1

#include "lua_objs.h"

     2

     3

#include <lua5.1/lua.h>

     4

#include <lua5.1/lualib.h>

     5

#include <lua5.1/lauxlib.h>

     6

     7

/**

     8

 * Convenience function to register a new metatable for a type, this leaves the metatable on the stack

     9

 */

    10

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

    11

{

    12

    luaL_newmetatable(L, name);

    13

    14

    // set the metatable __index to itself

    15

    lua_pushvalue(L, -1);

    16

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

    17

    18

    // register the methods to the metatable

    19

    luaL_register(L, NULL, methods);

    20

}

    21

    22

/**

    23

 * Convenience function to create a new userdata with the given type metatable name, return the pointer, and keep it

    24

 * on the stack

    25

 */

    26

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

    27

{

    28

    // create the new userdata on the stack

    29

    void *ud = lua_newuserdata(L, size);

    30

    31

    // get the type and set it

    32

    luaL_getmetatable(L, name);

    33

    lua_setmetatable(L, -2);

    34

    35

    // ok

    36

    return ud;

    37

}

    38

    39

/**

    40

 * Convenience function to get a userdata with the given type metatable name as the first argument for a function

    41

 */

    42

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

    43

{

    44

    void *ud;

    45

    46

    // validate the userdata arg

    47

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

    48

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

    49

    50

    } else {

    51

        // ok

    52

        return ud;

    53

    54

    }

    55

}

    56

    57

/**

    58

 * Our lua wrapper for irc_chan

    59

 */

    60

struct lua_chan {

    61

    struct irc_chan *chan;

    62

};

    63

    64

/**

    65

 * Create a lua_chan userdata from the given irc_chan and leave it on the stack, returning 1

    66

 */

    67

static int lua_chan_create (lua_State *L, struct irc_chan *chan)

    68

{

    69

    // create the new obj

    70

    struct lua_chan *lua_chan = lua_obj_create_obj(L, "evirc.chan", sizeof(*lua_chan));

    71

    72

    // initialize

    73

    lua_chan->chan = chan;

    74

    75

    // ok

    76

    return 1;

    77

}

    78

    79

/**

    80

 * Return the channel name as a lua string

    81

 */

    82

static int lua_chan_tostring (lua_State *L)

    83

{

    84

    struct lua_chan *lua_chan = lua_obj_get_obj(L, __func__, "evirc.chan");

    85

    86

    lua_pushfstring(L, "<irc_chan %s>", irc_chan_name(lua_chan->chan));

    87

    88

    return 1;

    89

}

    90

   110

   111

static const struct luaL_Reg lua_chan_methods[] = {

   112

    {   "__tostring",       &lua_chan_tostring  },

   114

    {   NULL,               NULL                },

   115

};

   116

   117

/**

   118

 * Initialize the lua_chan object type

   119

 */

   120

static void lua_chan_init (lua_State *L)

   121

{

   122

    lua_obj_create_type(L, "evirc.chan", lua_chan_methods);

   123

}

   124

   125

/**

   126

 * Our lua wrapper for irc_net

   127

 */

   128

struct lua_net {

   129

    struct irc_net *net;

   130

};

   131

   132

/**

   133

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

   134

 */

   135

static int lua_net_create (lua_State *L, struct irc_net *net)

   136

{

   137

    // create the new obj

   138

    struct lua_net *lua_net = lua_obj_create_obj(L, "evirc.net", sizeof(*lua_net));

   139

   140

    // initialize

   141

    lua_net->net = net;

   142

   143

    // ok

   144

    return 1;

   145

}

   146

   147

/**

   148

 * Return the network name as a lua string

   149

 */

   150

static int lua_net_tostring (lua_State *L)

   151

{

   152

    struct lua_net *lua_net = lua_obj_get_obj(L, __func__, "evirc.net");

   153

   154

    lua_pushfstring(L, "<irc_net %s>", irc_net_name(lua_net->net));

   155

   156

    return 1;

   157

}

   158

   159

/**

   160

 * Join a new channel, returning the lua_chan

   161

 */

   162

static int lua_net_join (lua_State *L)

   163

{

   164

    struct lua_net *lua_net = lua_obj_get_obj(L, __func__, "evirc.net");

   165

    struct irc_chan_info chan_info;

   166

    struct irc_chan *chan;

   167

    struct error_info err;

   168

   169

    // the channel name

   170

    chan_info.channel = luaL_checkstring(L, 2);

   171

   172

    // add it

   173

    if (irc_net_add_chan(lua_net->net, &chan, &chan_info, &err))

   174

        return luaL_error(L, "irc_net_add_chan: %s: %s", chan_info.channel, error_msg(&err));

   175

   176

    // return it

   177

    return lua_chan_create(L, chan);    

   178

}

   179

   180

/**

   181

 * Look up a channel by name, returning the lua_chan

   182

 */

   183

static int lua_net_get_chan (lua_State *L)

   184

{

   185

    struct lua_net *lua_net = lua_obj_get_obj(L, __func__, "evirc.net");

   186

    struct irc_chan *chan;

   187

   188

    // the channel name

   189

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

   190

   191

    // lookup the irc_chan

   192

    if ((chan = irc_net_get_chan(lua_net->net, channel)) == NULL)

   193

        return luaL_error(L, "irc_net_get_chan: no such channel: %s", channel);

   194

   195

    // wrap it

   196

    return lua_chan_create(L, chan);

   197

}

   198

   199

static const struct luaL_Reg lua_net_methods[] = {

   200

    {   "__tostring",   &lua_net_tostring   },

   201

    {   "join",         &lua_net_join       },

   202

    {   "channel",      &lua_net_get_chan   },

   203

    {   NULL,           NULL                }

   204

};

   205

   206

/**

   207

 * Initialize the lua_net object type

   208

 */

   209

static void lua_net_init (lua_State *L)

   210

{

   211

    lua_obj_create_type(L, "evirc.net", lua_net_methods);

   212

}

   213

   214

/**

   215

 * Wrapper for irc_client

   216

 */

   217

struct lua_client {

   218

    struct irc_client *client;

   219

};

   220

   221

static int lua_client_quit (lua_State *L)

   222

{

   223

    struct lua_client *lua_client = lua_obj_get_obj(L, __func__, "evirc.client");

   224

    err_t err;

   225

   226

    // the message

   227

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

   228

   229

    // execute

   230

    if ((err = irc_client_quit(lua_client->client, message)))

   231

        return luaL_error(L, "irc_client_quit: %s", error_name(err));

   232

   233

    // ok

   234

    return 0;

   235

}

   236

   237

static int lua_client_get_network (lua_State *L)

   238

{

   239

    struct lua_client *lua_client = lua_obj_get_obj(L, __func__, "evirc.client");

   240

    struct irc_net *net;

   241

   242

    // the network name

   243

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

   244

   245

    // lookup the irc_net

   246

    if ((net = irc_client_get_net(lua_client->client, network)) == NULL)

   247

        return luaL_error(L, "irc_client_get_net: no such network: %s", network);

   248

   249

    // wrap it

   250

    return lua_net_create(L, net);

   251

}

   252

   253

static const struct luaL_Reg lua_client_methods[] = {

   254

    {   "quit",         &lua_client_quit        },

   255

    {   "network",      &lua_client_get_network },

   256

    {   NULL,           NULL                    }

   257

};

   258

   259

/**

   260

 * Initializes a lua_irc_client wrapper for the given client in the give lua state. This registers a set of globals for

   261

 * 'client' and 'networks'.

   262

 */

   263

static void lua_client_init (lua_State *L, struct irc_client *client)

   264

{

   265

    // allocate the global "client" object

   266

    // XXX: mem errors?

   267

    struct lua_client *lua_client = lua_newuserdata(L, sizeof(*lua_client));

   268

   269

    // create the type metatable

   270

    lua_obj_create_type(L, "evirc.client", lua_client_methods);

   271

   272

    // set the client userdata's metatable

   273

    lua_setmetatable(L, -2);

   274

   275

    // initialize it

   276

    lua_client->client = client;

   277

   278

    // store it as a global

   279

    lua_setglobal(L, "client");

   280

}

   281

   282

err_t lua_objs_init (lua_State *L, struct nexus *nexus)

   283

{

   284

    // init the various bits

   285

    lua_client_init(L, nexus->client);

   286

    lua_net_init(L);

   287

    lua_chan_init(L);

   288

   289

    return SUCCESS;

   290

}