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_alignment(token_t t)
 146 {
 147         size_t align;
 148 # define PSI_TAS_D(T) struct TAS_ ##T { \
 149         char c; \
 150         ##T x; \
 151 }
 152 # define PSI_TAS_C(T) align = offsetof(struct TAS_ ##T, x)
 153 # define PSI_TAS_CASE(T) { \
 154         PSI_TAS_D(T); \
 155         PSI_TAS_C(T); \
 156 }
 157         switch (t) {
 158         case PSI_T_CHAR:
 159                 PSI_TAS_CASE(char);
 160                 break;
 161         case PSI_T_SINT8:
 162                 PSI_TAS_CASE(int8_t);
 163                 break;
 164         case PSI_T_UINT8:
 165                 PSI_TAS_CASE(uint8_t);
 166                 break;
 167         case PSI_T_SHORT:
 168                 PSI_TAS_CASE(short);
 169                 break;
 170         case PSI_T_SINT16:
 171                 PSI_TAS_CASE(int16_t);
 172                 break;
 173         case PSI_T_UINT16:
 174                 PSI_TAS_CASE(uint16_t);
 175                 break;
 176         case PSI_T_INT:
 177                 PSI_TAS_CASE(int);
 178                 break;
 179         case PSI_T_SINT32:
 180                 PSI_TAS_CASE(int32_t);
 181                 break;
 182         case PSI_T_UINT32:
 183                 PSI_TAS_CASE(uint32_t);
 184                 break;
 185         case PSI_T_LONG:
 186                 PSI_TAS_CASE(long);
 187                 break;
 188         case PSI_T_SINT64:
 189                 PSI_TAS_CASE(int64_t);
 190                 break;
 191         case PSI_T_UINT64:
 192                 PSI_TAS_CASE(uint64_t);
 193                 break;
 194         case PSI_T_FLOAT:
 195                 PSI_TAS_CASE(float);
 196                 break;
 197         case PSI_T_DOUBLE:
 198                 PSI_TAS_CASE(double);
 199                 break;
 200         EMPTY_SWITCH_DEFAULT_CASE();
 201         }
 202 }
 203
 204 size_t psi_t_size(token_t t)
 205 {
 206         size_t size;
 207
 208         switch (t) {
 209         case PSI_T_CHAR:
 210                 size = sizeof(char);
 211                 break;
 212         case PSI_T_SINT8:
 213         case PSI_T_UINT8:
 214                 size = 1;
 215                 break;
 216         case PSI_T_SHORT:
 217                 size = sizeof(short);
 218                 break;
 219         case PSI_T_SINT16:
 220         case PSI_T_UINT16:
 221                 size = 2;
 222                 break;
 223         case PSI_T_INT:
 224                 size = sizeof(int);
 225                 break;
 226         case PSI_T_SINT32:
 227         case PSI_T_UINT32:
 228                 size = 4;
 229                 break;
 230         case PSI_T_LONG:
 231                 size = sizeof(long);
 232                 break;
 233         case PSI_T_SINT64:
 234         case PSI_T_UINT64:
 235                 size = 8;
 236                 break;
 237         case PSI_T_FLOAT:
 238                 size = sizeof(float);
 239                 break;
 240         case PSI_T_DOUBLE:
 241                 size = sizeof(double);
 242                 break;
 243         EMPTY_SWITCH_DEFAULT_CASE();
 244         }
 245         return size;
 246 }
 247
 248 size_t psi_t_align(token_t t, size_t s)
 249 {
 250         size_t a = psi_t_alignment(t);
 251         return ((s - 1) | (a - 1)) + 1;
 252 }
 253
 254 static impl_val *iterate(impl_val *val, token_t t, unsigned i, impl_val *tmp)
 255 {
 256         size_t size = psi_t_size(t);
 257
 258         memset(tmp, 0, sizeof(*tmp));
 259         memcpy(tmp, val->ptr + size * i, size);
 260         return tmp;
 261 }
 262
 263 void psi_to_array(impl_val *ret_val, decl_arg *func, zval *return_value)
 264 {
 265         zval ele;
 266         unsigned i;
 267         impl_val tmp;
 268         token_t t = real_decl_type(func->type)->type;
 269
 270         array_init(return_value);
 271         ret_val = deref_impl_val(0, ret_val, func);
 272         for (i = 0; i < func->var->array_size; ++i) {
 273                 impl_val *ptr = iterate(ret_val, t, i, &tmp);
 274
 275                 switch (t) {
 276                 case PSI_T_FLOAT:
 277                 case PSI_T_DOUBLE:
 278                         ZVAL_DOUBLE(&ele, ptr->dval);
 279                         break;
 280                 default:
 281                         ZVAL_LONG(&ele, ptr->lval);
 282                         break;
 283                 }
 284
 285                 add_next_index_zval(return_value, &ele);
 286         }
 287 }
 288
 289 ZEND_RESULT_CODE psi_parse_args(zend_execute_data *execute_data, impl *impl)
 290 {
 291         impl_arg *iarg;
 292
 293         if (!impl->func->args->count) {
 294                 return zend_parse_parameters_none();
 295         }
 296
 297         ZEND_PARSE_PARAMETERS_START(psi_num_min_args(impl), impl->func->args->count)
 298         nextarg:
 299                 iarg = impl->func->args->args[_i];
 300                 if (iarg->def) {
 301                         Z_PARAM_OPTIONAL;
 302                 }
 303                 if (PSI_T_BOOL == iarg->type->type) {
 304                         if (iarg->def) {
 305                                 iarg->val.bval = iarg->def->type == PSI_T_TRUE ? 1 : 0;
 306                         }
 307                         Z_PARAM_BOOL(iarg->val.bval);
 308                 } else if (PSI_T_INT == iarg->type->type) {
 309                         if (iarg->def) {
 310                                 iarg->val.lval = zend_atol(iarg->def->text, strlen(iarg->def->text));
 311                         }
 312                         Z_PARAM_LONG(iarg->val.lval);
 313                 } else if (PSI_T_FLOAT == iarg->type->type) {
 314                         if (iarg->def) {
 315                                 iarg->val.dval = zend_strtod(iarg->def->text, NULL);
 316                         }
 317                         Z_PARAM_DOUBLE(iarg->val.dval);
 318                 } else if (PSI_T_STRING == iarg->type->type) {
 319                         struct {char *val; size_t len;} str;
 320                         if (iarg->def) {
 321                                 /* FIXME */
 322                                 str.len = strlen(iarg->def->text) - 2;
 323                                 str.val = &iarg->def->text[1];
 324                         }
 325                         Z_PARAM_STR_EX(iarg->val.str, 1, 0);
 326                         if (iarg->val.str) {
 327                                 zend_string_addref(iarg->val.str);
 328                         } else if (iarg->def) {
 329                                 iarg->val.str = zend_string_init(str.val, str.len, 0);
 330                         }
 331                 } else if (PSI_T_ARRAY == iarg->type->type) {
 332                         /* handled as _zv in let or set */
 333                         Z_PARAM_PROLOGUE(0);
 334                 } else {
 335                         error_code = ZPP_ERROR_FAILURE;
 336                         break;
 337                 }
 338                 iarg->_zv = _arg;
 339                 if (_i < _max_num_args) {
 340                         goto nextarg;
 341                 }
 342         ZEND_PARSE_PARAMETERS_END_EX(return FAILURE);
 343
 344         return SUCCESS;
 345 }
 346
 347 impl_val *psi_do_let(decl_arg *darg)
 348 {
 349         impl_val *arg_val = &darg->let->out;
 350         impl_arg *iarg = darg->let->arg;
 351
 352         if (!iarg) {
 353                 /*
 354                  * let foo = NULL;
 355                  * let foo;
 356                  */
 357                 if (darg->var->array_size) {
 358                         arg_val->ptr = ecalloc(darg->var->array_size, sizeof(*arg_val));
 359                         darg->let->mem = arg_val->ptr;
 360                 } else {
 361                         memset(arg_val, 0, sizeof(*arg_val));
 362                 }
 363                 return arg_val;
 364         }
 365         switch (darg->let->val->func->type) {
 366         case PSI_T_BOOLVAL:
 367                 if (iarg->type->type == PSI_T_BOOL) {
 368                         arg_val->cval = iarg->val.cval;
 369                 } else {
 370                         arg_val->cval = zend_is_true(iarg->_zv);
 371                 }
 372                 break;
 373         case PSI_T_INTVAL:
 374                 if (iarg->type->type == PSI_T_INT) {
 375                         arg_val->lval = iarg->val.lval;
 376                 } else {
 377                         arg_val->lval = zval_get_long(iarg->_zv);
 378                 }
 379                 break;
 380         case PSI_T_STRVAL:
 381                 if (iarg->type->type == PSI_T_STRING) {
 382                         arg_val->ptr = estrdup(iarg->val.str->val);
 383                         darg->let->mem = arg_val->ptr;
 384                         zend_string_release(iarg->val.str);
 385                 } else {
 386                         zend_string *zs = zval_get_string(iarg->_zv);
 387                         arg_val->ptr = estrdup(zs->val);
 388                         darg->let->mem = arg_val->ptr;
 389                         zend_string_release(zs);
 390                 }
 391                 break;
 392         case PSI_T_STRLEN:
 393                 if (iarg->type->type == PSI_T_STRING) {
 394                         arg_val->lval = iarg->val.str->len;
 395                         zend_string_release(iarg->val.str);
 396                 } else {
 397                         zend_string *zs = zval_get_string(iarg->_zv);
 398                         arg_val->lval = zs->len;
 399                         zend_string_release(zs);
 400                 }
 401                 break;
 402         case PSI_T_CALLOC:
 403                 arg_val->ptr = calloc(1, darg->let->val->func->size);
 404                 darg->let->mem = arg_val->ptr;
 405                 break;
 406         EMPTY_SWITCH_DEFAULT_CASE();
 407         }
 408
 409         return arg_val;
 410 }
 411
 412 void psi_do_set(zval *return_value, set_func *func, decl_vars *vars)
 413 {
 414         impl_val *val = (impl_val *) &vars->vars[0]->arg->let->ptr;
 415
 416         ZVAL_DEREF(return_value);
 417         zval_dtor(return_value);
 418
 419         switch (func->type) {
 420         case PSI_T_TO_STRING:
 421                 psi_to_string(val, vars->vars[0]->arg, return_value);
 422                 break;
 423         case PSI_T_TO_ARRAY:
 424                 psi_to_array(val, vars->vars[0]->arg, return_value);
 425                 break;
 426         EMPTY_SWITCH_DEFAULT_CASE();
 427         }
 428 }
 429
 430 void psi_do_return(impl *impl, impl_val *ret_val, zval *return_value)
 431 {
 432         switch (impl->stmts->ret.list[0]->func->type) {
 433         case PSI_T_TO_STRING:
 434                 psi_to_string(ret_val, impl->decl->func, return_value);
 435                 break;
 436         case PSI_T_TO_INT:
 437                 psi_to_int(ret_val, impl->decl->func, return_value);
 438                 break;
 439         EMPTY_SWITCH_DEFAULT_CASE();
 440         }
 441 }
 442
 443 void psi_do_free(free_stmt *fre)
 444 {
 445         size_t i;
 446
 447         for (i = 0; i < fre->vars->count; ++i) {
 448                 decl_var *dvar = fre->vars->vars[i];
 449
 450                 if (dvar->arg && dvar->arg->let->out.ptr) {
 451                         free(dvar->arg->let->out.ptr);
 452                         dvar->arg->let->out.ptr = NULL;
 453                 }
 454         }
 455 }
 456
 457 void psi_do_clean(impl *impl)
 458 {
 459         size_t i;
 460
 461         for (i = 0; i < impl->func->args->count; ++i ) {
 462                 impl_arg *iarg = impl->func->args->args[i];
 463
 464                 switch (iarg->type->type) {
 465                 case PSI_T_STRING:
 466                         if (iarg->val.str) {
 467                                 zend_string_release(iarg->val.str);
 468                         }
 469                         break;
 470                 }
 471         }
 472
 473         for (i = 0; i < impl->decl->args->count; ++i) {
 474                 decl_arg *darg = impl->decl->args->args[i];
 475
 476                 if (darg->let && darg->let->mem) {
 477                         efree(darg->let->mem);
 478                         darg->let->mem = NULL;
 479                 }
 480         }
 481 }
 482
 483 PHP_MINIT_FUNCTION(psi)
 484 {
 485         PSI_ContextOps *ops;
 486
 487         REGISTER_INI_ENTRIES();
 488
 489         if (!strcasecmp(PSI_G(engine), "jit")) {
 490                 ops = PSI_Libjit();
 491         } else {
 492                 ops = PSI_Libffi();
 493         }
 494
 495         PSI_ContextInit(&PSI_G(context), ops, psi_error);
 496         PSI_ContextBuild(&PSI_G(context), PSI_G(directory));
 497
 498         return SUCCESS;
 499 }
 500 PHP_MSHUTDOWN_FUNCTION(psi)
 501 {
 502         PSI_ContextDtor(&PSI_G(context));
 503
 504         UNREGISTER_INI_ENTRIES();
 505
 506         return SUCCESS;
 507 }
 508
 509 /* Remove if there's nothing to do at request start */
 510 /* {{{ PHP_RINIT_FUNCTION
 511  */
 512 PHP_RINIT_FUNCTION(psi)
 513 {
 514 #if defined(COMPILE_DL_PSI) && defined(ZTS)
 515         ZEND_TSRMLS_CACHE_UPDATE();
 516 #endif
 517         return SUCCESS;
 518 }
 519 /* }}} */
 520
 521 /* Remove if there's nothing to do at request end */
 522 /* {{{ PHP_RSHUTDOWN_FUNCTION
 523  */
 524 PHP_RSHUTDOWN_FUNCTION(psi)
 525 {
 526         return SUCCESS;
 527 }
 528 /* }}} */
 529
 530 PHP_MINFO_FUNCTION(psi)
 531 {
 532         php_info_print_table_start();
 533         php_info_print_table_header(2, "psi support", "enabled");
 534         php_info_print_table_end();
 535
 536         DISPLAY_INI_ENTRIES();
 537 }
 538 const zend_function_entry psi_functions[] = {
 539         PHP_FE_END
 540 };
 541
 542 zend_module_entry psi_module_entry = {
 543         STANDARD_MODULE_HEADER,
 544         "psi",
 545         psi_functions,
 546         PHP_MINIT(psi),
 547         PHP_MSHUTDOWN(psi),
 548         PHP_RINIT(psi),         /* Replace with NULL if there's nothing to do at request start */
 549         PHP_RSHUTDOWN(psi),     /* Replace with NULL if there's nothing to do at request end */
 550         PHP_MINFO(psi),
 551         PHP_PSI_VERSION,
 552         STANDARD_MODULE_PROPERTIES
 553 };
 554
 555 #ifdef COMPILE_DL_PSI
 556 #ifdef ZTS
 557 ZEND_TSRMLS_CACHE_DEFINE();
 558 #endif
 559 ZEND_GET_MODULE(psi)
 560 #endif
 561
 562 /*
 563  * Local variables:
 564  * tab-width: 4
 565  * c-basic-offset: 4
 566  * End:
 567  * vim600: noet sw=4 ts=4 fdm=marker
 568  * vim<600: noet sw=4 ts=4
 569  */