Mirrors
/
php
mirror of https://github.com/php/php-src
3
0
Fork 0
Code Releases Activity
Browse Source

Switch position of ce in exception ce variable names

pull/1388/head
Aaron Piotrowski 11 years ago
parent
a812a74c2e
commit
ed1b64877d
21 changed files with 116 additions and 116 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 8
      Zend/zend.c
  2. 116
      Zend/zend_exceptions.c
  3. 16
      Zend/zend_exceptions.h
  4. 2
      Zend/zend_generators.c
  5. 10
      Zend/zend_language_scanner.c
  6. 10
      Zend/zend_language_scanner.l
  7. 2
      ext/com_dotnet/com_extension.c
  8. 2
      ext/dom/php_dom.c
  9. 4
      ext/intl/intl_error.c
  10. 8
      ext/mysqli/mysqli.c
  11. 2
      ext/pdo/pdo.c
  12. 6
      ext/pgsql/pgsql.c
  13. 4
      ext/phar/phar_object.c
  14. 2
      ext/reflection/php_reflection.c
  15. 2
      ext/simplexml/simplexml.c
  16. 4
      ext/snmp/snmp.c
  17. 12
      ext/soap/soap.c
  18. 2
      ext/spl/spl_exceptions.c
  19. 16
      ext/sqlite3/sqlite3.c
  20. 2
      ext/standard/assert.c
  21. 2
      sapi/cli/php_cli.c

8
Zend/zend.c
View File

@ -882,7 +882,7 @@ void zenderror(const char *error) /* {{{ */
return;
}
zend_throw_exception(zend_parse_error_ce, error, E_PARSE);
zend_throw_exception(zend_ce_parse_error, error, E_PARSE);
}
/* }}} */
@ -1059,7 +1059,7 @@ static void zend_error_va_list(int type, const char *format, va_list args)
va_start(args, format);
#endif
zend_vspprintf(&message, 0, format, args);
zend_throw_exception(zend_error_ce, message, type);
zend_throw_exception(zend_ce_error, message, type);
efree(message);
#if !defined(HAVE_NORETURN) || defined(HAVE_NORETURN_ALIAS)
va_end(args);
@ -1318,7 +1318,7 @@ ZEND_API void zend_type_error(const char *format, ...) /* {{{ */
va_start(va, format);
zend_vspprintf(&message, 0, format, va);
zend_throw_exception(zend_type_error_ce, message, E_ERROR);
zend_throw_exception(zend_ce_type_error, message, E_ERROR);
efree(message);
va_end(va);
} /* }}} */
@ -1331,7 +1331,7 @@ ZEND_API void zend_internal_type_error(zend_bool throw_exception, const char *fo
va_start(va, format);
zend_vspprintf(&message, 0, format, va);
if (throw_exception) {
zend_throw_exception(zend_type_error_ce, message, E_ERROR);
zend_throw_exception(zend_ce_type_error, message, E_ERROR);
} else {
zend_error(E_WARNING, message);
}

116
Zend/zend_exceptions.c
View File

@ -31,11 +31,11 @@
#include "zend_smart_str.h"
ZEND_API zend_class_entry *zend_ce_throwable;
ZEND_API zend_class_entry *zend_exception_ce;
ZEND_API zend_class_entry *zend_error_exception_ce;
ZEND_API zend_class_entry *zend_error_ce;
ZEND_API zend_class_entry *zend_parse_error_ce;
ZEND_API zend_class_entry *zend_type_error_ce;
ZEND_API zend_class_entry *zend_ce_exception;
ZEND_API zend_class_entry *zend_ce_error_exception;
ZEND_API zend_class_entry *zend_ce_error;
ZEND_API zend_class_entry *zend_ce_parse_error;
ZEND_API zend_class_entry *zend_ce_type_error;
ZEND_API zend_class_entry *zend_ce_arithmetic_error;
ZEND_API zend_class_entry *zend_ce_division_by_zero_error;
@ -46,21 +46,21 @@ static zend_object_handlers default_exception_handlers;
/* {{{ zend_implement_throwable */
static int zend_implement_throwable(zend_class_entry *interface, zend_class_entry *class_type)
{
if (instanceof_function(class_type, zend_exception_ce) || instanceof_function(class_type, zend_error_ce)) {
if (instanceof_function(class_type, zend_ce_exception) || instanceof_function(class_type, zend_ce_error)) {
return SUCCESS;
}
zend_error_noreturn(E_ERROR, "Class %s cannot implement interface %s, extend %s or %s instead",
ZSTR_VAL(class_type->name),
ZSTR_VAL(interface->name),
ZSTR_VAL(zend_exception_ce->name),
ZSTR_VAL(zend_error_ce->name));
ZSTR_VAL(zend_ce_exception->name),
ZSTR_VAL(zend_ce_error->name));
return FAILURE;
}
/* }}} */
static inline zend_class_entry *i_get_exception_base(zval *object)
{
return instanceof_function(Z_OBJCE_P(object), zend_exception_ce) ? zend_exception_ce : zend_error_ce;
return instanceof_function(Z_OBJCE_P(object), zend_ce_exception) ? zend_ce_exception : zend_ce_error;
}
ZEND_API zend_class_entry *zend_get_exception_base(zval *object)
@ -141,7 +141,7 @@ ZEND_API void zend_throw_exception_internal(zval *exception) /* {{{ */
}
}
if (!EG(current_execute_data)) {
if (exception && Z_OBJCE_P(exception) == zend_parse_error_ce) {
if (exception && Z_OBJCE_P(exception) == zend_ce_parse_error) {
return;
}
if(EG(exception)) {
@ -206,7 +206,7 @@ static zend_object *zend_default_exception_new_ex(zend_class_entry *class_type,
base_ce = i_get_exception_base(&obj);
if (EXPECTED(class_type != zend_parse_error_ce || !(filename = zend_get_compiled_filename()))) {
if (EXPECTED(class_type != zend_ce_parse_error || !(filename = zend_get_compiled_filename()))) {
zend_update_property_string(base_ce, &obj, "file", sizeof("file")-1, zend_get_executed_filename());
zend_update_property_long(base_ce, &obj, "line", sizeof("line")-1, zend_get_executed_lineno());
} else {
@ -295,7 +295,7 @@ ZEND_METHOD(error_exception, __construct)
if (execute_data->called_scope) {
ce = execute_data->called_scope;
} else {
ce = zend_error_exception_ce;
ce = zend_ce_error_exception;
}
zend_error(E_EXCEPTION | E_ERROR, "Wrong parameters for %s([string $message [, long $code, [ long $severity, [ string $filename, [ long $lineno [, Throwable $previous = NULL]]]]]])", ZSTR_VAL(ce->name));
return;
@ -304,25 +304,25 @@ ZEND_METHOD(error_exception, __construct)
object = getThis();
if (message) {
zend_update_property_string(zend_exception_ce, object, "message", sizeof("message")-1, message);
zend_update_property_string(zend_ce_exception, object, "message", sizeof("message")-1, message);
}
if (code) {
zend_update_property_long(zend_exception_ce, object, "code", sizeof("code")-1, code);
zend_update_property_long(zend_ce_exception, object, "code", sizeof("code")-1, code);
}
if (previous) {
zend_update_property(zend_exception_ce, object, "previous", sizeof("previous")-1, previous);
zend_update_property(zend_ce_exception, object, "previous", sizeof("previous")-1, previous);
}
zend_update_property_long(zend_error_exception_ce, object, "severity", sizeof("severity")-1, severity);
zend_update_property_long(zend_ce_error_exception, object, "severity", sizeof("severity")-1, severity);
if (argc >= 4) {
zend_update_property_string(zend_exception_ce, object, "file", sizeof("file")-1, filename);
zend_update_property_string(zend_ce_exception, object, "file", sizeof("file")-1, filename);
if (argc < 5) {
lineno = 0; /* invalidate lineno */
}
zend_update_property_long(zend_exception_ce, object, "line", sizeof("line")-1, lineno);
zend_update_property_long(zend_ce_exception, object, "line", sizeof("line")-1, lineno);
}
}
/* }}} */
@ -709,7 +709,7 @@ ZEND_METHOD(exception, __toString)
ZVAL_UNDEF(&trace);
}
if (Z_OBJCE_P(exception) == zend_type_error_ce && strstr(ZSTR_VAL(message), ", called in ")) {
if (Z_OBJCE_P(exception) == zend_ce_type_error && strstr(ZSTR_VAL(message), ", called in ")) {
zend_string *real_message = zend_strpprintf(0, "%s and defined", ZSTR_VAL(message));
zend_string_release(message);
message = real_message;
@ -819,46 +819,46 @@ void zend_register_default_exception(void) /* {{{ */
default_exception_handlers.clone_obj = NULL;
INIT_CLASS_ENTRY(ce, "Exception", default_exception_functions);
zend_exception_ce = zend_register_internal_class_ex(&ce, NULL);
zend_exception_ce->create_object = zend_default_exception_new;
zend_class_implements(zend_exception_ce, 1, zend_ce_throwable);
zend_declare_property_string(zend_exception_ce, "message", sizeof("message")-1, "", ZEND_ACC_PROTECTED);
zend_declare_property_string(zend_exception_ce, "string", sizeof("string")-1, "", ZEND_ACC_PRIVATE);
zend_declare_property_long(zend_exception_ce, "code", sizeof("code")-1, 0, ZEND_ACC_PROTECTED);
zend_declare_property_null(zend_exception_ce, "file", sizeof("file")-1, ZEND_ACC_PROTECTED);
zend_declare_property_null(zend_exception_ce, "line", sizeof("line")-1, ZEND_ACC_PROTECTED);
zend_declare_property_null(zend_exception_ce, "trace", sizeof("trace")-1, ZEND_ACC_PRIVATE);
zend_declare_property_null(zend_exception_ce, "previous", sizeof("previous")-1, ZEND_ACC_PRIVATE);
zend_ce_exception = zend_register_internal_class_ex(&ce, NULL);
zend_ce_exception->create_object = zend_default_exception_new;
zend_class_implements(zend_ce_exception, 1, zend_ce_throwable);
zend_declare_property_string(zend_ce_exception, "message", sizeof("message")-1, "", ZEND_ACC_PROTECTED);
zend_declare_property_string(zend_ce_exception, "string", sizeof("string")-1, "", ZEND_ACC_PRIVATE);
zend_declare_property_long(zend_ce_exception, "code", sizeof("code")-1, 0, ZEND_ACC_PROTECTED);
zend_declare_property_null(zend_ce_exception, "file", sizeof("file")-1, ZEND_ACC_PROTECTED);
zend_declare_property_null(zend_ce_exception, "line", sizeof("line")-1, ZEND_ACC_PROTECTED);
zend_declare_property_null(zend_ce_exception, "trace", sizeof("trace")-1, ZEND_ACC_PRIVATE);
zend_declare_property_null(zend_ce_exception, "previous", sizeof("previous")-1, ZEND_ACC_PRIVATE);
INIT_CLASS_ENTRY(ce, "ErrorException", error_exception_functions);
zend_error_exception_ce = zend_register_internal_class_ex(&ce, zend_exception_ce);
zend_error_exception_ce->create_object = zend_error_exception_new;
zend_declare_property_long(zend_error_exception_ce, "severity", sizeof("severity")-1, E_ERROR, ZEND_ACC_PROTECTED);
zend_ce_error_exception = zend_register_internal_class_ex(&ce, zend_ce_exception);
zend_ce_error_exception->create_object = zend_error_exception_new;
zend_declare_property_long(zend_ce_error_exception, "severity", sizeof("severity")-1, E_ERROR, ZEND_ACC_PROTECTED);
INIT_CLASS_ENTRY(ce, "Error", default_exception_functions);
zend_error_ce = zend_register_internal_class_ex(&ce, NULL);
zend_error_ce->create_object = zend_default_exception_new;
zend_class_implements(zend_error_ce, 1, zend_ce_throwable);
zend_declare_property_string(zend_error_ce, "message", sizeof("message")-1, "", ZEND_ACC_PROTECTED);
zend_declare_property_string(zend_error_ce, "string", sizeof("string")-1, "", ZEND_ACC_PRIVATE);
zend_declare_property_long(zend_error_ce, "code", sizeof("code")-1, 0, ZEND_ACC_PROTECTED);
zend_declare_property_null(zend_error_ce, "file", sizeof("file")-1, ZEND_ACC_PROTECTED);
zend_declare_property_null(zend_error_ce, "line", sizeof("line")-1, ZEND_ACC_PROTECTED);
zend_declare_property_null(zend_error_ce, "trace", sizeof("trace")-1, ZEND_ACC_PRIVATE);
zend_declare_property_null(zend_error_ce, "previous", sizeof("previous")-1, ZEND_ACC_PRIVATE);
zend_ce_error = zend_register_internal_class_ex(&ce, NULL);
zend_ce_error->create_object = zend_default_exception_new;
zend_class_implements(zend_ce_error, 1, zend_ce_throwable);
zend_declare_property_string(zend_ce_error, "message", sizeof("message")-1, "", ZEND_ACC_PROTECTED);
zend_declare_property_string(zend_ce_error, "string", sizeof("string")-1, "", ZEND_ACC_PRIVATE);
zend_declare_property_long(zend_ce_error, "code", sizeof("code")-1, 0, ZEND_ACC_PROTECTED);
zend_declare_property_null(zend_ce_error, "file", sizeof("file")-1, ZEND_ACC_PROTECTED);
zend_declare_property_null(zend_ce_error, "line", sizeof("line")-1, ZEND_ACC_PROTECTED);
zend_declare_property_null(zend_ce_error, "trace", sizeof("trace")-1, ZEND_ACC_PRIVATE);
zend_declare_property_null(zend_ce_error, "previous", sizeof("previous")-1, ZEND_ACC_PRIVATE);
INIT_CLASS_ENTRY(ce, "ParseError", NULL);
zend_parse_error_ce = zend_register_internal_class_ex(&ce, zend_error_ce);
zend_parse_error_ce->create_object = zend_default_exception_new;
zend_ce_parse_error = zend_register_internal_class_ex(&ce, zend_ce_error);
zend_ce_parse_error->create_object = zend_default_exception_new;
INIT_CLASS_ENTRY(ce, "TypeError", NULL);
zend_type_error_ce = zend_register_internal_class_ex(&ce, zend_error_ce);
zend_type_error_ce->create_object = zend_default_exception_new;
zend_ce_type_error = zend_register_internal_class_ex(&ce, zend_ce_error);
zend_ce_type_error->create_object = zend_default_exception_new;
INIT_CLASS_ENTRY(ce, "ArithmeticError", NULL);
zend_ce_arithmetic_error = zend_register_internal_class_ex(&ce, zend_error_ce);
zend_ce_arithmetic_error = zend_register_internal_class_ex(&ce, zend_ce_error);
zend_ce_arithmetic_error->create_object = zend_default_exception_new;
INIT_CLASS_ENTRY(ce, "DivisionByZeroError", NULL);
@ -867,17 +867,17 @@ void zend_register_default_exception(void) /* {{{ */
}
/* }}} */
/* {{{ Deprecated - Use zend_exception_ce directly instead */
/* {{{ Deprecated - Use zend_ce_exception directly instead */
ZEND_API zend_class_entry *zend_exception_get_default(void)
{
return zend_exception_ce;
return zend_ce_exception;
}
/* }}} */
/* {{{ Deprecated - Use zend_error_exception_ce directly instead */
/* {{{ Deprecated - Use zend_ce_error_exception directly instead */
ZEND_API zend_class_entry *zend_get_error_exception(void)
{
return zend_error_exception_ce;
return zend_ce_error_exception;
}
/* }}} */
@ -888,10 +888,10 @@ ZEND_API zend_object *zend_throw_exception(zend_class_entry *exception_ce, const
if (exception_ce) {
if (!instanceof_function(exception_ce, zend_ce_throwable)) {
zend_error(E_NOTICE, "Exceptions must implement Throwable");
exception_ce = zend_exception_ce;
exception_ce = zend_ce_exception;
}
} else {
exception_ce = zend_exception_ce;
exception_ce = zend_ce_exception;
}
object_init_ex(&ex, exception_ce);
@ -928,7 +928,7 @@ ZEND_API zend_object *zend_throw_error_exception(zend_class_entry *exception_ce,
zval ex;
zend_object *obj = zend_throw_exception(exception_ce, message, code);
ZVAL_OBJ(&ex, obj);
zend_update_property_long(zend_error_exception_ce, &ex, "severity", sizeof("severity")-1, severity);
zend_update_property_long(zend_ce_error_exception, &ex, "severity", sizeof("severity")-1, severity);
return obj;
}
/* }}} */
@ -961,7 +961,7 @@ ZEND_API void zend_exception_error(zend_object *ex, int severity) /* {{{ */
ZVAL_OBJ(&exception, ex);
ce_exception = Z_OBJCE(exception);
EG(exception) = NULL;
if (ce_exception == zend_parse_error_ce) {
if (ce_exception == zend_ce_parse_error) {
zend_string *message = zval_get_string(GET_PROPERTY(&exception, "message"));
zend_string *file = zval_get_string(GET_PROPERTY_SILENT(&exception, "file"));
zend_long line = zval_get_long(GET_PROPERTY_SILENT(&exception, "line"));
@ -991,7 +991,7 @@ ZEND_API void zend_exception_error(zend_object *ex, int severity) /* {{{ */
ZVAL_OBJ(&zv, EG(exception));
/* do the best we can to inform about the inner exception */
if (instanceof_function(ce_exception, zend_exception_ce) || instanceof_function(ce_exception, zend_error_ce)) {
if (instanceof_function(ce_exception, zend_ce_exception) || instanceof_function(ce_exception, zend_ce_error)) {
file = zval_get_string(GET_PROPERTY_SILENT(&zv, "file"));
line = zval_get_long(GET_PROPERTY_SILENT(&zv, "line"));
}

16
Zend/zend_exceptions.h
View File

@ -27,11 +27,11 @@
BEGIN_EXTERN_C()
extern ZEND_API zend_class_entry *zend_ce_throwable;
extern ZEND_API zend_class_entry *zend_exception_ce;
extern ZEND_API zend_class_entry *zend_error_exception_ce;
extern ZEND_API zend_class_entry *zend_error_ce;
extern ZEND_API zend_class_entry *zend_parse_error_ce;
extern ZEND_API zend_class_entry *zend_type_error_ce;
extern ZEND_API zend_class_entry *zend_ce_exception;
extern ZEND_API zend_class_entry *zend_ce_error_exception;
extern ZEND_API zend_class_entry *zend_ce_error;
extern ZEND_API zend_class_entry *zend_ce_parse_error;
extern ZEND_API zend_class_entry *zend_ce_type_error;
extern ZEND_API zend_class_entry *zend_ce_arithmetic_error;
extern ZEND_API zend_class_entry *zend_ce_division_by_zero_error;
@ -45,15 +45,15 @@ void zend_register_default_exception(void);
ZEND_API zend_class_entry *zend_get_exception_base(zval *object);
/* Deprecated - Use zend_exception_ce directly instead */
/* Deprecated - Use zend_ce_exception directly instead */
ZEND_API zend_class_entry *zend_exception_get_default(void);
/* Deprecated - Use zend_error_exception_ce directly instead */
/* Deprecated - Use zend_ce_error_exception directly instead */
ZEND_API zend_class_entry *zend_get_error_exception(void);
ZEND_API void zend_register_default_classes(void);
/* exception_ce NULL, zend_exception_ce, zend_error_ce, or a derived class
/* exception_ce NULL, zend_ce_exception, zend_ce_error, or a derived class
* message NULL or the message of the exception */
ZEND_API zend_object *zend_throw_exception(zend_class_entry *exception_ce, const char *message, zend_long code);
ZEND_API zend_object *zend_throw_exception_ex(zend_class_entry *exception_ce, zend_long code, const char *format, ...);

2
Zend/zend_generators.c
View File

@ -1124,7 +1124,7 @@ void zend_register_generator_ce(void) /* {{{ */
zend_generator_handlers.get_constructor = zend_generator_get_constructor;
INIT_CLASS_ENTRY(ce, "ClosedGeneratorException", NULL);
zend_ce_ClosedGeneratorException = zend_register_internal_class_ex(&ce, zend_exception_ce);
zend_ce_ClosedGeneratorException = zend_register_internal_class_ex(&ce, zend_ce_exception);
}
/* }}} */

10
Zend/zend_language_scanner.c
View File

@ -1010,7 +1010,7 @@ static int zend_scan_escape_string(zval *zendlval, char *str, int len, char quot
}
if (!valid) {
zend_throw_exception(zend_parse_error_ce,
zend_throw_exception(zend_ce_parse_error,
"Invalid UTF-8 codepoint escape sequence", E_PARSE);
zval_ptr_dtor(zendlval);
return FAILURE;
@ -1021,7 +1021,7 @@ static int zend_scan_escape_string(zval *zendlval, char *str, int len, char quot
/* per RFC 3629, UTF-8 can only represent 21 bits */
if (codepoint > 0x10FFFF || errno) {
zend_throw_exception(zend_parse_error_ce,
zend_throw_exception(zend_ce_parse_error,
"Invalid UTF-8 codepoint escape sequence: Codepoint too large", E_PARSE);
zval_ptr_dtor(zendlval);
return FAILURE;
@ -2743,7 +2743,7 @@ yy136:
* Because the lexing itself doesn't do that for us
*/
if (end != yytext + yyleng) {
zend_throw_exception(zend_parse_error_ce, "Invalid numeric literal", E_PARSE);
zend_throw_exception(zend_ce_parse_error, "Invalid numeric literal", E_PARSE);
RETURN_TOKEN(T_ERROR);
}
} else {
@ -2759,7 +2759,7 @@ yy136:
}
/* Also not an assert for the same reason */
if (end != yytext + yyleng) {
zend_throw_exception(zend_parse_error_ce,
zend_throw_exception(zend_ce_parse_error,
"Invalid numeric literal", E_PARSE);
RETURN_TOKEN(T_ERROR);
}
@ -2768,7 +2768,7 @@ yy136:
}
/* Also not an assert for the same reason */
if (end != yytext + yyleng) {
zend_throw_exception(zend_parse_error_ce, "Invalid numeric literal", E_PARSE);
zend_throw_exception(zend_ce_parse_error, "Invalid numeric literal", E_PARSE);
RETURN_TOKEN(T_ERROR);
}
}

10
Zend/zend_language_scanner.l
View File

@ -1008,7 +1008,7 @@ static int zend_scan_escape_string(zval *zendlval, char *str, int len, char quot
}
if (!valid) {
zend_throw_exception(zend_parse_error_ce,
zend_throw_exception(zend_ce_parse_error,
"Invalid UTF-8 codepoint escape sequence", E_PARSE);
zval_ptr_dtor(zendlval);
return FAILURE;
@ -1019,7 +1019,7 @@ static int zend_scan_escape_string(zval *zendlval, char *str, int len, char quot
/* per RFC 3629, UTF-8 can only represent 21 bits */
if (codepoint > 0x10FFFF || errno) {
zend_throw_exception(zend_parse_error_ce,
zend_throw_exception(zend_ce_parse_error,
"Invalid UTF-8 codepoint escape sequence: Codepoint too large", E_PARSE);
zval_ptr_dtor(zendlval);
return FAILURE;
@ -1658,7 +1658,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
* Because the lexing itself doesn't do that for us
*/
if (end != yytext + yyleng) {
zend_throw_exception(zend_parse_error_ce, "Invalid numeric literal", E_PARSE);
zend_throw_exception(zend_ce_parse_error, "Invalid numeric literal", E_PARSE);
RETURN_TOKEN(T_ERROR);
}
} else {
@ -1674,7 +1674,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
}
/* Also not an assert for the same reason */
if (end != yytext + yyleng) {
zend_throw_exception(zend_parse_error_ce,
zend_throw_exception(zend_ce_parse_error,
"Invalid numeric literal", E_PARSE);
RETURN_TOKEN(T_ERROR);
}
@ -1683,7 +1683,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
}
/* Also not an assert for the same reason */
if (end != yytext + yyleng) {
zend_throw_exception(zend_parse_error_ce, "Invalid numeric literal", E_PARSE);
zend_throw_exception(zend_ce_parse_error, "Invalid numeric literal", E_PARSE);
RETURN_TOKEN(T_ERROR);
}
}

2
ext/com_dotnet/com_extension.c
View File

@ -358,7 +358,7 @@ PHP_MINIT_FUNCTION(com_dotnet)
php_com_persist_minit(INIT_FUNC_ARGS_PASSTHRU);
INIT_CLASS_ENTRY(ce, "com_exception", NULL);
php_com_exception_class_entry = zend_register_internal_class_ex(&ce, zend_exception_ce);
php_com_exception_class_entry = zend_register_internal_class_ex(&ce, zend_ce_exception);
php_com_exception_class_entry->ce_flags |= ZEND_ACC_FINAL;
/* php_com_exception_class_entry->constructor->common.fn_flags |= ZEND_ACC_PROTECTED; */

2
ext/dom/php_dom.c
View File

@ -614,7 +614,7 @@ PHP_MINIT_FUNCTION(dom)
zend_hash_init(&classes, 0, NULL, NULL, 1);
INIT_CLASS_ENTRY(ce, "DOMException", php_dom_domexception_class_functions);
dom_domexception_class_entry = zend_register_internal_class_ex(&ce, zend_exception_ce);
dom_domexception_class_entry = zend_register_internal_class_ex(&ce, zend_ce_exception);
dom_domexception_class_entry->ce_flags |= ZEND_ACC_FINAL;
zend_declare_property_long(dom_domexception_class_entry, "code", sizeof("code")-1, 0, ZEND_ACC_PUBLIC);

4
ext/intl/intl_error.c
View File

@ -237,8 +237,8 @@ void intl_register_IntlException_class( void )
/* Create and register 'IntlException' class. */
INIT_CLASS_ENTRY_EX( ce, "IntlException", sizeof( "IntlException" ) - 1, NULL );
IntlException_ce_ptr = zend_register_internal_class_ex( &ce,
zend_exception_ce );
IntlException_ce_ptr->create_object = zend_exception_ce->create_object;
zend_ce_exception );
IntlException_ce_ptr->create_object = zend_ce_exception->create_object;
}
smart_str intl_parse_error_to_string( UParseError* pe )

8
ext/mysqli/mysqli.c
View File

@ -606,7 +606,7 @@ PHP_MINIT_FUNCTION(mysqli)
#ifdef HAVE_SPL
mysqli_exception_class_entry = zend_register_internal_class_ex(&cex, spl_ce_RuntimeException);
#else
mysqli_exception_class_entry = zend_register_internal_class_ex(&cex, zend_exception_ce);
mysqli_exception_class_entry = zend_register_internal_class_ex(&cex, zend_ce_exception);
#endif
mysqli_exception_class_entry->ce_flags |= ZEND_ACC_FINAL;
zend_declare_property_long(mysqli_exception_class_entry, "code", sizeof("code")-1, 0, ZEND_ACC_PROTECTED);
@ -1302,7 +1302,7 @@ void php_mysqli_fetch_into_hash(INTERNAL_FUNCTION_PARAMETERS, int override_flags
* single value is an array. Also we'd have to make that one
* argument passed by reference.
*/
zend_throw_exception(zend_exception_ce, "Parameter ctor_params must be an array", 0);
zend_throw_exception(zend_ce_exception, "Parameter ctor_params must be an array", 0);
return;
}
}
@ -1314,7 +1314,7 @@ void php_mysqli_fetch_into_hash(INTERNAL_FUNCTION_PARAMETERS, int override_flags
fcc.object = Z_OBJ_P(return_value);
if (zend_call_function(&fci, &fcc) == FAILURE) {
zend_throw_exception_ex(zend_exception_ce, 0, "Could not execute %s::%s()", ZSTR_VAL(ce->name), ZSTR_VAL(ce->constructor->common.function_name));
zend_throw_exception_ex(zend_ce_exception, 0, "Could not execute %s::%s()", ZSTR_VAL(ce->name), ZSTR_VAL(ce->constructor->common.function_name));
} else {
zval_ptr_dtor(&retval);
}
@ -1322,7 +1322,7 @@ void php_mysqli_fetch_into_hash(INTERNAL_FUNCTION_PARAMETERS, int override_flags
efree(fci.params);
}
} else if (ctor_params) {
zend_throw_exception_ex(zend_exception_ce, 0, "Class %s does not have a constructor hence you cannot use ctor_params", ZSTR_VAL(ce->name));
zend_throw_exception_ex(zend_ce_exception, 0, "Class %s does not have a constructor hence you cannot use ctor_params", ZSTR_VAL(ce->name));
}
}
}

2
ext/pdo/pdo.c
View File

@ -93,7 +93,7 @@ PDO_API zend_class_entry *php_pdo_get_exception_base(int root) /* {{{ */
}
}
#endif
return zend_exception_ce;
return zend_ce_exception;
}
/* }}} */

6
ext/pgsql/pgsql.c
View File

@ -2808,7 +2808,7 @@ static void php_pgsql_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, zend_long result_
* single value is an array. Also we'd have to make that one
* argument passed by reference.
*/
zend_throw_exception(zend_exception_ce, "Parameter ctor_params must be an array", 0);
zend_throw_exception(zend_ce_exception, "Parameter ctor_params must be an array", 0);
return;
}
}
@ -2820,7 +2820,7 @@ static void php_pgsql_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, zend_long result_
fcc.object = Z_OBJ_P(return_value);
if (zend_call_function(&fci, &fcc) == FAILURE) {
zend_throw_exception_ex(zend_exception_ce, 0, "Could not execute %s::%s()", ce->name, ce->constructor->common.function_name);
zend_throw_exception_ex(zend_ce_exception, 0, "Could not execute %s::%s()", ce->name, ce->constructor->common.function_name);
} else {
zval_ptr_dtor(&retval);
}
@ -2828,7 +2828,7 @@ static void php_pgsql_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, zend_long result_
efree(fci.params);
}
} else if (ctor_params) {
zend_throw_exception_ex(zend_exception_ce, 0, "Class %s does not have a constructor hence you cannot use ctor_params", ce->name);
zend_throw_exception_ex(zend_ce_exception, 0, "Class %s does not have a constructor hence you cannot use ctor_params", ce->name);
}
}
}

4
ext/phar/phar_object.c
View File

@ -1118,7 +1118,7 @@ static spl_other_handler phar_spl_foreign_handler = {
PHP_METHOD(Phar, __construct)
{
#if !HAVE_SPL
zend_throw_exception_ex(zend_exception_ce, 0, "Cannot instantiate Phar object without SPL extension");
zend_throw_exception_ex(zend_ce_exception, 0, "Cannot instantiate Phar object without SPL extension");
#else
char *fname, *alias = NULL, *error, *arch = NULL, *entry = NULL, *save_fname;
size_t fname_len, alias_len = 0;
@ -5295,7 +5295,7 @@ void phar_object_init(void) /* {{{ */
zend_class_entry ce;
INIT_CLASS_ENTRY(ce, "PharException", phar_exception_methods);
phar_ce_PharException = zend_register_internal_class_ex(&ce, zend_exception_ce);
phar_ce_PharException = zend_register_internal_class_ex(&ce, zend_ce_exception);
#if HAVE_SPL
INIT_CLASS_ENTRY(ce, "Phar", php_archive_methods);

2
ext/reflection/php_reflection.c
View File

@ -6572,7 +6572,7 @@ PHP_MINIT_FUNCTION(reflection) /* {{{ */
reflection_object_handlers.write_property = _reflection_write_property;
INIT_CLASS_ENTRY(_reflection_entry, "ReflectionException", reflection_exception_functions);
reflection_exception_ptr = zend_register_internal_class_ex(&_reflection_entry, zend_exception_ce);
reflection_exception_ptr = zend_register_internal_class_ex(&_reflection_entry, zend_ce_exception);
INIT_CLASS_ENTRY(_reflection_entry, "Reflection", reflection_functions);
reflection_ptr = zend_register_internal_class(&_reflection_entry);

2
ext/simplexml/simplexml.c
View File

@ -2285,7 +2285,7 @@ SXE_METHOD(__construct)
if (!docp) {
((php_libxml_node_object *)sxe)->document = NULL;
zend_throw_exception(zend_exception_ce, "String could not be parsed as XML", 0);
zend_throw_exception(zend_ce_exception, "String could not be parsed as XML", 0);
return;
}

4
ext/snmp/snmp.c
View File

@ -1820,7 +1820,7 @@ PHP_METHOD(snmp, __construct)
case SNMP_VERSION_3:
break;
default:
zend_throw_exception(zend_exception_ce, "Unknown SNMP protocol version", 0);
zend_throw_exception(zend_ce_exception, "Unknown SNMP protocol version", 0);
return;
}
@ -2419,7 +2419,7 @@ PHP_MINIT_FUNCTION(snmp)
#ifdef HAVE_SPL
php_snmp_exception_ce = zend_register_internal_class_ex(&cex, spl_ce_RuntimeException);
#else
php_snmp_exception_ce = zend_register_internal_class_ex(&cex, zend_exception_ce);
php_snmp_exception_ce = zend_register_internal_class_ex(&cex, zend_ce_exception);
#endif
return SUCCESS;

12
ext/soap/soap.c
View File

@ -683,7 +683,7 @@ PHP_MINIT_FUNCTION(soap)
/* Register SoapFault class */
INIT_CLASS_ENTRY(ce, PHP_SOAP_FAULT_CLASSNAME, soap_fault_functions);
soap_fault_class_entry = zend_register_internal_class_ex(&ce, zend_exception_ce);
soap_fault_class_entry = zend_register_internal_class_ex(&ce, zend_ce_exception);
/* Register SoapParam class */
INIT_CLASS_ENTRY(ce, PHP_SOAP_PARAM_CLASSNAME, soap_param_functions);
@ -1495,10 +1495,10 @@ static void _soap_server_exception(soapServicePtr service, sdlFunctionPtr functi
ZVAL_OBJ(&exception_object, EG(exception));
if (instanceof_function(Z_OBJCE(exception_object), soap_fault_class_entry)) {
soap_server_fault_ex(function, &exception_object, NULL);
} else if (instanceof_function(Z_OBJCE(exception_object), zend_error_ce)) {
} else if (instanceof_function(Z_OBJCE(exception_object), zend_ce_error)) {
if (service->send_errors) {
zval rv;
zend_string *msg = zval_get_string(zend_read_property(zend_error_ce, &exception_object, "message", sizeof("message")-1, 0, &rv));
zend_string *msg = zval_get_string(zend_read_property(zend_ce_error, &exception_object, "message", sizeof("message")-1, 0, &rv));
add_soap_fault_ex(&exception_object, this_ptr, "Server", ZSTR_VAL(msg), NULL, NULL);
zend_string_release(msg);
} else {
@ -2582,13 +2582,13 @@ static int do_request(zval *this_ptr, xmlDoc *request, char *location, char *act
add_soap_fault(this_ptr, "Client", "SoapClient::__doRequest() failed", NULL, NULL);
ret = FALSE;
} else if (Z_TYPE_P(response) != IS_STRING) {
if (EG(exception) && instanceof_function(EG(exception)->ce, zend_error_ce)) {
if (EG(exception) && instanceof_function(EG(exception)->ce, zend_ce_error)) {
zval rv;
zend_string *msg;
zval exception_object;
ZVAL_OBJ(&exception_object, EG(exception));
msg = zval_get_string(zend_read_property(zend_error_ce, &exception_object, "message", sizeof("message")-1, 0, &rv));
msg = zval_get_string(zend_read_property(zend_ce_error, &exception_object, "message", sizeof("message")-1, 0, &rv));
/* change class */
EG(exception)->ce = soap_fault_class_entry;
set_soap_fault(&exception_object, NULL, "Client", ZSTR_VAL(msg), NULL, NULL, NULL);
@ -3280,7 +3280,7 @@ static void set_soap_fault(zval *obj, char *fault_code_ns, char *fault_code, cha
}
add_property_string(obj, "faultstring", fault_string ? fault_string : "");
zend_update_property_string(zend_exception_ce, obj, "message", sizeof("message")-1, (fault_string ? fault_string : ""));
zend_update_property_string(zend_ce_exception, obj, "message", sizeof("message")-1, (fault_string ? fault_string : ""));
if (fault_code != NULL) {
int soap_version = SOAP_GLOBAL(soap_version);

2
ext/spl/spl_exceptions.c
View File

@ -47,7 +47,7 @@ PHPAPI zend_class_entry *spl_ce_RangeException;
PHPAPI zend_class_entry *spl_ce_UnderflowException;
PHPAPI zend_class_entry *spl_ce_UnexpectedValueException;
#define spl_ce_Exception zend_exception_ce
#define spl_ce_Exception zend_ce_exception
/* {{{ PHP_MINIT_FUNCTION(spl_exceptions) */
PHP_MINIT_FUNCTION(spl_exceptions)

16
ext/sqlite3/sqlite3.c
View File

@ -54,7 +54,7 @@ static void php_sqlite3_error(php_sqlite3_db_object *db_obj, char *format, ...)
va_end(arg);
if (db_obj && db_obj->exception) {
zend_throw_exception(zend_exception_ce, message, 0);
zend_throw_exception(zend_ce_exception, message, 0);
} else {
php_error_docref(NULL, E_WARNING, "%s", message);
}
@ -111,7 +111,7 @@ PHP_METHOD(sqlite3, open)
}
if (db_obj->initialised) {
zend_throw_exception(zend_exception_ce, "Already initialised DB Object", 0);
zend_throw_exception(zend_ce_exception, "Already initialised DB Object", 0);
}
if (strlen(filename) != filename_len) {
@ -119,20 +119,20 @@ PHP_METHOD(sqlite3, open)
}
if (memcmp(filename, ":memory:", sizeof(":memory:")) != 0) {
if (!(fullpath = expand_filepath(filename, NULL))) {
zend_throw_exception(zend_exception_ce, "Unable to expand filepath", 0);
zend_throw_exception(zend_ce_exception, "Unable to expand filepath", 0);
return;
}
#if PHP_API_VERSION < 20100412
if (PG(safe_mode) && (!php_checkuid(fullpath, NULL, CHECKUID_CHECK_FILE_AND_DIR))) {
zend_throw_exception_ex(zend_exception_ce, 0, "safe_mode prohibits opening %s", fullpath);
zend_throw_exception_ex(zend_ce_exception, 0, "safe_mode prohibits opening %s", fullpath);
efree(fullpath);
return;
}
#endif
if (php_check_open_basedir(fullpath)) {
zend_throw_exception_ex(zend_exception_ce, 0, "open_basedir prohibits opening %s", fullpath);
zend_throw_exception_ex(zend_ce_exception, 0, "open_basedir prohibits opening %s", fullpath);
efree(fullpath);
return;
}
@ -145,7 +145,7 @@ PHP_METHOD(sqlite3, open)
#else
if (sqlite3_open(fullpath, &(db_obj->db)) != SQLITE_OK) {
#endif
zend_throw_exception_ex(zend_exception_ce, 0, "Unable to open database: %s", sqlite3_errmsg(db_obj->db));
zend_throw_exception_ex(zend_ce_exception, 0, "Unable to open database: %s", sqlite3_errmsg(db_obj->db));
if (fullpath) {
efree(fullpath);
}
@ -155,7 +155,7 @@ PHP_METHOD(sqlite3, open)
#if SQLITE_HAS_CODEC
if (encryption_key_len > 0) {
if (sqlite3_key(db_obj->db, encryption_key, encryption_key_len) != SQLITE_OK) {
zend_throw_exception_ex(zend_exception_ce, 0, "Unable to open database: %s", sqlite3_errmsg(db_obj->db));
zend_throw_exception_ex(zend_ce_exception, 0, "Unable to open database: %s", sqlite3_errmsg(db_obj->db));
return;
}
}
@ -1807,7 +1807,7 @@ PHP_METHOD(sqlite3result, finalize)
__constructor for SQLite3Result. */
PHP_METHOD(sqlite3result, __construct)
{
zend_throw_exception(zend_exception_ce, "SQLite3Result cannot be directly instantiated", 0);
zend_throw_exception(zend_ce_exception, "SQLite3Result cannot be directly instantiated", 0);
}
/* }}} */

2
ext/standard/assert.c
View File

@ -114,7 +114,7 @@ PHP_MINIT_FUNCTION(assert) /* {{{ */
REGISTER_LONG_CONSTANT("ASSERT_EXCEPTION", ASSERT_EXCEPTION, CONST_CS|CONST_PERSISTENT);
INIT_CLASS_ENTRY(ce, "AssertionError", NULL);
assertion_error_ce = zend_register_internal_class_ex(&ce, zend_error_ce);
assertion_error_ce = zend_register_internal_class_ex(&ce, zend_ce_error);
return SUCCESS;
}

2
sapi/cli/php_cli.c
View File

@ -1090,7 +1090,7 @@ static int do_cli(int argc, char **argv) /* {{{ */
zval tmp, *msg, rv;
ZVAL_OBJ(&tmp, EG(exception));
msg = zend_read_property(zend_exception_ce, &tmp, "message", sizeof("message")-1, 0, &rv);
msg = zend_read_property(zend_ce_exception, &tmp, "message", sizeof("message")-1, 0, &rv);
zend_printf("Exception: %s\n", Z_STRVAL_P(msg));
zval_ptr_dtor(&tmp);
EG(exception) = NULL;

Write Preview
Loading…
Cancel
Save