lua.c

   1 /*
   2    +----------------------------------------------------------------------+
   3    | LUA extension for PHP                                                |
   4    +----------------------------------------------------------------------+
   5    | Copyright (c) 2007 Johannes Schlueter                                |
   6    +----------------------------------------------------------------------+
   7    | This source file is subject to version 3.01 of the PHP license,      |
   8    | that is bundled with this package in the file LICENSE, and is        |
   9    | available through the world-wide-web at the following url:           |
  10    | http://www.php.net/license/3_01.txt                                  |
  11    | If you did not receive a copy of the PHP license and are unable to   |
  12    | obtain it through the world-wide-web, please send a note to          |
  13    | license@php.net so we can mail you a copy immediately.               |
  14    +----------------------------------------------------------------------+
  15    | Author: Johannes Schlueter  <johannes@php.net>                       |
  16    |         Marcelo  Araujo     <msaraujo@php.net>                       |
  17    |         Andreas Streichardt <andreas.streichardt@globalpark.com      |
  18    +----------------------------------------------------------------------+
  19    */
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include "config.h"
  23 #endif
  24
  25 #include "php.h"
  26 #include "php_ini.h"
  27 #include "ext/standard/info.h"
  28 #include "php_lua.h"
  29
  30 #include "lua.h"
  31 #include "lauxlib.h"
  32 #include "lualib.h"
  33
  34 #define EXT_LUA_VERSION PHP_LUA_VERSION
  35
  36 #ifdef LUA_STACK_DEBUG
  37 #define LUA_STACK_START(L) int __lua_old_top = lua_gettop(L)
  38 #define LUA_STACK_END(L) \
  39   if (__lua_old_top != lua_gettop(L)) {                                                         \
  40     php_error_docref(NULL TSRMLS_CC, E_WARNING, "wrong stack size (%i before operation, %i now)", __lua_old_top, lua_gettop(L)); \
  41   }
  42 #else
  43 #define LUA_STACK_START(L)
  44 #define LUA_STACK_END(L)
  45 #endif
  46
  47 #define LUA_POP_ZVAL(L, z) \
  48   php_lua_get_zval_from_stack(L, -1, z); \
  49 lua_pop(L, 1)
  50
  51 ZEND_DECLARE_MODULE_GLOBALS(lua)
  52
  53 #define getLuaZ(var) (((php_lua_object*)zend_object_store_get_object(var TSRMLS_CC))->L)
  54 #define getLua()     getLuaZ(getThis())
  55
  56 static zend_object_handlers lua_handlers;
  57 static zend_class_entry *lua_ce;
  58
  59 typedef struct _php_lua_object {
  60   zend_object std;
  61   lua_State *L;
  62 } php_lua_object;
  63
  64 static const luaL_Reg php_lualibs[] = {
  65   {"base", luaopen_base},
  66   {LUA_LOADLIBNAME, luaopen_package},
  67   {LUA_TABLIBNAME, luaopen_table},
  68   {LUA_IOLIBNAME, luaopen_io},
  69   {LUA_OSLIBNAME, luaopen_os},
  70   {LUA_STRLIBNAME, luaopen_string},
  71   {LUA_MATHLIBNAME, luaopen_math},
  72   {LUA_DBLIBNAME, luaopen_debug},
  73   {NULL, NULL}
  74 };
  75
  76 static void php_lua_push_zval(lua_State *L, zval *val_p TSRMLS_DC);
  77 static void php_lua_write_real_property(lua_State *L,int index,zval *prop, zval *value TSRMLS_DC);
  78
  79 static void *php_lua_alloc (void *ud, void *ptr, size_t osize, size_t nsize) { /* {{{ */
  80   if (nsize == 0) {
  81     if (ptr) {
  82       efree(ptr);
  83     }
  84     return NULL;
  85   } else {
  86     if (ptr) {
  87       return erealloc(ptr, nsize);
  88     } else {
  89       return emalloc(nsize);
  90     }
  91   }
  92 } /* }}} */
  93
  94
  95 static void php_lua_push_array(lua_State *L, zval *array TSRMLS_DC) /* {{{ */
  96 {
  97   zval **data;
  98   HashTable *arr_hash;
  99   HashPosition pointer;
 100   int array_count;
 101   char *key;
 102   int key_len;
 103   long index;
 104   int hash_key;
 105   char *key_copy;
 106
 107   zval *zkey;
 108
 109   arr_hash = Z_ARRVAL_P(array);
 110   array_count = zend_hash_num_elements(arr_hash);
 111
 112   lua_newtable(L);
 113
 114   for(zend_hash_internal_pointer_reset_ex(arr_hash, &pointer); zend_hash_get_current_data_ex(arr_hash, (void**) &data, &pointer) == SUCCESS;           zend_hash_move_forward_ex(arr_hash, &pointer))
 115   {
 116     hash_key=zend_hash_get_current_key_ex(arr_hash, &key, &key_len, &index, 0, &pointer);
 117
 118     if (hash_key == HASH_KEY_IS_LONG && index == 0) {
 119       php_error_docref(NULL TSRMLS_CC, E_WARNING, "Trying to push array index %d to lua which is unsupported in lua. Element has been discarded",index);
 120     }
 121     else {
 122       ALLOC_INIT_ZVAL(zkey);
 123       if (hash_key == HASH_KEY_IS_STRING) {
 124         key_copy=estrndup(key,key_len-1);
 125         Z_TYPE_P(zkey)=IS_STRING;
 126         Z_STRVAL_P(zkey)=key_copy;
 127         Z_STRLEN_P(zkey)=key_len-1;
 128       }
 129       else {
 130         Z_TYPE_P(zkey)=IS_LONG;
 131         Z_LVAL_P(zkey)=index;
 132       }
 133
 134       php_lua_write_real_property(L,-3,zkey,*data TSRMLS_CC);
 135       zval_ptr_dtor(&zkey);
 136     }
 137   }
 138 } /* }}} */
 139
 140
 141
 142
 143 static void php_lua_push_zval(lua_State *L, zval *val_p TSRMLS_DC) /* {{{ */
 144 {
 145   /* TODO: Use proper type for lua and separate only when needed */
 146
 147   /* push into lua stack properly */
 148   switch (Z_TYPE_P(val_p)) {
 149     case IS_STRING:
 150       lua_pushlstring(L, Z_STRVAL_P(val_p), Z_STRLEN_P(val_p));
 151       break;
 152
 153     case IS_NULL:
 154       lua_pushnil(L);
 155       break;
 156
 157     case IS_DOUBLE:
 158       lua_pushnumber(L, Z_DVAL_P(val_p));
 159       break;
 160
 161     case IS_LONG:
 162       lua_pushnumber(L, Z_LVAL_P(val_p));
 163       break;
 164
 165     case IS_BOOL:
 166       lua_pushboolean(L, Z_BVAL_P(val_p));
 167       break;
 168
 169     case IS_ARRAY:
 170       php_lua_push_array(L,val_p TSRMLS_CC);
 171       break;
 172
 173     default:
 174       php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid type `%s' supported in lua", zend_zval_type_name(val_p));
 175       lua_pushnil(L);
 176       break;
 177   }
 178
 179 } /* }}} */
 180
 181 static int php_lua_push_apply_func(void *pDest, void *argument TSRMLS_DC) /* {{{ */
 182 {
 183   php_lua_push_zval((lua_State*)argument, *(zval**)pDest TSRMLS_CC);
 184   return ZEND_HASH_APPLY_KEEP;
 185 } /* }}} */
 186
 187 static void php_lua_get_zval_from_stack(lua_State *L, int index, zval *ret TSRMLS_DC) /* {{{ */
 188 {
 189   const char *value;
 190   size_t value_len;
 191
 192   switch (lua_type(L, index)) {
 193     case LUA_TBOOLEAN:
 194       ZVAL_BOOL(ret, lua_toboolean(L, index));
 195       break;
 196
 197     case LUA_TNUMBER:
 198       ZVAL_DOUBLE(ret, lua_tonumber(L, index));
 199       break;
 200
 201     case LUA_TSTRING:
 202       value = lua_tolstring(L, index, &value_len);
 203       ZVAL_STRINGL(ret, (char*)value, value_len, 1);
 204       break;
 205
 206     case LUA_TTABLE:
 207       array_init(ret);
 208       /* notify lua to traverse the table */
 209       lua_pushnil(L);
 210
 211       zval *akey,*aval;
 212
 213       /* table has been moved by one because of the pushnil */
 214       /* this will ONLY work with negative indices! */
 215       while (lua_next(L, index-1) != 0)
 216       {
 217         ALLOC_INIT_ZVAL(akey);
 218         ALLOC_INIT_ZVAL(aval);
 219
 220         /* `key' is at index -2 and `value' at index -1 */
 221         php_lua_get_zval_from_stack(L,-2,akey);
 222         php_lua_get_zval_from_stack(L,-1,aval);
 223
 224         switch(Z_TYPE_P(akey))
 225         {
 226           /* lua can't use (at least when i tried ;) ) floats as array keys so that should be safe */
 227           case IS_DOUBLE:
 228             add_index_zval(ret,(long)Z_DVAL_P(akey),aval);
 229             break;
 230           default:
 231             add_assoc_zval(ret,Z_STRVAL_P(akey),aval);
 232             break;
 233         }
 234         lua_pop(L, 1);  /* removes `value'; keeps `key' for next iteration */
 235         zval_ptr_dtor(&akey);
 236       }
 237       break;
 238
 239
 240     case LUA_TFUNCTION:
 241       /* TODO: Make this a PHP Function */
 242
 243     default:
 244       php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid type `%i' passed from lua.", lua_type(L, index));
 245       /* fall-through */
 246
 247     case LUA_TNIL:
 248       ZVAL_NULL(ret);
 249       break;
 250   }
 251
 252 } /* }}} */
 253
 254 static int php_lua_print(lua_State *L) /* {{{ */
 255 {
 256   int i;
 257   int n = lua_gettop(L);
 258
 259   for (i = 1; i <= n; i++) {
 260     php_printf("%s", lua_tostring(L, i));
 261   }
 262
 263   return 0;
 264 } /* }}} */
 265
 266 static void php_lua_object_dtor(void *object, zend_object_handle handle TSRMLS_DC) /* {{{ */
 267 {
 268   php_lua_object *intern = (php_lua_object*)object;
 269   zend_object_std_dtor(&(intern->std) TSRMLS_CC);
 270
 271   if (intern->L) {
 272     lua_close(intern->L);
 273   }
 274
 275   efree(intern);
 276 } /* }}} */
 277
 278 static zval *php_lua_read_property(zval *obj, zval *prop, int type TSRMLS_DC) /* {{{ */
 279 {
 280   zval *retval;
 281   lua_State *L = getLuaZ(obj);
 282
 283   LUA_STACK_START(L);
 284
 285   if (type != BP_VAR_R) {
 286     php_error_docref(NULL TSRMLS_CC, E_WARNING, "No write access using read_property.");
 287     ALLOC_INIT_ZVAL(retval);
 288     return retval;
 289   }
 290
 291   if (Z_TYPE_P(prop) == IS_STRING) {
 292     MAKE_STD_ZVAL(retval);
 293     lua_getfield(L, LUA_GLOBALSINDEX, Z_STRVAL_P(prop) TSRMLS_CC);
 294     php_lua_get_zval_from_stack(L, -1, retval TSRMLS_CC);
 295     ZVAL_DELREF(retval);
 296   } else {
 297     ALLOC_INIT_ZVAL(retval);
 298   }
 299
 300   lua_pop(L, 1);
 301
 302   LUA_STACK_END(L);
 303
 304   return retval;
 305 } /* }}} */
 306
 307
 308 static void php_lua_write_real_property(lua_State *L,int index,zval *prop, zval *value TSRMLS_DC) /* {{{ */
 309 {
 310   LUA_STACK_START(L);
 311   php_lua_push_zval(L, prop TSRMLS_CC);
 312   php_lua_push_zval(L, value TSRMLS_CC);
 313
 314   lua_settable(L, index);
 315   LUA_STACK_END(L);
 316 } /* }}} */
 317
 318
 319
 320 static void php_lua_write_property(zval *obj, zval *prop, zval *value TSRMLS_DC) /* {{{ */
 321 {
 322   /* TODO: Use proper type for lua and separate only when needed */
 323   lua_State *L = getLuaZ(obj);
 324
 325   php_lua_write_real_property(L,LUA_GLOBALSINDEX,prop,value TSRMLS_CC);
 326 } /* }}} */
 327
 328 static int php_lua_atpanic(lua_State *L) { /* {{{ */
 329   TSRMLS_FETCH();
 330   php_error_docref(NULL TSRMLS_CC, E_WARNING, "lua panic (%s)", lua_tostring(L, 1));
 331   lua_pop(L, 1);
 332   zend_bailout();
 333   return 0;
 334 } /* }}} */
 335
 336 static zend_object_value php_lua_create_object(zend_class_entry *ce TSRMLS_DC) /* {{{ */
 337 {
 338   zval tmp;
 339   zend_object_value retval;
 340   php_lua_object *intern;
 341   lua_State *L;
 342
 343   L = lua_newstate(php_lua_alloc, NULL);
 344   lua_atpanic(L, php_lua_atpanic);
 345
 346   intern = ecalloc(1, sizeof(php_lua_object));
 347   intern->L = L;
 348   zend_object_std_init(&(intern->std), ce TSRMLS_CC);
 349   zend_hash_copy(intern->std.properties,
 350       &ce->default_properties, (copy_ctor_func_t) zval_add_ref,
 351       (void *) &tmp, sizeof(zval *));
 352
 353   retval.handle = zend_objects_store_put(intern, php_lua_object_dtor, NULL, NULL TSRMLS_CC);
 354   retval.handlers = &lua_handlers;
 355   return retval;
 356 } /* }}} */
 357
 358 static int php_lua_callback(lua_State *L) /* {{{ */
 359 {
 360   int selected_callback_index=(int)lua_tonumber(L, lua_upvalueindex(1));
 361   zval *return_value;
 362
 363   ALLOC_INIT_ZVAL(return_value);
 364
 365   if (!zend_is_callable(LUA_G(lua_callback)[selected_callback_index],0,NULL))
 366     return;
 367
 368   zval **params;
 369   int n = lua_gettop(L);    /* number of arguments */
 370
 371   params=emalloc(n*sizeof(zval));
 372
 373   int i;
 374   for (i = 1; i <= n; i++) {
 375     ALLOC_INIT_ZVAL(params[i-1]);
 376     /* php_lua_get_zval_from_stack won't work with positive indices */
 377     php_lua_get_zval_from_stack(L,-n-1+i,params[i-1] TSRMLS_CC);
 378   }
 379
 380   /* XXX no check - do we need one? :S */
 381   /* johannes said i should use zend_call_method but this only allows up to 2 parameters?! */
 382   call_user_function(EG(function_table),NULL,LUA_G(lua_callback)[selected_callback_index],return_value,n,params TSRMLS_CC);
 383
 384   /* hmm...what if the result is NULL? should php return a return value (NULL) then or just return 0? :S */
 385   php_lua_push_zval(L,return_value TSRMLS_CC);
 386
 387   for (i = 0; i < n; i++) {
 388     zval_ptr_dtor(&params[i]);
 389   }
 390   efree(params);
 391
 392   zval_ptr_dtor(&return_value);
 393
 394   /* PHP doesn't support multiple return values so this will always be 1 */
 395   return 1;
 396 } /* }}} */
 397
 398 static void php_lua_call_table_with_arguments(lua_State *L,int level,int table_index,char *function,int propagate_self,zval *args,zval *return_value) /* {{{ */
 399 {
 400   lua_getfield(L,table_index,function);
 401   if (lua_type(L,lua_gettop(L)) != LUA_TFUNCTION) {
 402     lua_pop(L, lua_gettop(L) - level);
 403     php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid lua callback. '%s' is not a defined function",function);
 404     return;
 405   }
 406
 407   /* push the table on the stack as the first argument */
 408   if (propagate_self)
 409     lua_pushvalue(L,table_index + lua_gettop(L));
 410
 411   zend_hash_apply_with_argument(Z_ARRVAL_P(args), php_lua_push_apply_func, (void *)L  TSRMLS_CC);
 412
 413   if (lua_pcall(L, zend_hash_num_elements(Z_ARRVAL_P(args)) + propagate_self, LUA_MULTRET, 0) != 0) {
 414     php_error_docref(NULL TSRMLS_CC, E_WARNING, "error running lua function `%s': %s", function, lua_tostring(L, -1));
 415     lua_pop(L, lua_gettop(L) - level);
 416     return;
 417   }
 418
 419   /* always return an array. otherwise we couldn't distinguish between a table return or a multi return */
 420   array_init(return_value);
 421   int retcount = lua_gettop(L) - level;
 422   int i;
 423   zval *val;
 424
 425   for (i = -retcount; i < 0; i++)
 426   {
 427     MAKE_STD_ZVAL(val);
 428     php_lua_get_zval_from_stack(L, i, val TSRMLS_CC);
 429     add_next_index_zval(return_value, val);
 430   }
 431   lua_pop(L, retcount);
 432
 433   return;
 434 } /* }}} */
 435
 436 static void php_lua_call_table_function(INTERNAL_FUNCTION_PARAMETERS,int propagate_self) /* {{{ */
 437 {
 438   zval *callback,*args;
 439   zval **lua_table,**lua_function;
 440   int array_count,level;
 441   lua_State *L;
 442
 443   L=getLua();
 444   LUA_STACK_START(L);
 445
 446   if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "za", &callback, &args) == FAILURE) {
 447     return;
 448   }
 449
 450   array_count=zend_hash_num_elements(Z_ARRVAL_P(callback));
 451   if (array_count!=2) {
 452     LUA_STACK_END(L);
 453     php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid callback supplied. must contain exactly 2 elements");
 454     return;
 455   }
 456   if (zend_hash_index_find(Z_ARRVAL_P(callback), 0, (void**)&lua_table) == FAILURE) {
 457     php_error_docref(NULL TSRMLS_CC, E_WARNING, "callback index 0 is empty");
 458     return;
 459   }
 460   if (zend_hash_index_find(Z_ARRVAL_P(callback), 1, (void**)&lua_function) == FAILURE) {
 461     php_error_docref(NULL TSRMLS_CC, E_WARNING, "callback index 1 is empty");
 462     return;
 463   }
 464   lua_getglobal(L,Z_STRVAL_PP(lua_table));
 465   if (lua_type(L,lua_gettop(L)) != LUA_TTABLE) {
 466     lua_pop(L, -1);
 467     php_error_docref(NULL TSRMLS_CC, E_WARNING, "trying to call an invalid table '%s'",Z_STRVAL_PP(lua_table));
 468     return;
 469   }
 470   level=lua_gettop(L);
 471
 472   php_lua_call_table_with_arguments(L,level,-1,Z_STRVAL_PP(lua_function),propagate_self,args,return_value);
 473
 474   /* remove the table which is still on top */
 475   lua_pop(L,-1);
 476
 477   LUA_STACK_END(L);
 478 } /* }}} */
 479
 480 /* {{{ */
 481 static int php_lua_binary_zval_writer(lua_State* L, const void* p,size_t size, void* u)
 482 {
 483   Z_STRVAL_P((zval*)u)=erealloc(Z_STRVAL_P((zval*)u),(Z_STRLEN_P((zval*)u)+1+size)*sizeof(char));
 484   memcpy(&Z_STRVAL_P((zval*)u)[Z_STRLEN_P((zval*)u)],p,size);
 485   Z_STRLEN_P((zval*)u)=Z_STRLEN_P((zval*)u)+size;
 486   Z_STRVAL_P((zval*)u)[Z_STRLEN_P((zval*)u)]='\0';
 487   return 0;
 488 }
 489 /* }}} */
 490
 491 #define RETURN_STR "return %s"
 492
 493
 494 /* {{{ lua::__construct()
 495    Create new LUA instance */
 496 PHP_METHOD(lua, __construct)
 497 {
 498   lua_State *L = getLua();
 499   // mop: open standard libs if desired
 500   if (lua_globals.load_standard_libs)
 501     luaL_openlibs(L);
 502
 503   lua_register(L, "print", php_lua_print);
 504 }
 505 /* }}} */
 506
 507 /* {{{ lua::__call(string method, array args [, int nresults])
 508    Call a lua function from within PHP */
 509 PHP_METHOD(lua, __call)
 510 {
 511   int level, retcount;
 512   char *function, *func;
 513   long function_len;
 514   zval *args;
 515   int nresults = LUA_MULTRET;
 516   lua_State *L = getLua();
 517
 518   LUA_STACK_START(L);
 519
 520   if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sa|l", &function, &function_len, &args, &nresults) == FAILURE) {
 521     return;
 522   }
 523
 524   level = lua_gettop(L);
 525
 526   spprintf(&func, sizeof(RETURN_STR)-2-1+function_len, RETURN_STR, function);
 527   if (luaL_dostring(L, func)) {
 528     efree(func);
 529     php_error_docref(NULL TSRMLS_CC, E_WARNING, "error looking up lua function `%s': %s", function, lua_tostring(L, -1));
 530     lua_pop(L, lua_gettop(L) - level);
 531     LUA_STACK_END(L);
 532     return;
 533   }
 534   efree(func);
 535
 536   zend_hash_apply_with_argument(Z_ARRVAL_P(args), php_lua_push_apply_func, (void *)L  TSRMLS_CC);
 537
 538   if (lua_pcall(L, zend_hash_num_elements(Z_ARRVAL_P(args)), nresults, 0) != 0) {
 539     php_error_docref(NULL TSRMLS_CC, E_WARNING, "error running lua function `%s': %s", function, lua_tostring(L, -1));
 540     lua_pop(L, lua_gettop(L) - level);
 541     LUA_STACK_END(L);
 542     return;
 543   }
 544
 545   retcount = lua_gettop(L) - level;
 546
 547   if (retcount == 0) {
 548     /* No vlaue returned -> return null */
 549   } else {
 550     /* multiple return values -> build an array */
 551     int i;
 552     zval *val;
 553
 554     array_init(return_value);
 555     for (i = -retcount; i < 0; i++)
 556     {
 557       MAKE_STD_ZVAL(val);
 558       php_lua_get_zval_from_stack(L, i, val TSRMLS_CC);
 559       add_next_index_zval(return_value, val);
 560     }
 561     lua_pop(L, retcount);
 562   }
 563
 564   LUA_STACK_END(L);
 565   return;
 566 }
 567
 568 /* {{{ lua::call_function(string function, array args)
 569    Call a lua function from within PHP */
 570 PHP_METHOD(lua, call_function)
 571 {
 572   char *function;
 573   char *function_len;
 574   zval *args;
 575   lua_State *L;
 576   int level;
 577
 578   L=getLua();
 579   LUA_STACK_START(L);
 580
 581   level=lua_gettop(L);
 582
 583   if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sa", &function, &function_len, &args) == FAILURE) {
 584     return;
 585   }
 586
 587   php_lua_call_table_with_arguments(L,level,LUA_GLOBALSINDEX,function,0,args,return_value);
 588
 589   LUA_STACK_END(L);
 590 }
 591
 592 /* {{{ lua::call_table(array lua_callback, array args)
 593    Call a lua table from within PHP (lua_table.lua_function()) */
 594 PHP_METHOD(lua, call_table)
 595 {
 596   php_lua_call_table_function(INTERNAL_FUNCTION_PARAM_PASSTHRU,0);
 597 }
 598
 599 /* {{{ lua::call_table_self(array lua_callback, array args)
 600    Call a lua table from within PHP and propagate self (lua_table:lua_function()) */
 601 PHP_METHOD(lua, call_table_self)
 602 {
 603   php_lua_call_table_function(INTERNAL_FUNCTION_PARAM_PASSTHRU,1);
 604 }
 605
 606 /* {{{ void lua::evaluate(string code)
 607    Evaluates code with lua */
 608 PHP_METHOD(lua, evaluate)
 609 {
 610   int error;
 611   long code_len;
 612   char *code;
 613   lua_State *L = getLua();
 614
 615   LUA_STACK_START(L);
 616
 617   if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &code, &code_len) == FAILURE) {
 618     return;
 619   }
 620
 621   error = luaL_loadbuffer(L, code, code_len, "line") || lua_pcall(L, 0, LUA_MULTRET, 0);
 622   if (error) {
 623     php_error_docref(NULL TSRMLS_CC, E_WARNING, "lua error: %s", lua_tostring(L, -1));
 624     lua_pop(L, 1);  /* pop error message from the stack */
 625   }
 626
 627   /* always return an array. otherwise we couldn't distinguish between a table return or a multi return */
 628   array_init(return_value);
 629   int retcount = lua_gettop(L);
 630   int i;
 631   zval *val;
 632
 633   for (i = -retcount; i < 0; i++)
 634   {
 635     MAKE_STD_ZVAL(val);
 636     php_lua_get_zval_from_stack(L, i, val TSRMLS_CC);
 637     add_next_index_zval(return_value, val);
 638   }
 639   lua_pop(L, retcount);
 640
 641   LUA_STACK_END(L);
 642 }
 643 /* }}} */
 644
 645 /* {{{ void lua::evaluatefile(string file)
 646    Evaluates a lua script */
 647 PHP_METHOD(lua, evaluatefile)
 648 {
 649   int error;
 650   long file_len;
 651   char *file;
 652   lua_State *L = getLua();
 653
 654   LUA_STACK_START(L);
 655
 656   if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &file, &file_len) == FAILURE) {
 657     return;
 658   }
 659
 660   if (php_check_open_basedir(file TSRMLS_CC) || (PG(safe_mode) && !php_checkuid(file, "rb+", CHECKUID_CHECK_MODE_PARAM))) {
 661     LUA_STACK_END(L);
 662     RETURN_FALSE;
 663   }
 664
 665   error = luaL_dofile(L, file);
 666
 667   if (error) {
 668     php_error_docref(NULL TSRMLS_CC, E_WARNING, "lua error: %s", lua_tostring(L, -1));
 669     lua_pop(L, 1);
 670   }
 671
 672   array_init(return_value);
 673   int retcount = lua_gettop(L);
 674   int i;
 675   zval *val;
 676
 677   for (i = -retcount; i < 0; i++)
 678   {
 679     MAKE_STD_ZVAL(val);
 680     php_lua_get_zval_from_stack(L, i, val TSRMLS_CC);
 681     add_next_index_zval(return_value, val);
 682   }
 683   lua_pop(L, retcount);
 684
 685   LUA_STACK_END(L);
 686 }
 687 /* }}} */
 688
 689 /* {{{ string lua::getVersion()
 690    Return Lua's version      */
 691 PHP_METHOD(lua, getversion)
 692 {
 693   RETURN_STRING(LUA_RELEASE, 1);
 694 }
 695 /* }}} */
 696
 697 /* {{{ */
 698 PHP_METHOD(lua,expose_function)
 699 {
 700   zval *callback;
 701   char *lua_name;
 702   long len;
 703
 704   lua_State *L = getLua();
 705
 706   if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,"sz",&lua_name,&len,&callback) == FAILURE)
 707     return;
 708
 709   if (zend_is_callable(callback,0,NULL)) {
 710     lua_pushnumber(L,LUA_G(lua_callback_count));
 711     lua_pushcclosure(L, php_lua_callback,1);
 712     lua_setglobal(L, lua_name);
 713   }
 714   /* hmm...out of memory check? */
 715   LUA_G(lua_callback)=erealloc(LUA_G(lua_callback),sizeof(zval)*(LUA_G(lua_callback_count)+1));
 716
 717   ALLOC_INIT_ZVAL(LUA_G(lua_callback)[LUA_G(lua_callback_count)]);
 718   *LUA_G(lua_callback)[LUA_G(lua_callback_count)] = *callback;
 719   zval_copy_ctor(LUA_G(lua_callback)[LUA_G(lua_callback_count)]);
 720
 721   LUA_G(lua_callback_count)++;
 722 }
 723 /* }}} */
 724
 725 /* {{{ */
 726 PHP_METHOD(lua,compile)
 727 {
 728   char *chunk;
 729   long len;
 730   int error;
 731
 732   lua_State *L = lua_newstate(php_lua_alloc, NULL);
 733   lua_atpanic(L, php_lua_atpanic);
 734
 735   LUA_STACK_START(L);
 736
 737   if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,"s",&chunk,&len) == FAILURE)
 738   {
 739     lua_close(L);
 740     return;
 741   }
 742
 743   error = luaL_loadbuffer(L, chunk, len, "line");
 744   if (error) {
 745     php_error_docref(NULL TSRMLS_CC, E_WARNING, "lua error: %s", lua_tostring(L, -1));
 746     lua_pop(L, 1);  /* pop error message from the stack */
 747     lua_close(L);
 748     return;
 749   }
 750
 751   RETVAL_STRING("",1);
 752
 753   error=lua_dump(L,php_lua_binary_zval_writer,return_value);
 754   lua_pop(L, 1);  /* clean stack */
 755   LUA_STACK_END(L);
 756   lua_close(L);
 757   if (error) {
 758     php_error_docref(NULL TSRMLS_CC, E_WARNING, "Couldn't dump code");
 759     RETURN_NULL();
 760   }
 761 }
 762
 763 /* {{{ lua_functions[] */
 764 zend_function_entry lua_functions[] = {
 765   {NULL, NULL, NULL}
 766 };
 767 /* }}} */
 768
 769 /* {{{ ARG_INFO */
 770
 771 ZEND_BEGIN_ARG_INFO_EX(arginfo_lua_call, 0, 0, 2)
 772         ZEND_ARG_INFO(0, method)
 773         ZEND_ARG_INFO(0, args)
 774 ZEND_END_ARG_INFO()
 775
 776 ZEND_BEGIN_ARG_INFO_EX(arginfo_lua_call_table, 0, 0, 2)
 777   ZEND_ARG_INFO(0, callback)
 778   ZEND_ARG_INFO(0, args)
 779 ZEND_END_ARG_INFO()
 780
 781 ZEND_BEGIN_ARG_INFO_EX(arginfo_lua_call_function, 0, 0, 2)
 782   ZEND_ARG_INFO(0, function)
 783   ZEND_ARG_INFO(0, args)
 784 ZEND_END_ARG_INFO()
 785
 786 ZEND_BEGIN_ARG_INFO_EX(arginfo_lua_evaluate, 0, 0, 1)
 787   ZEND_ARG_INFO(0, code)
 788 ZEND_END_ARG_INFO()
 789
 790 ZEND_BEGIN_ARG_INFO_EX(arginfo_lua_evaluatefile, 0, 0, 1)
 791   ZEND_ARG_INFO(0, file)
 792 ZEND_END_ARG_INFO()
 793
 794 ZEND_BEGIN_ARG_INFO_EX(arginfo_lua_expose_function, 0, 0, 1)
 795   ZEND_ARG_INFO(0, callback)
 796 ZEND_END_ARG_INFO()
 797
 798 ZEND_BEGIN_ARG_INFO_EX(arginfo_lua_compile, 0, 0, 1)
 799   ZEND_ARG_INFO(0, chunk)
 800 ZEND_END_ARG_INFO()
 801
 802 /* }}} */
 803
 804 /* {{{ lua_class_functions[] */
 805 zend_function_entry lua_class_functions[] = {
 806   PHP_ME(lua, __construct,                NULL,                                   ZEND_ACC_PUBLIC)
 807   PHP_ME(lua, __call,                     arginfo_lua_call,                       ZEND_ACC_PUBLIC)
 808   PHP_ME(lua, call_function,              arginfo_lua_call_function,              ZEND_ACC_PUBLIC)
 809   PHP_ME(lua, call_table,                 arginfo_lua_call_table,                 ZEND_ACC_PUBLIC)
 810   PHP_ME(lua, call_table_self,            arginfo_lua_call_table,                 ZEND_ACC_PUBLIC)
 811   PHP_ME(lua, evaluate,                   arginfo_lua_evaluate,                   ZEND_ACC_PUBLIC)
 812   PHP_ME(lua, evaluatefile,               arginfo_lua_evaluatefile,               ZEND_ACC_PUBLIC)
 813   PHP_ME(lua, getversion,                 NULL,                                   ZEND_ACC_PUBLIC)
 814   PHP_ME(lua, expose_function,            arginfo_lua_expose_function,            ZEND_ACC_PUBLIC)
 815   PHP_ME(lua, compile,                    arginfo_lua_compile,                    ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 816   {NULL, NULL, NULL}
 817 };
 818 /* }}} */
 819
 820 #ifdef COMPILE_DL_LUA
 821 ZEND_GET_MODULE(lua)
 822 #endif
 823
 824   /* {{{ PHP_INI
 825   */
 826 PHP_INI_BEGIN()
 827   STD_PHP_INI_BOOLEAN("lua.load_standard_libs","1", PHP_INI_ALL, OnUpdateBool, load_standard_libs, zend_lua_globals, lua_globals)
 828 PHP_INI_END()
 829   /* }}} */
 830
 831   /* {{{ php_lua_init_globals
 832   */
 833 static void php_lua_init_globals(zend_lua_globals *lua_globals)
 834 {
 835 }
 836 /* }}} */
 837
 838 /* {{{ PHP_MINIT_FUNCTION
 839 */
 840 PHP_MINIT_FUNCTION(lua)
 841 {
 842   REGISTER_INI_ENTRIES();
 843
 844   zend_class_entry ce;
 845   INIT_CLASS_ENTRY(ce, "lua", lua_class_functions);
 846   lua_ce = zend_register_internal_class(&ce TSRMLS_CC);
 847   lua_ce->create_object = php_lua_create_object;
 848   memcpy(&lua_handlers, zend_get_std_object_handlers(),
 849       sizeof(zend_object_handlers));
 850   lua_handlers.write_property = php_lua_write_property;
 851   lua_handlers.read_property  = php_lua_read_property;
 852   lua_ce->ce_flags |= ZEND_ACC_FINAL;
 853
 854   zend_declare_class_constant_long(lua_ce, "MULTRET", sizeof("MULTRET")-1, LUA_MULTRET TSRMLS_CC);
 855
 856   ZEND_INIT_MODULE_GLOBALS(lua, php_lua_init_globals, NULL);
 857
 858   return SUCCESS;
 859 }
 860 /* }}} */
 861
 862 /* {{{ PHP_MSHUTDOWN_FUNCTION
 863 */
 864 PHP_MSHUTDOWN_FUNCTION(lua)
 865 {
 866   UNREGISTER_INI_ENTRIES();
 867   return SUCCESS;
 868 }
 869 /* }}} */
 870
 871 /* {{{ PHP_RINIT_FUNCTION
 872 */
 873 PHP_RINIT_FUNCTION(lua)
 874 {
 875   LUA_G(lua_callback_count)=0;
 876   LUA_G(lua_callback)=emalloc(sizeof(zval*));
 877   return SUCCESS;
 878 }
 879 /* }}} */
 880
 881 /* {{{ PHP_RSHUTDOWN_FUNCTION
 882 */
 883 PHP_RSHUTDOWN_FUNCTION(lua)
 884 {
 885   long i;
 886   for (i=0;i<LUA_G(lua_callback_count);i++)
 887     efree(LUA_G(lua_callback)[i]);
 888   efree(LUA_G(lua_callback));
 889   return SUCCESS;
 890 }
 891 /* }}} */
 892
 893 /* {{{ PHP_MINFO_FUNCTION
 894 */
 895 PHP_MINFO_FUNCTION(lua)
 896 {
 897   php_info_print_table_start();
 898   php_info_print_table_row(2, "lua support", "enabled");
 899   php_info_print_table_row(2, "lua extension version", EXT_LUA_VERSION);
 900   php_info_print_table_row(2, "lua release", LUA_RELEASE);
 901   php_info_print_table_row(2, "lua copyright", LUA_COPYRIGHT);
 902   php_info_print_table_row(2, "lua authors", LUA_AUTHORS);
 903   php_info_print_table_end();
 904
 905   DISPLAY_INI_ENTRIES();
 906 }
 907 /* }}} */
 908
 909 /* {{{ lua_module_entry
 910 */
 911 zend_module_entry lua_module_entry = {
 912   STANDARD_MODULE_HEADER,
 913   "lua",
 914   lua_functions,
 915   PHP_MINIT(lua),
 916   PHP_MSHUTDOWN(lua),
 917   PHP_RINIT(lua),
 918   PHP_RSHUTDOWN(lua),
 919   PHP_MINFO(lua),
 920   EXT_LUA_VERSION,
 921   STANDARD_MODULE_PROPERTIES
 922 };
 923 /* }}} */
 924
 925 /*
 926  * Local variables:
 927  * tab-width: 4
 928  * c-basic-offset: 4
 929  * vim: set noet sw=4 ts=4:
 930  * vim600: noet sw=4 ts=4 fdm=marker:
 931  * End:
 932  */