/* {{{ php_foreach_all */ static int php_foreach_all (int instatus, char *inkey, int inkeylen, char *inval, int invallen, char *indata) { int is_stop = 0; zval *args; zval *retval; TSRMLS_FETCH(); MAKE_STD_ZVAL(args); array_init(args); add_index_long(args, 0, instatus); add_index_stringl(args, 1, inkey, inkeylen, 1); add_index_stringl(args, 2, inval, invallen, 1); php_yp_all_callback *cb = (php_yp_all_callback *) indata; zend_fcall_info_args(&cb->fci, args TSRMLS_CC); zend_fcall_info_call(&cb->fci, &cb->fcc, &retval, args TSRMLS_CC); zend_fcall_info_args_clear(&cb->fci, 1); if (retval) { is_stop = zval_is_true(retval); zval_ptr_dtor(&retval); } return is_stop; }
PHP_METHOD(Test_NativeArray, testArrayMultipleAccess1) { zval _0; zval a, b, _1; zval *this_ptr = getThis(); ZVAL_UNDEF(&a); ZVAL_UNDEF(&b); ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_0); ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); zephir_create_array(&a, 1, 0 TSRMLS_CC); ZEPHIR_INIT_VAR(&_0); zephir_create_array(&_0, 2, 0 TSRMLS_CC); add_index_stringl(&_0, 0, SL("a")); add_index_stringl(&_0, 1, SL("b")); zephir_array_update_long(&a, 0, &_0, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY); zephir_array_fetch_long(&_1, &a, 0, PH_NOISY | PH_READONLY, "test/nativearray.zep", 310 TSRMLS_CC); zephir_array_fetch_long(&b, &_1, 0, PH_NOISY | PH_READONLY, "test/nativearray.zep", 310 TSRMLS_CC); RETURN_CTOR(&b); }
PHP_METHOD(Test_NativeArray, testArray13) { zval *a; ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(a); array_init_size(a, 5); add_index_stringl(a, 1, SL("hello1"), 1); add_index_stringl(a, 2, SL("hello2"), 1); add_index_stringl(a, 3, SL("hello3"), 1); RETURN_CCTOR(a); }
PHP_METHOD(Test_NativeArray, testArray13) { zval a; zval *this_ptr = getThis(); ZVAL_UNDEF(&a); ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); zephir_create_array(&a, 3, 0 TSRMLS_CC); add_index_stringl(&a, 1, SL("hello1")); add_index_stringl(&a, 2, SL("hello2")); add_index_stringl(&a, 3, SL("hello3")); RETURN_CCTOR(&a); }
PHP_METHOD(Test_NativeArray, testArrayMultipleAccess1) { zval *_0; zval *a, *b, *_1; ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(a); array_init_size(a, 2); ZEPHIR_INIT_VAR(_0); array_init_size(_0, 3); add_index_stringl(_0, 0, SL("a"), 1); add_index_stringl(_0, 1, SL("b"), 1); zephir_array_update_long(&a, 0, &_0, PH_COPY, "test/nativearray.zep", 312); zephir_array_fetch_long(&_1, a, 0, PH_NOISY | PH_READONLY TSRMLS_CC); zephir_array_fetch_long(&b, _1, 0, PH_NOISY | PH_READONLY TSRMLS_CC); RETURN_CTOR(b); }
PHP_METHOD(Test_NativeArray, testArray29) { long b; zval *a; ZEPHIR_MM_GROW(); b = 1; ZEPHIR_INIT_VAR(a); array_init_size(a, 2); add_index_stringl(a, b, SL("hello"), 1); RETURN_CCTOR(a); }
void KPHPArrayObject::AddKrollValueToPHPArray(KValueRef value, zval *phpArray, unsigned int index) { if (value->IsNull() || value->IsUndefined()) { add_index_null(phpArray, (unsigned long) index); } else if (value->IsBool()) { if (value->ToBool()) add_index_bool(phpArray, (unsigned long) index, 1); else add_index_bool(phpArray, (unsigned long) index, 0); } else if (value->IsNumber()) { /* No way to check whether the number is an integer or a double here. All Kroll numbers are doubles, so return a double. This could cause some PHP to function incorrectly if it's doing strict type checking. */ add_index_double(phpArray, (unsigned long) index, value->ToNumber()); } else if (value->IsString()) { add_index_stringl(phpArray, (unsigned long) index, (char *) value->ToString(), strlen(value->ToString()), 1); } else if (value->IsObject()) { /*TODO: Implement*/ } else if (value->IsMethod()) { /*TODO: Implement*/ } else if (value->IsList()) { zval *phpValue; AutoPtr<KPHPArrayObject> pl = value->ToList().cast<KPHPArrayObject>(); if (!pl.isNull()) phpValue = pl->ToPHP(); else phpValue = PHPUtils::ToPHPValue(value); add_index_zval(phpArray, (unsigned long) index, phpValue); } }
PHP_METHOD(Test_NativeArray, testArray29) { long b = 0; zval a; zval *this_ptr = getThis(); ZVAL_UNDEF(&a); ZEPHIR_MM_GROW(); b = 1; ZEPHIR_INIT_VAR(&a); zephir_create_array(&a, 1, 0 TSRMLS_CC); add_index_stringl(&a, b, SL("hello")); RETURN_CCTOR(&a); }
FOREACH_KEYVAL(pos, param, key, entry) { if (key.type == HASH_KEY_IS_STRING) { if (PHP_ICONV_ERR_SUCCESS != php_iconv_string(key.str, key.len-1, &xkey, &xlen, oe, ie)) { http_error_ex(HE_WARNING, HTTP_E_QUERYSTRING, "Failed to convert '%.*s' from '%s' to '%s'", key.len-1, key.str, ie, oe); return FAILURE; } } if (Z_TYPE_PP(entry) == IS_STRING) { if (PHP_ICONV_ERR_SUCCESS != php_iconv_string(Z_STRVAL_PP(entry), Z_STRLEN_PP(entry), &xlate_str, &xlate_len, oe, ie)) { if (key.type == HASH_KEY_IS_STRING) { efree(xkey); } http_error_ex(HE_WARNING, HTTP_E_QUERYSTRING, "Failed to convert '%.*s' from '%s' to '%s'", Z_STRLEN_PP(entry), Z_STRVAL_PP(entry), ie, oe); return FAILURE; } if (key.type == HASH_KEY_IS_STRING) { add_assoc_stringl_ex(array, xkey, xlen+1, xlate_str, xlate_len, 0); } else { add_index_stringl(array, key.num, xlate_str, xlate_len, 0); } } else if (Z_TYPE_PP(entry) == IS_ARRAY) { zval *subarray; MAKE_STD_ZVAL(subarray); array_init(subarray); if (key.type == HASH_KEY_IS_STRING) { add_assoc_zval_ex(array, xkey, xlen+1, subarray); } else { add_index_zval(array, key.num, subarray); } if (SUCCESS != http_querystring_xlate(subarray, *entry, ie, oe)) { if (key.type == HASH_KEY_IS_STRING) { efree(xkey); } return FAILURE; } } if (key.type == HASH_KEY_IS_STRING) { efree(xkey); } }
PHPAPI int php_sscanf_internal( char *string, char *format, int argCount, zval *args, int varStart, zval *return_value) { int numVars, nconversions, totalVars = -1; int i, result; zend_long value; int objIndex; char *end, *baseString; zval *current; char op = 0; int base = 0; int underflow = 0; size_t width; zend_long (*fn)() = NULL; char *ch, sch; int flags; char buf[64]; /* Temporary buffer to hold scanned number * strings before they are passed to strtoul() */ /* do some sanity checking */ if ((varStart > argCount) || (varStart < 0)){ varStart = SCAN_MAX_ARGS + 1; } numVars = argCount - varStart; if (numVars < 0) { numVars = 0; } #if 0 zend_printf("<br>in sscanf_internal : <br> string is \"%s\", format = \"%s\"<br> NumVars = %d. VarStart = %d<br>-------------------------<br>", string, format, numVars, varStart); #endif /* * Check for errors in the format string. */ if (ValidateFormat(format, numVars, &totalVars) != SCAN_SUCCESS) { scan_set_error_return( numVars, return_value ); return SCAN_ERROR_INVALID_FORMAT; } objIndex = numVars ? varStart : 0; /* * If any variables are passed, make sure they are all passed by reference */ if (numVars) { for (i = varStart;i < argCount;i++){ if ( ! Z_ISREF(args[ i ] ) ) { php_error_docref(NULL, E_WARNING, "Parameter %d must be passed by reference", i); scan_set_error_return(numVars, return_value); return SCAN_ERROR_VAR_PASSED_BYVAL; } } } /* * Allocate space for the result objects. Only happens when no variables * are specified */ if (!numVars) { zval tmp; /* allocate an array for return */ array_init(return_value); for (i = 0; i < totalVars; i++) { ZVAL_NULL(&tmp); if (add_next_index_zval(return_value, &tmp) == FAILURE) { scan_set_error_return(0, return_value); return FAILURE; } } varStart = 0; /* Array index starts from 0 */ } baseString = string; /* * Iterate over the format string filling in the result objects until * we reach the end of input, the end of the format string, or there * is a mismatch. */ nconversions = 0; /* note ! - we need to limit the loop for objIndex to keep it in bounds */ while (*format != '\0') { ch = format++; flags = 0; /* * If we see whitespace in the format, skip whitespace in the string. */ if ( isspace( (int)*ch ) ) { sch = *string; while ( isspace( (int)sch ) ) { if (*string == '\0') { goto done; } string++; sch = *string; } continue; } if (*ch != '%') { literal: if (*string == '\0') { underflow = 1; goto done; } sch = *string; string++; if (*ch != sch) { goto done; } continue; } ch = format++; if (*ch == '%') { goto literal; } /* * Check for assignment suppression ('*') or an XPG3-style * assignment ('%n$'). */ if (*ch == '*') { flags |= SCAN_SUPPRESS; ch = format++; } else if ( isdigit(UCHAR(*ch))) { value = ZEND_STRTOUL(format-1, &end, 10); if (*end == '$') { format = end+1; ch = format++; objIndex = varStart + value - 1; } } /* * Parse any width specifier. */ if ( isdigit(UCHAR(*ch))) { width = ZEND_STRTOUL(format-1, &format, 10); ch = format++; } else { width = 0; } /* * Ignore size specifier. */ if ((*ch == 'l') || (*ch == 'L') || (*ch == 'h')) { ch = format++; } /* * Handle the various field types. */ switch (*ch) { case 'n': if (!(flags & SCAN_SUPPRESS)) { if (numVars && objIndex >= argCount) { break; } else if (numVars) { current = Z_REFVAL(args[objIndex++]); zval_ptr_dtor(current); ZVAL_LONG(current, (zend_long)(string - baseString) ); } else { add_index_long(return_value, objIndex++, string - baseString); } } nconversions++; continue; case 'd': case 'D': op = 'i'; base = 10; fn = (zend_long (*)())ZEND_STRTOL_PTR; break; case 'i': op = 'i'; base = 0; fn = (zend_long (*)())ZEND_STRTOL_PTR; break; case 'o': op = 'i'; base = 8; fn = (zend_long (*)())ZEND_STRTOL_PTR; break; case 'x': case 'X': op = 'i'; base = 16; fn = (zend_long (*)())ZEND_STRTOL_PTR; break; case 'u': op = 'i'; base = 10; flags |= SCAN_UNSIGNED; fn = (zend_long (*)())ZEND_STRTOUL_PTR; break; case 'f': case 'e': case 'E': case 'g': op = 'f'; break; case 's': op = 's'; break; case 'c': op = 's'; flags |= SCAN_NOSKIP; /*-cc-*/ if (0 == width) { width = 1; } /*-cc-*/ break; case '[': op = '['; flags |= SCAN_NOSKIP; break; } /* switch */ /* * At this point, we will need additional characters from the * string to proceed. */ if (*string == '\0') { underflow = 1; goto done; } /* * Skip any leading whitespace at the beginning of a field unless * the format suppresses this behavior. */ if (!(flags & SCAN_NOSKIP)) { while (*string != '\0') { sch = *string; if (! isspace((int)sch) ) { break; } string++; } if (*string == '\0') { underflow = 1; goto done; } } /* * Perform the requested scanning operation. */ switch (op) { case 'c': case 's': /* * Scan a string up to width characters or whitespace. */ if (width == 0) { width = (size_t) ~0; } end = string; while (*end != '\0') { sch = *end; if ( isspace( (int)sch ) ) { break; } end++; if (--width == 0) { break; } } if (!(flags & SCAN_SUPPRESS)) { if (numVars && objIndex >= argCount) { break; } else if (numVars) { current = Z_REFVAL(args[objIndex++]); zval_ptr_dtor(current); ZVAL_STRINGL(current, string, end-string); } else { add_index_stringl(return_value, objIndex++, string, end-string); } } string = end; break; case '[': { CharSet cset; if (width == 0) { width = (size_t) ~0; } end = string; format = BuildCharSet(&cset, format); while (*end != '\0') { sch = *end; if (!CharInSet(&cset, (int)sch)) { break; } end++; if (--width == 0) { break; } } ReleaseCharSet(&cset); if (string == end) { /* * Nothing matched the range, stop processing */ goto done; } if (!(flags & SCAN_SUPPRESS)) { if (numVars && objIndex >= argCount) { break; } else if (numVars) { current = Z_REFVAL(args[objIndex++]); zval_ptr_dtor(current); ZVAL_STRINGL(current, string, end-string); } else { add_index_stringl(return_value, objIndex++, string, end-string); } } string = end; break; } /* case 'c': / Scan a single character./ sch = *string; string++; if (!(flags & SCAN_SUPPRESS)) { if (numVars) { char __buf[2]; __buf[0] = sch; __buf[1] = '\0';; current = args[objIndex++]; zval_dtor(*current); ZVAL_STRINGL( *current, __buf, 1); } else { add_index_stringl(return_value, objIndex++, &sch, 1); } } break; */ case 'i': /* * Scan an unsigned or signed integer. */ /*-cc-*/ buf[0] = '\0'; /*-cc-*/ if ((width == 0) || (width > sizeof(buf) - 1)) { width = sizeof(buf) - 1; } flags |= SCAN_SIGNOK | SCAN_NODIGITS | SCAN_NOZERO; for (end = buf; width > 0; width--) { switch (*string) { /* * The 0 digit has special meaning at the beginning of * a number. If we are unsure of the base, it * indicates that we are in base 8 or base 16 (if it is * followed by an 'x'). */ case '0': /*-cc-*/ if (base == 16) { flags |= SCAN_XOK; } /*-cc-*/ if (base == 0) { base = 8; flags |= SCAN_XOK; } if (flags & SCAN_NOZERO) { flags &= ~(SCAN_SIGNOK | SCAN_NODIGITS | SCAN_NOZERO); } else { flags &= ~(SCAN_SIGNOK | SCAN_XOK | SCAN_NODIGITS); } goto addToInt; case '1': case '2': case '3': case '4': case '5': case '6': case '7': if (base == 0) { base = 10; } flags &= ~(SCAN_SIGNOK | SCAN_XOK | SCAN_NODIGITS); goto addToInt; case '8': case '9': if (base == 0) { base = 10; } if (base <= 8) { break; } flags &= ~(SCAN_SIGNOK | SCAN_XOK | SCAN_NODIGITS); goto addToInt; case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': if (base <= 10) { break; } flags &= ~(SCAN_SIGNOK | SCAN_XOK | SCAN_NODIGITS); goto addToInt; case '+': case '-': if (flags & SCAN_SIGNOK) { flags &= ~SCAN_SIGNOK; goto addToInt; } break; case 'x': case 'X': if ((flags & SCAN_XOK) && (end == buf+1)) { base = 16; flags &= ~SCAN_XOK; goto addToInt; } break; } /* * We got an illegal character so we are done accumulating. */ break; addToInt: /* * Add the character to the temporary buffer. */ *end++ = *string++; if (*string == '\0') { break; } } /* * Check to see if we need to back up because we only got a * sign or a trailing x after a 0. */ if (flags & SCAN_NODIGITS) { if (*string == '\0') { underflow = 1; } goto done; } else if (end[-1] == 'x' || end[-1] == 'X') { end--; string--; } /* * Scan the value from the temporary buffer. If we are * returning a large unsigned value, we have to convert it back * to a string since PHP only supports signed values. */ if (!(flags & SCAN_SUPPRESS)) { *end = '\0'; value = (zend_long) (*fn)(buf, NULL, base); if ((flags & SCAN_UNSIGNED) && (value < 0)) { snprintf(buf, sizeof(buf), ZEND_ULONG_FMT, value); /* INTL: ISO digit */ if (numVars && objIndex >= argCount) { break; } else if (numVars) { /* change passed value type to string */ current = Z_REFVAL(args[objIndex++]); zval_ptr_dtor(current); ZVAL_STRING(current, buf); } else { add_index_string(return_value, objIndex++, buf); } } else { if (numVars && objIndex >= argCount) { break; } else if (numVars) { current = Z_REFVAL(args[objIndex++]); zval_ptr_dtor(current); ZVAL_LONG(current, value); } else { add_index_long(return_value, objIndex++, value); } } } break; case 'f': /* * Scan a floating point number */ buf[0] = '\0'; /* call me pedantic */ if ((width == 0) || (width > sizeof(buf) - 1)) { width = sizeof(buf) - 1; } flags |= SCAN_SIGNOK | SCAN_NODIGITS | SCAN_PTOK | SCAN_EXPOK; for (end = buf; width > 0; width--) { switch (*string) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': flags &= ~(SCAN_SIGNOK | SCAN_NODIGITS); goto addToFloat; case '+': case '-': if (flags & SCAN_SIGNOK) { flags &= ~SCAN_SIGNOK; goto addToFloat; } break; case '.': if (flags & SCAN_PTOK) { flags &= ~(SCAN_SIGNOK | SCAN_PTOK); goto addToFloat; } break; case 'e': case 'E': /* * An exponent is not allowed until there has * been at least one digit. */ if ((flags & (SCAN_NODIGITS | SCAN_EXPOK)) == SCAN_EXPOK) { flags = (flags & ~(SCAN_EXPOK|SCAN_PTOK)) | SCAN_SIGNOK | SCAN_NODIGITS; goto addToFloat; } break; } /* * We got an illegal character so we are done accumulating. */ break; addToFloat: /* * Add the character to the temporary buffer. */ *end++ = *string++; if (*string == '\0') { break; } } /* * Check to see if we need to back up because we saw a * trailing 'e' or sign. */ if (flags & SCAN_NODIGITS) { if (flags & SCAN_EXPOK) { /* * There were no digits at all so scanning has * failed and we are done. */ if (*string == '\0') { underflow = 1; } goto done; } /* * We got a bad exponent ('e' and maybe a sign). */ end--; string--; if (*end != 'e' && *end != 'E') { end--; string--; } } /* * Scan the value from the temporary buffer. */ if (!(flags & SCAN_SUPPRESS)) { double dvalue; *end = '\0'; dvalue = zend_strtod(buf, NULL); if (numVars && objIndex >= argCount) { break; } else if (numVars) { current = Z_REFVAL(args[objIndex++]); zval_ptr_dtor(current); ZVAL_DOUBLE(current, dvalue); } else { add_index_double(return_value, objIndex++, dvalue ); } } break; } /* switch (op) */ nconversions++; } /* while (*format != '\0') */ done: result = SCAN_SUCCESS; if (underflow && (0==nconversions)) { scan_set_error_return( numVars, return_value ); result = SCAN_ERROR_EOF; } else if (numVars) { convert_to_long(return_value ); Z_LVAL_P(return_value) = nconversions; } else if (nconversions < totalVars) { /* TODO: not all elements converted. we need to prune the list - cc */ } return result; }
/* {{{ _php_mb_regex_ereg_exec */ static void _php_mb_regex_ereg_exec(INTERNAL_FUNCTION_PARAMETERS, int icase) { zval *arg_pattern, *array = NULL; char *string; size_t string_len; php_mb_regex_t *re; OnigRegion *regs = NULL; int i, match_len, beg, end; OnigOptionType options; char *str; if (zend_parse_parameters(ZEND_NUM_ARGS(), "zs|z/", &arg_pattern, &string, &string_len, &array) == FAILURE) { RETURN_FALSE; } if (!php_mb_check_encoding( string, string_len, _php_mb_regex_mbctype2name(MBREX(current_mbctype)) )) { if (array != NULL) { zval_dtor(array); array_init(array); } RETURN_FALSE; } if (array != NULL) { zval_dtor(array); array_init(array); } options = MBREX(regex_default_options); if (icase) { options |= ONIG_OPTION_IGNORECASE; } /* compile the regular expression from the supplied regex */ if (Z_TYPE_P(arg_pattern) != IS_STRING) { /* we convert numbers to integers and treat them as a string */ if (Z_TYPE_P(arg_pattern) == IS_DOUBLE) { convert_to_long_ex(arg_pattern); /* get rid of decimal places */ } convert_to_string_ex(arg_pattern); /* don't bother doing an extended regex with just a number */ } if (Z_STRLEN_P(arg_pattern) == 0) { php_error_docref(NULL, E_WARNING, "empty pattern"); RETVAL_FALSE; goto out; } re = php_mbregex_compile_pattern(Z_STRVAL_P(arg_pattern), Z_STRLEN_P(arg_pattern), options, MBREX(current_mbctype), MBREX(regex_default_syntax)); if (re == NULL) { RETVAL_FALSE; goto out; } regs = onig_region_new(); /* actually execute the regular expression */ if (onig_search(re, (OnigUChar *)string, (OnigUChar *)(string + string_len), (OnigUChar *)string, (OnigUChar *)(string + string_len), regs, 0) < 0) { RETVAL_FALSE; goto out; } match_len = 1; str = string; if (array != NULL) { match_len = regs->end[0] - regs->beg[0]; for (i = 0; i < regs->num_regs; i++) { beg = regs->beg[i]; end = regs->end[i]; if (beg >= 0 && beg < end && (size_t)end <= string_len) { add_index_stringl(array, i, (char *)&str[beg], end - beg); } else { add_index_bool(array, i, 0); } } } if (match_len == 0) { match_len = 1; } RETVAL_LONG(match_len); out: if (regs != NULL) { onig_region_free(regs, 1); } }
/* {{{ _php_mb_regex_ereg_search_exec */ static void _php_mb_regex_ereg_search_exec(INTERNAL_FUNCTION_PARAMETERS, int mode) { char *arg_pattern = NULL, *arg_options = NULL; size_t arg_pattern_len, arg_options_len; int err; size_t n, i, pos, len, beg, end; OnigOptionType option; OnigUChar *str; OnigSyntaxType *syntax; if (zend_parse_parameters(ZEND_NUM_ARGS(), "|ss", &arg_pattern, &arg_pattern_len, &arg_options, &arg_options_len) == FAILURE) { return; } option = MBREX(regex_default_options); if (arg_options) { option = 0; _php_mb_regex_init_options(arg_options, arg_options_len, &option, &syntax, NULL); } if (arg_pattern) { /* create regex pattern buffer */ if ((MBREX(search_re) = php_mbregex_compile_pattern(arg_pattern, arg_pattern_len, option, MBREX(current_mbctype), MBREX(regex_default_syntax))) == NULL) { RETURN_FALSE; } } pos = MBREX(search_pos); str = NULL; len = 0; if (!Z_ISUNDEF(MBREX(search_str)) && Z_TYPE(MBREX(search_str)) == IS_STRING){ str = (OnigUChar *)Z_STRVAL(MBREX(search_str)); len = Z_STRLEN(MBREX(search_str)); } if (MBREX(search_re) == NULL) { php_error_docref(NULL, E_WARNING, "No regex given"); RETURN_FALSE; } if (str == NULL) { php_error_docref(NULL, E_WARNING, "No string given"); RETURN_FALSE; } if (MBREX(search_regs)) { onig_region_free(MBREX(search_regs), 1); } MBREX(search_regs) = onig_region_new(); err = onig_search(MBREX(search_re), str, str + len, str + pos, str + len, MBREX(search_regs), 0); if (err == ONIG_MISMATCH) { MBREX(search_pos) = len; RETVAL_FALSE; } else if (err <= -2) { OnigUChar err_str[ONIG_MAX_ERROR_MESSAGE_LEN]; onig_error_code_to_str(err_str, err); php_error_docref(NULL, E_WARNING, "mbregex search failure in mbregex_search(): %s", err_str); RETVAL_FALSE; } else { switch (mode) { case 1: array_init(return_value); beg = MBREX(search_regs)->beg[0]; end = MBREX(search_regs)->end[0]; add_next_index_long(return_value, beg); add_next_index_long(return_value, end - beg); break; case 2: array_init(return_value); n = MBREX(search_regs)->num_regs; for (i = 0; i < n; i++) { beg = MBREX(search_regs)->beg[i]; end = MBREX(search_regs)->end[i]; if (beg >= 0 && beg <= end && end <= len) { add_index_stringl(return_value, i, (char *)&str[beg], end - beg); } else { add_index_bool(return_value, i, 0); } } break; default: RETVAL_TRUE; break; } end = MBREX(search_regs)->end[0]; if (pos <= end) { MBREX(search_pos) = end; } else { MBREX(search_pos) = pos + 1; } } if (err < 0) { onig_region_free(MBREX(search_regs), 1); MBREX(search_regs) = (OnigRegion *)NULL; } }
/** * Sets the HTTP response code * *<code> * $response->setStatusCode(404, "Not Found"); *</code> */ PHP_METHOD(Phalcon_Http_Response, setStatusCode) { zval *_10; zephir_fcall_cache_entry *_7 = NULL, *_8 = NULL; zend_bool _4; HashTable *_2; HashPosition _1; zval *message = NULL, *_13, *_15; zval *code_param = NULL, *message_param = NULL, *headers = NULL, *currentHeadersRaw = NULL, *key = NULL, *defaultMessage, *_0 = NULL, **_3, _5 = zval_used_for_init, *_6 = NULL, *_9, *_11, *_12, _14; int code, ZEPHIR_LAST_CALL_STATUS; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &code_param, &message_param); code = zephir_get_intval(code_param); if (!message_param) { ZEPHIR_INIT_VAR(message); ZVAL_EMPTY_STRING(message); } else { zephir_get_strval(message, message_param); } ZEPHIR_CALL_METHOD(&headers, this_ptr, "getheaders", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(¤tHeadersRaw, headers, "toarray", NULL, 0); zephir_check_call_status(); if (Z_TYPE_P(currentHeadersRaw) == IS_ARRAY) { ZEPHIR_INIT_VAR(_0); zephir_is_iterable(currentHeadersRaw, &_2, &_1, 0, 0, "phalcon/http/response.zep", 130); for ( ; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS ; zephir_hash_move_forward_ex(_2, &_1) ) { ZEPHIR_GET_HMKEY(key, _2, _1); ZEPHIR_GET_HVALUE(_0, _3); _4 = Z_TYPE_P(key) == IS_STRING; if (_4) { ZEPHIR_SINIT_NVAR(_5); ZVAL_STRING(&_5, "HTTP/", 0); ZEPHIR_CALL_FUNCTION(&_6, "strstr", &_7, 235, key, &_5); zephir_check_call_status(); _4 = zephir_is_true(_6); } if (_4) { ZEPHIR_CALL_METHOD(NULL, headers, "remove", &_8, 0, key); zephir_check_call_status(); } } } if (ZEPHIR_IS_STRING_IDENTICAL(message, "")) { ZEPHIR_OBS_VAR(_9); zephir_read_property_this(&_9, this_ptr, SL("_statusCodes"), PH_NOISY_CC); if (Z_TYPE_P(_9) != IS_ARRAY) { ZEPHIR_INIT_VAR(_10); zephir_create_array(_10, 59, 0 TSRMLS_CC); add_index_stringl(_10, 100, SL("Continue"), 1); add_index_stringl(_10, 101, SL("Switching Protocols"), 1); add_index_stringl(_10, 102, SL("Processing"), 1); add_index_stringl(_10, 200, SL("OK"), 1); add_index_stringl(_10, 201, SL("Created"), 1); add_index_stringl(_10, 202, SL("Accepted"), 1); add_index_stringl(_10, 203, SL("Non-Authoritative Information"), 1); add_index_stringl(_10, 204, SL("No Content"), 1); add_index_stringl(_10, 205, SL("Reset Content"), 1); add_index_stringl(_10, 206, SL("Partial Content"), 1); add_index_stringl(_10, 207, SL("Multi-status"), 1); add_index_stringl(_10, 208, SL("Already Reported"), 1); add_index_stringl(_10, 300, SL("Multiple Choices"), 1); add_index_stringl(_10, 301, SL("Moved Permanently"), 1); add_index_stringl(_10, 302, SL("Found"), 1); add_index_stringl(_10, 303, SL("See Other"), 1); add_index_stringl(_10, 304, SL("Not Modified"), 1); add_index_stringl(_10, 305, SL("Use Proxy"), 1); add_index_stringl(_10, 306, SL("Switch Proxy"), 1); add_index_stringl(_10, 307, SL("Temporary Redirect"), 1); add_index_stringl(_10, 400, SL("Bad Request"), 1); add_index_stringl(_10, 401, SL("Unauthorized"), 1); add_index_stringl(_10, 402, SL("Payment Required"), 1); add_index_stringl(_10, 403, SL("Forbidden"), 1); add_index_stringl(_10, 404, SL("Not Found"), 1); add_index_stringl(_10, 405, SL("Method Not Allowed"), 1); add_index_stringl(_10, 406, SL("Not Acceptable"), 1); add_index_stringl(_10, 407, SL("Proxy Authentication Required"), 1); add_index_stringl(_10, 408, SL("Request Time-out"), 1); add_index_stringl(_10, 409, SL("Conflict"), 1); add_index_stringl(_10, 410, SL("Gone"), 1); add_index_stringl(_10, 411, SL("Length Required"), 1); add_index_stringl(_10, 412, SL("Precondition Failed"), 1); add_index_stringl(_10, 413, SL("Request Entity Too Large"), 1); add_index_stringl(_10, 414, SL("Request-URI Too Large"), 1); add_index_stringl(_10, 415, SL("Unsupported Media Type"), 1); add_index_stringl(_10, 416, SL("Requested range not satisfiable"), 1); add_index_stringl(_10, 417, SL("Expectation Failed"), 1); add_index_stringl(_10, 418, SL("I'm a teapot"), 1); add_index_stringl(_10, 422, SL("Unprocessable Entity"), 1); add_index_stringl(_10, 423, SL("Locked"), 1); add_index_stringl(_10, 424, SL("Failed Dependency"), 1); add_index_stringl(_10, 425, SL("Unordered Collection"), 1); add_index_stringl(_10, 426, SL("Upgrade Required"), 1); add_index_stringl(_10, 428, SL("Precondition Required"), 1); add_index_stringl(_10, 429, SL("Too Many Requests"), 1); add_index_stringl(_10, 431, SL("Request Header Fields Too Large"), 1); add_index_stringl(_10, 500, SL("Internal Server Error"), 1); add_index_stringl(_10, 501, SL("Not Implemented"), 1); add_index_stringl(_10, 502, SL("Bad Gateway"), 1); add_index_stringl(_10, 503, SL("Service Unavailable"), 1); add_index_stringl(_10, 504, SL("Gateway Time-out"), 1); add_index_stringl(_10, 505, SL("HTTP Version not supported"), 1); add_index_stringl(_10, 506, SL("Variant Also Negotiates"), 1); add_index_stringl(_10, 507, SL("Insufficient Storage"), 1); add_index_stringl(_10, 508, SL("Loop Detected"), 1); add_index_stringl(_10, 511, SL("Network Authentication Required"), 1); zephir_update_property_this(this_ptr, SL("_statusCodes"), _10 TSRMLS_CC); } _11 = zephir_fetch_nproperty_this(this_ptr, SL("_statusCodes"), PH_NOISY_CC); if (!(zephir_array_isset_long(_11, code))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_http_response_exception_ce, "Non-standard statuscode given without a message", "phalcon/http/response.zep", 204); return; } _12 = zephir_fetch_nproperty_this(this_ptr, SL("_statusCodes"), PH_NOISY_CC); ZEPHIR_OBS_VAR(defaultMessage); zephir_array_fetch_long(&defaultMessage, _12, code, PH_NOISY, "phalcon/http/response.zep", 207 TSRMLS_CC); zephir_get_strval(message, defaultMessage); } ZEPHIR_SINIT_NVAR(_5); ZVAL_LONG(&_5, code); ZEPHIR_INIT_VAR(_13); ZEPHIR_CONCAT_SVSV(_13, "HTTP/1.1 ", &_5, " ", message); ZEPHIR_CALL_METHOD(NULL, headers, "setraw", NULL, 0, _13); zephir_check_call_status(); ZEPHIR_SINIT_VAR(_14); ZVAL_LONG(&_14, code); ZEPHIR_INIT_VAR(_15); ZEPHIR_CONCAT_VSV(_15, &_14, " ", message); ZEPHIR_INIT_NVAR(_0); ZVAL_STRING(_0, "Status", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, headers, "set", NULL, 0, _0, _15); zephir_check_temp_parameter(_0); zephir_check_call_status(); RETURN_THIS(); }