#include "php.h"
#include "php_ini.h"
#include "ext/standard/info.h"
+#include "zend_exceptions.h"
#include "php_psi.h"
#include "parser.h"
STD_PHP_INI_ENTRY("psi.directory", "psi.d", PHP_INI_SYSTEM, OnUpdateString, directory, zend_psi_globals, psi_globals)
PHP_INI_END();
+static zend_object_handlers psi_object_handlers;
+static zend_class_entry *psi_class_entry;
+
void psi_error(int type, const char *msg, ...)
{
char buf[0x1000];
size_t psi_t_alignment(token_t t)
{
- size_t align;
-#define PSI_TAS_D(T) struct PSI_TAS_ ##T { \
- char c; \
- T x; \
-}
-#define PSI_TAS_P(T) struct PSI_TAS_ ## T ## _pointer { \
- char c; \
- T *x; \
-}
-#define PSI_TAS_C(T) align = offsetof(struct PSI_TAS_ ##T, x)
-#define PSI_TAS_CASE(T) { \
- PSI_TAS_D(T); \
- PSI_TAS_C(T); \
-}
+#define PSI_ALIGNOF(T) case PSI_T_## T: return ALIGNOF_## T ##_T;
switch (t) {
- case PSI_T_INT8:
- PSI_TAS_CASE(int8_t);
- break;
- case PSI_T_UINT8:
- PSI_TAS_CASE(uint8_t);
- break;
- case PSI_T_INT16:
- PSI_TAS_CASE(int16_t);
- break;
- case PSI_T_UINT16:
- PSI_TAS_CASE(uint16_t);
- break;
- case PSI_T_INT32:
- PSI_TAS_CASE(int32_t);
- break;
- case PSI_T_UINT32:
- PSI_TAS_CASE(uint32_t);
- break;
- case PSI_T_INT64:
- PSI_TAS_CASE(int64_t);
- break;
- case PSI_T_UINT64:
- PSI_TAS_CASE(uint64_t);
- break;
+ PSI_ALIGNOF(INT8);
+ PSI_ALIGNOF(UINT8);
+ PSI_ALIGNOF(INT16);
+ PSI_ALIGNOF(UINT16);
+ PSI_ALIGNOF(INT32);
+ PSI_ALIGNOF(UINT32);
+ PSI_ALIGNOF(INT64);
+ PSI_ALIGNOF(UINT64);
case PSI_T_FLOAT:
- PSI_TAS_CASE(float);
- break;
+ return ALIGNOF_FLOAT;
case PSI_T_DOUBLE:
- PSI_TAS_CASE(double);
- break;
+ return ALIGNOF_DOUBLE;
case PSI_T_POINTER:
- {
- PSI_TAS_P(char);
- PSI_TAS_C(char_pointer);
- }
- break;
+ return ALIGNOF_VOID_P;
EMPTY_SWITCH_DEFAULT_CASE();
}
-
- return align;
}
size_t psi_t_size(token_t t)
{
- size_t size;
-
+#define PSI_SIZEOF(T) case PSI_T_## T : return SIZEOF_## T ##_T;
switch (t) {
- case PSI_T_INT8:
- case PSI_T_UINT8:
- size = 1;
- break;
- case PSI_T_INT16:
- case PSI_T_UINT16:
- size = 2;
- break;
- case PSI_T_INT:
- size = sizeof(int);
- break;
- case PSI_T_INT32:
- case PSI_T_UINT32:
- size = 4;
- break;
- case PSI_T_INT64:
- case PSI_T_UINT64:
- size = 8;
- break;
+ PSI_SIZEOF(INT8);
+ PSI_SIZEOF(UINT8);
+ PSI_SIZEOF(INT16);
+ PSI_SIZEOF(UINT16);
+ PSI_SIZEOF(INT32);
+ PSI_SIZEOF(UINT32);
+ PSI_SIZEOF(INT64);
+ PSI_SIZEOF(UINT64);
case PSI_T_FLOAT:
- size = sizeof(float);
- break;
+ return SIZEOF_FLOAT;
case PSI_T_DOUBLE:
- size = sizeof(double);
- break;
+ return SIZEOF_DOUBLE;
case PSI_T_POINTER:
- size = sizeof(char *);
- break;
+ return SIZEOF_VOID_P;
EMPTY_SWITCH_DEFAULT_CASE();
}
- return size;
}
size_t psi_t_align(token_t t, size_t s)
return n;
}
-void psi_to_bool(zval *return_value, set_value *set, impl_val *ret_val)
+void psi_to_void(zval *return_value, set_value *set, impl_val *ret_val)
{
- decl_var *var = set->vars->vars[0];
- token_t t = real_decl_type(var->arg->type)->type;
- impl_val *v = deref_impl_val(ret_val, var);
+ RETVAL_NULL();
+}
- switch (t) {
- case PSI_T_FLOAT:
- RETVAL_DOUBLE((double) v->fval);
- break;
- case PSI_T_DOUBLE:
- RETVAL_DOUBLE(v->dval);
- break;
- default:
- RETVAL_LONG(v->lval);
- break;
- }
+void psi_to_bool(zval *return_value, set_value *set, impl_val *ret_val)
+{
+ psi_to_int(return_value, set, ret_val);
convert_to_boolean(return_value);
}
switch (t) {
case PSI_T_FLOAT:
RETVAL_DOUBLE((double) v->fval);
+ convert_to_long(return_value);
break;
case PSI_T_DOUBLE:
RETVAL_DOUBLE(v->dval);
+ convert_to_long(return_value);
break;
- default:
- RETVAL_LONG(v->lval);
- return;
+ case PSI_T_INT8:
+ RETVAL_LONG(v->i8);
+ break;
+ case PSI_T_UINT8:
+ RETVAL_LONG(v->u8);
+ break;
+ case PSI_T_INT16:
+ RETVAL_LONG(v->i16);
+ break;
+ case PSI_T_UINT16:
+ RETVAL_LONG(v->u16);
+ break;
+ case PSI_T_INT32:
+ RETVAL_LONG(v->i32);
+ break;
+ case PSI_T_UINT32:
+#if UINT32_MAX >= ZEND_LONG_MAX
+ if (v->u32 > ZEND_LONG_MAX) {
+ char d[12] = {0};
+
+ RETVAL_STRING(zend_print_ulong_to_buf(&d[10], v->u32));
+ } else {
+#endif
+ RETVAL_LONG(v->u32);
+#if UINT32_MAX >= ZEND_LONG_MAX
+ }
+#endif
+ break;
+ case PSI_T_INT64:
+ RETVAL_LONG(v->i64);
+ break;
+ case PSI_T_UINT64:
+ if (v->u64 > ZEND_LONG_MAX) {
+ char d[24] = {0};
+
+ RETVAL_STRING(zend_print_ulong_to_buf(&d[22], v->u64));
+ } else {
+ RETVAL_LONG(v->u64);
+ }
+ break;
+ EMPTY_SWITCH_DEFAULT_CASE();
}
- convert_to_long(return_value);
}
void psi_to_double(zval *return_value, set_value *set, impl_val *ret_val)
case PSI_T_DOUBLE:
RETVAL_DOUBLE(v->dval);
break;
- default:
- RETVAL_DOUBLE((double) v->lval);
+ case PSI_T_INT8:
+ RETVAL_DOUBLE((double) v->i8);
+ break;
+ case PSI_T_UINT8:
+ RETVAL_DOUBLE((double) v->u8);
+ break;
+ case PSI_T_INT16:
+ RETVAL_DOUBLE((double) v->i16);
+ break;
+ case PSI_T_UINT16:
+ RETVAL_DOUBLE((double) v->u16);
+ break;
+ case PSI_T_INT32:
+ RETVAL_DOUBLE((double) v->i32);
+ break;
+ case PSI_T_UINT32:
+ RETVAL_DOUBLE((double) v->u32);
+ break;
+ case PSI_T_INT64:
+ RETVAL_DOUBLE((double) v->i64);
break;
+ case PSI_T_UINT64:
+ RETVAL_DOUBLE((double) v->u64);
+ break;
+ EMPTY_SWITCH_DEFAULT_CASE();
}
}
token_t t = real_decl_type(var->arg->type)->type;
switch (t) {
+ case PSI_T_VOID:
case PSI_T_INT8:
case PSI_T_UINT8:
if (!var->arg->var->pointer_level) {
RETVAL_DOUBLE(deref_impl_val(ret_val, var)->dval);
break;
default:
- RETVAL_LONG(deref_impl_val(ret_val, var)->lval);
+ psi_to_int(return_value, set, ret_val);
break;
}
convert_to_string(return_value);
} else {
ZEND_ASSERT(0);
}
+}
+void psi_to_object(zval *return_value, set_value *set, impl_val *r_val)
+{
+ decl_var *var = set->vars->vars[0];
+ impl_val *ret_val = deref_impl_val(r_val, var);
+ psi_object *obj;
+
+ if (ret_val->ptr) {
+ object_init_ex(return_value, psi_class_entry);
+ obj = PSI_OBJ(return_value, NULL);
+ obj->data = ret_val->ptr;
+ } else {
+ RETVAL_NULL();
+ }
}
static inline ZEND_RESULT_CODE psi_parse_args(zend_execute_data *execute_data, impl *impl)
{
impl_arg *iarg;
+ zend_error_handling zeh;
+
+ zend_replace_error_handling(EH_THROW, zend_exception_get_default(), &zeh);
if (!impl->func->args->count) {
- return zend_parse_parameters_none();
+ ZEND_RESULT_CODE rv;
+
+ rv = zend_parse_parameters_none();
+ zend_restore_error_handling(&zeh);
+ return rv;
}
ZEND_PARSE_PARAMETERS_START(psi_num_min_args(impl), impl->func->args->count)
}
} else if (PSI_T_ARRAY == iarg->type->type) {
/* handled as _zv in let or set */
- Z_PARAM_PROLOGUE(0);
+ Z_PARAM_ARRAY_EX(iarg->_zv, 1, 0);
+ } else if (PSI_T_OBJECT == iarg->type->type) {
+ Z_PARAM_OBJECT_EX(iarg->_zv, 1, 0);
} else {
error_code = ZPP_ERROR_FAILURE;
break;
if (_i < _max_num_args) {
goto nextarg;
}
- ZEND_PARSE_PARAMETERS_END_EX(return FAILURE);
+ ZEND_PARSE_PARAMETERS_END_EX(
+ zend_restore_error_handling(&zeh);
+ return FAILURE
+ );
+ zend_restore_error_handling(&zeh);
return SUCCESS;
}
arg_val->lval = zval_get_long(iarg->_zv);
}
break;
+ case PSI_T_PATHVAL:
case PSI_T_STRVAL:
if (iarg->type->type == PSI_T_STRING) {
arg_val->ptr = estrdup(iarg->val.zend.str->val);
darg->let->mem = arg_val->ptr;
zend_string_release(zs);
}
+ if (PSI_T_PATHVAL == darg->let->val->func->type) {
+ if (SUCCESS != php_check_open_basedir(arg_val->ptr)) {
+ efree(arg_val->ptr);
+ return NULL;
+ }
+ }
break;
case PSI_T_STRLEN:
if (iarg->type->type == PSI_T_STRING) {
}
}
break;
+ case PSI_T_OBJVAL:
+ if (iarg->type->type == PSI_T_OBJECT) {
+ psi_object *obj;
+
+ if (!instanceof_function(Z_OBJCE_P(iarg->_zv), psi_class_entry)) {
+ return NULL;
+ }
+
+ obj = PSI_OBJ(iarg->_zv, NULL);
+ arg_val->ptr = obj->data;
+ }
+ break;
EMPTY_SWITCH_DEFAULT_CASE();
}
}
for (i = 0; i < impl->decl->args->count; ++i) {
decl_arg *darg = impl->decl->args->args[i];
- impl->decl->call.args[i] = psi_do_let(darg);
+ if (!(impl->decl->call.args[i] = psi_do_let(darg))) {
+ goto cleanup;
+ }
}
}
psi_do_free(fre);
}
+ psi_do_clean(impl);
+ return;
+cleanup:
+ memset(&ret_val, 0, sizeof(ret_val));
+ psi_do_return(return_value, impl->stmts->ret.list[0], &ret_val);
psi_do_clean(impl);
}
+static void psi_object_free(zend_object *o)
+{
+ psi_object *obj = PSI_OBJ(NULL, o);
+
+ if (obj->data) {
+ // free(obj->data);
+ obj->data = NULL;
+ }
+ zend_object_std_dtor(o);
+}
+
+static zend_object *psi_object_init(zend_class_entry *ce)
+{
+ psi_object *o = ecalloc(1, sizeof(*o) + zend_object_properties_size(ce));
+
+ zend_object_std_init(&o->std, ce);
+ object_properties_init(&o->std, ce);
+ o->std.handlers = &psi_object_handlers;
+ return &o->std;
+}
+
PHP_MINIT_FUNCTION(psi)
{
PSI_ContextOps *ops = NULL;
+ zend_class_entry ce = {0};
REGISTER_INI_ENTRIES();
+ INIT_NS_CLASS_ENTRY(ce, "psi", "object", NULL);
+ psi_class_entry = zend_register_internal_class_ex(&ce, NULL);
+ psi_class_entry->create_object = psi_object_init;
+
+ memcpy(&psi_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
+ psi_object_handlers.offset = XtOffsetOf(psi_object, std);
+ psi_object_handlers.free_obj = psi_object_free;
+ psi_object_handlers.clone_obj = NULL;
+
#ifdef HAVE_LIBJIT
if (!strcasecmp(PSI_G(engine), "jit")) {
ops = PSI_Libjit();
PSI_ContextInit(&PSI_G(context), ops, psi_error);
PSI_ContextBuild(&PSI_G(context), PSI_G(directory));
- if (getenv("PSI_DUMP")) {
+ if (psi_check_env("PSI_DUMP")) {
PSI_ContextDump(&PSI_G(context), STDOUT_FILENO);
}
projects / m6w6 / ext-psi / blobdiff