str 263 Zend/zend.c zend_string *str = zval_get_string(expr); str 264 Zend/zend.c size_t len = ZSTR_LEN(str); str 267 Zend/zend.c write_func(ZSTR_VAL(str), len); str 270 Zend/zend.c zend_string_release(str); str 1037 Zend/zend.c char *str; str 1179 Zend/zend.c len = (int)zend_vspprintf(&str, 0, format, usr_copy); str 1180 Zend/zend.c ZVAL_NEW_STR(¶ms[1], zend_string_init(str, len, 0)); str 1181 Zend/zend.c efree(str); str 198 Zend/zend.h size_t (*write_function)(const char *str, size_t str_length); str 219 Zend/zend.h typedef int (*zend_write_func_t)(const char *str, size_t str_length); str 268 Zend/zend.h #define ZEND_WRITE(str, str_len) zend_write((str), (str_len)) str 269 Zend/zend.h #define ZEND_WRITE_EX(str, str_len) write_func((str), (str_len)) str 270 Zend/zend.h #define ZEND_PUTS(str) zend_write((str), strlen((str))) str 271 Zend/zend.h #define ZEND_PUTS_EX(str) write_func((str), strlen((str))) str 574 Zend/zend_API.c zend_string **str = va_arg(*va, zend_string **); str 575 Zend/zend_API.c if (!zend_parse_arg_path_str(arg, str, check_null)) { str 583 Zend/zend_API.c zend_string **str = va_arg(*va, zend_string **); str 584 Zend/zend_API.c if (!zend_parse_arg_str(arg, str, check_null)) { str 1376 Zend/zend_API.c ZEND_API int add_assoc_str_ex(zval *arg, const char *key, size_t key_len, zend_string *str) /* {{{ */ str 1380 Zend/zend_API.c ZVAL_STR(&tmp, str); str 1386 Zend/zend_API.c ZEND_API int add_assoc_string_ex(zval *arg, const char *key, size_t key_len, char *str) /* {{{ */ str 1390 Zend/zend_API.c ZVAL_STRING(&tmp, str); str 1396 Zend/zend_API.c ZEND_API int add_assoc_stringl_ex(zval *arg, const char *key, size_t key_len, char *str, size_t length) /* {{{ */ str 1400 Zend/zend_API.c ZVAL_STRINGL(&tmp, str, length); str 1460 Zend/zend_API.c ZEND_API int add_index_str(zval *arg, zend_ulong index, zend_string *str) /* {{{ */ str 1464 Zend/zend_API.c ZVAL_STR(&tmp, str); str 1469 Zend/zend_API.c ZEND_API int add_index_string(zval *arg, zend_ulong index, const char *str) /* {{{ */ str 1473 Zend/zend_API.c ZVAL_STRING(&tmp, str); str 1478 Zend/zend_API.c ZEND_API int add_index_stringl(zval *arg, zend_ulong index, const char *str, size_t length) /* {{{ */ str 1482 Zend/zend_API.c ZVAL_STRINGL(&tmp, str, length); str 1538 Zend/zend_API.c ZEND_API int add_next_index_str(zval *arg, zend_string *str) /* {{{ */ str 1542 Zend/zend_API.c ZVAL_STR(&tmp, str); str 1547 Zend/zend_API.c ZEND_API int add_next_index_string(zval *arg, const char *str) /* {{{ */ str 1551 Zend/zend_API.c ZVAL_STRING(&tmp, str); str 1556 Zend/zend_API.c ZEND_API int add_next_index_stringl(zval *arg, const char *str, size_t length) /* {{{ */ str 1560 Zend/zend_API.c ZVAL_STRINGL(&tmp, str, length); str 1571 Zend/zend_API.c ZEND_API zval *add_get_assoc_string_ex(zval *arg, const char *key, uint key_len, const char *str) /* {{{ */ str 1575 Zend/zend_API.c ZVAL_STRING(&tmp, str); str 1581 Zend/zend_API.c ZEND_API zval *add_get_assoc_stringl_ex(zval *arg, const char *key, uint key_len, const char *str, size_t length) /* {{{ */ str 1585 Zend/zend_API.c ZVAL_STRINGL(&tmp, str, length); str 1609 Zend/zend_API.c ZEND_API zval *add_get_index_str(zval *arg, zend_ulong index, zend_string *str) /* {{{ */ str 1613 Zend/zend_API.c ZVAL_STR(&tmp, str); str 1618 Zend/zend_API.c ZEND_API zval *add_get_index_string(zval *arg, zend_ulong index, const char *str) /* {{{ */ str 1622 Zend/zend_API.c ZVAL_STRING(&tmp, str); str 1627 Zend/zend_API.c ZEND_API zval *add_get_index_stringl(zval *arg, zend_ulong index, const char *str, size_t length) /* {{{ */ str 1631 Zend/zend_API.c ZVAL_STRINGL(&tmp, str, length); str 1749 Zend/zend_API.c ZEND_API int add_property_str_ex(zval *arg, const char *key, size_t key_len, zend_string *str) /* {{{ */ str 1754 Zend/zend_API.c ZVAL_STR(&tmp, str); str 1763 Zend/zend_API.c ZEND_API int add_property_string_ex(zval *arg, const char *key, size_t key_len, const char *str) /* {{{ */ str 1768 Zend/zend_API.c ZVAL_STRING(&tmp, str); str 1777 Zend/zend_API.c ZEND_API int add_property_stringl_ex(zval *arg, const char *key, size_t key_len, const char *str, size_t length) /* {{{ */ str 1782 Zend/zend_API.c ZVAL_STRINGL(&tmp, str, length); str 395 Zend/zend_API.h ZEND_API int add_assoc_str_ex(zval *arg, const char *key, size_t key_len, zend_string *str); str 396 Zend/zend_API.h ZEND_API int add_assoc_string_ex(zval *arg, const char *key, size_t key_len, char *str); str 397 Zend/zend_API.h ZEND_API int add_assoc_stringl_ex(zval *arg, const char *key, size_t key_len, char *str, size_t length); str 421 Zend/zend_API.h ZEND_API int add_index_str(zval *arg, zend_ulong idx, zend_string *str); str 422 Zend/zend_API.h ZEND_API int add_index_string(zval *arg, zend_ulong idx, const char *str); str 423 Zend/zend_API.h ZEND_API int add_index_stringl(zval *arg, zend_ulong idx, const char *str, size_t length); str 431 Zend/zend_API.h ZEND_API int add_next_index_str(zval *arg, zend_string *str); str 432 Zend/zend_API.h ZEND_API int add_next_index_string(zval *arg, const char *str); str 433 Zend/zend_API.h ZEND_API int add_next_index_stringl(zval *arg, const char *str, size_t length); str 436 Zend/zend_API.h ZEND_API zval *add_get_assoc_string_ex(zval *arg, const char *key, uint key_len, const char *str); str 437 Zend/zend_API.h ZEND_API zval *add_get_assoc_stringl_ex(zval *arg, const char *key, uint key_len, const char *str, size_t length); str 444 Zend/zend_API.h ZEND_API zval *add_get_index_str(zval *arg, zend_ulong index, zend_string *str); str 445 Zend/zend_API.h ZEND_API zval *add_get_index_string(zval *arg, zend_ulong idx, const char *str); str 446 Zend/zend_API.h ZEND_API zval *add_get_index_stringl(zval *arg, zend_ulong idx, const char *str, size_t length); str 455 Zend/zend_API.h ZEND_API int add_property_str_ex(zval *arg, const char *key, size_t key_len, zend_string *str); str 456 Zend/zend_API.h ZEND_API int add_property_string_ex(zval *arg, const char *key, size_t key_len, const char *str); str 457 Zend/zend_API.h ZEND_API int add_property_stringl_ex(zval *arg, const char *key, size_t key_len, const char *str, size_t length); str 556 Zend/zend_API.h #define CHECK_ZVAL_STRING(str) \ str 557 Zend/zend_API.h if (ZSTR_VAL(str)[ZSTR_LEN(str)] != '\0') { zend_error(E_WARNING, "String is not zero-terminated (%s)", ZSTR_VAL(str)); } str 558 Zend/zend_API.h #define CHECK_ZVAL_STRING_REL(str) \ str 559 Zend/zend_API.h if (ZSTR_VAL(str)[ZSTR_LEN(str)] != '\0') { zend_error(E_WARNING, "String is not zero-terminated (%s) (source: %s:%d)", ZSTR_VAL(str) ZEND_FILE_LINE_RELAY_CC); } str 687 Zend/zend_API.h #define Z_EXPECTED_TYPE_ENUM(id, str) id, str 688 Zend/zend_API.h #define Z_EXPECTED_TYPE_STR(id, str) str, str 1122 Zend/zend_API.h zend_string *str; str 1124 Zend/zend_API.h if (!zend_parse_arg_str(arg, &str, check_null)) { str 1127 Zend/zend_API.h if (check_null && UNEXPECTED(!str)) { str 1131 Zend/zend_API.h *dest = ZSTR_VAL(str); str 1132 Zend/zend_API.h *dest_len = ZSTR_LEN(str); str 1148 Zend/zend_API.h zend_string *str; str 1150 Zend/zend_API.h if (!zend_parse_arg_path_str(arg, &str, check_null)) { str 1153 Zend/zend_API.h if (check_null && UNEXPECTED(!str)) { str 1157 Zend/zend_API.h *dest = ZSTR_VAL(str); str 1158 Zend/zend_API.h *dest_len = ZSTR_LEN(str); str 554 Zend/zend_ast.c static void zend_ast_export_ex(smart_str *str, zend_ast *ast, int priority, int indent); str 556 Zend/zend_ast.c static void zend_ast_export_str(smart_str *str, zend_string *s) str 563 Zend/zend_ast.c smart_str_appendc(str, '\\'); str 564 Zend/zend_ast.c smart_str_appendc(str, c); str 566 Zend/zend_ast.c smart_str_appendc(str, c); str 571 Zend/zend_ast.c static void zend_ast_export_qstr(smart_str *str, char quote, zend_string *s) str 580 Zend/zend_ast.c smart_str_appends(str, "\\n"); str 583 Zend/zend_ast.c smart_str_appends(str, "\\r"); str 586 Zend/zend_ast.c smart_str_appends(str, "\\t"); str 589 Zend/zend_ast.c smart_str_appends(str, "\\f"); str 592 Zend/zend_ast.c smart_str_appends(str, "\\v"); str 599 Zend/zend_ast.c smart_str_appends(str, "\\e"); str 602 Zend/zend_ast.c smart_str_appends(str, "\\0"); str 603 Zend/zend_ast.c smart_str_appendc(str, '0' + (c / 8)); str 604 Zend/zend_ast.c smart_str_appendc(str, '0' + (c % 8)); str 609 Zend/zend_ast.c smart_str_appendc(str, '\\'); str 611 Zend/zend_ast.c smart_str_appendc(str, c); str 616 Zend/zend_ast.c static void zend_ast_export_indent(smart_str *str, int indent) str 619 Zend/zend_ast.c smart_str_appends(str, " "); str 624 Zend/zend_ast.c static void zend_ast_export_name(smart_str *str, zend_ast *ast, int priority, int indent) str 630 Zend/zend_ast.c smart_str_append(str, Z_STR_P(zv)); str 634 Zend/zend_ast.c zend_ast_export_ex(str, ast, priority, indent); str 637 Zend/zend_ast.c static void zend_ast_export_ns_name(smart_str *str, zend_ast *ast, int priority, int indent) str 644 Zend/zend_ast.c smart_str_appendc(str, '\\'); str 646 Zend/zend_ast.c smart_str_appends(str, "namespace\\"); str 648 Zend/zend_ast.c smart_str_append(str, Z_STR_P(zv)); str 652 Zend/zend_ast.c zend_ast_export_ex(str, ast, priority, indent); str 694 Zend/zend_ast.c static void zend_ast_export_var(smart_str *str, zend_ast *ast, int priority, int indent) str 700 Zend/zend_ast.c smart_str_append(str, Z_STR_P(zv)); str 704 Zend/zend_ast.c zend_ast_export_ex(str, ast, 0, indent); str 707 Zend/zend_ast.c smart_str_appendc(str, '{'); str 708 Zend/zend_ast.c zend_ast_export_name(str, ast, 0, indent); str 709 Zend/zend_ast.c smart_str_appendc(str, '}'); str 712 Zend/zend_ast.c static void zend_ast_export_list(smart_str *str, zend_ast_list *list, int separator, int priority, int indent) str 718 Zend/zend_ast.c smart_str_appends(str, ", "); str 720 Zend/zend_ast.c zend_ast_export_ex(str, list->child[i], priority, indent); str 725 Zend/zend_ast.c static void zend_ast_export_encaps_list(smart_str *str, char quote, zend_ast_list *list, int indent) str 736 Zend/zend_ast.c zend_ast_export_qstr(str, quote, Z_STR_P(zv)); str 744 Zend/zend_ast.c zend_ast_export_ex(str, ast, 0, indent); str 746 Zend/zend_ast.c smart_str_appendc(str, '{'); str 747 Zend/zend_ast.c zend_ast_export_ex(str, ast, 0, indent); str 748 Zend/zend_ast.c smart_str_appendc(str, '}'); str 754 Zend/zend_ast.c static void zend_ast_export_name_list(smart_str *str, zend_ast_list *list, int indent) str 760 Zend/zend_ast.c smart_str_appends(str, ", "); str 762 Zend/zend_ast.c zend_ast_export_name(str, list->child[i], 0, indent); str 767 Zend/zend_ast.c static void zend_ast_export_var_list(smart_str *str, zend_ast_list *list, int indent) str 773 Zend/zend_ast.c smart_str_appends(str, ", "); str 776 Zend/zend_ast.c smart_str_appendc(str, '&'); str 778 Zend/zend_ast.c smart_str_appendc(str, '$'); str 779 Zend/zend_ast.c zend_ast_export_name(str, list->child[i], 20, indent); str 784 Zend/zend_ast.c static void zend_ast_export_stmt(smart_str *str, zend_ast *ast, int indent) str 797 Zend/zend_ast.c zend_ast_export_stmt(str, ast, indent); str 801 Zend/zend_ast.c zend_ast_export_indent(str, indent); str 802 Zend/zend_ast.c zend_ast_export_ex(str, ast, 0, indent); str 819 Zend/zend_ast.c smart_str_appendc(str, ';'); str 822 Zend/zend_ast.c smart_str_appendc(str, '\n'); str 826 Zend/zend_ast.c static void zend_ast_export_if_stmt(smart_str *str, zend_ast_list *list, int indent) str 838 Zend/zend_ast.c smart_str_appends(str, "if ("); str 840 Zend/zend_ast.c zend_ast_export_indent(str, indent); str 841 Zend/zend_ast.c smart_str_appends(str, "} elseif ("); str 843 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[0], 0, indent); str 844 Zend/zend_ast.c smart_str_appends(str, ") {\n"); str 845 Zend/zend_ast.c zend_ast_export_stmt(str, ast->child[1], indent + 1); str 847 Zend/zend_ast.c zend_ast_export_indent(str, indent); str 848 Zend/zend_ast.c smart_str_appends(str, "} else "); str 853 Zend/zend_ast.c smart_str_appends(str, "{\n"); str 854 Zend/zend_ast.c zend_ast_export_stmt(str, ast->child[1], indent + 1); str 859 Zend/zend_ast.c zend_ast_export_indent(str, indent); str 860 Zend/zend_ast.c smart_str_appendc(str, '}'); str 863 Zend/zend_ast.c static void zend_ast_export_zval(smart_str *str, zval *zv, int priority, int indent) str 873 Zend/zend_ast.c smart_str_appends(str, "null"); str 876 Zend/zend_ast.c smart_str_appends(str, "false"); str 879 Zend/zend_ast.c smart_str_appends(str, "true"); str 882 Zend/zend_ast.c smart_str_append_long(str, Z_LVAL_P(zv)); str 886 Zend/zend_ast.c smart_str_appendl(str, ZSTR_VAL(key), ZSTR_LEN(key)); str 890 Zend/zend_ast.c smart_str_appendc(str, '\''); str 891 Zend/zend_ast.c zend_ast_export_str(str, Z_STR_P(zv)); str 892 Zend/zend_ast.c smart_str_appendc(str, '\''); str 895 Zend/zend_ast.c smart_str_appendc(str, '['); str 901 Zend/zend_ast.c smart_str_appends(str, ", "); str 904 Zend/zend_ast.c smart_str_appendc(str, '\''); str 905 Zend/zend_ast.c zend_ast_export_str(str, key); str 906 Zend/zend_ast.c smart_str_appends(str, "' => "); str 908 Zend/zend_ast.c smart_str_append_long(str, idx); str 909 Zend/zend_ast.c smart_str_appends(str, " => "); str 911 Zend/zend_ast.c zend_ast_export_zval(str, val, 0, indent); str 913 Zend/zend_ast.c smart_str_appendc(str, ']'); str 916 Zend/zend_ast.c smart_str_appendl(str, Z_STRVAL_P(zv), Z_STRLEN_P(zv)); str 919 Zend/zend_ast.c zend_ast_export_ex(str, Z_ASTVAL_P(zv), priority, indent); str 967 Zend/zend_ast.c static void zend_ast_export_ex(smart_str *str, zend_ast *ast, int priority, int indent) str 980 Zend/zend_ast.c zend_ast_export_zval(str, zend_ast_get_zval(ast), priority, indent); str 993 Zend/zend_ast.c smart_str_appends(str, "public "); str 995 Zend/zend_ast.c smart_str_appends(str, "protected "); str 997 Zend/zend_ast.c smart_str_appends(str, "private "); str 1000 Zend/zend_ast.c smart_str_appends(str, "static "); str 1003 Zend/zend_ast.c smart_str_appends(str, "abstract "); str 1006 Zend/zend_ast.c smart_str_appends(str, "final "); str 1008 Zend/zend_ast.c smart_str_appends(str, "function "); str 1010 Zend/zend_ast.c smart_str_appendc(str, '&'); str 1013 Zend/zend_ast.c smart_str_appendl(str, ZSTR_VAL(decl->name), ZSTR_LEN(decl->name)); str 1015 Zend/zend_ast.c smart_str_appendc(str, '('); str 1016 Zend/zend_ast.c zend_ast_export_ex(str, decl->child[0], 0, indent); str 1017 Zend/zend_ast.c smart_str_appendc(str, ')'); str 1018 Zend/zend_ast.c zend_ast_export_ex(str, decl->child[1], 0, indent); str 1020 Zend/zend_ast.c smart_str_appends(str, ": "); str 1021 Zend/zend_ast.c zend_ast_export_ns_name(str, decl->child[3], 0, indent); str 1024 Zend/zend_ast.c smart_str_appends(str, " {\n"); str 1025 Zend/zend_ast.c zend_ast_export_stmt(str, decl->child[2], indent + 1); str 1026 Zend/zend_ast.c zend_ast_export_indent(str, indent); str 1027 Zend/zend_ast.c smart_str_appendc(str, '}'); str 1029 Zend/zend_ast.c smart_str_appendc(str, '\n'); str 1032 Zend/zend_ast.c smart_str_appends(str, ";\n"); str 1038 Zend/zend_ast.c smart_str_appends(str, "interface "); str 1040 Zend/zend_ast.c smart_str_appends(str, "trait "); str 1043 Zend/zend_ast.c smart_str_appends(str, "abstract "); str 1046 Zend/zend_ast.c smart_str_appends(str, "final "); str 1048 Zend/zend_ast.c smart_str_appends(str, "class "); str 1050 Zend/zend_ast.c smart_str_appendl(str, ZSTR_VAL(decl->name), ZSTR_LEN(decl->name)); str 1052 Zend/zend_ast.c smart_str_appends(str, " extends "); str 1053 Zend/zend_ast.c zend_ast_export_ns_name(str, decl->child[0], 0, indent); str 1056 Zend/zend_ast.c smart_str_appends(str, " implements "); str 1057 Zend/zend_ast.c zend_ast_export_ex(str, decl->child[1], 0, indent); str 1059 Zend/zend_ast.c smart_str_appends(str, " {\n"); str 1060 Zend/zend_ast.c zend_ast_export_stmt(str, decl->child[2], indent + 1); str 1061 Zend/zend_ast.c zend_ast_export_indent(str, indent); str 1062 Zend/zend_ast.c smart_str_appends(str, "}\n"); str 1070 Zend/zend_ast.c zend_ast_export_list(str, (zend_ast_list*)ast, 1, 20, indent); str 1073 Zend/zend_ast.c smart_str_appends(str, "list("); str 1074 Zend/zend_ast.c zend_ast_export_list(str, (zend_ast_list*)ast, 1, 20, indent); str 1075 Zend/zend_ast.c smart_str_appendc(str, ')'); str 1078 Zend/zend_ast.c smart_str_appendc(str, '['); str 1079 Zend/zend_ast.c zend_ast_export_list(str, (zend_ast_list*)ast, 1, 20, indent); str 1080 Zend/zend_ast.c smart_str_appendc(str, ']'); str 1083 Zend/zend_ast.c smart_str_appendc(str, '"'); str 1084 Zend/zend_ast.c zend_ast_export_encaps_list(str, '"', (zend_ast_list*)ast, indent); str 1085 Zend/zend_ast.c smart_str_appendc(str, '"'); str 1089 Zend/zend_ast.c zend_ast_export_stmt(str, ast, indent); str 1092 Zend/zend_ast.c zend_ast_export_if_stmt(str, (zend_ast_list*)ast, indent); str 1096 Zend/zend_ast.c zend_ast_export_list(str, (zend_ast_list*)ast, 0, 0, indent); str 1099 Zend/zend_ast.c smart_str_appends(str, " use("); str 1100 Zend/zend_ast.c zend_ast_export_var_list(str, (zend_ast_list*)ast, indent); str 1101 Zend/zend_ast.c smart_str_appendc(str, ')'); str 1105 Zend/zend_ast.c smart_str_appends(str, "public "); str 1107 Zend/zend_ast.c smart_str_appends(str, "protected "); str 1109 Zend/zend_ast.c smart_str_appends(str, "private "); str 1112 Zend/zend_ast.c smart_str_appends(str, "static "); str 1117 Zend/zend_ast.c smart_str_appends(str, "const "); str 1120 Zend/zend_ast.c zend_ast_export_name_list(str, (zend_ast_list*)ast, indent); str 1123 Zend/zend_ast.c smart_str_appends(str, "use "); str 1125 Zend/zend_ast.c smart_str_appends(str, "function "); str 1127 Zend/zend_ast.c smart_str_appends(str, "const "); str 1155 Zend/zend_ast.c smart_str_appendc(str, '$'); str 1156 Zend/zend_ast.c zend_ast_export_var(str, ast->child[0], 0, indent); str 1159 Zend/zend_ast.c zend_ast_export_ns_name(str, ast->child[0], 0, indent); str 1162 Zend/zend_ast.c smart_str_appends(str, "..."); str 1186 Zend/zend_ast.c smart_str_appendc(str, '`'); str 1188 Zend/zend_ast.c zend_ast_export_encaps_list(str, '`', (zend_ast_list*)ast->child[0], indent); str 1190 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[0], 0, indent); str 1192 Zend/zend_ast.c smart_str_appendc(str, '`'); str 1238 Zend/zend_ast.c zend_ast_export_name(str, ast->child[0], 0, indent); str 1239 Zend/zend_ast.c smart_str_appendc(str, ':'); str 1242 Zend/zend_ast.c smart_str_appendc(str, '&'); str 1252 Zend/zend_ast.c smart_str_appends(str, "goto "); str 1253 Zend/zend_ast.c zend_ast_export_name(str, ast->child[0], 0, indent); str 1262 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[0], 260, indent); str 1263 Zend/zend_ast.c smart_str_appendc(str, '['); str 1265 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[1], 0, indent); str 1267 Zend/zend_ast.c smart_str_appendc(str, ']'); str 1270 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[0], 0, indent); str 1271 Zend/zend_ast.c smart_str_appends(str, "->"); str 1272 Zend/zend_ast.c zend_ast_export_var(str, ast->child[1], 0, indent); str 1275 Zend/zend_ast.c zend_ast_export_ns_name(str, ast->child[0], 0, indent); str 1276 Zend/zend_ast.c smart_str_appends(str, "::$"); str 1277 Zend/zend_ast.c zend_ast_export_var(str, ast->child[1], 0, indent); str 1280 Zend/zend_ast.c zend_ast_export_ns_name(str, ast->child[0], 0, indent); str 1281 Zend/zend_ast.c smart_str_appendc(str, '('); str 1282 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[1], 0, indent); str 1283 Zend/zend_ast.c smart_str_appendc(str, ')'); str 1286 Zend/zend_ast.c zend_ast_export_ns_name(str, ast->child[0], 0, indent); str 1287 Zend/zend_ast.c smart_str_appends(str, "::"); str 1288 Zend/zend_ast.c zend_ast_export_name(str, ast->child[1], 0, indent); str 1340 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[1], 80, indent); str 1341 Zend/zend_ast.c smart_str_appends(str, " => "); str 1343 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[0], 80, indent); str 1346 Zend/zend_ast.c smart_str_appends(str, "new "); str 1347 Zend/zend_ast.c zend_ast_export_ns_name(str, ast->child[0], 0, indent); str 1348 Zend/zend_ast.c smart_str_appendc(str, '('); str 1349 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[1], 0, indent); str 1350 Zend/zend_ast.c smart_str_appendc(str, ')'); str 1353 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[0], 0, indent); str 1354 Zend/zend_ast.c smart_str_appends(str, " instanceof "); str 1355 Zend/zend_ast.c zend_ast_export_ns_name(str, ast->child[1], 0, indent); str 1358 Zend/zend_ast.c if (priority > 70) smart_str_appendc(str, '('); str 1359 Zend/zend_ast.c smart_str_appends(str, "yield "); str 1362 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[1], 70, indent); str 1363 Zend/zend_ast.c smart_str_appends(str, " => "); str 1365 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[0], 70, indent); str 1367 Zend/zend_ast.c if (priority > 70) smart_str_appendc(str, ')'); str 1373 Zend/zend_ast.c smart_str_appends(str, "static $"); str 1374 Zend/zend_ast.c zend_ast_export_name(str, ast->child[0], 0, indent); str 1377 Zend/zend_ast.c smart_str_appends(str, "while ("); str 1378 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[0], 0, indent); str 1379 Zend/zend_ast.c smart_str_appends(str, ") {\n"); str 1380 Zend/zend_ast.c zend_ast_export_stmt(str, ast->child[1], indent + 1); str 1381 Zend/zend_ast.c zend_ast_export_indent(str, indent); str 1382 Zend/zend_ast.c smart_str_appendc(str, '}'); str 1385 Zend/zend_ast.c smart_str_appends(str, "do {\n"); str 1386 Zend/zend_ast.c zend_ast_export_stmt(str, ast->child[0], indent + 1); str 1387 Zend/zend_ast.c zend_ast_export_indent(str, indent); str 1388 Zend/zend_ast.c smart_str_appends(str, "} while ("); str 1389 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[1], 0, indent); str 1390 Zend/zend_ast.c smart_str_appendc(str, ')'); str 1395 Zend/zend_ast.c smart_str_appends(str, "if ("); str 1396 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[0], 0, indent); str 1397 Zend/zend_ast.c smart_str_appends(str, ") {\n"); str 1398 Zend/zend_ast.c zend_ast_export_stmt(str, ast->child[1], indent + 1); str 1400 Zend/zend_ast.c smart_str_appends(str, "else {\n"); str 1401 Zend/zend_ast.c zend_ast_export_stmt(str, ast->child[1], indent + 1); str 1403 Zend/zend_ast.c zend_ast_export_indent(str, indent); str 1404 Zend/zend_ast.c smart_str_appendc(str, '}'); str 1407 Zend/zend_ast.c smart_str_appends(str, "switch ("); str 1408 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[0], 0, indent); str 1409 Zend/zend_ast.c smart_str_appends(str, ") {\n"); str 1410 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[1], 0, indent + 1); str 1411 Zend/zend_ast.c zend_ast_export_indent(str, indent); str 1412 Zend/zend_ast.c smart_str_appendc(str, '}'); str 1415 Zend/zend_ast.c zend_ast_export_indent(str, indent); str 1417 Zend/zend_ast.c smart_str_appends(str, "case "); str 1418 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[0], 0, indent); str 1419 Zend/zend_ast.c smart_str_appends(str, ":\n"); str 1421 Zend/zend_ast.c smart_str_appends(str, "default:\n"); str 1423 Zend/zend_ast.c zend_ast_export_stmt(str, ast->child[1], indent + 1); str 1426 Zend/zend_ast.c smart_str_appends(str, "declare("); str 1428 Zend/zend_ast.c zend_ast_export_list(str, (zend_ast_list*)ast->child[0], 1, 0, indent); str 1429 Zend/zend_ast.c smart_str_appendc(str, ')'); str 1431 Zend/zend_ast.c smart_str_appends(str, " {\n"); str 1432 Zend/zend_ast.c zend_ast_export_stmt(str, ast->child[1], indent + 1); str 1433 Zend/zend_ast.c zend_ast_export_indent(str, indent); str 1434 Zend/zend_ast.c smart_str_appendc(str, '}'); str 1436 Zend/zend_ast.c smart_str_appendc(str, ';'); str 1440 Zend/zend_ast.c smart_str_appendc(str, '$'); str 1443 Zend/zend_ast.c zend_ast_export_name(str, ast->child[0], 0, indent); str 1446 Zend/zend_ast.c smart_str_appends(str, "use "); str 1447 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[0], 0, indent); str 1449 Zend/zend_ast.c smart_str_appends(str, " {\n"); str 1450 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[1], 0, indent + 1); str 1451 Zend/zend_ast.c zend_ast_export_indent(str, indent); str 1452 Zend/zend_ast.c smart_str_appends(str, "}"); str 1454 Zend/zend_ast.c smart_str_appends(str, ";"); str 1458 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[0], 0, indent); str 1459 Zend/zend_ast.c smart_str_appends(str, " insteadof "); str 1460 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[1], 0, indent); str 1464 Zend/zend_ast.c zend_ast_export_name(str, ast->child[0], 0, indent); str 1465 Zend/zend_ast.c smart_str_appends(str, "::"); str 1467 Zend/zend_ast.c zend_ast_export_name(str, ast->child[1], 0, indent); str 1470 Zend/zend_ast.c smart_str_appends(str, "namespace"); str 1472 Zend/zend_ast.c smart_str_appendc(str, ' '); str 1473 Zend/zend_ast.c zend_ast_export_name(str, ast->child[0], 0, indent); str 1476 Zend/zend_ast.c smart_str_appends(str, " {\n"); str 1477 Zend/zend_ast.c zend_ast_export_stmt(str, ast->child[1], indent + 1); str 1478 Zend/zend_ast.c zend_ast_export_indent(str, indent); str 1479 Zend/zend_ast.c smart_str_appends(str, "}\n"); str 1481 Zend/zend_ast.c smart_str_appendc(str, ';'); str 1486 Zend/zend_ast.c zend_ast_export_name(str, ast->child[0], 0, indent); str 1488 Zend/zend_ast.c smart_str_appends(str, " as public"); str 1490 Zend/zend_ast.c smart_str_appends(str, " as protected"); str 1492 Zend/zend_ast.c smart_str_appends(str, " as private"); str 1494 Zend/zend_ast.c smart_str_appends(str, " as"); str 1497 Zend/zend_ast.c smart_str_appendc(str, ' '); str 1498 Zend/zend_ast.c zend_ast_export_name(str, ast->child[1], 0, indent); str 1504 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[0], 0, indent); str 1505 Zend/zend_ast.c smart_str_appends(str, "->"); str 1506 Zend/zend_ast.c zend_ast_export_var(str, ast->child[1], 0, indent); str 1507 Zend/zend_ast.c smart_str_appendc(str, '('); str 1508 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[2], 0, indent); str 1509 Zend/zend_ast.c smart_str_appendc(str, ')'); str 1512 Zend/zend_ast.c zend_ast_export_ns_name(str, ast->child[0], 0, indent); str 1513 Zend/zend_ast.c smart_str_appends(str, "::"); str 1514 Zend/zend_ast.c zend_ast_export_var(str, ast->child[1], 0, indent); str 1515 Zend/zend_ast.c smart_str_appendc(str, '('); str 1516 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[2], 0, indent); str 1517 Zend/zend_ast.c smart_str_appendc(str, ')'); str 1520 Zend/zend_ast.c if (priority > 100) smart_str_appendc(str, '('); str 1521 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[0], 100, indent); str 1523 Zend/zend_ast.c smart_str_appends(str, " ? "); str 1524 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[1], 101, indent); str 1525 Zend/zend_ast.c smart_str_appends(str, " : "); str 1527 Zend/zend_ast.c smart_str_appends(str, " ?: "); str 1529 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[2], 101, indent); str 1530 Zend/zend_ast.c if (priority > 100) smart_str_appendc(str, ')'); str 1534 Zend/zend_ast.c smart_str_appends(str, "try {\n"); str 1535 Zend/zend_ast.c zend_ast_export_stmt(str, ast->child[0], indent + 1); str 1536 Zend/zend_ast.c zend_ast_export_indent(str, indent); str 1537 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[1], 0, indent); str 1539 Zend/zend_ast.c smart_str_appends(str, "} finally {\n"); str 1540 Zend/zend_ast.c zend_ast_export_stmt(str, ast->child[2], indent + 1); str 1541 Zend/zend_ast.c zend_ast_export_indent(str, indent); str 1543 Zend/zend_ast.c smart_str_appendc(str, '}'); str 1546 Zend/zend_ast.c smart_str_appends(str, "} catch ("); str 1547 Zend/zend_ast.c zend_ast_export_ns_name(str, ast->child[0], 0, indent); str 1548 Zend/zend_ast.c smart_str_appends(str, " $"); str 1549 Zend/zend_ast.c zend_ast_export_var(str, ast->child[1], 0, indent); str 1550 Zend/zend_ast.c smart_str_appends(str, ") {\n"); str 1551 Zend/zend_ast.c zend_ast_export_stmt(str, ast->child[2], indent + 1); str 1552 Zend/zend_ast.c zend_ast_export_indent(str, indent); str 1556 Zend/zend_ast.c zend_ast_export_ns_name(str, ast->child[0], 0, indent); str 1557 Zend/zend_ast.c smart_str_appendc(str, ' '); str 1560 Zend/zend_ast.c smart_str_appendc(str, '&'); str 1563 Zend/zend_ast.c smart_str_appends(str, "..."); str 1565 Zend/zend_ast.c smart_str_appendc(str, '$'); str 1566 Zend/zend_ast.c zend_ast_export_name(str, ast->child[1], 0, indent); str 1571 Zend/zend_ast.c smart_str_appends(str, "for ("); str 1572 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[0], 0, indent); str 1573 Zend/zend_ast.c smart_str_appendc(str, ';'); str 1575 Zend/zend_ast.c smart_str_appendc(str, ' '); str 1576 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[1], 0, indent); str 1578 Zend/zend_ast.c smart_str_appendc(str, ';'); str 1580 Zend/zend_ast.c smart_str_appendc(str, ' '); str 1581 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[2], 0, indent); str 1583 Zend/zend_ast.c smart_str_appends(str, ") {\n"); str 1584 Zend/zend_ast.c zend_ast_export_stmt(str, ast->child[3], indent + 1); str 1585 Zend/zend_ast.c zend_ast_export_indent(str, indent); str 1586 Zend/zend_ast.c smart_str_appendc(str, '}'); str 1589 Zend/zend_ast.c smart_str_appends(str, "foreach ("); str 1590 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[0], 0, indent); str 1591 Zend/zend_ast.c smart_str_appends(str, " as "); str 1593 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[2], 0, indent); str 1594 Zend/zend_ast.c smart_str_appends(str, " => "); str 1596 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[1], 0, indent); str 1597 Zend/zend_ast.c smart_str_appends(str, ") {\n"); str 1598 Zend/zend_ast.c zend_ast_export_stmt(str, ast->child[3], indent + 1); str 1599 Zend/zend_ast.c zend_ast_export_indent(str, indent); str 1600 Zend/zend_ast.c smart_str_appendc(str, '}'); str 1607 Zend/zend_ast.c if (priority > p) smart_str_appendc(str, '('); str 1608 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[0], pl, indent); str 1609 Zend/zend_ast.c smart_str_appends(str, op); str 1610 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[1], pr, indent); str 1611 Zend/zend_ast.c if (priority > p) smart_str_appendc(str, ')'); str 1615 Zend/zend_ast.c if (priority > p) smart_str_appendc(str, '('); str 1616 Zend/zend_ast.c smart_str_appends(str, op); str 1617 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[0], pl, indent); str 1618 Zend/zend_ast.c if (priority > p) smart_str_appendc(str, ')'); str 1622 Zend/zend_ast.c if (priority > p) smart_str_appendc(str, '('); str 1623 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[0], pl, indent); str 1624 Zend/zend_ast.c smart_str_appends(str, op); str 1625 Zend/zend_ast.c if (priority > p) smart_str_appendc(str, ')'); str 1629 Zend/zend_ast.c smart_str_appends(str, op); str 1630 Zend/zend_ast.c smart_str_appendc(str, '('); str 1631 Zend/zend_ast.c zend_ast_export_ex(str, ast->child[0], 0, indent); str 1632 Zend/zend_ast.c smart_str_appendc(str, ')'); str 1636 Zend/zend_ast.c smart_str_appends(str, op); str 1638 Zend/zend_ast.c smart_str_appendc(str, ' '); str 1645 Zend/zend_ast.c smart_str_appends(str, op); str 1650 Zend/zend_ast.c smart_str_appends(str, " = "); str 1659 Zend/zend_ast.c smart_str str = {0}; str 1661 Zend/zend_ast.c smart_str_appends(&str, prefix); str 1662 Zend/zend_ast.c zend_ast_export_ex(&str, ast, 0, 0); str 1663 Zend/zend_ast.c smart_str_appends(&str, suffix); str 1664 Zend/zend_ast.c smart_str_0(&str); str 1665 Zend/zend_ast.c return str.s; str 250 Zend/zend_ast.h static zend_always_inline zend_ast *zend_ast_create_zval_from_str(zend_string *str) { str 252 Zend/zend_ast.h ZVAL_STR(&zv, str); str 111 Zend/zend_builtin_functions.c ZEND_ARG_INFO(0, str) str 98 Zend/zend_compile.c static zend_string *zend_new_interned_string_safe(zend_string *str) /* {{{ */ { str 101 Zend/zend_compile.c zend_string_addref(str); str 102 Zend/zend_compile.c interned_str = zend_new_interned_string(str); str 103 Zend/zend_compile.c if (str != interned_str) { str 106 Zend/zend_compile.c zend_string_release(str); str 107 Zend/zend_compile.c return str; str 456 Zend/zend_compile.c static inline int zend_add_literal_string(zend_op_array *op_array, zend_string **str) /* {{{ */ str 460 Zend/zend_compile.c ZVAL_STR(&zv, *str); str 462 Zend/zend_compile.c *str = Z_STR(zv); str 560 Zend/zend_compile.c #define LITERAL_STR(op, str) do { \ str 562 Zend/zend_compile.c ZVAL_STR(&_c, str); \ str 741 Zend/zend_compile.c void *zend_hash_find_ptr_lc(HashTable *ht, const char *str, size_t len) { str 747 Zend/zend_compile.c zend_str_tolower_copy(ZSTR_VAL(lcname), str, len); str 2867 Zend/zend_compile.c zend_string *str = Z_STR(name_node->u.constant); str 2868 Zend/zend_compile.c if ((colon = zend_memrchr(ZSTR_VAL(str), ':', ZSTR_LEN(str))) != NULL && colon > ZSTR_VAL(str) && *(colon - 1) == ':') { str 2869 Zend/zend_compile.c zend_string *class = zend_string_init(ZSTR_VAL(str), colon - ZSTR_VAL(str) - 1, 0); str 2870 Zend/zend_compile.c zend_string *method = zend_string_init(colon + 1, ZSTR_LEN(str) - (colon - ZSTR_VAL(str)) - 1, 0); str 2882 Zend/zend_compile.c opline->op2.constant = zend_add_func_name_literal(CG(active_op_array), str); str 142 Zend/zend_compile.h zend_string *str; str 44 Zend/zend_constants.h #define REGISTER_STRING_CONSTANT(name, str, flags) zend_register_string_constant((name), sizeof(name)-1, (str), (flags), module_number) str 45 Zend/zend_constants.h #define REGISTER_STRINGL_CONSTANT(name, str, len, flags) zend_register_stringl_constant((name), sizeof(name)-1, (str), (len), (flags), module_number) str 51 Zend/zend_constants.h #define REGISTER_NS_STRING_CONSTANT(ns, name, str, flags) zend_register_string_constant(ZEND_NS_NAME(ns, name), sizeof(ZEND_NS_NAME(ns, name))-1, (str), (flags), module_number) str 52 Zend/zend_constants.h #define REGISTER_NS_STRINGL_CONSTANT(ns, name, str, len, flags) zend_register_stringl_constant(ZEND_NS_NAME(ns, name), sizeof(ZEND_NS_NAME(ns, name))-1, (str), (len), (flags), module_number) str 58 Zend/zend_constants.h #define REGISTER_MAIN_STRING_CONSTANT(name, str, flags) zend_register_string_constant((name), sizeof(name)-1, (str), (flags), 0) str 59 Zend/zend_constants.h #define REGISTER_MAIN_STRINGL_CONSTANT(name, str, len, flags) zend_register_stringl_constant((name), sizeof(name)-1, (str), (len), (flags), 0) str 452 Zend/zend_exceptions.c smart_str_appends(str, "[unknown]"); \ str 454 Zend/zend_exceptions.c smart_str_appends(str, Z_STRVAL_P(tmp)); \ str 478 Zend/zend_exceptions.c static void smart_str_append_escaped(smart_str *str, const char *s, size_t l) { str 482 Zend/zend_exceptions.c smart_str_alloc(str, len, 0); str 483 Zend/zend_exceptions.c res = &ZSTR_VAL(str->s)[ZSTR_LEN(str->s)]; str 484 Zend/zend_exceptions.c ZSTR_LEN(str->s) += len; str 517 Zend/zend_exceptions.c static void _build_trace_args(zval *arg, smart_str *str) /* {{{ */ str 528 Zend/zend_exceptions.c smart_str_appends(str, "NULL, "); str 531 Zend/zend_exceptions.c smart_str_appendc(str, '\''); str 532 Zend/zend_exceptions.c smart_str_append_escaped(str, Z_STRVAL_P(arg), MIN(Z_STRLEN_P(arg), 15)); str 534 Zend/zend_exceptions.c smart_str_appends(str, "...', "); str 536 Zend/zend_exceptions.c smart_str_appends(str, "', "); str 540 Zend/zend_exceptions.c smart_str_appends(str, "false, "); str 543 Zend/zend_exceptions.c smart_str_appends(str, "true, "); str 546 Zend/zend_exceptions.c smart_str_appends(str, "Resource id #"); str 547 Zend/zend_exceptions.c smart_str_append_long(str, Z_RES_HANDLE_P(arg)); str 548 Zend/zend_exceptions.c smart_str_appends(str, ", "); str 551 Zend/zend_exceptions.c smart_str_append_long(str, Z_LVAL_P(arg)); str 552 Zend/zend_exceptions.c smart_str_appends(str, ", "); str 558 Zend/zend_exceptions.c smart_str_appendl(str, s_tmp, l_tmp); str 559 Zend/zend_exceptions.c smart_str_appends(str, ", "); str 564 Zend/zend_exceptions.c smart_str_appends(str, "Array, "); str 567 Zend/zend_exceptions.c smart_str_appends(str, "Object("); str 568 Zend/zend_exceptions.c smart_str_appends(str, ZSTR_VAL(Z_OBJCE_P(arg)->name)); str 569 Zend/zend_exceptions.c smart_str_appends(str, "), "); str 575 Zend/zend_exceptions.c static void _build_trace_string(smart_str *str, HashTable *ht, uint32_t num) /* {{{ */ str 579 Zend/zend_exceptions.c smart_str_appendc(str, '#'); str 580 Zend/zend_exceptions.c smart_str_append_long(str, num); str 581 Zend/zend_exceptions.c smart_str_appendc(str, ' '); str 587 Zend/zend_exceptions.c smart_str_appends(str, "[unknown function]"); str 601 Zend/zend_exceptions.c smart_str_append(str, Z_STR_P(file)); str 602 Zend/zend_exceptions.c smart_str_appendc(str, '('); str 603 Zend/zend_exceptions.c smart_str_append_long(str, line); str 604 Zend/zend_exceptions.c smart_str_appends(str, "): "); str 607 Zend/zend_exceptions.c smart_str_appends(str, "[internal function]: "); str 612 Zend/zend_exceptions.c smart_str_appendc(str, '('); str 616 Zend/zend_exceptions.c size_t last_len = ZSTR_LEN(str->s); str 620 Zend/zend_exceptions.c _build_trace_args(arg, str); str 623 Zend/zend_exceptions.c if (last_len != ZSTR_LEN(str->s)) { str 624 Zend/zend_exceptions.c ZSTR_LEN(str->s) -= 2; /* remove last ', ' */ str 630 Zend/zend_exceptions.c smart_str_appends(str, ")\n"); str 642 Zend/zend_exceptions.c smart_str str = {0}; str 660 Zend/zend_exceptions.c _build_trace_string(&str, Z_ARRVAL_P(frame), num++); str 663 Zend/zend_exceptions.c smart_str_appendc(&str, '#'); str 664 Zend/zend_exceptions.c smart_str_append_long(&str, num); str 665 Zend/zend_exceptions.c smart_str_appends(&str, " {main}"); str 666 Zend/zend_exceptions.c smart_str_0(&str); str 668 Zend/zend_exceptions.c RETURN_NEW_STR(str.s); str 698 Zend/zend_exceptions.c zend_string *str; str 701 Zend/zend_exceptions.c str = zend_vstrpprintf(max_len, format, arg); str 703 Zend/zend_exceptions.c return str; str 713 Zend/zend_exceptions.c zend_string *str; str 719 Zend/zend_exceptions.c str = ZSTR_EMPTY_ALLOC(); str 725 Zend/zend_exceptions.c zend_string *prev_str = str; str 754 Zend/zend_exceptions.c str = zend_strpprintf(0, "%s: %s in %s:" ZEND_LONG_FMT str 760 Zend/zend_exceptions.c str = zend_strpprintf(0, "%s in %s:" ZEND_LONG_FMT str 781 Zend/zend_exceptions.c zend_update_property_str(base_ce, exception, "string", sizeof("string")-1, str); str 783 Zend/zend_exceptions.c RETURN_STR(str); str 1011 Zend/zend_exceptions.c zend_string *str, *file = NULL; str 1043 Zend/zend_exceptions.c str = zval_get_string(GET_PROPERTY_SILENT(&exception, "string")); str 1048 Zend/zend_exceptions.c "Uncaught %s\n thrown", ZSTR_VAL(str)); str 1050 Zend/zend_exceptions.c zend_string_release(str); str 1304 Zend/zend_execute.c static void zend_assign_to_string_offset(zval *str, zend_long offset, zval *value, zval *result) str 1310 Zend/zend_execute.c zend_string_release(Z_STR_P(str)); str 1317 Zend/zend_execute.c old_str = Z_STR_P(str); str 1318 Zend/zend_execute.c if ((size_t)offset >= Z_STRLEN_P(str)) { str 1319 Zend/zend_execute.c zend_long old_len = Z_STRLEN_P(str); str 1320 Zend/zend_execute.c Z_STR_P(str) = zend_string_extend(Z_STR_P(str), offset + 1, 0); str 1321 Zend/zend_execute.c Z_TYPE_INFO_P(str) = IS_STRING_EX; str 1322 Zend/zend_execute.c memset(Z_STRVAL_P(str) + old_len, ' ', offset - old_len); str 1323 Zend/zend_execute.c Z_STRVAL_P(str)[offset+1] = 0; str 1324 Zend/zend_execute.c } else if (!Z_REFCOUNTED_P(str)) { str 1325 Zend/zend_execute.c Z_STR_P(str) = zend_string_init(Z_STRVAL_P(str), Z_STRLEN_P(str), 0); str 1326 Zend/zend_execute.c Z_TYPE_INFO_P(str) = IS_STRING_EX; str 1332 Zend/zend_execute.c Z_STRVAL_P(str)[offset] = ZSTR_VAL(tmp)[0]; str 1335 Zend/zend_execute.c Z_STRVAL_P(str)[offset] = Z_STRVAL_P(value)[0]; str 1344 Zend/zend_execute.c zend_uchar c = (zend_uchar)Z_STRVAL_P(str)[offset]; str 1349 Zend/zend_execute.c ZVAL_NEW_STR(result, zend_string_init(Z_STRVAL_P(str) + offset, 1, 0)); str 48 Zend/zend_execute.h ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name); str 49 Zend/zend_execute.h ZEND_API int zend_eval_stringl(char *str, size_t str_len, zval *retval_ptr, char *string_name); str 50 Zend/zend_execute.h ZEND_API int zend_eval_string_ex(char *str, zval *retval_ptr, char *string_name, int handle_exceptions); str 51 Zend/zend_execute.h ZEND_API int zend_eval_stringl_ex(char *str, size_t str_len, zval *retval_ptr, char *string_name, int handle_exceptions); str 1101 Zend/zend_execute_API.c ZEND_API int zend_eval_stringl(char *str, size_t str_len, zval *retval_ptr, char *string_name) /* {{{ */ str 1111 Zend/zend_execute_API.c memcpy(Z_STRVAL(pv) + sizeof("return ") - 1, str, str_len); str 1115 Zend/zend_execute_API.c ZVAL_STRINGL(&pv, str, str_len); str 1163 Zend/zend_execute_API.c ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name) /* {{{ */ str 1165 Zend/zend_execute_API.c return zend_eval_stringl(str, strlen(str), retval_ptr, string_name); str 1169 Zend/zend_execute_API.c ZEND_API int zend_eval_stringl_ex(char *str, size_t str_len, zval *retval_ptr, char *string_name, int handle_exceptions) /* {{{ */ str 1173 Zend/zend_execute_API.c result = zend_eval_stringl(str, str_len, retval_ptr, string_name); str 1182 Zend/zend_execute_API.c ZEND_API int zend_eval_string_ex(char *str, zval *retval_ptr, char *string_name, int handle_exceptions) /* {{{ */ str 1184 Zend/zend_execute_API.c return zend_eval_stringl_ex(str, strlen(str), retval_ptr, string_name, handle_exceptions); str 1505 Zend/zend_execute_API.c zend_string **str = ex->func->op_array.vars; str 1506 Zend/zend_execute_API.c zend_string **end = str + ex->func->op_array.last_var; str 1510 Zend/zend_execute_API.c _zend_hash_append_ind(symbol_table, *str, var); str 1511 Zend/zend_execute_API.c str++; str 1513 Zend/zend_execute_API.c } while (str != end); str 1527 Zend/zend_execute_API.c zend_string **str = op_array->vars; str 1528 Zend/zend_execute_API.c zend_string **end = str + op_array->last_var; str 1532 Zend/zend_execute_API.c zval *zv = zend_hash_find(ht, *str); str 1544 Zend/zend_execute_API.c zv = zend_hash_add_new(ht, *str, var); str 1547 Zend/zend_execute_API.c str++; str 1549 Zend/zend_execute_API.c } while (str != end); str 1561 Zend/zend_execute_API.c zend_string **str = op_array->vars; str 1562 Zend/zend_execute_API.c zend_string **end = str + op_array->last_var; str 1567 Zend/zend_execute_API.c zend_hash_del(ht, *str); str 1569 Zend/zend_execute_API.c zend_hash_update(ht, *str, var); str 1572 Zend/zend_execute_API.c str++; str 1574 Zend/zend_execute_API.c } while (str != end); str 1593 Zend/zend_execute_API.c zend_string **str = op_array->vars; str 1594 Zend/zend_execute_API.c zend_string **end = str + op_array->last_var; str 1597 Zend/zend_execute_API.c if (ZSTR_H(*str) == h && str 1598 Zend/zend_execute_API.c ZSTR_LEN(*str) == ZSTR_LEN(name) && str 1599 Zend/zend_execute_API.c memcmp(ZSTR_VAL(*str), ZSTR_VAL(name), ZSTR_LEN(name)) == 0) { str 1600 Zend/zend_execute_API.c zval *var = EX_VAR_NUM(str - op_array->vars); str 1604 Zend/zend_execute_API.c str++; str 1605 Zend/zend_execute_API.c } while (str != end); str 1634 Zend/zend_execute_API.c zend_string **str = op_array->vars; str 1635 Zend/zend_execute_API.c zend_string **end = str + op_array->last_var; str 1638 Zend/zend_execute_API.c if (ZSTR_H(*str) == h && str 1639 Zend/zend_execute_API.c ZSTR_LEN(*str) == len && str 1640 Zend/zend_execute_API.c memcmp(ZSTR_VAL(*str), name, len) == 0) { str 1641 Zend/zend_execute_API.c zval *var = EX_VAR_NUM(str - op_array->vars); str 1646 Zend/zend_execute_API.c str++; str 1647 Zend/zend_execute_API.c } while (str != end); str 71 Zend/zend_gc.c # define GC_TRACE(str) str 509 Zend/zend_hash.c static zend_always_inline Bucket *zend_hash_str_find_bucket(const HashTable *ht, const char *str, size_t len, zend_ulong h) str 524 Zend/zend_hash.c && !memcmp(ZSTR_VAL(p->key), str, len)) { str 656 Zend/zend_hash.c ZEND_API zval* ZEND_FASTCALL _zend_hash_str_add_or_update(HashTable *ht, const char *str, size_t len, zval *pData, uint32_t flag ZEND_FILE_LINE_DC) str 658 Zend/zend_hash.c zend_string *key = zend_string_init(str, len, ht->u.flags & HASH_FLAG_PERSISTENT); str 664 Zend/zend_hash.c ZEND_API zval* ZEND_FASTCALL _zend_hash_str_update(HashTable *ht, const char *str, size_t len, zval *pData ZEND_FILE_LINE_DC) str 666 Zend/zend_hash.c zend_string *key = zend_string_init(str, len, ht->u.flags & HASH_FLAG_PERSISTENT); str 672 Zend/zend_hash.c ZEND_API zval* ZEND_FASTCALL _zend_hash_str_update_ind(HashTable *ht, const char *str, size_t len, zval *pData ZEND_FILE_LINE_DC) str 674 Zend/zend_hash.c zend_string *key = zend_string_init(str, len, ht->u.flags & HASH_FLAG_PERSISTENT); str 680 Zend/zend_hash.c ZEND_API zval* ZEND_FASTCALL _zend_hash_str_add(HashTable *ht, const char *str, size_t len, zval *pData ZEND_FILE_LINE_DC) str 682 Zend/zend_hash.c zend_string *key = zend_string_init(str, len, ht->u.flags & HASH_FLAG_PERSISTENT); str 688 Zend/zend_hash.c ZEND_API zval* ZEND_FASTCALL _zend_hash_str_add_new(HashTable *ht, const char *str, size_t len, zval *pData ZEND_FILE_LINE_DC) str 690 Zend/zend_hash.c zend_string *key = zend_string_init(str, len, ht->u.flags & HASH_FLAG_PERSISTENT); str 712 Zend/zend_hash.c ZEND_API zval* ZEND_FASTCALL zend_hash_str_add_empty_element(HashTable *ht, const char *str, size_t len) str 717 Zend/zend_hash.c return zend_hash_str_add(ht, str, len, &dummy); str 1140 Zend/zend_hash.c ZEND_API int ZEND_FASTCALL zend_hash_str_del_ind(HashTable *ht, const char *str, size_t len) str 1151 Zend/zend_hash.c h = zend_inline_hash_func(str, len); str 1160 Zend/zend_hash.c && !memcmp(ZSTR_VAL(p->key), str, len)) { str 1184 Zend/zend_hash.c ZEND_API int ZEND_FASTCALL zend_hash_str_del(HashTable *ht, const char *str, size_t len) str 1195 Zend/zend_hash.c h = zend_inline_hash_func(str, len); str 1204 Zend/zend_hash.c && !memcmp(ZSTR_VAL(p->key), str, len)) { str 1987 Zend/zend_hash.c ZEND_API zval* ZEND_FASTCALL zend_hash_str_find(const HashTable *ht, const char *str, size_t len) str 1994 Zend/zend_hash.c h = zend_inline_hash_func(str, len); str 1995 Zend/zend_hash.c p = zend_hash_str_find_bucket(ht, str, len, h); str 2009 Zend/zend_hash.c ZEND_API zend_bool ZEND_FASTCALL zend_hash_str_exists(const HashTable *ht, const char *str, size_t len) str 2016 Zend/zend_hash.c h = zend_inline_hash_func(str, len); str 2017 Zend/zend_hash.c p = zend_hash_str_find_bucket(ht, str, len, h); str 160 Zend/zend_hash.h ZEND_API zend_bool ZEND_FASTCALL zend_hash_str_exists(const HashTable *ht, const char *str, size_t len); str 294 Zend/zend_hash.h static zend_always_inline zval *zend_hash_str_find_ind(const HashTable *ht, const char *str, size_t len) str 298 Zend/zend_hash.h zv = zend_hash_str_find(ht, str, len); str 400 Zend/zend_hash.h static zend_always_inline zval *zend_symtable_str_update(HashTable *ht, const char *str, size_t len, zval *pData) str 404 Zend/zend_hash.h if (ZEND_HANDLE_NUMERIC_STR(str, len, idx)) { str 407 Zend/zend_hash.h return zend_hash_str_update(ht, str, len, pData); str 412 Zend/zend_hash.h static zend_always_inline zval *zend_symtable_str_update_ind(HashTable *ht, const char *str, size_t len, zval *pData) str 416 Zend/zend_hash.h if (ZEND_HANDLE_NUMERIC_STR(str, len, idx)) { str 419 Zend/zend_hash.h return zend_hash_str_update_ind(ht, str, len, pData); str 424 Zend/zend_hash.h static zend_always_inline int zend_symtable_str_del(HashTable *ht, const char *str, size_t len) str 428 Zend/zend_hash.h if (ZEND_HANDLE_NUMERIC_STR(str, len, idx)) { str 431 Zend/zend_hash.h return zend_hash_str_del(ht, str, len); str 436 Zend/zend_hash.h static zend_always_inline int zend_symtable_str_del_ind(HashTable *ht, const char *str, size_t len) str 440 Zend/zend_hash.h if (ZEND_HANDLE_NUMERIC_STR(str, len, idx)) { str 443 Zend/zend_hash.h return zend_hash_str_del_ind(ht, str, len); str 448 Zend/zend_hash.h static zend_always_inline zval *zend_symtable_str_find(HashTable *ht, const char *str, size_t len) str 452 Zend/zend_hash.h if (ZEND_HANDLE_NUMERIC_STR(str, len, idx)) { str 455 Zend/zend_hash.h return zend_hash_str_find(ht, str, len); str 460 Zend/zend_hash.h static zend_always_inline int zend_symtable_str_exists(HashTable *ht, const char *str, size_t len) str 464 Zend/zend_hash.h if (ZEND_HANDLE_NUMERIC_STR(str, len, idx)) { str 467 Zend/zend_hash.h return zend_hash_str_exists(ht, str, len); str 499 Zend/zend_hash.h static zend_always_inline void *zend_hash_str_add_ptr(HashTable *ht, const char *str, size_t len, void *pData) str 504 Zend/zend_hash.h zv = zend_hash_str_add(ht, str, len, &tmp); str 513 Zend/zend_hash.h static zend_always_inline void *zend_hash_str_add_new_ptr(HashTable *ht, const char *str, size_t len, void *pData) str 518 Zend/zend_hash.h zv = zend_hash_str_add_new(ht, str, len, &tmp); str 541 Zend/zend_hash.h static zend_always_inline void *zend_hash_str_update_ptr(HashTable *ht, const char *str, size_t len, void *pData) str 546 Zend/zend_hash.h zv = zend_hash_str_update(ht, str, len, &tmp); str 568 Zend/zend_hash.h static zend_always_inline void *zend_hash_str_add_mem(HashTable *ht, const char *str, size_t len, void *pData, size_t size) str 573 Zend/zend_hash.h if ((zv = zend_hash_str_add(ht, str, len, &tmp))) { str 590 Zend/zend_hash.h static zend_always_inline void *zend_hash_str_update_mem(HashTable *ht, const char *str, size_t len, void *pData, size_t size) str 596 Zend/zend_hash.h return zend_hash_str_update_ptr(ht, str, len, p); str 693 Zend/zend_hash.h static zend_always_inline void *zend_hash_str_find_ptr(const HashTable *ht, const char *str, size_t len) str 697 Zend/zend_hash.h zv = zend_hash_str_find(ht, str, len); str 719 Zend/zend_hash.h static zend_always_inline void *zend_symtable_str_find_ptr(HashTable *ht, const char *str, size_t len) str 723 Zend/zend_hash.h if (ZEND_HANDLE_NUMERIC_STR(str, len, idx)) { str 726 Zend/zend_hash.h return zend_hash_str_find_ptr(ht, str, len); str 45 Zend/zend_highlight.h ZEND_API int highlight_string(zval *str, zend_syntax_highlighter_ini *syntax_highlighter_ini, char *str_name); str 344 Zend/zend_inheritance.c static ZEND_COLD void zend_append_type_hint(smart_str *str, const zend_function *fptr, zend_arg_info *arg_info, int return_hint) /* {{{ */ str 366 Zend/zend_inheritance.c smart_str_appendl(str, class_name, class_name_len); str 368 Zend/zend_inheritance.c smart_str_appendc(str, ' '); str 372 Zend/zend_inheritance.c smart_str_appendl(str, "int", 3); str 374 Zend/zend_inheritance.c smart_str_appendl(str, "bool", 4); str 377 Zend/zend_inheritance.c smart_str_appends(str, type_name); str 380 Zend/zend_inheritance.c smart_str_appendc(str, ' '); str 388 Zend/zend_inheritance.c smart_str str = {0}; str 391 Zend/zend_inheritance.c smart_str_appends(&str, "& "); str 396 Zend/zend_inheritance.c smart_str_appendl(&str, ZSTR_VAL(fptr->common.scope->name), strlen(ZSTR_VAL(fptr->common.scope->name))); str 397 Zend/zend_inheritance.c smart_str_appends(&str, "::"); str 400 Zend/zend_inheritance.c smart_str_append(&str, fptr->common.function_name); str 401 Zend/zend_inheritance.c smart_str_appendc(&str, '('); str 413 Zend/zend_inheritance.c zend_append_type_hint(&str, fptr, arg_info, 0); str 416 Zend/zend_inheritance.c smart_str_appendc(&str, '&'); str 420 Zend/zend_inheritance.c smart_str_appends(&str, "..."); str 423 Zend/zend_inheritance.c smart_str_appendc(&str, '$'); str 427 Zend/zend_inheritance.c smart_str_appends(&str, ((zend_internal_arg_info*)arg_info)->name); str 429 Zend/zend_inheritance.c smart_str_appendl(&str, ZSTR_VAL(arg_info->name), ZSTR_LEN(arg_info->name)); str 432 Zend/zend_inheritance.c smart_str_appends(&str, "param"); str 433 Zend/zend_inheritance.c smart_str_append_unsigned(&str, i); str 437 Zend/zend_inheritance.c smart_str_appends(&str, " = "); str 459 Zend/zend_inheritance.c smart_str_append(&str, Z_STR_P(zv)); str 461 Zend/zend_inheritance.c smart_str_appends(&str, "false"); str 463 Zend/zend_inheritance.c smart_str_appends(&str, "true"); str 465 Zend/zend_inheritance.c smart_str_appends(&str, "NULL"); str 467 Zend/zend_inheritance.c smart_str_appendc(&str, '\''); str 468 Zend/zend_inheritance.c smart_str_appendl(&str, Z_STRVAL_P(zv), MIN(Z_STRLEN_P(zv), 10)); str 470 Zend/zend_inheritance.c smart_str_appends(&str, "..."); str 472 Zend/zend_inheritance.c smart_str_appendc(&str, '\''); str 474 Zend/zend_inheritance.c smart_str_appends(&str, "Array"); str 476 Zend/zend_inheritance.c smart_str_appends(&str, "<expression>"); str 479 Zend/zend_inheritance.c smart_str_append(&str, zv_str); str 484 Zend/zend_inheritance.c smart_str_appends(&str, "NULL"); str 489 Zend/zend_inheritance.c smart_str_appends(&str, ", "); str 495 Zend/zend_inheritance.c smart_str_appendc(&str, ')'); str 498 Zend/zend_inheritance.c smart_str_appends(&str, ": "); str 499 Zend/zend_inheritance.c zend_append_type_hint(&str, fptr, fptr->common.arg_info - 1, 1); str 501 Zend/zend_inheritance.c smart_str_0(&str); str 503 Zend/zend_inheritance.c return str.s; str 180 Zend/zend_ini.h ZEND_API int zend_parse_ini_string(char *str, zend_bool unbuffered_errors, int scanner_mode, zend_ini_parser_cb_t ini_parser_cb, void *arg); str 108 Zend/zend_ini_parser.y zend_string *str = zval_get_string(op1); str 110 Zend/zend_ini_parser.y ZVAL_PSTRINGL(op1, ZSTR_VAL(str), ZSTR_LEN(str)); str 111 Zend/zend_ini_parser.y zend_string_release(str); str 235 Zend/zend_ini_parser.y ZEND_API int zend_parse_ini_string(char *str, zend_bool unbuffered_errors, int scanner_mode, zend_ini_parser_cb_t ini_parser_cb, void *arg) str 244 Zend/zend_ini_parser.y if (zend_ini_prepare_string_for_scanning(str, scanner_mode) == FAILURE) { str 141 Zend/zend_ini_scanner.c #define zend_ini_copy_value(retval, str, len) \ str 142 Zend/zend_ini_scanner.c ZVAL_NEW_STR(retval, zend_string_init(str, len, 1)) str 145 Zend/zend_ini_scanner.c #define RETURN_TOKEN(type, str, len) { \ str 147 Zend/zend_ini_scanner.c zend_ini_copy_typed_value(ini_lval, type, str, len); \ str 149 Zend/zend_ini_scanner.c zend_ini_copy_value(ini_lval, str, len); \ str 154 Zend/zend_ini_scanner.c static inline int convert_to_number(zval *retval, const char *str, const int str_len) str 161 Zend/zend_ini_scanner.c if ((type = is_numeric_string_ex(str, str_len, &lval, &dval, 0, &overflow)) != 0) { str 174 Zend/zend_ini_scanner.c static void zend_ini_copy_typed_value(zval *retval, const int type, const char *str, int len) str 187 Zend/zend_ini_scanner.c if (convert_to_number(retval, str, len) == SUCCESS) { str 192 Zend/zend_ini_scanner.c zend_ini_copy_value(retval, str, len); str 211 Zend/zend_ini_scanner.c static void yy_scan_buffer(char *str, unsigned int len) str 213 Zend/zend_ini_scanner.c YYCURSOR = (YYCTYPE*)str; str 298 Zend/zend_ini_scanner.c int zend_ini_prepare_string_for_scanning(char *str, int scanner_mode) str 300 Zend/zend_ini_scanner.c int len = (int)strlen(str); str 306 Zend/zend_ini_scanner.c yy_scan_buffer(str, len); str 314 Zend/zend_ini_scanner.c static void zend_ini_escape_string(zval *lval, char *str, int len, char quote_type) str 319 Zend/zend_ini_scanner.c zend_ini_copy_value(lval, str, len); str 34 Zend/zend_ini_scanner.h int zend_ini_prepare_string_for_scanning(char *str, int scanner_mode); str 53 Zend/zend_language_parser.y %destructor { if ($$) zend_string_release($$); } <str> str 260 Zend/zend_language_parser.y %type <str> backup_doc_comment str 1294 Zend/zend_language_parser.y const unsigned char *end, *str, *tok1 = NULL, *tok2 = NULL; str 1308 Zend/zend_language_parser.y str = LANG_SCNG(yy_text); str 1309 Zend/zend_language_parser.y end = memchr(str, '\n', LANG_SCNG(yy_leng)); str 1323 Zend/zend_language_parser.y len = (end - str) > 30 ? 30 : (end - str); str 1327 Zend/zend_language_parser.y snprintf(buffer, sizeof(buffer), "'%.*s' %.*s", len, str, toklen, tok1); str 1329 Zend/zend_language_parser.y snprintf(buffer, sizeof(buffer), "'%.*s'", len, str); str 170 Zend/zend_language_scanner.c static void yy_scan_buffer(char *str, unsigned int len) str 172 Zend/zend_language_scanner.c YYCURSOR = (YYCTYPE*)str; str 669 Zend/zend_language_scanner.c ZEND_API int zend_prepare_string_for_scanning(zval *str, char *filename) str 676 Zend/zend_language_scanner.c old_len = Z_STRLEN_P(str); str 677 Zend/zend_language_scanner.c Z_STR_P(str) = zend_string_extend(Z_STR_P(str), old_len + ZEND_MMAP_AHEAD, 0); str 678 Zend/zend_language_scanner.c Z_TYPE_INFO_P(str) = IS_STRING_EX; str 679 Zend/zend_language_scanner.c memset(Z_STRVAL_P(str) + old_len, 0, ZEND_MMAP_AHEAD + 1); str 684 Zend/zend_language_scanner.c buf = Z_STRVAL_P(str); str 822 Zend/zend_language_scanner.c int highlight_string(zval *str, zend_syntax_highlighter_ini *syntax_highlighter_ini, char *str_name) str 825 Zend/zend_language_scanner.c zval tmp = *str; str 827 Zend/zend_language_scanner.c str = &tmp; str 828 Zend/zend_language_scanner.c zval_copy_ctor(str); str 830 Zend/zend_language_scanner.c if (zend_prepare_string_for_scanning(str, str_name)==FAILURE) { str 841 Zend/zend_language_scanner.c zval_dtor(str); str 892 Zend/zend_language_scanner.c static int zend_scan_escape_string(zval *zendlval, char *str, int len, char quote_type) str 897 Zend/zend_language_scanner.c ZVAL_STRINGL(zendlval, str, len); str 1091 Zend/zend_language_scanner.c unsigned char *str; str 1094 Zend/zend_language_scanner.c SCNG(output_filter)(&str, &sz, (unsigned char *)s, (size_t)Z_STRLEN_P(zendlval)); str 1096 Zend/zend_language_scanner.c ZVAL_STRINGL(zendlval, (char *) str, sz); str 1097 Zend/zend_language_scanner.c efree(str); str 2901 Zend/zend_language_scanner.c char *str = NULL; str 2904 Zend/zend_language_scanner.c SCNG(output_filter)((unsigned char **)&str, &sz, (unsigned char *)s, (size_t)Z_STRLEN_P(zendlval)); str 2905 Zend/zend_language_scanner.c ZVAL_STRINGL(zendlval, str, sz); str 69 Zend/zend_language_scanner.h ZEND_API int zend_prepare_string_for_scanning(zval *str, char *filename); str 27 Zend/zend_multibyte.h typedef size_t (*zend_encoding_filter)(unsigned char **str, size_t *str_length, const unsigned char *buf, size_t length); str 83 Zend/zend_operators.c ZEND_API int ZEND_FASTCALL zend_atoi(const char *str, int str_len) /* {{{ */ str 88 Zend/zend_operators.c str_len = (int)strlen(str); str 90 Zend/zend_operators.c retval = ZEND_STRTOL(str, NULL, 0); str 92 Zend/zend_operators.c switch (str[str_len-1]) { str 111 Zend/zend_operators.c ZEND_API zend_long ZEND_FASTCALL zend_atol(const char *str, int str_len) /* {{{ */ str 116 Zend/zend_operators.c str_len = (int)strlen(str); str 118 Zend/zend_operators.c retval = ZEND_STRTOL(str, NULL, 0); str 120 Zend/zend_operators.c switch (str[str_len-1]) { str 159 Zend/zend_operators.c zend_string *str; str 161 Zend/zend_operators.c str = Z_STR_P(op); str 162 Zend/zend_operators.c if ((Z_TYPE_INFO_P(op)=is_numeric_string(ZSTR_VAL(str), ZSTR_LEN(str), &Z_LVAL_P(op), &Z_DVAL_P(op), 1)) == 0) { str 165 Zend/zend_operators.c zend_string_release(str); str 315 Zend/zend_operators.c zend_string *str = Z_STR_P(op); str 317 Zend/zend_operators.c ZVAL_LONG(op, ZEND_STRTOL(ZSTR_VAL(str), NULL, base)); str 318 Zend/zend_operators.c zend_string_release(str); str 375 Zend/zend_operators.c zend_string *str = Z_STR_P(op); str 377 Zend/zend_operators.c ZVAL_DOUBLE(op, zend_strtod(ZSTR_VAL(str), NULL)); str 378 Zend/zend_operators.c zend_string_release(str); str 455 Zend/zend_operators.c zend_string *str = Z_STR_P(op); str 457 Zend/zend_operators.c if (ZSTR_LEN(str) == 0 str 458 Zend/zend_operators.c || (ZSTR_LEN(str) == 1 && ZSTR_VAL(str)[0] == '0')) { str 463 Zend/zend_operators.c zend_string_release(str); str 496 Zend/zend_operators.c zend_string *str; str 499 Zend/zend_operators.c str = zend_strpprintf(0, "%.*H", (int) EG(precision), dval); str 500 Zend/zend_operators.c ZVAL_NEW_STR(op, str); str 538 Zend/zend_operators.c zend_string *str; str 541 Zend/zend_operators.c str = zend_strpprintf(0, "%.*G", (int) EG(precision), dval); str 543 Zend/zend_operators.c ZVAL_NEW_STR(op, str); str 845 Zend/zend_operators.c zend_string *str = zval_get_string(z); str 847 Zend/zend_operators.c return str; str 1344 Zend/zend_operators.c zend_string *str; str 1364 Zend/zend_operators.c str = zend_string_alloc(Z_STRLEN_P(longer), 0); str 1366 Zend/zend_operators.c ZSTR_VAL(str)[i] = Z_STRVAL_P(longer)[i] | Z_STRVAL_P(shorter)[i]; str 1368 Zend/zend_operators.c memcpy(ZSTR_VAL(str) + i, Z_STRVAL_P(longer) + i, Z_STRLEN_P(longer) - i + 1); str 1372 Zend/zend_operators.c ZVAL_NEW_STR(result, str); str 1411 Zend/zend_operators.c zend_string *str; str 1431 Zend/zend_operators.c str = zend_string_alloc(Z_STRLEN_P(shorter), 0); str 1433 Zend/zend_operators.c ZSTR_VAL(str)[i] = Z_STRVAL_P(shorter)[i] & Z_STRVAL_P(longer)[i]; str 1435 Zend/zend_operators.c ZSTR_VAL(str)[i] = 0; str 1439 Zend/zend_operators.c ZVAL_NEW_STR(result, str); str 1478 Zend/zend_operators.c zend_string *str; str 1498 Zend/zend_operators.c str = zend_string_alloc(Z_STRLEN_P(shorter), 0); str 1500 Zend/zend_operators.c ZSTR_VAL(str)[i] = Z_STRVAL_P(shorter)[i] ^ Z_STRVAL_P(longer)[i]; str 1502 Zend/zend_operators.c ZSTR_VAL(str)[i] = 0; str 1506 Zend/zend_operators.c ZVAL_NEW_STR(result, str); str 2143 Zend/zend_operators.c static void ZEND_FASTCALL increment_string(zval *str) /* {{{ */ str 2146 Zend/zend_operators.c size_t pos=Z_STRLEN_P(str)-1; str 2152 Zend/zend_operators.c if (Z_STRLEN_P(str) == 0) { str 2153 Zend/zend_operators.c zend_string_release(Z_STR_P(str)); str 2155 Zend/zend_operators.c ZVAL_INTERNED_STR(str, CG(one_char_string)['1']); str 2157 Zend/zend_operators.c Z_STR_P(str) = zend_string_init("1", sizeof("1")-1, 0); str 2158 Zend/zend_operators.c Z_TYPE_INFO_P(str) = IS_STRING_EX; str 2163 Zend/zend_operators.c if (!Z_REFCOUNTED_P(str)) { str 2164 Zend/zend_operators.c Z_STR_P(str) = zend_string_init(Z_STRVAL_P(str), Z_STRLEN_P(str), 0); str 2165 Zend/zend_operators.c Z_TYPE_INFO_P(str) = IS_STRING_EX; str 2166 Zend/zend_operators.c } else if (Z_REFCOUNT_P(str) > 1) { str 2167 Zend/zend_operators.c Z_DELREF_P(str); str 2168 Zend/zend_operators.c Z_STR_P(str) = zend_string_init(Z_STRVAL_P(str), Z_STRLEN_P(str), 0); str 2170 Zend/zend_operators.c zend_string_forget_hash_val(Z_STR_P(str)); str 2172 Zend/zend_operators.c s = Z_STRVAL_P(str); str 2213 Zend/zend_operators.c t = zend_string_alloc(Z_STRLEN_P(str)+1, 0); str 2214 Zend/zend_operators.c memcpy(ZSTR_VAL(t) + 1, Z_STRVAL_P(str), Z_STRLEN_P(str)); str 2215 Zend/zend_operators.c ZSTR_VAL(t)[Z_STRLEN_P(str) + 1] = '\0'; str 2227 Zend/zend_operators.c zend_string_free(Z_STR_P(str)); str 2228 Zend/zend_operators.c ZVAL_NEW_STR(str, t); str 2414 Zend/zend_operators.c register unsigned char *str = (unsigned char*)source; str 2416 Zend/zend_operators.c register unsigned char *end = str + length; str 2418 Zend/zend_operators.c while (str < end) { str 2419 Zend/zend_operators.c *result++ = zend_tolower_ascii(*str++); str 2433 Zend/zend_operators.c ZEND_API void ZEND_FASTCALL zend_str_tolower(char *str, size_t length) /* {{{ */ str 2435 Zend/zend_operators.c register unsigned char *p = (unsigned char*)str; str 2473 Zend/zend_operators.c ZEND_API zend_string* ZEND_FASTCALL zend_string_tolower(zend_string *str) /* {{{ */ str 2475 Zend/zend_operators.c register unsigned char *p = (unsigned char*)ZSTR_VAL(str); str 2476 Zend/zend_operators.c register unsigned char *end = p + ZSTR_LEN(str); str 2480 Zend/zend_operators.c zend_string *res = zend_string_alloc(ZSTR_LEN(str), 0); str 2483 Zend/zend_operators.c if (p != (unsigned char*)ZSTR_VAL(str)) { str 2484 Zend/zend_operators.c memcpy(ZSTR_VAL(res), ZSTR_VAL(str), p - (unsigned char*)ZSTR_VAL(str)); str 2486 Zend/zend_operators.c r = p + (ZSTR_VAL(res) - ZSTR_VAL(str)); str 2497 Zend/zend_operators.c return zend_string_copy(str); str 2733 Zend/zend_operators.c zend_string *str; str 2735 Zend/zend_operators.c str = zend_strpprintf(0, "%.*G", (int) EG(precision), (double)Z_DVAL_P(op)); str 2736 Zend/zend_operators.c ZVAL_NEW_STR(op, str); str 2748 Zend/zend_operators.c ZEND_API zend_uchar ZEND_FASTCALL is_numeric_str_function(const zend_string *str, zend_long *lval, double *dval) /* {{{ */ { str 2749 Zend/zend_operators.c return is_numeric_string_ex(ZSTR_VAL(str), ZSTR_LEN(str), lval, dval, -1, NULL); str 2753 Zend/zend_operators.c ZEND_API zend_uchar ZEND_FASTCALL _is_numeric_string_ex(const char *str, size_t length, zend_long *lval, double *dval, int allow_errors, int *oflow_info) /* {{{ */ str 2772 Zend/zend_operators.c while (*str == ' ' || *str == '\t' || *str == '\n' || *str == '\r' || *str == '\v' || *str == '\f') { str 2773 Zend/zend_operators.c str++; str 2776 Zend/zend_operators.c ptr = str; str 2817 Zend/zend_operators.c *oflow_info = *str == '-' ? -1 : 1; str 2829 Zend/zend_operators.c local_dval = zend_strtod(str, &ptr); str 2838 Zend/zend_operators.c if (ptr != str + length) { str 2851 Zend/zend_operators.c if (!(cmp < 0 || (cmp == 0 && *str == '-'))) { str 2853 Zend/zend_operators.c *dval = zend_strtod(str, NULL); str 2856 Zend/zend_operators.c *oflow_info = *str == '-' ? -1 : 1; str 91 Zend/zend_operators.h ZEND_API zend_uchar ZEND_FASTCALL _is_numeric_string_ex(const char *str, size_t length, zend_long *lval, double *dval, int allow_errors, int *oflow_info); str 130 Zend/zend_operators.h static zend_always_inline zend_uchar is_numeric_string_ex(const char *str, size_t length, zend_long *lval, double *dval, int allow_errors, int *oflow_info) str 132 Zend/zend_operators.h if (*str > '9') { str 135 Zend/zend_operators.h return _is_numeric_string_ex(str, length, lval, dval, allow_errors, oflow_info); str 138 Zend/zend_operators.h static zend_always_inline zend_uchar is_numeric_string(const char *str, size_t length, zend_long *lval, double *dval, int allow_errors) { str 139 Zend/zend_operators.h return is_numeric_string_ex(str, length, lval, dval, allow_errors, NULL); str 142 Zend/zend_operators.h ZEND_API zend_uchar ZEND_FASTCALL is_numeric_str_function(const zend_string *str, zend_long *lval, double *dval); str 340 Zend/zend_operators.h ZEND_API void ZEND_FASTCALL zend_str_tolower(char *str, size_t length); str 344 Zend/zend_operators.h ZEND_API zend_string* ZEND_FASTCALL zend_string_tolower(zend_string *str); str 362 Zend/zend_operators.h ZEND_API int ZEND_FASTCALL zend_atoi(const char *str, int str_len); str 363 Zend/zend_operators.h ZEND_API zend_long ZEND_FASTCALL zend_atol(const char *str, int str_len); str 423 Zend/zend_portability.h #define ZEND_STRL(str) (str), (sizeof(str)-1) str 424 Zend/zend_portability.h #define ZEND_STRS(str) (str), (sizeof(str)) str 35 Zend/zend_smart_str.c ZEND_API void ZEND_FASTCALL smart_str_erealloc(smart_str *str, size_t len) str 37 Zend/zend_smart_str.c if (UNEXPECTED(!str->s)) { str 38 Zend/zend_smart_str.c str->a = len < SMART_STR_START_SIZE str 41 Zend/zend_smart_str.c str->s = zend_string_alloc(str->a, 0); str 42 Zend/zend_smart_str.c ZSTR_LEN(str->s) = 0; str 44 Zend/zend_smart_str.c str->a = SMART_STR_NEW_SIZE(len); str 45 Zend/zend_smart_str.c str->s = (zend_string *) erealloc2(str->s, _ZSTR_HEADER_SIZE + str->a + 1, _ZSTR_HEADER_SIZE + ZSTR_LEN(str->s) + 1); str 49 Zend/zend_smart_str.c ZEND_API void ZEND_FASTCALL smart_str_realloc(smart_str *str, size_t len) str 51 Zend/zend_smart_str.c if (UNEXPECTED(!str->s)) { str 52 Zend/zend_smart_str.c str->a = len < SMART_STR_START_SIZE str 55 Zend/zend_smart_str.c str->s = zend_string_alloc(str->a, 1); str 56 Zend/zend_smart_str.c ZSTR_LEN(str->s) = 0; str 58 Zend/zend_smart_str.c str->a = SMART_STR_NEW_SIZE(len); str 59 Zend/zend_smart_str.c str->s = (zend_string *) realloc(str->s, _ZSTR_HEADER_SIZE + str->a + 1); str 46 Zend/zend_smart_str.h ZEND_API void ZEND_FASTCALL smart_str_erealloc(smart_str *str, size_t len); str 47 Zend/zend_smart_str.h ZEND_API void ZEND_FASTCALL smart_str_realloc(smart_str *str, size_t len); str 51 Zend/zend_smart_str.h static zend_always_inline size_t smart_str_alloc(smart_str *str, size_t len, zend_bool persistent) { str 52 Zend/zend_smart_str.h if (UNEXPECTED(!str->s)) { str 55 Zend/zend_smart_str.h len += ZSTR_LEN(str->s); str 56 Zend/zend_smart_str.h if (UNEXPECTED(len >= str->a)) { str 59 Zend/zend_smart_str.h smart_str_realloc(str, len); str 61 Zend/zend_smart_str.h smart_str_erealloc(str, len); str 68 Zend/zend_smart_str.h static zend_always_inline void smart_str_free(smart_str *str) { str 69 Zend/zend_smart_str.h if (str->s) { str 70 Zend/zend_smart_str.h zend_string_release(str->s); str 71 Zend/zend_smart_str.h str->s = NULL; str 73 Zend/zend_smart_str.h str->a = 0; str 76 Zend/zend_smart_str.h static zend_always_inline void smart_str_0(smart_str *str) { str 77 Zend/zend_smart_str.h if (str->s) { str 78 Zend/zend_smart_str.h ZSTR_VAL(str->s)[ZSTR_LEN(str->s)] = '\0'; str 88 Zend/zend_smart_str.h static zend_always_inline void smart_str_appendl_ex(smart_str *dest, const char *str, size_t len, zend_bool persistent) { str 90 Zend/zend_smart_str.h memcpy(ZSTR_VAL(dest->s) + ZSTR_LEN(dest->s), str, len); str 24 Zend/zend_string.c ZEND_API zend_string *(*zend_new_interned_string)(zend_string *str); str 28 Zend/zend_string.c static zend_string *zend_new_interned_string_int(zend_string *str); str 32 Zend/zend_string.c ZEND_API zend_ulong zend_hash_func(const char *str, size_t len) str 34 Zend/zend_string.c return zend_inline_hash_func(str, len); str 40 Zend/zend_string.c zend_string *str = Z_STR_P(zv); str 41 Zend/zend_string.c pefree(str, GC_FLAGS(str) & IS_STR_PERSISTENT); str 48 Zend/zend_string.c zend_string *str; str 58 Zend/zend_string.c str = zend_string_alloc(sizeof("")-1, 1); str 59 Zend/zend_string.c ZSTR_VAL(str)[0] = '\000'; str 60 Zend/zend_string.c CG(empty_string) = zend_new_interned_string_int(str); str 78 Zend/zend_string.c static zend_string *zend_new_interned_string_int(zend_string *str) str 86 Zend/zend_string.c if (ZSTR_IS_INTERNED(str)) { str 87 Zend/zend_string.c return str; str 90 Zend/zend_string.c h = zend_string_hash_val(str); str 95 Zend/zend_string.c if ((p->h == h) && (ZSTR_LEN(p->key) == ZSTR_LEN(str))) { str 96 Zend/zend_string.c if (!memcmp(ZSTR_VAL(p->key), ZSTR_VAL(str), ZSTR_LEN(str))) { str 97 Zend/zend_string.c zend_string_release(str); str 104 Zend/zend_string.c GC_REFCOUNT(str) = 1; str 105 Zend/zend_string.c GC_FLAGS(str) |= IS_STR_INTERNED; str 137 Zend/zend_string.c p->key = str; str 138 Zend/zend_string.c Z_STR(p->val) = str; str 146 Zend/zend_string.c return str; str 148 Zend/zend_string.c return str; str 28 Zend/zend_string.h ZEND_API extern zend_string *(*zend_new_interned_string)(zend_string *str); str 32 Zend/zend_string.h ZEND_API zend_ulong zend_hash_func(const char *str, size_t len); str 50 Zend/zend_string.h #define STR_ALLOCA_ALLOC(str, _len, use_heap) ZSTR_ALLOCA_ALLOC(str, _len, use_heap) str 51 Zend/zend_string.h #define STR_ALLOCA_INIT(str, s, len, use_heap) ZSTR_ALLOCA_INIT(str, s, len, use_heap) str 52 Zend/zend_string.h #define STR_ALLOCA_FREE(str, use_heap) ZSTR_ALLOCA_FREE(str, use_heap) str 64 Zend/zend_string.h #define ZSTR_ALLOCA_ALLOC(str, _len, use_heap) do { \ str 65 Zend/zend_string.h (str) = (zend_string *)do_alloca(ZEND_MM_ALIGNED_SIZE_EX(_ZSTR_STRUCT_SIZE(_len), 8), (use_heap)); \ str 66 Zend/zend_string.h GC_REFCOUNT(str) = 1; \ str 67 Zend/zend_string.h GC_TYPE_INFO(str) = IS_STRING; \ str 68 Zend/zend_string.h zend_string_forget_hash_val(str); \ str 69 Zend/zend_string.h ZSTR_LEN(str) = _len; \ str 72 Zend/zend_string.h #define ZSTR_ALLOCA_INIT(str, s, len, use_heap) do { \ str 73 Zend/zend_string.h ZSTR_ALLOCA_ALLOC(str, len, use_heap); \ str 74 Zend/zend_string.h memcpy(ZSTR_VAL(str), (s), (len)); \ str 75 Zend/zend_string.h ZSTR_VAL(str)[(len)] = '\0'; \ str 78 Zend/zend_string.h #define ZSTR_ALLOCA_FREE(str, use_heap) free_alloca(str, use_heap) str 155 Zend/zend_string.h static zend_always_inline zend_string *zend_string_init(const char *str, size_t len, int persistent) str 159 Zend/zend_string.h memcpy(ZSTR_VAL(ret), str, len); str 285 Zend/zend_string.h #define zend_string_equals_literal_ci(str, c) \ str 286 Zend/zend_string.h (ZSTR_LEN(str) == sizeof(c) - 1 && !zend_binary_strcasecmp(ZSTR_VAL(str), ZSTR_LEN(str), (c), sizeof(c) - 1)) str 288 Zend/zend_string.h #define zend_string_equals_literal(str, literal) \ str 289 Zend/zend_string.h (ZSTR_LEN(str) == sizeof(literal)-1 && !memcmp(ZSTR_VAL(str), literal, sizeof(literal) - 1)) str 324 Zend/zend_string.h static zend_always_inline zend_ulong zend_inline_hash_func(const char *str, size_t len) str 330 Zend/zend_string.h hash = ((hash << 5) + hash) + *str++; str 331 Zend/zend_string.h hash = ((hash << 5) + hash) + *str++; str 332 Zend/zend_string.h hash = ((hash << 5) + hash) + *str++; str 333 Zend/zend_string.h hash = ((hash << 5) + hash) + *str++; str 334 Zend/zend_string.h hash = ((hash << 5) + hash) + *str++; str 335 Zend/zend_string.h hash = ((hash << 5) + hash) + *str++; str 336 Zend/zend_string.h hash = ((hash << 5) + hash) + *str++; str 337 Zend/zend_string.h hash = ((hash << 5) + hash) + *str++; str 340 Zend/zend_string.h case 7: hash = ((hash << 5) + hash) + *str++; /* fallthrough... */ str 341 Zend/zend_string.h case 6: hash = ((hash << 5) + hash) + *str++; /* fallthrough... */ str 342 Zend/zend_string.h case 5: hash = ((hash << 5) + hash) + *str++; /* fallthrough... */ str 343 Zend/zend_string.h case 4: hash = ((hash << 5) + hash) + *str++; /* fallthrough... */ str 344 Zend/zend_string.h case 3: hash = ((hash << 5) + hash) + *str++; /* fallthrough... */ str 345 Zend/zend_string.h case 2: hash = ((hash << 5) + hash) + *str++; /* fallthrough... */ str 346 Zend/zend_string.h case 1: hash = ((hash << 5) + hash) + *str++; break; str 363 Zend/zend_string.h zend_string *str; str 365 Zend/zend_string.h str = zend_string_alloc(sizeof("")-1, 1); str 366 Zend/zend_string.h ZSTR_VAL(str)[0] = '\000'; str 369 Zend/zend_string.h *s = zend_new_interned_string(str); str 371 Zend/zend_string.h zend_string_hash_val(str); str 372 Zend/zend_string.h GC_FLAGS(str) |= IS_STR_INTERNED; str 373 Zend/zend_string.h *s = str; str 4412 Zend/zend_strtod.c ZEND_API double zend_hex_strtod(const char *str, const char **endptr) str 4414 Zend/zend_strtod.c const char *s = str; str 4419 Zend/zend_strtod.c if (strlen(str) < 2) { str 4421 Zend/zend_strtod.c *endptr = str; str 4446 Zend/zend_strtod.c *endptr = any ? s - 1 : str; str 4452 Zend/zend_strtod.c ZEND_API double zend_oct_strtod(const char *str, const char **endptr) str 4454 Zend/zend_strtod.c const char *s = str; str 4459 Zend/zend_strtod.c if (strlen(str) < 1) { str 4461 Zend/zend_strtod.c *endptr = str; str 4481 Zend/zend_strtod.c *endptr = any ? s - 1 : str; str 4487 Zend/zend_strtod.c ZEND_API double zend_bin_strtod(const char *str, const char **endptr) str 4489 Zend/zend_strtod.c const char *s = str; str 4494 Zend/zend_strtod.c if (strlen(str) < 2) { str 4496 Zend/zend_strtod.c *endptr = str; str 4526 Zend/zend_strtod.c *endptr = (char *)(any ? s - 1 : str); str 31 Zend/zend_strtod.h ZEND_API double zend_hex_strtod(const char *str, const char **endptr); str 32 Zend/zend_strtod.h ZEND_API double zend_oct_strtod(const char *str, const char **endptr); str 33 Zend/zend_strtod.h ZEND_API double zend_bin_strtod(const char *str, const char **endptr); str 114 Zend/zend_ts_hash.h static zend_always_inline void *zend_ts_hash_str_find_ptr(TsHashTable *ht, const char *str, size_t len) str 118 Zend/zend_ts_hash.h zv = zend_ts_hash_str_find(ht, str, len); str 122 Zend/zend_ts_hash.h static zend_always_inline void *zend_ts_hash_str_update_ptr(TsHashTable *ht, const char *str, size_t len, void *pData) str 127 Zend/zend_ts_hash.h zv = zend_ts_hash_str_update(ht, str, len, &tmp); str 131 Zend/zend_ts_hash.h static zend_always_inline void *zend_ts_hash_str_add_ptr(TsHashTable *ht, const char *str, size_t len, void *pData) str 136 Zend/zend_ts_hash.h zv = zend_ts_hash_str_add(ht, str, len, &tmp); str 105 Zend/zend_types.h zend_string *str; str 512 Zend/zend_types.h #define Z_STR(zval) (zval).value.str str 36 Zend/zend_variables.c zend_string *str = (zend_string*)p; str 37 Zend/zend_variables.c CHECK_ZVAL_STRING_REL(str); str 38 Zend/zend_variables.c zend_string_release(str); str 88 Zend/zend_variables.c zend_string *str = (zend_string*)p; str 89 Zend/zend_variables.c CHECK_ZVAL_STRING_REL(str); str 90 Zend/zend_variables.c zend_string_free(str); str 273 Zend/zend_vm_def.h zend_string *str; str 293 Zend/zend_vm_def.h str = zend_string_realloc(op1_str, len + ZSTR_LEN(op2_str), 0); str 294 Zend/zend_vm_def.h memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 295 Zend/zend_vm_def.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 298 Zend/zend_vm_def.h str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); str 299 Zend/zend_vm_def.h memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); str 300 Zend/zend_vm_def.h memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 301 Zend/zend_vm_def.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 1453 Zend/zend_vm_def.h zend_string *str = Z_STR_P(z); str 1455 Zend/zend_vm_def.h if (ZSTR_LEN(str) != 0) { str 1456 Zend/zend_vm_def.h zend_write(ZSTR_VAL(str), ZSTR_LEN(str)); str 1459 Zend/zend_vm_def.h zend_string *str = _zval_get_string_func(z); str 1461 Zend/zend_vm_def.h if (ZSTR_LEN(str) != 0) { str 1462 Zend/zend_vm_def.h zend_write(ZSTR_VAL(str), ZSTR_LEN(str)); str 1466 Zend/zend_vm_def.h zend_string_release(str); str 2668 Zend/zend_vm_def.h zend_string *op1_str, *op2_str, *str; str 2714 Zend/zend_vm_def.h str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); str 2715 Zend/zend_vm_def.h memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); str 2716 Zend/zend_vm_def.h memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 2717 Zend/zend_vm_def.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 5205 Zend/zend_vm_def.h zend_string *str; str 5210 Zend/zend_vm_def.h str = Z_STR_P(offset); str 5212 Zend/zend_vm_def.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 5217 Zend/zend_vm_def.h zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); str 5226 Zend/zend_vm_def.h str = ZSTR_EMPTY_ALLOC(); str 5239 Zend/zend_vm_def.h str = ZSTR_EMPTY_ALLOC(); str 6509 Zend/zend_vm_def.h zend_string *str; str 6515 Zend/zend_vm_def.h str = Z_STR_P(offset); str 6517 Zend/zend_vm_def.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 6522 Zend/zend_vm_def.h value = zend_hash_find_ind(ht, str); str 6534 Zend/zend_vm_def.h str = ZSTR_EMPTY_ALLOC(); str 6547 Zend/zend_vm_def.h str = ZSTR_EMPTY_ALLOC(); str 7723 Zend/zend_vm_def.h zend_string *str; str 7727 Zend/zend_vm_def.h if (zend_parse_arg_str_weak(&tmp, &str)) { str 7728 Zend/zend_vm_def.h ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str)); str 2866 Zend/zend_vm_execute.h zend_string *str = Z_STR_P(z); str 2868 Zend/zend_vm_execute.h if (ZSTR_LEN(str) != 0) { str 2869 Zend/zend_vm_execute.h zend_write(ZSTR_VAL(str), ZSTR_LEN(str)); str 2872 Zend/zend_vm_execute.h zend_string *str = _zval_get_string_func(z); str 2874 Zend/zend_vm_execute.h if (ZSTR_LEN(str) != 0) { str 2875 Zend/zend_vm_execute.h zend_write(ZSTR_VAL(str), ZSTR_LEN(str)); str 2879 Zend/zend_vm_execute.h zend_string_release(str); str 4224 Zend/zend_vm_execute.h zend_string *str; str 4228 Zend/zend_vm_execute.h if (zend_parse_arg_str_weak(&tmp, &str)) { str 4229 Zend/zend_vm_execute.h ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str)); str 4544 Zend/zend_vm_execute.h zend_string *str; str 4564 Zend/zend_vm_execute.h str = zend_string_realloc(op1_str, len + ZSTR_LEN(op2_str), 0); str 4565 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 4566 Zend/zend_vm_execute.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 4569 Zend/zend_vm_execute.h str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); str 4570 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); str 4571 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 4572 Zend/zend_vm_execute.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 5426 Zend/zend_vm_execute.h zend_string *op1_str, *op2_str, *str; str 5472 Zend/zend_vm_execute.h str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); str 5473 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); str 5474 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 5475 Zend/zend_vm_execute.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 6039 Zend/zend_vm_execute.h zend_string *str; str 6044 Zend/zend_vm_execute.h str = Z_STR_P(offset); str 6046 Zend/zend_vm_execute.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 6051 Zend/zend_vm_execute.h zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); str 6060 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 6073 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 6320 Zend/zend_vm_execute.h zend_string *str; str 6326 Zend/zend_vm_execute.h str = Z_STR_P(offset); str 6328 Zend/zend_vm_execute.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 6333 Zend/zend_vm_execute.h value = zend_hash_find_ind(ht, str); str 6345 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 6358 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 7853 Zend/zend_vm_execute.h zend_string *str; str 7858 Zend/zend_vm_execute.h str = Z_STR_P(offset); str 7860 Zend/zend_vm_execute.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 7865 Zend/zend_vm_execute.h zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); str 7874 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 7887 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 8519 Zend/zend_vm_execute.h zend_string *str; str 8539 Zend/zend_vm_execute.h str = zend_string_realloc(op1_str, len + ZSTR_LEN(op2_str), 0); str 8540 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 8541 Zend/zend_vm_execute.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 8544 Zend/zend_vm_execute.h str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); str 8545 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); str 8546 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 8547 Zend/zend_vm_execute.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 9172 Zend/zend_vm_execute.h zend_string *op1_str, *op2_str, *str; str 9218 Zend/zend_vm_execute.h str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); str 9219 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); str 9220 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 9221 Zend/zend_vm_execute.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 9728 Zend/zend_vm_execute.h zend_string *str; str 9733 Zend/zend_vm_execute.h str = Z_STR_P(offset); str 9735 Zend/zend_vm_execute.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 9740 Zend/zend_vm_execute.h zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); str 9749 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 9762 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 9829 Zend/zend_vm_execute.h zend_string *str; str 9835 Zend/zend_vm_execute.h str = Z_STR_P(offset); str 9837 Zend/zend_vm_execute.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 9842 Zend/zend_vm_execute.h value = zend_hash_find_ind(ht, str); str 9854 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 9867 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 10375 Zend/zend_vm_execute.h zend_string *str; str 10395 Zend/zend_vm_execute.h str = zend_string_realloc(op1_str, len + ZSTR_LEN(op2_str), 0); str 10396 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 10397 Zend/zend_vm_execute.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 10400 Zend/zend_vm_execute.h str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); str 10401 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); str 10402 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 10403 Zend/zend_vm_execute.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 10994 Zend/zend_vm_execute.h zend_string *op1_str, *op2_str, *str; str 11040 Zend/zend_vm_execute.h str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); str 11041 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); str 11042 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 11043 Zend/zend_vm_execute.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 11502 Zend/zend_vm_execute.h zend_string *str; str 11507 Zend/zend_vm_execute.h str = Z_STR_P(offset); str 11509 Zend/zend_vm_execute.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 11514 Zend/zend_vm_execute.h zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); str 11523 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 11536 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 11603 Zend/zend_vm_execute.h zend_string *str; str 11609 Zend/zend_vm_execute.h str = Z_STR_P(offset); str 11611 Zend/zend_vm_execute.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 11616 Zend/zend_vm_execute.h value = zend_hash_find_ind(ht, str); str 11628 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 11641 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 12955 Zend/zend_vm_execute.h zend_string *str; str 12960 Zend/zend_vm_execute.h str = Z_STR_P(offset); str 12962 Zend/zend_vm_execute.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 12967 Zend/zend_vm_execute.h zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); str 12976 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 12989 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 13679 Zend/zend_vm_execute.h zend_string *str; str 13684 Zend/zend_vm_execute.h str = Z_STR_P(offset); str 13686 Zend/zend_vm_execute.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 13691 Zend/zend_vm_execute.h zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); str 13700 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 13713 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 14228 Zend/zend_vm_execute.h zend_string *str; str 14233 Zend/zend_vm_execute.h str = Z_STR_P(offset); str 14235 Zend/zend_vm_execute.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 14240 Zend/zend_vm_execute.h zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); str 14249 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 14262 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 14742 Zend/zend_vm_execute.h zend_string *str; str 14747 Zend/zend_vm_execute.h str = Z_STR_P(offset); str 14749 Zend/zend_vm_execute.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 14754 Zend/zend_vm_execute.h zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); str 14763 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 14776 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 17828 Zend/zend_vm_execute.h zend_string *str; str 17833 Zend/zend_vm_execute.h str = Z_STR_P(offset); str 17835 Zend/zend_vm_execute.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 17840 Zend/zend_vm_execute.h zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); str 17849 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 17862 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 19413 Zend/zend_vm_execute.h zend_string *str; str 19418 Zend/zend_vm_execute.h str = Z_STR_P(offset); str 19420 Zend/zend_vm_execute.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 19425 Zend/zend_vm_execute.h zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); str 19434 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 19447 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 20984 Zend/zend_vm_execute.h zend_string *str; str 20989 Zend/zend_vm_execute.h str = Z_STR_P(offset); str 20991 Zend/zend_vm_execute.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 20996 Zend/zend_vm_execute.h zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); str 21005 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 21018 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 22561 Zend/zend_vm_execute.h zend_string *str; str 22566 Zend/zend_vm_execute.h str = Z_STR_P(offset); str 22568 Zend/zend_vm_execute.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 22573 Zend/zend_vm_execute.h zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); str 22582 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 22595 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 24185 Zend/zend_vm_execute.h zend_string *str; str 24191 Zend/zend_vm_execute.h str = Z_STR_P(offset); str 24193 Zend/zend_vm_execute.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 24198 Zend/zend_vm_execute.h value = zend_hash_find_ind(ht, str); str 24210 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 24223 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 26493 Zend/zend_vm_execute.h zend_string *str; str 26499 Zend/zend_vm_execute.h str = Z_STR_P(offset); str 26501 Zend/zend_vm_execute.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 26506 Zend/zend_vm_execute.h value = zend_hash_find_ind(ht, str); str 26518 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 26531 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 27988 Zend/zend_vm_execute.h zend_string *str; str 27994 Zend/zend_vm_execute.h str = Z_STR_P(offset); str 27996 Zend/zend_vm_execute.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 28001 Zend/zend_vm_execute.h value = zend_hash_find_ind(ht, str); str 28013 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 28026 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 28362 Zend/zend_vm_execute.h zend_string *str = Z_STR_P(z); str 28364 Zend/zend_vm_execute.h if (ZSTR_LEN(str) != 0) { str 28365 Zend/zend_vm_execute.h zend_write(ZSTR_VAL(str), ZSTR_LEN(str)); str 28368 Zend/zend_vm_execute.h zend_string *str = _zval_get_string_func(z); str 28370 Zend/zend_vm_execute.h if (ZSTR_LEN(str) != 0) { str 28371 Zend/zend_vm_execute.h zend_write(ZSTR_VAL(str), ZSTR_LEN(str)); str 28375 Zend/zend_vm_execute.h zend_string_release(str); str 29795 Zend/zend_vm_execute.h zend_string *str; str 29799 Zend/zend_vm_execute.h if (zend_parse_arg_str_weak(&tmp, &str)) { str 29800 Zend/zend_vm_execute.h ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str)); str 30095 Zend/zend_vm_execute.h zend_string *str; str 30115 Zend/zend_vm_execute.h str = zend_string_realloc(op1_str, len + ZSTR_LEN(op2_str), 0); str 30116 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 30117 Zend/zend_vm_execute.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 30120 Zend/zend_vm_execute.h str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); str 30121 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); str 30122 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 30123 Zend/zend_vm_execute.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 31867 Zend/zend_vm_execute.h zend_string *op1_str, *op2_str, *str; str 31913 Zend/zend_vm_execute.h str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); str 31914 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); str 31915 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 31916 Zend/zend_vm_execute.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 32174 Zend/zend_vm_execute.h zend_string *str; str 32179 Zend/zend_vm_execute.h str = Z_STR_P(offset); str 32181 Zend/zend_vm_execute.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 32186 Zend/zend_vm_execute.h zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); str 32195 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 32208 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 32596 Zend/zend_vm_execute.h zend_string *str; str 32602 Zend/zend_vm_execute.h str = Z_STR_P(offset); str 32604 Zend/zend_vm_execute.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 32609 Zend/zend_vm_execute.h value = zend_hash_find_ind(ht, str); str 32621 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 32634 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 34706 Zend/zend_vm_execute.h zend_string *str; str 34711 Zend/zend_vm_execute.h str = Z_STR_P(offset); str 34713 Zend/zend_vm_execute.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 34718 Zend/zend_vm_execute.h zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); str 34727 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 34740 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 35350 Zend/zend_vm_execute.h zend_string *str; str 35370 Zend/zend_vm_execute.h str = zend_string_realloc(op1_str, len + ZSTR_LEN(op2_str), 0); str 35371 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 35372 Zend/zend_vm_execute.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 35375 Zend/zend_vm_execute.h str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); str 35376 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); str 35377 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 35378 Zend/zend_vm_execute.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 36951 Zend/zend_vm_execute.h zend_string *op1_str, *op2_str, *str; str 36997 Zend/zend_vm_execute.h str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); str 36998 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); str 36999 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 37000 Zend/zend_vm_execute.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 37258 Zend/zend_vm_execute.h zend_string *str; str 37263 Zend/zend_vm_execute.h str = Z_STR_P(offset); str 37265 Zend/zend_vm_execute.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 37270 Zend/zend_vm_execute.h zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); str 37279 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 37292 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 37500 Zend/zend_vm_execute.h zend_string *str; str 37506 Zend/zend_vm_execute.h str = Z_STR_P(offset); str 37508 Zend/zend_vm_execute.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 37513 Zend/zend_vm_execute.h value = zend_hash_find_ind(ht, str); str 37525 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 37538 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 38046 Zend/zend_vm_execute.h zend_string *str; str 38066 Zend/zend_vm_execute.h str = zend_string_realloc(op1_str, len + ZSTR_LEN(op2_str), 0); str 38067 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 38068 Zend/zend_vm_execute.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 38071 Zend/zend_vm_execute.h str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); str 38072 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); str 38073 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 38074 Zend/zend_vm_execute.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 39531 Zend/zend_vm_execute.h zend_string *op1_str, *op2_str, *str; str 39577 Zend/zend_vm_execute.h str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); str 39578 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); str 39579 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 39580 Zend/zend_vm_execute.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 39839 Zend/zend_vm_execute.h zend_string *str; str 39844 Zend/zend_vm_execute.h str = Z_STR_P(offset); str 39846 Zend/zend_vm_execute.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 39851 Zend/zend_vm_execute.h zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); str 39860 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 39873 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 40083 Zend/zend_vm_execute.h zend_string *str; str 40089 Zend/zend_vm_execute.h str = Z_STR_P(offset); str 40091 Zend/zend_vm_execute.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 40096 Zend/zend_vm_execute.h value = zend_hash_find_ind(ht, str); str 40108 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 40121 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 40291 Zend/zend_vm_execute.h zend_string *str = Z_STR_P(z); str 40293 Zend/zend_vm_execute.h if (ZSTR_LEN(str) != 0) { str 40294 Zend/zend_vm_execute.h zend_write(ZSTR_VAL(str), ZSTR_LEN(str)); str 40297 Zend/zend_vm_execute.h zend_string *str = _zval_get_string_func(z); str 40299 Zend/zend_vm_execute.h if (ZSTR_LEN(str) != 0) { str 40300 Zend/zend_vm_execute.h zend_write(ZSTR_VAL(str), ZSTR_LEN(str)); str 40304 Zend/zend_vm_execute.h zend_string_release(str); str 40811 Zend/zend_vm_execute.h zend_string *str; str 40815 Zend/zend_vm_execute.h if (zend_parse_arg_str_weak(&tmp, &str)) { str 40816 Zend/zend_vm_execute.h ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str)); str 41075 Zend/zend_vm_execute.h zend_string *str; str 41095 Zend/zend_vm_execute.h str = zend_string_realloc(op1_str, len + ZSTR_LEN(op2_str), 0); str 41096 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 41097 Zend/zend_vm_execute.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 41100 Zend/zend_vm_execute.h str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); str 41101 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); str 41102 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 41103 Zend/zend_vm_execute.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 41766 Zend/zend_vm_execute.h zend_string *op1_str, *op2_str, *str; str 41812 Zend/zend_vm_execute.h str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); str 41813 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); str 41814 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 41815 Zend/zend_vm_execute.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 42226 Zend/zend_vm_execute.h zend_string *str; str 42232 Zend/zend_vm_execute.h str = Z_STR_P(offset); str 42234 Zend/zend_vm_execute.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 42239 Zend/zend_vm_execute.h value = zend_hash_find_ind(ht, str); str 42251 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 42264 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 43453 Zend/zend_vm_execute.h zend_string *str; str 43473 Zend/zend_vm_execute.h str = zend_string_realloc(op1_str, len + ZSTR_LEN(op2_str), 0); str 43474 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 43475 Zend/zend_vm_execute.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 43478 Zend/zend_vm_execute.h str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); str 43479 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); str 43480 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 43481 Zend/zend_vm_execute.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 43914 Zend/zend_vm_execute.h zend_string *op1_str, *op2_str, *str; str 43960 Zend/zend_vm_execute.h str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); str 43961 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); str 43962 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 43963 Zend/zend_vm_execute.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 44193 Zend/zend_vm_execute.h zend_string *str; str 44199 Zend/zend_vm_execute.h str = Z_STR_P(offset); str 44201 Zend/zend_vm_execute.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 44206 Zend/zend_vm_execute.h value = zend_hash_find_ind(ht, str); str 44218 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 44231 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 44598 Zend/zend_vm_execute.h zend_string *str; str 44618 Zend/zend_vm_execute.h str = zend_string_realloc(op1_str, len + ZSTR_LEN(op2_str), 0); str 44619 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 44620 Zend/zend_vm_execute.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 44623 Zend/zend_vm_execute.h str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); str 44624 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); str 44625 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 44626 Zend/zend_vm_execute.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 45060 Zend/zend_vm_execute.h zend_string *op1_str, *op2_str, *str; str 45106 Zend/zend_vm_execute.h str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); str 45107 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); str 45108 Zend/zend_vm_execute.h memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); str 45109 Zend/zend_vm_execute.h ZVAL_NEW_STR(EX_VAR(opline->result.var), str); str 45340 Zend/zend_vm_execute.h zend_string *str; str 45346 Zend/zend_vm_execute.h str = Z_STR_P(offset); str 45348 Zend/zend_vm_execute.h if (ZEND_HANDLE_NUMERIC(str, hval)) { str 45353 Zend/zend_vm_execute.h value = zend_hash_find_ind(ht, str); str 45365 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 45378 Zend/zend_vm_execute.h str = ZSTR_EMPTY_ALLOC(); str 197 ext/bcmath/bcmath.c static void php_str2num(bc_num *num, char *str) str 201 ext/bcmath/bcmath.c if (!(p = strchr(str, '.'))) { str 202 ext/bcmath/bcmath.c bc_str2num(num, str, 0); str 206 ext/bcmath/bcmath.c bc_str2num(num, str, strlen(p+1)); str 112 ext/bcmath/libbcmath/src/bcmath.h _PROTOTYPE(void bc_str2num, (bc_num *num, char *str, int scale)); str 47 ext/bcmath/libbcmath/src/num2str.c zend_string *str; str 55 ext/bcmath/libbcmath/src/num2str.c str = zend_string_alloc(num->n_len + num->n_scale + signch + 1, 0); str 57 ext/bcmath/libbcmath/src/num2str.c str = zend_string_alloc(num->n_len + signch, 0); str 58 ext/bcmath/libbcmath/src/num2str.c if (str == NULL) bc_out_of_memory(); str 61 ext/bcmath/libbcmath/src/num2str.c sptr = ZSTR_VAL(str); str 79 ext/bcmath/libbcmath/src/num2str.c ZSTR_LEN(str) = sptr - (char *)ZSTR_VAL(str); str 80 ext/bcmath/libbcmath/src/num2str.c return str; str 44 ext/bcmath/libbcmath/src/str2num.c bc_str2num (bc_num *num, char *str, int scale) str 54 ext/bcmath/libbcmath/src/str2num.c ptr = str; str 79 ext/bcmath/libbcmath/src/str2num.c ptr = str; str 91 ext/bz2/bz2.c ZEND_ARG_INFO(0, str) str 674 ext/com_dotnet/com_com.c char *str; str 676 ext/com_dotnet/com_com.c str = php_com_olestring_to_string(guid_string, &len, CP_ACP); str 677 ext/com_dotnet/com_com.c RETVAL_STRINGL(str, len); str 679 ext/com_dotnet/com_com.c efree(str); str 352 ext/com_dotnet/com_persist.c char *str = php_com_olestring_to_string(olename, str 354 ext/com_dotnet/com_persist.c RETVAL_STRINGL(str, len); str 356 ext/com_dotnet/com_persist.c efree(str); str 122 ext/com_dotnet/com_typeinfo.c char *str = NULL; str 130 ext/com_dotnet/com_typeinfo.c spprintf(&str, 0, "%s,%d,%d", keyname, major_tmp, minor_tmp); str 132 ext/com_dotnet/com_typeinfo.c TL = php_com_load_typelib(str, codepage); str 134 ext/com_dotnet/com_typeinfo.c efree(str); str 238 ext/com_dotnet/com_variant.c char *str = php_com_olestring_to_string(olestring, str 240 ext/com_dotnet/com_variant.c ZVAL_STRINGL(z, str, len); str 242 ext/com_dotnet/com_variant.c efree(str); str 170 ext/curl/interface.c static int php_curl_option_str(php_curl *ch, zend_long option, const char *str, const int len, zend_bool make_copy) str 174 ext/curl/interface.c if (strlen(str) != len) { str 185 ext/curl/interface.c copystr = estrndup(str, len); str 187 ext/curl/interface.c zend_llist_add_element(&ch->to_free->str, ©str); str 190 ext/curl/interface.c error = curl_easy_setopt(ch->cp, option, str); str 344 ext/curl/interface.c ZEND_ARG_INFO(0, str) str 349 ext/curl/interface.c ZEND_ARG_INFO(0, str) str 510 ext/curl/interface.c char str[1024]; str 517 ext/curl/interface.c sprintf(str, "%d", d->age); str 518 ext/curl/interface.c php_info_print_table_row(2, "Age", str); str 585 ext/curl/interface.c n += sprintf(str + n, "%s%s", *p, *(p + 1) != NULL ? ", " : ""); str 588 ext/curl/interface.c php_info_print_table_row(2, "Protocols", str); str 1620 ext/curl/interface.c if (ch->header.str) { str 1621 ext/curl/interface.c zend_string_release(ch->header.str); str 1624 ext/curl/interface.c ch->header.str = zend_string_init(buf, buf_len, 0); str 1757 ext/curl/interface.c zend_llist_init(&ch->to_free->str, sizeof(char *), (llist_dtor_func_t)curl_free_string, 0); str 1851 ext/curl/interface.c curl_easy_setopt(ch->cp, CURLOPT_ERRORBUFFER, ch->err.str); str 1981 ext/curl/interface.c curl_easy_setopt(dupch->cp, CURLOPT_ERRORBUFFER, dupch->err.str); str 2267 ext/curl/interface.c zend_string *str = zval_get_string(zvalue); str 2268 ext/curl/interface.c int ret = php_curl_option_str(ch, option, ZSTR_VAL(str), ZSTR_LEN(str), 0); str 2269 ext/curl/interface.c zend_string_release(str); str 2292 ext/curl/interface.c zend_string *str = zval_get_string(zvalue); str 2293 ext/curl/interface.c int ret = php_curl_option_str(ch, option, ZSTR_VAL(str), ZSTR_LEN(str), 0); str 2294 ext/curl/interface.c zend_string_release(str); str 2303 ext/curl/interface.c zend_string *str = zval_get_string(zvalue); str 2304 ext/curl/interface.c int ret = php_curl_option_str(ch, option, ZSTR_VAL(str), ZSTR_LEN(str), 1); str 2305 ext/curl/interface.c zend_string_release(str); str 2312 ext/curl/interface.c zend_string *str = zval_get_string(zvalue); str 2313 ext/curl/interface.c int ret = php_curl_option_url(ch, ZSTR_VAL(str), ZSTR_LEN(str)); str 2314 ext/curl/interface.c zend_string_release(str); str 2618 ext/curl/interface.c zend_string *str = zval_get_string(zvalue); str 2620 ext/curl/interface.c error = curl_easy_setopt(ch->cp, CURLOPT_POSTFIELDSIZE, ZSTR_LEN(str)); str 2621 ext/curl/interface.c error = curl_easy_setopt(ch->cp, CURLOPT_COPYPOSTFIELDS, ZSTR_VAL(str)); str 2622 ext/curl/interface.c zend_string_release(str); str 2625 ext/curl/interface.c zend_string *str = zval_get_string(zvalue); str 2627 ext/curl/interface.c post = estrndup(ZSTR_VAL(str), ZSTR_LEN(str)); str 2628 ext/curl/interface.c zend_llist_add_element(&ch->to_free->str, &post); str 2631 ext/curl/interface.c error = curl_easy_setopt(ch->cp, CURLOPT_POSTFIELDSIZE, ZSTR_LEN(str)); str 2632 ext/curl/interface.c zend_string_release(str); str 2723 ext/curl/interface.c zend_string *str = zval_get_string(zvalue); str 2726 ext/curl/interface.c if (ZSTR_LEN(str) && php_check_open_basedir(ZSTR_VAL(str))) { str 2727 ext/curl/interface.c zend_string_release(str); str 2731 ext/curl/interface.c ret = php_curl_option_str(ch, option, ZSTR_VAL(str), ZSTR_LEN(str), 0); str 2732 ext/curl/interface.c zend_string_release(str); str 2850 ext/curl/interface.c if (ch->header.str) { str 2851 ext/curl/interface.c zend_string_release(ch->header.str); str 2852 ext/curl/interface.c ch->header.str = NULL; str 2855 ext/curl/interface.c memset(ch->err.str, 0, CURL_ERROR_SIZE + 1); str 3042 ext/curl/interface.c if (ch->header.str) { str 3043 ext/curl/interface.c CAASTR("request_header", ch->header.str); str 3048 ext/curl/interface.c if (ch->header.str) { str 3049 ext/curl/interface.c RETURN_STR_COPY(ch->header.str); str 3144 ext/curl/interface.c ch->err.str[CURL_ERROR_SIZE] = 0; str 3145 ext/curl/interface.c RETURN_STRING(ch->err.str); str 3222 ext/curl/interface.c zend_llist_clean(&ch->to_free->str); str 3238 ext/curl/interface.c if (ch->header.str) { str 3239 ext/curl/interface.c zend_string_release(ch->header.str); str 3282 ext/curl/interface.c const char *str; str 3288 ext/curl/interface.c str = curl_easy_strerror(code); str 3289 ext/curl/interface.c if (str) { str 3290 ext/curl/interface.c RETURN_STRING(str); str 3379 ext/curl/interface.c char *str = NULL, *res = NULL; str 3384 ext/curl/interface.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs", &zid, &str, &str_len) == FAILURE) { str 3392 ext/curl/interface.c if ((res = curl_easy_escape(ch->cp, str, str_len))) { str 3405 ext/curl/interface.c char *str = NULL, *out = NULL; str 3411 ext/curl/interface.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs", &zid, &str, &str_len) == FAILURE) { str 3419 ext/curl/interface.c if ((out = curl_easy_unescape(ch->cp, str, str_len, &out_len))) { str 392 ext/curl/multi.c const char *str; str 398 ext/curl/multi.c str = curl_multi_strerror(code); str 399 ext/curl/multi.c if (str) { str 400 ext/curl/multi.c RETURN_STRING(str); str 162 ext/curl/php_curl.h char str[CURL_ERROR_SIZE + 1]; str 167 ext/curl/php_curl.h zend_string *str; str 171 ext/curl/php_curl.h zend_llist str; str 116 ext/date/lib/parse_date.c #define TIMELIB_HAVE_TIME() { if (s->time->have_time) { add_error(s, "Double time specification"); timelib_string_free(str); return TIMELIB_ERROR; } else { s->time->have_time = 1; s->time->h = 0; s->time->i = 0; s->time->s = 0; s->time->f = 0; } } str 118 ext/date/lib/parse_date.c #define TIMELIB_HAVE_DATE() { if (s->time->have_date) { add_error(s, "Double date specification"); timelib_string_free(str); return TIMELIB_ERROR; } else { s->time->have_date = 1; } } str 123 ext/date/lib/parse_date.c #define TIMELIB_HAVE_TZ() { s->cur = cursor; if (s->time->have_zone) { s->time->have_zone > 1 ? add_error(s, "Double timezone specification") : add_warning(s, "Double timezone specification"); timelib_string_free(str); s->time->have_zone++; return TIMELIB_ERROR; } else { s->time->have_zone++; } } str 125 ext/date/lib/parse_date.c #define TIMELIB_INIT s->cur = cursor; str = timelib_string(s); ptr = str str 126 ext/date/lib/parse_date.c #define TIMELIB_DEINIT timelib_string_free(str) str 158 ext/date/lib/parse_date.c uchar *lim, *str, *ptr, *cur, *tok, *pos; str 350 ext/date/lib/parse_date.c s->errors->warning_messages[s->errors->warning_count - 1].position = s->tok ? s->tok - s->str : 0; str 359 ext/date/lib/parse_date.c s->errors->error_messages[s->errors->error_count - 1].position = s->tok ? s->tok - s->str : 0; str 451 ext/date/lib/parse_date.c char *begin, *end, *str; str 470 ext/date/lib/parse_date.c str = timelib_calloc(1, end - begin + 1); str 471 ext/date/lib/parse_date.c memcpy(str, begin, end - begin); str 472 ext/date/lib/parse_date.c tmp_nr = strtoll(str, NULL, 10); str 473 ext/date/lib/parse_date.c timelib_free(str); str 494 ext/date/lib/parse_date.c char *begin, *end, *str; str 510 ext/date/lib/parse_date.c str = timelib_calloc(1, end - begin + 1); str 511 ext/date/lib/parse_date.c memcpy(str, begin, end - begin); str 512 ext/date/lib/parse_date.c if (str[0] == ':') { str 513 ext/date/lib/parse_date.c str[0] = '.'; str 515 ext/date/lib/parse_date.c tmp_nr = strtod(str, NULL); str 516 ext/date/lib/parse_date.c timelib_free(str); str 817 ext/date/lib/parse_date.c char *str, *ptr = NULL; str 24658 ext/date/lib/parse_date.c in.str = timelib_malloc((e - s) + YYMAXFILL); str 24659 ext/date/lib/parse_date.c memset(in.str, 0, (e - s) + YYMAXFILL); str 24660 ext/date/lib/parse_date.c memcpy(in.str, s, (e - s)); str 24661 ext/date/lib/parse_date.c in.lim = in.str + (e - s) + YYMAXFILL; str 24662 ext/date/lib/parse_date.c in.cur = in.str; str 24694 ext/date/lib/parse_date.c timelib_free(in.str); str 82 ext/date/lib/parse_iso_intervals.c #define TIMELIB_INIT s->cur = cursor; str = timelib_string(s); ptr = str str 83 ext/date/lib/parse_iso_intervals.c #define TIMELIB_DEINIT timelib_string_free(str) str 97 ext/date/lib/parse_iso_intervals.c uchar *lim, *str, *ptr, *cur, *tok, *pos; str 117 ext/date/lib/parse_iso_intervals.c s->errors->warning_messages[s->errors->warning_count - 1].position = s->tok ? s->tok - s->str : 0; str 126 ext/date/lib/parse_iso_intervals.c s->errors->error_messages[s->errors->error_count - 1].position = s->tok ? s->tok - s->str : 0; str 141 ext/date/lib/parse_iso_intervals.c char *begin, *end, *str; str 157 ext/date/lib/parse_iso_intervals.c str = timelib_calloc(1, end - begin + 1); str 158 ext/date/lib/parse_iso_intervals.c memcpy(str, begin, end - begin); str 159 ext/date/lib/parse_iso_intervals.c tmp_nr = strtoll(str, NULL, 10); str 160 ext/date/lib/parse_iso_intervals.c timelib_free(str); str 252 ext/date/lib/parse_iso_intervals.c char *str, *ptr = NULL; str 949 ext/date/lib/parse_iso_intervals.c in.str = timelib_malloc((e - s) + YYMAXFILL); str 950 ext/date/lib/parse_iso_intervals.c memset(in.str, 0, (e - s) + YYMAXFILL); str 951 ext/date/lib/parse_iso_intervals.c memcpy(in.str, s, (e - s)); str 952 ext/date/lib/parse_iso_intervals.c in.lim = in.str + (e - s) + YYMAXFILL; str 953 ext/date/lib/parse_iso_intervals.c in.cur = in.str; str 1003 ext/date/lib/parse_iso_intervals.c timelib_free(in.str); str 4125 ext/date/php_date.c zend_string *str = zval_get_string(z_arg); \ str 4126 ext/date/php_date.c DATE_A64I((*intobj)->diff->member, ZSTR_VAL(str)); \ str 4127 ext/date/php_date.c zend_string_release(str); \ str 1240 ext/dba/dba.c char *str = hptr->info(hptr, NULL); str 1241 ext/dba/dba.c add_assoc_string(return_value, hptr->name, str); str 1242 ext/dba/dba.c efree(str); str 145 ext/dba/libinifile/inifile.c static char *etrim(const char *str) str 150 ext/dba/libinifile/inifile.c if (!str) { str 153 ext/dba/libinifile/inifile.c val = (char*)str; str 158 ext/dom/attr.c zend_string *str; str 170 ext/dom/attr.c str = zval_get_string(newval); str 172 ext/dom/attr.c xmlNodeSetContentLen((xmlNodePtr) attrp, (xmlChar *) ZSTR_VAL(str), ZSTR_LEN(str) + 1); str 174 ext/dom/attr.c zend_string_release(str); str 102 ext/dom/characterdata.c zend_string *str; str 109 ext/dom/characterdata.c str = zval_get_string(newval); str 111 ext/dom/characterdata.c xmlNodeSetContentLen(nodep, (xmlChar *) ZSTR_VAL(str), ZSTR_LEN(str) + 1); str 113 ext/dom/characterdata.c zend_string_release(str); str 334 ext/dom/document.c zend_string *str; str 342 ext/dom/document.c str = zval_get_string(newval); str 351 ext/dom/document.c docp->encoding = xmlStrdup((const xmlChar *) ZSTR_VAL(str)); str 356 ext/dom/document.c zend_string_release(str); str 429 ext/dom/document.c zend_string *str; str 440 ext/dom/document.c str = zval_get_string(newval); str 442 ext/dom/document.c docp->version = xmlStrdup((const xmlChar *) ZSTR_VAL(str)); str 444 ext/dom/document.c zend_string_release(str); str 657 ext/dom/document.c zend_string *str; str 668 ext/dom/document.c str = zval_get_string(newval); str 670 ext/dom/document.c docp->URL = xmlStrdup((const xmlChar *) ZSTR_VAL(str)); str 672 ext/dom/document.c zend_string_release(str); str 203 ext/dom/node.c char *str = NULL; str 221 ext/dom/node.c str = (char *) qname; str 223 ext/dom/node.c str = (char *) nodep->name; str 232 ext/dom/node.c str = (char *) qname; str 234 ext/dom/node.c str = (char *) nodep->name; str 243 ext/dom/node.c str = (char *) nodep->name; str 246 ext/dom/node.c str = "#cdata-section"; str 249 ext/dom/node.c str = "#comment"; str 253 ext/dom/node.c str = "#document"; str 256 ext/dom/node.c str = "#document-fragment"; str 259 ext/dom/node.c str = "#text"; str 265 ext/dom/node.c if (str != NULL) { str 266 ext/dom/node.c ZVAL_STRING(retval, str); str 289 ext/dom/node.c char *str = NULL; str 304 ext/dom/node.c str = (char *) xmlNodeGetContent(nodep); str 307 ext/dom/node.c str = (char *) xmlNodeGetContent(nodep->children); str 310 ext/dom/node.c str = NULL; str 314 ext/dom/node.c if(str != NULL) { str 315 ext/dom/node.c ZVAL_STRING(retval, str); str 316 ext/dom/node.c xmlFree(str); str 346 ext/dom/node.c zend_string *str = zval_get_string(newval); str 347 ext/dom/node.c xmlNodeSetContentLen(nodep, (xmlChar *) ZSTR_VAL(str), ZSTR_LEN(str) + 1); str 348 ext/dom/node.c zend_string_release(str); str 628 ext/dom/node.c char *str = NULL; str 640 ext/dom/node.c str = (char *) nodep->ns->href; str 644 ext/dom/node.c str = NULL; str 648 ext/dom/node.c if (str != NULL) { str 649 ext/dom/node.c ZVAL_STRING(retval, str); str 668 ext/dom/node.c char *str = NULL; str 681 ext/dom/node.c str = (char *) ns->prefix; str 685 ext/dom/node.c str = NULL; str 689 ext/dom/node.c if (str == NULL) { str 692 ext/dom/node.c ZVAL_STRING(retval, str); str 700 ext/dom/node.c zend_string *str; str 723 ext/dom/node.c str = zval_get_string(newval); str 724 ext/dom/node.c prefix = ZSTR_VAL(str); str 748 ext/dom/node.c zend_string_release(str); str 755 ext/dom/node.c zend_string_release(str); str 827 ext/dom/node.c char *str = NULL; str 834 ext/dom/node.c str = (char *) xmlNodeGetContent(nodep); str 836 ext/dom/node.c if (str != NULL) { str 837 ext/dom/node.c ZVAL_STRING(retval, str); str 838 ext/dom/node.c xmlFree(str); str 849 ext/dom/node.c zend_string *str; str 856 ext/dom/node.c str = zval_get_string(newval); str 859 ext/dom/node.c xmlNodeAddContent(nodep, ZSTR_VAL(str)); str 860 ext/dom/node.c zend_string_release(str); str 137 ext/dom/processinginstruction.c zend_string *str; str 144 ext/dom/processinginstruction.c str = zval_get_string(newval); str 146 ext/dom/processinginstruction.c xmlNodeSetContentLen(nodep, (xmlChar *) ZSTR_VAL(str), ZSTR_LEN(str) + 1); str 148 ext/dom/processinginstruction.c zend_string_release(str); str 82 ext/dom/xpath.c char *str; str 132 ext/dom/xpath.c str = (char *)xmlXPathCastToString(obj); str 133 ext/dom/xpath.c ZVAL_STRING(&fci.params[i], str); str 134 ext/dom/xpath.c xmlFree(str); str 223 ext/dom/xpath.c zend_string *str = zval_get_string(&retval); str 224 ext/dom/xpath.c valuePush(ctxt, xmlXPathNewString((xmlChar *) ZSTR_VAL(str))); str 225 ext/dom/xpath.c zend_string_release(str); str 520 ext/dom/xpath.c zend_string *str = zval_get_string(entry); str 522 ext/dom/xpath.c zend_hash_update(intern->registered_phpfunctions, str, &new_string); str 523 ext/dom/xpath.c zend_string_release(str); str 277 ext/exif/exif.c static size_t php_strnlen(char* str, size_t maxlen) { str 280 ext/exif/exif.c if (str && maxlen && *str) { str 283 ext/exif/exif.c } while (--maxlen && *(++str)); str 671 ext/fileinfo/libmagic/apprentice.c nonmagic(const char *str) str 676 ext/fileinfo/libmagic/apprentice.c for (p = str; *p; p++) str 82 ext/fileinfo/libmagic/fsmagic.c handle_mime(struct magic_set *ms, int mime, const char *str) str 85 ext/fileinfo/libmagic/fsmagic.c if (file_printf(ms, "inode/%s", str) == -1) str 513 ext/fileinfo/libmagic/funcs.c file_printable(char *buf, size_t bufsiz, const char *str) str 516 ext/fileinfo/libmagic/funcs.c const unsigned char *s = (const unsigned char *)str; str 140 ext/fileinfo/libmagic/readcdf.c const char *str = NULL; str 147 ext/fileinfo/libmagic/readcdf.c str = cdf_clsid_to_mime(root_storage->d_storage_uuid, str 205 ext/fileinfo/libmagic/readcdf.c } else if (str == NULL && info[i].pi_id == str 207 ext/fileinfo/libmagic/readcdf.c str = cdf_app_to_mime(vbuf, app2mime); str 245 ext/fileinfo/libmagic/readcdf.c if (str == NULL) str 247 ext/fileinfo/libmagic/readcdf.c if (file_printf(ms, "application/%s", str) == -1) str 297 ext/fileinfo/libmagic/readcdf.c const char *str; str 327 ext/fileinfo/libmagic/readcdf.c str = cdf_clsid_to_mime(root_storage->d_storage_uuid, str 329 ext/fileinfo/libmagic/readcdf.c if (str) { str 330 ext/fileinfo/libmagic/readcdf.c if (file_printf(ms, ", %s", str) == -1) str 553 ext/fileinfo/libmagic/readcdf.c const char *str = NULL; str 558 ext/fileinfo/libmagic/readcdf.c for (j = 0; str == NULL && j < dir.dir_len; j++) { str 562 ext/fileinfo/libmagic/readcdf.c str = cdf_app_to_mime(name, str 566 ext/fileinfo/libmagic/readcdf.c if (str != NULL) { str 567 ext/fileinfo/libmagic/readcdf.c if (file_printf(ms, "%s", str) == -1) str 572 ext/fileinfo/libmagic/readcdf.c if (str == NULL) str 573 ext/fileinfo/libmagic/readcdf.c str = "vnd.ms-office"; str 574 ext/fileinfo/libmagic/readcdf.c if (file_printf(ms, "application/%s", str) == -1) str 510 ext/fileinfo/libmagic/softmagic.c char *str = p->s; str 513 ext/fileinfo/libmagic/softmagic.c t = ms->offset + strlen(str); str 516 ext/fileinfo/libmagic/softmagic.c str[strcspn(str, "\r\n")] = '\0'; str 520 ext/fileinfo/libmagic/softmagic.c while (isspace((unsigned char)*str)) str 521 ext/fileinfo/libmagic/softmagic.c str++; str 522 ext/fileinfo/libmagic/softmagic.c last = str; str 532 ext/fileinfo/libmagic/softmagic.c file_printable(sbuf, sizeof(sbuf), str)) == -1) str 1062 ext/fileinfo/libmagic/softmagic.c mdebug(uint32_t offset, const char *str, size_t len) str 1065 ext/fileinfo/libmagic/softmagic.c file_showstr(stderr, str, len); str 84 ext/filter/logical_filters.c static int _php_filter_validate_ipv6(char *str, size_t str_len); str 86 ext/filter/logical_filters.c static int php_filter_parse_int(const char *str, size_t str_len, zend_long *ret) { /* {{{ */ str 89 ext/filter/logical_filters.c const char *end = str + str_len; str 91 ext/filter/logical_filters.c switch (*str) { str 95 ext/filter/logical_filters.c str++; str 100 ext/filter/logical_filters.c if (*str == '0' && str + 1 == end) { str 106 ext/filter/logical_filters.c if (str < end && *str >= '1' && *str <= '9') { str 107 ext/filter/logical_filters.c ctx_value = ((sign)?-1:1) * ((*(str++)) - '0'); str 112 ext/filter/logical_filters.c if ((end - str > MAX_LENGTH_OF_LONG - 1) /* number too long */ str 113 ext/filter/logical_filters.c || (SIZEOF_LONG == 4 && (end - str == MAX_LENGTH_OF_LONG - 1) && *str > '2')) { str 118 ext/filter/logical_filters.c while (str < end) { str 119 ext/filter/logical_filters.c if (*str >= '0' && *str <= '9') { str 120 ext/filter/logical_filters.c digit = (*(str++) - '0'); str 138 ext/filter/logical_filters.c static int php_filter_parse_octal(const char *str, size_t str_len, zend_long *ret) { /* {{{ */ str 140 ext/filter/logical_filters.c const char *end = str + str_len; str 142 ext/filter/logical_filters.c while (str < end) { str 143 ext/filter/logical_filters.c if (*str >= '0' && *str <= '7') { str 144 ext/filter/logical_filters.c zend_ulong n = ((*(str++)) - '0'); str 161 ext/filter/logical_filters.c static int php_filter_parse_hex(const char *str, size_t str_len, zend_long *ret) { /* {{{ */ str 163 ext/filter/logical_filters.c const char *end = str + str_len; str 166 ext/filter/logical_filters.c while (str < end) { str 167 ext/filter/logical_filters.c if (*str >= '0' && *str <= '9') { str 168 ext/filter/logical_filters.c n = ((*(str++)) - '0'); str 169 ext/filter/logical_filters.c } else if (*str >= 'a' && *str <= 'f') { str 170 ext/filter/logical_filters.c n = ((*(str++)) - ('a' - 10)); str 171 ext/filter/logical_filters.c } else if (*str >= 'A' && *str <= 'F') { str 172 ext/filter/logical_filters.c n = ((*(str++)) - ('A' - 10)); str 256 ext/filter/logical_filters.c char *str = Z_STRVAL_P(value); str 260 ext/filter/logical_filters.c PHP_FILTER_TRIM_DEFAULT_EX(str, len, 0); str 270 ext/filter/logical_filters.c if (*str == '1') { str 272 ext/filter/logical_filters.c } else if (*str == '0') { str 279 ext/filter/logical_filters.c if (strncasecmp(str, "on", 2) == 0) { str 281 ext/filter/logical_filters.c } else if (strncasecmp(str, "no", 2) == 0) { str 288 ext/filter/logical_filters.c if (strncasecmp(str, "yes", 3) == 0) { str 290 ext/filter/logical_filters.c } else if (strncasecmp(str, "off", 3) == 0) { str 297 ext/filter/logical_filters.c if (strncasecmp(str, "true", 4) == 0) { str 304 ext/filter/logical_filters.c if (strncasecmp(str, "false", 5) == 0) { str 326 ext/filter/logical_filters.c char *str, *end; str 341 ext/filter/logical_filters.c str = Z_STRVAL_P(value); str 343 ext/filter/logical_filters.c PHP_FILTER_TRIM_DEFAULT(str, len); str 344 ext/filter/logical_filters.c end = str + len; str 358 ext/filter/logical_filters.c if (str < end && (*str == '+' || *str == '-')) { str 359 ext/filter/logical_filters.c *p++ = *str++; str 364 ext/filter/logical_filters.c while (str < end && *str >= '0' && *str <= '9') { str 366 ext/filter/logical_filters.c *p++ = *str++; str 368 ext/filter/logical_filters.c if (str == end || *str == dec_sep || *str == 'e' || *str == 'E') { str 372 ext/filter/logical_filters.c if (*str == dec_sep) { str 374 ext/filter/logical_filters.c str++; str 375 ext/filter/logical_filters.c while (str < end && *str >= '0' && *str <= '9') { str 376 ext/filter/logical_filters.c *p++ = *str++; str 379 ext/filter/logical_filters.c if (*str == 'e' || *str == 'E') { str 380 ext/filter/logical_filters.c *p++ = *str++; str 381 ext/filter/logical_filters.c if (str < end && (*str == '+' || *str == '-')) { str 382 ext/filter/logical_filters.c *p++ = *str++; str 384 ext/filter/logical_filters.c while (str < end && *str >= '0' && *str <= '9') { str 385 ext/filter/logical_filters.c *p++ = *str++; str 390 ext/filter/logical_filters.c if ((flags & FILTER_FLAG_ALLOW_THOUSAND) && (*str == tsd_sep[0] || *str == tsd_sep[1] || *str == tsd_sep[2])) { str 395 ext/filter/logical_filters.c str++; str 400 ext/filter/logical_filters.c if (str != end) { str 632 ext/filter/logical_filters.c static int _php_filter_validate_ipv4(char *str, size_t str_len, int *ip) /* {{{ */ str 634 ext/filter/logical_filters.c const char *end = str + str_len; str 638 ext/filter/logical_filters.c while (str < end) { str 640 ext/filter/logical_filters.c if (*str < '0' || *str > '9') { str 643 ext/filter/logical_filters.c leading_zero = (*str == '0'); str 645 ext/filter/logical_filters.c num = ((*(str++)) - '0'); str 646 ext/filter/logical_filters.c while (str < end && (*str >= '0' && *str <= '9')) { str 647 ext/filter/logical_filters.c num = num * 10 + ((*(str++)) - '0'); str 658 ext/filter/logical_filters.c return str == end; str 659 ext/filter/logical_filters.c } else if (str >= end || *(str++) != '.') { str 667 ext/filter/logical_filters.c static int _php_filter_validate_ipv6(char *str, size_t str_len) /* {{{ */ str 675 ext/filter/logical_filters.c char *s = str; str 677 ext/filter/logical_filters.c if (!memchr(str, ':', str_len)) { str 682 ext/filter/logical_filters.c ipv4 = memchr(str, '.', str_len); str 684 ext/filter/logical_filters.c while (ipv4 > str && *(ipv4-1) != ':') { str 688 ext/filter/logical_filters.c if (!_php_filter_validate_ipv4(ipv4, (str_len - (ipv4 - str)), ip4elm)) { str 692 ext/filter/logical_filters.c str_len = ipv4 - str; /* length excluding ipv4 */ str 705 ext/filter/logical_filters.c end = str + str_len; str 707 ext/filter/logical_filters.c while (str < end) { str 708 ext/filter/logical_filters.c if (*str == ':') { str 709 ext/filter/logical_filters.c if (++str >= end) { str 713 ext/filter/logical_filters.c if (*str == ':') { str 720 ext/filter/logical_filters.c if (++str == end) { str 723 ext/filter/logical_filters.c } else if ((str - 1) == s) { str 729 ext/filter/logical_filters.c while ((str < end) && str 730 ext/filter/logical_filters.c ((*str >= '0' && *str <= '9') || str 731 ext/filter/logical_filters.c (*str >= 'a' && *str <= 'f') || str 732 ext/filter/logical_filters.c (*str >= 'A' && *str <= 'F'))) { str 734 ext/filter/logical_filters.c str++; str 32 ext/filter/sanitizing_filters.c smart_str str = {0}; str 43 ext/filter/sanitizing_filters.c smart_str_appendl(&str, "&#", 2); str 44 ext/filter/sanitizing_filters.c smart_str_append_unsigned(&str, (zend_ulong)*s); str 45 ext/filter/sanitizing_filters.c smart_str_appendc(&str, ';'); str 48 ext/filter/sanitizing_filters.c smart_str_appendc(&str, *s); str 53 ext/filter/sanitizing_filters.c smart_str_0(&str); str 55 ext/filter/sanitizing_filters.c ZVAL_NEW_STR(value, str.s); str 72 ext/filter/sanitizing_filters.c zend_string *str; str 90 ext/filter/sanitizing_filters.c str = zend_string_safe_alloc(Z_STRLEN_P(value), 3, 0, 0); str 91 ext/filter/sanitizing_filters.c p = (unsigned char *) ZSTR_VAL(str); str 106 ext/filter/sanitizing_filters.c ZSTR_LEN(str) = p - (unsigned char *)ZSTR_VAL(str); str 108 ext/filter/sanitizing_filters.c ZVAL_NEW_STR(value, str); str 113 ext/filter/sanitizing_filters.c unsigned char *str; str 122 ext/filter/sanitizing_filters.c str = (unsigned char *)Z_STRVAL_P(value); str 126 ext/filter/sanitizing_filters.c if ((str[i] >= 127) && (flags & FILTER_FLAG_STRIP_HIGH)) { str 127 ext/filter/sanitizing_filters.c } else if ((str[i] < 32) && (flags & FILTER_FLAG_STRIP_LOW)) { str 128 ext/filter/sanitizing_filters.c } else if ((str[i] == '`') && (flags & FILTER_FLAG_STRIP_BACKTICK)) { str 130 ext/filter/sanitizing_filters.c ZSTR_VAL(buf)[c] = str[i]; str 160 ext/filter/sanitizing_filters.c unsigned char *str; str 164 ext/filter/sanitizing_filters.c str = (unsigned char *)Z_STRVAL_P(value); str 168 ext/filter/sanitizing_filters.c if ((*map)[str[i]]) { str 169 ext/filter/sanitizing_filters.c ZSTR_VAL(buf)[c] = str[i]; str 616 ext/gd/gd.c ZEND_ARG_INFO(0, str) str 625 ext/gd/gd.c ZEND_ARG_INFO(0, str) str 3515 ext/gd/gd.c unsigned char *str = NULL; str 3531 ext/gd/gd.c str = (unsigned char *) estrndup(C, C_len); str 3532 ext/gd/gd.c l = strlen((char *)str); str 3550 ext/gd/gd.c gdImageChar(im, font, x, y, (int) ((unsigned char) str[i]), col); str 3557 ext/gd/gd.c gdImageCharUp(im, font, x, y, (int) str[i], col); str 3563 ext/gd/gd.c if (str) { str 3564 ext/gd/gd.c efree(str); str 3832 ext/gd/gd.c char *str = NULL, *fontname = NULL; str 3840 ext/gd/gd.c } else if (zend_parse_parameters(argc, "ddss|a", &ptsize, &angle, &fontname, &fontname_len, &str, &str_len, &EXT) == FAILURE) { str 3846 ext/gd/gd.c } else if (zend_parse_parameters(argc, "rddlllss|a", &IM, &ptsize, &angle, &x, &y, &col, &fontname, &fontname_len, &str, &str_len, &EXT) == FAILURE) { str 3887 ext/gd/gd.c error = gdImageStringFTEx(im, brect, col, fontname, ptsize, angle, x, y, str, &strex); str 3890 ext/gd/gd.c error = gdImageStringFT(im, brect, col, fontname, ptsize, angle, x, y, str); str 208 ext/gd/libgd/gdft.c static int gdTcl_UtfToUniChar (char *str, Tcl_UniChar * chPtr) str 215 ext/gd/libgd/gdft.c byte = *((unsigned char *) str); str 219 ext/gd/libgd/gdft.c byte = *((unsigned char *) (str + 1)); str 221 ext/gd/libgd/gdft.c byte = *((unsigned char *) (str + 2)); str 224 ext/gd/libgd/gdft.c byte = *((unsigned char *) (str + i)); str 237 ext/gd/libgd/gdft.c byte = *((unsigned char *) (str + i)); str 254 ext/gd/libgd/gdft.c byte = *((unsigned char *) str); str 260 ext/gd/libgd/gdft.c ten = (str[1] & 0x7F) - 0x20; str 280 ext/gd/libgd/gdft.c if ((str[1] & 0xC0) == 0x80) { str 283 ext/gd/libgd/gdft.c *chPtr = (Tcl_UniChar) (((byte & 0x1F) << 6) | (str[1] & 0x3F)); str 294 ext/gd/libgd/gdft.c if (((str[1] & 0xC0) == 0x80) && ((str[2] & 0xC0) == 0x80)) { str 297 ext/gd/libgd/gdft.c *chPtr = (Tcl_UniChar) (((byte & 0x0F) << 12) | ((str[1] & 0x3F) << 6) | (str[2] & 0x3F)); str 315 ext/gd/libgd/gdft.c str++; str 316 ext/gd/libgd/gdft.c if ((*str & 0xC0) != 0x80) { str 321 ext/gd/libgd/gdft.c ch |= (*str & 0x3F); str 88 ext/gd/libgd/gdkanji.c DetectKanjiCode (unsigned char *str) str 106 ext/gd/libgd/gdkanji.c if ((c = str[i++]) != '\0') str 110 ext/gd/libgd/gdkanji.c c = str[i++]; str 113 ext/gd/libgd/gdkanji.c c = str[i++]; str 121 ext/gd/libgd/gdkanji.c c = str[i++]; str 132 ext/gd/libgd/gdkanji.c c = str[i++]; str 140 ext/gd/libgd/gdkanji.c c = str[i++]; str 157 ext/gd/libgd/gdkanji.c c = str[i++]; str 167 ext/gd/libgd/gdkanji.c c = str[i++]; str 605 ext/gd/libgd/gdkanji.c unsigned char *str; str 617 ext/gd/libgd/gdkanji.c str = output; str 618 ext/gd/libgd/gdkanji.c while (*str != '\0') str 619 ext/gd/libgd/gdkanji.c putchar (*(str++)); str 753 ext/gmp/gmp.c zend_string *str; str 760 ext/gmp/gmp.c str = zend_string_alloc(num_len, 0); str 761 ext/gmp/gmp.c mpz_get_str(ZSTR_VAL(str), base, gmpnum); str 771 ext/gmp/gmp.c if (ZSTR_VAL(str)[ZSTR_LEN(str) - 1] == '\0') { str 772 ext/gmp/gmp.c ZSTR_LEN(str)--; str 774 ext/gmp/gmp.c ZSTR_VAL(str)[ZSTR_LEN(str)] = '\0'; str 777 ext/gmp/gmp.c ZVAL_NEW_STR(result, str); str 597 ext/hash/hash.c zend_string *str; str 600 ext/hash/hash.c ZEND_HASH_FOREACH_STR_KEY(&php_hash_hashtable, str) { str 601 ext/hash/hash.c add_next_index_str(return_value, zend_string_copy(str)); str 1084 ext/hash/hash.c zend_string *str; str 1087 ext/hash/hash.c ZEND_HASH_FOREACH_STR_KEY(&php_hash_hashtable, str) { str 1088 ext/hash/hash.c s += slprintf(s, e - s, "%s ", ZSTR_VAL(str)); str 1110 ext/hash/hash.c ZEND_ARG_INFO(0, str) str 1122 ext/hash/hash.c ZEND_ARG_INFO(0, str) str 101 ext/hash/hash_tiger.c #define split_ex(str) \ str 102 ext/hash/hash_tiger.c x0=str[0]; x1=str[1]; x2=str[2]; x3=str[3]; \ str 103 ext/hash/hash_tiger.c x4=str[4]; x5=str[5]; x6=str[6]; x7=str[7]; str 105 ext/hash/hash_tiger.c # define split(str) \ str 111 ext/hash/hash_tiger.c ((unsigned char *) tmp)[i^7] = ((unsigned char *) str)[i]; \ str 119 ext/hash/hash_tiger.c #define tiger_compress(passes, str, state) \ str 129 ext/hash/hash_tiger.c split(str); \ str 67 ext/iconv/iconv.c ZEND_ARG_INFO(0, str) str 72 ext/iconv/iconv.c ZEND_ARG_INFO(0, str) str 112 ext/iconv/iconv.c ZEND_ARG_INFO(0, str) str 205 ext/iconv/iconv.c static php_iconv_err_t _php_iconv_strlen(size_t *pretval, const char *str, size_t nbytes, const char *enc); str 207 ext/iconv/iconv.c static php_iconv_err_t _php_iconv_substr(smart_str *pretval, const char *str, size_t nbytes, zend_long offset, zend_long len, const char *enc); str 213 ext/iconv/iconv.c static php_iconv_err_t _php_iconv_mime_decode(smart_str *pretval, const char *str, size_t str_nbytes, const char *enc, const char **next_pos, int mode); str 737 ext/iconv/iconv.c static php_iconv_err_t _php_iconv_strlen(size_t *pretval, const char *str, size_t nbytes, const char *enc) str 772 ext/iconv/iconv.c for (in_p = str, in_left = nbytes, cnt = 0; in_left > 0; cnt+=2) { str 822 ext/iconv/iconv.c const char *str, size_t nbytes, zend_long offset, zend_long len, const char *enc) str 839 ext/iconv/iconv.c err = _php_iconv_strlen(&total_len, str, nbytes, enc); str 893 ext/iconv/iconv.c for (in_p = str, in_left = nbytes, cnt = 0; in_left > 0 && len > 0; ++cnt) { str 1483 ext/iconv/iconv.c static php_iconv_err_t _php_iconv_mime_decode(smart_str *pretval, const char *str, size_t str_nbytes, const char *enc, const char **next_pos, int mode) str 1520 ext/iconv/iconv.c p1 = str; str 2054 ext/iconv/iconv.c zend_string *str; str 2061 ext/iconv/iconv.c &str, &charset, &charset_len) == FAILURE) { str 2070 ext/iconv/iconv.c err = _php_iconv_strlen(&retval, ZSTR_VAL(str), ZSTR_LEN(str), charset); str 2086 ext/iconv/iconv.c zend_string *str; str 2094 ext/iconv/iconv.c &str, &offset, &length, str 2105 ext/iconv/iconv.c length = ZSTR_LEN(str); str 2108 ext/iconv/iconv.c err = _php_iconv_substr(&retval, ZSTR_VAL(str), ZSTR_LEN(str), offset, length, charset); str 2111 ext/iconv/iconv.c if (err == PHP_ICONV_ERR_SUCCESS && ZSTR_LEN(str) > 0 && retval.s != NULL) { str 87 ext/imap/php_imap.c char *cpystr(const char *str); str 455 ext/imap/php_imap.c ZEND_ARG_INFO(0, str) str 2690 ext/imap/php_imap.c zend_string *str, *defaulthost; str 2695 ext/imap/php_imap.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "SS", &str, &defaulthost) == FAILURE) { str 2702 ext/imap/php_imap.c str_copy = estrndup(ZSTR_VAL(str), ZSTR_LEN(str)); str 2735 ext/imap/php_imap.c zend_string *str; str 2738 ext/imap/php_imap.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &str) == FAILURE) { str 2747 ext/imap/php_imap.c cpytxt(&src, ZSTR_VAL(str), ZSTR_LEN(str)); str 4258 ext/imap/php_imap.c zend_string *str; str 4263 ext/imap/php_imap.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &str) == FAILURE) { str 4269 ext/imap/php_imap.c string = ZSTR_VAL(str); str 4270 ext/imap/php_imap.c end = ZSTR_LEN(str); str 4387 ext/imap/php_imap.c static int _php_rfc822_len(char *str) str 4392 ext/imap/php_imap.c if (!str || !*str) { str 4399 ext/imap/php_imap.c len = strlen(str) + 2; str 4400 ext/imap/php_imap.c p = str; str 4905 ext/imap/php_imap.c PHP_IMAP_EXPORT void mm_notify(MAILSTREAM *stream, char *str, long errflg) str 4909 ext/imap/php_imap.c if (strncmp(str, "[ALERT] ", 8) == 0) { str 4912 ext/imap/php_imap.c IMAPG(imap_alertstack)->LSIZE = strlen((char*)(IMAPG(imap_alertstack)->LTEXT = (unsigned char*)cpystr(str))); str 4921 ext/imap/php_imap.c cur->LSIZE = strlen((char*)(cur->LTEXT = (unsigned char*)cpystr(str))); str 5037 ext/imap/php_imap.c PHP_IMAP_EXPORT void mm_log(char *str, long errflg) str 5045 ext/imap/php_imap.c IMAPG(imap_errorstack)->LSIZE = strlen((char*)(IMAPG(imap_errorstack)->LTEXT = (unsigned char*)cpystr(str))); str 5055 ext/imap/php_imap.c cur->LSIZE = strlen((char*)(cur->LTEXT = (unsigned char*)cpystr(str))); str 5062 ext/imap/php_imap.c PHP_IMAP_EXPORT void mm_dlog(char *str) str 5093 ext/imap/php_imap.c PHP_IMAP_EXPORT void mm_fatal(char *str) str 307 ext/intl/collator/collator_convert.c zval* collator_convert_string_to_number( zval* str, zval *rv ) str 309 ext/intl/collator/collator_convert.c zval* num = collator_convert_string_to_number_if_possible( str, rv ); str 310 ext/intl/collator/collator_convert.c if( num == str ) str 331 ext/intl/collator/collator_convert.c zval* collator_convert_string_to_double( zval* str, zval *rv ) str 333 ext/intl/collator/collator_convert.c zval* num = collator_convert_string_to_number( str, rv ); str 352 ext/intl/collator/collator_convert.c zval* collator_convert_string_to_number_if_possible( zval* str, zval *rv ) str 358 ext/intl/collator/collator_convert.c if( Z_TYPE_P( str ) != IS_STRING ) str 360 ext/intl/collator/collator_convert.c COLLATOR_CONVERT_RETURN_FAILED( str ); str 363 ext/intl/collator/collator_convert.c if( ( is_numeric = collator_is_numeric( (UChar*) Z_STRVAL_P(str), UCHARS( Z_STRLEN_P(str) ), &lval, &dval, 1 ) ) ) str 373 ext/intl/collator/collator_convert.c COLLATOR_CONVERT_RETURN_FAILED( str ); str 392 ext/intl/collator/collator_convert.c zval* str = NULL; str 401 ext/intl/collator/collator_convert.c str = collator_convert_zstr_utf8_to_utf16( &arg_copy, rv ); str 406 ext/intl/collator/collator_convert.c str = collator_convert_zstr_utf8_to_utf16( arg, rv ); str 414 ext/intl/collator/collator_convert.c return str; str 33 ext/intl/collator/collator_convert.h zval* collator_convert_string_to_number_if_possible( zval* str, zval *rv ); str 34 ext/intl/collator/collator_convert.h zval* collator_convert_string_to_double( zval* str, zval *rv ); str 225 ext/intl/collator/collator_is_numeric.c zend_uchar collator_is_numeric( UChar *str, int32_t length, zend_long *lval, double *dval, int allow_errors ) str 237 ext/intl/collator/collator_is_numeric.c if (length>=2 && str[0]=='0' && (str[1]=='x' || str[1]=='X')) { str 242 ext/intl/collator/collator_is_numeric.c local_lval = collator_u_strtol(str, &end_ptr_long, conv_base); str 244 ext/intl/collator/collator_is_numeric.c if (end_ptr_long == str+length) { /* integer string */ str 249 ext/intl/collator/collator_is_numeric.c } else if (end_ptr_long == str && *end_ptr_long != '\0' && *str != '.' && *str != '-') { /* ignore partial string matches */ str 261 ext/intl/collator/collator_is_numeric.c local_dval = collator_u_strtod(str, &end_ptr_double); str 262 ext/intl/collator/collator_is_numeric.c if (local_dval == 0 && end_ptr_double == str) { str 265 ext/intl/collator/collator_is_numeric.c if (end_ptr_double == str+length) { /* floating point string */ str 24 ext/intl/collator/collator_is_numeric.h zend_uchar collator_is_numeric( UChar *str, int32_t length, zend_long *lval, double *dval, int allow_errors ); str 547 ext/intl/collator/collator_sort.c char* str = NULL; str 558 ext/intl/collator/collator_sort.c &object, Collator_ce_ptr, &str, &str_len ) == FAILURE ) str 584 ext/intl/collator/collator_sort.c &ustr, &ustr_len, str, str_len, COLLATOR_ERROR_CODE_P( co ) ); str 743 ext/intl/converter/converter.c ZEND_ARG_INFO(0, str) str 749 ext/intl/converter/converter.c char *str; str 755 ext/intl/converter/converter.c &str, &str_len, &reverse) == FAILURE) { str 764 ext/intl/converter/converter.c str, str_len, str 776 ext/intl/converter/converter.c ZEND_ARG_INFO(0, str) str 783 ext/intl/converter/converter.c char *str, *src, *dest; str 789 ext/intl/converter/converter.c &str, &str_len, &dest, &dest_len, &src, &src_len, &options) == FAILURE) { str 819 ext/intl/converter/converter.c (ret = php_converter_do_convert(dest_cnv, src_cnv, str, str_len, NULL)) != NULL) { str 42 ext/intl/formatter/formatter_parse.c char* str = NULL; str 54 ext/intl/formatter/formatter_parse.c &object, NumberFormatter_ce_ptr, &str, &str_len, &type, &zposition ) == FAILURE ) str 66 ext/intl/formatter/formatter_parse.c intl_convert_utf8_to_utf16(&sstr, &sstr_len, str, str_len, &INTL_DATA_ERROR_CODE(nfo)); str 133 ext/intl/formatter/formatter_parse.c char *str; str 142 ext/intl/formatter/formatter_parse.c &object, NumberFormatter_ce_ptr, &str, &str_len, &zcurrency, &zposition ) == FAILURE ) str 154 ext/intl/formatter/formatter_parse.c intl_convert_utf8_to_utf16(&sstr, &sstr_len, str, str_len, &INTL_DATA_ERROR_CODE(nfo)); str 373 ext/intl/grapheme/grapheme_string.c char *str; str 388 ext/intl/grapheme/grapheme_string.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "sl|l!", &str, &str_len, &lstart, &length, &no_length) == FAILURE) { str 414 ext/intl/grapheme/grapheme_string.c if ( grapheme_ascii_check((unsigned char *)str, str_len) >= 0 ) { str 417 ext/intl/grapheme/grapheme_string.c grapheme_substr_ascii(str, str_len, start, (int32_t)length, &sub_str, &asub_str_len); str 430 ext/intl/grapheme/grapheme_string.c intl_convert_utf8_to_utf16(&ustr, &ustr_len, str, str_len, &status); str 785 ext/intl/grapheme/grapheme_string.c char *str, *pstr; str 799 ext/intl/grapheme/grapheme_string.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "sl|llz", &str, &str_len, &size, &extract_type, &lstart, &next) == FAILURE) { str 841 ext/intl/grapheme/grapheme_string.c pstr = str + start; str 845 ext/intl/grapheme/grapheme_string.c char *str_end = str + str_len; str 858 ext/intl/grapheme/grapheme_string.c str_len -= (pstr - str); str 52 ext/intl/grapheme/grapheme_util.c void grapheme_substr_ascii(char *str, size_t str_len, int32_t f, int32_t l, char **sub_str, int32_t *sub_str_len) str 105 ext/intl/grapheme/grapheme_util.c *sub_str = str + f; str 27 ext/intl/grapheme/grapheme_util.h void grapheme_substr_ascii(char *str, size_t str_len, int32_t f, int32_t l, char **sub_str, int32_t *sub_str_len); str 43 ext/intl/intl_common.h #define INTL_Z_STRVAL_P(str) (UChar*) Z_STRVAL_P(str) str 44 ext/intl/intl_common.h #define INTL_Z_STRLEN_P(str) UCHARS( Z_STRLEN_P(str) ) str 29 ext/intl/intl_convertcpp.h int intl_stringFromChar(UnicodeString &ret, char *str, size_t str_len, UErrorCode *status); str 148 ext/intl/locale/locale_methods.c static int getStrrtokenPos(char* str, int savedPos) str 154 ext/intl/locale/locale_methods.c if(isIDSeparator(*(str+i)) ){ str 156 ext/intl/locale/locale_methods.c if(i>=2 && isIDSeparator(*(str+i-2)) ){ str 178 ext/intl/locale/locale_methods.c static int getSingletonPos(const char* str) str 184 ext/intl/locale/locale_methods.c if( str && ((len=strlen(str))>0) ){ str 186 ext/intl/locale/locale_methods.c if( isIDSeparator(*(str+i)) ){ str 193 ext/intl/locale/locale_methods.c if( isIDSeparator(*(str+i+2)) ){ str 900 ext/intl/locale/locale_methods.c #define RETURN_SMART_STR(str) smart_str_0((str)); RETURN_NEW_STR((str)->s) str 1202 ext/intl/locale/locale_methods.c static int strToMatch(const char* str ,char *retstr) str 1208 ext/intl/locale/locale_methods.c if( (!str) || str[0] == '\0'){ str 1212 ext/intl/locale/locale_methods.c anchor1 = str; str 1213 ext/intl/locale/locale_methods.c while( (*str)!='\0' ){ str 1214 ext/intl/locale/locale_methods.c if( *str == '-' ){ str 1217 ext/intl/locale/locale_methods.c *retstr = tolower(*str); str 1219 ext/intl/locale/locale_methods.c str++; str 1224 ext/intl/locale/locale_methods.c str= anchor1; str 1507 ext/intl/locale/locale_methods.c char *str = canonicalize ? cur_arr[i*2] : cur_arr[i*2+1]; str 1508 ext/intl/locale/locale_methods.c return_value = zend_string_init(str, strlen(str), 0); str 297 ext/intl/transliterator/transliterator_methods.c char *str; str 318 ext/intl/transliterator/transliterator_methods.c &arg1, &str, &str_len, &start, &limit ) == FAILURE ) str 353 ext/intl/transliterator/transliterator_methods.c &str, &str_len, &start, &limit ) == FAILURE ) str 380 ext/intl/transliterator/transliterator_methods.c intl_convert_utf8_to_utf16( &ustr, &ustr_len, str, str_len, str 200 ext/json/json.c PHP_JSON_API void php_json_decode_ex(zval *return_value, char *str, size_t str_len, zend_long options, zend_long depth) /* {{{ */ str 204 ext/json/json.c php_json_parser_init(&parser, return_value, str, str_len, (int)options, (int)depth); str 246 ext/json/json.c char *str; str 252 ext/json/json.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|bll", &str, &str_len, &assoc, &depth, &options) == FAILURE) { str 270 ext/json/json.c php_json_decode_ex(return_value, str, str_len, options, depth); str 230 ext/json/json_parser.y void php_json_parser_init(php_json_parser *parser, zval *return_value, char *str, size_t str_len, int options, int max_depth) str 233 ext/json/json_parser.y php_json_scanner_init(&parser->scanner, str, str_len, options); str 85 ext/json/json_scanner.c void php_json_scanner_init(php_json_scanner *s, char *str, size_t str_len, int options) str 87 ext/json/json_scanner.c s->cursor = (php_json_ctype *) str; str 88 ext/json/json_scanner.c s->limit = (php_json_ctype *) str + str_len; str 626 ext/json/json_scanner.c zend_string *str; str 633 ext/json/json_scanner.c str = zend_string_alloc(len, 0); str 634 ext/json/json_scanner.c ZSTR_VAL(str)[len] = '\0'; str 635 ext/json/json_scanner.c ZVAL_STR(&s->value, str); str 96 ext/json/php_json.h PHP_JSON_API void php_json_decode_ex(zval *return_value, char *str, size_t str_len, zend_long options, zend_long depth); str 98 ext/json/php_json.h static inline void php_json_decode(zval *return_value, char *str, int str_len, zend_bool assoc, zend_long depth) str 100 ext/json/php_json.h php_json_decode_ex(return_value, str, str_len, assoc ? PHP_JSON_OBJECT_AS_ARRAY : 0, depth); str 32 ext/json/php_json_parser.h void php_json_parser_init(php_json_parser *parser, zval *return_value, char *str, size_t str_len, int options, int max_depth); str 43 ext/json/php_json_scanner.h void php_json_scanner_init(php_json_scanner *scanner, char *str, size_t str_len, int options); str 1602 ext/ldap/ldap.c static int _ldap_str_equal_to_const(const char *str, uint str_len, const char *cstr) str 1610 ext/ldap/ldap.c if (str[i] != cstr[i]) { str 1621 ext/ldap/ldap.c static int _ldap_strlen_max(const char *str, uint max_len) str 1626 ext/ldap/ldap.c if (str[i] == '\0') { str 38 ext/mbstring/libmbfl/tests/emoji.c char str[] = {0xF9,0xD6,0x00}; // U+00A9 str 44 ext/mbstring/libmbfl/tests/emoji.c char str[] = {0xF7,0x74,0x00}; // U+00A9 str 50 ext/mbstring/libmbfl/tests/emoji.c char str[] = {0xF7,0xEE,0x00}; // U+00A9 str 74 ext/mbstring/libmbfl/tests/emoji.c strcpy(dev.buffer, str); str 75 ext/mbstring/libmbfl/tests/emoji.c dev.pos += strlen(str); str 69 ext/mbstring/mb_gpc.c php_default_treat_data(arg, str, destArray); str 117 ext/mbstring/mb_gpc.c res = str; str 251 ext/mbstring/mbstring.c ZEND_ARG_INFO(0, str) str 318 ext/mbstring/mbstring.c ZEND_ARG_INFO(0, str) str 325 ext/mbstring/mbstring.c ZEND_ARG_INFO(0, str) str 332 ext/mbstring/mbstring.c ZEND_ARG_INFO(0, str) str 337 ext/mbstring/mbstring.c ZEND_ARG_INFO(0, str) str 345 ext/mbstring/mbstring.c ZEND_ARG_INFO(0, str) str 367 ext/mbstring/mbstring.c ZEND_ARG_INFO(0, str) str 380 ext/mbstring/mbstring.c ZEND_ARG_INFO(0, str) str 392 ext/mbstring/mbstring.c ZEND_ARG_INFO(0, str) str 993 ext/mbstring/mbstring.c static int _php_mb_match_regex(void *opaque, const char *str, size_t str_len); str 1019 ext/mbstring/mbstring.c static int _php_mb_match_regex(void *opaque, const char *str, size_t str_len) str 1021 ext/mbstring/mbstring.c return onig_search((php_mb_regex_t *)opaque, (const OnigUChar *)str, str 1022 ext/mbstring/mbstring.c (const OnigUChar*)str + str_len, (const OnigUChar *)str, str 1023 ext/mbstring/mbstring.c (const OnigUChar*)str + str_len, NULL, ONIG_OPTION_NONE) >= 0; str 1050 ext/mbstring/mbstring.c static int _php_mb_match_regex(void *opaque, const char *str, size_t str_len) str 1052 ext/mbstring/mbstring.c return pcre_exec((pcre *)opaque, NULL, str, (int)str_len, 0, str 1147 ext/mbstring/mbstring.c static char *php_mb_rfc1867_getword_conf(const zend_encoding *encoding, char *str) /* {{{ */ str 1149 ext/mbstring/mbstring.c while (*str && isspace(*(unsigned char *)str)) { str 1150 ext/mbstring/mbstring.c ++str; str 1153 ext/mbstring/mbstring.c if (!*str) { str 1157 ext/mbstring/mbstring.c if (*str == '"' || *str == '\'') { str 1158 ext/mbstring/mbstring.c char quote = *str; str 1160 ext/mbstring/mbstring.c str++; str 1161 ext/mbstring/mbstring.c return php_mb_rfc1867_substring_conf(encoding, str, strlen(str), quote); str 1163 ext/mbstring/mbstring.c char *strend = str; str 1168 ext/mbstring/mbstring.c return php_mb_rfc1867_substring_conf(encoding, str, strend - str, 0); str 2865 ext/mbstring/mbstring.c char *str, *encoding = NULL; str 2872 ext/mbstring/mbstring.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "sl|l!s", &str, &str_len, &from, &len, &len_is_null, &encoding, &encoding_len) == FAILURE) { str 2888 ext/mbstring/mbstring.c string.val = (unsigned char *)str; str 3055 ext/mbstring/mbstring.c char *str, *trimmarker = NULL, *encoding = NULL; str 3060 ext/mbstring/mbstring.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "sll|ss", &str, &str_len, &from, &width, &trimmarker, &trimmarker_len, &encoding, &encoding_len) == FAILURE) { str 3081 ext/mbstring/mbstring.c string.val = (unsigned char *)str; str 3269 ext/mbstring/mbstring.c char *str; str 3276 ext/mbstring/mbstring.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "sl|s!", &str, &str_len, str 3281 ext/mbstring/mbstring.c newstr = php_unicode_convert_case(case_mode, str, (size_t) str_len, &ret_len, from_encoding); str 3297 ext/mbstring/mbstring.c char *str; str 3302 ext/mbstring/mbstring.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s!", &str, &str_len, str 3306 ext/mbstring/mbstring.c newstr = php_unicode_convert_case(PHP_UNICODE_CASE_UPPER, str, (size_t) str_len, &ret_len, from_encoding); str 3324 ext/mbstring/mbstring.c char *str; str 3329 ext/mbstring/mbstring.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s!", &str, &str_len, str 3333 ext/mbstring/mbstring.c newstr = php_unicode_convert_case(PHP_UNICODE_CASE_LOWER, str, (size_t) str_len, &ret_len, from_encoding); str 3349 ext/mbstring/mbstring.c char *str; str 3359 ext/mbstring/mbstring.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|z!b", &str, &str_len, &encoding_list, &strict) == FAILURE) { str 3406 ext/mbstring/mbstring.c string.val = (unsigned char *)str; str 3913 ext/mbstring/mbstring.c char *str, *encoding = NULL; str 3922 ext/mbstring/mbstring.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "sz|sb", &str, &str_len, &zconvmap, &encoding, &encoding_len, &is_hex) == FAILURE) { str 3929 ext/mbstring/mbstring.c string.val = (unsigned char *)str; str 4001 ext/mbstring/mbstring.c #define SKIP_LONG_HEADER_SEP_MBSTRING(str, pos) \ str 4002 ext/mbstring/mbstring.c if (str[pos] == '\r' && str[pos + 1] == '\n' && (str[pos + 2] == ' ' || str[pos + 2] == '\t')) { \ str 4004 ext/mbstring/mbstring.c while (str[pos + 1] == ' ' || str[pos + 1] == '\t') { \ str 4010 ext/mbstring/mbstring.c #define MAIL_ASCIIZ_CHECK_MBSTRING(str, len) \ str 4011 ext/mbstring/mbstring.c pp = str; \ str 4017 ext/mbstring/mbstring.c static int _php_mbstr_parse_mail_headers(HashTable *ht, const char *str, size_t str_len) str 4027 ext/mbstring/mbstring.c ps = str; str 152 ext/mbstring/mbstring.h MBSTRING_API int php_mb_encoding_converter_ex(char **str, int *len, const char *encoding_to, str 155 ext/mbstring/oniguruma/onigposix.h ONIG_EXTERN int regexec P_((regex_t* reg, const char* str, size_t nmatch, regmatch_t* matches, int options)); str 741 ext/mbstring/oniguruma/oniguruma.h int onig_search P_((OnigRegex, const OnigUChar* str, const OnigUChar* end, const OnigUChar* start, const OnigUChar* range, OnigRegion* region, OnigOptionType option)); str 743 ext/mbstring/oniguruma/oniguruma.h int onig_match P_((OnigRegex, const OnigUChar* str, const OnigUChar* end, const OnigUChar* at, OnigRegion* region, OnigOptionType option)); str 488 ext/mbstring/oniguruma/regexec.c (((s) - str) * num_comb_exp_check + ((snum) - 1)) str 1021 ext/mbstring/oniguruma/regexec.c #define IS_EMPTY_STR (str == end) str 1022 ext/mbstring/oniguruma/regexec.c #define ON_STR_BEGIN(s) ((s) == str) str 1038 ext/mbstring/oniguruma/regexec.c OnigStackType* stk_top, UChar* str, regex_t* reg) str 1052 ext/mbstring/oniguruma/regexec.c child->beg = (int )(k->u.mem.pstr - str); str 1056 ext/mbstring/oniguruma/regexec.c r = make_capture_history_tree(child, kp, stk_top, str, reg); str 1060 ext/mbstring/oniguruma/regexec.c child->end = (int )(k->u.mem.pstr - str); str 1065 ext/mbstring/oniguruma/regexec.c node->end = (int )(k->u.mem.pstr - str); str 1238 ext/mbstring/oniguruma/regexec.c match_at(regex_t* reg, const UChar* str, const UChar* end, str 1285 ext/mbstring/oniguruma/regexec.c (int )str, (int )end, (int )sstart, (int )sprev); str 1287 ext/mbstring/oniguruma/regexec.c (int )(end - str), (int )(sstart - str)); str 1298 ext/mbstring/oniguruma/regexec.c fprintf(stderr, "%4d> \"", (int )(s - str)); str 1337 ext/mbstring/oniguruma/regexec.c rmt[0].rm_so = sstart - str; str 1338 ext/mbstring/oniguruma/regexec.c rmt[0].rm_eo = s - str; str 1342 ext/mbstring/oniguruma/regexec.c rmt[i].rm_so = STACK_AT(mem_start_stk[i])->u.mem.pstr - str; str 1344 ext/mbstring/oniguruma/regexec.c rmt[i].rm_so = (UChar* )((void* )(mem_start_stk[i])) - str; str 1348 ext/mbstring/oniguruma/regexec.c : (UChar* )((void* )mem_end_stk[i])) - str; str 1357 ext/mbstring/oniguruma/regexec.c region->beg[0] = sstart - str; str 1358 ext/mbstring/oniguruma/regexec.c region->end[0] = s - str; str 1362 ext/mbstring/oniguruma/regexec.c region->beg[i] = STACK_AT(mem_start_stk[i])->u.mem.pstr - str; str 1364 ext/mbstring/oniguruma/regexec.c region->beg[i] = (UChar* )((void* )mem_start_stk[i]) - str; str 1368 ext/mbstring/oniguruma/regexec.c : (UChar* )((void* )mem_end_stk[i])) - str; str 1390 ext/mbstring/oniguruma/regexec.c node->beg = sstart - str; str 1391 ext/mbstring/oniguruma/regexec.c node->end = s - str; str 1395 ext/mbstring/oniguruma/regexec.c stk, (UChar* )str, reg); str 2641 ext/mbstring/oniguruma/regexec.c s = (UChar* )ONIGENC_STEP_BACK(encode, str, s, (int )tlen); str 2643 ext/mbstring/oniguruma/regexec.c sprev = (UChar* )onigenc_get_prev_char_head(encode, str, s); str 2651 ext/mbstring/oniguruma/regexec.c q = (UChar* )ONIGENC_STEP_BACK(encode, str, s, (int )tlen); str 2661 ext/mbstring/oniguruma/regexec.c sprev = (UChar* )onigenc_get_prev_char_head(encode, str, s); str 3049 ext/mbstring/oniguruma/regexec.c onig_match(regex_t* reg, const UChar* str, const UChar* end, const UChar* at, OnigRegion* region, str 3084 ext/mbstring/oniguruma/regexec.c int offset = at - str; str 3085 ext/mbstring/oniguruma/regexec.c STATE_CHECK_BUFF_INIT(msa, end - str, offset, reg->num_comb_exp_check); str 3100 ext/mbstring/oniguruma/regexec.c prev = (UChar* )onigenc_get_prev_char_head(reg->enc, str, at); str 3101 ext/mbstring/oniguruma/regexec.c r = match_at(reg, str, end, str 3114 ext/mbstring/oniguruma/regexec.c forward_search_range(regex_t* reg, const UChar* str, const UChar* end, UChar* s, str 3121 ext/mbstring/oniguruma/regexec.c (int )str, (int )end, (int )s, (int )range); str 3173 ext/mbstring/oniguruma/regexec.c (pprev ? pprev : str), p); str 3183 ext/mbstring/oniguruma/regexec.c (pprev ? pprev : str), p); str 3205 ext/mbstring/oniguruma/regexec.c (pprev ? pprev : str), p); str 3221 ext/mbstring/oniguruma/regexec.c (pprev ? pprev : str), *low); str 3231 ext/mbstring/oniguruma/regexec.c (int )(*low - str), (int )(*high - str), reg->dmin, reg->dmax); str 3245 ext/mbstring/oniguruma/regexec.c backward_search_range(regex_t* reg, const UChar* str, const UChar* end, str 3295 ext/mbstring/oniguruma/regexec.c prev = onigenc_get_prev_char_head(reg->enc, str, p); str 3336 ext/mbstring/oniguruma/regexec.c (int )(*low - str), (int )(*high - str)); str 3350 ext/mbstring/oniguruma/regexec.c onig_search(regex_t* reg, const UChar* str, const UChar* end, str 3389 ext/mbstring/oniguruma/regexec.c (int )str, (int )(end - str), (int )(start - str), (int )(range - str)); str 3401 ext/mbstring/oniguruma/regexec.c if (start > end || start < str) goto mismatch_no_msa; str 3407 ext/mbstring/oniguruma/regexec.c r = match_at(reg, str, end, (upper_range), s, prev, &msa); \ str 3418 ext/mbstring/oniguruma/regexec.c r = match_at(reg, str, end, (upper_range), s, prev, &msa); \ str 3429 ext/mbstring/oniguruma/regexec.c r = match_at(reg, str, end, s, prev, &msa);\ str 3440 ext/mbstring/oniguruma/regexec.c r = match_at(reg, str, end, s, prev, &msa);\ str 3452 ext/mbstring/oniguruma/regexec.c if (reg->anchor != 0 && str < end) { str 3466 ext/mbstring/oniguruma/regexec.c if (start != str) goto mismatch_no_msa; str 3467 ext/mbstring/oniguruma/regexec.c range = str + 1; str 3470 ext/mbstring/oniguruma/regexec.c if (range <= str) { str 3471 ext/mbstring/oniguruma/regexec.c start = str; str 3472 ext/mbstring/oniguruma/regexec.c range = str; str 3482 ext/mbstring/oniguruma/regexec.c if ((OnigDistance )(max_semi_end - str) < reg->anchor_dmin) str 3489 ext/mbstring/oniguruma/regexec.c start = onigenc_get_right_adjust_char_head(reg->enc, str, start); str 3491 ext/mbstring/oniguruma/regexec.c start = onigenc_get_prev_char_head(reg->enc, str, end); str 3506 ext/mbstring/oniguruma/regexec.c start = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc, str, start); str 3512 ext/mbstring/oniguruma/regexec.c UChar* pre_end = ONIGENC_STEP_BACK(reg->enc, str, end, 1); str 3519 ext/mbstring/oniguruma/regexec.c pre_end = ONIGENC_STEP_BACK(reg->enc, str, pre_end, 1); str 3525 ext/mbstring/oniguruma/regexec.c if (min_semi_end > str && start <= min_semi_end) { str 3538 ext/mbstring/oniguruma/regexec.c else if (str == end) { /* empty string */ str 3546 ext/mbstring/oniguruma/regexec.c start = end = str = address_for_empty_string; str 3563 ext/mbstring/oniguruma/regexec.c (int )(end - str), (int )(start - str), (int )(range - str)); str 3569 ext/mbstring/oniguruma/regexec.c int offset = (MIN(start, range) - str); str 3570 ext/mbstring/oniguruma/regexec.c STATE_CHECK_BUFF_INIT(msa, end - str, offset, reg->num_comb_exp_check); str 3576 ext/mbstring/oniguruma/regexec.c if (s > str) str 3577 ext/mbstring/oniguruma/regexec.c prev = onigenc_get_prev_char_head(reg->enc, str, s); str 3599 ext/mbstring/oniguruma/regexec.c if (! forward_search_range(reg, str, end, s, sch_range, str 3614 ext/mbstring/oniguruma/regexec.c if (! forward_search_range(reg, str, end, s, sch_range, str 3653 ext/mbstring/oniguruma/regexec.c adjrange = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc, str, range); str 3662 ext/mbstring/oniguruma/regexec.c if (backward_search_range(reg, str, end, sch_start, range, adjrange, str 3670 ext/mbstring/oniguruma/regexec.c prev = onigenc_get_prev_char_head(reg->enc, str, s); str 3692 ext/mbstring/oniguruma/regexec.c if (backward_search_range(reg, str, end, sch_start, range, adjrange, str 3698 ext/mbstring/oniguruma/regexec.c prev = onigenc_get_prev_char_head(reg->enc, str, s); str 3748 ext/mbstring/oniguruma/regexec.c return s - str; str 64 ext/mbstring/oniguruma/reggnu.c re_match(regex_t* reg, const char* str, int size, int pos, str 67 ext/mbstring/oniguruma/reggnu.c return onig_match(reg, (UChar* )str, (UChar* )(str + size), str 68 ext/mbstring/oniguruma/reggnu.c (UChar* )(str + pos), regs, ONIG_OPTION_NONE); str 69 ext/mbstring/oniguruma/regparse.h #define NSTR(node) (&((node)->u.str)) str 99 ext/mbstring/oniguruma/regparse.h #define NSTRING_LEN(node) ((node)->u.str.end - (node)->u.str.s) str 100 ext/mbstring/oniguruma/regparse.h #define NSTRING_SET_RAW(node) (node)->u.str.flag |= NSTR_RAW str 101 ext/mbstring/oniguruma/regparse.h #define NSTRING_CLEAR_RAW(node) (node)->u.str.flag &= ~NSTR_RAW str 102 ext/mbstring/oniguruma/regparse.h #define NSTRING_SET_AMBIG(node) (node)->u.str.flag |= NSTR_AMBIG str 104 ext/mbstring/oniguruma/regparse.h (node)->u.str.flag |= NSTR_DONT_GET_OPT_INFO str 105 ext/mbstring/oniguruma/regparse.h #define NSTRING_IS_RAW(node) (((node)->u.str.flag & NSTR_RAW) != 0) str 106 ext/mbstring/oniguruma/regparse.h #define NSTRING_IS_AMBIG(node) (((node)->u.str.flag & NSTR_AMBIG) != 0) str 108 ext/mbstring/oniguruma/regparse.h (((node)->u.str.flag & NSTR_DONT_GET_OPT_INFO) != 0) str 256 ext/mbstring/oniguruma/regparse.h StrNode str; str 166 ext/mbstring/oniguruma/regposix.c regexec(regex_t* reg, const char* str, size_t nmatch, str 192 ext/mbstring/oniguruma/regposix.c ENC_STRING_LEN(ONIG_C(reg)->enc, str, len); str 193 ext/mbstring/oniguruma/regposix.c end = (UChar* )(str + len); str 194 ext/mbstring/oniguruma/regposix.c r = onig_search(ONIG_C(reg), (UChar* )str, end, (UChar* )str, end, str 34 ext/mbstring/oniguruma/testc.c static void xx(char* pattern, char* str, int from, int to, int mem, int not) str 51 ext/mbstring/oniguruma/testc.c r = regexec(®, str, reg.re_nsub + 1, pmatch, 0); str 61 ext/mbstring/oniguruma/testc.c fprintf(stdout, "OK(N): /%s/ '%s'\n", pattern, str); str 65 ext/mbstring/oniguruma/testc.c fprintf(stdout, "FAIL: /%s/ '%s'\n", pattern, str); str 71 ext/mbstring/oniguruma/testc.c fprintf(stdout, "FAIL(N): /%s/ '%s'\n", pattern, str); str 76 ext/mbstring/oniguruma/testc.c fprintf(stdout, "OK: /%s/ '%s'\n", pattern, str); str 80 ext/mbstring/oniguruma/testc.c fprintf(stdout, "FAIL: /%s/ '%s' %d-%d : %d-%d\n", pattern, str, str 102 ext/mbstring/oniguruma/testc.c r = onig_search(reg, (UChar* )str, (UChar* )(str + SLEN(str)), str 103 ext/mbstring/oniguruma/testc.c (UChar* )str, (UChar* )(str + SLEN(str)), str 115 ext/mbstring/oniguruma/testc.c fprintf(stdout, "OK(N): /%s/ '%s'\n", pattern, str); str 119 ext/mbstring/oniguruma/testc.c fprintf(stdout, "FAIL: /%s/ '%s'\n", pattern, str); str 125 ext/mbstring/oniguruma/testc.c fprintf(stdout, "FAIL(N): /%s/ '%s'\n", pattern, str); str 130 ext/mbstring/oniguruma/testc.c fprintf(stdout, "OK: /%s/ '%s'\n", pattern, str); str 134 ext/mbstring/oniguruma/testc.c fprintf(stdout, "FAIL: /%s/ '%s' %d-%d : %d-%d\n", pattern, str, str 144 ext/mbstring/oniguruma/testc.c static void x2(char* pattern, char* str, int from, int to) str 146 ext/mbstring/oniguruma/testc.c xx(pattern, str, from, to, 0, 0); str 149 ext/mbstring/oniguruma/testc.c static void x3(char* pattern, char* str, int from, int to, int mem) str 151 ext/mbstring/oniguruma/testc.c xx(pattern, str, from, to, mem, 0); str 154 ext/mbstring/oniguruma/testc.c static void n(char* pattern, char* str) str 156 ext/mbstring/oniguruma/testc.c xx(pattern, str, 0, 0, 0, 1); str 58 ext/mbstring/oniguruma/testu.c static void xx(char* pattern, char* str, int from, int to, int mem, int not) str 69 ext/mbstring/oniguruma/testu.c uconv(str, cstr, ulen(str)); str 79 ext/mbstring/oniguruma/testu.c r = regexec(®, str, reg.re_nsub + 1, pmatch, 0); str 122 ext/mbstring/oniguruma/testu.c uconv(str, cstr, ulen(str)); str 148 ext/mbstring/oniguruma/testu.c r = onig_search(reg, (UChar* )str, (UChar* )(str + ulen(str)), str 149 ext/mbstring/oniguruma/testu.c (UChar* )str, (UChar* )(str + ulen(str)), str 190 ext/mbstring/oniguruma/testu.c static void x2(char* pattern, char* str, int from, int to) str 192 ext/mbstring/oniguruma/testu.c xx(pattern, str, from, to, 0, 0); str 195 ext/mbstring/oniguruma/testu.c static void x3(char* pattern, char* str, int from, int to, int mem) str 197 ext/mbstring/oniguruma/testu.c xx(pattern, str, from, to, mem, 0); str 200 ext/mbstring/oniguruma/testu.c static void n(char* pattern, char* str) str 202 ext/mbstring/oniguruma/testu.c xx(pattern, str, 0, 0, 0, 1); str 34 ext/mbstring/oniguruma/win32/testc.c static void xx(char* pattern, char* str, int from, int to, int mem, int not) str 51 ext/mbstring/oniguruma/win32/testc.c r = regexec(®, str, reg.re_nsub + 1, pmatch, 0); str 61 ext/mbstring/oniguruma/win32/testc.c fprintf(stdout, "OK(N): /%s/ '%s'\n", pattern, str); str 65 ext/mbstring/oniguruma/win32/testc.c fprintf(stdout, "FAIL: /%s/ '%s'\n", pattern, str); str 71 ext/mbstring/oniguruma/win32/testc.c fprintf(stdout, "FAIL(N): /%s/ '%s'\n", pattern, str); str 76 ext/mbstring/oniguruma/win32/testc.c fprintf(stdout, "OK: /%s/ '%s'\n", pattern, str); str 80 ext/mbstring/oniguruma/win32/testc.c fprintf(stdout, "FAIL: /%s/ '%s' %d-%d : %d-%d\n", pattern, str, str 102 ext/mbstring/oniguruma/win32/testc.c r = onig_search(reg, (UChar* )str, (UChar* )(str + SLEN(str)), str 103 ext/mbstring/oniguruma/win32/testc.c (UChar* )str, (UChar* )(str + SLEN(str)), str 115 ext/mbstring/oniguruma/win32/testc.c fprintf(stdout, "OK(N): /%s/ '%s'\n", pattern, str); str 119 ext/mbstring/oniguruma/win32/testc.c fprintf(stdout, "FAIL: /%s/ '%s'\n", pattern, str); str 125 ext/mbstring/oniguruma/win32/testc.c fprintf(stdout, "FAIL(N): /%s/ '%s'\n", pattern, str); str 130 ext/mbstring/oniguruma/win32/testc.c fprintf(stdout, "OK: /%s/ '%s'\n", pattern, str); str 134 ext/mbstring/oniguruma/win32/testc.c fprintf(stdout, "FAIL: /%s/ '%s' %d-%d : %d-%d\n", pattern, str, str 144 ext/mbstring/oniguruma/win32/testc.c static void x2(char* pattern, char* str, int from, int to) str 146 ext/mbstring/oniguruma/win32/testc.c xx(pattern, str, from, to, 0, 0); str 149 ext/mbstring/oniguruma/win32/testc.c static void x3(char* pattern, char* str, int from, int to, int mem) str 151 ext/mbstring/oniguruma/win32/testc.c xx(pattern, str, from, to, mem, 0); str 154 ext/mbstring/oniguruma/win32/testc.c static void n(char* pattern, char* str) str 156 ext/mbstring/oniguruma/win32/testc.c xx(pattern, str, 0, 0, 0, 1); str 472 ext/mbstring/php_mbregex.c static size_t _php_mb_regex_get_option_string(char *str, size_t len, OnigOptionType option, OnigSyntaxType *syntax) str 476 ext/mbstring/php_mbregex.c char *p = str; str 696 ext/mbstring/php_mbregex.c char *str; str 738 ext/mbstring/php_mbregex.c str = string; str 748 ext/mbstring/php_mbregex.c add_index_stringl(array, i, (char *)&str[beg], end - beg); str 1184 ext/mbstring/php_mbregex.c OnigUChar *str; str 1206 ext/mbstring/php_mbregex.c str = NULL; str 1209 ext/mbstring/php_mbregex.c str = (OnigUChar *)Z_STRVAL(MBREX(search_str)); str 1218 ext/mbstring/php_mbregex.c if (str == NULL) { str 1228 ext/mbstring/php_mbregex.c err = onig_search(MBREX(search_re), str, str + len, str + pos, str + len, MBREX(search_regs), 0); str 1256 ext/mbstring/php_mbregex.c add_index_stringl(return_value, i, (char *)&str[beg], end - beg); str 1362 ext/mbstring/php_mbregex.c OnigUChar *str; str 1367 ext/mbstring/php_mbregex.c str = (OnigUChar *)Z_STRVAL(MBREX(search_str)); str 1374 ext/mbstring/php_mbregex.c add_index_stringl(return_value, i, (char *)&str[beg], end - beg); str 1133 ext/mcrypt/mcrypt.c char *str; str 1134 ext/mcrypt/mcrypt.c spprintf(&str, 0, "Only keys of size 1 to %d supported", max_key_size); str 1135 ext/mcrypt/mcrypt.c return str; str 1137 ext/mcrypt/mcrypt.c char *str; str 1138 ext/mcrypt/mcrypt.c spprintf(&str, 0, "Only keys of size %d supported", key_sizes[0]); str 1139 ext/mcrypt/mcrypt.c return str; str 1143 ext/mcrypt/mcrypt.c smart_str str = {0}; str 1144 ext/mcrypt/mcrypt.c smart_str_appends(&str, "Only keys of sizes "); str 1148 ext/mcrypt/mcrypt.c smart_str_appends(&str, " or "); str 1150 ext/mcrypt/mcrypt.c smart_str_appends(&str, ", "); str 1153 ext/mcrypt/mcrypt.c smart_str_append_long(&str, key_sizes[i]); str 1156 ext/mcrypt/mcrypt.c smart_str_appends(&str, " supported"); str 1157 ext/mcrypt/mcrypt.c smart_str_0(&str); str 1158 ext/mcrypt/mcrypt.c result = estrndup(ZSTR_VAL(str.s), ZSTR_LEN(str.s)); str 1159 ext/mcrypt/mcrypt.c smart_str_free(&str); str 41 ext/mysqli/mysqli_api.c static void mysqli_tx_cor_options_to_string(const MYSQL * const conn, smart_str * str, const uint32_t mode) str 44 ext/mysqli/mysqli_api.c if (str->s && ZSTR_LEN(str->s)) { str 45 ext/mysqli/mysqli_api.c smart_str_appendl(str, " ", sizeof(" ") - 1); str 47 ext/mysqli/mysqli_api.c smart_str_appendl(str, "AND CHAIN", sizeof("AND CHAIN") - 1); str 49 ext/mysqli/mysqli_api.c if (str->s && ZSTR_LEN(str->s)) { str 50 ext/mysqli/mysqli_api.c smart_str_appendl(str, " ", sizeof(" ") - 1); str 52 ext/mysqli/mysqli_api.c smart_str_appendl(str, "AND NO CHAIN", sizeof("AND NO CHAIN") - 1); str 56 ext/mysqli/mysqli_api.c if (str->s && ZSTR_LEN(str->s)) { str 57 ext/mysqli/mysqli_api.c smart_str_appendl(str, " ", sizeof(" ") - 1); str 59 ext/mysqli/mysqli_api.c smart_str_appendl(str, "RELEASE", sizeof("RELEASE") - 1); str 61 ext/mysqli/mysqli_api.c if (str->s && ZSTR_LEN(str->s)) { str 62 ext/mysqli/mysqli_api.c smart_str_appendl(str, " ", sizeof(" ") - 1); str 64 ext/mysqli/mysqli_api.c smart_str_appendl(str, "NO RELEASE", sizeof("NO RELEASE") - 1); str 66 ext/mysqli/mysqli_api.c smart_str_0(str); str 2682 ext/mysqlnd/mysqlnd.c MYSQLND_METHOD(mysqlnd_conn_data, tx_cor_options_to_string)(const MYSQLND_CONN_DATA * const conn, smart_str * str, const unsigned int mode) str 2685 ext/mysqlnd/mysqlnd.c if (str->s && ZSTR_LEN(str->s)) { str 2686 ext/mysqlnd/mysqlnd.c smart_str_appendl(str, " ", sizeof(" ") - 1); str 2688 ext/mysqlnd/mysqlnd.c smart_str_appendl(str, "AND CHAIN", sizeof("AND CHAIN") - 1); str 2690 ext/mysqlnd/mysqlnd.c if (str->s && ZSTR_LEN(str->s)) { str 2691 ext/mysqlnd/mysqlnd.c smart_str_appendl(str, " ", sizeof(" ") - 1); str 2693 ext/mysqlnd/mysqlnd.c smart_str_appendl(str, "AND NO CHAIN", sizeof("AND NO CHAIN") - 1); str 2697 ext/mysqlnd/mysqlnd.c if (str->s && ZSTR_LEN(str->s)) { str 2698 ext/mysqlnd/mysqlnd.c smart_str_appendl(str, " ", sizeof(" ") - 1); str 2700 ext/mysqlnd/mysqlnd.c smart_str_appendl(str, "RELEASE", sizeof("RELEASE") - 1); str 2702 ext/mysqlnd/mysqlnd.c if (str->s && ZSTR_LEN(str->s)) { str 2703 ext/mysqlnd/mysqlnd.c smart_str_appendl(str, " ", sizeof(" ") - 1); str 2705 ext/mysqlnd/mysqlnd.c smart_str_appendl(str, "NO RELEASE", sizeof("NO RELEASE") - 1); str 2707 ext/mysqlnd/mysqlnd.c smart_str_0(str); str 30 ext/mysqlnd/mysqlnd_priv.h #define MYSQLND_STR_W_LEN(str) str, (sizeof(str) - 1) str 537 ext/oci8/oci8_collection.c text *str; str 539 ext/oci8/oci8_collection.c PHP_OCI_CALL_RETURN(str, OCIStringPtr, (connection->env, oci_string)); str 541 ext/oci8/oci8_collection.c if (str) { str 542 ext/oci8/oci8_collection.c ZVAL_STRING(result_element, (char *)str); str 176 ext/opcache/Optimizer/pass1_5.c zend_string *str; str 201 ext/opcache/Optimizer/pass1_5.c str = zend_string_alloc(final_length, 0); str 202 ext/opcache/Optimizer/pass1_5.c str->len = final_length; str 203 ext/opcache/Optimizer/pass1_5.c ptr = str->val; str 208 ext/opcache/Optimizer/pass1_5.c ZVAL_NEW_STR(&ZEND_OP2_LITERAL(opline), str); str 216 ext/opcache/Optimizer/pass1_5.c ZVAL_NEW_STR(&ZEND_OP2_LITERAL(opline), str); str 113 ext/opcache/Optimizer/zend_optimizer.c static inline int zend_optimizer_add_literal_string(zend_op_array *op_array, zend_string *str) { str 115 ext/opcache/Optimizer/zend_optimizer.c ZVAL_STR(&zv, str); str 116 ext/opcache/Optimizer/zend_optimizer.c zend_string_hash_val(str); str 129 ext/opcache/Optimizer/zend_optimizer.c zend_string *str = zend_string_init(Z_STRVAL_P(val) + 1, Z_STRLEN_P(val) - 1, 0); str 131 ext/opcache/Optimizer/zend_optimizer.c ZVAL_STR(val, str); str 322 ext/opcache/ZendAccelerator.c static zend_string *(*orig_new_interned_string)(zend_string *str); str 330 ext/opcache/ZendAccelerator.c static zend_string *accel_new_interned_string_for_php(zend_string *str) str 332 ext/opcache/ZendAccelerator.c return str; str 380 ext/opcache/ZendAccelerator.c static zend_string *accel_find_interned_string(zend_string *str) str 388 ext/opcache/ZendAccelerator.c if (IS_ACCEL_INTERNED(str)) { str 390 ext/opcache/ZendAccelerator.c return str; str 394 ext/opcache/ZendAccelerator.c return str; str 399 ext/opcache/ZendAccelerator.c h = zend_string_hash_val(str); str 407 ext/opcache/ZendAccelerator.c if ((p->h == h) && (ZSTR_LEN(p->key) == ZSTR_LEN(str))) { str 408 ext/opcache/ZendAccelerator.c if (!memcmp(ZSTR_VAL(p->key), ZSTR_VAL(str), ZSTR_LEN(str))) { str 419 ext/opcache/ZendAccelerator.c zend_string *accel_new_interned_string(zend_string *str) str 430 ext/opcache/ZendAccelerator.c return str; str 434 ext/opcache/ZendAccelerator.c if (IS_ACCEL_INTERNED(str)) { str 436 ext/opcache/ZendAccelerator.c return str; str 439 ext/opcache/ZendAccelerator.c h = zend_string_hash_val(str); str 446 ext/opcache/ZendAccelerator.c if ((p->h == h) && (ZSTR_LEN(p->key) == ZSTR_LEN(str))) { str 447 ext/opcache/ZendAccelerator.c if (!memcmp(ZSTR_VAL(p->key), ZSTR_VAL(str), ZSTR_LEN(str))) { str 448 ext/opcache/ZendAccelerator.c zend_string_release(str); str 455 ext/opcache/ZendAccelerator.c if (ZCSG(interned_strings_top) + ZEND_MM_ALIGNED_SIZE(_ZSTR_STRUCT_SIZE(ZSTR_LEN(str))) >= str 459 ext/opcache/ZendAccelerator.c return str; str 468 ext/opcache/ZendAccelerator.c ZCSG(interned_strings_top) += ZEND_MM_ALIGNED_SIZE(_ZSTR_STRUCT_SIZE(ZSTR_LEN(str))); str 478 ext/opcache/ZendAccelerator.c ZSTR_H(p->key) = ZSTR_H(str); str 479 ext/opcache/ZendAccelerator.c ZSTR_LEN(p->key) = ZSTR_LEN(str); str 480 ext/opcache/ZendAccelerator.c memcpy(ZSTR_VAL(p->key), ZSTR_VAL(str), ZSTR_LEN(str)); str 484 ext/opcache/ZendAccelerator.c zend_string_release(str); str 487 ext/opcache/ZendAccelerator.c return str; str 967 ext/opcache/ZendAccelerator.c zend_string *str = accel_find_interned_string(cwd_str); str 968 ext/opcache/ZendAccelerator.c if (!str) { str 971 ext/opcache/ZendAccelerator.c str = accel_new_interned_string(zend_string_copy(cwd_str)); str 972 ext/opcache/ZendAccelerator.c if (str == cwd_str) { str 973 ext/opcache/ZendAccelerator.c zend_string_release(str); str 974 ext/opcache/ZendAccelerator.c str = NULL; str 979 ext/opcache/ZendAccelerator.c if (str) { str 981 ext/opcache/ZendAccelerator.c char *res = zend_print_long_to_buf(buf + sizeof(buf) - 1, ZSTR_VAL(str) - ZCSG(interned_strings_start)); str 1007 ext/opcache/ZendAccelerator.c zend_string *str = accel_find_interned_string(ZCG(include_path)); str 1008 ext/opcache/ZendAccelerator.c if (!str) { str 1011 ext/opcache/ZendAccelerator.c str = accel_new_interned_string(zend_string_copy(ZCG(include_path))); str 1012 ext/opcache/ZendAccelerator.c if (str == ZCG(include_path)) { str 1013 ext/opcache/ZendAccelerator.c str = NULL; str 1018 ext/opcache/ZendAccelerator.c if (str) { str 1020 ext/opcache/ZendAccelerator.c char *res = zend_print_long_to_buf(buf + sizeof(buf) - 1, ZSTR_VAL(str) - ZCSG(interned_strings_start)); str 340 ext/opcache/ZendAccelerator.h #define IS_ACCEL_INTERNED(str) \ str 341 ext/opcache/ZendAccelerator.h ((char*)(str) >= ZCSG(interned_strings_start) && (char*)(str) < ZCSG(interned_strings_end)) str 343 ext/opcache/ZendAccelerator.h zend_string *accel_new_interned_string(zend_string *str); str 548 ext/opcache/zend_accelerator_module.c char *str; str 560 ext/opcache/zend_accelerator_module.c str = asctime(ta); str 561 ext/opcache/zend_accelerator_module.c len = strlen(str); str 562 ext/opcache/zend_accelerator_module.c if (len > 0 && str[len - 1] == '\n') len--; str 563 ext/opcache/zend_accelerator_module.c add_assoc_stringl(&persistent_script_report, "last_used", str, len); str 34 ext/opcache/zend_accelerator_util_funcs.h void zend_accel_move_user_functions(HashTable *str, HashTable *dst); str 195 ext/opcache/zend_file_cache.c static void *zend_file_cache_serialize_interned(zend_string *str, str 202 ext/opcache/zend_file_cache.c ret = zend_shared_alloc_get_xlat_entry(str); str 207 ext/opcache/zend_file_cache.c len = ZEND_MM_ALIGNED_SIZE(_ZSTR_STRUCT_SIZE(ZSTR_LEN(str))); str 209 ext/opcache/zend_file_cache.c zend_shared_alloc_register_xlat_entry(str, ret); str 217 ext/opcache/zend_file_cache.c memcpy(ZSTR_VAL((zend_string*)ZCG(mem)) + info->str_size, str, len); str 222 ext/opcache/zend_file_cache.c static void *zend_file_cache_unserialize_interned(zend_string *str, int in_shm) str 226 ext/opcache/zend_file_cache.c str = (zend_string*)((char*)ZCG(mem) + ((size_t)(str) & ~Z_UL(1))); str 228 ext/opcache/zend_file_cache.c ret = accel_new_interned_string(str); str 229 ext/opcache/zend_file_cache.c if (ret == str) { str 234 ext/opcache/zend_file_cache.c ret = str; str 36 ext/opcache/zend_persist.c #define zend_accel_store_string(str) do { \ str 37 ext/opcache/zend_persist.c zend_string *new_str = zend_shared_alloc_get_xlat_entry(str); \ str 39 ext/opcache/zend_persist.c zend_string_release(str); \ str 40 ext/opcache/zend_persist.c str = new_str; \ str 42 ext/opcache/zend_persist.c new_str = zend_accel_memdup((void*)str, _ZSTR_STRUCT_SIZE(ZSTR_LEN(str))); \ str 43 ext/opcache/zend_persist.c zend_string_release(str); \ str 44 ext/opcache/zend_persist.c str = new_str; \ str 45 ext/opcache/zend_persist.c zend_string_hash_val(str); \ str 46 ext/opcache/zend_persist.c GC_FLAGS(str) = IS_STR_INTERNED | IS_STR_PERMANENT; \ str 49 ext/opcache/zend_persist.c #define zend_accel_memdup_string(str) do { \ str 50 ext/opcache/zend_persist.c str = zend_accel_memdup(str, _ZSTR_STRUCT_SIZE(ZSTR_LEN(str))); \ str 51 ext/opcache/zend_persist.c zend_string_hash_val(str); \ str 52 ext/opcache/zend_persist.c GC_FLAGS(str) = IS_STR_INTERNED | IS_STR_PERMANENT; \ str 54 ext/opcache/zend_persist.c #define zend_accel_store_interned_string(str) do { \ str 55 ext/opcache/zend_persist.c if (!IS_ACCEL_INTERNED(str)) { \ str 56 ext/opcache/zend_persist.c zend_accel_store_string(str); \ str 59 ext/opcache/zend_persist.c #define zend_accel_memdup_interned_string(str) do { \ str 60 ext/opcache/zend_persist.c if (!IS_ACCEL_INTERNED(str)) { \ str 61 ext/opcache/zend_persist.c zend_accel_memdup_string(str); \ str 34 ext/opcache/zend_persist_calc.c # define ADD_STRING(str) ADD_DUP_SIZE((str), _ZSTR_STRUCT_SIZE(ZSTR_LEN(str))) str 36 ext/opcache/zend_persist_calc.c # define ADD_INTERNED_STRING(str, do_free) do { \ str 38 ext/opcache/zend_persist_calc.c ADD_STRING(str); \ str 39 ext/opcache/zend_persist_calc.c } else if (!IS_ACCEL_INTERNED(str)) { \ str 40 ext/opcache/zend_persist_calc.c zend_string *tmp = accel_new_interned_string(str); \ str 41 ext/opcache/zend_persist_calc.c if (tmp != (str)) { \ str 45 ext/opcache/zend_persist_calc.c (str) = tmp; \ str 47 ext/opcache/zend_persist_calc.c ADD_STRING(str); \ str 660 ext/openssl/openssl.c ASN1_STRING * str = NULL; str 684 ext/openssl/openssl.c str = X509_NAME_ENTRY_get_data(ne); str 685 ext/openssl/openssl.c if (ASN1_STRING_type(str) != V_ASN1_UTF8STRING) { str 686 ext/openssl/openssl.c to_add_len = ASN1_STRING_to_UTF8(&to_add, str); str 688 ext/openssl/openssl.c to_add = ASN1_STRING_data(str); str 689 ext/openssl/openssl.c to_add_len = ASN1_STRING_length(str); str 713 ext/openssl/openssl.c static void add_assoc_asn1_string(zval * val, char * key, ASN1_STRING * str) /* {{{ */ str 715 ext/openssl/openssl.c add_assoc_stringl(val, key, (char *)str->data, str->length); str 834 ext/openssl/openssl.c char * str; str 839 ext/openssl/openssl.c str = CONF_get_string(req->req_config, NULL, "oid_section"); str 840 ext/openssl/openssl.c if (str == NULL) { str 843 ext/openssl/openssl.c sktmp = CONF_get_section(req->req_config, str); str 845 ext/openssl/openssl.c php_error_docref(NULL, E_WARNING, "problem loading oid section %s", str); str 901 ext/openssl/openssl.c char * str; str 914 ext/openssl/openssl.c str = CONF_get_string(req->req_config, NULL, "oid_file"); str 915 ext/openssl/openssl.c if (str && !php_openssl_open_base_dir_chk(str)) { str 916 ext/openssl/openssl.c BIO *oid_bio = BIO_new_file(str, "r"); str 939 ext/openssl/openssl.c str = CONF_get_string(req->req_config, req->section_name, "encrypt_rsa_key"); str 940 ext/openssl/openssl.c if (str == NULL) { str 941 ext/openssl/openssl.c str = CONF_get_string(req->req_config, req->section_name, "encrypt_key"); str 943 ext/openssl/openssl.c if (str && strcmp(str, "no") == 0) { str 980 ext/openssl/openssl.c str = CONF_get_string(req->req_config, req->section_name, "string_mask"); str 981 ext/openssl/openssl.c if (str && !ASN1_STRING_set_default_mask_asc(str)) { str 982 ext/openssl/openssl.c php_error_docref(NULL, E_WARNING, "Invalid global string mask setting %s", str); str 2664 ext/openssl/openssl.c char * str, *dn_sect, *attr_sect; str 2743 ext/openssl/openssl.c for (str = type; *str; str++) { str 2744 ext/openssl/openssl.c if (*str == ':' || *str == ',' || *str == '.') { str 2745 ext/openssl/openssl.c str++; str 2746 ext/openssl/openssl.c if (*str) { str 2747 ext/openssl/openssl.c type = str; str 3548 ext/openssl/openssl.c zend_string *str = zend_string_alloc(len, 0); \ str 3549 ext/openssl/openssl.c BN_bn2bin(pkey->pkey._type->_name, (unsigned char*)ZSTR_VAL(str)); \ str 3550 ext/openssl/openssl.c ZSTR_VAL(str)[len] = 0; \ str 3551 ext/openssl/openssl.c add_assoc_str(&_type, #_name, str); \ str 97 ext/openssl/xp_ssl.c #define GET_VER_OPT_STRING(name, str) if (GET_VER_OPT(name)) { convert_to_string_ex(val); str = Z_STRVAL_P(val); } str 2695 ext/pcre/pcrelib/pcre_internal.h #define STRLEN_UC(str) strlen((const char *)str) str 2707 ext/pcre/pcrelib/pcre_internal.h extern unsigned int PRIV(strlen_uc)(const pcre_uchar *str); str 2717 ext/pcre/pcrelib/pcre_internal.h #define STRLEN_UC(str) PRIV(strlen_uc)(str) str 163 ext/pcre/pcrelib/pcre_jit_compile.c const pcre_uchar *str; str 3896 ext/pcre/pcrelib/pcre_jit_compile.c OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str)); str 3926 ext/pcre/pcrelib/pcre_jit_compile.c OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str)); str 5310 ext/pcre/pcrelib/pcre_jit_compile.c OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str)); str 8184 ext/pcre/pcrelib/pcre_jit_compile.c OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str)); str 10031 ext/pcre/pcrelib/pcre_jit_compile.c OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str)); str 10212 ext/pcre/pcrelib/pcre_jit_compile.c OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str)); str 10433 ext/pcre/pcrelib/pcre_jit_compile.c arguments.str = subject + start_offset; str 10526 ext/pcre/pcrelib/pcre_jit_compile.c arguments.str = subject_ptr + start_offset; str 520 ext/pcre/php_pcre.c zend_string *str = zend_string_init(ZSTR_VAL(regex), ZSTR_LEN(regex), 1); str 521 ext/pcre/php_pcre.c GC_REFCOUNT(str) = 0; /* will be incremented by zend_hash_update_mem() */ str 522 ext/pcre/php_pcre.c ZSTR_H(str) = ZSTR_H(regex); str 523 ext/pcre/php_pcre.c regex = str; str 570 ext/pcre/php_pcre.c static inline void add_offset_pair(zval *result, char *str, int len, int offset, char *name) str 577 ext/pcre/php_pcre.c ZVAL_STRINGL(&tmp, str, len); str 974 ext/pcre/php_pcre.c static int preg_get_backref(char **str, int *backref) str 977 ext/pcre/php_pcre.c register char *walk = *str; str 1006 ext/pcre/php_pcre.c *str = walk; str 2168 ext/pcre/php_pcre.c ZEND_ARG_INFO(0, str) str 1133 ext/pdo/pdo_dbh.c char *str; str 1139 ext/pdo/pdo_dbh.c if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "s|l", &str, &str_len, ¶mtype)) { str 1150 ext/pdo/pdo_dbh.c if (dbh->methods->quoter(dbh, str, str_len, &qstr, &qlen, paramtype)) { str 507 ext/pdo_firebird/firebird_driver.c zend_string *str = zval_get_string(val); str 511 ext/pdo_firebird/firebird_driver.c spprintf(&H->date_format, 0, "%s", ZSTR_VAL(str)); str 512 ext/pdo_firebird/firebird_driver.c zend_string_release(str); str 518 ext/pdo_firebird/firebird_driver.c zend_string *str = zval_get_string(val); str 522 ext/pdo_firebird/firebird_driver.c spprintf(&H->time_format, 0, "%s", ZSTR_VAL(str)); str 523 ext/pdo_firebird/firebird_driver.c zend_string_release(str); str 529 ext/pdo_firebird/firebird_driver.c zend_string *str = zval_get_string(val); str 533 ext/pdo_firebird/firebird_driver.c spprintf(&H->timestamp_format, 0, "%s", ZSTR_VAL(str)); str 534 ext/pdo_firebird/firebird_driver.c zend_string_release(str); str 830 ext/pdo_mysql/mysql_statement.c char *str; str 865 ext/pdo_mysql/mysql_statement.c str = type_to_name_native(F->type); str 866 ext/pdo_mysql/mysql_statement.c if (str) { str 867 ext/pdo_mysql/mysql_statement.c add_assoc_string(return_value, "native_type", str); str 66 ext/pdo_pgsql/pgsql_driver.c static zend_string* _pdo_pgsql_escape_credentials(char *str) str 68 ext/pdo_pgsql/pgsql_driver.c if (str) { str 69 ext/pdo_pgsql/pgsql_driver.c zend_string *tmp = zend_string_init(str, strlen(str), 0); str 335 ext/pdo_pgsql/pgsql_statement.c zend_string *str = php_stream_copy_to_mem(stm, PHP_STREAM_COPY_ALL, 0); str 336 ext/pdo_pgsql/pgsql_statement.c if (str != NULL) { str 338 ext/pdo_pgsql/pgsql_statement.c ZVAL_STR(parameter, str); str 441 ext/pdo_pgsql/pgsql_statement.c char *str; str 447 ext/pdo_pgsql/pgsql_statement.c str = PQfname(S->result, colno); str 448 ext/pdo_pgsql/pgsql_statement.c cols[colno].name = zend_string_init(str, strlen(str), 0); str 237 ext/pdo_sqlite/sqlite_statement.c const char *str; str 245 ext/pdo_sqlite/sqlite_statement.c str = sqlite3_column_name(S->stmt, colno); str 246 ext/pdo_sqlite/sqlite_statement.c stmt->columns[colno].name = zend_string_init(str, strlen(str), 0); str 296 ext/pdo_sqlite/sqlite_statement.c const char *str; str 331 ext/pdo_sqlite/sqlite_statement.c str = sqlite3_column_decltype(S->stmt, colno); str 332 ext/pdo_sqlite/sqlite_statement.c if (str) { str 333 ext/pdo_sqlite/sqlite_statement.c add_assoc_string(return_value, "sqlite:decl_type", (char *)str); str 337 ext/pdo_sqlite/sqlite_statement.c str = sqlite3_column_table_name(S->stmt, colno); str 338 ext/pdo_sqlite/sqlite_statement.c if (str) { str 339 ext/pdo_sqlite/sqlite_statement.c add_assoc_string(return_value, "table", (char *)str); str 794 ext/pgsql/pgsql.c #define PGSQLescapeLiteral(conn, str, len) PQescapeLiteral(conn, str, len) str 795 ext/pgsql/pgsql.c #define PGSQLescapeIdentifier(conn, str, len) PQescapeIdentifier(conn, str, len) str 798 ext/pgsql/pgsql.c #define PGSQLescapeLiteral(conn, str, len) php_pgsql_PQescapeInternal(conn, str, len, 1, 0) str 799 ext/pgsql/pgsql.c #define PGSQLescapeLiteral2(conn, str, len) php_pgsql_PQescapeInternal(conn, str, len, 1, 1) str 800 ext/pgsql/pgsql.c #define PGSQLescapeIdentifier(conn, str, len) php_pgsql_PQescapeInternal(conn, str, len, 0, 0) str 804 ext/pgsql/pgsql.c static char *php_pgsql_PQescapeInternal(PGconn *conn, const char *str, size_t len, int escape_literal, int safe) /* {{{ */ str 824 ext/pgsql/pgsql.c new_len = PQescapeStringConn(conn, tmp, str, len, NULL); str 845 ext/pgsql/pgsql.c tmp_len = strspn(str, "\\"); str 852 ext/pgsql/pgsql.c for (s = (char *)str; s - str < len; ++s) { str 865 ext/pgsql/pgsql.c for (s = (char *)str; s - str < len; ++s) { str 1277 ext/pgsql/pgsql.c smart_str str = {0}; str 1290 ext/pgsql/pgsql.c smart_str_appends(&str, "pgsql"); str 1300 ext/pgsql/pgsql.c smart_str_append_long(&str, Z_LVAL(args[1]) ^ PGSQL_CONNECT_FORCE_NEW); str 1304 ext/pgsql/pgsql.c smart_str_appendc(&str, '_'); str 1305 ext/pgsql/pgsql.c smart_str_appendl(&str, Z_STRVAL(args[i]), Z_STRLEN(args[i])); str 1308 ext/pgsql/pgsql.c smart_str_0(&str); str 1336 ext/pgsql/pgsql.c if ((le = zend_hash_find_ptr(&EG(persistent_list), str.s)) == NULL) { /* we don't */ str 1367 ext/pgsql/pgsql.c if (zend_hash_str_update_mem(&EG(persistent_list), ZSTR_VAL(str.s), ZSTR_LEN(str.s), &new_le, sizeof(zend_resource)) == NULL) { str 1397 ext/pgsql/pgsql.c zend_hash_del(&EG(persistent_list), str.s); str 1421 ext/pgsql/pgsql.c && (index_ptr = zend_hash_find_ptr(&EG(regular_list), str.s)) != NULL) { str 1435 ext/pgsql/pgsql.c zend_hash_del(&EG(regular_list), str.s); str 1479 ext/pgsql/pgsql.c if (zend_hash_update_mem(&EG(regular_list), str.s, (void *) &new_index_ptr, sizeof(zend_resource)) == NULL) { str 1491 ext/pgsql/pgsql.c smart_str_free(&str); str 1495 ext/pgsql/pgsql.c smart_str_free(&str); str 2338 ext/pgsql/pgsql.c smart_str str = {0}; str 2343 ext/pgsql/pgsql.c smart_str_appends(&str, "pgsql_oid_"); str 2344 ext/pgsql/pgsql.c smart_str_append_unsigned(&str, oid); str 2345 ext/pgsql/pgsql.c smart_str_0(&str); str 2347 ext/pgsql/pgsql.c if ((field_type = zend_hash_find_ptr(list, str.s)) != NULL) { str 2359 ext/pgsql/pgsql.c smart_str_free(&str); str 2371 ext/pgsql/pgsql.c smart_str_free(&str); str 2372 ext/pgsql/pgsql.c smart_str_appends(&str, "pgsql_oid_"); str 2373 ext/pgsql/pgsql.c smart_str_appends(&str, tmp_oid); str 2374 ext/pgsql/pgsql.c smart_str_0(&str); str 2381 ext/pgsql/pgsql.c zend_hash_update_mem(list, str.s, (void *) &new_oid_entry, sizeof(zend_resource)); str 2389 ext/pgsql/pgsql.c smart_str_free(&str); str 3524 ext/pgsql/pgsql.c char *str; str 3531 ext/pgsql/pgsql.c if (zend_parse_parameters(argc, "rs|l", &pgsql_id, &str, &str_len, &z_len) == FAILURE) { str 3554 ext/pgsql/pgsql.c if ((nbytes = lo_write((PGconn *)pgsql->conn, pgsql->lofd, str, len)) == -1) { str 5719 ext/pgsql/pgsql.c static int php_pgsql_convert_match(const char *str, size_t str_len, const char *regex , int icase) str 5729 ext/pgsql/pgsql.c if (str[i] == '\n' || str 5730 ext/pgsql/pgsql.c str[i] == '\r' || str 5731 ext/pgsql/pgsql.c str[i] == '\0' ) { str 5745 ext/pgsql/pgsql.c res = pcre_exec(re, NULL, str, str_len, 0, 0, NULL, 0); str 5764 ext/pgsql/pgsql.c smart_str str = {0}; str 5769 ext/pgsql/pgsql.c smart_str_appendc(&str, 'E'); str 5770 ext/pgsql/pgsql.c smart_str_appendc(&str, '\''); str 5771 ext/pgsql/pgsql.c smart_str_appendl(&str, Z_STRVAL_P(src), Z_STRLEN_P(src)); str 5772 ext/pgsql/pgsql.c smart_str_appendc(&str, '\''); str 5773 ext/pgsql/pgsql.c smart_str_0(&str); str 5778 ext/pgsql/pgsql.c ZVAL_NEW_STR(src, str.s); str 6046 ext/pgsql/pgsql.c zend_string *str; str 6048 ext/pgsql/pgsql.c str = zend_string_alloc(Z_STRLEN_P(val) * 2, 0); str 6050 ext/pgsql/pgsql.c ZSTR_LEN(str) = PQescapeStringConn(pg_link, ZSTR_VAL(str), Z_STRVAL_P(val), Z_STRLEN_P(val), NULL); str 6051 ext/pgsql/pgsql.c str = zend_string_truncate(str, ZSTR_LEN(str), 0); str 6052 ext/pgsql/pgsql.c ZVAL_NEW_STR(&new_val, str); str 87 ext/phar/phar_object.c zend_string *str = strpprintf(4096, "phar://%s%s", fname, entry); str 90 ext/phar/phar_object.c ZVAL_NEW_STR(stuff, str); str 134 ext/phar/phar_object.c zend_string *str = strpprintf(4096, "phar://%s%s", fname, entry); str 137 ext/phar/phar_object.c ZVAL_NEW_STR(stuff, str); str 4798 ext/phar/phar_object.c zend_string *str; str 4832 ext/phar/phar_object.c str = php_stream_copy_to_mem(fp, link->uncompressed_filesize, 0); str 4833 ext/phar/phar_object.c if (str) { str 4834 ext/phar/phar_object.c RETURN_STR(str); str 1023 ext/phar/tar.c zend_string *str = php_stream_copy_to_mem(stubfile, len, 0); str 1024 ext/phar/tar.c if (str) { str 1025 ext/phar/tar.c len = ZSTR_LEN(str); str 1026 ext/phar/tar.c user_stub = estrndup(ZSTR_VAL(str), ZSTR_LEN(str)); str 1027 ext/phar/tar.c zend_string_release(str); str 1400 ext/phar/util.c zend_string *str; str 1406 ext/phar/util.c str = php_stream_copy_to_mem(fp, (size_t) end, 0); str 1407 ext/phar/util.c if (str) { str 1408 ext/phar/util.c ZVAL_STR(&zp[0], str); str 587 ext/phar/zip.c zend_string *str = php_stream_copy_to_mem(fp, entry.uncompressed_filesize, 0); str 588 ext/phar/zip.c if (str) { str 589 ext/phar/zip.c entry.uncompressed_filesize = ZSTR_LEN(str); str 590 ext/phar/zip.c actual_alias = estrndup(ZSTR_VAL(str), ZSTR_LEN(str)); str 591 ext/phar/zip.c zend_string_release(str); str 619 ext/phar/zip.c zend_string *str = php_stream_copy_to_mem(fp, entry.uncompressed_filesize, 0); str 620 ext/phar/zip.c if (str) { str 621 ext/phar/zip.c entry.uncompressed_filesize = ZSTR_LEN(str); str 622 ext/phar/zip.c actual_alias = estrndup(ZSTR_VAL(str), ZSTR_LEN(str)); str 623 ext/phar/zip.c zend_string_release(str); str 641 ext/phar/zip.c zend_string *str = php_stream_copy_to_mem(fp, entry.uncompressed_filesize, 0); str 642 ext/phar/zip.c if (str) { str 643 ext/phar/zip.c entry.uncompressed_filesize = ZSTR_LEN(str); str 644 ext/phar/zip.c actual_alias = estrndup(ZSTR_VAL(str), ZSTR_LEN(str)); str 645 ext/phar/zip.c zend_string_release(str); str 1275 ext/phar/zip.c zend_string *str = php_stream_copy_to_mem(stubfile, len, 0); str 1276 ext/phar/zip.c if (str) { str 1277 ext/phar/zip.c len = ZSTR_LEN(str); str 1278 ext/phar/zip.c user_stub = estrndup(ZSTR_VAL(str), ZSTR_LEN(str)); str 1279 ext/phar/zip.c zend_string_release(str); str 466 ext/readline/readline.c static void _readline_string_zval(zval *ret, const char *str) str 468 ext/readline/readline.c if (str) { str 469 ext/readline/readline.c ZVAL_STRING(ret, (char*)str); str 85 ext/readline/readline_cli.c static size_t readline_shell_write(const char *str, size_t str_length) /* {{{ */ str 88 ext/readline/readline_cli.c smart_str_appendl(CLIR_G(prompt_str), str, str_length); str 96 ext/readline/readline_cli.c return fwrite(str, 1, MIN(str_length, 16384), pager_pipe); str 103 ext/readline/readline_cli.c static size_t readline_shell_ub_write(const char *str, size_t str_length) /* {{{ */ str 108 ext/readline/readline_cli.c php_last_char = str[str_length-1]; str 72 ext/recode/recode.c ZEND_ARG_INFO(0, str) str 150 ext/recode/recode.c char *req, *str; str 152 ext/recode/recode.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss", &req, &req_len, &str, &str_len) == FAILURE) { str 168 ext/recode/recode.c recode_buffer_to_buffer(request, str, str_len, &r, &r_len, &r_alen); str 126 ext/reflection/php_reflection.c static void string_init(string *str) str 128 ext/reflection/php_reflection.c str->buf= zend_string_alloc(1024, 0); str 129 ext/reflection/php_reflection.c str->alloced = 1024; str 130 ext/reflection/php_reflection.c ZSTR_VAL(str->buf)[0] = '\0'; str 131 ext/reflection/php_reflection.c ZSTR_LEN(str->buf) = 0; str 134 ext/reflection/php_reflection.c static string *string_printf(string *str, const char *format, ...) str 143 ext/reflection/php_reflection.c register size_t nlen = (ZSTR_LEN(str->buf) + 1 + len + (1024 - 1)) & ~(1024 - 1); str 144 ext/reflection/php_reflection.c if (str->alloced < nlen) { str 145 ext/reflection/php_reflection.c size_t old_len = ZSTR_LEN(str->buf); str 146 ext/reflection/php_reflection.c str->alloced = nlen; str 147 ext/reflection/php_reflection.c str->buf = zend_string_extend(str->buf, str->alloced, 0); str 148 ext/reflection/php_reflection.c ZSTR_LEN(str->buf) = old_len; str 150 ext/reflection/php_reflection.c memcpy(ZSTR_VAL(str->buf) + ZSTR_LEN(str->buf), s_tmp, len + 1); str 151 ext/reflection/php_reflection.c ZSTR_LEN(str->buf) += len; str 155 ext/reflection/php_reflection.c return str; str 158 ext/reflection/php_reflection.c static string *string_write(string *str, char *buf, size_t len) str 160 ext/reflection/php_reflection.c register size_t nlen = (ZSTR_LEN(str->buf) + 1 + len + (1024 - 1)) & ~(1024 - 1); str 161 ext/reflection/php_reflection.c if (str->alloced < nlen) { str 162 ext/reflection/php_reflection.c size_t old_len = ZSTR_LEN(str->buf); str 163 ext/reflection/php_reflection.c str->alloced = nlen; str 164 ext/reflection/php_reflection.c str->buf = zend_string_extend(str->buf, str->alloced, 0); str 165 ext/reflection/php_reflection.c ZSTR_LEN(str->buf) = old_len; str 167 ext/reflection/php_reflection.c memcpy(ZSTR_VAL(str->buf) + ZSTR_LEN(str->buf), buf, len); str 168 ext/reflection/php_reflection.c ZSTR_LEN(str->buf) += len; str 169 ext/reflection/php_reflection.c ZSTR_VAL(str->buf)[ZSTR_LEN(str->buf)] = '\0'; str 170 ext/reflection/php_reflection.c return str; str 173 ext/reflection/php_reflection.c static string *string_append(string *str, string *append) str 176 ext/reflection/php_reflection.c string_write(str, ZSTR_VAL(append->buf), ZSTR_LEN(append->buf)); str 178 ext/reflection/php_reflection.c return str; str 181 ext/reflection/php_reflection.c static void string_free(string *str) str 183 ext/reflection/php_reflection.c zend_string_release(str->buf); str 184 ext/reflection/php_reflection.c str->alloced = 0; str 185 ext/reflection/php_reflection.c str->buf = NULL; str 368 ext/reflection/php_reflection.c static void _const_string(string *str, char *name, zval *value, char *indent); str 369 ext/reflection/php_reflection.c static void _function_string(string *str, zend_function *fptr, zend_class_entry *scope, char* indent); str 370 ext/reflection/php_reflection.c static void _property_string(string *str, zend_property_info *prop, char *prop_name, char* indent); str 371 ext/reflection/php_reflection.c static void _class_string(string *str, zend_class_entry *ce, zval *obj, char *indent); str 372 ext/reflection/php_reflection.c static void _extension_string(string *str, zend_module_entry *module, char *indent); str 373 ext/reflection/php_reflection.c static void _zend_extension_string(string *str, zend_extension *extension, char *indent); str 376 ext/reflection/php_reflection.c static void _class_string(string *str, zend_class_entry *ce, zval *obj, char *indent) str 386 ext/reflection/php_reflection.c string_printf(str, "%s%s", indent, ZSTR_VAL(ce->info.user.doc_comment)); str 387 ext/reflection/php_reflection.c string_write(str, "\n", 1); str 391 ext/reflection/php_reflection.c string_printf(str, "%sObject of class [ ", indent); str 399 ext/reflection/php_reflection.c string_printf(str, "%s%s [ ", indent, kind); str 401 ext/reflection/php_reflection.c string_printf(str, (ce->type == ZEND_USER_CLASS) ? "<user" : "<internal"); str 403 ext/reflection/php_reflection.c string_printf(str, ":%s", ce->info.internal.module->name); str 405 ext/reflection/php_reflection.c string_printf(str, "> "); str 407 ext/reflection/php_reflection.c string_printf(str, "<iterateable> "); str 410 ext/reflection/php_reflection.c string_printf(str, "interface "); str 412 ext/reflection/php_reflection.c string_printf(str, "trait "); str 415 ext/reflection/php_reflection.c string_printf(str, "abstract "); str 418 ext/reflection/php_reflection.c string_printf(str, "final "); str 420 ext/reflection/php_reflection.c string_printf(str, "class "); str 422 ext/reflection/php_reflection.c string_printf(str, "%s", ZSTR_VAL(ce->name)); str 424 ext/reflection/php_reflection.c string_printf(str, " extends %s", ZSTR_VAL(ce->parent->name)); str 431 ext/reflection/php_reflection.c string_printf(str, " extends %s", ZSTR_VAL(ce->interfaces[0]->name)); str 433 ext/reflection/php_reflection.c string_printf(str, " implements %s", ZSTR_VAL(ce->interfaces[0]->name)); str 436 ext/reflection/php_reflection.c string_printf(str, ", %s", ZSTR_VAL(ce->interfaces[i]->name)); str 439 ext/reflection/php_reflection.c string_printf(str, " ] {\n"); str 443 ext/reflection/php_reflection.c string_printf(str, "%s @@ %s %d-%d\n", indent, ZSTR_VAL(ce->info.user.filename), str 448 ext/reflection/php_reflection.c string_printf(str, "\n"); str 450 ext/reflection/php_reflection.c string_printf(str, "%s - Constants [%d] {\n", indent, count); str 457 ext/reflection/php_reflection.c _const_string(str, ZSTR_VAL(key), value, indent); str 460 ext/reflection/php_reflection.c string_printf(str, "%s }\n", indent); str 478 ext/reflection/php_reflection.c string_printf(str, "\n%s - Static properties [%d] {\n", indent, count_static_props); str 484 ext/reflection/php_reflection.c _property_string(str, prop, NULL, ZSTR_VAL(sub_indent.buf)); str 488 ext/reflection/php_reflection.c string_printf(str, "%s }\n", indent); str 506 ext/reflection/php_reflection.c string_printf(str, "\n%s - Static methods [%d] {", indent, count_static_funcs); str 514 ext/reflection/php_reflection.c string_printf(str, "\n"); str 515 ext/reflection/php_reflection.c _function_string(str, mptr, ce, ZSTR_VAL(sub_indent.buf)); str 519 ext/reflection/php_reflection.c string_printf(str, "\n"); str 521 ext/reflection/php_reflection.c string_printf(str, "%s }\n", indent); str 525 ext/reflection/php_reflection.c string_printf(str, "\n%s - Properties [%d] {\n", indent, count); str 531 ext/reflection/php_reflection.c _property_string(str, prop, NULL, ZSTR_VAL(sub_indent.buf)); str 535 ext/reflection/php_reflection.c string_printf(str, "%s }\n", indent); str 556 ext/reflection/php_reflection.c string_printf(str, "\n%s - Dynamic properties [%d] {\n", indent, count); str 557 ext/reflection/php_reflection.c string_append(str, &dyn); str 558 ext/reflection/php_reflection.c string_printf(str, "%s }\n", indent); str 601 ext/reflection/php_reflection.c string_printf(str, "\n%s - Methods [%d] {", indent, count); str 603 ext/reflection/php_reflection.c string_printf(str, "\n"); str 605 ext/reflection/php_reflection.c string_append(str, &dyn); str 608 ext/reflection/php_reflection.c string_printf(str, "\n%s - Methods [0] {\n", indent); str 610 ext/reflection/php_reflection.c string_printf(str, "%s }\n", indent); str 612 ext/reflection/php_reflection.c string_printf(str, "%s}\n", indent); str 618 ext/reflection/php_reflection.c static void _const_string(string *str, char *name, zval *value, char *indent) str 623 ext/reflection/php_reflection.c string_printf(str, "%s Constant [ %s %s ] { %s }\n", str 650 ext/reflection/php_reflection.c static void _parameter_string(string *str, zend_function *fptr, struct _zend_arg_info *arg_info, uint32_t offset, uint32_t required, char* indent) str 652 ext/reflection/php_reflection.c string_printf(str, "Parameter #%d [ ", offset); str 654 ext/reflection/php_reflection.c string_printf(str, "<optional> "); str 656 ext/reflection/php_reflection.c string_printf(str, "<required> "); str 659 ext/reflection/php_reflection.c string_printf(str, "%s ", str 665 ext/reflection/php_reflection.c string_printf(str, "or NULL "); str 668 ext/reflection/php_reflection.c string_printf(str, "%s ", zend_get_type_by_const(arg_info->type_hint)); str 670 ext/reflection/php_reflection.c string_printf(str, "or NULL "); str 674 ext/reflection/php_reflection.c string_write(str, "&", sizeof("&")-1); str 677 ext/reflection/php_reflection.c string_write(str, "...", sizeof("...")-1); str 680 ext/reflection/php_reflection.c string_printf(str, "$%s", str 686 ext/reflection/php_reflection.c string_printf(str, "$param%d", offset); str 694 ext/reflection/php_reflection.c string_write(str, " = ", sizeof(" = ")-1); str 701 ext/reflection/php_reflection.c string_write(str, "true", sizeof("true")-1); str 703 ext/reflection/php_reflection.c string_write(str, "false", sizeof("false")-1); str 705 ext/reflection/php_reflection.c string_write(str, "NULL", sizeof("NULL")-1); str 707 ext/reflection/php_reflection.c string_write(str, "'", sizeof("'")-1); str 708 ext/reflection/php_reflection.c string_write(str, Z_STRVAL(zv), MIN(Z_STRLEN(zv), 15)); str 710 ext/reflection/php_reflection.c string_write(str, "...", sizeof("...")-1); str 712 ext/reflection/php_reflection.c string_write(str, "'", sizeof("'")-1); str 714 ext/reflection/php_reflection.c string_write(str, "Array", sizeof("Array")-1); str 717 ext/reflection/php_reflection.c string_write(str, ZSTR_VAL(zv_str), ZSTR_LEN(zv_str)); str 723 ext/reflection/php_reflection.c string_write(str, " ]", sizeof(" ]")-1); str 728 ext/reflection/php_reflection.c static void _function_parameter_string(string *str, zend_function *fptr, char* indent) str 741 ext/reflection/php_reflection.c string_printf(str, "\n"); str 742 ext/reflection/php_reflection.c string_printf(str, "%s- Parameters [%d] {\n", indent, num_args); str 744 ext/reflection/php_reflection.c string_printf(str, "%s ", indent); str 745 ext/reflection/php_reflection.c _parameter_string(str, fptr, arg_info, i, required, indent); str 746 ext/reflection/php_reflection.c string_write(str, "\n", sizeof("\n")-1); str 749 ext/reflection/php_reflection.c string_printf(str, "%s}\n", indent); str 754 ext/reflection/php_reflection.c static void _function_closure_string(string *str, zend_function *fptr, char* indent) str 771 ext/reflection/php_reflection.c string_printf(str, "\n"); str 772 ext/reflection/php_reflection.c string_printf(str, "%s- Bound Variables [%d] {\n", indent, zend_hash_num_elements(static_variables)); str 775 ext/reflection/php_reflection.c string_printf(str, "%s Variable #%d [ $%s ]\n", indent, i++, ZSTR_VAL(key)); str 777 ext/reflection/php_reflection.c string_printf(str, "%s}\n", indent); str 782 ext/reflection/php_reflection.c static void _function_string(string *str, zend_function *fptr, zend_class_entry *scope, char* indent) str 794 ext/reflection/php_reflection.c string_printf(str, "%s%s\n", indent, ZSTR_VAL(fptr->op_array.doc_comment)); str 797 ext/reflection/php_reflection.c string_write(str, indent, strlen(indent)); str 798 ext/reflection/php_reflection.c string_printf(str, fptr->common.fn_flags & ZEND_ACC_CLOSURE ? "Closure [ " : (fptr->common.scope ? "Method [ " : "Function [ ")); str 799 ext/reflection/php_reflection.c string_printf(str, (fptr->type == ZEND_USER_FUNCTION) ? "<user" : "<internal"); str 801 ext/reflection/php_reflection.c string_printf(str, ", deprecated"); str 804 ext/reflection/php_reflection.c string_printf(str, ":%s", ((zend_internal_function*)fptr)->module->name); str 809 ext/reflection/php_reflection.c string_printf(str, ", inherits %s", ZSTR_VAL(fptr->common.scope->name)); str 816 ext/reflection/php_reflection.c string_printf(str, ", overwrites %s", ZSTR_VAL(overwrites->common.scope->name)); str 823 ext/reflection/php_reflection.c string_printf(str, ", prototype %s", ZSTR_VAL(fptr->common.prototype->common.scope->name)); str 826 ext/reflection/php_reflection.c string_printf(str, ", ctor"); str 829 ext/reflection/php_reflection.c string_printf(str, ", dtor"); str 831 ext/reflection/php_reflection.c string_printf(str, "> "); str 834 ext/reflection/php_reflection.c string_printf(str, "abstract "); str 837 ext/reflection/php_reflection.c string_printf(str, "final "); str 840 ext/reflection/php_reflection.c string_printf(str, "static "); str 847 ext/reflection/php_reflection.c string_printf(str, "public "); str 850 ext/reflection/php_reflection.c string_printf(str, "private "); str 853 ext/reflection/php_reflection.c string_printf(str, "protected "); str 856 ext/reflection/php_reflection.c string_printf(str, "<visibility error> "); str 859 ext/reflection/php_reflection.c string_printf(str, "method "); str 861 ext/reflection/php_reflection.c string_printf(str, "function "); str 865 ext/reflection/php_reflection.c string_printf(str, "&"); str 867 ext/reflection/php_reflection.c string_printf(str, "%s ] {\n", ZSTR_VAL(fptr->common.function_name)); str 870 ext/reflection/php_reflection.c string_printf(str, "%s @@ %s %d - %d\n", indent, str 878 ext/reflection/php_reflection.c _function_closure_string(str, fptr, ZSTR_VAL(param_indent.buf)); str 880 ext/reflection/php_reflection.c _function_parameter_string(str, fptr, ZSTR_VAL(param_indent.buf)); str 883 ext/reflection/php_reflection.c string_printf(str, " %s- Return [ ", indent); str 885 ext/reflection/php_reflection.c string_printf(str, "%s ", str 891 ext/reflection/php_reflection.c string_printf(str, "or NULL "); str 894 ext/reflection/php_reflection.c string_printf(str, "%s ", zend_get_type_by_const(fptr->common.arg_info[-1].type_hint)); str 896 ext/reflection/php_reflection.c string_printf(str, "or NULL "); str 899 ext/reflection/php_reflection.c string_printf(str, "]\n"); str 901 ext/reflection/php_reflection.c string_printf(str, "%s}\n", indent); str 906 ext/reflection/php_reflection.c static void _property_string(string *str, zend_property_info *prop, char *prop_name, char* indent) str 910 ext/reflection/php_reflection.c string_printf(str, "%sProperty [ ", indent); str 912 ext/reflection/php_reflection.c string_printf(str, "<dynamic> public $%s", prop_name); str 916 ext/reflection/php_reflection.c string_write(str, "<implicit> ", sizeof("<implicit> ") - 1); str 918 ext/reflection/php_reflection.c string_write(str, "<default> ", sizeof("<default> ") - 1); str 925 ext/reflection/php_reflection.c string_printf(str, "public "); str 928 ext/reflection/php_reflection.c string_printf(str, "private "); str 931 ext/reflection/php_reflection.c string_printf(str, "protected "); str 935 ext/reflection/php_reflection.c string_printf(str, "static "); str 939 ext/reflection/php_reflection.c string_printf(str, "$%s", prop_name); str 942 ext/reflection/php_reflection.c string_printf(str, " ]\n"); str 949 ext/reflection/php_reflection.c string *str = va_arg(args, string *); str 955 ext/reflection/php_reflection.c string_printf(str, " %sEntry [ %s <", indent, ZSTR_VAL(ini_entry->name)); str 957 ext/reflection/php_reflection.c string_printf(str, "ALL"); str 960 ext/reflection/php_reflection.c string_printf(str, "USER"); str 964 ext/reflection/php_reflection.c string_printf(str, "%sPERDIR", comma); str 968 ext/reflection/php_reflection.c string_printf(str, "%sSYSTEM", comma); str 972 ext/reflection/php_reflection.c string_printf(str, "> ]\n"); str 973 ext/reflection/php_reflection.c string_printf(str, " %s Current = '%s'\n", indent, ini_entry->value ? ZSTR_VAL(ini_entry->value) : ""); str 975 ext/reflection/php_reflection.c string_printf(str, " %s Default = '%s'\n", indent, ini_entry->orig_value ? ZSTR_VAL(ini_entry->orig_value) : ""); str 977 ext/reflection/php_reflection.c string_printf(str, " %s}\n", indent); str 986 ext/reflection/php_reflection.c string *str = va_arg(args, string *); str 994 ext/reflection/php_reflection.c string_printf(str, "\n"); str 995 ext/reflection/php_reflection.c _class_string(str, ce, NULL, indent); str 1006 ext/reflection/php_reflection.c string *str = va_arg(args, string *); str 1012 ext/reflection/php_reflection.c _const_string(str, ZSTR_VAL(constant->name), &constant->value, indent); str 1019 ext/reflection/php_reflection.c static void _extension_string(string *str, zend_module_entry *module, char *indent) /* {{{ */ str 1021 ext/reflection/php_reflection.c string_printf(str, "%sExtension [ ", indent); str 1023 ext/reflection/php_reflection.c string_printf(str, "<persistent>"); str 1026 ext/reflection/php_reflection.c string_printf(str, "<temporary>" ); str 1028 ext/reflection/php_reflection.c string_printf(str, " extension #%d %s version %s ] {\n", str 1035 ext/reflection/php_reflection.c string_printf(str, "\n - Dependencies {\n"); str 1038 ext/reflection/php_reflection.c string_printf(str, "%s Dependency [ %s (", indent, dep->name); str 1042 ext/reflection/php_reflection.c string_write(str, "Required", sizeof("Required") - 1); str 1045 ext/reflection/php_reflection.c string_write(str, "Conflicts", sizeof("Conflicts") - 1); str 1048 ext/reflection/php_reflection.c string_write(str, "Optional", sizeof("Optional") - 1); str 1051 ext/reflection/php_reflection.c string_write(str, "Error", sizeof("Error") - 1); /* shouldn't happen */ str 1056 ext/reflection/php_reflection.c string_printf(str, " %s", dep->rel); str 1059 ext/reflection/php_reflection.c string_printf(str, " %s", dep->version); str 1061 ext/reflection/php_reflection.c string_write(str, ") ]\n", sizeof(") ]\n") - 1); str 1064 ext/reflection/php_reflection.c string_printf(str, "%s }\n", indent); str 1072 ext/reflection/php_reflection.c string_printf(str, "\n - INI {\n"); str 1073 ext/reflection/php_reflection.c string_append(str, &str_ini); str 1074 ext/reflection/php_reflection.c string_printf(str, "%s }\n", indent); str 1086 ext/reflection/php_reflection.c string_printf(str, "\n - Constants [%d] {\n", num_constants); str 1087 ext/reflection/php_reflection.c string_append(str, &str_constants); str 1088 ext/reflection/php_reflection.c string_printf(str, "%s }\n", indent); str 1101 ext/reflection/php_reflection.c string_printf(str, "\n - Functions {\n"); str 1104 ext/reflection/php_reflection.c _function_string(str, fptr, NULL, " "); str 1108 ext/reflection/php_reflection.c string_printf(str, "%s }\n", indent); str 1122 ext/reflection/php_reflection.c string_printf(str, "\n - Classes [%d] {", num_classes); str 1123 ext/reflection/php_reflection.c string_append(str, &str_classes); str 1124 ext/reflection/php_reflection.c string_printf(str, "%s }\n", indent); str 1130 ext/reflection/php_reflection.c string_printf(str, "%s}\n", indent); str 1134 ext/reflection/php_reflection.c static void _zend_extension_string(string *str, zend_extension *extension, char *indent) /* {{{ */ str 1136 ext/reflection/php_reflection.c string_printf(str, "%sZend Extension [ %s ", indent, extension->name); str 1139 ext/reflection/php_reflection.c string_printf(str, "%s ", extension->version); str 1142 ext/reflection/php_reflection.c string_printf(str, "%s ", extension->copyright); str 1145 ext/reflection/php_reflection.c string_printf(str, "by %s ", extension->author); str 1148 ext/reflection/php_reflection.c string_printf(str, "<%s> ", extension->URL); str 1151 ext/reflection/php_reflection.c string_printf(str, "]\n"); str 1662 ext/reflection/php_reflection.c string str; str 1668 ext/reflection/php_reflection.c string_init(&str); str 1669 ext/reflection/php_reflection.c _function_string(&str, fptr, intern->ce, ""); str 1670 ext/reflection/php_reflection.c RETURN_NEW_STR(str.buf); str 2522 ext/reflection/php_reflection.c string str; str 2528 ext/reflection/php_reflection.c string_init(&str); str 2529 ext/reflection/php_reflection.c _parameter_string(&str, param->fptr, param->arg_info, param->offset, param->required, ""); str 2530 ext/reflection/php_reflection.c RETURN_NEW_STR(str.buf); str 3106 ext/reflection/php_reflection.c string str; str 3112 ext/reflection/php_reflection.c string_init(&str); str 3113 ext/reflection/php_reflection.c _function_string(&str, mptr, intern->ce, ""); str 3114 ext/reflection/php_reflection.c RETURN_NEW_STR(str.buf); str 3874 ext/reflection/php_reflection.c string str; str 3880 ext/reflection/php_reflection.c string_init(&str); str 3881 ext/reflection/php_reflection.c _class_string(&str, ce, &intern->obj, ""); str 3882 ext/reflection/php_reflection.c RETURN_NEW_STR(str.buf); str 5256 ext/reflection/php_reflection.c string str; str 5262 ext/reflection/php_reflection.c string_init(&str); str 5263 ext/reflection/php_reflection.c _property_string(&str, &ref->prop, NULL, ""); str 5264 ext/reflection/php_reflection.c RETURN_NEW_STR(str.buf); str 5578 ext/reflection/php_reflection.c string str; str 5584 ext/reflection/php_reflection.c string_init(&str); str 5585 ext/reflection/php_reflection.c _extension_string(&str, module, ""); str 5586 ext/reflection/php_reflection.c RETURN_NEW_STR(str.buf); str 5941 ext/reflection/php_reflection.c string str; str 5947 ext/reflection/php_reflection.c string_init(&str); str 5948 ext/reflection/php_reflection.c _zend_extension_string(&str, extension, ""); str 5949 ext/reflection/php_reflection.c RETURN_NEW_STR(str.buf); str 2236 ext/session/session.c zend_string *str = NULL; str 2243 ext/session/session.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &str) == FAILURE) { str 2247 ext/session/session.c if (php_session_decode(str) == FAILURE) { str 237 ext/soap/php_encoding.c void whiteSpace_replace(xmlChar* str) str 239 ext/soap/php_encoding.c while (*str != '\0') { str 240 ext/soap/php_encoding.c if (*str == '\x9' || *str == '\xA' || *str == '\xD') { str 241 ext/soap/php_encoding.c *str = ' '; str 243 ext/soap/php_encoding.c str++; str 247 ext/soap/php_encoding.c void whiteSpace_collapse(xmlChar* str) str 252 ext/soap/php_encoding.c pos = str; str 253 ext/soap/php_encoding.c whiteSpace_replace(str); str 254 ext/soap/php_encoding.c while (*str == ' ') { str 255 ext/soap/php_encoding.c str++; str 258 ext/soap/php_encoding.c while (*str != '\0') { str 259 ext/soap/php_encoding.c if (*str != ' ' || old != ' ') { str 260 ext/soap/php_encoding.c *pos = *str; str 263 ext/soap/php_encoding.c old = *str; str 264 ext/soap/php_encoding.c str++; str 757 ext/soap/php_encoding.c zend_string *str; str 764 ext/soap/php_encoding.c str = php_base64_decode(data->children->content, strlen((char*)data->children->content)); str 765 ext/soap/php_encoding.c if (!str) { str 768 ext/soap/php_encoding.c ZVAL_STR(ret, str); str 770 ext/soap/php_encoding.c str = php_base64_decode(data->children->content, strlen((char*)data->children->content)); str 771 ext/soap/php_encoding.c if (!str) { str 774 ext/soap/php_encoding.c ZVAL_STR(ret, str); str 786 ext/soap/php_encoding.c zend_string *str; str 799 ext/soap/php_encoding.c str = zend_string_alloc(strlen((char*)data->children->content) / 2, 0); str 800 ext/soap/php_encoding.c for (i = j = 0; i < ZSTR_LEN(str); i++) { str 803 ext/soap/php_encoding.c ZSTR_VAL(str)[i] = (c - '0') << 4; str 805 ext/soap/php_encoding.c ZSTR_VAL(str)[i] = (c - 'a' + 10) << 4; str 807 ext/soap/php_encoding.c ZSTR_VAL(str)[i] = (c - 'A' + 10) << 4; str 813 ext/soap/php_encoding.c ZSTR_VAL(str)[i] |= c - '0'; str 815 ext/soap/php_encoding.c ZSTR_VAL(str)[i] |= c - 'a' + 10; str 817 ext/soap/php_encoding.c ZSTR_VAL(str)[i] |= c - 'A' + 10; str 822 ext/soap/php_encoding.c ZSTR_VAL(str)[ZSTR_LEN(str)] = '\0'; str 823 ext/soap/php_encoding.c ZVAL_NEW_STR(ret, str); str 833 ext/soap/php_encoding.c char *str; str 841 ext/soap/php_encoding.c str = estrndup(Z_STRVAL_P(data), Z_STRLEN_P(data)); str 845 ext/soap/php_encoding.c str = estrndup(ZSTR_VAL(tmp), ZSTR_LEN(tmp)); str 851 ext/soap/php_encoding.c xmlBufferPtr in = xmlBufferCreateStatic(str, new_len); str 856 ext/soap/php_encoding.c efree(str); str 857 ext/soap/php_encoding.c str = estrdup((char*)xmlBufferContent(out)); str 864 ext/soap/php_encoding.c if (!php_libxml_xmlCheckUTF8(BAD_CAST(str))) { str 869 ext/soap/php_encoding.c memcpy(err, str, new_len+1); str 905 ext/soap/php_encoding.c text = xmlNewTextLen(BAD_CAST(str), new_len); str 907 ext/soap/php_encoding.c efree(str); str 918 ext/soap/php_encoding.c zend_string *str; str 925 ext/soap/php_encoding.c str = php_base64_encode((unsigned char*)Z_STRVAL_P(data), Z_STRLEN_P(data)); str 928 ext/soap/php_encoding.c str = php_base64_encode((unsigned char*) ZSTR_VAL(tmp), ZSTR_LEN(tmp)); str 932 ext/soap/php_encoding.c text = xmlNewTextLen(BAD_CAST(ZSTR_VAL(str)), ZSTR_LEN(str)); str 934 ext/soap/php_encoding.c zend_string_release(str); str 946 ext/soap/php_encoding.c unsigned char *str; str 958 ext/soap/php_encoding.c str = (unsigned char *) safe_emalloc(Z_STRLEN_P(data) * 2, sizeof(char), 1); str 961 ext/soap/php_encoding.c str[j++] = hexconvtab[((unsigned char)Z_STRVAL_P(data)[i]) >> 4]; str 962 ext/soap/php_encoding.c str[j++] = hexconvtab[((unsigned char)Z_STRVAL_P(data)[i]) & 15]; str 964 ext/soap/php_encoding.c str[j] = '\0'; str 966 ext/soap/php_encoding.c text = xmlNewTextLen(str, Z_STRLEN_P(data) * 2 * sizeof(char)); str 968 ext/soap/php_encoding.c efree(str); str 1063 ext/soap/php_encoding.c zend_string *str = zend_long_to_str(zval_get_long(data)); str 1064 ext/soap/php_encoding.c xmlNodeSetContentLen(ret, BAD_CAST(ZSTR_VAL(str)), ZSTR_LEN(str)); str 1065 ext/soap/php_encoding.c zend_string_release(str); str 1078 ext/soap/php_encoding.c char *str; str 1086 ext/soap/php_encoding.c str = (char *) safe_emalloc(EG(precision), 1, MAX_LENGTH_OF_DOUBLE + 1); str 1087 ext/soap/php_encoding.c php_gcvt(Z_DVAL(tmp), EG(precision), '.', 'E', str); str 1088 ext/soap/php_encoding.c xmlNodeSetContentLen(ret, BAD_CAST(str), strlen(str)); str 1089 ext/soap/php_encoding.c efree(str); str 2011 ext/soap/php_encoding.c static int calc_dimension_12(const char* str) str 2014 ext/soap/php_encoding.c while (*str != '\0' && (*str < '0' || *str > '9') && (*str != '*')) { str 2015 ext/soap/php_encoding.c str++; str 2017 ext/soap/php_encoding.c if (*str == '*') { str 2019 ext/soap/php_encoding.c str++; str 2021 ext/soap/php_encoding.c while (*str != '\0') { str 2022 ext/soap/php_encoding.c if (*str >= '0' && *str <= '9') { str 2027 ext/soap/php_encoding.c } else if (*str == '*') { str 2032 ext/soap/php_encoding.c str++; str 2037 ext/soap/php_encoding.c static int* get_position_12(int dimension, const char* str) str 2044 ext/soap/php_encoding.c while (*str != '\0' && (*str < '0' || *str > '9') && (*str != '*')) { str 2045 ext/soap/php_encoding.c str++; str 2047 ext/soap/php_encoding.c if (*str == '*') { str 2048 ext/soap/php_encoding.c str++; str 2051 ext/soap/php_encoding.c while (*str != '\0') { str 2052 ext/soap/php_encoding.c if (*str >= '0' && *str <= '9') { str 2057 ext/soap/php_encoding.c pos[i] = (pos[i]*10)+(*str-'0'); str 2058 ext/soap/php_encoding.c } else if (*str == '*') { str 2063 ext/soap/php_encoding.c str++; str 2068 ext/soap/php_encoding.c static int calc_dimension(const char* str) str 2071 ext/soap/php_encoding.c while (*str != ']' && *str != '\0') { str 2072 ext/soap/php_encoding.c if (*str == ',') { str 2075 ext/soap/php_encoding.c str++; str 2080 ext/soap/php_encoding.c static void get_position_ex(int dimension, const char* str, int** pos) str 2085 ext/soap/php_encoding.c while (*str != ']' && *str != '\0' && i < dimension) { str 2086 ext/soap/php_encoding.c if (*str >= '0' && *str <= '9') { str 2087 ext/soap/php_encoding.c (*pos)[i] = ((*pos)[i]*10)+(*str-'0'); str 2088 ext/soap/php_encoding.c } else if (*str == ',') { str 2091 ext/soap/php_encoding.c str++; str 2095 ext/soap/php_encoding.c static int* get_position(int dimension, const char* str) str 2100 ext/soap/php_encoding.c get_position_ex(dimension, str, &pos); str 3025 ext/soap/php_encoding.c char *str, *start, *next; str 3032 ext/soap/php_encoding.c str = estrndup(Z_STRVAL_P(data), Z_STRLEN_P(data)); str 3033 ext/soap/php_encoding.c whiteSpace_collapse(BAD_CAST(str)); str 3034 ext/soap/php_encoding.c start = str; str 3067 ext/soap/php_encoding.c efree(str); str 198 ext/soap/php_encoding.h void whiteSpace_replace(xmlChar* str); str 199 ext/soap/php_encoding.h void whiteSpace_collapse(xmlChar* str); str 31 ext/soap/php_http.c #define smart_str_append_const(str, const) \ str 32 ext/soap/php_http.c smart_str_appendl(str,const,sizeof(const)-1) str 462 ext/soap/php_schema.c char *str = emalloc(sizeof("anonymous") + buf + sizeof(buf) - 1 - res); str 464 ext/soap/php_schema.c memcpy(str, "anonymous", sizeof("anonymous")-1); str 465 ext/soap/php_schema.c memcpy(str + sizeof("anonymous")-1, res, buf + sizeof(buf) - res); str 466 ext/soap/php_schema.c newType->name = str; str 501 ext/soap/php_schema.c char *str, *start, *end, *next; str 505 ext/soap/php_schema.c str = estrdup((char*)memberTypes->children->content); str 506 ext/soap/php_schema.c whiteSpace_collapse(BAD_CAST(str)); str 507 ext/soap/php_schema.c start = str; str 541 ext/soap/php_schema.c efree(str); str 559 ext/soap/php_schema.c char *str = emalloc(sizeof("anonymous") + buf + sizeof(buf) - 1 - res); str 561 ext/soap/php_schema.c memcpy(str, "anonymous", sizeof("anonymous")-1); str 562 ext/soap/php_schema.c memcpy(str + sizeof("anonymous")-1, res, buf + sizeof(buf) - res); str 563 ext/soap/php_schema.c newType->name = str; str 1931 ext/soap/php_schema.c char *str = emalloc(sizeof("anonymous") + buf + sizeof(buf) - 1 - res); str 1933 ext/soap/php_schema.c memcpy(str, "anonymous", sizeof("anonymous")-1); str 1934 ext/soap/php_schema.c memcpy(str + sizeof("anonymous")-1, res, buf + sizeof(buf) - res); str 1935 ext/soap/php_schema.c dummy_type->name = str; str 1779 ext/soap/php_sdl.c static void sdl_serialize_string(const char *str, smart_str *out) str 1783 ext/soap/php_sdl.c if (str) { str 1784 ext/soap/php_sdl.c i = strlen(str); str 1787 ext/soap/php_sdl.c WSDL_CACHE_PUT_N(str, i, out); str 30 ext/soap/php_xml.c static int is_blank(const xmlChar* str) str 32 ext/soap/php_xml.c while (*str != '\0') { str 33 ext/soap/php_xml.c if (*str != ' ' && *str != 0x9 && *str != 0xa && *str != 0xd) { str 36 ext/soap/php_xml.c str++; str 941 ext/soap/soap.c zend_string *str; str 975 ext/soap/soap.c str = strpprintf(0, "SoapFault exception: [%s] %s in %s:%pd\nStack trace:\n%s", str 981 ext/soap/soap.c RETVAL_STR(str); str 4001 ext/soap/soap.c zend_string *str = php_escape_html_entities((unsigned char*)Z_STRVAL_P(tmp), Z_STRLEN_P(tmp), 0, 0, NULL); str 4005 ext/soap/soap.c xmlChar *code = xmlBuildQName(BAD_CAST(ZSTR_VAL(str)), nsptr->prefix, NULL, 0); str 4009 ext/soap/soap.c xmlNodeSetContentLen(node, BAD_CAST(ZSTR_VAL(str)), (int)ZSTR_LEN(str)); str 4011 ext/soap/soap.c zend_string_release(str); str 4026 ext/soap/soap.c zend_string *str = php_escape_html_entities((unsigned char*)Z_STRVAL_P(tmp), Z_STRLEN_P(tmp), 0, 0, NULL); str 4030 ext/soap/soap.c xmlChar *code = xmlBuildQName(BAD_CAST(ZSTR_VAL(str)), nsptr->prefix, NULL, 0); str 4034 ext/soap/soap.c xmlNodeSetContentLen(node, BAD_CAST(ZSTR_VAL(str)), (int)ZSTR_LEN(str)); str 4036 ext/soap/soap.c zend_string_release(str); str 4515 ext/soap/soap.c char *str = estrndup(function_name,len); str 4516 ext/soap/soap.c php_strtolower(str,len); str 4518 ext/soap/soap.c if ((tmp = zend_hash_str_find_ptr(&sdl->functions, str, len)) != NULL) { str 4519 ext/soap/soap.c efree(str); str 4521 ext/soap/soap.c } else if (sdl->requests != NULL && (tmp = zend_hash_str_find_ptr(sdl->requests, str, len)) != NULL) { str 4522 ext/soap/soap.c efree(str); str 4526 ext/soap/soap.c efree(str); str 562 ext/sockets/conversions.c zend_string *str = zend_string_alloc(size - 1, 0); str 563 ext/sockets/conversions.c memset(ZSTR_VAL(str), '\0', size); str 565 ext/sockets/conversions.c ZVAL_NEW_STR(zv, str); str 612 ext/sockets/conversions.c zend_string *str = zend_string_alloc(size - 1, 0); str 614 ext/sockets/conversions.c memset(ZSTR_VAL(str), '\0', size); str 616 ext/sockets/conversions.c ZVAL_NEW_STR(zv, str); str 1246 ext/sockets/conversions.c zend_string *str; str 1248 ext/sockets/conversions.c str = zval_get_string((zval *) zv); str 1251 ext/sockets/conversions.c ret = if_nametoindex(ZSTR_VAL(str)); str 1253 ext/sockets/conversions.c do_from_zval_err(ctx, "no interface with name \"%s\" could be found", ZSTR_VAL(str)); str 1258 ext/sockets/conversions.c if (strlcpy(ifr.ifr_name, ZSTR_VAL(str), sizeof(ifr.ifr_name)) str 1260 ext/sockets/conversions.c do_from_zval_err(ctx, "the interface name \"%s\" is too large ", ZSTR_VAL(str)); str 1264 ext/sockets/conversions.c "found", ZSTR_VAL(str)); str 1268 ext/sockets/conversions.c ZSTR_VAL(str), errno); str 1280 ext/sockets/conversions.c zend_string_release(str); str 1104 ext/sockets/sockets.c char *str; str 1106 ext/sockets/sockets.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs|l", &arg1, &str, &str_len, &length) == FAILURE) { str 1119 ext/sockets/sockets.c retval = write(php_sock->bsd_socket, str, MIN(length, str_len)); str 1121 ext/sockets/sockets.c retval = send(php_sock->bsd_socket, str, min(length, str_len), 0); str 2872 ext/spl/spl_directory.c char *str; str 2876 ext/spl/spl_directory.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|l", &str, &str_len, &length) == FAILURE) { str 2897 ext/spl/spl_directory.c RETURN_LONG(php_stream_write(intern->u.file.stream, str, str_len)); str 3033 ext/spl/spl_directory.c ZEND_ARG_INFO(0, str) str 1030 ext/spl/spl_iterators.c smart_str str = {0}; str 1034 ext/spl/spl_iterators.c smart_str_appendl(&str, ZSTR_VAL(object->prefix[0].s), ZSTR_LEN(object->prefix[0].s)); str 1040 ext/spl/spl_iterators.c smart_str_appendl(&str, ZSTR_VAL(object->prefix[1].s), ZSTR_LEN(object->prefix[1].s)); str 1042 ext/spl/spl_iterators.c smart_str_appendl(&str, ZSTR_VAL(object->prefix[2].s), ZSTR_LEN(object->prefix[2].s)); str 1050 ext/spl/spl_iterators.c smart_str_appendl(&str, ZSTR_VAL(object->prefix[3].s), ZSTR_LEN(object->prefix[3].s)); str 1052 ext/spl/spl_iterators.c smart_str_appendl(&str, ZSTR_VAL(object->prefix[4].s), ZSTR_LEN(object->prefix[4].s)); str 1057 ext/spl/spl_iterators.c smart_str_appendl(&str, ZSTR_VAL(object->prefix[5].s), ZSTR_LEN(object->prefix[5].s)); str 1058 ext/spl/spl_iterators.c smart_str_0(&str); str 1060 ext/spl/spl_iterators.c RETURN_NEW_STR(str.s); str 1201 ext/spl/spl_iterators.c zend_string *str; str 1239 ext/spl/spl_iterators.c str = zend_string_alloc(Z_STRLEN(prefix) + Z_STRLEN(entry) + Z_STRLEN(postfix), 0); str 1240 ext/spl/spl_iterators.c ptr = ZSTR_VAL(str); str 1254 ext/spl/spl_iterators.c RETURN_NEW_STR(str); str 1265 ext/spl/spl_iterators.c zend_string *str; str 1293 ext/spl/spl_iterators.c str = zend_string_alloc(Z_STRLEN(prefix) + Z_STRLEN(key) + Z_STRLEN(postfix), 0); str 1294 ext/spl/spl_iterators.c ptr = ZSTR_VAL(str); str 1308 ext/spl/spl_iterators.c RETURN_NEW_STR(str); str 14790 ext/sqlite3/libsqlite/sqlite3.c StrAccum str; /* The string being accumulated */ str 96656 ext/sqlite3/libsqlite/sqlite3.c StrAccum str; str 96665 ext/sqlite3/libsqlite/sqlite3.c sqlite3StrAccumInit(&str, db, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]); str 96666 ext/sqlite3/libsqlite/sqlite3.c sqlite3XPrintf(&str, SQLITE_PRINTF_SQLFUNC, zFormat, &x); str 96667 ext/sqlite3/libsqlite/sqlite3.c n = str.nChar; str 96668 ext/sqlite3/libsqlite/sqlite3.c sqlite3_result_text(context, sqlite3StrAccumFinish(&str), n, str 119269 ext/sqlite3/libsqlite/sqlite3.c StrAccum str; /* EQP output string */ str 119280 ext/sqlite3/libsqlite/sqlite3.c sqlite3StrAccumInit(&str, db, zBuf, sizeof(zBuf), SQLITE_MAX_LENGTH); str 119281 ext/sqlite3/libsqlite/sqlite3.c sqlite3StrAccumAppendAll(&str, isSearch ? "SEARCH" : "SCAN"); str 119283 ext/sqlite3/libsqlite/sqlite3.c sqlite3XPrintf(&str, 0, " SUBQUERY %d", pItem->iSelectId); str 119285 ext/sqlite3/libsqlite/sqlite3.c sqlite3XPrintf(&str, 0, " TABLE %s", pItem->zName); str 119289 ext/sqlite3/libsqlite/sqlite3.c sqlite3XPrintf(&str, 0, " AS %s", pItem->zAlias); str 119312 ext/sqlite3/libsqlite/sqlite3.c sqlite3StrAccumAppend(&str, " USING ", 7); str 119313 ext/sqlite3/libsqlite/sqlite3.c sqlite3XPrintf(&str, 0, zFmt, pIdx->zName); str 119314 ext/sqlite3/libsqlite/sqlite3.c explainIndexRange(&str, pLoop, pItem->pTab); str 119328 ext/sqlite3/libsqlite/sqlite3.c sqlite3StrAccumAppendAll(&str, " USING INTEGER PRIMARY KEY "); str 119329 ext/sqlite3/libsqlite/sqlite3.c sqlite3StrAccumAppendAll(&str, zRange); str 119333 ext/sqlite3/libsqlite/sqlite3.c sqlite3XPrintf(&str, 0, " VIRTUAL TABLE INDEX %d:%s", str 119339 ext/sqlite3/libsqlite/sqlite3.c sqlite3XPrintf(&str, 0, " (~%llu rows)", sqlite3LogEstToInt(pLoop->nOut)); str 119341 ext/sqlite3/libsqlite/sqlite3.c sqlite3StrAccumAppend(&str, " (~1 row)", 9); str 119344 ext/sqlite3/libsqlite/sqlite3.c zMsg = sqlite3StrAccumFinish(&str); str 1842 ext/standard/array.c zend_string *str = zend_long_to_str(num_key); str 1843 ext/standard/array.c php_prefix_varname(&final_name, prefix, ZSTR_VAL(str), ZSTR_LEN(str), 1); str 1844 ext/standard/array.c zend_string_release(str); str 4656 ext/standard/array.c zend_string *str, *key; str 4694 ext/standard/array.c str = zval_get_string(value); str 4695 ext/standard/array.c zend_hash_add(&exclude, str, &dummy); str 4696 ext/standard/array.c zend_string_release(str); str 4703 ext/standard/array.c str = zval_get_string(value); str 4704 ext/standard/array.c if (!zend_hash_exists(&exclude, str)) { str 4712 ext/standard/array.c zend_string_release(str); str 182 ext/standard/assert.c zend_string *str = zval_get_string(description); str 183 ext/standard/assert.c php_error_docref(NULL, E_RECOVERABLE_ERROR, "Failure evaluating code: %s%s:\"%s\"", PHP_EOL, ZSTR_VAL(str), myeval); str 184 ext/standard/assert.c zend_string_release(str); str 252 ext/standard/assert.c zend_string *str = zval_get_string(description); str 253 ext/standard/assert.c zend_throw_exception(assertion_error_ce, ZSTR_VAL(str), E_ERROR); str 254 ext/standard/assert.c zend_string_release(str); str 264 ext/standard/assert.c zend_string *str = zval_get_string(description); str 266 ext/standard/assert.c php_error_docref(NULL, E_WARNING, "%s: \"%s\" failed", ZSTR_VAL(str), myeval); str 268 ext/standard/assert.c php_error_docref(NULL, E_WARNING, "%s failed", ZSTR_VAL(str)); str 270 ext/standard/assert.c zend_string_release(str); str 56 ext/standard/base64.c PHPAPI zend_string *php_base64_encode(const unsigned char *str, size_t length) /* {{{ */ str 58 ext/standard/base64.c const unsigned char *current = str; str 130 ext/standard/base64.c PHPAPI zend_string *php_base64_decode(const unsigned char *str, size_t length) /* {{{ */ str 132 ext/standard/base64.c return php_base64_decode_ex(str, length, 0); str 136 ext/standard/base64.c PHPAPI zend_string *php_base64_decode_ex(const unsigned char *str, size_t length, zend_bool strict) /* {{{ */ str 138 ext/standard/base64.c const unsigned char *current = str; str 214 ext/standard/base64.c char *str; str 218 ext/standard/base64.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &str, &str_len) == FAILURE) { str 221 ext/standard/base64.c result = php_base64_encode((unsigned char*)str, str_len); str 234 ext/standard/base64.c char *str; str 239 ext/standard/base64.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|b", &str, &str_len, &strict) == FAILURE) { str 242 ext/standard/base64.c result = php_base64_decode_ex((unsigned char*)str, str_len, strict); str 852 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 856 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 869 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 876 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 883 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 1112 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 1773 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 1878 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 1883 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 1923 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 1934 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2140 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2147 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2167 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2172 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2177 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2182 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2190 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2200 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2205 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2209 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2269 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2275 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2281 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2288 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2300 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2304 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2308 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2313 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2319 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2329 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2334 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2338 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2342 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2360 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2365 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2370 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2375 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2434 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2440 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2444 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2448 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2461 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2472 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2583 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2587 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2591 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 2595 ext/standard/basic_functions.c ZEND_ARG_INFO(0, str) str 3986 ext/standard/basic_functions.c char str[40]; str 3997 ext/standard/basic_functions.c if (inet_ntop(AF_INET, &myaddr, str, sizeof(str))) { str 3998 ext/standard/basic_functions.c RETURN_STRING(str); str 4016 ext/standard/basic_functions.c char *ptr, *str; str 4019 ext/standard/basic_functions.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &str, &str_len) == FAILURE) { str 4024 ext/standard/basic_functions.c ptr = sapi_getenv(str, str_len); str 4040 ext/standard/basic_functions.c size = GetEnvironmentVariableA(str, &dummybuf, 0); str 4052 ext/standard/basic_functions.c size = GetEnvironmentVariableA(str, ptr, size); str 4065 ext/standard/basic_functions.c ptr = getenv(str); str 5246 ext/standard/basic_functions.c char *varname, *str; str 5253 ext/standard/basic_functions.c str = zend_ini_string(varname, (uint)varname_len, 0); str 5255 ext/standard/basic_functions.c if (!str) { str 5259 ext/standard/basic_functions.c RETURN_STRING(str); str 5443 ext/standard/basic_functions.c char *str; str 5449 ext/standard/basic_functions.c str = zend_ini_string("include_path", sizeof("include_path") - 1, 0); str 5451 ext/standard/basic_functions.c if (str == NULL) { str 5455 ext/standard/basic_functions.c RETURN_STRING(str); str 5930 ext/standard/basic_functions.c char *string = NULL, *str = NULL; str 5936 ext/standard/basic_functions.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|bl", &str, &str_len, &process_sections, &scanner_mode) == FAILURE) { str 5954 ext/standard/basic_functions.c memcpy(string, str, str_len); str 284 ext/standard/crypt.c char *str, *salt_in = NULL; str 294 ext/standard/crypt.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", &str, &str_len, &salt_in, &salt_in_len) == FAILURE) { str 321 ext/standard/crypt.c if ((result = php_crypt(str, (int)str_len, salt, (int)salt_in_len, 0)) == NULL) { str 204 ext/standard/cyr_convert.c static char * php_convert_cyr_string(unsigned char *str, size_t length, char from, char to) str 258 ext/standard/cyr_convert.c if (!str) str 259 ext/standard/cyr_convert.c return (char *)str; str 262 ext/standard/cyr_convert.c tmp = (from_table == NULL)? str[i] : from_table[ str[i] ]; str 263 ext/standard/cyr_convert.c str[i] = (to_table == NULL) ? tmp : to_table[tmp + 256]; str 265 ext/standard/cyr_convert.c return (char *)str; str 275 ext/standard/cyr_convert.c zend_string *str; str 281 ext/standard/cyr_convert.c str = zend_string_init(input, input_len, 0); str 283 ext/standard/cyr_convert.c php_convert_cyr_string((unsigned char *) ZSTR_VAL(str), ZSTR_LEN(str), fr_cs[0], to_cs[0]); str 284 ext/standard/cyr_convert.c RETVAL_NEW_STR(str); str 57 ext/standard/datetime.c char *str; str 60 ext/standard/datetime.c str = emalloc(81); str 61 ext/standard/datetime.c str[0] = '\0'; str 64 ext/standard/datetime.c return str; str 67 ext/standard/datetime.c snprintf(str, 80, "%s, %02d %s %04d %02d:%02d:%02d GMT", str 74 ext/standard/datetime.c str[79] = 0; str 75 ext/standard/datetime.c return (str); str 299 ext/standard/dir.c char *str; str 303 ext/standard/dir.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "p", &str, &str_len) == FAILURE) { str 307 ext/standard/dir.c ret = chroot(str); str 331 ext/standard/dir.c char *str; str 335 ext/standard/dir.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "p", &str, &str_len) == FAILURE) { str 339 ext/standard/dir.c if (php_check_open_basedir(str)) { str 342 ext/standard/dir.c ret = VCWD_CHDIR(str); str 279 ext/standard/exec.c PHPAPI zend_string *php_escape_shell_cmd(char *str) str 282 ext/standard/exec.c size_t l = strlen(str); str 298 ext/standard/exec.c int mb_len = php_mblen(str + x, (l - x)); str 304 ext/standard/exec.c memcpy(ZSTR_VAL(cmd) + y, str + x, mb_len); str 310 ext/standard/exec.c switch (str[x]) { str 314 ext/standard/exec.c if (!p && (p = memchr(str + x + 1, str[x], l - x - 1))) { str 316 ext/standard/exec.c } else if (p && *p == str[x]) { str 321 ext/standard/exec.c ZSTR_VAL(cmd)[y++] = str[x]; str 360 ext/standard/exec.c ZSTR_VAL(cmd)[y++] = str[x]; str 386 ext/standard/exec.c PHPAPI zend_string *php_escape_shell_arg(char *str) str 389 ext/standard/exec.c size_t l = strlen(str); str 408 ext/standard/exec.c int mb_len = php_mblen(str + x, (l - x)); str 414 ext/standard/exec.c memcpy(ZSTR_VAL(cmd) + y, str + x, mb_len); str 420 ext/standard/exec.c switch (str[x]) { str 435 ext/standard/exec.c ZSTR_VAL(cmd)[y++] = str[x]; str 657 ext/standard/file.c zend_string *str = zval_get_string(tmp); str 658 ext/standard/file.c if (ZSTR_LEN(str)) { str 659 ext/standard/file.c numbytes += ZSTR_LEN(str); str 660 ext/standard/file.c bytes_written = php_stream_write(stream, ZSTR_VAL(str), ZSTR_LEN(str)); str 661 ext/standard/file.c if (bytes_written != ZSTR_LEN(str)) { str 662 ext/standard/file.c php_error_docref(NULL, E_WARNING, "Failed to write %zd bytes to %s", ZSTR_LEN(str), filename); str 663 ext/standard/file.c zend_string_release(str); str 668 ext/standard/file.c zend_string_release(str); str 1007 ext/standard/file.c zend_string *str; str 1039 ext/standard/file.c str = zend_string_alloc(len, 0); str 1040 ext/standard/file.c if (php_stream_get_line(stream, ZSTR_VAL(str), len, &line_len) == NULL) { str 1041 ext/standard/file.c zend_string_free(str); str 1047 ext/standard/file.c str = zend_string_truncate(str, line_len, 0); str 1049 ext/standard/file.c ZSTR_LEN(str) = line_len; str 1051 ext/standard/file.c RETURN_NEW_STR(str); str 1220 ext/standard/filters.c zend_string *str = zval_get_string(tmpval); str 1222 ext/standard/filters.c if (NULL == (*pretval = pemalloc(ZSTR_LEN(str) + 1, persistent))) { str 1226 ext/standard/filters.c *pretval_len = ZSTR_LEN(str); str 1227 ext/standard/filters.c memcpy(*pretval, ZSTR_VAL(str), ZSTR_LEN(str) + 1); str 1228 ext/standard/filters.c zend_string_release(str); str 573 ext/standard/formatted_print.c zend_string *str = zval_get_string(tmp); str 575 ext/standard/formatted_print.c ZSTR_VAL(str), str 578 ext/standard/formatted_print.c ZSTR_LEN(str), str 580 ext/standard/formatted_print.c zend_string_release(str); str 103 ext/standard/html.c const unsigned char *str, str 125 ext/standard/html.c c = str[pos]; str 135 ext/standard/html.c if (!utf8_trail(str[pos + 1])) { str 136 ext/standard/html.c MB_FAILURE(pos, utf8_lead(str[pos + 1]) ? 1 : 2); str 138 ext/standard/html.c this_char = ((c & 0x1f) << 6) | (str[pos + 1] & 0x3f); str 147 ext/standard/html.c !utf8_trail(str[pos + 1]) || !utf8_trail(str[pos + 2])) { str 148 ext/standard/html.c if (avail < 2 || utf8_lead(str[pos + 1])) str 150 ext/standard/html.c else if (avail < 3 || utf8_lead(str[pos + 2])) str 156 ext/standard/html.c this_char = ((c & 0x0f) << 12) | ((str[pos + 1] & 0x3f) << 6) | (str[pos + 2] & 0x3f); str 167 ext/standard/html.c !utf8_trail(str[pos + 1]) || !utf8_trail(str[pos + 2]) || str 168 ext/standard/html.c !utf8_trail(str[pos + 3])) { str 169 ext/standard/html.c if (avail < 2 || utf8_lead(str[pos + 1])) str 171 ext/standard/html.c else if (avail < 3 || utf8_lead(str[pos + 2])) str 173 ext/standard/html.c else if (avail < 4 || utf8_lead(str[pos + 3])) str 179 ext/standard/html.c this_char = ((c & 0x07) << 18) | ((str[pos + 1] & 0x3f) << 12) | ((str[pos + 2] & 0x3f) << 6) | (str[pos + 3] & 0x3f); str 193 ext/standard/html.c unsigned char c = str[pos]; str 199 ext/standard/html.c next = str[pos + 1]; str 217 ext/standard/html.c unsigned char c = str[pos]; str 223 ext/standard/html.c next = str[pos + 1]; str 243 ext/standard/html.c unsigned char c = str[pos]; str 249 ext/standard/html.c next = str[pos + 1]; str 270 ext/standard/html.c unsigned char c = str[pos]; str 276 ext/standard/html.c next = str[pos + 1]; str 297 ext/standard/html.c unsigned char c = str[pos]; str 303 ext/standard/html.c next = str[pos + 1]; str 317 ext/standard/html.c next = str[pos + 1]; str 328 ext/standard/html.c if (avail < 3 || !(str[pos + 1] >= 0xA1 && str[pos + 1] <= 0xFE) || str 329 ext/standard/html.c !(str[pos + 2] >= 0xA1 && str[pos + 2] <= 0xFE)) { str 330 ext/standard/html.c if (avail < 2 || (str[pos + 1] != 0xA0 && str[pos + 1] != 0xFF)) str 332 ext/standard/html.c else if (avail < 3 || (str[pos + 2] != 0xA0 && str[pos + 2] != 0xFF)) str 338 ext/standard/html.c this_char = (c << 16) | (str[pos + 1] << 8) | str[pos + 2]; str 352 ext/standard/html.c this_char = str[pos++]; str 364 ext/standard/html.c const unsigned char *str, str 369 ext/standard/html.c return get_next_char(cs_utf_8, str, str_len, cursor, status); str 1446 ext/standard/html.c zend_string *str, *hint_charset = NULL; str 1453 ext/standard/html.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|lS!b", &str, &flags, &hint_charset, &double_encode) == FAILURE) { str 1458 ext/standard/html.c Z_PARAM_STR(str) str 1469 ext/standard/html.c replaced = php_escape_html_entities_ex((unsigned char*)ZSTR_VAL(str), ZSTR_LEN(str), all, (int) flags, (hint_charset ? ZSTR_VAL(hint_charset) : default_charset), double_encode); str 1508 ext/standard/html.c char *str; str 1513 ext/standard/html.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|l", &str, &str_len, "e_style) == FAILURE) { str 1517 ext/standard/html.c replaced = php_unescape_html_entities((unsigned char*)str, str_len, 0 /*!all*/, (int)quote_style, NULL); str 1529 ext/standard/html.c zend_string *str, *hint_charset = NULL; str 1535 ext/standard/html.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|lS", &str, str 1541 ext/standard/html.c Z_PARAM_STR(str) str 1551 ext/standard/html.c replaced = php_unescape_html_entities((unsigned char*)ZSTR_VAL(str), ZSTR_LEN(str), 1 /*all*/, (int)quote_style, (hint_charset ? ZSTR_VAL(hint_charset) : default_charset)); str 60 ext/standard/html.h PHPAPI unsigned int php_next_utf8_char(const unsigned char *str, size_t str_len, size_t *cursor, int *status); str 62 ext/standard/info.c static int php_info_print_html_esc(const char *str, size_t len) /* {{{ */ str 67 ext/standard/info.c new_str = php_escape_html_entities((unsigned char *) str, len, 0, ENT_QUOTES, "utf-8"); str 90 ext/standard/info.c static int php_info_print(const char *str) /* {{{ */ str 92 ext/standard/info.c return php_output_write(str, strlen(str)); str 320 ext/standard/iptc.c char *str, key[16]; str 324 ext/standard/iptc.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &str, &str_len) != SUCCESS) { str 328 ext/standard/iptc.c buffer = (unsigned char *)str; str 59 ext/standard/mail.c #define SKIP_LONG_HEADER_SEP(str, pos) \ str 60 ext/standard/mail.c if (str[pos] == '\r' && str[pos + 1] == '\n' && (str[pos + 2] == ' ' || str[pos + 2] == '\t')) { \ str 62 ext/standard/mail.c while (str[pos + 1] == ' ' || str[pos + 1] == '\t') { \ str 68 ext/standard/mail.c #define MAIL_ASCIIZ_CHECK(str, len) \ str 69 ext/standard/mail.c p = str; \ str 81 ext/standard/mail.c char *str = NULL; str 85 ext/standard/mail.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &str, &str_len) == FAILURE) { str 90 ext/standard/mail.c h = (h + (h << 5)) ^ (zend_ulong) (unsigned char) tolower(str[j]); str 34 ext/standard/metaphone.c zend_string *str; str 38 ext/standard/metaphone.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|l", &str, &phones) == FAILURE) { str 42 ext/standard/metaphone.c if (metaphone((unsigned char *)ZSTR_VAL(str), ZSTR_LEN(str), phones, &result, 1) == 0) { str 339 ext/standard/pack.c zend_string *str = zval_get_string(&argv[currentarg++]); str 342 ext/standard/pack.c memcpy(&ZSTR_VAL(output)[outputpos], ZSTR_VAL(str), str 343 ext/standard/pack.c (ZSTR_LEN(str) < arg_cp) ? ZSTR_LEN(str) : arg_cp); str 346 ext/standard/pack.c zend_string_release(str); str 355 ext/standard/pack.c zend_string *str = zval_get_string(&argv[currentarg++]); str 356 ext/standard/pack.c char *v = ZSTR_VAL(str); str 359 ext/standard/pack.c if(arg > ZSTR_LEN(str)) { str 361 ext/standard/pack.c arg = ZSTR_LEN(str); str 389 ext/standard/pack.c zend_string_release(str); str 70 ext/standard/password.c static int php_password_salt_is_alphabet(const char *str, const size_t len) /* {{{ */ str 75 ext/standard/password.c if (!((str[i] >= 'A' && str[i] <= 'Z') || (str[i] >= 'a' && str[i] <= 'z') || (str[i] >= '0' && str[i] <= '9') || str[i] == '.' || str[i] == '/')) { str 83 ext/standard/password.c static int php_password_salt_to64(const char *str, const size_t str_len, const size_t out_len, char *ret) /* {{{ */ str 90 ext/standard/password.c buffer = php_base64_encode((unsigned char*) str, str_len); str 125 ext/standard/php_string.h PHPAPI char *php_strtr(char *str, size_t len, char *str_from, char *str_to, size_t trlen); str 126 ext/standard/php_string.h PHPAPI zend_string *php_addslashes(zend_string *str, int should_free); str 127 ext/standard/php_string.h PHPAPI zend_string *php_addcslashes(zend_string *str, int freeit, char *what, size_t what_len); str 128 ext/standard/php_string.h PHPAPI void php_stripslashes(zend_string *str); str 129 ext/standard/php_string.h PHPAPI void php_stripcslashes(zend_string *str); str 131 ext/standard/php_string.h PHPAPI size_t php_dirname(char *str, size_t len); str 134 ext/standard/php_string.h size_t needle_len, char *str, size_t str_len); str 135 ext/standard/php_string.h PHPAPI zend_string *php_trim(zend_string *str, char *what, size_t what_len, int mode); str 139 ext/standard/php_string.h PHPAPI void php_explode(const zend_string *delim, zend_string *str, zval *return_value, zend_long limit); str 111 ext/standard/proc_open.c zend_string *str = zval_get_string(element); str 112 ext/standard/proc_open.c size_t el_len = ZSTR_LEN(str); str 113 ext/standard/proc_open.c zend_string_release(str); str 135 ext/standard/proc_open.c zend_string *str = zval_get_string(element); str 137 ext/standard/proc_open.c if (ZSTR_LEN(str) == 0) { str 146 ext/standard/proc_open.c l = ZSTR_LEN(string_key) + ZSTR_LEN(str) + 2; str 149 ext/standard/proc_open.c strncat(p, ZSTR_VAL(str), ZSTR_LEN(str)); str 157 ext/standard/proc_open.c memcpy(p, ZSTR_VAL(str), ZSTR_LEN(str)); str 162 ext/standard/proc_open.c p += ZSTR_LEN(str) + 1; str 165 ext/standard/proc_open.c zend_string_release(str); str 54 ext/standard/quot_print.c PHPAPI zend_string *php_quot_print_decode(const unsigned char *str, size_t length, int replace_us_by_ws) /* {{{ */ str 87 ext/standard/quot_print.c i = length, p1 = str; buf_size = length; str 100 ext/standard/quot_print.c i = length; p1 = str; p2 = (unsigned char*)ZSTR_VAL(retval); str 148 ext/standard/quot_print.c PHPAPI zend_string *php_quot_print_encode(const unsigned char *str, size_t length) /* {{{ */ str 159 ext/standard/quot_print.c if (((c = *str++) == '\015') && (*str == '\012') && length > 0) { str 161 ext/standard/quot_print.c *d++ = *str++; str 165 ext/standard/quot_print.c if (iscntrl (c) || (c == 0x7f) || (c & 0x80) || (c == '=') || ((c == ' ') && (*str == '\015'))) { str 267 ext/standard/quot_print.c zend_string *str; str 270 ext/standard/quot_print.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &str) != SUCCESS) { str 274 ext/standard/quot_print.c if (!ZSTR_LEN(str)) { str 278 ext/standard/quot_print.c new_str = php_quot_print_encode((unsigned char *)ZSTR_VAL(str), (size_t)ZSTR_LEN(str)); str 24 ext/standard/quot_print.h PHPAPI zend_string *php_quot_print_decode(const unsigned char *str, size_t length, int replace_us_by_ws); str 25 ext/standard/quot_print.h PHPAPI zend_string *php_quot_print_encode(const unsigned char *str, size_t length); str 31 ext/standard/soundex.c char *str; str 63 ext/standard/soundex.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &str, &str_len) == FAILURE) { str 77 ext/standard/soundex.c code = toupper((int)(unsigned char)str[i]); str 1304 ext/standard/streamsfuncs.c char *str = NULL; str 1311 ext/standard/streamsfuncs.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "rl|s", &zstream, &max_length, &str, &str_len) == FAILURE) { str 1325 ext/standard/streamsfuncs.c if ((buf = php_stream_get_record(stream, max_length, str, str_len))) { str 160 ext/standard/string.c zend_string *str = zend_string_alloc(target_length, 0); str 161 ext/standard/string.c unsigned char *ret = (unsigned char *)ZSTR_VAL(str); str 174 ext/standard/string.c zend_string_free(str); str 183 ext/standard/string.c zend_string_free(str); str 190 ext/standard/string.c return str; str 799 ext/standard/string.c PHPAPI zend_string *php_trim(zend_string *str, char *what, size_t what_len, int mode) str 801 ext/standard/string.c const char *c = ZSTR_VAL(str); str 802 ext/standard/string.c size_t len = ZSTR_LEN(str); str 888 ext/standard/string.c if (ZSTR_LEN(str) == len) { str 889 ext/standard/string.c return zend_string_copy(str); str 901 ext/standard/string.c zend_string *str; str 905 ext/standard/string.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|S", &str, &what) == FAILURE) { str 910 ext/standard/string.c Z_PARAM_STR(str) str 916 ext/standard/string.c ZVAL_STR(return_value, php_trim(str, (what ? ZSTR_VAL(what) : NULL), (what ? ZSTR_LEN(what) : 0), mode)); str 1086 ext/standard/string.c PHPAPI void php_explode(const zend_string *delim, zend_string *str, zval *return_value, zend_long limit) str 1088 ext/standard/string.c char *p1 = ZSTR_VAL(str); str 1089 ext/standard/string.c char *endp = ZSTR_VAL(str) + ZSTR_LEN(str); str 1090 ext/standard/string.c char *p2 = (char *) php_memnstr(ZSTR_VAL(str), ZSTR_VAL(delim), ZSTR_LEN(delim), endp); str 1094 ext/standard/string.c ZVAL_STR_COPY(&tmp, str); str 1114 ext/standard/string.c PHPAPI void php_explode_negative_limit(const zend_string *delim, zend_string *str, zval *return_value, zend_long limit) str 1117 ext/standard/string.c char *p1 = ZSTR_VAL(str); str 1118 ext/standard/string.c char *endp = ZSTR_VAL(str) + ZSTR_LEN(str); str 1119 ext/standard/string.c char *p2 = (char *) php_memnstr(ZSTR_VAL(str), ZSTR_VAL(delim), ZSTR_LEN(delim), endp); str 1158 ext/standard/string.c zend_string *str, *delim; str 1163 ext/standard/string.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "SS|l", &delim, &str, &limit) == FAILURE) { str 1169 ext/standard/string.c Z_PARAM_STR(str) str 1182 ext/standard/string.c if (ZSTR_LEN(str) == 0) { str 1191 ext/standard/string.c php_explode(delim, str, return_value, limit); str 1193 ext/standard/string.c php_explode_negative_limit(delim, str, return_value, limit); str 1195 ext/standard/string.c ZVAL_STR_COPY(&tmp, str); str 1211 ext/standard/string.c zend_string *str; str 1249 ext/standard/string.c str = zend_string_safe_alloc(numelems - 1, ZSTR_LEN(delim), len, 0); str 1250 ext/standard/string.c cptr = ZSTR_VAL(str) + ZSTR_LEN(str); str 1271 ext/standard/string.c memcpy(ZSTR_VAL(str), ZSTR_VAL(*strptr), ZSTR_LEN(*strptr)); str 1281 ext/standard/string.c RETURN_NEW_STR(str); str 1336 ext/standard/string.c zend_string *str, *tok = NULL; str 1344 ext/standard/string.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|S", &str, &tok) == FAILURE) { str 1349 ext/standard/string.c Z_PARAM_STR(str) str 1356 ext/standard/string.c tok = str; str 1359 ext/standard/string.c ZVAL_STRINGL(&BG(strtok_zval), ZSTR_VAL(str), ZSTR_LEN(str)); str 1361 ext/standard/string.c BG(strtok_len) = ZSTR_LEN(str); str 1537 ext/standard/string.c zend_string *str; str 1540 ext/standard/string.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &str) == FAILURE) { str 1545 ext/standard/string.c Z_PARAM_STR(str) str 1549 ext/standard/string.c RETURN_STR(php_string_tolower(str)); str 1660 ext/standard/string.c char *str; str 1665 ext/standard/string.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|l", &str, &str_len, &levels) == FAILURE) { str 1669 ext/standard/string.c ret = zend_string_init(str, str_len, 0); str 2330 ext/standard/string.c zend_string *str; str 2336 ext/standard/string.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|ls", &str, &chunklen, &end, &endlen) == FAILURE) { str 2345 ext/standard/string.c if ((size_t)chunklen > ZSTR_LEN(str)) { str 2347 ext/standard/string.c result = zend_string_safe_alloc(ZSTR_LEN(str), 1, endlen, 0); str 2348 ext/standard/string.c memcpy(ZSTR_VAL(result), ZSTR_VAL(str), ZSTR_LEN(str)); str 2349 ext/standard/string.c memcpy(ZSTR_VAL(result) + ZSTR_LEN(str), end, endlen); str 2354 ext/standard/string.c if (!ZSTR_LEN(str)) { str 2358 ext/standard/string.c result = php_chunk_split(ZSTR_VAL(str), ZSTR_LEN(str), end, endlen, (size_t)chunklen); str 2372 ext/standard/string.c zend_string *str; str 2377 ext/standard/string.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "Sl|l", &str, &f, &l) == FAILURE) { str 2382 ext/standard/string.c Z_PARAM_STR(str) str 2390 ext/standard/string.c if ((l < 0 && (size_t)(-l) > ZSTR_LEN(str))) { str 2392 ext/standard/string.c } else if (l > (zend_long)ZSTR_LEN(str)) { str 2393 ext/standard/string.c l = ZSTR_LEN(str); str 2396 ext/standard/string.c l = ZSTR_LEN(str); str 2399 ext/standard/string.c if (f > (zend_long)ZSTR_LEN(str)) { str 2401 ext/standard/string.c } else if (f < 0 && -f > ZSTR_LEN(str)) { str 2405 ext/standard/string.c if (l < 0 && (l + (zend_long)ZSTR_LEN(str) - f) < 0) { str 2413 ext/standard/string.c f = (zend_long)ZSTR_LEN(str) + f; str 2423 ext/standard/string.c l = ((zend_long)ZSTR_LEN(str) - f) + l; str 2429 ext/standard/string.c if (f > (zend_long)ZSTR_LEN(str)) { str 2433 ext/standard/string.c if ((f + l) > (zend_long)ZSTR_LEN(str)) { str 2434 ext/standard/string.c l = ZSTR_LEN(str) - f; str 2437 ext/standard/string.c RETURN_STRINGL(ZSTR_VAL(str) + f, l); str 2445 ext/standard/string.c zval *str; str 2456 ext/standard/string.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "zzz|z/", &str, &repl, &from, &len) == FAILURE) { str 2460 ext/standard/string.c if (Z_TYPE_P(str) != IS_ARRAY) { str 2461 ext/standard/string.c convert_to_string_ex(str); str 2475 ext/standard/string.c if (Z_TYPE_P(str) != IS_ARRAY) { str 2476 ext/standard/string.c l = Z_STRLEN_P(str); str 2480 ext/standard/string.c if (Z_TYPE_P(str) == IS_STRING) { str 2486 ext/standard/string.c RETURN_STR_COPY(Z_STR_P(str)); str 2491 ext/standard/string.c RETURN_STR_COPY(Z_STR_P(str)); str 2496 ext/standard/string.c if (Z_TYPE_P(str) != IS_ARRAY) { str 2506 ext/standard/string.c f = (zend_long)Z_STRLEN_P(str) + f; str 2510 ext/standard/string.c } else if (f > Z_STRLEN_P(str)) { str 2511 ext/standard/string.c f = Z_STRLEN_P(str); str 2517 ext/standard/string.c l = ((zend_long)Z_STRLEN_P(str) - f) + l; str 2523 ext/standard/string.c if (l > Z_STRLEN_P(str) || (l < 0 && (size_t)(-l) > Z_STRLEN_P(str))) { str 2524 ext/standard/string.c l = Z_STRLEN_P(str); str 2527 ext/standard/string.c if ((f + l) > (zend_long)Z_STRLEN_P(str)) { str 2528 ext/standard/string.c l = Z_STRLEN_P(str) - f; str 2549 ext/standard/string.c result = zend_string_alloc(Z_STRLEN_P(str) - l + ZSTR_LEN(repl_str), 0); str 2551 ext/standard/string.c memcpy(ZSTR_VAL(result), Z_STRVAL_P(str), f); str 2555 ext/standard/string.c memcpy((ZSTR_VAL(result) + f + ZSTR_LEN(repl_str)), Z_STRVAL_P(str) + f + l, Z_STRLEN_P(str) - f - l); str 2563 ext/standard/string.c RETURN_STR_COPY(Z_STR_P(str)); str 2574 ext/standard/string.c ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(str), num_index, str_index, tmp_str) { str 2705 ext/standard/string.c zend_string *str; str 2717 ext/standard/string.c str = zend_string_safe_alloc(2, ZSTR_LEN(old), 0, 0); str 2719 ext/standard/string.c for (p = ZSTR_VAL(old), q = ZSTR_VAL(str); p != old_end; p++) { str 2742 ext/standard/string.c RETURN_NEW_STR(zend_string_truncate(str, q - ZSTR_VAL(str), 0)); str 2750 ext/standard/string.c char *str; str 2754 ext/standard/string.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &str, &str_len) == FAILURE) { str 2759 ext/standard/string.c Z_PARAM_STRING(str, str_len) str 2763 ext/standard/string.c RETURN_LONG((unsigned char) str[0]); str 2800 ext/standard/string.c static void php_ucfirst(char *str) str 2803 ext/standard/string.c r = str; str 2812 ext/standard/string.c zend_string *str; str 2815 ext/standard/string.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &str) == FAILURE) { str 2820 ext/standard/string.c Z_PARAM_STR(str) str 2824 ext/standard/string.c if (!ZSTR_LEN(str)) { str 2828 ext/standard/string.c ZVAL_STRINGL(return_value, ZSTR_VAL(str), ZSTR_LEN(str)); str 2835 ext/standard/string.c static void php_lcfirst(char *str) str 2838 ext/standard/string.c r = str; str 2847 ext/standard/string.c zend_string *str; str 2849 ext/standard/string.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &str) == FAILURE) { str 2853 ext/standard/string.c if (!ZSTR_LEN(str)) { str 2857 ext/standard/string.c ZVAL_STRINGL(return_value, ZSTR_VAL(str), ZSTR_LEN(str)); str 2866 ext/standard/string.c zend_string *str; str 2873 ext/standard/string.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|s", &str, &delims, &delims_len) == FAILURE) { str 2878 ext/standard/string.c Z_PARAM_STR(str) str 2884 ext/standard/string.c if (!ZSTR_LEN(str)) { str 2890 ext/standard/string.c ZVAL_STRINGL(return_value, ZSTR_VAL(str), ZSTR_LEN(str)); str 2904 ext/standard/string.c PHPAPI char *php_strtr(char *str, size_t len, char *str_from, char *str_to, size_t trlen) str 2909 ext/standard/string.c return str; str 2915 ext/standard/string.c if (str[i] == ch_from) { str 2916 ext/standard/string.c str[i] = ch_to; str 2929 ext/standard/string.c str[i] = xlat[(size_t)(unsigned char) str[i]]; str 2933 ext/standard/string.c return str; str 2939 ext/standard/string.c static zend_string *php_strtr_ex(zend_string *str, char *str_from, char *str_to, size_t trlen) str 2945 ext/standard/string.c return zend_string_copy(str); str 2950 ext/standard/string.c for (i = 0; i < ZSTR_LEN(str); i++) { str 2951 ext/standard/string.c if (ZSTR_VAL(str)[i] == ch_from) { str 2952 ext/standard/string.c new_str = zend_string_alloc(ZSTR_LEN(str), 0); str 2953 ext/standard/string.c memcpy(ZSTR_VAL(new_str), ZSTR_VAL(str), i); str 2958 ext/standard/string.c for (; i < ZSTR_LEN(str); i++) { str 2959 ext/standard/string.c ZSTR_VAL(new_str)[i] = (ZSTR_VAL(str)[i] != ch_from) ? ZSTR_VAL(str)[i] : ch_to; str 2970 ext/standard/string.c for (i = 0; i < ZSTR_LEN(str); i++) { str 2971 ext/standard/string.c if (ZSTR_VAL(str)[i] != xlat[(size_t)(unsigned char) ZSTR_VAL(str)[i]]) { str 2972 ext/standard/string.c new_str = zend_string_alloc(ZSTR_LEN(str), 0); str 2973 ext/standard/string.c memcpy(ZSTR_VAL(new_str), ZSTR_VAL(str), i); str 2974 ext/standard/string.c ZSTR_VAL(new_str)[i] = xlat[(size_t)(unsigned char) ZSTR_VAL(str)[i]]; str 2979 ext/standard/string.c for (;i < ZSTR_LEN(str); i++) { str 2980 ext/standard/string.c ZSTR_VAL(new_str)[i] = xlat[(size_t)(unsigned char) ZSTR_VAL(str)[i]]; str 2985 ext/standard/string.c return zend_string_copy(str); str 2996 ext/standard/string.c char *str = ZSTR_VAL(input); str 3087 ext/standard/string.c key = str + pos; str 3098 ext/standard/string.c smart_str_appendl(&result, str + old_pos, pos - old_pos); str 3113 ext/standard/string.c smart_str_appendl(&result, str + old_pos, slen - old_pos); str 3130 ext/standard/string.c static zend_string* php_char_to_str_ex(zend_string *str, char from, char *to, size_t to_len, int case_sensitivity, zend_long *replace_count) str 3135 ext/standard/string.c char *source, *target, *source_end= ZSTR_VAL(str) + ZSTR_LEN(str); str 3138 ext/standard/string.c char *p = ZSTR_VAL(str), *e = p + ZSTR_LEN(str); str 3145 ext/standard/string.c for (source = ZSTR_VAL(str); source < source_end; source++) { str 3153 ext/standard/string.c return zend_string_copy(str); str 3157 ext/standard/string.c result = zend_string_safe_alloc(char_count, to_len - 1, ZSTR_LEN(str), 0); str 3159 ext/standard/string.c result = zend_string_alloc(ZSTR_LEN(str) - char_count, 0); str 3164 ext/standard/string.c char *p = ZSTR_VAL(str), *e = p + ZSTR_LEN(str), *s = ZSTR_VAL(str); str 3181 ext/standard/string.c for (source = ZSTR_VAL(str); source < source_end; source++) { str 3202 ext/standard/string.c char *needle, size_t needle_len, char *str, size_t str_len, zend_long *replace_count) str 3217 ext/standard/string.c memcpy(ZSTR_VAL(new_str) + (r - ZSTR_VAL(haystack)), str, str_len); str 3249 ext/standard/string.c memcpy(e, str, str_len); str 3266 ext/standard/string.c new_str = zend_string_init(str, str_len, 0); str 3276 ext/standard/string.c zend_string *needle, char *str, size_t str_len, zend_long *replace_count) str 3292 ext/standard/string.c memcpy(ZSTR_VAL(new_str) + (r - lc_haystack), str, str_len); str 3332 ext/standard/string.c memcpy(e, str, str_len); str 3359 ext/standard/string.c new_str = zend_string_init(str, str_len, 0); str 3369 ext/standard/string.c PHPAPI zend_string *php_str_to_str(char *haystack, size_t length, char *needle, size_t needle_len, char *str, size_t str_len) str 3381 ext/standard/string.c memcpy(r, str, str_len); str 3415 ext/standard/string.c memcpy(e, str, str_len); str 3432 ext/standard/string.c new_str = zend_string_init(str, str_len, 0); str 3444 ext/standard/string.c zend_string *str; str 3450 ext/standard/string.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "Sz|s", &str, &from, &to, &to_len) == FAILURE) { str 3455 ext/standard/string.c Z_PARAM_STR(str) str 3468 ext/standard/string.c if (ZSTR_LEN(str) == 0) { str 3476 ext/standard/string.c RETURN_STR_COPY(str); str 3491 ext/standard/string.c RETVAL_STR_COPY(str); str 3493 ext/standard/string.c RETVAL_STR(php_char_to_str_ex(str, str 3501 ext/standard/string.c RETVAL_STR(php_str_to_str_ex(str, str 3510 ext/standard/string.c php_strtr_array(return_value, str, pats); str 3515 ext/standard/string.c RETURN_STR(php_strtr_ex(str, str 3527 ext/standard/string.c zend_string *str; str 3531 ext/standard/string.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &str) == FAILURE) { str 3535 ext/standard/string.c n = zend_string_alloc(ZSTR_LEN(str), 0); str 3538 ext/standard/string.c e = ZSTR_VAL(str) + ZSTR_LEN(str); str 3540 ext/standard/string.c while (--e >= ZSTR_VAL(str)) { str 3634 ext/standard/string.c PHPAPI void php_stripslashes(zend_string *str) str 3639 ext/standard/string.c s = ZSTR_VAL(str); str 3640 ext/standard/string.c t = ZSTR_VAL(str); str 3641 ext/standard/string.c l = ZSTR_LEN(str); str 3646 ext/standard/string.c ZSTR_LEN(str)--; str 3672 ext/standard/string.c zend_string *str, *what; str 3674 ext/standard/string.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "SS", &str, &what) == FAILURE) { str 3678 ext/standard/string.c if (ZSTR_LEN(str) == 0) { str 3683 ext/standard/string.c RETURN_STRINGL(ZSTR_VAL(str), ZSTR_LEN(str)); str 3686 ext/standard/string.c RETURN_STR(php_addcslashes(str, 0, ZSTR_VAL(what), ZSTR_LEN(what))); str 3694 ext/standard/string.c zend_string *str; str 3697 ext/standard/string.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &str) == FAILURE) { str 3702 ext/standard/string.c Z_PARAM_STR(str) str 3706 ext/standard/string.c if (ZSTR_LEN(str) == 0) { str 3710 ext/standard/string.c RETURN_STR(php_addslashes(str, 0)); str 3718 ext/standard/string.c zend_string *str; str 3720 ext/standard/string.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &str) == FAILURE) { str 3724 ext/standard/string.c ZVAL_STRINGL(return_value, ZSTR_VAL(str), ZSTR_LEN(str)); str 3733 ext/standard/string.c zend_string *str; str 3735 ext/standard/string.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &str) == FAILURE) { str 3739 ext/standard/string.c ZVAL_STRINGL(return_value, ZSTR_VAL(str), ZSTR_LEN(str)); str 3764 ext/standard/string.c PHPAPI void php_stripcslashes(zend_string *str) str 3767 ext/standard/string.c size_t nlen = ZSTR_LEN(str), i; str 3770 ext/standard/string.c for (source = (char*)ZSTR_VAL(str), end = source + ZSTR_LEN(str), target = ZSTR_VAL(str); source < end; source++) { str 3821 ext/standard/string.c ZSTR_LEN(str) = nlen; str 3827 ext/standard/string.c PHPAPI zend_string *php_addcslashes(zend_string *str, int should_free, char *what, size_t wlength) str 3834 ext/standard/string.c zend_string *new_str = zend_string_safe_alloc(4, ZSTR_LEN(str), 0, 0); str 3838 ext/standard/string.c for (source = (char*)ZSTR_VAL(str), end = source + ZSTR_LEN(str), target = ZSTR_VAL(new_str); source < end; source++) { str 3861 ext/standard/string.c if (newlen < ZSTR_LEN(str) * 4) { str 3865 ext/standard/string.c zend_string_release(str); str 3873 ext/standard/string.c PHPAPI zend_string *php_addslashes(zend_string *str, int should_free) str 3881 ext/standard/string.c if (!str) { str 3885 ext/standard/string.c source = ZSTR_VAL(str); str 3886 ext/standard/string.c end = source + ZSTR_LEN(str); str 3902 ext/standard/string.c return zend_string_copy(str); str 3905 ext/standard/string.c return str; str 3908 ext/standard/string.c offset = source - (char *)ZSTR_VAL(str); str 3909 ext/standard/string.c new_str = zend_string_safe_alloc(2, ZSTR_LEN(str) - offset, offset, 0); str 3910 ext/standard/string.c memcpy(ZSTR_VAL(new_str), ZSTR_VAL(str), offset); str 3934 ext/standard/string.c zend_string_release(str); str 4198 ext/standard/string.c char *str; str 4206 ext/standard/string.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|l", &str, &str_len, &max_chars) == FAILURE) { str 4214 ext/standard/string.c tmp = str; str 4238 ext/standard/string.c *target = str[i-1]; str 4287 ext/standard/string.c *target = str[i-1]; str 4385 ext/standard/string.c zend_string *str; str 4392 ext/standard/string.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|b", &str, &is_xhtml) == FAILURE) { str 4397 ext/standard/string.c Z_PARAM_STR(str) str 4403 ext/standard/string.c tmp = ZSTR_VAL(str); str 4404 ext/standard/string.c end = ZSTR_VAL(str) + ZSTR_LEN(str); str 4425 ext/standard/string.c RETURN_STR_COPY(str); str 4431 ext/standard/string.c result = zend_string_safe_alloc(repl_cnt, repl_len, ZSTR_LEN(str), 0); str 4435 ext/standard/string.c tmp = ZSTR_VAL(str); str 4473 ext/standard/string.c zend_string *str; str 4478 ext/standard/string.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|z", &str, &allow) == FAILURE) { str 4489 ext/standard/string.c buf = zend_string_init(ZSTR_VAL(str), ZSTR_LEN(str), 0); str 4490 ext/standard/string.c ZSTR_LEN(buf) = php_strip_tags_ex(ZSTR_VAL(buf), ZSTR_LEN(str), NULL, allowed_tags, allowed_tags_len, 0); str 4990 ext/standard/string.c zend_string *str; str 4995 ext/standard/string.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|sss", &str, &delim_str, &delim_len, str 5004 ext/standard/string.c php_fgetcsv(NULL, delim, enc, esc, ZSTR_LEN(str), ZSTR_VAL(str), return_value); str 5419 ext/standard/string.c char *str, *format; str 5423 ext/standard/string.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss*", &str, &str_len, &format, &format_len, str 5428 ext/standard/string.c result = php_sscanf_internal(str, format, num_args, args, 0, return_value); str 5457 ext/standard/string.c static void php_string_shuffle(char *str, zend_long len) /* {{{ */ str 5475 ext/standard/string.c temp = str[n_left]; str 5476 ext/standard/string.c str[n_left] = str[rnd_idx]; str 5477 ext/standard/string.c str[rnd_idx] = temp; str 5513 ext/standard/string.c zend_string *str; str 5518 ext/standard/string.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|ls", &str, &type, &char_list, &char_list_len) == FAILURE) { str 5526 ext/standard/string.c if (!ZSTR_LEN(str)) { str 5531 ext/standard/string.c if (!ZSTR_LEN(str)) { str 5545 ext/standard/string.c p = ZSTR_VAL(str); str 5546 ext/standard/string.c e = ZSTR_VAL(str) + ZSTR_LEN(str); str 5569 ext/standard/string.c add_index_stringl(return_value, (s - ZSTR_VAL(str)), s, p - s); str 5595 ext/standard/string.c zend_string *str; str 5616 ext/standard/string.c str = zend_string_safe_alloc(format_len, 1, 1024, 0); str 5617 ext/standard/string.c if ((res_len = strfmon(ZSTR_VAL(str), ZSTR_LEN(str), format, value)) < 0) { str 5618 ext/standard/string.c zend_string_free(str); str 5621 ext/standard/string.c ZSTR_LEN(str) = (size_t)res_len; str 5622 ext/standard/string.c ZSTR_VAL(str)[ZSTR_LEN(str)] = '\0'; str 5624 ext/standard/string.c RETURN_NEW_STR(zend_string_truncate(str, ZSTR_LEN(str), 0)); str 5633 ext/standard/string.c zend_string *str; str 5638 ext/standard/string.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|l", &str, &split_length) == FAILURE) { str 5648 ext/standard/string.c if (0 == ZSTR_LEN(str) || (size_t)split_length >= ZSTR_LEN(str)) { str 5650 ext/standard/string.c add_next_index_stringl(return_value, ZSTR_VAL(str), ZSTR_LEN(str)); str 5654 ext/standard/string.c array_init_size(return_value, (uint32_t)(((ZSTR_LEN(str) - 1) / split_length) + 1)); str 5656 ext/standard/string.c n_reg_segments = ZSTR_LEN(str) / split_length; str 5657 ext/standard/string.c p = ZSTR_VAL(str); str 5664 ext/standard/string.c if (p != (ZSTR_VAL(str) + ZSTR_LEN(str))) { str 5665 ext/standard/string.c add_next_index_stringl(return_value, p, (ZSTR_VAL(str) + ZSTR_LEN(str) - p)); str 64 ext/standard/url.c PHPAPI char *php_replace_controlchars_ex(char *str, size_t len) str 66 ext/standard/url.c unsigned char *s = (unsigned char *)str; str 67 ext/standard/url.c unsigned char *e = (unsigned char *)str + len; str 69 ext/standard/url.c if (!str) { str 81 ext/standard/url.c return (str); str 85 ext/standard/url.c PHPAPI char *php_replace_controlchars(char *str) str 87 ext/standard/url.c return php_replace_controlchars_ex(str, strlen(str)); str 90 ext/standard/url.c PHPAPI php_url *php_url_parse(char const *str) str 92 ext/standard/url.c return php_url_parse_ex(str, strlen(str)); str 97 ext/standard/url.c PHPAPI php_url *php_url_parse_ex(char const *str, size_t length) str 103 ext/standard/url.c s = str; str 376 ext/standard/url.c char *str; str 381 ext/standard/url.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|l", &str, &str_len, &key) == FAILURE) { str 385 ext/standard/url.c resource = php_url_parse_ex(str, str_len); str 578 ext/standard/url.c PHPAPI size_t php_url_decode(char *str, size_t len) str 580 ext/standard/url.c char *dest = str; str 581 ext/standard/url.c char *data = str; str 603 ext/standard/url.c return dest - str; str 612 ext/standard/url.c zend_string *str; str 614 ext/standard/url.c str = zend_string_alloc(3 * len, 0); str 616 ext/standard/url.c ZSTR_VAL(str)[y] = (unsigned char) s[x]; str 618 ext/standard/url.c if ((ZSTR_VAL(str)[y] < '0' && ZSTR_VAL(str)[y] != '-' && ZSTR_VAL(str)[y] != '.') || str 619 ext/standard/url.c (ZSTR_VAL(str)[y] < 'A' && ZSTR_VAL(str)[y] > '9') || str 620 ext/standard/url.c (ZSTR_VAL(str)[y] > 'Z' && ZSTR_VAL(str)[y] < 'a' && ZSTR_VAL(str)[y] != '_') || str 621 ext/standard/url.c (ZSTR_VAL(str)[y] > 'z' && ZSTR_VAL(str)[y] != '~')) { str 622 ext/standard/url.c ZSTR_VAL(str)[y++] = '%'; str 623 ext/standard/url.c ZSTR_VAL(str)[y++] = hexchars[(unsigned char) s[x] >> 4]; str 624 ext/standard/url.c ZSTR_VAL(str)[y] = hexchars[(unsigned char) s[x] & 15]; str 626 ext/standard/url.c if (!isalnum(ZSTR_VAL(str)[y]) && strchr("_-.~", ZSTR_VAL(str)[y]) != NULL) { str 627 ext/standard/url.c ZSTR_VAL(str)[y++] = '%'; str 628 ext/standard/url.c ZSTR_VAL(str)[y++] = hexchars[os_toascii[(unsigned char) s[x]] >> 4]; str 629 ext/standard/url.c ZSTR_VAL(str)[y] = hexchars[os_toascii[(unsigned char) s[x]] & 15]; str 633 ext/standard/url.c ZSTR_VAL(str)[y] = '\0'; str 634 ext/standard/url.c str = zend_string_truncate(str, y, 0); str 636 ext/standard/url.c return str; str 685 ext/standard/url.c PHPAPI size_t php_raw_url_decode(char *str, size_t len) str 687 ext/standard/url.c char *dest = str; str 688 ext/standard/url.c char *data = str; str 707 ext/standard/url.c return dest - str; str 35 ext/standard/url.h PHPAPI php_url *php_url_parse(char const *str); str 36 ext/standard/url.h PHPAPI php_url *php_url_parse_ex(char const *str, size_t length); str 37 ext/standard/url.h PHPAPI size_t php_url_decode(char *str, size_t len); /* return value: length of decoded string */ str 38 ext/standard/url.h PHPAPI size_t php_raw_url_decode(char *str, size_t len); /* return value: length of decoded string */ str 41 ext/standard/url.h PHPAPI char *php_replace_controlchars_ex(char *str, size_t len); str 644 ext/standard/var.c static inline void php_var_serialize_string(smart_str *buf, char *str, size_t len) /* {{{ */ str 649 ext/standard/var.c smart_str_appendl(buf, str, len); str 173 ext/standard/var_unserializer.c zend_string *str = zend_string_alloc(len, 0); str 177 ext/standard/var_unserializer.c zend_string_free(str); str 183 ext/standard/var_unserializer.c zend_string_free(str); str 187 ext/standard/var_unserializer.c ZSTR_VAL(str)[i] = (char)**p; str 200 ext/standard/var_unserializer.c zend_string_free(str); str 204 ext/standard/var_unserializer.c ZSTR_VAL(str)[i] = (char)ch; str 208 ext/standard/var_unserializer.c ZSTR_VAL(str)[i] = 0; str 209 ext/standard/var_unserializer.c ZSTR_LEN(str) = i; str 210 ext/standard/var_unserializer.c return str; str 654 ext/standard/var_unserializer.c char *str; str 677 ext/standard/var_unserializer.c str = (char*)YYCURSOR; str 690 ext/standard/var_unserializer.c len3 = strspn(str, "0123456789_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377\\"); str 697 ext/standard/var_unserializer.c class_name = zend_string_init(str, len, 0); str 890 ext/standard/var_unserializer.c zend_string *str; str 899 ext/standard/var_unserializer.c if ((str = unserialize_str(&YYCURSOR, len, maxlen)) == NULL) { str 904 ext/standard/var_unserializer.c zend_string_free(str); str 912 ext/standard/var_unserializer.c ZVAL_STR(rval, str); str 937 ext/standard/var_unserializer.c char *str; str 946 ext/standard/var_unserializer.c str = (char*)YYCURSOR; str 958 ext/standard/var_unserializer.c ZVAL_STRINGL(rval, str, len); str 51 ext/wddx/php_wddx_api.h #define php_wddx_add_chunk(packet, str) smart_str_appends(packet, str) str 52 ext/wddx/php_wddx_api.h #define php_wddx_add_chunk_ex(packet, str, len) smart_str_appendl(packet, str, len) str 53 ext/wddx/php_wddx_api.h #define php_wddx_add_chunk_static(packet, str) smart_str_appendl(packet, str, sizeof(str)-1) str 249 ext/wddx/wddx.c smart_str *str = (smart_str *)rsrc->ptr; str 250 ext/wddx/wddx.c smart_str_free(str); str 251 ext/wddx/wddx.c efree(str); str 263 ext/wddx/wddx.c zend_string *str; str 278 ext/wddx/wddx.c str = zend_string_copy(packet->s); str 281 ext/wddx/wddx.c return str; str 413 ext/wddx/wddx.c zend_string *str = zval_get_string(var); str 414 ext/wddx/wddx.c snprintf(tmp_buf, sizeof(tmp_buf), WDDX_NUMBER, ZSTR_VAL(str)); str 415 ext/wddx/wddx.c zend_string_release(str); str 565 ext/xml/xml.c zend_string *str; str 579 ext/xml/xml.c str = zend_string_init(s, len, 0); str 580 ext/xml/xml.c return str; str 584 ext/xml/xml.c str = zend_string_safe_alloc(len, 4, 0, 0); str 585 ext/xml/xml.c ZSTR_LEN(str) = 0; str 589 ext/xml/xml.c ZSTR_VAL(str)[ZSTR_LEN(str)++] = (char) c; str 591 ext/xml/xml.c ZSTR_VAL(str)[ZSTR_LEN(str)++] = (0xc0 | (c >> 6)); str 592 ext/xml/xml.c ZSTR_VAL(str)[ZSTR_LEN(str)++] = (0x80 | (c & 0x3f)); str 594 ext/xml/xml.c ZSTR_VAL(str)[ZSTR_LEN(str)++] = (0xe0 | (c >> 12)); str 595 ext/xml/xml.c ZSTR_VAL(str)[ZSTR_LEN(str)++] = (0xc0 | ((c >> 6) & 0x3f)); str 596 ext/xml/xml.c ZSTR_VAL(str)[ZSTR_LEN(str)++] = (0x80 | (c & 0x3f)); str 598 ext/xml/xml.c ZSTR_VAL(str)[ZSTR_LEN(str)++] = (0xf0 | (c >> 18)); str 599 ext/xml/xml.c ZSTR_VAL(str)[ZSTR_LEN(str)++] = (0xe0 | ((c >> 12) & 0x3f)); str 600 ext/xml/xml.c ZSTR_VAL(str)[ZSTR_LEN(str)++] = (0xc0 | ((c >> 6) & 0x3f)); str 601 ext/xml/xml.c ZSTR_VAL(str)[ZSTR_LEN(str)++] = (0x80 | (c & 0x3f)); str 606 ext/xml/xml.c ZSTR_VAL(str)[ZSTR_LEN(str)] = '\0'; str 607 ext/xml/xml.c str = zend_string_truncate(str, ZSTR_LEN(str), 0); str 608 ext/xml/xml.c return str; str 619 ext/xml/xml.c zend_string *str; str 629 ext/xml/xml.c str = zend_string_init((char *)s, len, 0); str 630 ext/xml/xml.c return str; str 633 ext/xml/xml.c str = zend_string_alloc(len, 0); str 634 ext/xml/xml.c ZSTR_LEN(str) = 0; str 643 ext/xml/xml.c ZSTR_VAL(str)[ZSTR_LEN(str)++] = decoder ? decoder(c) : c; str 645 ext/xml/xml.c ZSTR_VAL(str)[ZSTR_LEN(str)] = '\0'; str 646 ext/xml/xml.c if (ZSTR_LEN(str) < len) { str 647 ext/xml/xml.c str = zend_string_truncate(str, ZSTR_LEN(str), 0); str 650 ext/xml/xml.c return str; str 704 ext/xml/xml.c zend_string *str; str 706 ext/xml/xml.c str = xml_utf8_decode((const XML_Char *)tag, strlen(tag), parser->target_encoding); str 709 ext/xml/xml.c php_strtoupper(ZSTR_VAL(str), ZSTR_LEN(str)); str 712 ext/xml/xml.c return str; str 1485 ext/xml/xml.c char *str; str 1491 ext/xml/xml.c str = (char *)XML_ErrorString((int)code); str 1492 ext/xml/xml.c if (str) { str 1493 ext/xml/xml.c RETVAL_STRING(str); str 114 ext/xmlrpc/libxmlrpc/simplestring.c string->str = (char*)malloc(SIMPLESTRING_INCR); str 115 ext/xmlrpc/libxmlrpc/simplestring.c if(string->str) { str 116 ext/xmlrpc/libxmlrpc/simplestring.c string->str[0] = 0; str 143 ext/xmlrpc/libxmlrpc/simplestring.c if(string->str) { str 144 ext/xmlrpc/libxmlrpc/simplestring.c string->str[0] = 0; str 168 ext/xmlrpc/libxmlrpc/simplestring.c if(string && string->str) { str 169 ext/xmlrpc/libxmlrpc/simplestring.c my_free(string->str); str 195 ext/xmlrpc/libxmlrpc/simplestring.c if(!target->str) { str 205 ext/xmlrpc/libxmlrpc/simplestring.c target->str = (char*)realloc(target->str, newsize); str 207 ext/xmlrpc/libxmlrpc/simplestring.c target->size = target->str ? newsize : 0; str 210 ext/xmlrpc/libxmlrpc/simplestring.c if(target->str) { str 212 ext/xmlrpc/libxmlrpc/simplestring.c memcpy(target->str + target->len, source, add_len); str 215 ext/xmlrpc/libxmlrpc/simplestring.c target->str[target->len] = 0; /* null terminate */ str 52 ext/xmlrpc/libxmlrpc/simplestring.h char* str; /* string buf */ str 448 ext/xmlrpc/libxmlrpc/xml_element.c char* escaped_str = el->text.str; str 452 ext/xmlrpc/libxmlrpc/xml_element.c escaped_str = xml_elem_entity_escape(el->text.str, buflen, &buflen, options->escaping ); str 454 ext/xmlrpc/libxmlrpc/xml_element.c escaped_str = el->text.str; str 464 ext/xmlrpc/libxmlrpc/xml_element.c if(escaped_str != el->text.str) { str 548 ext/xmlrpc/libxmlrpc/xml_element.c return buf.str; str 190 ext/xmlrpc/libxmlrpc/xml_element.h #define xml_elem_get_val(el) (char *)((el) ? el->text.str : NULL) str 91 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c XMLRPC_SetValueString(xCurrent, el->text.str, el->text.len); str 94 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c XMLRPC_SetValueInt(xCurrent, atoi(el->text.str)); str 97 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c XMLRPC_SetValueBoolean(xCurrent, atoi(el->text.str)); str 100 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c XMLRPC_SetValueDouble(xCurrent, atof(el->text.str)); str 103 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c XMLRPC_SetValueDateTime_ISO8601(xCurrent, el->text.str); str 107 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c base64_decode_xmlrpc(&buf, el->text.str, el->text.len); str 150 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c XMLRPC_RequestSetMethodName(request, el->text.str); str 346 ext/xmlrpc/libxmlrpc/xml_to_soap.c XMLRPC_SetValueString(xCurrent, el->text.str, el->text.len); str 349 ext/xmlrpc/libxmlrpc/xml_to_soap.c XMLRPC_SetValueInt(xCurrent, atoi(el->text.str)); str 352 ext/xmlrpc/libxmlrpc/xml_to_soap.c XMLRPC_SetValueBoolean(xCurrent, atoi(el->text.str)); str 356 ext/xmlrpc/libxmlrpc/xml_to_soap.c XMLRPC_SetValueDouble(xCurrent, atof(el->text.str)); str 362 ext/xmlrpc/libxmlrpc/xml_to_soap.c XMLRPC_SetValueDateTime_ISO8601(xCurrent, el->text.str); str 366 ext/xmlrpc/libxmlrpc/xml_to_soap.c base64_decode_xmlrpc(&buf, el->text.str, el->text.len); str 123 ext/xmlrpc/libxmlrpc/xml_to_xmlrpc.c XMLRPC_SetValueString(current_val, el->text.str, el->text.len); str 126 ext/xmlrpc/libxmlrpc/xml_to_xmlrpc.c XMLRPC_SetValueID_Case(current_val, el->text.str, 0, xmlrpc_case_exact); str 129 ext/xmlrpc/libxmlrpc/xml_to_xmlrpc.c XMLRPC_SetValueInt(current_val, atoi(el->text.str)); str 132 ext/xmlrpc/libxmlrpc/xml_to_xmlrpc.c XMLRPC_SetValueBoolean(current_val, atoi(el->text.str)); str 135 ext/xmlrpc/libxmlrpc/xml_to_xmlrpc.c XMLRPC_SetValueDouble(current_val, atof(el->text.str)); str 138 ext/xmlrpc/libxmlrpc/xml_to_xmlrpc.c XMLRPC_SetValueDateTime_ISO8601(current_val, el->text.str); str 142 ext/xmlrpc/libxmlrpc/xml_to_xmlrpc.c base64_decode_xmlrpc(&buf, el->text.str, el->text.len); str 161 ext/xmlrpc/libxmlrpc/xml_to_xmlrpc.c XMLRPC_RequestSetMethodName(request, el->text.str); str 372 ext/xmlrpc/libxmlrpc/xmlrpc.c return request->methodName.str; str 395 ext/xmlrpc/libxmlrpc/xmlrpc.c return request ? request->methodName.str : NULL; str 871 ext/xmlrpc/libxmlrpc/xmlrpc.c simplestring_init(&v->str); str 911 ext/xmlrpc/libxmlrpc/xmlrpc.c value->id.str[i] = str 914 ext/xmlrpc/libxmlrpc/xmlrpc.c str[i]) : toupper (value-> str 916 ext/xmlrpc/libxmlrpc/xmlrpc.c str[i]); str 920 ext/xmlrpc/libxmlrpc/xmlrpc.c pRetval = value->id.str; str 956 ext/xmlrpc/libxmlrpc/xmlrpc.c simplestring_clear(&value->str); str 957 ext/xmlrpc/libxmlrpc/xmlrpc.c (len > 0) ? simplestring_addn(&value->str, val, len) : str 958 ext/xmlrpc/libxmlrpc/xmlrpc.c simplestring_add(&value->str, val); str 960 ext/xmlrpc/libxmlrpc/xmlrpc.c pRetval = (char *)value->str.str; str 1278 ext/xmlrpc/libxmlrpc/xmlrpc.c if(xIter && xIter->id.str) { str 1280 ext/xmlrpc/libxmlrpc/xmlrpc.c if(!strcmp(xIter->id.str, id)) { str 1285 ext/xmlrpc/libxmlrpc/xmlrpc.c if(!strcasecmp(xIter->id.str, id)) { str 1451 ext/xmlrpc/libxmlrpc/xmlrpc.c if(value->id.str) { str 1452 ext/xmlrpc/libxmlrpc/xmlrpc.c printf ("decremented refcount of %s, now %i\n", value->id.str, str 1500 ext/xmlrpc/libxmlrpc/xmlrpc.c if(value->id.str) { str 1501 ext/xmlrpc/libxmlrpc/xmlrpc.c printf("free'd %s\n", value->id.str); str 1508 ext/xmlrpc/libxmlrpc/xmlrpc.c simplestring_free(&value->str); str 1587 ext/xmlrpc/libxmlrpc/xmlrpc.c if(value->id.str) { str 1588 ext/xmlrpc/libxmlrpc/xmlrpc.c printf ("incremented refcount of %s, now %i\n", value->id.str, str 1630 ext/xmlrpc/libxmlrpc/xmlrpc.c XMLRPC_SetValueID (xReturn, xSource->id.str, xSource->id.len); str 1640 ext/xmlrpc/libxmlrpc/xmlrpc.c XMLRPC_SetValueString (xReturn, xSource->str.str, xSource->str.len); str 1734 ext/xmlrpc/libxmlrpc/xmlrpc.c simplestring_clear(&value->str); str 1735 ext/xmlrpc/libxmlrpc/xmlrpc.c simplestring_add(&value->str, s); str 1801 ext/xmlrpc/libxmlrpc/xmlrpc.c simplestring_clear(&value->str); str 1802 ext/xmlrpc/libxmlrpc/xmlrpc.c (len > 0) ? simplestring_addn(&value->str, s, len) : str 1803 ext/xmlrpc/libxmlrpc/xmlrpc.c simplestring_add(&value->str, s); str 1921 ext/xmlrpc/libxmlrpc/xmlrpc.c return ((value && value->type == xmlrpc_string) ? value->str.str : 0); str 1944 ext/xmlrpc/libxmlrpc/xmlrpc.c return ((value) ? value->str.len : 0); str 2041 ext/xmlrpc/libxmlrpc/xmlrpc.c return ((value && value->type == xmlrpc_base64) ? value->str.str : 0); str 2089 ext/xmlrpc/libxmlrpc/xmlrpc.c return ((value && value->type == xmlrpc_datetime) ? value->str.str : 0); str 2113 ext/xmlrpc/libxmlrpc/xmlrpc.c return (const char*)((value && value->id.len) ? value->id.str : 0); str 2576 ext/xmlrpc/libxmlrpc/xmlrpc.c XMLRPC_ServerFindMethod (server, request->methodName.str); str 2583 ext/xmlrpc/libxmlrpc/xmlrpc.c request->methodName.str); str 2813 ext/xmlrpc/libxmlrpc/xmlrpc.c XMLRPC_VectorAppendString (xOutput, "faultString", description.str, str 364 ext/xmlrpc/libxmlrpc/xmlrpc_introspection.c xReturn = describeValue_worker(ptype, name, (desc ? desc : (xSubList ? NULL : el->text.str)), optional, def, xSubList); str 401 ext/xmlrpc/libxmlrpc/xmlrpc_introspection.c xReturn = XMLRPC_CreateValueString(name, el->text.str, el->text.len); str 420 ext/xmlrpc/libxmlrpc/xmlrpc_introspection.c xReturn = XMLRPC_CreateValueString(el->name, el->text.str, el->text.len); str 91 ext/xmlrpc/libxmlrpc/xmlrpc_private.h simplestring str; /* string value buffer */ str 257 ext/xmlrpc/xmlrpc-epi-php.c XMLRPC_VALUE_TYPE xmlrpc_str_as_type(const char* str); str 258 ext/xmlrpc/xmlrpc-epi-php.c XMLRPC_VECTOR_TYPE xmlrpc_str_as_vector_type(const char* str); str 1233 ext/xmlrpc/xmlrpc-epi-php.c XMLRPC_VALUE_TYPE xmlrpc_str_as_type(const char* str) /* {{{ */ str 1238 ext/xmlrpc/xmlrpc-epi-php.c if (str) { str 1240 ext/xmlrpc/xmlrpc-epi-php.c if (!strcmp(str_mapping[i], str)) { str 1250 ext/xmlrpc/xmlrpc-epi-php.c XMLRPC_VECTOR_TYPE xmlrpc_str_as_vector_type(const char* str) /* {{{ */ str 1255 ext/xmlrpc/xmlrpc-epi-php.c if (str) { str 1257 ext/xmlrpc/xmlrpc-epi-php.c if (!strcmp(str_mapping[i], str)) { str 108 ext/xsl/xsltprocessor.c static char *php_xsl_xslt_string_to_xpathexpr(const char *str) str 110 ext/xsl/xsltprocessor.c const xmlChar *string = (const xmlChar *)str; str 187 ext/xsl/xsltprocessor.c char *str; str 250 ext/xsl/xsltprocessor.c str = (char*)xmlXPathCastToString(obj); str 251 ext/xsl/xsltprocessor.c ZVAL_STRING(&args[i], str); str 252 ext/xsl/xsltprocessor.c xmlFree(str); str 290 ext/xsl/xsltprocessor.c str = (char *) xmlXPathCastToString(obj); str 291 ext/xsl/xsltprocessor.c ZVAL_STRING(&args[i], str); str 292 ext/xsl/xsltprocessor.c xmlFree(str); str 266 ext/zip/lib/zip.h char *str; /* string representation or NULL */ str 44 ext/zip/lib/zip_dirent.c static zip_string_t *_zip_dirent_process_ef_utf_8(const zip_dirent_t *de, zip_uint16_t id, zip_string_t *str); str 533 ext/zip/lib/zip_dirent.c _zip_dirent_process_ef_utf_8(const zip_dirent_t *de, zip_uint16_t id, zip_string_t *str) str 542 ext/zip/lib/zip_dirent.c return str; str 546 ext/zip/lib/zip_dirent.c return str; str 552 ext/zip/lib/zip_dirent.c if (_zip_string_crc32(str) == ef_crc) { str 557 ext/zip/lib/zip_dirent.c _zip_string_free(str); str 558 ext/zip/lib/zip_dirent.c str = ef_str; str 564 ext/zip/lib/zip_dirent.c return str; str 830 ext/zip/lib/zip_dirent.c _zip_ef_utf8(zip_uint16_t id, zip_string_t *str, zip_error_t *error) str 837 ext/zip/lib/zip_dirent.c if ((raw=_zip_string_get(str, &len, ZIP_FL_ENC_RAW, NULL)) == NULL) { str 853 ext/zip/lib/zip_dirent.c _zip_buffer_put_32(buffer, _zip_string_crc32(str)); str 54 ext/zip/lib/zip_error.c free(err->str); str 55 ext/zip/lib/zip_error.c err->str = NULL; str 64 ext/zip/lib/zip_error.c err->str = NULL; str 83 ext/zip/lib/zip_error_strerror.c err->str = s; str 44 ext/zip/lib/zip_file_get_comment.c const zip_uint8_t *str; str 49 ext/zip/lib/zip_file_get_comment.c if ((str=_zip_string_get(de->comment, &len, flags, &za->error)) == NULL) str 55 ext/zip/lib/zip_file_get_comment.c return (const char *)str; str 45 ext/zip/lib/zip_get_archive_comment.c const zip_uint8_t *str; str 52 ext/zip/lib/zip_get_archive_comment.c if ((str=_zip_string_get(comment, &len, flags, &za->error)) == NULL) str 58 ext/zip/lib/zip_get_archive_comment.c return (const char *)str; str 51 ext/zip/lib/zip_get_name.c const zip_uint8_t *str; str 56 ext/zip/lib/zip_get_name.c if ((str=_zip_string_get(de->filename, NULL, flags, error)) == NULL) str 59 ext/zip/lib/zip_get_name.c return (const char *)str; str 45 ext/zip/lib/zip_set_name.c zip_string_t *str; str 63 ext/zip/lib/zip_set_name.c if ((str=_zip_string_new((const zip_uint8_t *)name, (zip_uint16_t)strlen(name), flags, &za->error)) == NULL) str 65 ext/zip/lib/zip_set_name.c if ((flags & ZIP_FL_ENCODING_ALL) == ZIP_FL_ENC_GUESS && _zip_guess_encoding(str, ZIP_ENCODING_UNKNOWN) == ZIP_ENCODING_UTF8_GUESSED) str 66 ext/zip/lib/zip_set_name.c str->encoding = ZIP_ENCODING_UTF8_KNOWN; str 69 ext/zip/lib/zip_set_name.c str = NULL; str 73 ext/zip/lib/zip_set_name.c _zip_string_free(str); str 80 ext/zip/lib/zip_set_name.c _zip_string_free(str); str 87 ext/zip/lib/zip_set_name.c same_as_orig = _zip_string_equal(e->orig->filename, str); str 94 ext/zip/lib/zip_set_name.c _zip_string_free(str); str 99 ext/zip/lib/zip_set_name.c if ((new_name = _zip_string_get(same_as_orig ? e->orig->filename : str, NULL, 0, &za->error)) == NULL) { str 100 ext/zip/lib/zip_set_name.c _zip_string_free(str); str 116 ext/zip/lib/zip_set_name.c _zip_string_free(str); str 125 ext/zip/lib/zip_set_name.c _zip_string_free(str); str 147 ext/zip/lib/zip_set_name.c _zip_string_free(str); str 154 ext/zip/lib/zip_set_name.c e->changes->filename = str; str 40 ext/zip/lib/zip_source_win32a.c static void * _win32_strdup_a(const void *str); str 77 ext/zip/lib/zip_source_win32a.c _win32_strdup_a(const void *str) str 79 ext/zip/lib/zip_source_win32a.c return strdup((const char *)str); str 40 ext/zip/lib/zip_source_win32w.c static void * _win32_strdup_w(const void *str); str 77 ext/zip/lib/zip_source_win32w.c _win32_strdup_w(const void *str) str 79 ext/zip/lib/zip_source_win32w.c return _wcsdup((const wchar_t *)str); str 117 ext/zip/lib/zip_utf-8.c _zip_guess_encoding(zip_string_t *str, zip_encoding_type_t expected_encoding) str 123 ext/zip/lib/zip_utf-8.c if (str == NULL) str 126 ext/zip/lib/zip_utf-8.c name = str->raw; str 128 ext/zip/lib/zip_utf-8.c if (str->encoding != ZIP_ENCODING_UNKNOWN) str 129 ext/zip/lib/zip_utf-8.c enc = str->encoding; str 132 ext/zip/lib/zip_utf-8.c for (i=0; i<str->length; i++) { str 148 ext/zip/lib/zip_utf-8.c if (i + ulen >= str->length) { str 164 ext/zip/lib/zip_utf-8.c str->encoding = enc; str 168 ext/zip/lib/zip_utf-8.c str->encoding = enc = ZIP_ENCODING_UTF8_KNOWN; str 763 ext/zlib/zlib.c zend_string *str = Z_STR_P(option_buffer); str 767 ext/zlib/zlib.c for (i = 0; i < ZSTR_LEN(str); i++) { str 768 ext/zlib/zlib.c if (ZSTR_VAL(str)[i]) { str 782 ext/zlib/zlib.c *dict = emalloc(ZSTR_LEN(str)); str 783 ext/zlib/zlib.c memcpy(*dict, ZSTR_VAL(str), ZSTR_LEN(str)); str 784 ext/zlib/zlib.c *dictlen = ZSTR_LEN(str); str 1266 ext/zlib/zlib.c ZEND_ARG_INFO(0, str) str 971 main/SAPI.c SAPI_API int sapi_register_treat_data(void (*treat_data)(int arg, char *str, zval *destArray)) str 199 main/SAPI.h SAPI_API int sapi_register_treat_data(void (*treat_data)(int arg, char *str, zval *destArray)); str 230 main/SAPI.h size_t (*ub_write)(const char *str, size_t str_length); str 255 main/SAPI.h void (*treat_data)(int arg, char *str, zval *destArray); str 301 main/SAPI.h #define SAPI_TREAT_DATA_FUNC(treat_data) void treat_data(int arg, char *str, zval* destArray) str 310 main/fastcgi.c static inline char* fcgi_hash_strndup(fcgi_hash *h, char *str, unsigned int str_len) str 324 main/fastcgi.c memcpy(ret, str, str_len); str 503 main/fastcgi.c char *str; str 509 main/fastcgi.c str = getenv("_FCGI_SHUTDOWN_EVENT_"); str 510 main/fastcgi.c if (str != NULL) { str 514 main/fastcgi.c ZEND_ATOL(ev, str); str 521 main/fastcgi.c str = getenv("_FCGI_MUTEX_"); str 522 main/fastcgi.c if (str != NULL) { str 524 main/fastcgi.c ZEND_ATOL(mt, str); str 1203 main/fastcgi.c int fcgi_read(fcgi_request *req, char *str, int len) str 1227 main/fastcgi.c ret = (int)safe_read(req, str, rest); str 1229 main/fastcgi.c ret = (int)safe_read(req, str, req->in_len); str 1238 main/fastcgi.c str += ret; str 1531 main/fastcgi.c int fcgi_write(fcgi_request *req, fcgi_request_type type, const char *str, int len) str 1558 main/fastcgi.c memcpy(req->out_pos, str, rest); str 1562 main/fastcgi.c memcpy(req->out_pos, str, limit); str 1565 main/fastcgi.c str += limit; str 1583 main/fastcgi.c memcpy(req->out_pos, str, len); str 1590 main/fastcgi.c memcpy(req->out_pos, str, limit); str 1598 main/fastcgi.c memcpy(req->out_pos, str + limit, len - limit); str 1613 main/fastcgi.c if (safe_write(req, str + pos, 0xfff8) != 0xfff8) { str 1629 main/fastcgi.c if (safe_write(req, str + pos, (len - pos) - rest) != (len - pos) - rest) { str 1635 main/fastcgi.c memcpy(req->out_pos, str + len - rest, rest); str 1730 main/fastcgi.c static char str[INET6_ADDRSTRLEN]; str 1734 main/fastcgi.c return inet_ntop(client_sa.sa.sa_family, &client_sa.sa_inet.sin_addr, str, INET6_ADDRSTRLEN); str 1741 main/fastcgi.c return inet_ntop(AF_INET, ((char *)&client_sa.sa_inet6.sin6_addr)+12, str, INET6_ADDRSTRLEN); str 1746 main/fastcgi.c return inet_ntop(client_sa.sa.sa_family, &client_sa.sa_inet6.sin6_addr, str, INET6_ADDRSTRLEN); str 118 main/fastcgi.h int fcgi_read(fcgi_request *req, char *str, int len); str 120 main/fastcgi.h int fcgi_write(fcgi_request *req, fcgi_request_type type, const char *str, int len); str 26 main/http_status_codes.h const char *str; str 965 main/main.c PHPAPI void php_html_puts(const char *str, size_t size) str 967 main/main.c zend_html_puts(str, size); str 1886 main/main.c static size_t php_output_wrapper(const char *str, size_t str_length) str 1888 main/main.c return php_output_write(str, str_length); str 56 main/output.c static inline void php_output_op(int op, const char *str, size_t len); str 90 main/output.c static size_t php_output_stdout(const char *str, size_t str_len) str 92 main/output.c fwrite(str, 1, str_len, stdout); str 95 main/output.c static size_t php_output_stderr(const char *str, size_t str_len) str 97 main/output.c fwrite(str, 1, str_len, stderr); str 104 main/output.c static size_t (*php_output_direct)(const char *str, size_t str_len) = php_output_stderr; str 243 main/output.c PHPAPI size_t php_output_write_unbuffered(const char *str, size_t len) str 246 main/output.c return sapi_module.ub_write(str, len); str 248 main/output.c return php_output_direct(str, len); str 254 main/output.c PHPAPI size_t php_output_write(const char *str, size_t len) str 257 main/output.c php_output_op(PHP_OUTPUT_HANDLER_WRITE, str, len); str 263 main/output.c return php_output_direct(str, len); str 520 main/output.c zend_string *str = zend_string_init(name, name_len, 1); str 522 main/output.c handler = php_output_handler_init(str, chunk_size, (flags & ~0xf) | PHP_OUTPUT_HANDLER_INTERNAL); str 524 main/output.c zend_string_release(str); str 1033 main/output.c static inline void php_output_op(int op, const char *str, size_t len) str 1051 main/output.c context.in.data = (char *) str; str 1062 main/output.c context.out.data = (char *) str; str 248 main/php.h #define STR_PRINT(str) ((str)?(str):"") str 782 main/php_ini.c zend_string *str; str 786 main/php_ini.c ZEND_HASH_FOREACH_STR_KEY_VAL(source_hash, str, data) { str 787 main/php_ini.c zend_alter_ini_entry_ex(str, Z_STR_P(data), modify_type, stage, 0); str 50 main/php_main.h PHPAPI void php_html_puts(const char *str, size_t siz); str 159 main/php_output.h #define PHPWRITE(str, str_len) php_output_write((str), (str_len)) str 160 main/php_output.h #define PHPWRITE_H(str, str_len) php_output_write_unbuffered((str), (str_len)) str 165 main/php_output.h #define PUTS(str) do { \ str 166 main/php_output.h const char *__str = (str); \ str 169 main/php_output.h #define PUTS_H(str) do { \ str 170 main/php_output.h const char *__str = (str); \ str 206 main/php_output.h PHPAPI size_t php_output_write_unbuffered(const char *str, size_t len); str 207 main/php_output.h PHPAPI size_t php_output_write(const char *str, size_t len); str 310 main/php_streams.h #define php_stream_write_string(stream, str) _php_stream_write(stream, str, strlen(str)) str 238 main/php_variables.c smart_str str; str 296 main/php_variables.c vars->ptr = ZSTR_VAL(vars->str.s); str 297 main/php_variables.c vars->end = ZSTR_VAL(vars->str.s) + ZSTR_LEN(vars->str.s); str 309 main/php_variables.c memmove(ZSTR_VAL(vars->str.s), vars->ptr, ZSTR_LEN(vars->str.s) = vars->end - vars->ptr); str 333 main/php_variables.c smart_str_appendl(&post_data.str, buf, len); str 336 main/php_variables.c smart_str_free(&post_data.str); str 346 main/php_variables.c if (post_data.str.s) { str 348 main/php_variables.c smart_str_free(&post_data.str); str 418 main/php_variables.c res = str; str 51 main/rfc1867.c static char *php_ap_getword_conf(const zend_encoding *encoding, char *str); str 543 main/rfc1867.c static char *php_ap_getword_conf(const zend_encoding *encoding, char *str) str 545 main/rfc1867.c while (*str && isspace(*str)) { str 546 main/rfc1867.c ++str; str 549 main/rfc1867.c if (!*str) { str 553 main/rfc1867.c if (*str == '"' || *str == '\'') { str 554 main/rfc1867.c char quote = *str; str 556 main/rfc1867.c str++; str 557 main/rfc1867.c return substring_conf(str, (int)strlen(str), quote); str 559 main/rfc1867.c char *strend = str; str 564 main/rfc1867.c return substring_conf(str, strend - str, 0); str 74 main/rfc1867.h typedef char* (*php_rfc1867_getword_conf_t)(const zend_encoding *encoding, char *str); str 75 main/rfc1867.h typedef char* (*php_rfc1867_basename_t)(const zend_encoding *encoding, char *str); str 543 main/snprintf.c #define STR_TO_DEC( str, num ) \ str 544 main/snprintf.c num = NUM( *str++ ) ; \ str 545 main/snprintf.c while ( isdigit((int)*str ) ) \ str 548 main/snprintf.c num += NUM( *str++ ) ; \ str 581 main/snprintf.c #define PREFIX( str, length, ch ) *--str = ch ; length++ ; has_prefix = YES str 132 main/spprintf.c #define INS_STRING(xbuf, str, len, is_char) do { \ str 134 main/spprintf.c smart_string_appendl((smart_string *)(xbuf), (str), (len)); \ str 136 main/spprintf.c smart_str_appendl((smart_str *)(xbuf), (str), (len)); \ str 165 main/spprintf.c #define STR_TO_DEC(str, num) do { \ str 166 main/spprintf.c num = NUM(*str++); \ str 167 main/spprintf.c while (isdigit((int)*str)) { \ str 169 main/spprintf.c num += NUM(*str++); \ str 171 main/spprintf.c while (isdigit((int)*str++)); \ str 899 main/spprintf.c zend_string *str; str 902 main/spprintf.c str = vstrpprintf(max_len, format, ap); str 904 main/spprintf.c return str; str 25 main/streams/memory.c PHPAPI size_t php_url_decode(char *str, size_t len); str 558 main/streams/xp_socket.c static inline char *parse_ip_address_ex(const char *str, size_t str_len, int *portno, int get_err, zend_string **err) str 566 main/streams/xp_socket.c if (*(str) == '[' && str_len > 1) { str 568 main/streams/xp_socket.c p = memchr(str + 1, ']', str_len - 2); str 571 main/streams/xp_socket.c *err = strpprintf(0, "Failed to parse IPv6 address \"%s\"", str); str 576 main/streams/xp_socket.c return estrndup(str + 1, p - str - 1); str 580 main/streams/xp_socket.c colon = memchr(str, ':', str_len - 1); str 586 main/streams/xp_socket.c host = estrndup(str, colon - str); str 589 main/streams/xp_socket.c *err = strpprintf(0, "Failed to parse address \"%s\"", str); str 175 sapi/apache2handler/apache_config.c zend_string *str; str 178 sapi/apache2handler/apache_config.c ZEND_HASH_FOREACH_STR_KEY_PTR(&d->config, str, data) { str 179 sapi/apache2handler/apache_config.c phpapdebug((stderr, "APPLYING (%s)(%s)\n", str, data->value)); str 180 sapi/apache2handler/apache_config.c if (zend_alter_ini_entry_chars(str, data->value, data->value_len, data->status, data->htaccess?PHP_INI_STAGE_HTACCESS:PHP_INI_STAGE_ACTIVATE) == FAILURE) { str 73 sapi/apache2handler/sapi_apache2.c php_apache_sapi_ub_write(const char *str, size_t str_length) str 81 sapi/apache2handler/sapi_apache2.c if (ap_rwrite(str, str_length, r) < 0) { str 529 sapi/apache2handler/sapi_apache2.c zend_string *str; str 532 sapi/apache2handler/sapi_apache2.c ZEND_HASH_FOREACH_STR_KEY(&c->config, str) { str 533 sapi/apache2handler/sapi_apache2.c zend_restore_ini_entry(str, ZEND_INI_STAGE_SHUTDOWN); str 289 sapi/cgi/cgi_main.c static inline size_t sapi_cgi_single_write(const char *str, size_t str_length) str 294 sapi/cgi/cgi_main.c ret = write(STDOUT_FILENO, str, str_length); str 300 sapi/cgi/cgi_main.c ret = fwrite(str, 1, MIN(str_length, 16384), stdout); str 305 sapi/cgi/cgi_main.c static size_t sapi_cgi_ub_write(const char *str, size_t str_length) str 307 sapi/cgi/cgi_main.c const char *ptr = str; str 324 sapi/cgi/cgi_main.c static size_t sapi_fcgi_ub_write(const char *str, size_t str_length) str 326 sapi/cgi/cgi_main.c const char *ptr = str; str 426 sapi/cgi/cgi_main.c if (err->str) { str 427 sapi/cgi/cgi_main.c len = slprintf(buf, sizeof(buf), "Status: %d %s\r\n", SG(sapi_headers).http_response_code, err->str); str 1514 sapi/cgi/cgi_main.c char *str = NULL; str 1527 sapi/cgi/cgi_main.c var = str = do_alloca(var_len + 1, use_heap); str 1528 sapi/cgi/cgi_main.c *str++ = *p++; str 1531 sapi/cgi/cgi_main.c *str++ = '-'; str 1534 sapi/cgi/cgi_main.c *str++ = *p++; str 1537 sapi/cgi/cgi_main.c *str++ = (*p++ - 'A' + 'a'); str 1539 sapi/cgi/cgi_main.c *str++ = *p++; str 1542 sapi/cgi/cgi_main.c *str = 0; str 1553 sapi/cgi/cgi_main.c if (str) { str 33 sapi/cli/cli.h extern PHP_CLI_API size_t sapi_cli_single_write(const char *str, size_t str_length); str 36 sapi/cli/cli.h size_t (*cli_shell_write)(const char *str, size_t str_length); str 37 sapi/cli/cli.h size_t (*cli_shell_ub_write)(const char *str, size_t str_length); str 261 sapi/cli/php_cli.c PHP_CLI_API size_t sapi_cli_single_write(const char *str, size_t str_length) /* {{{ */ str 271 sapi/cli/php_cli.c shell_wrote = cli_shell_callbacks.cli_shell_write(str, str_length); str 279 sapi/cli/php_cli.c ret = write(STDOUT_FILENO, str, str_length); str 288 sapi/cli/php_cli.c ret = fwrite(str, 1, MIN(str_length, 16384), stdout); str 294 sapi/cli/php_cli.c static size_t sapi_cli_ub_write(const char *str, size_t str_length) /* {{{ */ str 296 sapi/cli/php_cli.c const char *ptr = str; str 306 sapi/cli/php_cli.c ub_wrote = cli_shell_callbacks.cli_shell_ub_write(str, str_length); str 325 sapi/cli/php_cli.c return (ptr - str); str 199 sapi/cli/php_cli_server.c const char *str; str 213 sapi/cli/php_cli_server.c static size_t php_cli_server_client_send_through(php_cli_server_client *client, const char *str, size_t str_len); str 294 sapi/cli/php_cli_server.c return result->str; str 317 sapi/cli/php_cli_server.c return template_map[c].str; str 486 sapi/cli/php_cli_server.c static size_t sapi_cli_server_ub_write(const char *str, size_t str_length) /* {{{ */ str 492 sapi/cli/php_cli_server.c return php_cli_server_client_send_through(client, str, str_length); str 1719 sapi/cli/php_cli_server.c static size_t php_cli_server_client_send_through(php_cli_server_client *client, const char *str, size_t str_len) /* {{{ */ str 1734 sapi/cli/php_cli_server.c nbytes_sent = send(client->sock, str + str_len - nbytes_left, nbytes_left, 0); str 51 sapi/embed/php_embed.c static inline size_t php_embed_single_write(const char *str, size_t str_length) str 56 sapi/embed/php_embed.c ret = write(STDOUT_FILENO, str, str_length); str 62 sapi/embed/php_embed.c ret = fwrite(str, 1, MIN(str_length, 16384), stdout); str 68 sapi/embed/php_embed.c static size_t php_embed_ub_write(const char *str, size_t str_length) str 70 sapi/embed/php_embed.c const char *ptr = str; str 282 sapi/fpm/fpm/fpm_main.c static inline size_t sapi_cgibin_single_write(const char *str, uint str_length) /* {{{ */ str 289 sapi/fpm/fpm/fpm_main.c ret = fcgi_write(request, FCGI_STDOUT, str, str_length); str 298 sapi/fpm/fpm/fpm_main.c ret = write(STDOUT_FILENO, str, str_length); str 304 sapi/fpm/fpm/fpm_main.c return fwrite(str, 1, MIN(str_length, 16384), stdout); str 309 sapi/fpm/fpm/fpm_main.c static size_t sapi_cgibin_ub_write(const char *str, size_t str_length) /* {{{ */ str 311 sapi/fpm/fpm/fpm_main.c const char *ptr = str; str 411 sapi/fpm/fpm/fpm_main.c if (err->str) { str 412 sapi/fpm/fpm/fpm_main.c len = slprintf(buf, sizeof(buf), "Status: %d %s\r\n", SG(sapi_headers).http_response_code, err->str); str 262 sapi/fpm/fpm/fpm_php.c zend_string *str; str 277 sapi/fpm/fpm/fpm_php.c ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(data), str, tmp) { str 278 sapi/fpm/fpm/fpm_php.c if (str && !strncmp(ZSTR_VAL(str), key, ZSTR_LEN(str))) { str 129 sapi/litespeed/lsapi_main.c static size_t sapi_lsapi_ub_write(const char *str, size_t str_length) str 134 sapi/litespeed/lsapi_main.c ret = LSAPI_Write( str, str_length ); str 142 sapi/litespeed/lsapi_main.c ret = write( 1, str, remain ); str 147 sapi/litespeed/lsapi_main.c str += ret; str 118 sapi/phpdbg/phpdbg_bp.c PHPDBG_API void phpdbg_export_breakpoints_to_string(char **str) /* {{{ */ str 123 sapi/phpdbg/phpdbg_bp.c *str = ""; str 139 sapi/phpdbg/phpdbg_bp.c "%sbreak %s:%lu\n", *str, str 146 sapi/phpdbg/phpdbg_bp.c "%sbreak %s\n", *str, str 152 sapi/phpdbg/phpdbg_bp.c "%sbreak %s::%s\n", *str, str 159 sapi/phpdbg/phpdbg_bp.c "%sbreak %s::%s#%llu\n", *str, str 167 sapi/phpdbg/phpdbg_bp.c "%sbreak %s#%llu\n", *str, str 174 sapi/phpdbg/phpdbg_bp.c "%sbreak %s:#%llu\n", *str, str 181 sapi/phpdbg/phpdbg_bp.c "%sbreak %s\n", *str, str 192 sapi/phpdbg/phpdbg_bp.c "%sbreak at %s if %s\n", *str, conditional->param.str, conditional->code); str 197 sapi/phpdbg/phpdbg_bp.c "%sbreak at %s::%s if %s\n", *str, str 204 sapi/phpdbg/phpdbg_bp.c "%sbreak at %s:%lu if %s\n", *str, str 212 sapi/phpdbg/phpdbg_bp.c phpdbg_asprintf(&new_str, "%sbreak if %s\n", str, conditional->code); str 219 sapi/phpdbg/phpdbg_bp.c if ((*str)[0]) { str 220 sapi/phpdbg/phpdbg_bp.c efree(*str); str 222 sapi/phpdbg/phpdbg_bp.c *str = new_str; str 228 sapi/phpdbg/phpdbg_bp.c if (!(*str)[0]) { str 229 sapi/phpdbg/phpdbg_bp.c *str = NULL; str 874 sapi/phpdbg/phpdbg_bp.c hash = zend_inline_hash_func(condition->str, condition->len); str 877 sapi/phpdbg/phpdbg_bp.c phpdbg_create_conditional_break(&new_break, param, condition->str, condition->len, hash); str 879 sapi/phpdbg/phpdbg_bp.c phpdbg_notice("breakpoint", "type=\"exists\" arg=\"%s\"", "Conditional break %s exists at the specified location", condition->str); str 996 sapi/phpdbg/phpdbg_bp.c const char *str = NULL; str 999 sapi/phpdbg/phpdbg_bp.c str = ops->function_name ? ZSTR_VAL(ops->function_name) : "main"; str 1000 sapi/phpdbg/phpdbg_bp.c len = ops->function_name ? ZSTR_LEN(ops->function_name) : strlen(str); str 1002 sapi/phpdbg/phpdbg_bp.c if (len == param->len && memcmp(param->str, str, len) == SUCCESS) { str 1010 sapi/phpdbg/phpdbg_bp.c const char *str = zend_get_executed_filename(); str 1011 sapi/phpdbg/phpdbg_bp.c size_t lengths[2] = {strlen(param->file.name), strlen(str)}; str 1015 sapi/phpdbg/phpdbg_bp.c param->file.name, str, lengths[0]) == SUCCESS); str 1568 sapi/phpdbg/phpdbg_bp.c brake->id, brake->param.str, brake->code, str 1574 sapi/phpdbg/phpdbg_bp.c brake->id, brake->param.str, brake->param.num, brake->code, str 161 sapi/phpdbg/phpdbg_bp.h PHPDBG_API void phpdbg_export_breakpoints_to_string(char **str); /* }}} */ str 85 sapi/phpdbg/phpdbg_cmd.c efree(param->str); str 98 sapi/phpdbg/phpdbg_cmd.c ZEND_IGNORE_VALUE(asprintf(pointer, "%s", param->str)); str 122 sapi/phpdbg/phpdbg_cmd.c ZEND_IGNORE_VALUE(asprintf(pointer, "%s#%lu", param->str, param->num)); str 144 sapi/phpdbg/phpdbg_cmd.c dest->str = estrndup(src->str, src->len); str 149 sapi/phpdbg/phpdbg_cmd.c dest->str = estrndup(src->str, src->len); str 175 sapi/phpdbg/phpdbg_cmd.c dest->str = estrndup(src->str, src->len); str 204 sapi/phpdbg/phpdbg_cmd.c hash += zend_inline_hash_func(param->str, param->len); str 228 sapi/phpdbg/phpdbg_cmd.c hash += zend_inline_hash_func(param->str, param->len); str 267 sapi/phpdbg/phpdbg_cmd.c (memcmp(l->str, r->str, l->len) == SUCCESS); str 328 sapi/phpdbg/phpdbg_cmd.c fprintf(stderr, "%s STR_PARAM(%s=%zu)\n", msg, param->str, param->len); str 352 sapi/phpdbg/phpdbg_cmd.c fprintf(stderr, "%s NUMERIC_FUNCTION_PARAM(%s::%ld)\n", msg, param->str, param->num); str 360 sapi/phpdbg/phpdbg_cmd.c fprintf(stderr, "%s COND_PARAM(%s=%zu)\n", msg, param->str, param->len); str 364 sapi/phpdbg/phpdbg_cmd.c fprintf(stderr, "%s OP_PARAM(%s=%zu)\n", msg, param->str, param->len); str 403 sapi/phpdbg/phpdbg_cmd.c if (remove->str) { str 404 sapi/phpdbg/phpdbg_cmd.c efree(remove->str); str 582 sapi/phpdbg/phpdbg_cmd.c if (command->alias == (*name->str)) { str 588 sapi/phpdbg/phpdbg_cmd.c if (strncasecmp(command->name, name->str, name->len) == SUCCESS) { str 613 sapi/phpdbg/phpdbg_cmd.c phpdbg_error("command", "type=\"notfound\" command=\"%s\" subcommand=\"%s\"", "The command \"%s %s\" could not be found", parent->name, name->str); str 615 sapi/phpdbg/phpdbg_cmd.c phpdbg_error("command", "type=\"notfound\" command=\"%s\"", "The command \"%s\" could not be found", name->str); str 648 sapi/phpdbg/phpdbg_cmd.c phpdbg_error("command", "type=\"ambiguous\" command=\"%s\" matches=\"%lu\" matched=\"%s\"", "The command \"%s\" is ambigious, matching %lu commands (%s)", name->str, matches, list); str 65 sapi/phpdbg/phpdbg_cmd.h char *str; str 79 sapi/phpdbg/phpdbg_cmd.h (v)->str = NULL; \ str 86 sapi/phpdbg/phpdbg_eol.c void phpdbg_eol_convert(char **str, int *len) str 88 sapi/phpdbg/phpdbg_eol.c char *in = *str, *out ; str 168 sapi/phpdbg/phpdbg_eol.c efree(*str); str 169 sapi/phpdbg/phpdbg_eol.c *str = erealloc(out, cursor); str 43 sapi/phpdbg/phpdbg_eol.h void phpdbg_eol_convert(char **str, int *len); str 223 sapi/phpdbg/phpdbg_help.c n = get_command(param->str, param->len, &cmd, phpdbg_prompt_commands); str 233 sapi/phpdbg/phpdbg_help.c if (!strncmp(cmd->name, param->str, param->len)) { str 240 sapi/phpdbg/phpdbg_help.c phpdbg_error("help", "type=\"ambiguousalias\" alias=\"%s\"", "Internal help error, non-unique alias \"%c\"", param->str[0]); str 245 sapi/phpdbg/phpdbg_help.c n = get_command( param->str, param->len, &cmd, phpdbg_help_commands); str 537 sapi/phpdbg/phpdbg_lexer.c yylval->str = estrndup(yytext, yyleng - unescape_string(yytext)); str 783 sapi/phpdbg/phpdbg_lexer.c yylval->str = estrndup(yytext, yyleng); str 873 sapi/phpdbg/phpdbg_lexer.c yylval->str = estrndup(yytext, yyleng); str 1739 sapi/phpdbg/phpdbg_lexer.c yylval->str = estrndup(yytext, yyleng - unescape_string(yytext)); str 78 sapi/phpdbg/phpdbg_list.c phpdbg_list_function_byname(param->str, param->len); str 109 sapi/phpdbg/phpdbg_list.c if (phpdbg_safe_class_lookup(param->str, param->len, &ce) == SUCCESS) { str 120 sapi/phpdbg/phpdbg_list.c phpdbg_error("list", "type=\"notfound\" class=\"%s\"", "The requested class (%s) could not be found", param->str); str 194 sapi/phpdbg/phpdbg_list.c void phpdbg_list_function_byname(const char *str, size_t len) /* {{{ */ str 198 sapi/phpdbg/phpdbg_list.c char *func_name = (char*) str; str 77 sapi/phpdbg/phpdbg_out.c #define STR_TO_DEC( str, num ) \ str 78 sapi/phpdbg/phpdbg_out.c num = NUM( *str++ ) ; \ str 79 sapi/phpdbg/phpdbg_out.c while ( isdigit((int)*str ) ) \ str 82 sapi/phpdbg/phpdbg_out.c num += NUM( *str++ ) ; \ str 115 sapi/phpdbg/phpdbg_out.c #define PREFIX( str, length, ch ) *--str = ch ; length++ ; has_prefix = YES str 131 sapi/phpdbg/phpdbg_parser.y $$.str = $1.str; str 137 sapi/phpdbg/phpdbg_parser.y $$.str = $2.str; str 157 sapi/phpdbg/phpdbg_parser.y $$.str = $3.str; str 162 sapi/phpdbg/phpdbg_parser.y $$.str = $3.str; str 171 sapi/phpdbg/phpdbg_parser.y $$.str = $3.str; str 153 sapi/phpdbg/phpdbg_print.c if (phpdbg_safe_class_lookup(param->str, param->len, &ce) == SUCCESS) { str 177 sapi/phpdbg/phpdbg_print.c phpdbg_error("print", "type=\"noclass\" class=\"%s\"", "The class %s could not be found", param->str); str 215 sapi/phpdbg/phpdbg_print.c const char *func_name = param->str; str 113 sapi/phpdbg/phpdbg_prompt.c lc_name = zend_str_tolower_dup(name->str, name->len); str 143 sapi/phpdbg/phpdbg_prompt.c add_next_index_stringl(¶ms, next->str, next->len); str 161 sapi/phpdbg/phpdbg_prompt.c spprintf(&buffered, 0, "%s#%ld", next->str, next->num); str 303 sapi/phpdbg/phpdbg_prompt.c char *str = strtok(buffer, "\n"); str 305 sapi/phpdbg/phpdbg_prompt.c while (str) { str 306 sapi/phpdbg/phpdbg_prompt.c phpdbg_line_init(str, &state); str 308 sapi/phpdbg/phpdbg_prompt.c str = strtok(NULL, "\n"); str 406 sapi/phpdbg/phpdbg_prompt.c if (VCWD_STAT(param->str, &sb) != FAILURE) { str 408 sapi/phpdbg/phpdbg_prompt.c char *res = phpdbg_resolve_path(param->str); str 450 sapi/phpdbg/phpdbg_prompt.c phpdbg_error("exec", "type=\"invalid\" context=\"%s\"", "Cannot use %s as execution context, not a valid file or symlink", param->str); str 453 sapi/phpdbg/phpdbg_prompt.c phpdbg_error("exec", "type=\"notfound\" context=\"%s\"", "Cannot stat %s, ensure the file exists", param->str); str 711 sapi/phpdbg/phpdbg_prompt.c char *argv_str = strtok(param->str, " "); str 812 sapi/phpdbg/phpdbg_prompt.c phpdbg_parse_variable(param->str, param->len, &EG(symbol_table), 0, phpdbg_output_ev_variable, 0); str 828 sapi/phpdbg/phpdbg_prompt.c if (zend_eval_stringl(param->str, param->len, &retval, "eval()'d code") == SUCCESS) { str 973 sapi/phpdbg/phpdbg_prompt.c phpdbg_set_breakpoint_function_opline(param->str, param->num); str 982 sapi/phpdbg/phpdbg_prompt.c phpdbg_set_breakpoint_expression(param->str, param->len); str 985 sapi/phpdbg/phpdbg_prompt.c phpdbg_set_breakpoint_symbol(param->str, param->len); str 988 sapi/phpdbg/phpdbg_prompt.c phpdbg_set_breakpoint_opcode(param->str, param->len); str 1000 sapi/phpdbg/phpdbg_prompt.c if ((fd=VCWD_POPEN((char*)param->str, "w"))) { str 1004 sapi/phpdbg/phpdbg_prompt.c phpdbg_error("sh", "type=\"failure\" smd=\"%s\"", "Failed to execute %s", param->str); str 1177 sapi/phpdbg/phpdbg_prompt.c path = estrndup(param->str, param->len); str 1190 sapi/phpdbg/phpdbg_prompt.c phpdbg_error("dl", "type=\"unsupported\" path=\"%.*s\"", "Cannot dynamically load %.*s - dynamic modules are not supported", (int) param->len, param->str); str 1204 sapi/phpdbg/phpdbg_prompt.c if (VCWD_STAT(param->str, &sb) != -1) { str 1205 sapi/phpdbg/phpdbg_prompt.c phpdbg_try_file_init(param->str, param->len, 0); str 1207 sapi/phpdbg/phpdbg_prompt.c phpdbg_error("source", "type=\"notfound\" file=\"%s\"", "Failed to stat %s, file does not exist", param->str); str 1215 sapi/phpdbg/phpdbg_prompt.c FILE *handle = VCWD_FOPEN(param->str, "w+"); str 1221 sapi/phpdbg/phpdbg_prompt.c phpdbg_error("export", "type=\"openfailure\" file=\"%s\"", "Failed to open or create %s, check path and permissions", param->str); str 1230 sapi/phpdbg/phpdbg_prompt.c char *lcname = zend_str_tolower_dup(param->str, param->len); str 1240 sapi/phpdbg/phpdbg_prompt.c phpdbg_error("register", "type=\"notfound\" function=\"%s\"", "The requested function (%s) could not be found", param->str); str 1314 sapi/phpdbg/phpdbg_prompt.c phpdbg_list_function_byname(param->str, param->len); str 1332 sapi/phpdbg/phpdbg_prompt.c if (phpdbg_create_var_watchpoint(param->str, param->len) != FAILURE) { str 1333 sapi/phpdbg/phpdbg_prompt.c phpdbg_notice("watch", "variable=\"%.*s\"", "Set watchpoint on %.*s", (int) param->len, param->str); str 1692 sapi/phpdbg/phpdbg_prompt.c if (FAILURE == phpdbg_eol_global_update(param->str)) { str 1693 sapi/phpdbg/phpdbg_prompt.c phpdbg_notice("eol", "unknown EOL name '%s', give crlf, lf, cr", "unknown EOL name '%s', give crlf, lf, cr", param->str); str 55 sapi/phpdbg/phpdbg_set.c phpdbg_set_prompt(param->str); str 147 sapi/phpdbg/phpdbg_set.c const phpdbg_color_t *color = phpdbg_get_color(param->next->str, param->next->len); str 150 sapi/phpdbg/phpdbg_set.c phpdbg_error("setcolor", "type=\"nocolor\"", "Failed to find the requested color (%s)", param->next->str); str 154 sapi/phpdbg/phpdbg_set.c switch (phpdbg_get_element(param->str, param->len)) { str 175 sapi/phpdbg/phpdbg_set.c phpdbg_error("setcolor", "type=\"invalidtype\"", "Failed to find the requested element (%s)", param->str); str 211 sapi/phpdbg/phpdbg_set.c PHPDBG_G(oplog) = fopen(param->str, "w+"); str 213 sapi/phpdbg/phpdbg_set.c phpdbg_error("setoplog", "type=\"openfailure\" file=\"%s\"", "Failed to open %s for oplog", param->str); str 221 sapi/phpdbg/phpdbg_set.c phpdbg_notice("setoplog", "file=\"%s\"", "Successfully opened oplog %s", param->str); str 256 sapi/phpdbg/phpdbg_set.c if (param->len == sizeof("opcode") - 1 && !memcmp(param->str, "opcode", sizeof("opcode"))) { str 258 sapi/phpdbg/phpdbg_set.c } else if (param->len == sizeof("line") - 1 && !memcmp(param->str, "line", sizeof("line"))) { str 82 sapi/phpdbg/phpdbg_utils.c PHPDBG_API int phpdbg_is_numeric(const char *str) /* {{{ */ str 84 sapi/phpdbg/phpdbg_utils.c if (!str) str 87 sapi/phpdbg/phpdbg_utils.c for (; *str; str++) { str 88 sapi/phpdbg/phpdbg_utils.c if (isspace(*str) || *str == '-') { str 91 sapi/phpdbg/phpdbg_utils.c return isdigit(*str); str 96 sapi/phpdbg/phpdbg_utils.c PHPDBG_API int phpdbg_is_empty(const char *str) /* {{{ */ str 98 sapi/phpdbg/phpdbg_utils.c if (!str) str 101 sapi/phpdbg/phpdbg_utils.c for (; *str; str++) { str 102 sapi/phpdbg/phpdbg_utils.c if (isspace(*str)) { str 110 sapi/phpdbg/phpdbg_utils.c PHPDBG_API int phpdbg_is_addr(const char *str) /* {{{ */ str 112 sapi/phpdbg/phpdbg_utils.c return str[0] && str[1] && memcmp(str, "0x", 2) == 0; str 115 sapi/phpdbg/phpdbg_utils.c PHPDBG_API int phpdbg_is_class_method(const char *str, size_t len, char **class, char **method) /* {{{ */ str 119 sapi/phpdbg/phpdbg_utils.c if (strstr(str, "#") != NULL) str 122 sapi/phpdbg/phpdbg_utils.c if (strstr(str, " ") != NULL) str 125 sapi/phpdbg/phpdbg_utils.c sep = strstr(str, "::"); str 127 sapi/phpdbg/phpdbg_utils.c if (!sep || sep == str || sep+2 == str+len-1) { str 133 sapi/phpdbg/phpdbg_utils.c if (str[0] == '\\') { str 134 sapi/phpdbg/phpdbg_utils.c str++; str 138 sapi/phpdbg/phpdbg_utils.c *class = estrndup(str, sep - str); str 139 sapi/phpdbg/phpdbg_utils.c (*class)[sep - str] = 0; str 143 sapi/phpdbg/phpdbg_utils.c *method = estrndup(sep+2, str + len - (sep + 2)); str 200 sapi/phpdbg/phpdbg_utils.c PHPDBG_API char *phpdbg_trim(const char *str, size_t len, size_t *new_len) /* {{{ */ str 202 sapi/phpdbg/phpdbg_utils.c const char *p = str; str 810 sapi/phpdbg/phpdbg_utils.c zend_string *str = php_addcslashes(Z_STR_P(zv), 0, "\\\"", 2); str 811 sapi/phpdbg/phpdbg_utils.c for (i = 0; i < ZSTR_LEN(str); i++) { str 812 sapi/phpdbg/phpdbg_utils.c if (ZSTR_VAL(str)[i] < 32) { str 813 sapi/phpdbg/phpdbg_utils.c ZSTR_VAL(str)[i] = ' '; str 817 sapi/phpdbg/phpdbg_utils.c ZSTR_LEN(str) <= maxlen - 2 ? (int) ZSTR_LEN(str) : (maxlen - 3), str 818 sapi/phpdbg/phpdbg_utils.c ZSTR_VAL(str), ZSTR_LEN(str) <= maxlen - 2 ? 0 : '+'); str 819 sapi/phpdbg/phpdbg_utils.c zend_string_release(str); str 828 sapi/phpdbg/phpdbg_utils.c zend_string *str = Z_OBJCE_P(zv)->name; str 830 sapi/phpdbg/phpdbg_utils.c ZSTR_LEN(str) <= maxlen ? (int) ZSTR_LEN(str) : maxlen - 1, str 831 sapi/phpdbg/phpdbg_utils.c ZSTR_VAL(str), ZSTR_LEN(str) <= maxlen ? 0 : '+'); str 149 sapi/phpdbg/phpdbg_wait.c param.str = Z_STRVAL_P(script); str 172 sapi/phpdbg/phpdbg_watch.c zend_string_release(watch->str); str 186 sapi/phpdbg/phpdbg_watch.c watch->str = parent->str; str 187 sapi/phpdbg/phpdbg_watch.c ++GC_REFCOUNT(parent->str); str 204 sapi/phpdbg/phpdbg_watch.c if ((old = zend_hash_find_ptr(&cur->watches, watch->str)) || (old = zend_hash_find_ptr(&cur->implicit_watches, watch->str))) { str 217 sapi/phpdbg/phpdbg_watch.c zend_hash_del(&cur->watches, watch->str); str 225 sapi/phpdbg/phpdbg_watch.c zend_hash_del(&cur->implicit_watches, watch->str); str 254 sapi/phpdbg/phpdbg_watch.c zend_hash_add_ptr(&cur->watches, watch->str, watch->parent); str 257 sapi/phpdbg/phpdbg_watch.c zend_hash_add_ptr(&cur->implicit_watches, watch->str, watch->parent); str 268 sapi/phpdbg/phpdbg_watch.c zend_hash_del(&cur->watches, watch->str); str 269 sapi/phpdbg/phpdbg_watch.c zend_hash_del(&cur->implicit_watches, watch->str); str 290 sapi/phpdbg/phpdbg_watch.c ref->str = watch->str; str 291 sapi/phpdbg/phpdbg_watch.c ++GC_REFCOUNT(ref->str); str 337 sapi/phpdbg/phpdbg_watch.c phpdbg_watchpoint_t *old_watch = zend_hash_find_ptr(&PHPDBG_G(watchpoints), watch->str); str 369 sapi/phpdbg/phpdbg_watch.c zend_hash_add_ptr(&PHPDBG_G(watchpoints), watch->str, watch); str 474 sapi/phpdbg/phpdbg_watch.c new_watch->str = strpprintf(0, "%.*s%s%s%s", (int) ZSTR_LEN(watch->str) - 2, ZSTR_VAL(watch->str), (watch->flags & PHPDBG_WATCH_ARRAY) ? "[" : "->", phpdbg_get_property_key(ZSTR_VAL(new_watch->name_in_parent)), (watch->flags & PHPDBG_WATCH_ARRAY) ? "]" : ""); str 505 sapi/phpdbg/phpdbg_watch.c new_watch->str = strpprintf(0, "%.*s[]", (int) ZSTR_LEN(watch->str), ZSTR_VAL(watch->str)); str 541 sapi/phpdbg/phpdbg_watch.c zend_hash_del(&PHPDBG_G(watchpoints), parent->str); str 564 sapi/phpdbg/phpdbg_watch.c return zend_hash_del(&PHPDBG_G(watchpoints), watch->str); str 568 sapi/phpdbg/phpdbg_watch.c zend_string *str, *strkey; str 574 sapi/phpdbg/phpdbg_watch.c str = strpprintf(0, "%.*s%s%s%s", (int) ZSTR_LEN(watch->str), ZSTR_VAL(watch->str), (watch->flags & PHPDBG_WATCH_ARRAY) ? "[" : "->", phpdbg_get_property_key(ZSTR_VAL(strkey)), (watch->flags & PHPDBG_WATCH_ARRAY) ? "]" : ""); str 576 sapi/phpdbg/phpdbg_watch.c str = strpprintf(0, "%.*s%s" ZEND_LONG_FMT "%s", (int) ZSTR_LEN(watch->str), ZSTR_VAL(watch->str), (watch->flags & PHPDBG_WATCH_ARRAY) ? "[" : "->", numkey, (watch->flags & PHPDBG_WATCH_ARRAY) ? "]" : ""); str 579 sapi/phpdbg/phpdbg_watch.c if ((watchpoint = zend_hash_find_ptr(&PHPDBG_G(watchpoints), str))) { str 583 sapi/phpdbg/phpdbg_watch.c zend_string_release(str); str 620 sapi/phpdbg/phpdbg_watch.c ret = zend_hash_del(&PHPDBG_G(watchpoints), watch->str); str 632 sapi/phpdbg/phpdbg_watch.c watch->str = zend_string_init(name, namelen, 0); str 667 sapi/phpdbg/phpdbg_watch.c watch->str = zend_string_init(name, namelen, 0); str 698 sapi/phpdbg/phpdbg_watch.c if (phpdbg_delete_var_watchpoint(param->str, param->len) == FAILURE) { str 701 sapi/phpdbg/phpdbg_watch.c phpdbg_notice("watchdelete", "variable=\"%.*s\"", "Removed watchpoint %.*s", (int) param->len, param->str); str 719 sapi/phpdbg/phpdbg_watch.c if (phpdbg_watchpoint_parse_symtables(param->str, param->len, phpdbg_create_recursive_watchpoint) != FAILURE) { str 720 sapi/phpdbg/phpdbg_watch.c phpdbg_notice("watchrecursive", "variable=\"%.*s\"", "Set recursive watchpoint on %.*s", (int)param->len, param->str); str 738 sapi/phpdbg/phpdbg_watch.c if (phpdbg_watchpoint_parse_symtables(param->str, param->len, phpdbg_create_array_watchpoint) != FAILURE) { str 739 sapi/phpdbg/phpdbg_watch.c phpdbg_notice("watcharray", "variable=\"%.*s\"", "Set array watchpoint on %.*s", (int)param->len, param->str); str 763 sapi/phpdbg/phpdbg_watch.c phpdbg_notice("watchdelete", "variable=\"%.*s\" recursive=\"%s\"", "%.*s was removed, removing watchpoint%s", (int) ZSTR_LEN(watch->str), ZSTR_VAL(watch->str), (watch->flags & PHPDBG_WATCH_RECURSIVE) ? " recursively" : ""); str 783 sapi/phpdbg/phpdbg_watch.c zend_hash_del(&PHPDBG_G(watchpoints), watch->str); str 996 sapi/phpdbg/phpdbg_watch.c phpdbg_notice("watchhit", "variable=\"%s\"", "Breaking on watchpoint %.*s", (int) ZSTR_LEN(watch->str), ZSTR_VAL(watch->str)); str 1020 sapi/phpdbg/phpdbg_watch.c phpdbg_notice("watchdelete", "variable=\"%.*s\"", "Watchpoint %.*s was unset, removing watchpoint", (int) ZSTR_LEN(watch->str), ZSTR_VAL(watch->str)); str 1022 sapi/phpdbg/phpdbg_watch.c zend_hash_del(&PHPDBG_G(watchpoints), watch->str); str 1128 sapi/phpdbg/phpdbg_watch.c phpdbg_writeln("watchvariable", "variable=\"%.*s\" on=\"%s\" type=\"%s\"", "%.*s (%s, %s)", (int) ZSTR_LEN(watch->str), ZSTR_VAL(watch->str), watch->type == WATCH_ON_HASHTABLE ? "array" : watch->type == WATCH_ON_REFCOUNTED ? "refcount" : "variable", watch->flags == PHPDBG_WATCH_RECURSIVE ? "recursive" : "simple"); str 1154 sapi/phpdbg/phpdbg_watch.c phpdbg_notice("watchdelete", "variable=\"%.*s\" recursive=\"%s\"", "Array %.*s was removed, removing watchpoint%s", (int) ZSTR_LEN(watch->str), ZSTR_VAL(watch->str), (watch->flags & PHPDBG_WATCH_RECURSIVE) ? " recursively" : ""); str 1157 sapi/phpdbg/phpdbg_watch.c zend_hash_del(&PHPDBG_G(watchpoints), watch->str); str 76 sapi/phpdbg/phpdbg_watch.h zend_string *str; str 24 sapi/phpdbg/phpdbg_webdata_transfer.c zend_string *str = zend_string_init(name, len, 0); str 25 sapi/phpdbg/phpdbg_webdata_transfer.c ret = zend_is_auto_global(str); str 26 sapi/phpdbg/phpdbg_webdata_transfer.c efree(str); str 55 sapi/phpdbg/phpdbg_webdata_transfer.c zend_string *str; str 58 sapi/phpdbg/phpdbg_webdata_transfer.c if ((str = php_stream_copy_to_mem(stream, PHP_STREAM_COPY_ALL, 0))) { str 59 sapi/phpdbg/phpdbg_webdata_transfer.c ZVAL_STR(&zv[2], str); str 833 win32/glob.c g_opendir(str, pglob) str 834 win32/glob.c register Char *str; str 839 win32/glob.c if (!*str) str 842 win32/glob.c if (g_Ctoc(str, buf, sizeof(buf))) str 883 win32/glob.c g_strchr(str, ch) str 884 win32/glob.c Char *str; str 888 win32/glob.c if (*str == ch) str 889 win32/glob.c return (str); str 890 win32/glob.c } while (*str++); str 895 win32/glob.c g_Ctoc(str, buf, len) str 896 win32/glob.c register const Char *str; str 902 win32/glob.c if ((*buf++ = (char) *str++) == EOS) str 910 win32/glob.c qprintf(str, s) str 911 win32/glob.c const char *str; str 916 win32/glob.c (void)printf("%s:\n", str); str 71 win32/sendmail.c #define SMTP_SKIP_SPACE(str) { while (isspace(*str)) { str++; } } str 363 win32/sendmail.c size_t needle_len, char *str, size_t str_len);