Switch position of ce in exception ce variable names

6 files changed, 81 insertions, 81 deletions

diff --git a/Zend/zend.c b/Zend/zend.c
index 1a74d316c0..e824b75c8d 100644
--- a/Zend/zend.c
+++ b/Zend/zend.c
@@ -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);
 	}
diff --git a/Zend/zend_exceptions.c b/Zend/zend_exceptions.c
index 0f3ad2b06a..9a1b79184a 100644
--- a/Zend/zend_exceptions.c
+++ b/Zend/zend_exceptions.c
@@ -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"));
 			}
diff --git a/Zend/zend_exceptions.h b/Zend/zend_exceptions.h
index 268109af61..f9bf24b4c2 100644
--- a/Zend/zend_exceptions.h
+++ b/Zend/zend_exceptions.h
@@ -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, ...);
diff --git a/Zend/zend_generators.c b/Zend/zend_generators.c
index 2c68a3ad7e..66692db905 100644
--- a/Zend/zend_generators.c
+++ b/Zend/zend_generators.c
@@ -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);
 }
 /* }}} */
 
diff --git a/Zend/zend_language_scanner.c b/Zend/zend_language_scanner.c
index 63cab792b3..9e2250b926 100644
--- a/Zend/zend_language_scanner.c
+++ b/Zend/zend_language_scanner.c
@@ -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);
 		}
 	}
diff --git a/Zend/zend_language_scanner.l b/Zend/zend_language_scanner.l
index ca2b202dd7..4498edae5c 100644
--- a/Zend/zend_language_scanner.l
+++ b/Zend/zend_language_scanner.l
@@ -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);
 		}
 	}