1

#include "lua_objs.h"

     2

     5

#include <lua5.1/lua.h>

     6

#include <lua5.1/lualib.h>

     7

#include <lua5.1/lauxlib.h>

     8

     9

/**

    10

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

    11

 */

    12

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

    13

{

    14

    luaL_newmetatable(L, name);

    15

    16

    // set the metatable __index to itself

    17

    lua_pushvalue(L, -1);

    18

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

    19

    20

    // register the methods to the metatable

    21

    luaL_register(L, NULL, methods);

    22

}

    23

    24

/**

    25

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

    26

 * on the stack

    27

 */

    28

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

    29

{

    30

    // create the new userdata on the stack

    31

    void *ud = lua_newuserdata(L, size);

    32

    33

    // get the type and set it

    34

    luaL_getmetatable(L, name);

    35

    lua_setmetatable(L, -2);

    36

    37

    // ok

    38

    return ud;

    39

}

    40

    41

/**

    42

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

    43

 */

    44

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

    45

{

    46

    void *ud;

    47

    48

    // validate the userdata arg

    49

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

    50

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

    51

    52

    } else {

    53

        // ok

    54

        return ud;

    55

    56

    }

    57

}

    58

    59

/**

    60

 * Our lua wrapper for irc_chan

    61

 */

    62

struct lua_chan {

    63

    struct irc_chan *chan;

    64

};

    65

    66

/**

    67

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

    68

 */

    69

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

    70

{

    71

    // create the new obj

    72

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

    73

    74

    // initialize

    75

    lua_chan->chan = chan;

    76

    77

    // ok

    78

    return 1;

    79

}

    80

    81

/**

    82

 * Return the channel name as a lua string

    83

 */

    84

static int lua_chan_tostring (lua_State *L)

    85

{

    86

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

    87

    88

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

    89

    90

    return 1;

    91

}

    92

    93

/**

    94

 * Send a PRIVMSG to the channel

    95

 */

    96

static int lua_chan_say (lua_State *L)

    97

{

    98

    err_t err;

    99

   100

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

   101

   102

    // the message

   103

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

   104

   105

    // send

   106

    if ((err = irc_chan_PRIVMSG(lua_chan->chan, message)))

   107

        return luaL_error(L, "irc_chan_PRIVMSG: '%s': %s", message, error_name(err));

   108

   109

    // ok

   110

    return 0;

   111

}

   112

   113

static const struct luaL_Reg lua_chan_methods[] = {

   114

    {   "__tostring",       &lua_chan_tostring  },

   115

    {   "say",              &lua_chan_say       },

   116

    {   NULL,               NULL                },

   117

};

   118

   119

/**

   120

 * Initialize the lua_chan object type

   121

 */

   122

static void lua_chan_init (lua_State *L)

   123

{

   124

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

   125

}

   126

   127

/**

   128

 * Our lua wrapper for irc_net

   129

 */

   130

struct lua_net {

   131

    struct irc_net *net;

   132

};

   133

   134

/**

   135

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

   136

 */

   137

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

   138

{

   139

    // create the new obj

   140

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

   141

   142

    // initialize

   143

    lua_net->net = net;

   144

   145

    // ok

   146

    return 1;

   147

}

   148

   149

/**

   150

 * Return the network name as a lua string

   151

 */

   152

static int lua_net_tostring (lua_State *L)

   153

{

   154

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

   155

   156

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

   157

   158

    return 1;

   159

}

   160

   161

/**

   162

 * Join a new channel, returning the lua_chan

   163

 */

   164

static int lua_net_join (lua_State *L)

   165

{

   166

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

   167

    struct irc_chan_info chan_info;

   168

    struct irc_chan *chan;

   169

    struct error_info err;

   170

   171

    // the channel name

   172

    chan_info.channel = luaL_checkstring(L, 2);

   173

   174

    // add it

   175

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

   176

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

   177

   178

    // return it

   179

    return lua_chan_create(L, chan);    

   180

}

   181

   182

/**

   183

 * Look up a channel by name, returning the lua_chan

   184

 */

   185

static int lua_net_get_chan (lua_State *L)

   186

{

   187

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

   188

    struct irc_chan *chan;

   189

   190

    // the channel name

   191

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

   192

   193

    // lookup the irc_chan

   194

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

   195

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

   196

   197

    // wrap it

   198

    return lua_chan_create(L, chan);

   199

}

   200

   201

static const struct luaL_Reg lua_net_methods[] = {

   202

    {   "__tostring",   &lua_net_tostring   },

   203

    {   "join",         &lua_net_join       },

   204

    {   "channel",      &lua_net_get_chan   },

   205

    {   NULL,           NULL                }

   206

};

   207

   208

/**

   209

 * Initialize the lua_net object type

   210

 */

   211

static void lua_net_init (lua_State *L)

   212

{

   213

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

   214

}

   215

   216

/**

   217

 * Wrapper for irc_client

   218

 */

   219

struct lua_client {

   220

    struct irc_client *client;

   221

};

   222

   224

{

   225

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

   229

   232

   248

}

   249

   250

static int lua_client_get_network (lua_State *L)

   251

{

   252

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

   253

    struct irc_net *net;

   254

   255

    // the network name

   256

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

   257

   258

    // lookup the irc_net

   259

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

   260

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

   261

   262

    // wrap it

   263

    return lua_net_create(L, net);

   264

}

   265

   282

static const struct luaL_Reg lua_client_methods[] = {

   285

    {   "quit",         &lua_client_quit        },

   286

    {   NULL,           NULL                    }

   287

};

   288

   289

/**

   290

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

   291

 * 'client' and 'networks'.

   292

 */

   293

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

   294

{

   295

    // allocate the global "client" object

   296

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

   297

   298

    // create the type metatable

   299

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

   300

   301

    // set the client userdata's metatable

   302

    lua_setmetatable(L, -2);

   303

   304

    // initialize it

   305

    lua_client->client = client;

   306

   307

    // store it as a global

   308

    lua_setglobal(L, "client");

   309

}

   310

   315

{

   322

    // init the various bits

   323

    lua_client_init(L, nexus->client);

   324

    lua_net_init(L);

   325

    lua_chan_init(L);

   326

   329

}