1

#include "lua_objs.h"

     2

#include "lua_irc.h"

     3

#include "log.h"

     4

     5

#include <stdlib.h>

     6

#include <string.h>

     7

     8

void lua_obj_create_type (lua_State *L, const char *name, const struct luaL_Reg methods[])

     9

{

    10

    luaL_newmetatable(L, name);

    11

    12

    // set the metatable __index to itself

    13

    lua_pushvalue(L, -1);

    14

    lua_setfield(L, -1, "__index");

    15

    16

    // register the methods to the metatable

    17

    luaL_register(L, NULL, methods);

    18

}

    19

    20

void* lua_obj_create_obj (lua_State *L, const char *name, size_t size)

    21

{

    22

    // create the new userdata on the stack

    23

    void *ud = lua_newuserdata(L, size);

    24

    25

    // get the type and set it

    26

    luaL_getmetatable(L, name);

    27

    lua_setmetatable(L, -2);

    28

    29

    // ok

    30

    return ud;

    31

}

    32

    33

void* lua_obj_create_global_type (lua_State *L, const char *type_name, const struct luaL_Reg methods[], const char *global_name, size_t size)

    34

{

    35

    // allocate the global object

    36

    void *obj = lua_newuserdata(L, size);

    37

    38

    // create the type metatable

    39

    lua_obj_create_type(L, type_name, methods);

    40

    41

    // set the userdata's metatable

    42

    lua_setmetatable(L, -2);

    43

    44

    // store it as a global

    45

    lua_setglobal(L, global_name);

    46

    47

    // ok

    48

    return obj;

    49

}

    50

    51

void* lua_obj_get_obj (lua_State *L, const char *func, const char *name)

    52

{

    53

    void *ud;

    54

    55

    // validate the userdata arg

    56

    if ((ud = luaL_checkudata(L, 1, name)) == NULL) {

    57

        luaL_error(L, "bad type argument to %s: `%s` expected", func, name);

    58

    59

        // XXX: needs a __noreturn__ attribute

    60

        return NULL;

    61

    62

    } else {

    63

        // ok

    64

        return ud;

    65

    66

    }

    67

}

    68

    69

/**

    70

 * Wrapper for module

    71

 */

    72

struct lua_module {

    73

    struct module *module;

    74

};

    75

    76

/**

    77

 * Create a lua_module userdata from the given module and push it onto the stack, returning 1.

    78

 *

    79

 * The given module should be a reference of its own right.

    80

 */

    81

static int lua_module_create (lua_State *L, struct module *module)

    82

{

    83

    // create the new obj

    84

    struct lua_module *lua_module = lua_obj_create_obj(L, "spbot.module", sizeof(*lua_module));

    85

    86

    // initialize

    87

    lua_module->module = module;

    88

    89

    // ok

    90

    return 1;

    91

}

    92

    93

/**

    94

 * module_put() our module reference

    95

 */

    96

static int lua_module__gc (lua_State *L)

    97

{

    98

    struct lua_module *lua_module = lua_obj_get_obj(L, __func__, "spbot.module");

    99

   100

    // put it

   101

    module_put(lua_module->module);

   102

   103

    return 0;

   104

}

   105

   106

/**

   107

 * Parse and apply the given config option value as a raw value to the given module's option

   108

 */

   109

static int _lua_module_conf_raw_str (lua_State *L, struct lua_module *lua_module, struct nexus *nexus, 

   110

        const struct config_option *option, const char *conf_value)

   111

{

   112

    struct config_value value;

   113

    struct error_info err;

   114

   115

    // mutable version of the conf_value

   116

    char conf_value_buf[strlen(conf_value) + 1];

   117

    strcpy(conf_value_buf, conf_value);

   118

   119

    // parse it as a raw value

   120

    if (config_parse(option, nexus, &value, conf_value_buf, &err))

   121

        return luaL_error(L, "config_parse: %s/%s: %s", option->name, conf_value_buf, error_msg(&err));

   122

   123

    // apply it while conf_value_buf is still in scope

   124

    if (module_conf(lua_module->module, option, &value, &err))

   125

        return luaL_error(L, "module_conf: %s/%s: %s", module_name(lua_module->module), option->name, error_msg(&err));

   126

   127

    // ok

   128

    return 0;

   129

}

   130

   131

static int lua_module_conf (lua_State *L)

   132

{

   133

    struct lua_module *lua_module = lua_obj_get_obj(L, __func__, "spbot.module");

   134

    const struct config_option *option;

   139

    struct error_info err;

   140

   141

    // XXX: come up with some better way...

   142

    struct nexus *nexus = lua_module->module->modules->nexus;

   143

   144

    // the config name

   145

    const char *conf_name = luaL_checkstring(L, 2);

   146

   147

    // look it up

   148

    if ((option = module_conf_lookup(lua_module->module, conf_name, &err)) == NULL)

   149

        return luaL_error(L, "module_conf_lookup: %s/%s: %s", module_name(lua_module->module), conf_name, error_msg(&err));

   150

   151

    // the config value

   152

    switch (lua_type(L, 3)) {

   153

        case LUA_TSTRING:

   154

            // parse+apply it as a raw string

   155

            return _lua_module_conf_raw_str(L, lua_module, nexus, option, lua_tostring(L, 3));

   156

   157

        case LUA_TUSERDATA:

   158

            // some kind of userdata, use its metatable to figure out what type it is

   159

            if (!lua_getmetatable(L, 3))

   160

                return luaL_error(L, "config value is userdata without metatable");

   161

   162

            // get the target metatable

   163

            lua_getfield(L, LUA_REGISTRYINDEX, "evirc.chan");

   164

   165

            // is it a chan?

   166

            if (!lua_rawequal(L, -1, -2))

   167

                return luaL_error(L, "config value is userdata of unknown type");

   168

   169

            // pop the metatables

   170

            lua_pop(L, 2);

   171

   172

            // get the irc_chan

   173

            struct lua_chan *lua_chan = lua_touserdata(L, 3);

   174

   175

            // build the value

   178

   179

            break;

   180

   181

        default:

   182

            return luaL_error(L, "config value is of unknown lua type '%s'", lua_typename(L, 3));

   183

   184

    }

   185

   186

    // apply it

   188

        return luaL_error(L, "module_conf: %s/%s: %s", module_name(lua_module->module), option->name, error_msg(&err));

   189

   190

    // ok

   191

    return 0;

   192

}

   193

   194

static int lua_module_unload (lua_State *L)

   195

{

   196

    struct lua_module *lua_module = lua_obj_get_obj(L, __func__, "spbot.module");

   197

    struct error_info err;

   198

   199

    // just unload it

   200

    if ((ERROR_CODE(&err) = module_unload(lua_module->module)))

   201

        return luaL_error(L, "module_unload: %s: %s", module_name(lua_module->module), error_msg(&err));

   202

   203

    // ok

   204

    return 0;

   205

}

   206

   207

static const struct luaL_Reg lua_module_methods[] = {

   208

    {   "__gc",         &lua_module__gc             },

   209

    {   "conf",         &lua_module_conf            },

   210

    {   "unload",       &lua_module_unload          },

   211

    {   NULL,           NULL                        }

   212

};

   213

   214

/**

   215

 * Initialize the lua_module object type

   216

 */

   217

static void lua_module_init (lua_State *L)

   218

{

   219

    lua_obj_create_type(L, "spbot.module", lua_module_methods);

   220

}

   221

   222

/**

   223

 * Wrapper for modules

   224

 */

   225

struct lua_modules {

   226

    struct modules *modules;

   227

   228

    // strdup'd path for module_path

   229

    // XXX: remove when gc'd

   230

    char *path;

   231

};

   232

   233

static int lua_modules__gc (lua_State *L)

   234

{

   235

    struct lua_modules *lua_modules = lua_obj_get_obj(L, __func__, "spbot.modules");

   236

   237

    // remove the modules path if it was set by us

   238

    if (lua_modules->path && modules_path(lua_modules->modules, NULL) == lua_modules->path)

   239

        modules_path(lua_modules->modules, "");

   240

   241

    // release any strdup'd path

   242

    free(lua_modules->path);

   243

   244

    // ok

   245

    return 0;

   246

}

   247

   248

static int lua_modules_path (lua_State *L)

   249

{

   250

    struct lua_modules *lua_modules = lua_obj_get_obj(L, __func__, "spbot.modules");

   251

    char *path = NULL;

   252

    const char *old_path;

   253

   254

    if (!lua_isnoneornil(L, 2)) {

   255

        // the new path

   256

        if ((path = strdup(luaL_checkstring(L, 2))) == NULL)

   257

            return luaL_error(L, "strdup");

   258

    }

   259

   260

    // set or get

   261

    old_path = modules_path(lua_modules->modules, path);

   262

   263

    // return the old path

   264

    if (old_path)

   265

        lua_pushstring(L, old_path);

   266

    else

   267

        lua_pushnil(L);

   268

   269

    if (path) {

   270

        // replace the old path

   271

        free(lua_modules->path); 

   272

        lua_modules->path = path;

   273

    }

   274

   275

    // ok

   276

    return 1;

   277

}

   278

   279

static int lua_modules_load (lua_State *L)

   280

{

   281

    struct lua_modules *lua_modules = lua_obj_get_obj(L, __func__, "spbot.modules");

   282

    struct module *module;

   283

    struct module_info info;

   284

    struct error_info err;

   285

   286

    // the module name/path

   287

    info.name = luaL_checkstring(L, 2);

   288

    info.path = lua_isnoneornil(L, 3) ? NULL : luaL_checkstring(L, 3);

   289

   290

    // load and get a new reference

   291

    if (module_load(lua_modules->modules, &module, &info, &err))

   292

        return luaL_error(L, "module_load: %s/%s: %s", info.name, info.path, error_msg(&err));

   293

   294

    // wrap

   295

    return lua_module_create(L, module);

   296

}

   297

   298

static int lua_modules_module (lua_State *L)

   299

{

   300

    struct lua_modules *lua_modules = lua_obj_get_obj(L, __func__, "spbot.modules");

   301

    struct module *module;

   302

   303

    // the module name

   304

    const char *name = luaL_checkstring(L, 2);

   305

   306

    // look it up, as a new reference

   307

    if ((module = module_get(lua_modules->modules, name)) == NULL)

   308

        return luaL_error(L, "module_get: %s: no such module", name);

   309

   310

    // wrap

   311

    return lua_module_create(L, module);

   312

}

   313

   314

static const struct luaL_Reg lua_modules_methods[] = {

   315

    {   "__gc",         &lua_modules__gc            },

   316

    {   "path",         &lua_modules_path           },

   317

    {   "load",         &lua_modules_load           },

   318

    {   "module",       &lua_modules_module         },

   319

    {   NULL,           NULL                        }

   320

};

   321

   322

/**

   323

 * Initialize the spbot.modules type for lua_modules, and registers an instance bound to the given modules list at

   324

 * 'modules'.

   325

 */

   326

static void lua_modules_init (lua_State *L, struct modules *modules)

   327

{

   328

    // allocate the global "modules" object

   329

    struct lua_modules *lua_modules = lua_obj_create_global_type(L, "spbot.modules", lua_modules_methods, "modules", sizeof(*lua_modules));

   330

   331

    // initialize it

   332

    lua_modules->modules = modules;

   333

}

   334

   335

/**

   336

 * Wrapper for nexus

   337

 */

   338

struct lua_nexus {

   339

    struct nexus *nexus;

   340

};

   341

   342

static int lua_nexus_shutdown (lua_State *L)

   343

{

   344

    struct lua_nexus *lua_nexus = lua_obj_get_obj(L, __func__, "spbot.nexus");

   345

   346

    // just shut it down

   347

    nexus_shutdown(lua_nexus->nexus);

   348

   349

    return 0;

   350

}

   351

   352

static int lua_nexus_load_config (lua_State *L)

   353

{

   354

    struct lua_nexus *lua_nexus = lua_obj_get_obj(L, __func__, "spbot.nexus");

   355

    struct error_info err;

   356

   357

    const char *path = luaL_checkstring(L, 2);

   358

   359

    // just load it

   360

    if (nexus_load_config(lua_nexus->nexus, path, &err))

   361

        return luaL_error(L, "nexus_load_config(%s): %s", path, error_msg(&err));

   362

   363

    return 0;

   364

}

   365

   366

static const struct luaL_Reg lua_nexus_methods[] = {

   367

    {   "shutdown",     &lua_nexus_shutdown         },

   368

    {   "load_config",  &lua_nexus_load_config      },

   369

    {   NULL,           NULL                        }

   370

};

   371

   372

/**

   373

 * Initialize the spbot.nexus type for lua_nexus, and registers an instance bound to the given nexus list at

   374

 * 'nexus'.

   375

 */

   376

static void lua_nexus_init (lua_State *L, struct nexus *nexus)

   377

{

   378

    // allocate the global "nexus" object

   379

    struct lua_nexus *lua_nexus = lua_obj_create_global_type(L, "spbot.nexus", lua_nexus_methods, "nexus", sizeof(*lua_nexus));

   380

   381

    // initialize it

   382

    lua_nexus->nexus = nexus;

   383

}

   384

   385

/**

   386

 * Global functions

   387

 */

   388

static int lua_log_level (lua_State *L)

   389

{

   390

    // log level as a string

   391

    enum log_level new_level = luaL_checkoption(L, 1, NULL, log_level_names);

   392

   393

    // set it

   394

    set_log_level(new_level);

   395

   396

    // ok

   397

    return 0;

   398

}

   399

   400

static int lua_log (lua_State *L)

   401

{

   402

    // log level as a string

   403

    enum log_level level = luaL_checkoption(L, 1, NULL, log_level_names);

   404

   405

    // log message

   406

    const char *msg = luaL_checkstring(L, 2);

   407

   408

    // log it

   409

    log_msg(level, "lua", "%s", msg);

   410

   411

    // ok

   412

    return 0;

   413

}

   414

   415

static const struct luaL_Reg lua_global_functions[] = {

   416

    {   "log_level",    &lua_log_level              },

   417

    {   "log",          &lua_log                    },

   418

    {   NULL,           NULL                        }

   419

};

   420

   421

static void lua_global_init (lua_State *L)

   422

{

   423

    const struct luaL_Reg *reg;

   424

   425

    for (reg = lua_global_functions; reg->name && reg->func; reg++) {

   426

        // put the function on the stack

   427

        lua_pushcfunction(L, reg->func);

   428

   429

        // set the global

   430

        lua_setglobal(L, reg->name);

   431

    }

   432

}

   433

   434

void lua_objs_init (struct nexus_lua *lua)

   435

{

   436

    // init the various bits

   437

    lua_global_init(lua->st);

   438

    lua_nexus_init(lua->st, lua->nexus);

   439

    lua_modules_init(lua->st, lua->nexus->modules);

   440

    lua_module_init(lua->st);

   441

}

   442