Implement comparison pattern

We'll go with either ranges or this, yet to decide.

Author: iluuu1994

Zend/tests/pattern_matching/is/comparison.phpt

@@ -0,0 +1,65 @@
+--TEST--
+Comparison pattern
+--FILE--
+<?php
+
+echo "Basic comparison\n";
+
+var_dump(0 is <0);
+var_dump(0 is <1);
+var_dump(1 is <0);
+var_dump(0 is <=0);
+var_dump(0 is <=1);
+var_dump(1 is <=0);
+var_dump(0 is >0);
+var_dump(0 is >1);
+var_dump(1 is >0);
+var_dump(0 is >=0);
+var_dump(0 is >=1);
+var_dump(1 is >=0);
+
+echo "\nNumeric strings\n";
+
+var_dump('1' is >0);
+var_dump('1e2' is >99);
+var_dump('1e2' is >101);
+var_dump('3.141' is >3);
+var_dump('3.141' is >4);
+
+echo "\nNon-numeric\n";
+
+var_dump('foo' is >0);
+var_dump('10foo' is >0);
+var_dump('10 foo' is >0);
+var_dump([] is >0);
+var_dump(new stdClass is >0);
+
+?>
+--EXPECT--
+Basic comparison
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(true)
+bool(false)
+bool(false)
+bool(false)
+bool(true)
+bool(true)
+bool(false)
+bool(true)
+
+Numeric strings
+bool(true)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+
+Non-numeric
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)

Zend/zend_ast.h

@@ -119,6 +119,7 @@ enum _zend_ast_kind {
 	ZEND_AST_ARRAY_PATTERN,
 	ZEND_AST_BINDING_PATTERN,
 	ZEND_AST_EXPR_LIKE_PATTERN,
+	ZEND_AST_COMPARISON_PATTERN,
 
 	/* 2 child nodes */
 	ZEND_AST_DIM = 2 << ZEND_AST_NUM_CHILDREN_SHIFT,

Zend/zend_compile.c

@@ -7034,6 +7034,49 @@ static void zend_pm_compile_range(zend_ast *ast, znode *result, znode *expr_node
 	}
 }
 
+static void zend_pm_compile_comparison(zend_ast *ast, znode *result, znode *expr_node, bool consume_expr, uint32_t false_opnum, zend_pm_context *context)
+{
+	zend_op *opline;
+
+	uint32_t false_label = consume_expr ? zend_pm_label_create(context) : false_opnum;
+
+	opline = zend_emit_op_tmp(NULL, ZEND_IS_NUMERIC, expr_node, NULL);
+	SET_NODE(opline->result, result);
+	zend_pm_emit_jmpz_ex(result, false_label);
+
+	znode expr_node_copy;
+	zend_pm_copy_tmp(&expr_node_copy, expr_node, false);
+
+	zend_ast *const_ast = ast->child[0];
+	znode const_node;
+	const_node.op_type = IS_CONST;
+	ZVAL_COPY(&const_node.u.constant, zend_ast_get_zval(const_ast));
+
+	switch (ast->attr) {
+		case ZEND_COMPARISON_PATTERN_SMALLER:
+			opline = zend_emit_op_tmp(NULL, ZEND_IS_SMALLER, &expr_node_copy, &const_node);
+			break;
+		case ZEND_COMPARISON_PATTERN_SMALLER_OR_EQUAL:
+			opline = zend_emit_op_tmp(NULL, ZEND_IS_SMALLER_OR_EQUAL, &expr_node_copy, &const_node);
+			break;
+		case ZEND_COMPARISON_PATTERN_GREATER:
+			opline = zend_emit_op_tmp(NULL, ZEND_IS_SMALLER, &const_node, &expr_node_copy);
+			break;
+		case ZEND_COMPARISON_PATTERN_GREATER_OR_EQUAL:
+			opline = zend_emit_op_tmp(NULL, ZEND_IS_SMALLER_OR_EQUAL, &const_node, &expr_node_copy);
+			break;
+		EMPTY_SWITCH_DEFAULT_CASE();
+	}
+	SET_NODE(opline->result, result);
+	zend_pm_emit_jmpz_ex(result, false_label);
+
+	if (consume_expr) {
+		zend_pm_label_set_next(context, false_label);
+		zend_emit_op(NULL, ZEND_FREE, expr_node, NULL);
+		zend_pm_emit_jmpz_ex(result, false_opnum);
+	}
+}
+
 static void zend_compile_pattern(zend_ast *ast, znode *result, znode *expr_node, bool consume_expr, uint32_t false_opnum, zend_pm_context *context)
 {
 	bool create_label = false_opnum == (uint32_t)-1;
@@ -7069,6 +7112,9 @@ static void zend_compile_pattern(zend_ast *ast, znode *result, znode *expr_node,
 		case ZEND_AST_RANGE_INCLUSIVE:
 			zend_pm_compile_range(ast, result, expr_node, consume_expr, false_opnum, context, true);
 			break;
+		case ZEND_AST_COMPARISON_PATTERN:
+			zend_pm_compile_comparison(ast, result, expr_node, consume_expr, false_opnum, context);
+			break;
 		EMPTY_SWITCH_DEFAULT_CASE();
 	}
 

Zend/zend_compile.h

@@ -1228,6 +1228,11 @@ static zend_always_inline bool zend_check_arg_send_type(const zend_function *zf,
 /* Array pattern contains ... */
 #define ZEND_ARRAY_PATTERN_NON_EXHAUSTIVE (1<<1)
 
+#define ZEND_COMPARISON_PATTERN_SMALLER          0
+#define ZEND_COMPARISON_PATTERN_SMALLER_OR_EQUAL 1
+#define ZEND_COMPARISON_PATTERN_GREATER          2
+#define ZEND_COMPARISON_PATTERN_GREATER_OR_EQUAL 3
+
 /* For "use" AST nodes and the seen symbol table */
 #define ZEND_SYMBOL_CLASS    (1<<0)
 #define ZEND_SYMBOL_FUNCTION (1<<1)

Zend/zend_language_parser.y

@@ -296,11 +296,12 @@ static YYSIZE_T zend_yytnamerr(char*, const char*);
 %type <ast> object_pattern object_pattern_element_list non_empty_object_pattern_element_list
 %type <ast> object_pattern_element binding_pattern
 %type <ast> array_pattern array_pattern_element_list array_pattern_element
-%type <ast> range_pattern range_pattern_element
+%type <ast> range_pattern range_pattern_element comparison_pattern comparison_pattern_element
 
 %type <num> returns_ref function fn is_reference is_variadic property_modifiers property_hook_modifiers
 %type <num> method_modifiers class_const_modifiers member_modifier optional_cpp_modifiers
 %type <num> class_modifiers class_modifier anonymous_class_modifiers anonymous_class_modifiers_optional use_type backup_fn_flags
+%type <num> comparison_pattern_op
 
 %type <ptr> backup_lex_pos
 %type <str> backup_doc_comment
@@ -1422,6 +1423,7 @@ atomic_pattern:
 	|	array_pattern { $$ = $1; }
 	|	binding_pattern { $$ = $1; }
 	|	class_const_pattern { $$ = zend_ast_create(ZEND_AST_EXPR_LIKE_PATTERN, $1); }
+	|	comparison_pattern { $$ = $1; }
 	|	'(' pattern ')' {
 			$$ = $2;
 			$$->attr = ZEND_PARENTHESIZED_PATTERN;
@@ -1492,6 +1494,22 @@ range_pattern_element:
 	|	T_DNUMBER { $$ = $1; }
 ;
 
+comparison_pattern_op:
+		'<' { $<num>$ = ZEND_COMPARISON_PATTERN_SMALLER; }
+	|	T_IS_SMALLER_OR_EQUAL { $<num>$ = ZEND_COMPARISON_PATTERN_SMALLER_OR_EQUAL; }
+	|	'>' { $<num>$ = ZEND_COMPARISON_PATTERN_GREATER; }
+	|	T_IS_GREATER_OR_EQUAL { $<num>$ = ZEND_COMPARISON_PATTERN_GREATER_OR_EQUAL; }
+;
+
+comparison_pattern_element:
+		T_LNUMBER { $$ = $1; }
+	|	T_DNUMBER { $$ = $1; }
+;
+
+comparison_pattern:
+	comparison_pattern_op comparison_pattern_element { $$ = zend_ast_create_ex(ZEND_AST_COMPARISON_PATTERN, $1, $2); }
+;
+
 binding_pattern:
 		T_VARIABLE { $$ = zend_ast_create(ZEND_AST_BINDING_PATTERN, $1); }
 ;

Zend/zend_opcode.c

@@ -907,7 +907,8 @@ static bool keeps_op1_alive(zend_op *opline) {
 	 || opline->opcode == ZEND_FETCH_LIST_W
 	 || opline->opcode == ZEND_COPY_TMP
 	 || opline->opcode == ZEND_EXT_STMT
-	 || opline->opcode == ZEND_HAS_TYPE) {
+	 || opline->opcode == ZEND_HAS_TYPE
+	 || opline->opcode == ZEND_IS_NUMERIC) {
 		return true;
 	}
 	ZEND_ASSERT(opline->opcode != ZEND_FE_FETCH_R

Zend/zend_vm_def.h

@@ -9979,6 +9979,33 @@ ZEND_VM_HANDLER(209, ZEND_INIT_PARENT_PROPERTY_HOOK_CALL, CONST, UNUSED|NUM, NUM
 	ZEND_VM_NEXT_OPCODE();
 }
 
+ZEND_VM_HANDLER(212, ZEND_IS_NUMERIC, ANY, UNUSED)
+{
+	USE_OPLINE
+
+	zval *op1 = GET_OP1_ZVAL_PTR(BP_VAR_R);
+	zval *result = EX_VAR(opline->result.var);
+
+ZEND_VM_C_LABEL(try_again):
+	switch (Z_TYPE_P(op1)) {
+		case IS_LONG:
+		case IS_DOUBLE:
+			ZVAL_TRUE(result);
+			break;
+		case IS_STRING:
+			ZVAL_BOOL(result, is_numeric_string(Z_STRVAL_P(op1), Z_STRLEN_P(op1), NULL, NULL, 0));
+			break;
+		case IS_REFERENCE:
+			op1 = Z_REFVAL_P(op1);
+			ZEND_VM_C_GOTO(try_again);
+		default:
+			ZVAL_FALSE(result);
+			break;
+	}
+
+	ZEND_VM_NEXT_OPCODE();
+}
+
 ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_JMP, (OP_JMP_ADDR(op, op->op1) > op), ZEND_JMP_FORWARD, JMP_ADDR, ANY)
 {
 	USE_OPLINE