Bruce/lua-immutable
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
0030c0bc4f
lua-immutable/limmutable.c
Bruce Hill 0030c0bc4f Misc changes.
2018-03-16 15:05:40 -07:00

718 lines
23 KiB
C
Raw Blame History

/*
* immutable.c
* An immutable table library by Bruce Hill. This library returns a single function
* that can be used to declare immutable classes, like so:
*
* immutable = require 'immutable'
* local Foo = immutable({"baz","qux"}, {class_var=5})
* local foo = Foo("hello", 99)
* assert(foo.baz == "hello")
* assert(not pcall(function() foo.x = 'mutable' end))
* local t = {[foo]="it works"}
* assert(t[Foo("hello", 99)] == "it works")
* assert(foo.class_var == 5)
*
* Instances *are* garbage collected.
*/
#include "lua.h"
#include "lauxlib.h"
// The C API changed from 5.1 to 5.2, so these shims help the code compile on >=5.2
#if LUA_VERSION_NUM >= 502
#define lua_objlen(L, i) lua_rawlen(L, i)
#define luaL_register(L, _, R) luaL_setfuncs(L, R, 0)
#endif
// Lua 5.3 introduced lua_isinteger, fall back to lua_isnumber
#if LUA_VERSION_NUM < 503
#define lua_isinteger(L, i) lua_isnumber(L, i)
#endif
#if !defined(LUAI_HASHLIMIT)
#define LUAI_HASHLIMIT 5
#endif
// This is used to create a unique light userdata to store in the registry to allow all
// hash buckets to share the same {__mode='k'} metatable
static int WEAK_KEY_METATABLE;
// This is used to create a unique light userdata to store in the registry to allow all
// __instances tables to share the same {__mode='v'} metatable
static int WEAK_VALUE_METATABLE;
// This is used to create a unique light userdata to store in the registry to allow all
// constructed classes to have the same metatable:
// {__new=Lcreate_instance, __tostring=function(cls) return cls.name or 'immutable(...)' end}
static int SHARED_CLASS_METATABLE;
typedef struct {
unsigned long long hash;
size_t len;
} immutable_info_t;
static int Lcreate_instance(lua_State *L)
{
size_t n_args = lua_gettop(L)-1;
// arg 1: class table, ...
lua_getfield(L, 1, "__fields");
size_t n = lua_isnil(L, -1) ? n_args : lua_objlen(L, -1);
if (n_args > n) {
luaL_error(L, "Too many args: expected %d, but got %d", n, n_args);
}
lua_pop(L, 1);
// Compute the hash:
unsigned long long hash = 0x9a937c4d; // Seed
for (lua_Integer i=1; i <=(lua_Integer)n; i++) {
unsigned long long item_hash;
int type = n > n_args ? LUA_TNIL : lua_type(L, 1+i);
switch (type) {
case LUA_TNIL: case LUA_TNONE:
// Arbitrarily chosen value
item_hash = 0x97167da9;
break;
case LUA_TNUMBER:
{
// Cast float bits to integer
lua_Number num = lua_tonumber(L, 1+i);
item_hash = *((lua_Integer*)&num);
if (item_hash == 0) {
item_hash = 0x2887c992;
}
break;
}
case LUA_TBOOLEAN:
// Arbitrarily chosen values
item_hash = lua_toboolean(L, 1+i)? 0x82684f71 : 0x88d66f2a;
break;
case LUA_TTABLE:
case LUA_TFUNCTION:
case LUA_TUSERDATA:
case LUA_TTHREAD:
case LUA_TLIGHTUSERDATA:
item_hash = (1000003 * type) ^ (lua_Integer)lua_topointer(L, i);
break;
case LUA_TSTRING:
{
// Algorithm taken from Lua 5.3's implementation
size_t len;
const char *str = lua_tolstring(L, 1+i, &len);
item_hash = len ^ 0xd2e9e9ac; // Arbitrary seed
size_t step = (len >> LUAI_HASHLIMIT) + 1;
for (; len >= step; len -= step)
item_hash ^= ((item_hash<<5) + (item_hash>>2) + (unsigned char)(str[len - 1]));
break;
}
default:
item_hash = 0;
}
hash = (1000003 * hash) ^ item_hash;
}
lua_getfield(L, 1, "__instances");
// Stack: [buckets]
// Find bucket
lua_rawgeti(L, -1, hash);
// Stack: [buckets, bucket]
if (lua_isnil(L, -1)) {
// Make a new bucket
// Stack: [buckets, nil]
lua_pop(L, 1);
// Stack: [buckets]
lua_createtable(L, 0, 1);
// Stack: [buckets, bucket]
lua_pushlightuserdata(L, (void*)&WEAK_KEY_METATABLE);
lua_gettable(L, LUA_REGISTRYINDEX);
// Stack: [buckets, bucket, {__mode='k'}]
lua_setmetatable(L, -2);
// Stack: [buckets, bucket]
lua_pushvalue(L, -1);
// Stack: [buckets, bucket, bucket]
lua_rawseti(L, -3, hash);
// Stack: [buckets, bucket]
} else {
// Stack: [buckets, bucket]
// scan bucket
lua_pushnil(L);
while (lua_next(L, -2) != 0) { // for hash_collider_inst, hash_collider in pairs(bucket) do
// Stack: [buckets, bucket, hash_collider_inst, hash_collider]
// Shallow equality check:
lua_pushnil(L);
while (lua_next(L, -2) != 0) { // for i, collider_value in pairs(hash_collider) do
// Stack: [buckets, bucket, hash_collider_inst, hash_collider, i, value]
if (!lua_rawequal(L, -1, 1+lua_tonumber(L, -2))) { // If the i'th entry doesn't match the i'th arg
// Stack: [buckets, bucket, hash_collider_inst, hash_collider, i, value]
lua_pop(L, 3);
// Stack: [buckets, bucket, hash_collider_inst]
goto next_bucket_item;
} else {
// Stack: [buckets, bucket, hash_collider_inst, hash_collider, i, value]
lua_pop(L, 1);
// Stack: [buckets, bucket, hash_collider_inst, hash_collider, i]
}
}
// bucket item matches
// Stack: [buckets, bucket, hash_collider_inst, hash_collider]
lua_pop(L, 1);
return 1;
next_bucket_item: ;
}
}
// Failed to find an existing instance, so create a new one
// Stack: [buckets, bucket]
immutable_info_t *userdata = (immutable_info_t*)lua_newuserdata(L, sizeof(immutable_info_t));
userdata->hash = hash;
userdata->len = n;
// Stack [buckets, bucket, inst_userdata]
lua_pushvalue(L, 1);
// Stack [buckets, bucket, inst_userdata, metatable]
lua_setmetatable(L, -2);
// Stack [buckets, bucket, inst_userdata]
lua_pushvalue(L, -1);
// Stack [buckets, bucket, inst_userdata, inst_userdata]
lua_createtable(L, n, 1); // Create the table to store the instance's data
// Stack [buckets, bucket, inst_userdata, inst_userdata, inst_table]
// Set up a ref to the bucket so its lifetime is tied to inst_userdata
lua_getfield(L, 1, "__buckets");
// Stack [buckets, bucket, inst_userdata, inst_userdata, inst_table, __buckets]
lua_pushvalue(L, -3);
// Stack [buckets, bucket, inst_userdata, inst_userdata, inst_table, __buckets, inst_userdata]
lua_pushvalue(L, -6);
// Stack [buckets, bucket, inst_userdata, inst_userdata, inst_table, __buckets, inst_userdata, bucket]
lua_settable(L, -3);
lua_pop(L, 1);
// Stack [buckets, bucket, inst_userdata, inst_userdata, inst_table]
lua_Integer i;
for (i=1; i <= (lua_Integer)n_args; i++) {
lua_pushvalue(L, i+1);
// Stack [buckets, bucket, inst_userdata, inst_userdata, inst_table, arg #1+i]
lua_rawseti(L, -2, i);
}
for (; i <= (lua_Integer)n; i++) {
lua_pushnil(L);
// Stack [buckets, bucket, inst_userdata, inst_userdata, inst_table, nil]
lua_rawseti(L, -2, i);
}
// Stack [buckets, bucket, inst_userdata, inst_userdata, inst_table]
lua_settable(L, -4); // buckets[inst_userdata] = inst_table
// Stack [buckets, bucket, inst_userdata]
lua_gc(L, LUA_GCSTEP, 3);
return 1;
}
static int Lfrom_table(lua_State *L)
{
lua_pushvalue(L, 1);
// Stack: [mt]
lua_getfield(L, -1, "__fields");
int n;
if (lua_isnil(L, -1)) {
lua_pop(L, 1);
lua_getfield(L, 2, "n");
if (lua_isnil(L, -1)) {
n = lua_objlen(L, 2);
} else {
n = luaL_checkinteger(L, -1);
}
lua_pop(L, 1);
if (! lua_checkstack(L, n)) {
luaL_error(L, "Insufficient stack space!");
}
for (int i = 1; i <= n; i++) {
lua_rawgeti(L, 2, i);
}
// Stack: [mt, table[1], table[2], ... table[table.n]]
} else {
n = lua_objlen(L, -1);
if (! lua_checkstack(L, n)) {
luaL_error(L, "Insufficient stack space!");
}
// Stack: [mt, fields]
lua_pushnil(L);
while (lua_next(L, -2) != 0) {
// Stack: [mt, fields, i, field_i]
lua_gettable(L, 2);
// Stack: [mt, fields, i, table[field_i]]
lua_insert(L, -3);
// Stack: [mt, table[field_i], fields, i]
}
// Stack: [mt, table[field], ..., fields]
lua_pop(L, 1);
// Stack: [mt, table[field], ...]
}
lua_pushcfunction(L, Lcreate_instance);
// Stack: [mt, table[field], ..., create]
lua_insert(L, -(n+2));
// Stack: [create, mt, table[field_1], ...]
lua_call(L, n+1, 1);
return 1;
}
static int Lis_instance(lua_State *L)
{
if (lua_type(L, 2) != LUA_TUSERDATA) {
lua_pushboolean(L, 0);
return 1;
}
lua_getmetatable(L, 2);
lua_pushboolean(L, lua_rawequal(L, -1, 1));
return 1;
}
static int Llen(lua_State *L)
{
luaL_checktype(L, 1, LUA_TUSERDATA);
immutable_info_t *info = (immutable_info_t *)lua_touserdata(L, 1);
lua_pushinteger(L, info->len);
return 1;
}
static int Lindex(lua_State *L)
{
luaL_checktype(L, 1, LUA_TUSERDATA);
if (! lua_getmetatable(L, 1)) {
luaL_error(L, "invalid type");
}
immutable_info_t *info = (immutable_info_t*)lua_touserdata(L, 1);
if (! info) {
luaL_error(L, "invalid type");
}
// Stack: [mt]
lua_getfield(L, -1, "__indices");
// Stack: [mt, indices]
if (lua_isnil(L, -1)) {
if (! lua_isinteger(L, 2)) {
goto class_fallback;
}
lua_pop(L, 1);
// Stack: [mt]
lua_getfield(L, -1, "__instances");
// Stack: [mt, buckets]
lua_rawgeti(L, -1, info->hash);
// Stack: [mt, buckets, bucket]
if (lua_isnil(L, -1)) {
luaL_error(L, "Failed to find hash bucket");
}
lua_pushvalue(L, 1);
// Stack: [mt, buckets, bucket, inst_udata]
lua_rawget(L, -2);
// Stack: [mt, buckets, bucket, inst_table]
int i = luaL_checkinteger(L, 2);
lua_rawgeti(L, -1, i);
if (lua_isnil(L, -1)) {
goto class_fallback;
}
return 1;
}
// Stack: [mt, indices]
lua_pushvalue(L, 2);
// Stack: [mt, indices, k]
lua_gettable(L, -2);
// Stack: [mt, indices, i]
if (lua_isnil(L, -1) && lua_isinteger(L, 2)) {
int i = lua_tointeger(L, 2);
if (1 <= i && i <= (int)info->len) {
// Use the raw value of i
lua_pop(L, 1);
lua_pushvalue(L, 2);
}
}
if (lua_isnil(L, -1)) { // Didn't find the field name
goto class_fallback;
}
// Stack: [mt, indices, i]
lua_getfield(L, -3, "__instances");
// Stack: [mt, indices, i, buckets]
lua_rawgeti(L, -1, info->hash);
// Stack: [mt, indices, i, buckets, bucket]
if (lua_isnil(L, -1)) {
luaL_error(L, "Failed to find hash bucket for hash: %p", (void*)info->hash);
}
lua_pushvalue(L, 1);
// Stack: [mt, indices, i, buckets, bucket, inst_udata]
lua_rawget(L, -2);
// Stack: [mt, indices, i, buckets, bucket, inst_table]
int i = luaL_checkinteger(L, -4);
lua_rawgeti(L, -1, i);
return 1;
// Fall back to class:
class_fallback:
lua_pushvalue(L, 2);
lua_gettable(L, 3);
return 1;
}
static int Ltostring(lua_State *L)
{
luaL_Buffer b;
luaL_buffinit(L, &b);
if (! lua_getmetatable(L, 1)) {
luaL_error(L, "invalid type");
}
// Stack: [mt]
lua_getfield(L, -1, "name");
if (!lua_isnil(L, -1)) {
luaL_addvalue(&b);
} else {
lua_pop(L, 1);
}
luaL_addstring(&b, "(");
lua_getfield(L, -1, "__instances");
// Stack: [mt, buckets]
immutable_info_t *info = (immutable_info_t*)lua_touserdata(L, 1);
if (! info) {
luaL_error(L, "invalid type");
}
lua_rawgeti(L, -1, info->hash);
// Stack: [mt, buckets, bucket]
if (lua_isnil(L, -1)) {
luaL_error(L, "Failed to find hash bucket");
}
lua_pushvalue(L, 1);
// Stack: [mt, buckets, bucket, inst_udata]
lua_rawget(L, -2);
int inst_table_index = lua_gettop(L);
// Stack: [mt, buckets, bucket, inst_table]
lua_getglobal(L, "tostring");
// Stack: [mt, buckets, bucket, inst_table, tostring]
int tostring_index = lua_gettop(L);
lua_getfield(L, -5, "__fields");
// Stack: [mt, buckets, bucket, inst_table, tostring, fields]
if (lua_isnil(L, -1)) {
lua_pop(L, 1);
// Stack: [mt, buckets, bucket, inst_table, tostring]
immutable_info_t *info = (immutable_info_t*)lua_touserdata(L, 1);
int n = info->len, i = 1;
goto first_list_item;
while (++i <= n) {
// Stack: [mt, buckets, bucket, inst_table, tostring, ???]
luaL_addstring(&b, ", ");
first_list_item:
lua_pushvalue(L, tostring_index);
// Stack: [mt, buckets, bucket, inst_table, tostring, ???, tostring]
lua_rawgeti(L, inst_table_index, i);
// Stack: [mt, buckets, bucket, inst_table, tostring, ???, tostring, value]
lua_call(L, 1, 1);
// Stack: [mt, buckets, bucket, inst_table, tostring, ???, value string]
luaL_addvalue(&b);
// Stack: [mt, buckets, bucket, inst_table, tostring, ???]
}
} else {
int fields_index = lua_gettop(L);
int i = 1, num_fields = lua_objlen(L, -1);
goto first_table_item;
while (++i <= num_fields) {
// Stack: [mt, buckets, bucket, inst_table, tostring, fields, ???]
luaL_addstring(&b, ", ");
first_table_item:
lua_pushvalue(L, tostring_index);
// Stack: [mt, buckets, bucket, inst_table, tostring, fields, ???, tostring]
lua_rawgeti(L, fields_index, i);
// Stack: [mt, buckets, bucket, inst_table, tostring, fields, ???, tostring, fieldname]
lua_call(L, 1, 1);
// Stack: [mt, buckets, bucket, inst_table, tostring, fields, ???, field string]
luaL_addvalue(&b);
// Stack: [mt, buckets, bucket, inst_table, tostring, fields, ???]
luaL_addstring(&b, "=");
lua_pushvalue(L, tostring_index);
// Stack: [mt, buckets, bucket, inst_table, tostring, fields, ???, tostring]
lua_rawgeti(L, inst_table_index, i);
// Stack: [mt, buckets, bucket, inst_table, tostring, fields, ???, tostring, value]
lua_call(L, 1, 1);
// Stack: [mt, buckets, bucket, inst_table, tostring, fields, ???, value string]
luaL_addvalue(&b);
// Stack: [mt, buckets, bucket, inst_table, tostring, fields, ???]
}
}
luaL_addstring(&b, ")");
luaL_pushresult(&b);
return 1;
}
static int Lnexti(lua_State *L)
{
if (! lua_getmetatable(L, 1)) {
luaL_error(L, "invalid type");
}
// Stack: [mt]
lua_getfield(L, -1, "__instances");
// Stack: [mt, buckets]
immutable_info_t *info = (immutable_info_t*)lua_touserdata(L, 1);
if (! info) {
luaL_error(L, "invalid type");
}
lua_rawgeti(L, -1, info->hash);
// Stack: [mt, buckets, bucket]
if (lua_isnil(L, -1)) {
luaL_error(L, "Failed to find hash bucket");
}
lua_pushvalue(L, 1);
// Stack: [mt, buckets, bucket, inst_udata]
lua_rawget(L, -2);
// Stack: [mt, buckets, bucket, inst_table]
lua_getfield(L, -4, "__fields");
// Stack: [mt, buckets, bucket, inst_table, fields]
if (lua_isnil(L, -1)) {
lua_pop(L, 1);
// Stack: [mt, buckets, bucket, inst_table]
lua_pushvalue(L, 2);
// Stack: [mt, buckets, bucket, inst_table, i]
if (lua_next(L, -2) == 0) {
return 0;
} else {
return 2;
}
} else {
lua_pushvalue(L, 2);
// Stack: [mt, buckets, bucket, inst_table, fields, i]
if (lua_next(L, -2) == 0) {
return 0;
}
// Stack: [mt, buckets, bucket, inst_table, fields, i2, next_fieldname]
lua_pop(L, 1);
// Stack: [mt, buckets, bucket, inst_table, fields, i2]
int i = luaL_checkinteger(L, -1);
lua_rawgeti(L, -3, i);
// Stack: [mt, buckets, bucket, inst_table, fields, i2, value]
return 2;
}
}
static int Lipairs(lua_State *L)
{
lua_pushcfunction(L, Lnexti);
// Stack: [Lnexti]
lua_pushvalue(L, 1);
// Stack: [Lnexti, inst_udata]
lua_pushnil(L);
// Stack: [Lnexti, inst_udata, nil]
return 3;
}
static int Lnext(lua_State *L)
{
if (! lua_getmetatable(L, 1)) {
luaL_error(L, "invalid type");
}
// Stack: [mt]
lua_getfield(L, -1, "__instances");
// Stack: [mt, buckets]
immutable_info_t *info = (immutable_info_t*)lua_touserdata(L, 1);
if (! info) {
luaL_error(L, "invalid type");
}
lua_rawgeti(L, -1, info->hash);
// Stack: [mt, buckets, bucket]
if (lua_isnil(L, -1)) {
luaL_error(L, "Failed to find hash bucket");
}
lua_pushvalue(L, 1);
// Stack: [mt, buckets, bucket, inst_udata]
lua_rawget(L, -2);
// Stack: [mt, buckets, bucket, inst_table]
lua_getfield(L, -4, "__indices");
// Stack: [mt, buckets, bucket, inst_table, fields]
if (lua_isnil(L, -1)) {
lua_pop(L, 1);
// Stack: [mt, buckets, bucket, inst_table]
lua_pushvalue(L, 2);
// Stack: [mt, buckets, bucket, inst_table, k]
if (lua_next(L, -2) == 0) {
return 0;
}
// Stack: [mt, buckets, bucket, inst_table, k2, value]
return 2;
} else {
lua_pushvalue(L, 2);
// Stack: [mt, buckets, bucket, inst_table, fields, k]
if (lua_next(L, -2) == 0) {
return 0;
}
// Stack: [mt, buckets, bucket, inst_table, fields, k2, next_i]
lua_gettable(L, -4);
// Stack: [mt, buckets, bucket, inst_table, fields, k2, value]
return 2;
}
}
static int Lpairs(lua_State *L)
{
lua_pushcfunction(L, Lnext);
// Stack: [Lnext]
lua_pushvalue(L, 1);
// Stack: [Lnext, inst_udata]
lua_pushnil(L);
// Stack: [Lnext, inst_udata, nil]
return 3;
}
static int Ltable(lua_State *L)
{
lua_getmetatable(L, 1);
// Stack: [mt]
lua_getfield(L, -1, "__instances");
// Stack: [mt, buckets]
immutable_info_t *info = (immutable_info_t *)lua_touserdata(L, 1);
lua_rawgeti(L, -1, info->hash);
// Stack: [mt, buckets, bucket]
if (lua_isnil(L, -1)) {
luaL_error(L, "Failed to find hash bucket for hash: %p", (void*)info->hash);
}
lua_pushvalue(L, 1);
// Stack: [mt, buckets, bucket, inst_udata]
lua_rawget(L, -2);
// Stack: [mt, buckets, bucket, inst_table]
return 1;
}
static const luaL_Reg Rinstance_metamethods[] =
{
{ "__len", Llen},
{ "__index", Lindex},
{ "__tostring", Ltostring},
{ "__ipairs", Lipairs},
{ "__pairs", Lpairs},
{ "from_table", Lfrom_table},
{ "is_instance", Lis_instance},
{ "table", Ltable},
{ NULL, NULL}
};
static int Lmake_class(lua_State *L)
{
// immutable([fields], [methods/metamethods])
lua_createtable(L, 0, 16); // Rough guess, 16 fields from Rinstance_metamethods + __fields, etc.
// Stack: [CLS]
// Populate CLS.__len, CLS.__index, CLS.__pairs, etc.
luaL_register(L,NULL,Rinstance_metamethods);
// If methods were passed in, copy them over, overwriting defaults if desired
if (lua_type(L, 2) == LUA_TTABLE) {
// Stack: [CLS]
lua_pushnil(L);
// Stack: [CLS, nil]
while (lua_next(L, 2) != 0) {
// Stack: [CLS, method_name, method_value]
lua_pushvalue(L, -2);
// Stack: [CLS, method_name, method_value, method_name]
lua_pushvalue(L, -2);
// Stack: [CLS, method_name, method_value, method_name, method_value]
lua_settable(L, -5);
// Stack: [CLS, method_name, method_value]
lua_pop(L, 1);
// Stack: [CLS, method_name]
}
// Stack: [CLS]
}
// Stack: [CLS]
lua_createtable(L, 0, 32); // Rough guess: at least 32 instances concurrently
// Stack: [CLS, __instances]
lua_pushlightuserdata(L, (void*)&WEAK_VALUE_METATABLE);
lua_gettable(L, LUA_REGISTRYINDEX);
// Stack: [CLS, __instances, {__mode='v'}]
lua_setmetatable(L, -2);
// Stack: [CLS, __instances]
lua_setfield(L, -2, "__instances");
// Stack: [CLS]
lua_createtable(L, 0, 32); // Rough guess: at least 32 instances concurrently
// Stack: [CLS, __buckets]
lua_pushlightuserdata(L, (void*)&WEAK_KEY_METATABLE);
lua_gettable(L, LUA_REGISTRYINDEX);
// Stack: [CLS, __buckets, {__mode='k'}]
lua_setmetatable(L, -2);
// Stack: [CLS, __buckets]
lua_setfield(L, -2, "__buckets");
// Stack: [CLS]
switch (lua_type(L, 1)) {
case LUA_TTABLE: {
// CLS.__fields = arg1
lua_pushvalue(L, 1);
// Stack: [CLS, __fields]
lua_setfield(L, -2, "__fields");
// Stack: [CLS]
size_t n = lua_objlen(L, 1);
lua_createtable(L, 0, n);
// Stack: [CLS, __indices]
lua_pushnil(L);
while (lua_next(L, 1) != 0) {
// Stack: [CLS, __indices, i, fieldname]
lua_pushvalue(L, -2);
// Stack: [CLS, __indices, i, fieldname, i]
lua_settable(L, -4);
// Stack: [CLS, __indices, i]
}
lua_setfield(L, -2, "__indices");
break;
}
case LUA_TNIL: case LUA_TNONE: {
// If no fields were passed in, so leave __fields and __indices empty
break;
}
default: {
luaL_error(L, "immutable expected the fields to be either table or nil");
}
}
// Stack: [CLS]
lua_pushlightuserdata(L, (void*)&SHARED_CLASS_METATABLE);
lua_gettable(L, LUA_REGISTRYINDEX);
lua_setmetatable(L, -2);
// Stack [CLS]
return 1;
}
static int Lclass_tostring(lua_State *L)
{
lua_getfield(L, 1, "name");
if (lua_isnil(L, -1)) {
lua_pushfstring(L, "immutable type: %p", lua_topointer(L, 1));
}
return 1;
}
static const luaL_Reg Rclass_metamethods[] =
{
{ "__call", Lcreate_instance},
{ "__tostring", Lclass_tostring},
{ NULL, NULL}
};
LUALIB_API int luaopen_immutable(lua_State *L)
{
lua_pushlightuserdata(L, (void*)&WEAK_VALUE_METATABLE);
lua_createtable(L, 0, 1);
lua_pushstring(L, "v");
lua_setfield(L, -2, "__mode");
lua_settable(L, LUA_REGISTRYINDEX);
lua_pushlightuserdata(L, (void*)&WEAK_KEY_METATABLE);
lua_createtable(L, 0, 1);
lua_pushstring(L, "k");
lua_setfield(L, -2, "__mode");
lua_settable(L, LUA_REGISTRYINDEX);
lua_pushlightuserdata(L, (void*)&SHARED_CLASS_METATABLE);
lua_createtable(L, 0, 2);
luaL_register(L,NULL,Rclass_metamethods);
lua_settable(L, LUA_REGISTRYINDEX);
lua_pushcfunction(L, Lmake_class);
return 1;
}
Reference in New Issue View Git Blame Copy Permalink