void avbv_v(lhs_rhs_element & vec1, lhs_rhs_element const & vec2, ScalarType1 const & alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha, lhs_rhs_element const & vec3, ScalarType2 const & beta, vcl_size_t len_beta, bool reciprocal_beta, bool flip_sign_beta) { assert( vec1.type_family == VECTOR_TYPE_FAMILY && vec1.subtype == DENSE_VECTOR_TYPE && vec2.type_family == VECTOR_TYPE_FAMILY && vec2.subtype == DENSE_VECTOR_TYPE && vec3.type_family == VECTOR_TYPE_FAMILY && vec3.subtype == DENSE_VECTOR_TYPE && bool("Arguments are not vector types!")); switch (vec1.numeric_type) { case FLOAT_TYPE: assert(vec2.numeric_type == FLOAT_TYPE && vec3.numeric_type == FLOAT_TYPE && bool("Vectors do not have the same scalar type")); viennacl::linalg::avbv_v(*vec1.vector_float, *vec2.vector_float, convert_to_float(alpha), len_alpha, reciprocal_alpha, flip_sign_alpha, *vec3.vector_float, convert_to_float(beta), len_beta, reciprocal_beta, flip_sign_beta); break; case DOUBLE_TYPE: assert(vec2.numeric_type == DOUBLE_TYPE && vec3.numeric_type == DOUBLE_TYPE && bool("Vectors do not have the same scalar type")); viennacl::linalg::avbv_v(*vec1.vector_double, *vec2.vector_double, convert_to_double(alpha), len_alpha, reciprocal_alpha, flip_sign_alpha, *vec3.vector_double, convert_to_double(beta), len_beta, reciprocal_beta, flip_sign_beta); break; default: throw statement_not_supported_exception("Invalid arguments in scheduler when calling avbv_v()"); } }
/* {{{ proto double pow(double base, double exponent) Returns base raised to the power of expopent */ void php3_pow(INTERNAL_FUNCTION_PARAMETERS) { pval *num1, *num2; TLS_VARS; if (ARG_COUNT(ht) != 2 || getParameters(ht,2,&num1,&num2) == FAILURE) { WRONG_PARAM_COUNT; } convert_to_double(num1); convert_to_double(num2); RETURN_DOUBLE(pow(num1->value.dval, num2->value.dval)); }
/* {{{ proto double atan2(double y, double x) Returns the arc tangent of y/x, with the resulting quadrant determined by the signs of y and x */ void php3_atan2(INTERNAL_FUNCTION_PARAMETERS) { pval *num1, *num2; if (ARG_COUNT(ht) != 2 || getParameters(ht, 2, &num1, &num2) == FAILURE) { WRONG_PARAM_COUNT; } convert_to_double(num1); convert_to_double(num2); return_value->value.dval = atan2(num1->value.dval,num2->value.dval); return_value->type = IS_DOUBLE; }
static PHP_METHOD(swoole_table, set) { zval *array; char *key; zend_size_t keylen; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sa", &key, &keylen, &array) == FAILURE) { RETURN_FALSE; } swTable *table = swoole_get_object(getThis()); if (!table->memory) { swoole_php_fatal_error(E_ERROR, "Must create table first."); RETURN_FALSE; } sw_atomic_t *_lock = NULL; swTableRow *row = swTableRow_set(table, key, keylen, &_lock); if (!row) { sw_spinlock_release(_lock); swoole_php_error(E_WARNING, "Unable to allocate memory."); RETURN_FALSE; } swTableColumn *col; zval *v; char *k; uint32_t klen; int ktype; HashTable *_ht = Z_ARRVAL_P(array); SW_HASHTABLE_FOREACH_START2(_ht, k, klen, ktype, v) { col = swTableColumn_get(table, k, klen); if (k == NULL || col == NULL) { continue; } else if (col->type == SW_TABLE_STRING) { convert_to_string(v); swTableRow_set_value(row, col, Z_STRVAL_P(v), Z_STRLEN_P(v)); } else if (col->type == SW_TABLE_FLOAT) { convert_to_double(v); swTableRow_set_value(row, col, &Z_DVAL_P(v), 0); } else { convert_to_long(v); swTableRow_set_value(row, col, &Z_LVAL_P(v), 0); } }
VALUE php_value_to_float(VALUE self) { zval *zv = get_zval(self); if (zv) { convert_to_double(zv); return rb_float_new(Z_DVAL_P(zv)); } return Qnil; }
void php_array_add_sum_double(zval *row, zval *data1, zval *data2) { double x1, x2; zval temp; temp = *data1; zval_copy_ctor(&temp); convert_to_double(&temp); x1 = Z_DVAL(temp); zval_dtor(&temp); temp = *data2; zval_copy_ctor(&temp); convert_to_double(&temp); x2 = Z_DVAL(temp); zval_dtor(&temp); add_next_index_double(row, x1 + x2); }
/* {{{ proto int symbol.setpoints(array points) Set the points of the symbol ) */ PHP_METHOD(symbolObj, setPoints) { zval *zpoints, **ppzval; HashTable *points_hash = NULL; zval *zobj = getThis(); int index = 0, flag = 0, numelements = 0; php_symbol_object *php_symbol; PHP_MAPSCRIPT_ERROR_HANDLING(TRUE); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &zpoints) == FAILURE) { PHP_MAPSCRIPT_RESTORE_ERRORS(TRUE); return; } PHP_MAPSCRIPT_RESTORE_ERRORS(TRUE); php_symbol = (php_symbol_object *) zend_object_store_get_object(zobj TSRMLS_CC); points_hash = Z_ARRVAL_P(zpoints); numelements = zend_hash_num_elements(points_hash); if ((numelements == 0) || (numelements % 2 != 0)) { mapscript_report_php_error(E_WARNING, "symbol->setpoints : invalid array of %d element(s) as parameter." TSRMLS_CC, numelements); RETURN_LONG(MS_FAILURE); } for(zend_hash_internal_pointer_reset(points_hash); zend_hash_has_more_elements(points_hash) == SUCCESS; zend_hash_move_forward(points_hash)) { zend_hash_get_current_data(points_hash, (void **)&ppzval); if (Z_TYPE_PP(ppzval) != IS_DOUBLE) convert_to_double(*ppzval); if (!flag) { php_symbol->symbol->points[index].x = Z_DVAL_PP(ppzval); php_symbol->symbol->sizex = MS_MAX(php_symbol->symbol->sizex, php_symbol->symbol->points[index].x); } else { php_symbol->symbol->points[index].y = Z_DVAL_PP(ppzval); php_symbol->symbol->sizey = MS_MAX(php_symbol->symbol->sizey, php_symbol->symbol->points[index].y); index++; } flag = !flag; } php_symbol->symbol->numpoints = (numelements/2); RETURN_LONG(MS_SUCCESS); }
/* {{{ proto string number_format(double number [, int num_decimal_places [, string dec_separator, string thousands_separator]]) Formats a number with grouped thousands */ void php3_number_format(INTERNAL_FUNCTION_PARAMETERS) { pval *num,*dec,*t_s,*d_p; char thousand_sep=',', dec_point='.'; switch(ARG_COUNT(ht)) { case 1: if (getParameters(ht, 1, &num)==FAILURE) { RETURN_FALSE; } convert_to_double(num); RETURN_STRING(_php3_number_format(num->value.dval,0,dec_point,thousand_sep),0); break; case 2: if (getParameters(ht, 2, &num, &dec)==FAILURE) { RETURN_FALSE; } convert_to_double(num); convert_to_long(dec); RETURN_STRING(_php3_number_format(num->value.dval,dec->value.lval,dec_point,thousand_sep),0); break; case 4: if (getParameters(ht, 4, &num, &dec, &d_p, &t_s)==FAILURE) { RETURN_FALSE; } convert_to_double(num); convert_to_long(dec); convert_to_string(d_p); convert_to_string(t_s); if (d_p->value.str.len==1) { dec_point=d_p->value.str.val[0]; } if (t_s->value.str.len==1) { thousand_sep=t_s->value.str.val[0]; } RETURN_STRING(_php3_number_format(num->value.dval,dec->value.lval,dec_point,thousand_sep),0); break; default: WRONG_PARAM_COUNT; break; } }
/* {{{ proto double deg2rad(double number) Converts the number in degrees to the radian equivalent */ void php3_deg2rad(INTERNAL_FUNCTION_PARAMETERS) { pval *deg; TLS_VARS; if (ARG_COUNT(ht) != 1 || getParameters(ht, 1, °) == FAILURE) { WRONG_PARAM_COUNT; } convert_to_double(deg); RETVAL_DOUBLE((deg->value.dval / 180.0) * M_PI); }
/* {{{ proto double sqrt(double number) Returns the square root of the number */ void php3_sqrt(INTERNAL_FUNCTION_PARAMETERS) { pval *num; if (ARG_COUNT(ht) != 1 || getParameters(ht, 1, &num) == FAILURE) { WRONG_PARAM_COUNT; } convert_to_double(num); return_value->value.dval = sqrt(num->value.dval); return_value->type = IS_DOUBLE; }
/* {{{ proto double rad2deg(double number) Converts the radian number to the equivalent number in degrees */ void php3_rad2deg(INTERNAL_FUNCTION_PARAMETERS) { pval *rad; TLS_VARS; if (ARG_COUNT(ht) != 1 || getParameters(ht, 1, &rad) == FAILURE) { WRONG_PARAM_COUNT; } convert_to_double(rad); RETVAL_DOUBLE((rad->value.dval / M_PI) * 180); }
/* {{{ cfg_get_double */ PHPAPI int cfg_get_double(const char *varname, double *result) { zval *tmp, var; if ((tmp = zend_hash_str_find(&configuration_hash, varname, strlen(varname))) == NULL) { *result = (double) 0; return FAILURE; } ZVAL_DUP(&var, tmp); convert_to_double(&var); *result = Z_DVAL(var); return SUCCESS; }
PHPAPI int cfg_get_double(char *varname,double *result) { zval *tmp,var; if (zend_hash_find(&configuration_hash,varname,strlen(varname)+1,(void **) &tmp)==FAILURE) { *result=(double)0; return FAILURE; } var = *tmp; zval_copy_ctor(&var); convert_to_double(&var); *result = var.value.dval; return SUCCESS; }
/* * (x, y) style sequence to the corresponding variables * * */ int sequence_to_doubles(PyObject* seq, double* x, double* y) { PyObject *fastseq=PySequence_Fast(seq, ""); PyObject *py_x; PyObject *py_y; if (!fastseq) { PyErr_Clear(); return 0; } py_x=PySequence_Fast_GET_ITEM(fastseq, 0); if (!convert_to_double(py_x, x)) { Py_XDECREF(fastseq); return 0; } py_y=PySequence_Fast_GET_ITEM(fastseq, 1); if (!convert_to_double(py_y, y)) { Py_XDECREF(fastseq); return 0; } Py_XDECREF(fastseq); return 1; }
void as(lhs_rhs_element & s1, lhs_rhs_element const & s2, ScalarType1 const & alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha) { assert( s1.type_family == SCALAR_TYPE_FAMILY && (s1.subtype == HOST_SCALAR_TYPE || s1.subtype == DEVICE_SCALAR_TYPE) && s2.type_family == SCALAR_TYPE_FAMILY && (s2.subtype == HOST_SCALAR_TYPE || s2.subtype == DEVICE_SCALAR_TYPE) && bool("Arguments are not vector types!")); switch (s1.numeric_type) { case FLOAT_TYPE: assert(s2.numeric_type == FLOAT_TYPE && bool("Vectors do not have the same scalar type")); viennacl::linalg::av(*s1.vector_float, *s2.vector_float, convert_to_float(alpha), len_alpha, reciprocal_alpha, flip_sign_alpha); break; case DOUBLE_TYPE: assert(s2.numeric_type == DOUBLE_TYPE && bool("Vectors do not have the same scalar type")); viennacl::linalg::av(*s1.vector_double, *s2.vector_double, convert_to_double(alpha), len_alpha, reciprocal_alpha, flip_sign_alpha); break; default: throw statement_not_supported_exception("Invalid arguments in scheduler when calling av()"); } }
/* {{{ proto bool GmagickDraw::affine(array affine) Adjusts the current affine transformation matrix with the specified affine transformation matrix. Note that the current affine transform is adjusted rather than replaced. */ PHP_METHOD(gmagickdraw, affine) { php_gmagickdraw_object *internd; zval *affine_matrix, **ppzval; HashTable *affine; char *matrix_elements[] = { "sx", "rx", "ry", "sy", "tx", "ty" }; int i; double value; AffineMatrix *pmatrix; /* Parse parameters given to function */ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &affine_matrix) == FAILURE) { return; } /* Allocate space to build matrix */ pmatrix = emalloc(sizeof(AffineMatrix)); affine = Z_ARRVAL_P(affine_matrix); zend_hash_internal_pointer_reset_ex(affine, (HashPosition *) 0); for (i = 0; i < 6 ; i++) { if (zend_hash_find(affine, matrix_elements[i], 3, (void**)&ppzval) == FAILURE) { efree(pmatrix); GMAGICK_THROW_EXCEPTION_WITH_MESSAGE(GMAGICKDRAW_CLASS, "AffineMatrix should contain keys: sx, rx, ry, sy, tx and ty", 2); } else { zval tmp_zval, *tmp_pzval; tmp_zval = **ppzval; zval_copy_ctor(&tmp_zval); tmp_pzval = &tmp_zval; convert_to_double(tmp_pzval); value = Z_DVAL(tmp_zval); if (strcmp(matrix_elements[i], "sx") == 0) { pmatrix->sx = value; } else if (strcmp(matrix_elements[i], "rx") == 0) { pmatrix->rx = value; } else if (strcmp(matrix_elements[i], "ry") == 0) { pmatrix->ry = value; } else if (strcmp(matrix_elements[i], "sy") == 0) { pmatrix->sy = value; } else if (strcmp(matrix_elements[i], "tx") == 0) { pmatrix->tx = value; } else if (strcmp(matrix_elements[i], "ty") == 0) { pmatrix->ty = value; } } } internd = (php_gmagickdraw_object *) zend_object_store_get_object(getThis() TSRMLS_CC); DrawAffine(internd->drawing_wand, pmatrix); efree(pmatrix); RETURN_TRUE; }
static PHP_METHOD(swoole_redis, __construct) { zval *zset = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &zset) == FAILURE) { return; } swRedisClient *redis = emalloc(sizeof(swRedisClient)); bzero(redis, sizeof(swRedisClient)); redis->object = getThis(); redis->timeout = SW_REDIS_CONNECT_TIMEOUT; redis->database = -1; if (zset && !ZVAL_IS_NULL(zset)) { php_swoole_array_separate(zset); zend_update_property(swoole_redis_class_entry_ptr, getThis(), ZEND_STRL("setting"), zset TSRMLS_CC); sw_zval_ptr_dtor(&zset); HashTable *vht; zval *ztmp; vht = Z_ARRVAL_P(zset); /** * timeout */ if (php_swoole_array_get_value(vht, "timeout", ztmp)) { convert_to_double(ztmp); redis->timeout = (double) Z_DVAL_P(ztmp); } /** * password */ if (php_swoole_array_get_value(vht, "password", ztmp)) { convert_to_string(ztmp); if (Z_STRLEN_P(ztmp) >= 1 << 8) { swoole_php_fatal_error(E_WARNING, "redis password is too long."); } else if (Z_STRLEN_P(ztmp) > 0) { redis->password = estrdup(Z_STRVAL_P(ztmp)); redis->password_len = Z_STRLEN_P(ztmp); } } /** * database */ if (php_swoole_array_get_value(vht, "database", ztmp)) { convert_to_long(ztmp); if (Z_LVAL_P(ztmp) > 1 << 8) { swoole_php_fatal_error(E_WARNING, "redis database number is too big."); } else { redis->database = (int8_t) Z_LVAL_P(ztmp); } } } sw_copy_to_stack(redis->object, redis->_object); swoole_set_object(getThis(), redis); }
/* php_formatted_print() {{{ * New sprintf implementation for PHP. * * Modifiers: * * " " pad integers with spaces * "-" left adjusted field * n field size * "."n precision (floats only) * "+" Always place a sign (+ or -) in front of a number * * Type specifiers: * * "%" literal "%", modifiers are ignored. * "b" integer argument is printed as binary * "c" integer argument is printed as a single character * "d" argument is an integer * "f" the argument is a float * "o" integer argument is printed as octal * "s" argument is a string * "x" integer argument is printed as lowercase hexadecimal * "X" integer argument is printed as uppercase hexadecimal * */ static char * php_formatted_print(int ht, int *len, int use_array, int format_offset TSRMLS_DC) { zval ***args, **z_format; int argc, size = 240, inpos = 0, outpos = 0, temppos; int alignment, currarg, adjusting, argnum, width, precision; char *format, *result, padding; int always_sign; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "+", &args, &argc) == FAILURE) { return NULL; } /* verify the number of args */ if ((use_array && argc != (2 + format_offset)) || (!use_array && argc < (1 + format_offset))) { efree(args); WRONG_PARAM_COUNT_WITH_RETVAL(NULL); } if (use_array) { int i = 1; zval ***newargs; zval **array; z_format = args[format_offset]; array = args[1 + format_offset]; SEPARATE_ZVAL(array); convert_to_array_ex(array); argc = 1 + zend_hash_num_elements(Z_ARRVAL_PP(array)); newargs = (zval ***)safe_emalloc(argc, sizeof(zval *), 0); newargs[0] = z_format; for (zend_hash_internal_pointer_reset(Z_ARRVAL_PP(array)); zend_hash_get_current_data(Z_ARRVAL_PP(array), (void **)&newargs[i++]) == SUCCESS; zend_hash_move_forward(Z_ARRVAL_PP(array))); efree(args); args = newargs; format_offset = 0; } convert_to_string_ex(args[format_offset]); format = Z_STRVAL_PP(args[format_offset]); result = emalloc(size); currarg = 1; while (inpos<Z_STRLEN_PP(args[format_offset])) { int expprec = 0, multiuse = 0; zval *tmp; PRINTF_DEBUG(("sprintf: format[%d]='%c'\n", inpos, format[inpos])); PRINTF_DEBUG(("sprintf: outpos=%d\n", outpos)); if (format[inpos] != '%') { php_sprintf_appendchar(&result, &outpos, &size, format[inpos++] TSRMLS_CC); } else if (format[inpos + 1] == '%') { php_sprintf_appendchar(&result, &outpos, &size, '%' TSRMLS_CC); inpos += 2; } else { /* starting a new format specifier, reset variables */ alignment = ALIGN_RIGHT; adjusting = 0; padding = ' '; always_sign = 0; inpos++; /* skip the '%' */ PRINTF_DEBUG(("sprintf: first looking at '%c', inpos=%d\n", format[inpos], inpos)); if (isascii((int)format[inpos]) && !isalpha((int)format[inpos])) { /* first look for argnum */ temppos = inpos; while (isdigit((int)format[temppos])) temppos++; if (format[temppos] == '$') { argnum = php_sprintf_getnumber(format, &inpos); if (argnum <= 0) { efree(result); efree(args); php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument number must be greater than zero"); return NULL; } multiuse = 1; inpos++; /* skip the '$' */ } else { argnum = currarg++; } argnum += format_offset; /* after argnum comes modifiers */ PRINTF_DEBUG(("sprintf: looking for modifiers\n" "sprintf: now looking at '%c', inpos=%d\n", format[inpos], inpos)); for (;; inpos++) { if (format[inpos] == ' ' || format[inpos] == '0') { padding = format[inpos]; } else if (format[inpos] == '-') { alignment = ALIGN_LEFT; /* space padding, the default */ } else if (format[inpos] == '+') { always_sign = 1; } else if (format[inpos] == '\'') { padding = format[++inpos]; } else { PRINTF_DEBUG(("sprintf: end of modifiers\n")); break; } } PRINTF_DEBUG(("sprintf: padding='%c'\n", padding)); PRINTF_DEBUG(("sprintf: alignment=%s\n", (alignment == ALIGN_LEFT) ? "left" : "right")); /* after modifiers comes width */ if (isdigit((int)format[inpos])) { PRINTF_DEBUG(("sprintf: getting width\n")); if ((width = php_sprintf_getnumber(format, &inpos)) < 0) { efree(result); efree(args); php_error_docref(NULL TSRMLS_CC, E_WARNING, "Width must be greater than zero and less than %d", INT_MAX); return NULL; } adjusting |= ADJ_WIDTH; } else { width = 0; } PRINTF_DEBUG(("sprintf: width=%d\n", width)); /* after width and argnum comes precision */ if (format[inpos] == '.') { inpos++; PRINTF_DEBUG(("sprintf: getting precision\n")); if (isdigit((int)format[inpos])) { if ((precision = php_sprintf_getnumber(format, &inpos)) < 0) { efree(result); efree(args); php_error_docref(NULL TSRMLS_CC, E_WARNING, "Precision must be greater than zero and less than %d", INT_MAX); return NULL; } adjusting |= ADJ_PRECISION; expprec = 1; } else { precision = 0; } } else { precision = 0; } PRINTF_DEBUG(("sprintf: precision=%d\n", precision)); } else { width = precision = 0; argnum = currarg++ + format_offset; } if (argnum >= argc) { efree(result); efree(args); php_error_docref(NULL TSRMLS_CC, E_WARNING, "Too few arguments"); return NULL; } if (format[inpos] == 'l') { inpos++; } PRINTF_DEBUG(("sprintf: format character='%c'\n", format[inpos])); /* now we expect to find a type specifier */ if (multiuse) { MAKE_STD_ZVAL(tmp); *tmp = **(args[argnum]); INIT_PZVAL(tmp); zval_copy_ctor(tmp); } else { SEPARATE_ZVAL(args[argnum]); tmp = *(args[argnum]); } switch (format[inpos]) { case 's': { zval *var, var_copy; int use_copy; zend_make_printable_zval(tmp, &var_copy, &use_copy); if (use_copy) { var = &var_copy; } else { var = tmp; } php_sprintf_appendstring(&result, &outpos, &size, Z_STRVAL_P(var), width, precision, padding, alignment, Z_STRLEN_P(var), 0, expprec, 0); if (use_copy) { zval_dtor(&var_copy); } break; } case 'd': convert_to_long(tmp); php_sprintf_appendint(&result, &outpos, &size, Z_LVAL_P(tmp), width, padding, alignment, always_sign); break; case 'u': convert_to_long(tmp); php_sprintf_appenduint(&result, &outpos, &size, Z_LVAL_P(tmp), width, padding, alignment); break; case 'g': case 'G': case 'e': case 'E': case 'f': case 'F': convert_to_double(tmp); php_sprintf_appenddouble(&result, &outpos, &size, Z_DVAL_P(tmp), width, padding, alignment, precision, adjusting, format[inpos], always_sign TSRMLS_CC); break; case 'c': convert_to_long(tmp); php_sprintf_appendchar(&result, &outpos, &size, (char) Z_LVAL_P(tmp) TSRMLS_CC); break; case 'o': convert_to_long(tmp); php_sprintf_append2n(&result, &outpos, &size, Z_LVAL_P(tmp), width, padding, alignment, 3, hexchars, expprec); break; case 'x': convert_to_long(tmp); php_sprintf_append2n(&result, &outpos, &size, Z_LVAL_P(tmp), width, padding, alignment, 4, hexchars, expprec); break; case 'X': convert_to_long(tmp); php_sprintf_append2n(&result, &outpos, &size, Z_LVAL_P(tmp), width, padding, alignment, 4, HEXCHARS, expprec); break; case 'b': convert_to_long(tmp); php_sprintf_append2n(&result, &outpos, &size, Z_LVAL_P(tmp), width, padding, alignment, 1, hexchars, expprec); break; case '%': php_sprintf_appendchar(&result, &outpos, &size, '%' TSRMLS_CC); break; default: break; } if (multiuse) { zval_ptr_dtor(&tmp); } inpos++; } } efree(args); /* possibly, we have to make sure we have room for the terminating null? */ result[outpos]=0; *len = outpos; return result; }
static PHP_METHOD(swoole_mysql, connect) { zval *server_info; zval *callback; char buf[2048]; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "az", &server_info, &callback) == FAILURE) { RETURN_FALSE; } HashTable *_ht = Z_ARRVAL_P(server_info); zval *value; mysql_client *client = swoole_get_object(getThis()); mysql_connector *connector = &client->connector; if (php_swoole_array_get_value(_ht, "host", value)) { convert_to_string(value); connector->host = Z_STRVAL_P(value); connector->host_len = Z_STRLEN_P(value); } else { zend_throw_exception(swoole_mysql_exception_class_entry, "HOST parameter is required.", 11 TSRMLS_CC); RETURN_FALSE; } if (php_swoole_array_get_value(_ht, "port", value)) { convert_to_long(value); connector->port = Z_LVAL_P(value); } else { connector->port = SW_MYSQL_DEFAULT_PORT; } if (php_swoole_array_get_value(_ht, "user", value)) { convert_to_string(value); connector->user = Z_STRVAL_P(value); connector->user_len = Z_STRLEN_P(value); } else { zend_throw_exception(swoole_mysql_exception_class_entry, "USER parameter is required.", 11 TSRMLS_CC); RETURN_FALSE; } if (php_swoole_array_get_value(_ht, "password", value)) { convert_to_string(value); connector->password = Z_STRVAL_P(value); connector->password_len = Z_STRLEN_P(value); } else { zend_throw_exception(swoole_mysql_exception_class_entry, "PASSWORD parameter is required.", 11 TSRMLS_CC); RETURN_FALSE; } if (php_swoole_array_get_value(_ht, "database", value)) { convert_to_string(value); connector->database = Z_STRVAL_P(value); connector->database_len = Z_STRLEN_P(value); } else { zend_throw_exception(swoole_mysql_exception_class_entry, "DATABASE parameter is required.", 11 TSRMLS_CC); RETURN_FALSE; } if (php_swoole_array_get_value(_ht, "timeout", value)) { convert_to_double(value); connector->timeout = Z_DVAL_P(value); } else { connector->timeout = SW_MYSQL_CONNECT_TIMEOUT; } if (php_swoole_array_get_value(_ht, "charset", value)) { convert_to_string(value); connector->character_set = mysql_get_charset(Z_STRVAL_P(value)); if (connector->character_set < 0) { snprintf(buf, sizeof(buf), "unknown charset [%s].", Z_STRVAL_P(value)); zend_throw_exception(swoole_mysql_exception_class_entry, buf, 11 TSRMLS_CC); RETURN_FALSE; } } else { connector->character_set = SW_MYSQL_DEFAULT_CHARSET; } swClient *cli = emalloc(sizeof(swClient)); int type = SW_SOCK_TCP; if (strncasecmp(connector->host, ZEND_STRL("unix:/")) == 0) { connector->host = connector->host + 5; connector->host_len = connector->host_len - 5; type = SW_SOCK_UNIX_STREAM; } else if (strchr(connector->host, ':')) { type = SW_SOCK_TCP6; } php_swoole_check_reactor(); if (!isset_event_callback) { SwooleG.main_reactor->setHandle(SwooleG.main_reactor, PHP_SWOOLE_FD_MYSQL | SW_EVENT_READ, swoole_mysql_onRead); SwooleG.main_reactor->setHandle(SwooleG.main_reactor, PHP_SWOOLE_FD_MYSQL | SW_EVENT_WRITE, swoole_mysql_onWrite); SwooleG.main_reactor->setHandle(SwooleG.main_reactor, PHP_SWOOLE_FD_MYSQL | SW_EVENT_ERROR, swoole_mysql_onError); } if (swClient_create(cli, type, 0) < 0) { zend_throw_exception(swoole_mysql_exception_class_entry, "swClient_create failed.", 1 TSRMLS_CC); RETURN_FALSE; } int tcp_nodelay = 1; if (setsockopt(cli->socket->fd, IPPROTO_TCP, TCP_NODELAY, (const void *) &tcp_nodelay, sizeof(int)) == -1) { swoole_php_sys_error(E_WARNING, "setsockopt(%d, IPPROTO_TCP, TCP_NODELAY) failed.", cli->socket->fd); } int ret = cli->connect(cli, connector->host, connector->port, connector->timeout, 1); if ((ret < 0 && errno == EINPROGRESS) || ret == 0) { if (SwooleG.main_reactor->add(SwooleG.main_reactor, cli->socket->fd, PHP_SWOOLE_FD_MYSQL | SW_EVENT_WRITE) < 0) { RETURN_FALSE; } } else { snprintf(buf, sizeof(buf), "connect to mysql server[%s:%d] failed.", connector->host, connector->port); zend_throw_exception(swoole_mysql_exception_class_entry, buf, 2 TSRMLS_CC); RETURN_FALSE; } zend_update_property(swoole_mysql_class_entry_ptr, getThis(), ZEND_STRL("onConnect"), callback TSRMLS_CC); zend_update_property(swoole_mysql_class_entry_ptr, getThis(), ZEND_STRL("serverInfo"), server_info TSRMLS_CC); zend_update_property_long(swoole_mysql_class_entry_ptr, getThis(), ZEND_STRL("sock"), cli->socket->fd TSRMLS_CC); client->buffer = swString_new(SW_BUFFER_SIZE_BIG); client->fd = cli->socket->fd; client->object = getThis(); client->cli = cli; sw_copy_to_stack(client->object, client->_object); sw_zval_add_ref(&client->object); swConnection *_socket = swReactor_get(SwooleG.main_reactor, cli->socket->fd); _socket->object = client; _socket->active = 0; RETURN_TRUE; }
void binary_serialize(int8_t thrift_typeID, PHPOutputTransport& transport, zval** value, HashTable* fieldspec) { // At this point the typeID (and field num, if applicable) should've already been written to the output so all we need to do is write the payload. switch (thrift_typeID) { case T_STOP: case T_VOID: return; case T_STRUCT: { TSRMLS_FETCH(); if (Z_TYPE_PP(value) != IS_OBJECT) { throw_tprotocolexception("Attempt to send non-object type as a T_STRUCT", INVALID_DATA); } zval* spec = zend_read_static_property(zend_get_class_entry(*value TSRMLS_CC), "_TSPEC", 6, false TSRMLS_CC); binary_serialize_spec(*value, transport, Z_ARRVAL_P(spec)); } return; case T_BOOL: if (Z_TYPE_PP(value) != IS_BOOL) convert_to_boolean(*value); transport.writeI8(Z_BVAL_PP(value) ? 1 : 0); return; case T_BYTE: if (Z_TYPE_PP(value) != IS_LONG) convert_to_long(*value); transport.writeI8(Z_LVAL_PP(value)); return; case T_I16: if (Z_TYPE_PP(value) != IS_LONG) convert_to_long(*value); transport.writeI16(Z_LVAL_PP(value)); return; case T_I32: if (Z_TYPE_PP(value) != IS_LONG) convert_to_long(*value); transport.writeI32(Z_LVAL_PP(value)); return; case T_I64: case T_U64: if (Z_TYPE_PP(value) != IS_LONG) convert_to_long(*value); transport.writeI64(Z_LVAL_PP(value)); return; case T_DOUBLE: { union { int64_t c; double d; } a; if (Z_TYPE_PP(value) != IS_DOUBLE) convert_to_double(*value); a.d = Z_DVAL_PP(value); transport.writeI64(a.c); } return; //case T_UTF7: case T_UTF8: case T_UTF16: case T_STRING: if (Z_TYPE_PP(value) != IS_STRING) convert_to_string(*value); transport.writeString(Z_STRVAL_PP(value), Z_STRLEN_PP(value)); return; case T_MAP: { if (Z_TYPE_PP(value) != IS_ARRAY) convert_to_array(*value); if (Z_TYPE_PP(value) != IS_ARRAY) { throw_tprotocolexception("Attempt to send an incompatible type as an array (T_MAP)", INVALID_DATA); } HashTable* ht = Z_ARRVAL_PP(value); zval** val_ptr; zend_hash_find(fieldspec, "ktype", 6, (void**)&val_ptr); if (Z_TYPE_PP(val_ptr) != IS_LONG) convert_to_long(*val_ptr); uint8_t keytype = Z_LVAL_PP(val_ptr); transport.writeI8(keytype); zend_hash_find(fieldspec, "vtype", 6, (void**)&val_ptr); if (Z_TYPE_PP(val_ptr) != IS_LONG) convert_to_long(*val_ptr); uint8_t valtype = Z_LVAL_PP(val_ptr); transport.writeI8(valtype); zend_hash_find(fieldspec, "val", 4, (void**)&val_ptr); HashTable* valspec = Z_ARRVAL_PP(val_ptr); transport.writeI32(zend_hash_num_elements(ht)); HashPosition key_ptr; for (zend_hash_internal_pointer_reset_ex(ht, &key_ptr); zend_hash_get_current_data_ex(ht, (void**)&val_ptr, &key_ptr) == SUCCESS; zend_hash_move_forward_ex(ht, &key_ptr)) { binary_serialize_hashtable_key(keytype, transport, ht, key_ptr); binary_serialize(valtype, transport, val_ptr, valspec); } } return; case T_LIST: { if (Z_TYPE_PP(value) != IS_ARRAY) convert_to_array(*value); if (Z_TYPE_PP(value) != IS_ARRAY) { throw_tprotocolexception("Attempt to send an incompatible type as an array (T_LIST)", INVALID_DATA); } HashTable* ht = Z_ARRVAL_PP(value); zval** val_ptr; zend_hash_find(fieldspec, "etype", 6, (void**)&val_ptr); if (Z_TYPE_PP(val_ptr) != IS_LONG) convert_to_long(*val_ptr); uint8_t valtype = Z_LVAL_PP(val_ptr); transport.writeI8(valtype); zend_hash_find(fieldspec, "elem", 5, (void**)&val_ptr); HashTable* valspec = Z_ARRVAL_PP(val_ptr); transport.writeI32(zend_hash_num_elements(ht)); HashPosition key_ptr; for (zend_hash_internal_pointer_reset_ex(ht, &key_ptr); zend_hash_get_current_data_ex(ht, (void**)&val_ptr, &key_ptr) == SUCCESS; zend_hash_move_forward_ex(ht, &key_ptr)) { binary_serialize(valtype, transport, val_ptr, valspec); } } return; case T_SET: { if (Z_TYPE_PP(value) != IS_ARRAY) convert_to_array(*value); if (Z_TYPE_PP(value) != IS_ARRAY) { throw_tprotocolexception("Attempt to send an incompatible type as an array (T_SET)", INVALID_DATA); } HashTable* ht = Z_ARRVAL_PP(value); zval** val_ptr; zend_hash_find(fieldspec, "etype", 6, (void**)&val_ptr); if (Z_TYPE_PP(val_ptr) != IS_LONG) convert_to_long(*val_ptr); uint8_t keytype = Z_LVAL_PP(val_ptr); transport.writeI8(keytype); transport.writeI32(zend_hash_num_elements(ht)); HashPosition key_ptr; for (zend_hash_internal_pointer_reset_ex(ht, &key_ptr); zend_hash_get_current_data_ex(ht, (void**)&val_ptr, &key_ptr) == SUCCESS; zend_hash_move_forward_ex(ht, &key_ptr)) { binary_serialize_hashtable_key(keytype, transport, ht, key_ptr); } } return; }; char errbuf[128]; sprintf(errbuf, "Unknown thrift typeID %d", thrift_typeID); throw_tprotocolexception(errbuf, INVALID_DATA); }
/** * Returns a slice of the resultset to show in the pagination * * @return \stdClass */ PHP_METHOD(Phalcon_Paginator_Adapter_Model, getPaginate) { zval show = {}, config = {}, items = {}, page_number = {}, rowcount = {}, page = {}, last_show_page = {}, start = {}, possible_pages = {}, total_pages = {}; zval page_items = {}, maximum_pages = {}, next = {}, additional_page = {}, before = {}, remainder = {}, pages_total = {}; long int i, i_show; phalcon_return_property(&show, getThis(), SL("_limitRows")); phalcon_return_property(&config, getThis(), SL("_config")); phalcon_return_property(&page_number, getThis(), SL("_page")); i_show = phalcon_get_intval(&show); phalcon_array_fetch_str(&items, &config, SL("data"), PH_NOISY); if (Z_TYPE(page_number) == IS_NULL || PHALCON_LT(&show, &PHALCON_GLOBAL(z_zero))) { PHALCON_CPY_WRT_CTOR(&page_number, &PHALCON_GLOBAL(z_one)); } phalcon_fast_count(&rowcount, &items); object_init(&page); phalcon_sub_function(&last_show_page, &page_number, &PHALCON_GLOBAL(z_one)); mul_function(&start, &show, &last_show_page); phalcon_div_function(&possible_pages, &rowcount, &show); if (unlikely(Z_TYPE(possible_pages)) != IS_DOUBLE) { convert_to_double(&possible_pages); } ZVAL_LONG(&total_pages, (long int)ceil(Z_DVAL(possible_pages))); if (Z_TYPE(items) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STRW(phalcon_paginator_exception_ce, "Invalid data for paginator"); return; } array_init(&page_items); if (PHALCON_GT(&rowcount, &PHALCON_GLOBAL(z_zero))) { /** * Seek to the desired position */ if (PHALCON_LT(&start, &rowcount)) { PHALCON_CALL_METHODW(NULL, &items, "seek", &start); } else { PHALCON_CALL_METHODW(NULL, &items, "rewind"); PHALCON_CPY_WRT_CTOR(&page_number, &PHALCON_GLOBAL(z_one)); PHALCON_CPY_WRT_CTOR(&start, &PHALCON_GLOBAL(z_zero)); } /** * The record must be iterable */ for (i=1; ; ++i) { zval valid = {}, current = {}; PHALCON_CALL_METHODW(&valid, &items, "valid"); if (!PHALCON_IS_NOT_FALSE(&valid)) { break; } PHALCON_CALL_METHODW(¤t, &items, "current"); phalcon_array_append(&page_items, ¤t, PH_COPY); if (i >= i_show) { break; } } } phalcon_update_property_zval(&page, SL("items"), &page_items); phalcon_add_function(&maximum_pages, &start, &show); if (PHALCON_LT(&maximum_pages, &rowcount)) { phalcon_add_function(&next, &page_number, &PHALCON_GLOBAL(z_one)); } else if (PHALCON_IS_EQUAL(&maximum_pages, &rowcount)) { PHALCON_CPY_WRT_CTOR(&next, &rowcount); } else { phalcon_div_function(&possible_pages, &rowcount, &show); phalcon_add_function(&additional_page, &possible_pages, &PHALCON_GLOBAL(z_one)); ZVAL_LONG(&next, phalcon_get_intval(&additional_page)); } if (PHALCON_GT(&next, &total_pages)) { PHALCON_CPY_WRT_CTOR(&next, &total_pages); } phalcon_update_property_zval(&page, SL("next"), &next); if (PHALCON_GT(&page_number, &PHALCON_GLOBAL(z_one))) { phalcon_sub_function(&before, &page_number, &PHALCON_GLOBAL(z_one)); } else { PHALCON_CPY_WRT_CTOR(&before, &PHALCON_GLOBAL(z_one)); } phalcon_update_property_zval(&page, SL("first"), &PHALCON_GLOBAL(z_one)); phalcon_update_property_zval(&page, SL("before"), &before); phalcon_update_property_zval(&page, SL("current"), &page_number); mod_function(&remainder, &rowcount, &show); phalcon_div_function(&possible_pages, &rowcount, &show); if (!PHALCON_IS_LONG(&remainder, 0)) { phalcon_add_function(&next, &possible_pages, &PHALCON_GLOBAL(z_one)); ZVAL_LONG(&pages_total, phalcon_get_intval(&next)); } else { PHALCON_CPY_WRT_CTOR(&pages_total, &possible_pages); } phalcon_update_property_zval(&page, SL("last"), &pages_total); phalcon_update_property_zval(&page, SL("total_pages"), &pages_total); phalcon_update_property_zval(&page, SL("total_items"), &rowcount); RETURN_CTORW(&page); }
void *php_array_to_c_array(zval *param,int type,int size,int *array_size) { HashTable *param_ht = param->value.ht; zval **cur; void *params; int i,tmp_size = zend_hash_num_elements(param_ht); zend_hash_internal_pointer_reset(param_ht); params = (void *)emalloc(size * tmp_size); i = 0; while(zend_hash_get_current_data(param_ht,(void **)&cur) == SUCCESS) { if((*cur)->type == IS_ARRAY) { int new_array_size; void *array = php_array_to_c_array(*cur,type,size,&new_array_size); params = erealloc(params, (tmp_size + new_array_size) * size); memcpy(&((char*)params)[i*size],array,new_array_size * size); i += (new_array_size - 1); efree(array); } else { switch(type) { case TO_C_FLOAT: convert_to_double(*cur); ((float*)params)[i] = (float)Z_DVAL_P(*cur); break; case TO_C_DOUBLE: convert_to_double(*cur); ((double*)params)[i] = Z_DVAL_P(*cur); break; case TO_C_INT: convert_to_long(*cur); ((int*)params)[i] = (int)Z_LVAL_P(*cur); break; case TO_C_LONG: convert_to_long(*cur); ((long*)params)[i] = Z_LVAL_P(*cur); break; case TO_C_UCHAR: convert_to_long(*cur); ((unsigned char*)params)[i] = (unsigned char)Z_LVAL_P(*cur); break; case TO_C_SCHAR: convert_to_long(*cur); ((signed char*)params)[i] = (signed char)Z_LVAL_P(*cur); break; case TO_C_USHORT: convert_to_long(*cur); ((unsigned short*)params)[i] = (unsigned short)Z_LVAL_P(*cur); break; case TO_C_SHORT: convert_to_long(*cur); ((short*)params)[i] = (short)Z_LVAL_P(*cur); break; case TO_C_UINT: convert_to_long(*cur); ((unsigned int*)params)[i] = (unsigned int)Z_LVAL_P(*cur); break; case TO_C_STRING: convert_to_string(*cur); ((char **)params)[i] = estrdup(Z_STRVAL_P(*cur)); } } zend_hash_move_forward(param_ht); i++; } if(array_size != NULL) *array_size = i; return (void *)params; }
static int http_client_coro_execute(zval *zobject, char *uri, zend_size_t uri_len TSRMLS_DC) { if (uri_len <= 0) { swoole_php_fatal_error(E_WARNING, "path is empty."); return SW_ERR; } http_client *http = swoole_get_object(zobject); //http is not null when keeping alive if (http) { //http not ready if (http->state != HTTP_CLIENT_STATE_READY) { //swWarn("fd=%d, state=%d, active=%d, keep_alive=%d", http->cli->socket->fd, http->state, http->cli->socket->active, http->keep_alive); swoole_php_fatal_error(E_WARNING, "Operation now in progress phase %d.", http->state); return SW_ERR; } else if (!http->cli->socket->active) { swoole_php_fatal_error(E_WARNING, "connection#%d is closed.", http->cli->socket->fd); return SW_ERR; } } else { php_swoole_check_reactor(); http = http_client_create(zobject TSRMLS_CC); } if (http == NULL) { return SW_ERR; } if (http->body == NULL) { http->body = swString_new(SW_HTTP_RESPONSE_INIT_SIZE); if (http->body == NULL) { swoole_php_fatal_error(E_ERROR, "[1] swString_new(%d) failed.", SW_HTTP_RESPONSE_INIT_SIZE); return SW_ERR; } } else { swString_clear(http->body); } if (http->uri) { efree(http->uri); } http->uri = estrdup(uri); http->uri_len = uri_len; //if connection exists if (http->cli) { http_client_coro_send_http_request(zobject TSRMLS_CC); return SW_OK; } swClient *cli = php_swoole_client_new(zobject, http->host, http->host_len, http->port); if (cli == NULL) { return SW_ERR; } http->cli = cli; zval *ztmp; HashTable *vht; zval *zset = sw_zend_read_property(swoole_http_client_coro_class_entry_ptr, zobject, ZEND_STRL("setting"), 1 TSRMLS_CC); if (zset && !ZVAL_IS_NULL(zset)) { vht = Z_ARRVAL_P(zset); /** * timeout */ if (php_swoole_array_get_value(vht, "timeout", ztmp)) { convert_to_double(ztmp); http->timeout = (double) Z_DVAL_P(ztmp); } /** * keep_alive */ if (php_swoole_array_get_value(vht, "keep_alive", ztmp)) { convert_to_boolean(ztmp); http->keep_alive = (int) Z_LVAL_P(ztmp); } //client settings php_swoole_client_check_setting(http->cli, zset TSRMLS_CC); } if (cli->socket->active == 1) { swoole_php_fatal_error(E_WARNING, "swoole_http_client is already connected."); return SW_ERR; } #if PHP_MAJOR_VERSION < 7 sw_zval_add_ref(&zobject); #endif cli->object = zobject; //sw_copy_to_stack(cli->object, hcc->_object); cli->open_eof_check = 0; cli->open_length_check = 0; cli->reactor_fdtype = PHP_SWOOLE_FD_STREAM_CLIENT; cli->onReceive = http_client_coro_onReceive; cli->onConnect = http_client_coro_onConnect; cli->onClose = http_client_coro_onClose; cli->onError = http_client_coro_onError; return cli->connect(cli, http->host, http->port, http->timeout, 0); }
Stylesheet::Stylesheet(const ustring & name_in) { gw_message("Creating Stylesheet called '" + name_in + "'"); // Save the sheet's name. name = name_in; // If the name is empty, read from the template. ustring filename = stylesheet_xml_filename(name); if (name.empty()) filename = stylesheet_xml_template_filename(); // Read the xml data, bail out on failure. gchar *contents; g_file_get_contents(filename.c_str(), &contents, NULL, NULL); if (contents == NULL) { gw_critical(_("Failure reading stylesheet ") + filename); return; } // Parse the stylesheet. xmlParserInputBufferPtr inputbuffer; inputbuffer = xmlParserInputBufferCreateMem(contents, strlen(contents), XML_CHAR_ENCODING_NONE); ustring value; xmlTextReaderPtr reader = xmlNewTextReader(inputbuffer, NULL); if (reader) { StyleV2 * style = NULL; while ((xmlTextReaderRead(reader) == 1)) { switch (xmlTextReaderNodeType(reader)) { case XML_READER_TYPE_ELEMENT: { xmlChar *element_name = xmlTextReaderName(reader); if (!xmlStrcmp(element_name, BAD_CAST "style")) { char *attribute = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "marker"); if (attribute) { style = new StyleV2 (0); style->marker = attribute; free(attribute); } } free(element_name); element_name = NULL; break; } case XML_READER_TYPE_TEXT: { xmlChar *text = xmlTextReaderValue(reader); if (text) { value = (gchar *) text; xmlFree(text); } break; } case XML_READER_TYPE_END_ELEMENT: { xmlChar *element_name = xmlTextReaderName(reader); if (style) { if (!xmlStrcmp(element_name, BAD_CAST "marker")) style->marker = value; if (!xmlStrcmp(element_name, BAD_CAST "name")) style->name = value; if (!xmlStrcmp(element_name, BAD_CAST "info")) style->info = value; if (!xmlStrcmp(element_name, BAD_CAST "type")) style->type = (StyleType) convert_to_int(value); if (!xmlStrcmp(element_name, BAD_CAST "subtype")) style->subtype = convert_to_int(value); if (!xmlStrcmp(element_name, BAD_CAST "fontsize")) style->fontsize = convert_to_double(value); if (!xmlStrcmp(element_name, BAD_CAST "italic")) style->italic = value; if (!xmlStrcmp(element_name, BAD_CAST "bold")) style->bold = value; if (!xmlStrcmp(element_name, BAD_CAST "underline")) style->underline = value; if (!xmlStrcmp(element_name, BAD_CAST "smallcaps")) style->smallcaps = value; if (!xmlStrcmp(element_name, BAD_CAST "superscript")) style->superscript = convert_to_bool(value); if (!xmlStrcmp(element_name, BAD_CAST "justification")) style->justification = value; if (!xmlStrcmp(element_name, BAD_CAST "spacebefore")) style->spacebefore = convert_to_double(value); if (!xmlStrcmp(element_name, BAD_CAST "spaceafter")) style->spaceafter = convert_to_double(value); if (!xmlStrcmp(element_name, BAD_CAST "leftmargin")) style->leftmargin = convert_to_double(value); if (!xmlStrcmp(element_name, BAD_CAST "rightmargin")) style->rightmargin = convert_to_double(value); if (!xmlStrcmp(element_name, BAD_CAST "firstlineindent")) style->firstlineindent = convert_to_double(value); if (!xmlStrcmp(element_name, BAD_CAST "spancolumns")) style->spancolumns = convert_to_bool(value); if (!xmlStrcmp(element_name, BAD_CAST "color")) style->color = convert_to_int(value); if (!xmlStrcmp(element_name, BAD_CAST "print")) style->print = convert_to_bool(value); if (!xmlStrcmp(element_name, BAD_CAST "userbool1")) style->userbool1 = convert_to_bool(value); if (!xmlStrcmp(element_name, BAD_CAST "userbool2")) style->userbool2 = convert_to_bool(value); if (!xmlStrcmp(element_name, BAD_CAST "userbool3")) style->userbool3 = convert_to_bool(value); if (!xmlStrcmp(element_name, BAD_CAST "userint1")) style->userint1 = convert_to_int(value); if (!xmlStrcmp(element_name, BAD_CAST "userint2")) style->userint2 = convert_to_int(value); if (!xmlStrcmp(element_name, BAD_CAST "userint3")) style->userint3 = convert_to_int(value); if (!xmlStrcmp(element_name, BAD_CAST "userstring1")) style->userstring1 = value; if (!xmlStrcmp(element_name, BAD_CAST "userstring2")) style->userstring2 = value; if (!xmlStrcmp(element_name, BAD_CAST "userstring3")) style->userstring3 = value; } value.clear(); if (!xmlStrcmp(element_name, BAD_CAST "style")) { if (style) { insert (style); style = NULL; } } free(element_name); element_name = NULL; break; } } } } // Free memory. if (reader) xmlFreeTextReader(reader); if (inputbuffer) xmlFreeParserInputBuffer(inputbuffer); if (contents) g_free(contents); }
static void binary_serialize(int8_t thrift_typeID, PHPOutputTransport& transport, zval* value, HashTable* fieldspec) { // At this point the typeID (and field num, if applicable) should've already been written to the output so all we need to do is write the payload. switch (thrift_typeID) { case T_STOP: case T_VOID: return; case T_STRUCT: { if (Z_TYPE_P(value) != IS_OBJECT) { throw_tprotocolexception("Attempt to send non-object type as a T_STRUCT", INVALID_DATA); } zval* spec = zend_read_static_property(Z_OBJCE_P(value), "_TSPEC", sizeof("_TSPEC")-1, false); if (Z_TYPE_P(spec) != IS_ARRAY) { throw_tprotocolexception("Attempt to send non-Thrift object as a T_STRUCT", INVALID_DATA); } binary_serialize_spec(value, transport, Z_ARRVAL_P(spec)); } return; case T_BOOL: if (!zval_is_bool(value)) convert_to_boolean(value); transport.writeI8(Z_TYPE_INFO_P(value) == IS_TRUE ? 1 : 0); return; case T_BYTE: if (Z_TYPE_P(value) != IS_LONG) convert_to_long(value); transport.writeI8(Z_LVAL_P(value)); return; case T_I16: if (Z_TYPE_P(value) != IS_LONG) convert_to_long(value); transport.writeI16(Z_LVAL_P(value)); return; case T_I32: if (Z_TYPE_P(value) != IS_LONG) convert_to_long(value); transport.writeI32(Z_LVAL_P(value)); return; case T_I64: case T_U64: { int64_t l_data; #if defined(_LP64) || defined(_WIN64) if (Z_TYPE_P(value) != IS_LONG) convert_to_long(value); l_data = Z_LVAL_P(value); #else if (Z_TYPE_P(value) != IS_DOUBLE) convert_to_double(value); l_data = (int64_t)Z_DVAL_P(value); #endif transport.writeI64(l_data); } return; case T_DOUBLE: { union { int64_t c; double d; } a; if (Z_TYPE_P(value) != IS_DOUBLE) convert_to_double(value); a.d = Z_DVAL_P(value); transport.writeI64(a.c); } return; case T_UTF8: case T_UTF16: case T_STRING: if (Z_TYPE_P(value) != IS_STRING) convert_to_string(value); transport.writeString(Z_STRVAL_P(value), Z_STRLEN_P(value)); return; case T_MAP: { if (Z_TYPE_P(value) != IS_ARRAY) convert_to_array(value); if (Z_TYPE_P(value) != IS_ARRAY) { throw_tprotocolexception("Attempt to send an incompatible type as an array (T_MAP)", INVALID_DATA); } HashTable* ht = Z_ARRVAL_P(value); zval* val_ptr; val_ptr = zend_hash_str_find(fieldspec, "ktype", sizeof("ktype")-1); if (Z_TYPE_P(val_ptr) != IS_LONG) convert_to_long(val_ptr); uint8_t keytype = Z_LVAL_P(val_ptr); transport.writeI8(keytype); val_ptr = zend_hash_str_find(fieldspec, "vtype", sizeof("vtype")-1); if (Z_TYPE_P(val_ptr) != IS_LONG) convert_to_long(val_ptr); uint8_t valtype = Z_LVAL_P(val_ptr); transport.writeI8(valtype); val_ptr = zend_hash_str_find(fieldspec, "val", sizeof("val")-1); HashTable* valspec = Z_ARRVAL_P(val_ptr); transport.writeI32(zend_hash_num_elements(ht)); HashPosition key_ptr; for (zend_hash_internal_pointer_reset_ex(ht, &key_ptr); (val_ptr = zend_hash_get_current_data_ex(ht, &key_ptr)) != nullptr; zend_hash_move_forward_ex(ht, &key_ptr)) { binary_serialize_hashtable_key(keytype, transport, ht, key_ptr); binary_serialize(valtype, transport, val_ptr, valspec); } } return; case T_LIST: { if (Z_TYPE_P(value) != IS_ARRAY) convert_to_array(value); if (Z_TYPE_P(value) != IS_ARRAY) { throw_tprotocolexception("Attempt to send an incompatible type as an array (T_LIST)", INVALID_DATA); } HashTable* ht = Z_ARRVAL_P(value); zval* val_ptr; val_ptr = zend_hash_str_find(fieldspec, "etype", sizeof("etype")-1); if (Z_TYPE_P(val_ptr) != IS_LONG) convert_to_long(val_ptr); uint8_t valtype = Z_LVAL_P(val_ptr); transport.writeI8(valtype); val_ptr = zend_hash_str_find(fieldspec, "elem", sizeof("elem")-1); HashTable* valspec = Z_ARRVAL_P(val_ptr); transport.writeI32(zend_hash_num_elements(ht)); HashPosition key_ptr; for (zend_hash_internal_pointer_reset_ex(ht, &key_ptr); (val_ptr = zend_hash_get_current_data_ex(ht, &key_ptr)) != nullptr; zend_hash_move_forward_ex(ht, &key_ptr)) { binary_serialize(valtype, transport, val_ptr, valspec); } } return; case T_SET: { if (Z_TYPE_P(value) != IS_ARRAY) convert_to_array(value); if (Z_TYPE_P(value) != IS_ARRAY) { throw_tprotocolexception("Attempt to send an incompatible type as an array (T_SET)", INVALID_DATA); } HashTable* ht = Z_ARRVAL_P(value); zval* val_ptr; val_ptr = zend_hash_str_find(fieldspec, "etype", sizeof("etype")-1); if (Z_TYPE_P(val_ptr) != IS_LONG) convert_to_long(val_ptr); uint8_t keytype = Z_LVAL_P(val_ptr); transport.writeI8(keytype); transport.writeI32(zend_hash_num_elements(ht)); HashPosition key_ptr; for (zend_hash_internal_pointer_reset_ex(ht, &key_ptr); (val_ptr = zend_hash_get_current_data_ex(ht, &key_ptr)) != nullptr; zend_hash_move_forward_ex(ht, &key_ptr)) { binary_serialize_hashtable_key(keytype, transport, ht, key_ptr); } } return; }; char errbuf[128]; snprintf(errbuf, 128, "Unknown thrift typeID %d", thrift_typeID); throw_tprotocolexception(errbuf, INVALID_DATA); }
PHPAPI void php_pval_to_variant_ex(pval *pval_arg, VARIANT *var_arg, pval *pval_type, int codepage) { OLECHAR *unicode_str; var_arg->vt = (short) pval_type->value.lval; switch(var_arg->vt) { case VT_UI1: convert_to_long_ex(&pval_arg); var_arg->bVal = (unsigned char)pval_arg->value.lval; break; case VT_I2: convert_to_long_ex(&pval_arg); var_arg->iVal = (short)pval_arg->value.lval; break; case VT_I4: convert_to_long_ex(&pval_arg); var_arg->lVal = pval_arg->value.lval; break; case VT_R4: convert_to_double_ex(&pval_arg); var_arg->fltVal = (float)pval_arg->value.dval; break; case VT_R8: convert_to_double_ex(&pval_arg); var_arg->dblVal = pval_arg->value.dval; break; case VT_BOOL: convert_to_boolean_ex(&pval_arg); var_arg->boolVal = (short)pval_arg->value.lval; break; case VT_ERROR: convert_to_long_ex(&pval_arg); var_arg->scode = pval_arg->value.lval; break; case VT_CY: convert_to_double_ex(&pval_arg); VarCyFromR8(pval_arg->value.dval, &(var_arg->cyVal)); break; case VT_DATE: { SYSTEMTIME wintime; struct tm *phptime; phptime = gmtime(&(pval_arg->value.lval)); wintime.wYear = phptime->tm_year + 1900; wintime.wMonth = phptime->tm_mon + 1; wintime.wDay = phptime->tm_mday; wintime.wHour = phptime->tm_hour; wintime.wMinute = phptime->tm_min; wintime.wSecond = phptime->tm_sec; SystemTimeToVariantTime(&wintime, &(var_arg->date)); } case VT_BSTR: convert_to_string_ex(&pval_arg); unicode_str = php_char_to_OLECHAR(pval_arg->value.str.val, pval_arg->value.str.len, codepage); var_arg->bstrVal = SysAllocString(unicode_str); efree(unicode_str); break; case VT_DECIMAL: convert_to_string_ex(&pval_arg); unicode_str = php_char_to_OLECHAR(pval_arg->value.str.val, pval_arg->value.str.len, codepage); VarDecFromStr(unicode_str, LOCALE_SYSTEM_DEFAULT, 0, &(var_arg->decVal)); break; case VT_DECIMAL|VT_BYREF: convert_to_string_ex(&pval_arg); unicode_str = php_char_to_OLECHAR(pval_arg->value.str.val, pval_arg->value.str.len, codepage); VarDecFromStr(unicode_str, LOCALE_SYSTEM_DEFAULT, 0, var_arg->pdecVal); break; case VT_UNKNOWN: php_pval_to_variant(pval_arg, var_arg, codepage); if(var_arg->vt != VT_DISPATCH) var_arg->vt = VT_EMPTY; else { HRESULT hr; hr = var_arg->pdispVal->lpVtbl->QueryInterface(var_arg->pdispVal, &IID_IUnknown, &(var_arg->punkVal)); if (FAILED(hr)) { php_error(E_WARNING,"can't query IUnknown"); var_arg->vt = VT_EMPTY; } else var_arg->vt = VT_UNKNOWN; } break; case VT_DISPATCH: php_pval_to_variant(pval_arg, var_arg, codepage); if(var_arg->vt != VT_DISPATCH) var_arg->vt = VT_EMPTY; break; case VT_UI1|VT_BYREF: convert_to_long(pval_arg); var_arg->pbVal = (unsigned char FAR*) &(pval_arg->value.lval); break; case VT_I2|VT_BYREF: convert_to_long(pval_arg); var_arg->piVal = (short FAR*) &(pval_arg->value.lval); break; case VT_I4|VT_BYREF: convert_to_long(pval_arg); var_arg->plVal = (long FAR*) &(pval_arg->value.lval); break; case VT_R4|VT_BYREF: convert_to_double(pval_arg); var_arg->pfltVal = (float FAR*) &(pval_arg->value.lval); break; case VT_R8|VT_BYREF: convert_to_double(pval_arg); var_arg->pdblVal = (double FAR*) &(pval_arg->value.lval); break; case VT_BOOL|VT_BYREF: convert_to_boolean(pval_arg); var_arg->pboolVal = (short FAR*) &(pval_arg->value.lval); break; case VT_ERROR|VT_BYREF: convert_to_long(pval_arg); var_arg->pscode = (long FAR*) &(pval_arg->value.lval); break; case VT_CY|VT_BYREF: convert_to_double_ex(&pval_arg); VarCyFromR8(pval_arg->value.dval, var_arg->pcyVal); break; case VT_DATE|VT_BYREF: { SYSTEMTIME wintime; struct tm *phptime; phptime = gmtime(&(pval_arg->value.lval)); wintime.wYear = phptime->tm_year + 1900; wintime.wMonth = phptime->tm_mon + 1; wintime.wDay = phptime->tm_mday; wintime.wHour = phptime->tm_hour; wintime.wMinute = phptime->tm_min; wintime.wSecond = phptime->tm_sec; SystemTimeToVariantTime(&wintime, var_arg->pdate); } case VT_BSTR|VT_BYREF: convert_to_string(pval_arg); var_arg->pbstrVal = (BSTR FAR*) emalloc(sizeof(BSTR FAR*)); unicode_str = php_char_to_OLECHAR(pval_arg->value.str.val, pval_arg->value.str.len, codepage); *(var_arg->pbstrVal) = SysAllocString(unicode_str); efree(unicode_str); break; case VT_UNKNOWN|VT_BYREF: php_pval_to_variant(pval_arg, var_arg, codepage); if(var_arg->vt != VT_DISPATCH) var_arg->vt = VT_EMPTY; else { HRESULT hr; hr = var_arg->pdispVal->lpVtbl->QueryInterface(var_arg->pdispVal, &IID_IUnknown, &(var_arg->punkVal)); if (FAILED(hr)) { php_error(E_WARNING,"can't query IUnknown"); var_arg->vt = VT_EMPTY; } else var_arg->vt = VT_UNKNOWN|VT_BYREF; } break; case VT_DISPATCH|VT_BYREF: php_pval_to_variant(pval_arg, var_arg, codepage); if(var_arg->vt != VT_DISPATCH) var_arg->vt = VT_EMPTY; else var_arg->vt |= VT_BYREF; break; case VT_VARIANT|VT_BYREF: php_pval_to_variant(pval_arg, var_arg, codepage); if(var_arg->vt != (VT_VARIANT | VT_BYREF)) var_arg->vt = VT_EMPTY; break; case VT_I1: convert_to_long_ex(&pval_arg); var_arg->cVal = (char)pval_arg->value.lval; break; case VT_UI2: convert_to_long_ex(&pval_arg); var_arg->uiVal = (unsigned short)pval_arg->value.lval; break; case VT_UI4: convert_to_long_ex(&pval_arg); var_arg->ulVal = (unsigned long)pval_arg->value.lval; break; case VT_INT: convert_to_long_ex(&pval_arg); var_arg->intVal = (int)pval_arg->value.lval; break; case VT_UINT: convert_to_long_ex(&pval_arg); var_arg->uintVal = (unsigned int)pval_arg->value.lval; break; case VT_I1|VT_BYREF: convert_to_long(pval_arg); var_arg->pcVal = (char FAR*) &pval_arg->value.lval; break; case VT_UI2|VT_BYREF: convert_to_long(pval_arg); var_arg->puiVal = (unsigned short FAR*) &pval_arg->value.lval; break; case VT_UI4|VT_BYREF: convert_to_long(pval_arg); var_arg->pulVal = (unsigned long FAR*) &pval_arg->value.lval; break; case VT_INT|VT_BYREF: convert_to_long(pval_arg); var_arg->pintVal = (int FAR*) &pval_arg->value.lval; break; case VT_UINT|VT_BYREF: convert_to_long(pval_arg); var_arg->puintVal = (unsigned int FAR*) &pval_arg->value.lval; break; default: php_error(E_WARNING, "Type not supportet or not yet implemented."); } }
void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx) { int i = 0; zend_op *opline = op_array->opcodes; zend_op *end = opline + op_array->last; zend_bool collect_constants = (op_array == &ctx->script->main_op_array); while (opline < end) { switch (opline->opcode) { case ZEND_ADD: case ZEND_SUB: case ZEND_MUL: case ZEND_DIV: case ZEND_MOD: case ZEND_POW: case ZEND_SL: case ZEND_SR: case ZEND_CONCAT: case ZEND_FAST_CONCAT: case ZEND_IS_EQUAL: case ZEND_IS_NOT_EQUAL: case ZEND_IS_SMALLER: case ZEND_IS_SMALLER_OR_EQUAL: case ZEND_IS_IDENTICAL: case ZEND_IS_NOT_IDENTICAL: case ZEND_BW_OR: case ZEND_BW_AND: case ZEND_BW_XOR: case ZEND_BOOL_XOR: if (ZEND_OP1_TYPE(opline) == IS_CONST && ZEND_OP2_TYPE(opline) == IS_CONST) { /* binary operation with constant operands */ binary_op_type binary_op = get_binary_op(opline->opcode); uint32_t tv = ZEND_RESULT(opline).var; /* temporary variable */ zval result; int er; if (opline->opcode == ZEND_DIV && Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_LONG && Z_LVAL(ZEND_OP2_LITERAL(opline)) == 0) { /* div by 0 */ break; } er = EG(error_reporting); EG(error_reporting) = 0; /* evaluate constant expression */ if (binary_op(&result, &ZEND_OP1_LITERAL(opline), &ZEND_OP2_LITERAL(opline)) != SUCCESS) { EG(error_reporting) = er; break; } EG(error_reporting) = er; if (zend_optimizer_replace_by_const(op_array, opline + 1, IS_TMP_VAR, tv, &result)) { literal_dtor(&ZEND_OP1_LITERAL(opline)); literal_dtor(&ZEND_OP2_LITERAL(opline)); MAKE_NOP(opline); } } break; case ZEND_CAST: if (ZEND_OP1_TYPE(opline) == IS_CONST && opline->extended_value != IS_ARRAY && opline->extended_value != IS_OBJECT && opline->extended_value != IS_RESOURCE) { /* cast of constant operand */ zend_uchar type = opline->result_type; uint32_t tv = ZEND_RESULT(opline).var; /* temporary variable */ zval res; res = ZEND_OP1_LITERAL(opline); zval_copy_ctor(&res); switch (opline->extended_value) { case IS_NULL: convert_to_null(&res); break; case _IS_BOOL: convert_to_boolean(&res); break; case IS_LONG: convert_to_long(&res); break; case IS_DOUBLE: convert_to_double(&res); break; case IS_STRING: convert_to_string(&res); break; } if (zend_optimizer_replace_by_const(op_array, opline + 1, type, tv, &res)) { literal_dtor(&ZEND_OP1_LITERAL(opline)); MAKE_NOP(opline); } } else if (opline->extended_value == _IS_BOOL) { /* T = CAST(X, IS_BOOL) => T = BOOL(X) */ opline->opcode = ZEND_BOOL; opline->extended_value = 0; } break; case ZEND_BW_NOT: case ZEND_BOOL_NOT: if (ZEND_OP1_TYPE(opline) == IS_CONST) { /* unary operation on constant operand */ unary_op_type unary_op = get_unary_op(opline->opcode); zval result; uint32_t tv = ZEND_RESULT(opline).var; /* temporary variable */ int er; er = EG(error_reporting); EG(error_reporting) = 0; if (unary_op(&result, &ZEND_OP1_LITERAL(opline)) != SUCCESS) { EG(error_reporting) = er; break; } EG(error_reporting) = er; if (zend_optimizer_replace_by_const(op_array, opline + 1, IS_TMP_VAR, tv, &result)) { literal_dtor(&ZEND_OP1_LITERAL(opline)); MAKE_NOP(opline); } } break; #if 0 case ZEND_ADD_STRING: case ZEND_ADD_CHAR: { zend_op *next_op = opline + 1; int requires_conversion = (opline->opcode == ZEND_ADD_CHAR? 1 : 0); size_t final_length = 0; zend_string *str; char *ptr; zend_op *last_op; /* There is always a ZEND_RETURN at the end if (next_op>=end) { break; } */ while (next_op->opcode == ZEND_ADD_STRING || next_op->opcode == ZEND_ADD_CHAR) { if (ZEND_RESULT(opline).var != ZEND_RESULT(next_op).var) { break; } if (next_op->opcode == ZEND_ADD_CHAR) { final_length += 1; } else { /* ZEND_ADD_STRING */ final_length += Z_STRLEN(ZEND_OP2_LITERAL(next_op)); } next_op++; } if (final_length == 0) { break; } last_op = next_op; final_length += (requires_conversion? 1 : Z_STRLEN(ZEND_OP2_LITERAL(opline))); str = zend_string_alloc(final_length, 0); str->len = final_length; ptr = str->val; ptr[final_length] = '\0'; if (requires_conversion) { /* ZEND_ADD_CHAR */ char chval = (char)Z_LVAL(ZEND_OP2_LITERAL(opline)); ZVAL_NEW_STR(&ZEND_OP2_LITERAL(opline), str); ptr[0] = chval; opline->opcode = ZEND_ADD_STRING; ptr++; } else { /* ZEND_ADD_STRING */ memcpy(ptr, Z_STRVAL(ZEND_OP2_LITERAL(opline)), Z_STRLEN(ZEND_OP2_LITERAL(opline))); ptr += Z_STRLEN(ZEND_OP2_LITERAL(opline)); zend_string_release(Z_STR(ZEND_OP2_LITERAL(opline))); ZVAL_NEW_STR(&ZEND_OP2_LITERAL(opline), str); } next_op = opline + 1; while (next_op < last_op) { if (next_op->opcode == ZEND_ADD_STRING) { memcpy(ptr, Z_STRVAL(ZEND_OP2_LITERAL(next_op)), Z_STRLEN(ZEND_OP2_LITERAL(next_op))); ptr += Z_STRLEN(ZEND_OP2_LITERAL(next_op)); literal_dtor(&ZEND_OP2_LITERAL(next_op)); } else { /* ZEND_ADD_CHAR */ *ptr = (char)Z_LVAL(ZEND_OP2_LITERAL(next_op)); ptr++; } MAKE_NOP(next_op); next_op++; } if (!((ZEND_OPTIMIZER_PASS_5|ZEND_OPTIMIZER_PASS_10) & OPTIMIZATION_LEVEL)) { /* NOP removal is disabled => insert JMP over NOPs */ if (last_op-opline >= 3) { /* If we have more than 2 NOPS then JMP over them */ (opline + 1)->opcode = ZEND_JMP; ZEND_OP1(opline + 1).opline_num = last_op - op_array->opcodes; /* that's OK even for ZE2, since opline_num's are resolved in pass 2 later */ } } } break; #endif case ZEND_FETCH_CONSTANT: if (ZEND_OP1_TYPE(opline) == IS_UNUSED && ZEND_OP2_TYPE(opline) == IS_CONST && Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING && Z_STRLEN(ZEND_OP2_LITERAL(opline)) == sizeof("__COMPILER_HALT_OFFSET__") - 1 && memcmp(Z_STRVAL(ZEND_OP2_LITERAL(opline)), "__COMPILER_HALT_OFFSET__", sizeof("__COMPILER_HALT_OFFSET__") - 1) == 0) { /* substitute __COMPILER_HALT_OFFSET__ constant */ zend_execute_data *orig_execute_data = EG(current_execute_data); zend_execute_data fake_execute_data; zval *offset; memset(&fake_execute_data, 0, sizeof(zend_execute_data)); fake_execute_data.func = (zend_function*)op_array; EG(current_execute_data) = &fake_execute_data; if ((offset = zend_get_constant_str("__COMPILER_HALT_OFFSET__", sizeof("__COMPILER_HALT_OFFSET__") - 1)) != NULL) { uint32_t tv = ZEND_RESULT(opline).var; if (zend_optimizer_replace_by_const(op_array, opline, IS_TMP_VAR, tv, offset)) { literal_dtor(&ZEND_OP2_LITERAL(opline)); MAKE_NOP(opline); } } EG(current_execute_data) = orig_execute_data; break; } if (ZEND_OP1_TYPE(opline) == IS_UNUSED && ZEND_OP2_TYPE(opline) == IS_CONST && Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING) { /* substitute persistent constants */ uint32_t tv = ZEND_RESULT(opline).var; zval c; if (!zend_optimizer_get_persistent_constant(Z_STR(ZEND_OP2_LITERAL(opline)), &c, 1)) { if (!ctx->constants || !zend_optimizer_get_collected_constant(ctx->constants, &ZEND_OP2_LITERAL(opline), &c)) { break; } } if (Z_TYPE(c) == IS_CONSTANT_AST) { break; } if (zend_optimizer_replace_by_const(op_array, opline, IS_TMP_VAR, tv, &c)) { literal_dtor(&ZEND_OP2_LITERAL(opline)); MAKE_NOP(opline); } } /* class constant */ if (ZEND_OP1_TYPE(opline) != IS_UNUSED && ZEND_OP2_TYPE(opline) == IS_CONST && Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING) { zend_class_entry *ce = NULL; if (ZEND_OP1_TYPE(opline) == IS_CONST && Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING) { /* for A::B */ if (op_array->scope && !strncasecmp(Z_STRVAL(ZEND_OP1_LITERAL(opline)), op_array->scope->name->val, Z_STRLEN(ZEND_OP1_LITERAL(opline)) + 1)) { ce = op_array->scope; } else { if ((ce = zend_hash_find_ptr(EG(class_table), Z_STR(op_array->literals[opline->op1.constant + 1]))) == NULL || (ce->type == ZEND_INTERNAL_CLASS && ce->info.internal.module->type != MODULE_PERSISTENT) || (ce->type == ZEND_USER_CLASS && ZEND_CE_FILENAME(ce) != op_array->filename)) { break; } } } else if (op_array->scope && ZEND_OP1_TYPE(opline) == IS_VAR && (opline - 1)->opcode == ZEND_FETCH_CLASS && (ZEND_OP1_TYPE(opline - 1) == IS_UNUSED && ((opline - 1)->extended_value & ~ZEND_FETCH_CLASS_NO_AUTOLOAD) == ZEND_FETCH_CLASS_SELF) && ZEND_RESULT((opline - 1)).var == ZEND_OP1(opline).var) { /* for self::B */ ce = op_array->scope; } if (ce) { uint32_t tv = ZEND_RESULT(opline).var; zval *c, t; if ((c = zend_hash_find(&ce->constants_table, Z_STR(ZEND_OP2_LITERAL(opline)))) != NULL) { ZVAL_DEREF(c); if (Z_TYPE_P(c) == IS_CONSTANT_AST) { break; } if (ZEND_IS_CONSTANT_TYPE(Z_TYPE_P(c))) { if (!zend_optimizer_get_persistent_constant(Z_STR_P(c), &t, 1) || ZEND_IS_CONSTANT_TYPE(Z_TYPE(t))) { break; } } else { ZVAL_COPY_VALUE(&t, c); zval_copy_ctor(&t); } if (ZEND_OP1_TYPE(opline) == IS_CONST) { literal_dtor(&ZEND_OP1_LITERAL(opline)); } else { MAKE_NOP((opline - 1)); } if (zend_optimizer_replace_by_const(op_array, opline, IS_TMP_VAR, tv, &t)) { literal_dtor(&ZEND_OP2_LITERAL(opline)); MAKE_NOP(opline); } } } } break; case ZEND_DO_ICALL: { zend_op *send1_opline = opline - 1; zend_op *send2_opline = NULL; zend_op *init_opline = NULL; while (send1_opline->opcode == ZEND_NOP) { send1_opline--; } if (send1_opline->opcode != ZEND_SEND_VAL || ZEND_OP1_TYPE(send1_opline) != IS_CONST) { /* don't colllect constants after unknown function call */ collect_constants = 0; break; } if (send1_opline->op2.num == 2) { send2_opline = send1_opline; send1_opline--; while (send1_opline->opcode == ZEND_NOP) { send1_opline--; } if (send1_opline->opcode != ZEND_SEND_VAL || ZEND_OP1_TYPE(send1_opline) != IS_CONST) { /* don't colllect constants after unknown function call */ collect_constants = 0; break; } } init_opline = send1_opline - 1; while (init_opline->opcode == ZEND_NOP) { init_opline--; } if (init_opline->opcode != ZEND_INIT_FCALL || ZEND_OP2_TYPE(init_opline) != IS_CONST || Z_TYPE(ZEND_OP2_LITERAL(init_opline)) != IS_STRING) { /* don't colllect constants after unknown function call */ collect_constants = 0; break; } /* define("name", scalar); */ if (Z_STRLEN(ZEND_OP2_LITERAL(init_opline)) == sizeof("define")-1 && zend_binary_strcasecmp(Z_STRVAL(ZEND_OP2_LITERAL(init_opline)), Z_STRLEN(ZEND_OP2_LITERAL(init_opline)), "define", sizeof("define")-1) == 0) { if (Z_TYPE(ZEND_OP1_LITERAL(send1_opline)) == IS_STRING && send2_opline && Z_TYPE(ZEND_OP1_LITERAL(send2_opline)) <= IS_STRING) { if (collect_constants) { zend_optimizer_collect_constant(ctx, &ZEND_OP1_LITERAL(send1_opline), &ZEND_OP1_LITERAL(send2_opline)); } if (RESULT_UNUSED(opline) && !zend_memnstr(Z_STRVAL(ZEND_OP1_LITERAL(send1_opline)), "::", sizeof("::") - 1, Z_STRVAL(ZEND_OP1_LITERAL(send1_opline)) + Z_STRLEN(ZEND_OP1_LITERAL(send1_opline)))) { opline->opcode = ZEND_DECLARE_CONST; opline->op1_type = IS_CONST; opline->op2_type = IS_CONST; opline->result_type = IS_UNUSED; opline->op1.constant = send1_opline->op1.constant; opline->op2.constant = send2_opline->op1.constant; opline->result.num = 0; literal_dtor(&ZEND_OP2_LITERAL(init_opline)); MAKE_NOP(init_opline); MAKE_NOP(send1_opline); MAKE_NOP(send2_opline); } break; } } /* pre-evaluate constant functions: defined(x) constant(x) function_exists(x) is_callable(x) extension_loaded(x) */ if (!send2_opline && Z_TYPE(ZEND_OP1_LITERAL(send1_opline)) == IS_STRING) { if ((Z_STRLEN(ZEND_OP2_LITERAL(init_opline)) == sizeof("function_exists")-1 && !memcmp(Z_STRVAL(ZEND_OP2_LITERAL(init_opline)), "function_exists", sizeof("function_exists")-1)) || (Z_STRLEN(ZEND_OP2_LITERAL(init_opline)) == sizeof("is_callable")-1 && !memcmp(Z_STRVAL(ZEND_OP2_LITERAL(init_opline)), "is_callable", sizeof("is_callable")))) { zend_internal_function *func; zend_string *lc_name = zend_string_tolower( Z_STR(ZEND_OP1_LITERAL(send1_opline))); if ((func = zend_hash_find_ptr(EG(function_table), lc_name)) != NULL && func->type == ZEND_INTERNAL_FUNCTION && func->module->type == MODULE_PERSISTENT) { zval t; if (Z_STRLEN(ZEND_OP2_LITERAL(init_opline)) == sizeof("is_callable") - 1 || func->handler != ZEND_FN(display_disabled_function)) { ZVAL_TRUE(&t); } else { ZVAL_FALSE(&t); } if (zend_optimizer_replace_by_const(op_array, opline + 1, IS_VAR, ZEND_RESULT(opline).var, &t)) { literal_dtor(&ZEND_OP2_LITERAL(init_opline)); MAKE_NOP(init_opline); literal_dtor(&ZEND_OP1_LITERAL(send1_opline)); MAKE_NOP(send1_opline); MAKE_NOP(opline); zend_string_release(lc_name); break; } } zend_string_release(lc_name); } else if (Z_STRLEN(ZEND_OP2_LITERAL(init_opline)) == sizeof("extension_loaded")-1 && !memcmp(Z_STRVAL(ZEND_OP2_LITERAL(init_opline)), "extension_loaded", sizeof("extension_loaded")-1)) { zval t; zend_string *lc_name = zend_string_tolower( Z_STR(ZEND_OP1_LITERAL(send1_opline))); zend_module_entry *m = zend_hash_find_ptr(&module_registry, lc_name); zend_string_release(lc_name); if (!m) { if (!PG(enable_dl)) { break; } else { ZVAL_FALSE(&t); } } else { if (m->type == MODULE_PERSISTENT) { ZVAL_TRUE(&t); } else { break; } } if (zend_optimizer_replace_by_const(op_array, opline + 1, IS_VAR, ZEND_RESULT(opline).var, &t)) { literal_dtor(&ZEND_OP2_LITERAL(init_opline)); MAKE_NOP(init_opline); literal_dtor(&ZEND_OP1_LITERAL(send1_opline)); MAKE_NOP(send1_opline); MAKE_NOP(opline); break; } } else if (Z_STRLEN(ZEND_OP2_LITERAL(init_opline)) == sizeof("defined")-1 && !memcmp(Z_STRVAL(ZEND_OP2_LITERAL(init_opline)), "defined", sizeof("defined")-1)) { zval t; if (zend_optimizer_get_persistent_constant(Z_STR(ZEND_OP1_LITERAL(send1_opline)), &t, 0)) { ZVAL_TRUE(&t); if (zend_optimizer_replace_by_const(op_array, opline + 1, IS_VAR, ZEND_RESULT(opline).var, &t)) { literal_dtor(&ZEND_OP2_LITERAL(init_opline)); MAKE_NOP(init_opline); literal_dtor(&ZEND_OP1_LITERAL(send1_opline)); MAKE_NOP(send1_opline); MAKE_NOP(opline); break; } } } else if (Z_STRLEN(ZEND_OP2_LITERAL(init_opline)) == sizeof("constant")-1 && !memcmp(Z_STRVAL(ZEND_OP2_LITERAL(init_opline)), "constant", sizeof("constant")-1)) { zval t; if (zend_optimizer_get_persistent_constant(Z_STR(ZEND_OP1_LITERAL(send1_opline)), &t, 1)) { if (zend_optimizer_replace_by_const(op_array, opline + 1, IS_VAR, ZEND_RESULT(opline).var, &t)) { literal_dtor(&ZEND_OP2_LITERAL(init_opline)); MAKE_NOP(init_opline); literal_dtor(&ZEND_OP1_LITERAL(send1_opline)); MAKE_NOP(send1_opline); MAKE_NOP(opline); break; } } } else if ((CG(compiler_options) & ZEND_COMPILE_NO_BUILTIN_STRLEN) == 0 && Z_STRLEN(ZEND_OP2_LITERAL(init_opline)) == sizeof("strlen") - 1 && !memcmp(Z_STRVAL(ZEND_OP2_LITERAL(init_opline)), "strlen", sizeof("strlen") - 1)) { zval t; ZVAL_LONG(&t, Z_STRLEN(ZEND_OP1_LITERAL(send1_opline))); if (zend_optimizer_replace_by_const(op_array, opline + 1, IS_VAR, ZEND_RESULT(opline).var, &t)) { literal_dtor(&ZEND_OP2_LITERAL(init_opline)); MAKE_NOP(init_opline); literal_dtor(&ZEND_OP1_LITERAL(send1_opline)); MAKE_NOP(send1_opline); MAKE_NOP(opline); break; } /* dirname(IS_CONST/IS_STRING) -> IS_CONST/IS_STRING */ } else if (Z_STRLEN(ZEND_OP2_LITERAL(init_opline)) == sizeof("dirname")-1 && !memcmp(Z_STRVAL(ZEND_OP2_LITERAL(init_opline)), "dirname", sizeof("dirname")-1) && IS_ABSOLUTE_PATH(Z_STRVAL(ZEND_OP1_LITERAL(send1_opline)), Z_STRLEN(ZEND_OP1_LITERAL(send1_opline)))) { zend_string *dirname = zend_string_init(Z_STRVAL(ZEND_OP1_LITERAL(send1_opline)), Z_STRLEN(ZEND_OP1_LITERAL(send1_opline)), 0); dirname->len = zend_dirname(dirname->val, dirname->len); if (IS_ABSOLUTE_PATH(dirname->val, dirname->len)) { zval t; ZVAL_STR(&t, dirname); if (zend_optimizer_replace_by_const(op_array, opline + 1, IS_VAR, ZEND_RESULT(opline).var, &t)) { literal_dtor(&ZEND_OP2_LITERAL(init_opline)); MAKE_NOP(init_opline); literal_dtor(&ZEND_OP1_LITERAL(send1_opline)); MAKE_NOP(send1_opline); MAKE_NOP(opline); break; } } else { zend_string_release(dirname); } } } /* don't colllect constants after any other function call */ collect_constants = 0; break; } case ZEND_STRLEN: if (ZEND_OP1_TYPE(opline) == IS_CONST && Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING) { zval t; ZVAL_LONG(&t, Z_STRLEN(ZEND_OP1_LITERAL(opline))); if (zend_optimizer_replace_by_const(op_array, opline + 1, IS_TMP_VAR, ZEND_RESULT(opline).var, &t)) { literal_dtor(&ZEND_OP1_LITERAL(opline)); MAKE_NOP(opline); } } break; case ZEND_DEFINED: { zval c; uint32_t tv = ZEND_RESULT(opline).var; if (!zend_optimizer_get_persistent_constant(Z_STR(ZEND_OP1_LITERAL(opline)), &c, 0)) { break; } ZVAL_TRUE(&c); if (zend_optimizer_replace_by_const(op_array, opline, IS_TMP_VAR, tv, &c)) { literal_dtor(&ZEND_OP1_LITERAL(opline)); MAKE_NOP(opline); } } break; case ZEND_DECLARE_CONST: if (collect_constants && Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING && Z_TYPE(ZEND_OP2_LITERAL(opline)) <= IS_STRING) { zend_optimizer_collect_constant(ctx, &ZEND_OP1_LITERAL(opline), &ZEND_OP2_LITERAL(opline)); } break; case ZEND_RETURN: case ZEND_RETURN_BY_REF: case ZEND_GENERATOR_RETURN: case ZEND_EXIT: case ZEND_THROW: case ZEND_CATCH: case ZEND_BRK: case ZEND_CONT: case ZEND_GOTO: case ZEND_FAST_CALL: case ZEND_FAST_RET: case ZEND_JMP: case ZEND_JMPZNZ: case ZEND_JMPZ: case ZEND_JMPNZ: case ZEND_JMPZ_EX: case ZEND_JMPNZ_EX: case ZEND_FE_RESET_R: case ZEND_FE_RESET_RW: case ZEND_FE_FETCH_R: case ZEND_FE_FETCH_RW: case ZEND_NEW: case ZEND_JMP_SET: case ZEND_COALESCE: case ZEND_ASSERT_CHECK: collect_constants = 0; break; case ZEND_FETCH_R: case ZEND_FETCH_W: case ZEND_FETCH_RW: case ZEND_FETCH_FUNC_ARG: case ZEND_FETCH_IS: case ZEND_FETCH_UNSET: if (opline != op_array->opcodes && (opline-1)->opcode == ZEND_BEGIN_SILENCE && (opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_LOCAL && opline->op1_type == IS_CONST && opline->op2_type == IS_UNUSED && Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING && (Z_STRLEN(ZEND_OP1_LITERAL(opline)) != sizeof("this")-1 || memcmp(Z_STRVAL(ZEND_OP1_LITERAL(opline)), "this", sizeof("this") - 1) != 0)) { int var = opline->result.var; int level = 0; zend_op *op = opline + 1; zend_op *use = NULL; while (op < end) { if (op->opcode == ZEND_BEGIN_SILENCE) { level++; } else if (op->opcode == ZEND_END_SILENCE) { if (level == 0) { break; } else { level--; } } if (op->op1_type == IS_VAR && op->op1.var == var) { if (use) { /* used more than once */ use = NULL; break; } use = op; } else if (op->op2_type == IS_VAR && op->op2.var == var) { if (use) { /* used more than once */ use = NULL; break; } use = op; } op++; } if (use) { if (use->op1_type == IS_VAR && use->op1.var == var) { use->op1_type = IS_CV; use->op1.var = zend_optimizer_lookup_cv(op_array, Z_STR(ZEND_OP1_LITERAL(opline))); MAKE_NOP(opline); } else if (use->op2_type == IS_VAR && use->op2.var == var) { use->op2_type = IS_CV; use->op2.var = zend_optimizer_lookup_cv(op_array, Z_STR(ZEND_OP1_LITERAL(opline))); MAKE_NOP(opline); } } } break; } opline++; i++; } }
/** * Returns human readable sizes * * @param int $size * @param string $forceUnit * @param string $format * @param boolean $si * @return string */ PHP_METHOD(Phalcon_Text, bytes){ zval *z_size, *z_force_unit = NULL, *format = NULL, *si = NULL; char *force_unit; const char **units; const char *units1[] = {"B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"}; const char *units2[] = {"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"}; double size; int mod, power = 0, found = 0, i, j = 0; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 3, &z_size, &z_force_unit, &format, &si); PHALCON_SEPARATE_PARAM(z_size); convert_to_double(z_size); size = Z_DVAL_P(z_size); if (!z_force_unit) { PHALCON_INIT_VAR(z_force_unit); } else { PHALCON_SEPARATE_PARAM(z_force_unit); convert_to_string(z_force_unit); } if (!format) { PHALCON_INIT_VAR(format); } else { PHALCON_SEPARATE_PARAM(format); convert_to_string(format); } if (PHALCON_IS_EMPTY(format)) { PHALCON_INIT_NVAR(format); ZVAL_STRING(format, "%01.2f %s", 1); } if (!si) { si = PHALCON_GLOBAL(z_true); } if (!zend_is_true(si) || (!PHALCON_IS_EMPTY(z_force_unit) && phalcon_memnstr_str(z_force_unit, SL("i")))) { units = units2; mod = 1024; } else { units = units1; mod = 1000; } if (!PHALCON_IS_EMPTY(z_force_unit)) { force_unit = Z_STRVAL_P(z_force_unit); for (i = 0; i < sizeof(units); i++) { if (strcasecmp(force_unit, units[i]) == 0) { found = 1; power = i; break; } } } if (found) { while(j < power) { size /= mod; j++; } } else { while(size > mod) { size /= mod; power++; } } PHALCON_INIT_NVAR(z_size); ZVAL_DOUBLE(z_size, size); PHALCON_INIT_NVAR(z_force_unit); ZVAL_STRING(z_force_unit, units[power], 1); PHALCON_RETURN_CALL_FUNCTION("sprintf", format, z_size, z_force_unit); RETURN_MM(); }