git.m6w6.name Git - m6w6/ext-psi/blob - src/module.c

   1
   2 #ifdef HAVE_CONFIG_H
   3 #include "config.h"
   4 #endif
   5
   6 #include "php.h"
   7 #include "php_ini.h"
   8 #include "ext/standard/info.h"
   9
  10 #include "php_psi.h"
  11 #include "parser.h"
  12
  13 #include "libjit.h"
  14 #include "libffi.h"
  15
  16 ZEND_DECLARE_MODULE_GLOBALS(psi);
  17
  18 PHP_INI_BEGIN()
  19         STD_PHP_INI_ENTRY("psi.engine", "ffi", PHP_INI_SYSTEM, OnUpdateString, engine, zend_psi_globals, psi_globals)
  20         STD_PHP_INI_ENTRY("psi.directory", "psis", PHP_INI_SYSTEM, OnUpdateString, directory, zend_psi_globals, psi_globals)
  21 PHP_INI_END();
  22
  23 void psi_error(int type, const char *msg, ...)
  24 {
  25         char buf[0x1000];
  26         va_list argv;
  27
  28         va_start(argv, msg);
  29         vslprintf(buf, 0x1000, msg, argv);
  30         va_end(argv);
  31
  32         php_error(type, buf);
  33 }
  34
  35 int psi_internal_type(impl_type *type)
  36 {
  37         switch (type->type) {
  38         case PSI_T_BOOL:
  39                 return _IS_BOOL;
  40         case PSI_T_INT:
  41         case PSI_T_LONG:
  42                 return IS_LONG;
  43         case PSI_T_FLOAT:
  44         case PSI_T_DOUBLE:
  45                 return IS_DOUBLE;
  46         case PSI_T_STRING:
  47                 return IS_STRING;
  48         case PSI_T_ARRAY:
  49                 return IS_ARRAY;
  50         default:
  51                 return 0;
  52         }
  53 }
  54
  55 zend_internal_arg_info *psi_internal_arginfo(impl *impl)
  56 {
  57         size_t i;
  58         zend_internal_arg_info *aip;
  59         zend_internal_function_info *fi;
  60
  61         aip = calloc(impl->func->args->count + 1, sizeof(*aip));
  62
  63         fi = (zend_internal_function_info *) &aip[0];
  64         fi->required_num_args = psi_num_min_args(impl);
  65         fi->return_reference = impl->func->return_reference;
  66         fi->type_hint = psi_internal_type(impl->func->return_type);
  67
  68         for (i = 0; i < impl->func->args->count; ++i) {
  69                 impl_arg *iarg = impl->func->args->args[i];
  70                 zend_internal_arg_info *ai = &aip[i+1];
  71
  72                 ai->name = iarg->var->name;
  73                 ai->type_hint = psi_internal_type(iarg->type);
  74                 if (iarg->var->reference) {
  75                         ai->pass_by_reference = 1;
  76                 }
  77                 if (iarg->var->reference || (iarg->def && iarg->def->type == PSI_T_NULL)) {
  78                         ai->allow_null = 1;
  79                 }
  80         }
  81
  82         return aip;
  83 }
  84
  85 size_t psi_num_min_args(impl *impl)
  86 {
  87         size_t i, n = impl->func->args->count;
  88
  89         for (i = 0; i < impl->func->args->count; ++i) {
  90                 if (impl->func->args->args[i]->def) {
  91                         --n;
  92                 }
  93         }
  94         return n;
  95 }
  96
  97 void psi_to_int(impl_val *ret_val, decl_arg *func, zval *return_value)
  98 {
  99         switch (real_decl_type(func->type)->type) {
 100         case PSI_T_FLOAT:
 101         case PSI_T_DOUBLE:
 102                 RETVAL_DOUBLE(deref_impl_val(0, ret_val, func)->dval);
 103                 convert_to_long(return_value);
 104                 break;
 105         default:
 106                 RETVAL_LONG(deref_impl_val(0, ret_val, func)->lval);
 107         }
 108 }
 109
 110 void psi_to_double(impl_val *ret_val, decl_arg *func, zval *return_value)
 111 {
 112         RETVAL_DOUBLE(deref_impl_val(0, ret_val, func)->dval);
 113 }
 114
 115 void psi_to_string(impl_val *ret_val, decl_arg *func, zval *return_value)
 116 {
 117         switch (real_decl_type(func->type)->type) {
 118         case PSI_T_CHAR:
 119         case PSI_T_SINT8:
 120         case PSI_T_UINT8:
 121                 if (!func->var->pointer_level) {
 122                         char chr = ret_val->lval;
 123                         RETVAL_STRINGL(&chr, 1);
 124                 } else {
 125                         ret_val = deref_impl_val(1, ret_val, func);
 126                         if (ret_val->ptr) {
 127                                 RETVAL_STRING(ret_val->ptr);
 128                         } else {
 129                                 RETVAL_EMPTY_STRING();
 130                         }
 131                 }
 132                 break;
 133         case PSI_T_FLOAT:
 134         case PSI_T_DOUBLE:
 135                 RETVAL_DOUBLE(deref_impl_val(0, ret_val, func)->dval);
 136                 convert_to_string(return_value);
 137                 break;
 138         default:
 139                 RETVAL_LONG(deref_impl_val(0, ret_val, func)->lval);
 140                 convert_to_string(return_value);
 141                 break;
 142         }
 143 }
 144
 145 size_t psi_t_size(token_t t)
 146 {
 147         size_t size;
 148
 149         switch (t) {
 150         case PSI_T_CHAR:
 151                 size = sizeof(char);
 152                 break;
 153         case PSI_T_SINT8:
 154         case PSI_T_UINT8:
 155                 size = 1;
 156                 break;
 157         case PSI_T_SHORT:
 158                 size = sizeof(short);
 159                 break;
 160         case PSI_T_SINT16:
 161         case PSI_T_UINT16:
 162                 size = 2;
 163                 break;
 164         case PSI_T_INT:
 165                 size = sizeof(int);
 166                 break;
 167         case PSI_T_SINT32:
 168         case PSI_T_UINT32:
 169                 size = 4;
 170                 break;
 171         case PSI_T_LONG:
 172                 size = sizeof(long);
 173                 break;
 174         case PSI_T_SINT64:
 175         case PSI_T_UINT64:
 176                 size = 8;
 177                 break;
 178         case PSI_T_FLOAT:
 179                 size = sizeof(float);
 180                 break;
 181         case PSI_T_DOUBLE:
 182                 size = sizeof(double);
 183                 break;
 184         EMPTY_SWITCH_DEFAULT_CASE();
 185         }
 186         return size;
 187 }
 188
 189 static impl_val *iterate(impl_val *val, token_t t, unsigned i, impl_val *tmp)
 190 {
 191         size_t size = psi_t_size(t);
 192
 193         memset(tmp, 0, sizeof(*tmp));
 194         memcpy(tmp, val->ptr + size * i, size);
 195         return tmp;
 196 }
 197
 198 void psi_to_array(impl_val *ret_val, decl_arg *func, zval *return_value)
 199 {
 200         zval ele;
 201         unsigned i;
 202         impl_val tmp;
 203         token_t t = real_decl_type(func->type)->type;
 204
 205         array_init(return_value);
 206         ret_val = deref_impl_val(0, ret_val, func);
 207         for (i = 0; i < func->var->array_size; ++i) {
 208                 impl_val *ptr = iterate(ret_val, t, i, &tmp);
 209
 210                 switch (t) {
 211                 case PSI_T_FLOAT:
 212                 case PSI_T_DOUBLE:
 213                         ZVAL_DOUBLE(&ele, ptr->dval);
 214                         break;
 215                 default:
 216                         ZVAL_LONG(&ele, ptr->lval);
 217                         break;
 218                 }
 219
 220                 add_next_index_zval(return_value, &ele);
 221         }
 222 }
 223
 224 ZEND_RESULT_CODE psi_parse_args(zend_execute_data *execute_data, impl *impl)
 225 {
 226         impl_arg *iarg;
 227
 228         if (!impl->func->args->count) {
 229                 return zend_parse_parameters_none();
 230         }
 231
 232         ZEND_PARSE_PARAMETERS_START(psi_num_min_args(impl), impl->func->args->count)
 233         nextarg:
 234                 iarg = impl->func->args->args[_i];
 235                 if (iarg->def) {
 236                         Z_PARAM_OPTIONAL;
 237                 }
 238                 if (PSI_T_BOOL == iarg->type->type) {
 239                         if (iarg->def) {
 240                                 iarg->val.bval = iarg->def->type == PSI_T_TRUE ? 1 : 0;
 241                         }
 242                         Z_PARAM_BOOL(iarg->val.bval);
 243                 } else if (PSI_T_INT == iarg->type->type) {
 244                         if (iarg->def) {
 245                                 iarg->val.lval = zend_atol(iarg->def->text, strlen(iarg->def->text));
 246                         }
 247                         Z_PARAM_LONG(iarg->val.lval);
 248                 } else if (PSI_T_FLOAT == iarg->type->type) {
 249                         if (iarg->def) {
 250                                 iarg->val.dval = zend_strtod(iarg->def->text, NULL);
 251                         }
 252                         Z_PARAM_DOUBLE(iarg->val.dval);
 253                 } else if (PSI_T_STRING == iarg->type->type) {
 254                         struct {char *val; size_t len;} str;
 255                         if (iarg->def) {
 256                                 /* FIXME */
 257                                 str.len = strlen(iarg->def->text) - 2;
 258                                 str.val = &iarg->def->text[1];
 259                         }
 260                         Z_PARAM_STR_EX(iarg->val.str, 1, 0);
 261                         if (iarg->val.str) {
 262                                 zend_string_addref(iarg->val.str);
 263                         } else if (iarg->def) {
 264                                 iarg->val.str = zend_string_init(str.val, str.len, 0);
 265                         }
 266                 } else if (PSI_T_ARRAY == iarg->type->type) {
 267                         /* handled as _zv in let or set */
 268                         Z_PARAM_PROLOGUE(0);
 269                 } else {
 270                         error_code = ZPP_ERROR_FAILURE;
 271                         break;
 272                 }
 273                 iarg->_zv = _arg;
 274                 if (_i < _max_num_args) {
 275                         goto nextarg;
 276                 }
 277         ZEND_PARSE_PARAMETERS_END_EX(return FAILURE);
 278
 279         return SUCCESS;
 280 }
 281
 282 impl_val *psi_do_let(decl_arg *darg)
 283 {
 284         impl_val *arg_val = &darg->let->out;
 285         impl_arg *iarg = darg->let->arg;
 286
 287         if (!iarg) {
 288                 /*
 289                  * let foo = NULL;
 290                  * let foo;
 291                  */
 292                 if (darg->var->array_size) {
 293                         arg_val->ptr = ecalloc(darg->var->array_size, sizeof(*arg_val));
 294                         darg->let->mem = arg_val->ptr;
 295                 } else {
 296                         memset(arg_val, 0, sizeof(*arg_val));
 297                 }
 298                 return arg_val;
 299         }
 300         switch (darg->let->val->func->type) {
 301         case PSI_T_BOOLVAL:
 302                 if (iarg->type->type == PSI_T_BOOL) {
 303                         arg_val->cval = iarg->val.cval;
 304                 } else {
 305                         arg_val->cval = zend_is_true(iarg->_zv);
 306                 }
 307                 break;
 308         case PSI_T_INTVAL:
 309                 if (iarg->type->type == PSI_T_INT) {
 310                         arg_val->lval = iarg->val.lval;
 311                 } else {
 312                         arg_val->lval = zval_get_long(iarg->_zv);
 313                 }
 314                 break;
 315         case PSI_T_STRVAL:
 316                 if (iarg->type->type == PSI_T_STRING) {
 317                         arg_val->ptr = estrdup(iarg->val.str->val);
 318                         darg->let->mem = arg_val->ptr;
 319                         zend_string_release(iarg->val.str);
 320                 } else {
 321                         zend_string *zs = zval_get_string(iarg->_zv);
 322                         arg_val->ptr = estrdup(zs->val);
 323                         darg->let->mem = arg_val->ptr;
 324                         zend_string_release(zs);
 325                 }
 326                 break;
 327         case PSI_T_STRLEN:
 328                 if (iarg->type->type == PSI_T_STRING) {
 329                         arg_val->lval = iarg->val.str->len;
 330                         zend_string_release(iarg->val.str);
 331                 } else {
 332                         zend_string *zs = zval_get_string(iarg->_zv);
 333                         arg_val->lval = zs->len;
 334                         zend_string_release(zs);
 335                 }
 336                 break;
 337         case PSI_T_CALLOC:
 338                 arg_val->ptr = calloc(1, darg->let->val->func->size);
 339                 darg->let->mem = arg_val->ptr;
 340                 break;
 341         EMPTY_SWITCH_DEFAULT_CASE();
 342         }
 343
 344         return arg_val;
 345 }
 346
 347 void psi_do_set(zval *return_value, set_func *func, decl_vars *vars)
 348 {
 349         impl_val *val = (impl_val *) &vars->vars[0]->arg->let->ptr;
 350
 351         ZVAL_DEREF(return_value);
 352         zval_dtor(return_value);
 353
 354         switch (func->type) {
 355         case PSI_T_TO_STRING:
 356                 psi_to_string(val, vars->vars[0]->arg, return_value);
 357                 break;
 358         case PSI_T_TO_ARRAY:
 359                 psi_to_array(val, vars->vars[0]->arg, return_value);
 360                 break;
 361         EMPTY_SWITCH_DEFAULT_CASE();
 362         }
 363 }
 364
 365 void psi_do_return(impl *impl, impl_val *ret_val, zval *return_value)
 366 {
 367         switch (impl->stmts->ret.list[0]->func->type) {
 368         case PSI_T_TO_STRING:
 369                 psi_to_string(ret_val, impl->decl->func, return_value);
 370                 break;
 371         case PSI_T_TO_INT:
 372                 psi_to_int(ret_val, impl->decl->func, return_value);
 373                 break;
 374         EMPTY_SWITCH_DEFAULT_CASE();
 375         }
 376 }
 377
 378 void psi_do_free(free_stmt *fre)
 379 {
 380         size_t i;
 381
 382         for (i = 0; i < fre->vars->count; ++i) {
 383                 decl_var *dvar = fre->vars->vars[i];
 384
 385                 if (dvar->arg && dvar->arg->let->out.ptr) {
 386                         free(dvar->arg->let->out.ptr);
 387                         dvar->arg->let->out.ptr = NULL;
 388                 }
 389         }
 390 }
 391
 392 void psi_do_clean(impl *impl)
 393 {
 394         size_t i;
 395
 396         for (i = 0; i < impl->func->args->count; ++i ) {
 397                 impl_arg *iarg = impl->func->args->args[i];
 398
 399                 switch (iarg->type->type) {
 400                 case PSI_T_STRING:
 401                         if (iarg->val.str) {
 402                                 zend_string_release(iarg->val.str);
 403                         }
 404                         break;
 405                 }
 406         }
 407
 408         for (i = 0; i < impl->decl->args->count; ++i) {
 409                 decl_arg *darg = impl->decl->args->args[i];
 410
 411                 if (darg->let && darg->let->mem) {
 412                         efree(darg->let->mem);
 413                         darg->let->mem = NULL;
 414                 }
 415         }
 416 }
 417
 418 PHP_MINIT_FUNCTION(psi)
 419 {
 420         PSI_ContextOps *ops;
 421
 422         REGISTER_INI_ENTRIES();
 423
 424         if (!strcasecmp(PSI_G(engine), "jit")) {
 425                 ops = PSI_Libjit();
 426         } else {
 427                 ops = PSI_Libffi();
 428         }
 429
 430         PSI_ContextInit(&PSI_G(context), ops, psi_error);
 431         PSI_ContextBuild(&PSI_G(context), PSI_G(directory));
 432
 433         return SUCCESS;
 434 }
 435 PHP_MSHUTDOWN_FUNCTION(psi)
 436 {
 437         PSI_ContextDtor(&PSI_G(context));
 438
 439         UNREGISTER_INI_ENTRIES();
 440
 441         return SUCCESS;
 442 }
 443
 444 /* Remove if there's nothing to do at request start */
 445 /* {{{ PHP_RINIT_FUNCTION
 446  */
 447 PHP_RINIT_FUNCTION(psi)
 448 {
 449 #if defined(COMPILE_DL_PSI) && defined(ZTS)
 450         ZEND_TSRMLS_CACHE_UPDATE();
 451 #endif
 452         return SUCCESS;
 453 }
 454 /* }}} */
 455
 456 /* Remove if there's nothing to do at request end */
 457 /* {{{ PHP_RSHUTDOWN_FUNCTION
 458  */
 459 PHP_RSHUTDOWN_FUNCTION(psi)
 460 {
 461         return SUCCESS;
 462 }
 463 /* }}} */
 464
 465 PHP_MINFO_FUNCTION(psi)
 466 {
 467         php_info_print_table_start();
 468         php_info_print_table_header(2, "psi support", "enabled");
 469         php_info_print_table_end();
 470
 471         DISPLAY_INI_ENTRIES();
 472 }
 473 const zend_function_entry psi_functions[] = {
 474         PHP_FE_END
 475 };
 476
 477 zend_module_entry psi_module_entry = {
 478         STANDARD_MODULE_HEADER,
 479         "psi",
 480         psi_functions,
 481         PHP_MINIT(psi),
 482         PHP_MSHUTDOWN(psi),
 483         PHP_RINIT(psi),         /* Replace with NULL if there's nothing to do at request start */
 484         PHP_RSHUTDOWN(psi),     /* Replace with NULL if there's nothing to do at request end */
 485         PHP_MINFO(psi),
 486         PHP_PSI_VERSION,
 487         STANDARD_MODULE_PROPERTIES
 488 };
 489
 490 #ifdef COMPILE_DL_PSI
 491 #ifdef ZTS
 492 ZEND_TSRMLS_CACHE_DEFINE();
 493 #endif
 494 ZEND_GET_MODULE(psi)
 495 #endif
 496
 497 /*
 498  * Local variables:
 499  * tab-width: 4
 500  * c-basic-offset: 4
 501  * End:
 502  * vim600: noet sw=4 ts=4 fdm=marker
 503  * vim<600: noet sw=4 ts=4
 504  */