1

#include "lua_func.h"

     2

#include "error.h"

     3

     4

#include <lua5.1/lauxlib.h>

     5

     6

/**

     7

 * Pushes onto the stack the value at t[i]

     8

 */

     9

static void lua_getindex (lua_State *L, int t, int i)

    10

{

    11

    lua_pushinteger(L, i);

    12

    lua_gettable(L, t);

    13

}

    14

    15

/**

    16

 * Pushes onto the stack either:

    17

 *  * the value at t[name]

    18

 *  * the value at t[index]

    19

 *

    20

 *  Returns the new index, or 0, if neither could be found

    21

 */

    22

static int lua_arg_lookup (lua_State *L, int t, const char *name, int index)

    23

{

    24

    // try name

    25

    lua_getfield(L, t, name);

    26

    27

    if (!lua_isnil(L, -1))

    28

        return lua_gettop(L);

    29

    else

    30

        lua_pop(L, 1);

    31

    32

    // try index

    33

    lua_getindex(L, t, index);

    34

    35

    if (!lua_isnil(L, -1))

    36

        return lua_gettop(L);

    37

    38

    else

    39

        lua_pop(L, 1);

    40

    41

    // not found

    42

    return 0;

    43

}

    44

    45

static const char *_lua_arg_string (lua_State *L, int index, const char *name, const char *def)

    46

{

    47

    const char *value;

    48

    49

    // use default?

    50

    if (lua_isnoneornil(L, index) && def != (const char *) LUA_ARG_REQUIRED)

    51

        return def;

    52

    53

    // value given?

    54

    if ((value = lua_tostring(L, index)))

    55

        return value;

    56

    57

    // error

    58

    luaL_error(L, "missing value for required string argument <%d:%s>", index, name); return NULL;

    59

}

    60

    61

static bool _lua_arg_bool (lua_State *L, int index, const char *name, int def)

    62

{

    63

    (void) name;

    64

    65

    // use default?

    66

    if (lua_isnoneornil(L, index) && def != LUA_ARG_REQUIRED)

    67

        return def;

    68

    69

    // value given

    70

    return lua_toboolean(L, index);

    71

}

    72

    73

static long _lua_arg_int (lua_State *L, int index, const char *name, long def)

    74

{

    75

    (void) name;

    76

    77

    // use default?

    78

    if (lua_isnoneornil(L, index) && def != LUA_ARG_REQUIRED)

    79

        return def;

    80

    81

    // conver to integer

    82

    // XXX: check compatibility?

    83

    return lua_tointeger(L, index);

    84

}

    85

    86

static void * _lua_arg_obj (lua_State *L, int index, const struct lua_type *type, bool optional)

    87

{

    88

    // not given?

    89

    if (!lua_isnoneornil(L, index))

    90

        return lua_type_get(L, type, index);

    91

    92

    if (optional)

    93

        return NULL;

    94

    95

    luaL_error(L, "missing value for required object argument <%d:%s>", index, type->name);

    96

    return NULL;

    97

}

    98

    99

/**

   100

 * Look up the arg index to use for the given index/name.

   101

 *

   102

 * If no value is found for the corresponding index, returns zero.

   103

 */

   104

static int lua_arg_index (lua_State *L, int nargs, int index, const char *name)

   105

{

   106

    // lookup from table?

   107

    if (nargs == 2 && lua_istable(L, 2) && name) {

   108

        // push the value from the named field onto the stack

   109

        lua_getfield(L, 2, name);

   110

   111

        // no named field?

   112

        if (lua_isnil(L, -1)) {

   113

            lua_pop(L, 1);

   114

   115

            lua_getindex(L, 2, index - 1);

   116

        }

   117

   118

        // no index field?

   119

        if (lua_isnil(L, -1)) {

   120

            lua_pop(L, 1);

   121

   122

            return 0;

   123

        }

   124

   125

        // found either a named or indexed arg

   126

        return lua_gettop(L);

   127

   128

    } else if (index <= nargs) {

   129

        // use the same index

   130

        return index;

   131

   132

    } else {

   133

        // no index

   134

        return 0;

   135

    }

   136

}

   137

   138

const char *lua_arg_string (lua_State *L, int nargs, int index, const char *name, const char *def)

   139

{

   140

    return _lua_arg_string(L, lua_arg_index(L, nargs, index, name), name, def);

   141

}

   142

   143

bool lua_arg_bool (lua_State *L, int nargs, int index, const char *name, int def)

   144

{

   145

    return _lua_arg_bool(L, lua_arg_index(L, nargs, index, name), name, def);    

   146

}

   147

   148

void* lua_arg_obj (lua_State *L, int nargs, int index, const struct lua_type *type, bool optional)

   149

{

   150

    return _lua_arg_obj(L, lua_arg_index(L, nargs, index, NULL), type, optional);

   151

}

   152

   153

long lua_arg_int (lua_State *L, int nargs, int index, const char *name, long def)

   154

{

   155

    return _lua_arg_int(L, lua_arg_index(L, nargs, index, name), name, def);

   156

}

   157

   158

void lua_args_parse (lua_State *L, const struct lua_func *func, void **obj_ptr, ...)

   159

{

   160

    int argidx = 1, argtbl = 0, idx;

   161

    const struct lua_func_arg *arg;

   162

    va_list vargs;

   163

   164

    // first, the obj argument

   165

    if (func->type)

   166

        *obj_ptr = lua_type_get(L, func->type, argidx++);

   167

   168

    // were we given a table of arguments?

   169

    if (lua_istable(L, argidx))

   170

        argtbl = argidx++;

   171

   172

    // parse the args

   173

    va_start(vargs, obj_ptr);

   174

   175

    for (arg = func->args, idx = 1; arg->name && arg->type; arg++, idx++) {

   176

        int index;

   177

   178

        // map index

   179

        if (!argtbl)

   180

            // direct

   181

            index = argidx++;

   182

   183

        else

   184

            // lookup from table

   185

            index = lua_arg_lookup(L, argtbl, arg->name, idx);

   186

   187

        // apply

   188

        switch (arg->type) {

   189

            case LUA_ARG_STRING:

   190

                *va_arg(vargs, const char **) = _lua_arg_string(L, index, arg->name, arg->def.string);

   191

                break;

   192

   193

            case LUA_ARG_BOOL:

   194

                *va_arg(vargs, bool *) = _lua_arg_bool(L, index, arg->name, arg->def.boolean);

   195

                break;

   196

   197

            case LUA_ARG_INT:

   198

                *va_arg(vargs, long *) = _lua_arg_int(L, index, arg->name, arg->def.integer);

   199

                break;

   200

   201

            default:

   202

                NOT_REACHED();

   203

        };

   204

    }

   205

   206

    va_end(vargs);

   207

}