fiddlerwoaroof/crawl - Change P3DOLIF47OAWT6VFRTASS3Q3AXUI4SVPUHT4WF7PVBKVNVYWXF5QC

Move remaining libraries from clua.cc.

That's l_file.cc, l_food.cc, l_global.cc.

Created by Robert Vollmert on October 20, 2009

P3DOLIF47OAWT6VFRTASS3Q3AXUI4SVPUHT4WF7PVBKVNVYWXF5QC

Dependencies

In channels

main

Change contents

Insertion in crawl-ref/source/makefile.obj at line 53 [6.79]
[5.2841]
[4.2832]
```
l_food.o \
l_global.o \
```
Insertion in crawl-ref/source/l_libs.h at line 16 [5.2907]
[7.3235]
[4.2875]
```
void cluaopen_file(lua_State *ls);
void cluaopen_food(lua_State *ls);
```
Insertion in crawl-ref/source/l_libs.h at line 22 [5.2907]
[8.10713]
[7.3236]
```
void cluaopen_globals(lua_State *ls);
```
Deletion in crawl-ref/source/l_libs.h at line 38 [5.2907]
B:BD[7.3650] → [7.3650:3692]
```
extern const struct luaL_reg file_dlib[];
```
Insertion in crawl-ref/source/l_libs.h at line 50 [5.2907]
[7.3859]
[2.5350]
```
void dluaopen_file(lua_State *ls);
```

File addition: l_global.cc (----------)

[9.24]

#include "AppHdr.h"
#include "clua.h"
#include "l_libs.h"
//////////////////////////////////////////////////////////////////////
// Miscellaneous globals
#define PATTERN_FLUSH_CEILING 100
typedef std::map<std::string, text_pattern> pattern_map;
static pattern_map pattern_cache;
static text_pattern &get_text_pattern(const std::string &s, bool checkcase)
{
    pattern_map::iterator i = pattern_cache.find(s);
    if (i != pattern_cache.end())
        return i->second;
    if (pattern_cache.size() > PATTERN_FLUSH_CEILING)
        pattern_cache.clear();
    pattern_cache[s] = text_pattern(s, !checkcase);
    return (pattern_cache[s]);
}
static int lua_pmatch(lua_State *ls)
{
    const char *pattern = luaL_checkstring(ls, 1);
    if (!pattern)
        return (0);
    const char *text = luaL_checkstring(ls, 2);
    if (!text)
        return (0);
    bool checkcase = true;
    if (lua_isboolean(ls, 3))
        checkcase = lua_toboolean(ls, 3);
    text_pattern &tp = get_text_pattern(pattern, checkcase);
    lua_pushboolean( ls, tp.matches(text) );
    return (1);
}
void cluaopen_globals(lua_State *ls)
{
    lua_pushcfunction(ls, lua_pmatch);
    lua_setglobal(ls, "pmatch");
}

File addition: l_food.cc (----------)

[9.24]

#include "AppHdr.h"
#include "clua.h"
#include "l_libs.h"
#include "food.h"
#include "invent.h"
#include "items.h"
#include "player.h"
/////////////////////////////////////////////////////////////////////
// Food information.
static int food_do_eat(lua_State *ls)
{
    bool eaten = false;
    if (!you.turn_is_over)
        eaten = eat_food(-1);
    lua_pushboolean(ls, eaten);
    return (1);
}
static int food_prompt_eat_chunks(lua_State *ls)
{
    int eaten = 0;
    if (!you.turn_is_over)
        eaten = prompt_eat_chunks();
    lua_pushboolean(ls, (eaten != 0));
    return (1);
}
static int food_prompt_floor(lua_State *ls)
{
    int eaten = 0;
    if (!you.turn_is_over)
    {
        eaten = eat_from_floor();
        if (eaten == 1)
            burden_change();
    }
    lua_pushboolean(ls, (eaten != 0));
    return (1);
}
static int food_prompt_inventory(lua_State *ls)
{
    bool eaten = false;
    if (!you.turn_is_over)
        eaten = eat_from_inventory();
    lua_pushboolean(ls, eaten);
    return (1);
}
static int food_prompt_inventory_menu(lua_State *ls)
{
    bool eaten = false;
    if (!you.turn_is_over)
        eaten = prompt_eat_inventory_item();
    lua_pushboolean(ls, eaten);
    return (1);
}
static int food_can_eat(lua_State *ls)
{
    LUA_ITEM(item, 1);
    bool hungercheck = true;
    if (lua_isboolean(ls, 2))
        hungercheck = lua_toboolean(ls, 2);
    bool edible = item && can_ingest(item->base_type,
                                     item->sub_type,
                                     true,
                                     true,
                                     hungercheck);
    lua_pushboolean(ls, edible);
    return (1);
}
static bool eat_item(const item_def &item)
{
    if (in_inventory(item))
    {
        eat_inventory_item(item.link);
        return (true);
    }
    else
    {
        int ilink = item_on_floor(item, you.pos());
        if (ilink != NON_ITEM)
        {
            eat_floor_item(ilink);
            return (true);
        }
        return (false);
    }
}
static int food_eat(lua_State *ls)
{
    LUA_ITEM(item, 1);
    bool eaten = false;
    if (!you.turn_is_over)
    {
        // When we get down to eating, we don't care if the eating is courtesy
        // an un-ided amulet of the gourmand.
        bool edible = item && can_ingest(item->base_type,
                                         item->sub_type,
                                         false,
                                         false);
        if (edible)
            eaten = eat_item(*item);
    }
    lua_pushboolean(ls, eaten);
    return (1);
}
static int food_rotting(lua_State *ls)
{
    LUA_ITEM(item, 1);
    bool rotting = false;
    if (item && item->base_type == OBJ_FOOD && item->sub_type == FOOD_CHUNK)
        rotting = food_is_rotten(*item);
    lua_pushboolean(ls, rotting);
    return (1);
}
static int food_dangerous(lua_State *ls)
{
    LUA_ITEM(item, 1);
    bool dangerous = false;
    if (item)
    {
        dangerous = (is_poisonous(*item) || is_mutagenic(*item)
                     || causes_rot(*item) || is_forbidden_food(*item));
    }
    lua_pushboolean(ls, dangerous);
    return (1);
}
static int food_ischunk(lua_State *ls)
{
    LUA_ITEM(item, 1);
    lua_pushboolean(ls,
            item && item->base_type == OBJ_FOOD
                 && item->sub_type == FOOD_CHUNK);
    return (1);
}
static const struct luaL_reg food_lib[] =
{
    { "do_eat",            food_do_eat },
    { "prompt_eat_chunks", food_prompt_eat_chunks },
    { "prompt_floor",      food_prompt_floor },
    { "prompt_inventory",  food_prompt_inventory },
    { "prompt_inv_menu",   food_prompt_inventory_menu },
    { "can_eat",           food_can_eat },
    { "eat",               food_eat },
    { "rotting",           food_rotting },
    { "dangerous",         food_dangerous },
    { "ischunk",           food_ischunk },
    { NULL, NULL },
};
void cluaopen_food(lua_State *ls)
{
    luaL_openlib(ls, "food", food_lib, 0);
}

Insertion in crawl-ref/source/l_file.cc at line 3 [5.3210]
[5.3232]
[5.3232]
```
#include "clua.h"
```

Insertion in crawl-ref/source/l_file.cc at line 8 [5.3210]

[5.3289]


///////////////////////////////////////////////////////////
// User-accessible file operations
static const struct luaL_reg file_clib[] =
{
    { "write", CLua::file_write },
    { NULL, NULL },
};
void cluaopen_file(lua_State *ls)
{
    luaL_openlib(ls, "file", file_clib, 0);
}
///////////////////////////////////////////////////////////
// Non-user-accessible file operations

Replacement in crawl-ref/source/l_file.cc at line 147 [5.3210]
B:BD[5.6728] → [7.3861:3897]
```
const struct luaL_reg file_dlib[] =
```
[5.6728]
[5.6763]
```
static const struct luaL_reg file_dlib[] =
```

Insertion in crawl-ref/source/l_file.cc at line 158 [5.3210]

[5.7042]

void dluaopen_file(lua_State *ls)
{
    luaL_openlib(ls, "file", file_dlib, 0);
}

Insertion in crawl-ref/source/dlua.cc at line 310 [10.19392]
[7.19428]
[2.5552]
```
    dluaopen_file(dlua);
```
Deletion in crawl-ref/source/dlua.cc at line 322 [10.19392]
∅:D[7.19819] → [11.5048:5049]
B:BD[12.5132] → [11.5048:5049]
Deletion in crawl-ref/source/dlua.cc at line 323 [10.19392]
B:BD[7.19868] → [7.19868:19914]
```
    luaL_openlib(dlua, "file", file_dlib, 0);
```
Deletion in crawl-ref/source/clua.cc at line 593 [14.483969]
∅:D[13.19966] → [14.494782:494783]
B:BD[14.494782] → [14.494782:494783]
B:BD[13.20034] → [13.20034:20068]
B:BD[13.20103] → [13.20103:20137]
∅:D[15.17747] → [13.20212:20249]
B:BD[13.20212] → [13.20212:20249]
```
void luaopen_food(lua_State *ls);
void luaopen_file(lua_State *ls);
void luaopen_globals(lua_State *ls);
```
Replacement in crawl-ref/source/clua.cc at line 616 [14.483969]
∅:D[4.20001] → [13.20328:20354]
B:BD[13.20328] → [13.20328:20354]
```
    luaopen_food(_state);
```
[4.20001]
[7.20152]
```
    cluaopen_food(_state);
```
Replacement in crawl-ref/source/clua.cc at line 618 [14.483969]
∅:D[7.20180] → [13.20381:20407]
B:BD[13.20381] → [13.20381:20407]
```
    luaopen_file(_state);
```
[7.20180]
[3.7466]
```
    cluaopen_file(_state);
```
Replacement in crawl-ref/source/clua.cc at line 622 [14.483969]
B:BD[14.495233] → [13.20467:20496]
```
    luaopen_globals(_state);
```
[14.495233]
[14.495263]
```
    cluaopen_globals(_state);
```

Deletion in crawl-ref/source/clua.cc at line 717 [14.483969]

B:BD[16.10525] → [16.10525:10531]

∅:D[16.10531] → [14.498100:498173]

B:BD[14.498100] → [14.498100:498173]

B:BD[14.516124] → [17.20184:20205]

∅:D[17.20205] → [14.516258:516350]

B:BD[14.516258] → [14.516258:516350]

B:BD[14.516350] → [18.3991:4021]

∅:D[18.4021] → [14.516383:516434]

B:BD[14.516383] → [14.516383:516434]

B:BD[14.516434] → [17.20206:20303]

B:BD[17.20303] → [18.4022:4059]

∅:D[18.4059] → [17.20333:20392]

B:BD[17.20333] → [17.20333:20392]

∅:D[17.20392] → [14.516434:516480]

B:BD[14.516434] → [14.516434:516480]

B:BD[14.516480] → [19.1355:1441]

B:BD[19.1441] → [17.20393:20417]

∅:D[17.20417] → [19.1467:1541]

B:BD[19.1467] → [19.1467:1541]

∅:D[19.1541] → [14.516618:516738]

B:BD[14.516618] → [14.516618:516738]

B:BD[14.516738] → [17.20418:20658]

∅:D[17.20658] → [14.516783:517296]

B:BD[14.516783] → [14.516783:517296]

B:BD[14.517587] → [14.517587:517669]

B:BD[14.517669] → [17.20659:20698]

∅:D[17.20698] → [14.517764:517808]

B:BD[14.517764] → [14.517764:517808]

B:BD[14.517808] → [17.20699:20751]

∅:D[17.20751] → [14.517872:518531]

∅:D[20.102321] → [14.517872:518531]

B:BD[14.517872] → [14.517872:518531]

    }
}
/////////////////////////////////////////////////////////////////////
// Food information.
static int food_do_eat(lua_State *ls)
{
    bool eaten = false;
    if (!you.turn_is_over)
        eaten = eat_food(-1);
    lua_pushboolean(ls, eaten);
    return (1);
}
static int food_prompt_eat_chunks(lua_State *ls)
{
    int eaten = 0;
    if (!you.turn_is_over)
        eaten = prompt_eat_chunks();
    lua_pushboolean(ls, (eaten != 0));
    return (1);
}
static int food_prompt_floor(lua_State *ls)
{
    int eaten = 0;
    if (!you.turn_is_over)
    {
        eaten = eat_from_floor();
        if (eaten == 1)
            burden_change();
    }
    lua_pushboolean(ls, (eaten != 0));
    return (1);
}
static int food_prompt_inventory(lua_State *ls)
{
    bool eaten = false;
    if (!you.turn_is_over)
        eaten = eat_from_inventory();
    lua_pushboolean(ls, eaten);
    return (1);
}
static int food_prompt_inventory_menu(lua_State *ls)
{
    bool eaten = false;
    if (!you.turn_is_over)
        eaten = prompt_eat_inventory_item();
    lua_pushboolean(ls, eaten);
    return (1);
}
static int food_can_eat(lua_State *ls)
{
    LUA_ITEM(item, 1);
    bool hungercheck = true;
    if (lua_isboolean(ls, 2))
        hungercheck = lua_toboolean(ls, 2);
    bool edible = item && can_ingest(item->base_type,
                                     item->sub_type,
                                     true,
                                     true,
                                     hungercheck);
    lua_pushboolean(ls, edible);
    return (1);
}
static bool eat_item(const item_def &item)
{
    if (in_inventory(item))
    {
        eat_inventory_item(item.link);
        return (true);
    }
    else
    {
        int ilink = item_on_floor(item, you.pos());
        if (ilink != NON_ITEM)
        {
            eat_floor_item(ilink);
            return (true);
        }
        return (false);
    }
}
static int food_eat(lua_State *ls)
{
    LUA_ITEM(item, 1);
    bool eaten = false;
    if (!you.turn_is_over)
    {
        // When we get down to eating, we don't care if the eating is courtesy
        // an un-ided amulet of the gourmand.
        bool edible = item && can_ingest(item->base_type,
                                         item->sub_type,
                                         false,
                                         false);
        if (edible)
            eaten = eat_item(*item);

Deletion in crawl-ref/source/clua.cc at line 718 [14.483969]
B:BD[14.518537] → [14.518537:518588]
B:BD[14.519494] → [14.519494:519558]
B:BD[14.519558] → [21.21625:21626]
∅:D[21.21626] → [14.519558:519661]
B:BD[14.519558] → [14.519558:519661]
B:BD[14.519667] → [22.7671:7712]
B:BD[22.7712] → [21.21627:21628]
∅:D[21.21628] → [14.519712:519762]
B:BD[14.519712] → [14.519712:519762]
```
    lua_pushboolean(ls, eaten);
    return (1);
}
static int food_rotting(lua_State *ls)
{
    LUA_ITEM(item, 1);
    bool rotting = false;
    if (item && item->base_type == OBJ_FOOD && item->sub_type == FOOD_CHUNK)
        rotting = food_is_rotten(*item);
    lua_pushboolean(ls, rotting);
    return (1);
```
Deletion in crawl-ref/source/clua.cc at line 720 [14.483969]
B:BD[14.519765] → [17.20752:20818]
```
static int food_dangerous(lua_State *ls)
{
    LUA_ITEM(item, 1);
```

Deletion in crawl-ref/source/clua.cc at line 721 [14.483969]

B:BD[17.20819] → [17.20819:21063]

    bool dangerous = false;
    if (item)
    {
        dangerous = (is_poisonous(*item) || is_mutagenic(*item)
                     || causes_rot(*item) || is_forbidden_food(*item));
    }
    lua_pushboolean(ls, dangerous);
    return (1);
}

Deletion in crawl-ref/source/clua.cc at line 722 [14.483969]

∅:D[17.21064] → [14.519765:519853]

B:BD[14.519765] → [14.519765:519853]

B:BD[14.519853] → [23.16254:16302]

∅:D[23.16302] → [14.519902:520016]

B:BD[14.519902] → [14.519902:520016]

B:BD[14.520016] → [17.21065:21530]

∅:D[24.6992] → [14.520307:520331]

∅:D[17.21530] → [14.520307:520331]

B:BD[14.520307] → [14.520307:520331]

B:BD[14.520331] → [13.20564:20597]

∅:D[13.20597] → [14.520365:520410]

B:BD[14.520365] → [14.520365:520410]

B:BD[14.522790] → [14.522790:522793]

B:BD[14.522884] → [23.16309:16310]

B:BD[14.528038] → [14.528038:528117]

B:BD[14.528118] → [14.528118:528222]

B:BD[14.528222] → [13.20633:20666]

∅:D[13.20666] → [14.528256:528304]

B:BD[14.528256] → [14.528256:528304]

B:BD[14.528568] → [14.528568:528569]

static int food_ischunk(lua_State *ls)
{
    LUA_ITEM(item, 1);
    lua_pushboolean(ls,
            item && item->base_type == OBJ_FOOD
                 && item->sub_type == FOOD_CHUNK);
    return (1);
}
static const struct luaL_reg food_lib[] =
{
    { "do_eat",            food_do_eat },
    { "prompt_eat_chunks", food_prompt_eat_chunks },
    { "prompt_floor",      food_prompt_floor },
    { "prompt_inventory",  food_prompt_inventory },
    { "prompt_inv_menu",   food_prompt_inventory_menu },
    { "can_eat",           food_can_eat },
    { "eat",               food_eat },
    { "rotting",           food_rotting },
    { "dangerous",         food_dangerous },
    { "ischunk",           food_ischunk },
    { NULL, NULL },
};
void luaopen_food(lua_State *ls)
{
    luaL_openlib(ls, "food", food_lib, 0);
}
///////////////////////////////////////////////////////////
// File operations
static const struct luaL_reg file_lib[] =
{
    { "write", CLua::file_write },
    { NULL, NULL },
};
void luaopen_file(lua_State *ls)
{
    luaL_openlib(ls, "file", file_lib, 0);
}

Deletion in crawl-ref/source/clua.cc at line 775 [14.483969]

∅:D[25.37548] → [13.20847:20850]

B:BD[13.20847] → [13.20847:20850]

B:BD[26.5936] → [26.5936:5937]

∅:D[15.20113] → [14.535302:535434]

B:BD[14.535302] → [14.535302:535434]

B:BD[14.535434] → [27.1042:1099]

∅:D[27.1099] → [14.535488:535853]

B:BD[14.535488] → [14.535488:535853]

B:BD[14.535853] → [27.1100:1131]

}
//////////////////////////////////////////////////////////////////////
// Miscellaneous globals
#define PATTERN_FLUSH_CEILING 100
typedef std::map<std::string, text_pattern> pattern_map;
static pattern_map pattern_cache;
static text_pattern &get_text_pattern(const std::string &s, bool checkcase)
{
    pattern_map::iterator i = pattern_cache.find(s);
    if (i != pattern_cache.end())
        return i->second;
    if (pattern_cache.size() > PATTERN_FLUSH_CEILING)
        pattern_cache.clear();
    pattern_cache[s] = text_pattern(s, !checkcase);
    return (pattern_cache[s]);

Deletion in crawl-ref/source/clua.cc at line 777 [14.483969]

B:BD[14.535885] → [14.535885:536013]

static int lua_pmatch(lua_State *ls)
{
    const char *pattern = luaL_checkstring(ls, 1);
    if (!pattern)
        return (0);

Deletion in crawl-ref/source/clua.cc at line 778 [14.483969]

B:BD[14.536014] → [14.536014:536097]

    const char *text = luaL_checkstring(ls, 2);
    if (!text)
        return (0);

Deletion in crawl-ref/source/clua.cc at line 779 [14.483969]

B:BD[14.536098] → [14.536098:536323]

B:BD[14.536323] → [13.20888:20924]

∅:D[13.20924] → [14.536360:536436]

B:BD[14.536360] → [14.536360:536436]

B:BD[14.536437] → [14.536437:536438]

    bool checkcase = true;
    if (lua_isboolean(ls, 3))
        checkcase = lua_toboolean(ls, 3);
    text_pattern &tp = get_text_pattern(pattern, checkcase);
    lua_pushboolean( ls, tp.matches(text) );
    return (1);
}
void luaopen_globals(lua_State *ls)
{
    lua_pushcfunction(ls, lua_pmatch);
    lua_setglobal(ls, "pmatch");
}

Move remaining libraries from clua.cc.

Dependencies

In channels

Change contents

Insertion in crawl-ref/source/makefile.obj at line 53 [6.79]

Insertion in crawl-ref/source/l_libs.h at line 16 [5.2907]

Insertion in crawl-ref/source/l_libs.h at line 22 [5.2907]

Deletion in crawl-ref/source/l_libs.h at line 38 [5.2907]

Insertion in crawl-ref/source/l_libs.h at line 50 [5.2907]

File addition: l_global.cc (----------)

File addition: l_food.cc (----------)

Insertion in crawl-ref/source/l_file.cc at line 3 [5.3210]

Insertion in crawl-ref/source/l_file.cc at line 8 [5.3210]

Replacement in crawl-ref/source/l_file.cc at line 147 [5.3210]

Insertion in crawl-ref/source/l_file.cc at line 158 [5.3210]

Insertion in crawl-ref/source/dlua.cc at line 310 [10.19392]

Deletion in crawl-ref/source/dlua.cc at line 322 [10.19392]

Deletion in crawl-ref/source/dlua.cc at line 323 [10.19392]

Deletion in crawl-ref/source/clua.cc at line 593 [14.483969]

Replacement in crawl-ref/source/clua.cc at line 616 [14.483969]

Replacement in crawl-ref/source/clua.cc at line 618 [14.483969]

Replacement in crawl-ref/source/clua.cc at line 622 [14.483969]