- Improve comments, docs, code...

1 files changed, 923 insertions, 857 deletions

diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php
index 079dd4279d..f8d25b77d4 100644
--- a/Zend/zend_vm_gen.php
+++ b/Zend/zend_vm_gen.php
@@ -1,7 +1,7 @@
 <?php
-/* 
-   This script creates zend_vm_execute.h and zend_vm_opcodes.h
-   from existing zend_vm_def.h and zend_vm_execute.skl
+/*
+	This script creates zend_vm_execute.h and zend_vm_opcodes.h
+	from existing zend_vm_def.h and zend_vm_execute.skl
 */
 
 error_reporting(E_ALL);
@@ -11,192 +11,192 @@ define("ZEND_VM_KIND_SWITCH", 2);
 define("ZEND_VM_KIND_GOTO",   3);
 
 $op_types = array(
-  "ANY",
-  "CONST",
-  "TMP",
-  "VAR",
-  "UNUSED",
-  "CV"
+	"ANY",
+	"CONST",
+	"TMP",
+	"VAR",
+	"UNUSED",
+	"CV"
 );
 
 $prefix = array(
-  "ANY"    => "",
-  "TMP"    => "_TMP",
-  "VAR"    => "_VAR",
-  "CONST"  => "_CONST",
-  "UNUSED" => "_UNUSED",
-  "CV"     => "_CV",
+	"ANY"    => "",
+	"TMP"    => "_TMP",
+	"VAR"    => "_VAR",
+	"CONST"  => "_CONST",
+	"UNUSED" => "_UNUSED",
+	"CV"     => "_CV",
 );
 
 $typecode = array(
-  "ANY"    => 0,
-  "TMP"    => 1,
-  "VAR"    => 2,
-  "CONST"  => 0,
-  "UNUSED" => 3,
-  "CV"     => 4,
+	"ANY"    => 0,
+	"TMP"    => 1,
+	"VAR"    => 2,
+	"CONST"  => 0,
+	"UNUSED" => 3,
+	"CV"     => 4,
 );
 
 $op1_type = array(
-  "ANY"    => "opline->op1.op_type",
-  "TMP"    => "IS_TMP_VAR",
-  "VAR"    => "IS_VAR",
-  "CONST"  => "IS_CONST",
-  "UNUSED" => "IS_UNUSED",
-  "CV"     => "IS_CV",
+	"ANY"    => "opline->op1.op_type",
+	"TMP"    => "IS_TMP_VAR",
+	"VAR"    => "IS_VAR",
+	"CONST"  => "IS_CONST",
+	"UNUSED" => "IS_UNUSED",
+	"CV"     => "IS_CV",
 );
 
 $op2_type = array(
-  "ANY"    => "opline->op2.op_type",
-  "TMP"    => "IS_TMP_VAR",
-  "VAR"    => "IS_VAR",
-  "CONST"  => "IS_CONST",
-  "UNUSED" => "IS_UNUSED",
-  "CV"     => "IS_CV",
+	"ANY"    => "opline->op2.op_type",
+	"TMP"    => "IS_TMP_VAR",
+	"VAR"    => "IS_VAR",
+	"CONST"  => "IS_CONST",
+	"UNUSED" => "IS_UNUSED",
+	"CV"     => "IS_CV",
 );
 
 $op1_get_zval_ptr = array(
-  "ANY"    => "get_zval_ptr(&opline->op1, EX(Ts), &free_op1, \\1)",
-  "TMP"    => "_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
-  "VAR"    => "_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
-  "CONST"  => "_get_zval_ptr_const(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
-  "UNUSED" => "_get_zval_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
-  "CV"     => "_get_zval_ptr_cv(&opline->op1, EX(Ts), &free_op1, \\1 TSRMLS_CC)",
+	"ANY"    => "get_zval_ptr(&opline->op1, EX(Ts), &free_op1, \\1)",
+	"TMP"    => "_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
+	"VAR"    => "_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
+	"CONST"  => "_get_zval_ptr_const(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
+	"UNUSED" => "_get_zval_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
+	"CV"     => "_get_zval_ptr_cv(&opline->op1, EX(Ts), &free_op1, \\1 TSRMLS_CC)",
 );
 
 $op2_get_zval_ptr = array(
-  "ANY"    => "get_zval_ptr(&opline->op2, EX(Ts), &free_op2, \\1)",
-  "TMP"    => "_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
-  "VAR"    => "_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
-  "CONST"  => "_get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
-  "UNUSED" => "_get_zval_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
-  "CV"     => "_get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, \\1 TSRMLS_CC)",
+	"ANY"    => "get_zval_ptr(&opline->op2, EX(Ts), &free_op2, \\1)",
+	"TMP"    => "_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
+	"VAR"    => "_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
+	"CONST"  => "_get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
+	"UNUSED" => "_get_zval_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
+	"CV"     => "_get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, \\1 TSRMLS_CC)",
 );
 
 $op1_get_zval_ptr_ptr = array(
-  "ANY"    => "get_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, \\1)",
-  "TMP"    => "_get_zval_ptr_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
-  "VAR"    => "_get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
-  "CONST"  => "_get_zval_ptr_ptr_const(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
-  "UNUSED" => "_get_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
-  "CV"     => "_get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, \\1 TSRMLS_CC)",
+	"ANY"    => "get_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, \\1)",
+	"TMP"    => "_get_zval_ptr_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
+	"VAR"    => "_get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
+	"CONST"  => "_get_zval_ptr_ptr_const(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
+	"UNUSED" => "_get_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
+	"CV"     => "_get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, \\1 TSRMLS_CC)",
 );
 
 $op2_get_zval_ptr_ptr = array(
-  "ANY"    => "get_zval_ptr_ptr(&opline->op2, EX(Ts), &free_op2, \\1)",
-  "TMP"    => "_get_zval_ptr_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
-  "VAR"    => "_get_zval_ptr_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
-  "CONST"  => "_get_zval_ptr_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
-  "UNUSED" => "_get_zval_ptr_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
-  "CV"     => "_get_zval_ptr_ptr_cv(&opline->op2, EX(Ts), &free_op2, \\1 TSRMLS_CC)",
+	"ANY"    => "get_zval_ptr_ptr(&opline->op2, EX(Ts), &free_op2, \\1)",
+	"TMP"    => "_get_zval_ptr_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
+	"VAR"    => "_get_zval_ptr_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
+	"CONST"  => "_get_zval_ptr_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
+	"UNUSED" => "_get_zval_ptr_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
+	"CV"     => "_get_zval_ptr_ptr_cv(&opline->op2, EX(Ts), &free_op2, \\1 TSRMLS_CC)",
 );
 
 $op1_get_obj_zval_ptr = array(
-  "ANY"    => "get_obj_zval_ptr(&opline->op1, EX(Ts), &free_op1, \\1)",
-  "TMP"    => "_get_obj_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
-  "VAR"    => "_get_obj_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
-  "CONST"  => "_get_obj_zval_ptr_const(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
-  "UNUSED" => "_get_obj_zval_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
-  "CV"     => "_get_obj_zval_ptr_cv(&opline->op1, EX(Ts), &free_op1, \\1 TSRMLS_CC)",
+	"ANY"    => "get_obj_zval_ptr(&opline->op1, EX(Ts), &free_op1, \\1)",
+	"TMP"    => "_get_obj_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
+	"VAR"    => "_get_obj_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
+	"CONST"  => "_get_obj_zval_ptr_const(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
+	"UNUSED" => "_get_obj_zval_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
+	"CV"     => "_get_obj_zval_ptr_cv(&opline->op1, EX(Ts), &free_op1, \\1 TSRMLS_CC)",
 );
 
 $op2_get_obj_zval_ptr = array(
-  "ANY"    => "get_obj_zval_ptr(&opline->op2, EX(Ts), &free_op2, \\1)",
-  "TMP"    => "_get_obj_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
-  "VAR"    => "_get_obj_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
-  "CONST"  => "_get_obj_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
-  "UNUSED" => "_get_obj_zval_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
-  "CV"     => "_get_obj_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, \\1 TSRMLS_CC)",
+	"ANY"    => "get_obj_zval_ptr(&opline->op2, EX(Ts), &free_op2, \\1)",
+	"TMP"    => "_get_obj_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
+	"VAR"    => "_get_obj_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
+	"CONST"  => "_get_obj_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
+	"UNUSED" => "_get_obj_zval_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
+	"CV"     => "_get_obj_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, \\1 TSRMLS_CC)",
 );
 
 $op1_get_obj_zval_ptr_ptr = array(
-  "ANY"    => "get_obj_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, \\1)",
-  "TMP"    => "_get_obj_zval_ptr_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
-  "VAR"    => "_get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
-  "CONST"  => "_get_obj_zval_ptr_ptr_const(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
-  "UNUSED" => "_get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
-  "CV"     => "_get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, \\1 TSRMLS_CC)",
+	"ANY"    => "get_obj_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, \\1)",
+	"TMP"    => "_get_obj_zval_ptr_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
+	"VAR"    => "_get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
+	"CONST"  => "_get_obj_zval_ptr_ptr_const(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
+	"UNUSED" => "_get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)",
+	"CV"     => "_get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, \\1 TSRMLS_CC)",
 );
 
 $op2_get_obj_zval_ptr_ptr = array(
-  "ANY"    => "get_obj_zval_ptr_ptr(&opline->op2, EX(Ts), &free_op2, \\1)",
-  "TMP"    => "_get_obj_zval_ptr_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
-  "VAR"    => "_get_obj_zval_ptr_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
-  "CONST"  => "_get_obj_zval_ptr_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
-  "UNUSED" => "_get_obj_zval_ptr_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
-  "CV"     => "_get_obj_zval_ptr_ptr_cv(&opline->op2, EX(Ts), &free_op2, \\1 TSRMLS_CC)",
+	"ANY"    => "get_obj_zval_ptr_ptr(&opline->op2, EX(Ts), &free_op2, \\1)",
+	"TMP"    => "_get_obj_zval_ptr_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
+	"VAR"    => "_get_obj_zval_ptr_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
+	"CONST"  => "_get_obj_zval_ptr_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
+	"UNUSED" => "_get_obj_zval_ptr_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)",
+	"CV"     => "_get_obj_zval_ptr_ptr_cv(&opline->op2, EX(Ts), &free_op2, \\1 TSRMLS_CC)",
 );
 
 $op1_is_tmp_free = array(
-  "ANY"    => "IS_TMP_FREE(free_op1)",
-  "TMP"    => "1",
-  "VAR"    => "0",
-  "CONST"  => "0",
-  "UNUSED" => "0",
-  "CV"     => "0",
+	"ANY"    => "IS_TMP_FREE(free_op1)",
+	"TMP"    => "1",
+	"VAR"    => "0",
+	"CONST"  => "0",
+	"UNUSED" => "0",
+	"CV"     => "0",
 );
 
 $op2_is_tmp_free = array(
-  "ANY"    => "IS_TMP_FREE(free_op2)",
-  "TMP"    => "1",
-  "VAR"    => "0",
-  "CONST"  => "0",
-  "UNUSED" => "0",
-  "CV"     => "0",
+	"ANY"    => "IS_TMP_FREE(free_op2)",
+	"TMP"    => "1",
+	"VAR"    => "0",
+	"CONST"  => "0",
+	"UNUSED" => "0",
+	"CV"     => "0",
 );
 
 $op1_free_op = array(
-  "ANY"    => "FREE_OP(free_op1)",
-  "TMP"    => "zval_dtor(free_op1.var)",
-  "VAR"    => "if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}",
-  "CONST"  => "",
-  "UNUSED" => "",
-  "CV"     => "",
+	"ANY"    => "FREE_OP(free_op1)",
+	"TMP"    => "zval_dtor(free_op1.var)",
+	"VAR"    => "if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}",
+	"CONST"  => "",
+	"UNUSED" => "",
+	"CV"     => "",
 );
 
 $op2_free_op = array(
-  "ANY"    => "FREE_OP(free_op2)",
-  "TMP"    => "zval_dtor(free_op2.var)",
-  "VAR"    => "if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}",
-  "CONST"  => "",
-  "UNUSED" => "",
-  "CV"     => "",
+	"ANY"    => "FREE_OP(free_op2)",
+	"TMP"    => "zval_dtor(free_op2.var)",
+	"VAR"    => "if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}",
+	"CONST"  => "",
+	"UNUSED" => "",
+	"CV"     => "",
 );
 
 $op1_free_op_if_var = array(
-  "ANY"    => "FREE_OP_IF_VAR(free_op1)",
-  "TMP"    => "",
-  "VAR"    => "if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}",
-  "CONST"  => "",
-  "UNUSED" => "",
-  "CV"     => "",
+	"ANY"    => "FREE_OP_IF_VAR(free_op1)",
+	"TMP"    => "",
+	"VAR"    => "if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}",
+	"CONST"  => "",
+	"UNUSED" => "",
+	"CV"     => "",
 );
 
 $op2_free_op_if_var = array(
-  "ANY"    => "FREE_OP_IF_VAR(free_op2)",
-  "TMP"    => "",
-  "VAR"    => "if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}",
-  "CONST"  => "",
-  "UNUSED" => "",
-  "CV"     => "",
+	"ANY"    => "FREE_OP_IF_VAR(free_op2)",
+	"TMP"    => "",
+	"VAR"    => "if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}",
+	"CONST"  => "",
+	"UNUSED" => "",
+	"CV"     => "",
 );
 
 $op1_free_op_var_ptr = array(
-  "ANY"    => "if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}",
-  "TMP"    => "",
-  "VAR"    => "if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}",
-  "CONST"  => "",
-  "UNUSED" => "",
-  "CV"     => "",
+	"ANY"    => "if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}",
+	"TMP"    => "",
+	"VAR"    => "if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}",
+	"CONST"  => "",
+	"UNUSED" => "",
+	"CV"     => "",
 );
 
 $op2_free_op_var_ptr = array(
-  "ANY"    => "if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}",
-  "TMP"    => "",
-  "VAR"    => "if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}",
-  "CONST"  => "",
-  "UNUSED" => "",
-  "CV"     => "",
+	"ANY"    => "if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}",
+	"TMP"    => "",
+	"VAR"    => "if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}",
+	"CONST"  => "",
+	"UNUSED" => "",
+	"CV"     => "",
 );
 
 $list    = array(); // list of opcode handlers and helpers in original order
@@ -208,792 +208,858 @@ $line_no = 1;
 
 // Writes $s into resulting executor
 function out($f, $s) {
-  global $line_no;
-  fputs($f,$s);
-  $line_no += substr_count($s, "\n");
+	global $line_no;
+
+	fputs($f,$s);
+	$line_no += substr_count($s, "\n");
 }
 
 // Resets #line directives in resulting executor
 function out_line($f) {
-  global $line_no, $executor_file;
-  fputs($f,"#line ".($line_no+1)." \"".$executor_file."\"\n");
-  ++$line_no;
+	global $line_no, $executor_file;
+
+	fputs($f,"#line ".($line_no+1)." \"".$executor_file."\"\n");
+	++$line_no;
 }
 
 // Returns name of specialized helper
 function helper_name($name, $spec, $op1, $op2) {
-  global $prefix, $helpers;
-
-  if (isset($helpers[$name])) {
-    // If we haven't helper with specified spicialized operands then
-    // using unspecialized helper
-    if (!isset($helpers[$name]["op1"][$op1]) &&
-         isset($helpers[$name]["op1"]["ANY"])) {
-      $op1 = "ANY";
-    }
-    if (!isset($helpers[$name]["op2"][$op2]) &&
-         isset($helpers[$name]["op2"]["ANY"])) {
-      $op2 = "ANY";
-    }
-  }
-  return $name.($spec?"_SPEC":"").$prefix[$op1].$prefix[$op2];
+	global $prefix, $helpers;
+
+	if (isset($helpers[$name])) {
+		// If we haven't helper with specified spicialized operands then
+		// using unspecialized helper
+		if (!isset($helpers[$name]["op1"][$op1]) &&
+		    isset($helpers[$name]["op1"]["ANY"])) {
+			$op1 = "ANY";
+		}
+		if (!isset($helpers[$name]["op2"][$op2]) &&
+		    isset($helpers[$name]["op2"]["ANY"])) {
+			$op2 = "ANY";
+		}
+	}
+	return $name.($spec?"_SPEC":"").$prefix[$op1].$prefix[$op2];
 }
 
 // Generates code for opcode handler or helper
 function gen_code($f, $spec, $kind, $code, $op1, $op2) {
-  global $op1_type, $op2_type, $op1_get_zval_ptr, $op2_get_zval_ptr,
-    $op1_get_zval_ptr_ptr, $op2_get_zval_ptr_ptr,
-    $op1_get_obj_zval_ptr, $op2_get_obj_zval_ptr,
-    $op1_get_obj_zval_ptr_ptr, $op2_get_obj_zval_ptr_ptr,
-    $op1_is_tmp_free, $op2_is_tmp_free,
-    $op1_free_op, $op2_free_op, $op1_free_op_if_var, $op2_free_op_if_var,
-    $op1_free_op_var_ptr, $op2_free_op_var_ptr, $prefix;
-
-  // Specializing
-  $code = preg_replace(
-    array(
-      "/OP1_TYPE/",
-      "/OP2_TYPE/",
-      "/GET_OP1_ZVAL_PTR\(([^)]*)\)/",
-      "/GET_OP2_ZVAL_PTR\(([^)]*)\)/",
-      "/GET_OP1_ZVAL_PTR_PTR\(([^)]*)\)/",
-      "/GET_OP2_ZVAL_PTR_PTR\(([^)]*)\)/",
-      "/GET_OP1_OBJ_ZVAL_PTR\(([^)]*)\)/",
-      "/GET_OP2_OBJ_ZVAL_PTR\(([^)]*)\)/",
-      "/GET_OP1_OBJ_ZVAL_PTR_PTR\(([^)]*)\)/",
-      "/GET_OP2_OBJ_ZVAL_PTR_PTR\(([^)]*)\)/",
-      "/IS_OP1_TMP_FREE\(\)/",
-      "/IS_OP2_TMP_FREE\(\)/",
-      "/FREE_OP1\(\)/",
-      "/FREE_OP2\(\)/",
-      "/FREE_OP1_IF_VAR\(\)/",
-      "/FREE_OP2_IF_VAR\(\)/",
-      "/FREE_OP1_VAR_PTR\(\)/",
-      "/FREE_OP2_VAR_PTR\(\)/",
-      "/^#ifdef\s+ZEND_VM_SPEC\s*\n/m",
-      "/^#ifndef\s+ZEND_VM_SPEC\s*\n/m",
-      "/ZEND_VM_C_LABEL\(\s*([A-Za-z_]*)\s*\)/m",
-      "/ZEND_VM_C_GOTO\(\s*([A-Za-z_]*)\s*\)/m",
-    ),
-    array(
-      $op1_type[$op1],
-      $op2_type[$op2],
-      $op1_get_zval_ptr[$op1],
-      $op2_get_zval_ptr[$op2],
-      $op1_get_zval_ptr_ptr[$op1],
-      $op2_get_zval_ptr_ptr[$op2],
-      $op1_get_obj_zval_ptr[$op1],
-      $op2_get_obj_zval_ptr[$op2],
-      $op1_get_obj_zval_ptr_ptr[$op1],
-      $op2_get_obj_zval_ptr_ptr[$op2],
-      $op1_is_tmp_free[$op1],
-      $op2_is_tmp_free[$op2],
-      $op1_free_op[$op1],
-      $op2_free_op[$op2],
-      $op1_free_op_if_var[$op1],
-      $op2_free_op_if_var[$op2],
-      $op1_free_op_var_ptr[$op1],
-      $op2_free_op_var_ptr[$op2],
-      ($op1!="ANY"||$op2!="ANY")?"#if 1\n":"#if 0\n",
-      ($op1!="ANY"||$op2!="ANY")?"#if 0\n":"#if 1\n",
-      "\\1".(($spec && $kind != ZEND_VM_KIND_CALL)?("_SPEC".$prefix[$op1].$prefix[$op2]):""),
-      "goto \\1".(($spec && $kind != ZEND_VM_KIND_CALL)?("_SPEC".$prefix[$op1].$prefix[$op2]):""),
-    ),
-    $code); 
-
-  // Updating code according to selected threading model
-  switch($kind) {
-    case ZEND_VM_KIND_CALL:
-      $code = preg_replace(
-        array(
-          "/EXECUTE_DATA/m",
-          "/ZEND_VM_DISPATCH_TO_HANDLER\(\s*([A-Z_]*)\s*\)/m",
-          "/ZEND_VM_DISPATCH_TO_HELPER\(\s*([A-Za-z_]*)\s*\)/me",
-          "/ZEND_VM_DISPATCH_TO_HELPER_EX\(\s*([A-Za-z_]*)\s*,\s*[A-Za-z_]*\s*,\s*(.*)\s*\);/me",
-        ),
-        array(
-          "execute_data",
-          "return \\1".($spec?"_SPEC":"").$prefix[$op1].$prefix[$op2]."_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)",
-          "'return '.helper_name('\\1',$spec,'$op1','$op2').'(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)'",
-          "'return '.helper_name('\\1',$spec,'$op1','$op2').'(\\2, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);'",
-        ),
-        $code);
-      break;
-    case ZEND_VM_KIND_SWITCH:
-      $code = preg_replace(
-        array(
-          "/EXECUTE_DATA/m",
-          "/ZEND_VM_DISPATCH_TO_HANDLER\(\s*([A-Z_]*)\s*\)/m",
-          "/ZEND_VM_DISPATCH_TO_HELPER\(\s*([A-Za-z_]*)\s*\)/me",
-          "/ZEND_VM_DISPATCH_TO_HELPER_EX\(\s*([A-Za-z_]*)\s*,\s*([A-Za-z_]*)\s*,\s*(.*)\s*\);/me",
-        ),
-        array(
-          "&execute_data",
-          "goto \\1".($spec?"_SPEC":"").$prefix[$op1].$prefix[$op2]."_LABEL",
-          "'goto '.helper_name('\\1',$spec,'$op1','$op2')",
-          "'\\2 = \\3; goto '.helper_name('\\1',$spec,'$op1','$op2').';'",
-        ),
-        $code);
-      break;
-    case ZEND_VM_KIND_GOTO:
-      $code = preg_replace(
-        array(
-          "/EXECUTE_DATA/m",
-          "/ZEND_VM_DISPATCH_TO_HANDLER\(\s*([A-Z_]*)\s*\)/m",
-          "/ZEND_VM_DISPATCH_TO_HELPER\(\s*([A-Za-z_]*)\s*\)/me",
-          "/ZEND_VM_DISPATCH_TO_HELPER_EX\(\s*([A-Za-z_]*)\s*,\s*([A-Za-z_]*)\s*,\s*(.*)\s*\);/me",
-        ),
-        array(
-          "&execute_data",
-          "goto \\1".($spec?"_SPEC":"").$prefix[$op1].$prefix[$op2]."_HANDLER",
-          "'goto '.helper_name('\\1',$spec,'$op1','$op2')",
-          "'\\2 = \\3; goto '.helper_name('\\1',$spec,'$op1','$op2').';'",
-        ),
-        $code);
-      break;
-  }
-  
-  out($f, $code);
+	global $op1_type, $op2_type, $op1_get_zval_ptr, $op2_get_zval_ptr,
+		$op1_get_zval_ptr_ptr, $op2_get_zval_ptr_ptr,
+		$op1_get_obj_zval_ptr, $op2_get_obj_zval_ptr,
+		$op1_get_obj_zval_ptr_ptr, $op2_get_obj_zval_ptr_ptr,
+		$op1_is_tmp_free, $op2_is_tmp_free,
+		$op1_free_op, $op2_free_op, $op1_free_op_if_var, $op2_free_op_if_var,
+		$op1_free_op_var_ptr, $op2_free_op_var_ptr, $prefix;
+
+	// Specializing
+	$code = preg_replace(
+		array(
+			"/OP1_TYPE/",
+			"/OP2_TYPE/",
+			"/GET_OP1_ZVAL_PTR\(([^)]*)\)/",
+			"/GET_OP2_ZVAL_PTR\(([^)]*)\)/",
+			"/GET_OP1_ZVAL_PTR_PTR\(([^)]*)\)/",
+			"/GET_OP2_ZVAL_PTR_PTR\(([^)]*)\)/",
+			"/GET_OP1_OBJ_ZVAL_PTR\(([^)]*)\)/",
+			"/GET_OP2_OBJ_ZVAL_PTR\(([^)]*)\)/",
+			"/GET_OP1_OBJ_ZVAL_PTR_PTR\(([^)]*)\)/",
+			"/GET_OP2_OBJ_ZVAL_PTR_PTR\(([^)]*)\)/",
+			"/IS_OP1_TMP_FREE\(\)/",
+			"/IS_OP2_TMP_FREE\(\)/",
+			"/FREE_OP1\(\)/",
+			"/FREE_OP2\(\)/",
+			"/FREE_OP1_IF_VAR\(\)/",
+			"/FREE_OP2_IF_VAR\(\)/",
+			"/FREE_OP1_VAR_PTR\(\)/",
+			"/FREE_OP2_VAR_PTR\(\)/",
+			"/^#ifdef\s+ZEND_VM_SPEC\s*\n/m",
+			"/^#ifndef\s+ZEND_VM_SPEC\s*\n/m",
+			"/ZEND_VM_C_LABEL\(\s*([A-Za-z_]*)\s*\)/m",
+			"/ZEND_VM_C_GOTO\(\s*([A-Za-z_]*)\s*\)/m",
+		),
+		array(
+			$op1_type[$op1],
+			$op2_type[$op2],
+			$op1_get_zval_ptr[$op1],
+			$op2_get_zval_ptr[$op2],
+			$op1_get_zval_ptr_ptr[$op1],
+			$op2_get_zval_ptr_ptr[$op2],
+			$op1_get_obj_zval_ptr[$op1],
+			$op2_get_obj_zval_ptr[$op2],
+			$op1_get_obj_zval_ptr_ptr[$op1],
+			$op2_get_obj_zval_ptr_ptr[$op2],
+			$op1_is_tmp_free[$op1],
+			$op2_is_tmp_free[$op2],
+			$op1_free_op[$op1],
+			$op2_free_op[$op2],
+			$op1_free_op_if_var[$op1],
+			$op2_free_op_if_var[$op2],
+			$op1_free_op_var_ptr[$op1],
+			$op2_free_op_var_ptr[$op2],
+			($op1!="ANY"||$op2!="ANY")?"#if 1\n":"#if 0\n",
+			($op1!="ANY"||$op2!="ANY")?"#if 0\n":"#if 1\n",
+			"\\1".(($spec && $kind != ZEND_VM_KIND_CALL)?("_SPEC".$prefix[$op1].$prefix[$op2]):""),
+			"goto \\1".(($spec && $kind != ZEND_VM_KIND_CALL)?("_SPEC".$prefix[$op1].$prefix[$op2]):""),
+		),
+		$code);
+
+	// Updating code according to selected threading model
+	switch($kind) {
+		case ZEND_VM_KIND_CALL:
+			$code = preg_replace(
+				array(
+					"/EXECUTE_DATA/m",
+					"/ZEND_VM_DISPATCH_TO_HANDLER\(\s*([A-Z_]*)\s*\)/m",
+					"/ZEND_VM_DISPATCH_TO_HELPER\(\s*([A-Za-z_]*)\s*\)/me",
+					"/ZEND_VM_DISPATCH_TO_HELPER_EX\(\s*([A-Za-z_]*)\s*,\s*[A-Za-z_]*\s*,\s*(.*)\s*\);/me",
+				),
+				array(
+					"execute_data",
+					"return \\1".($spec?"_SPEC":"").$prefix[$op1].$prefix[$op2]."_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)",
+					"'return '.helper_name('\\1',$spec,'$op1','$op2').'(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)'",
+					"'return '.helper_name('\\1',$spec,'$op1','$op2').'(\\2, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);'",
+				),
+				$code);
+			break;
+		case ZEND_VM_KIND_SWITCH:
+			$code = preg_replace(
+				array(
+					"/EXECUTE_DATA/m",
+					"/ZEND_VM_DISPATCH_TO_HANDLER\(\s*([A-Z_]*)\s*\)/m",
+					"/ZEND_VM_DISPATCH_TO_HELPER\(\s*([A-Za-z_]*)\s*\)/me",
+					"/ZEND_VM_DISPATCH_TO_HELPER_EX\(\s*([A-Za-z_]*)\s*,\s*([A-Za-z_]*)\s*,\s*(.*)\s*\);/me",
+				),
+				array(
+					"&execute_data",
+					"goto \\1".($spec?"_SPEC":"").$prefix[$op1].$prefix[$op2]."_LABEL",
+					"'goto '.helper_name('\\1',$spec,'$op1','$op2')",
+					"'\\2 = \\3; goto '.helper_name('\\1',$spec,'$op1','$op2').';'",
+				),
+				$code);
+			break;
+		case ZEND_VM_KIND_GOTO:
+			$code = preg_replace(
+				array(
+					"/EXECUTE_DATA/m",
+					"/ZEND_VM_DISPATCH_TO_HANDLER\(\s*([A-Z_]*)\s*\)/m",
+					"/ZEND_VM_DISPATCH_TO_HELPER\(\s*([A-Za-z_]*)\s*\)/me",
+					"/ZEND_VM_DISPATCH_TO_HELPER_EX\(\s*([A-Za-z_]*)\s*,\s*([A-Za-z_]*)\s*,\s*(.*)\s*\);/me",
+				),
+				array(
+					"&execute_data",
+					"goto \\1".($spec?"_SPEC":"").$prefix[$op1].$prefix[$op2]."_HANDLER",
+					"'goto '.helper_name('\\1',$spec,'$op1','$op2')",
+					"'\\2 = \\3; goto '.helper_name('\\1',$spec,'$op1','$op2').';'",
+				),
+				$code);
+			break;
+	}
+
+	out($f, $code);
 }
 
 // Generates opcode handler
 function gen_handler($f, $spec, $kind, $name, $op1, $op2, $use, $code, $lineno) {
-  global $definition_file, $prefix, $typecode, $opnames;
-
-  if (ZEND_VM_LINES) {
-    out($f, "#line $lineno \"$definition_file\"\n");
-  }
-
-  // Generate opcode handler's entry point according to selected threading model
-  switch($kind) {
-    case ZEND_VM_KIND_CALL:
-      out($f,"static int ".$name.($spec?"_SPEC":"").$prefix[$op1].$prefix[$op2]."_HANDLER(ZEND_OPCODE_HANDLER_ARGS)\n");
-      break;
-    case ZEND_VM_KIND_SWITCH:
-      if ($spec) {
-        out($f,"case ".((string)($opnames[$name]*25+($typecode[$op1]*5)+$typecode[$op2])).": /*".$name."_SPEC".$prefix[$op1].$prefix[$op2]."_HANDLER*/");
-      } else {
-        out($f,"case ".$name.":");
-      }
-      if ($use) {
-        // This handler is used by other handlers. We will add label to call it.
-        out($f," ".$name.($spec?"_SPEC":"").$prefix[$op1].$prefix[$op2]."_LABEL:\n");
-      } else {
-        out($f,"\n");
-      }
-      break;
-    case ZEND_VM_KIND_GOTO:
-      out($f,$name.($spec?"_SPEC":"").$prefix[$op1].$prefix[$op2]."_HANDLER:\n");
-      break;
-  }
-
-  // Generate opcode handler's code
-  gen_code($f, $spec, $kind, $code, $op1, $op2);
+	global $definition_file, $prefix, $typecode, $opnames;
+
+	if (ZEND_VM_LINES) {
+		out($f, "#line $lineno \"$definition_file\"\n");
+	}
+
+	// Generate opcode handler's entry point according to selected threading model
+	switch($kind) {
+		case ZEND_VM_KIND_CALL:
+			out($f,"static int ".$name.($spec?"_SPEC":"").$prefix[$op1].$prefix[$op2]."_HANDLER(ZEND_OPCODE_HANDLER_ARGS)\n");
+			break;
+		case ZEND_VM_KIND_SWITCH:
+			if ($spec) {
+				out($f,"case ".((string)($opnames[$name]*25+($typecode[$op1]*5)+$typecode[$op2])).": /*".$name."_SPEC".$prefix[$op1].$prefix[$op2]."_HANDLER*/");
+			} else {
+				out($f,"case ".$name.":");
+			}
+			if ($use) {
+				// This handler is used by other handlers. We will add label to call it.
+				out($f," ".$name.($spec?"_SPEC":"").$prefix[$op1].$prefix[$op2]."_LABEL:\n");
+			} else {
+				out($f,"\n");
+			}
+			break;
+		case ZEND_VM_KIND_GOTO:
+			out($f,$name.($spec?"_SPEC":"").$prefix[$op1].$prefix[$op2]."_HANDLER:\n");
+			break;
+	}
+
+	// Generate opcode handler's code
+	gen_code($f, $spec, $kind, $code, $op1, $op2);
 }
 
 // Generates helper
 function gen_helper($f, $spec, $kind, $name, $op1, $op2, $param, $code, $lineno) {
-  global $definition_file, $prefix;
-
-  if (ZEND_VM_LINES) {
-    out($f, "#line $lineno \"$definition_file\"\n");
-  }
-
-  // Generate helper's entry point according to selected threading model
-  switch($kind) {
-    case ZEND_VM_KIND_CALL:
-      if ($param == null) {
-        out($f, "static int ".$name.($spec?"_SPEC":"").$prefix[$op1].$prefix[$op2]."(ZEND_OPCODE_HANDLER_ARGS)\n");
-      } else {
-        out($f, "static int ".$name.($spec?"_SPEC":"").$prefix[$op1].$prefix[$op2]."(".$param.", ZEND_OPCODE_HANDLER_ARGS)\n");
-      }
-      break;
-    case ZEND_VM_KIND_SWITCH:
-      out($f, $name.($spec?"_SPEC":"").$prefix[$op1].$prefix[$op2].":\n");
-      break;
-    case ZEND_VM_KIND_GOTO:
-      out($f, $name.($spec?"_SPEC":"").$prefix[$op1].$prefix[$op2].":\n");
-      break;
-  }
-
-  // Generate helper's code
-  gen_code($f, $spec, $kind, $code, $op1, $op2);
+	global $definition_file, $prefix;
+
+	if (ZEND_VM_LINES) {
+		out($f, "#line $lineno \"$definition_file\"\n");
+	}
+
+	// Generate helper's entry point according to selected threading model
+	switch($kind) {
+		case ZEND_VM_KIND_CALL:
+			if ($param == null) {
+			  // Helper without parameters
+				out($f, "static int ".$name.($spec?"_SPEC":"").$prefix[$op1].$prefix[$op2]."(ZEND_OPCODE_HANDLER_ARGS)\n");
+			} else {
+			  // Helper with parameter
+				out($f, "static int ".$name.($spec?"_SPEC":"").$prefix[$op1].$prefix[$op2]."(".$param.", ZEND_OPCODE_HANDLER_ARGS)\n");
+			}
+			break;
+		case ZEND_VM_KIND_SWITCH:
+			out($f, $name.($spec?"_SPEC":"").$prefix[$op1].$prefix[$op2].":\n");
+			break;
+		case ZEND_VM_KIND_GOTO:
+			out($f, $name.($spec?"_SPEC":"").$prefix[$op1].$prefix[$op2].":\n");
+			break;
+	}
+
+	// Generate helper's code
+	gen_code($f, $spec, $kind, $code, $op1, $op2);
 }
 
 // Generates array of opcode handlers (specialized or unspecialized)
 function gen_labels($f, $spec, $kind, $prolog) {
-  global $opcodes, $op_types, $prefix, $typecode;
-
-  $next = 0;
-  if ($spec) {
-    foreach($opcodes as $num => $dsc) {
-      while ($next != $num) {
-        $op1t = $op_types;
-        foreach($op1t as $op1) {
-          if ($op1 != "ANY") {
-            $op2t = $op_types;
-            foreach($op2t as $op2) {
-              if ($op2 != "ANY") {              
-                switch ($kind) {
-                  case ZEND_VM_KIND_CALL:
-                    out($f,$prolog."ZEND_NULL_HANDLER,\n");
-                    break;
-                  case ZEND_VM_KIND_SWITCH:
-                    out($f,$prolog."(opcode_handler_t)-1,\n");
-                    break;
-                  case ZEND_VM_KIND_GOTO:
-                    out($f,$prolog."(opcode_handler_t)&&ZEND_NULL_HANDLER,\n");
-                    break;
-                }
-              }
-            }
-          }
-        }
-        $next++;
-      }
-      $next = $num + 1;
-      $op1t = $op_types;
-      foreach($op1t as $op1) {
-        if ($op1 != "ANY") {
-          if (!isset($dsc["op1"][$op1])) {
-            $op1 = "ANY";
-          }
-          $op2t = $op_types;
-          foreach($op2t as $op2) {
-            if ($op2 != "ANY") {              
-              if (!isset($dsc["op2"][$op2])) {
-                $op2 = "ANY";
-              }
-              if (isset($dsc["op1"][$op1]) &&
-                  isset($dsc["op2"][$op2])) {
-                switch ($kind) {
-                  case ZEND_VM_KIND_CALL:
-                    out($f,$prolog.$dsc["op"]."_SPEC".$prefix[$op1].$prefix[$op2]."_HANDLER,\n");
-                    break;
-                  case ZEND_VM_KIND_SWITCH:
-                    out($f,$prolog."(opcode_handler_t)".((string)($num*25+$typecode[$op1]*5+$typecode[$op2])).",\n");
-                    break;
-                  case ZEND_VM_KIND_GOTO:
-                    out($f,$prolog."(opcode_handler_t)&&".$dsc["op"]."_SPEC".$prefix[$op1].$prefix[$op2]."_HANDLER,\n");
-                    break;
-                }
-              } else {
-                switch ($kind) {
-                  case ZEND_VM_KIND_CALL:
-                    out($f,$prolog."ZEND_NULL_HANDLER,\n");
-                    break;
-                  case ZEND_VM_KIND_SWITCH:
-                    out($f,$prolog."(opcode_handler_t)-1,\n");
-                    break;
-                  case ZEND_VM_KIND_GOTO:
-                    out($f,$prolog."(opcode_handler_t)&&ZEND_NULL_HANDLER,\n");
-                    break;
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  } else {
-    foreach($opcodes as $num => $dsc) {
-      while ($next != $num) {
-        switch ($kind) {
-          case ZEND_VM_KIND_CALL:
-            out($f,$prolog."ZEND_NULL_HANDLER,\n");
-            break;
-          case ZEND_VM_KIND_SWITCH:
-            out($f,$prolog."(opcode_handler_t)-1,\n");
-            break;
-          case ZEND_VM_KIND_GOTO:
-            out($f,$prolog."(opcode_handler_t)&&ZEND_NULL_HANDLER,\n");
-            break;
-        }
-        $next++;
-      }
-      $next = $num+1;
-      switch ($kind) {
-        case ZEND_VM_KIND_CALL:
-          out($f,$prolog.$dsc["op"]."_HANDLER,\n");
-          break;
-        case ZEND_VM_KIND_SWITCH:
-          out($f,$prolog."(opcode_handler_t)".((string)$num).",\n");
-          break;
-        case ZEND_VM_KIND_GOTO:
-          out($f,$prolog."(opcode_handler_t)&&".$dsc["op"]."_HANDLER,\n");
-          break;
-      }
-    }
-  }
-
-  // Last handler
-  switch ($kind) {
-    case ZEND_VM_KIND_CALL:
-      out($f,$prolog."ZEND_NULL_HANDLER\n");
-      break;
-    case ZEND_VM_KIND_SWITCH:
-      out($f,$prolog."(opcode_handler_t)-1\n");
-      break;
-    case ZEND_VM_KIND_GOTO:
-      out($f,$prolog."(opcode_handler_t)&&ZEND_NULL_HANDLER\n");
-      break;
-  }
+	global $opcodes, $op_types, $prefix, $typecode;
+
+	$next = 0;
+	if ($spec) {
+	  // Emit labels for specialized executor
+
+	  // For each opcode in opcode number order
+		foreach($opcodes as $num => $dsc) {
+			while ($next != $num) {
+			  // If some opcode numbers are not used then fill hole with pointers
+			  // to handler of undefined opcode
+				$op1t = $op_types;
+				// For each op1.op_type except ANY
+				foreach($op1t as $op1) {
+					if ($op1 != "ANY") {
+						$op2t = $op_types;
+						// For each op2.op_type except ANY
+						foreach($op2t as $op2) {
+							if ($op2 != "ANY") {
+							  // Emit pointer to handler of undefined opcode
+								switch ($kind) {
+									case ZEND_VM_KIND_CALL:
+										out($f,$prolog."ZEND_NULL_HANDLER,\n");
+										break;
+									case ZEND_VM_KIND_SWITCH:
+										out($f,$prolog."(opcode_handler_t)-1,\n");
+										break;
+									case ZEND_VM_KIND_GOTO:
+										out($f,$prolog."(opcode_handler_t)&&ZEND_NULL_HANDLER,\n");
+										break;
+								}
+							}
+						}
+					}
+				}
+				$next++;
+			}
+			$next = $num + 1;
+			$op1t = $op_types;
+			// For each op1.op_type except ANY
+			foreach($op1t as $op1) {
+				if ($op1 != "ANY") {
+					if (!isset($dsc["op1"][$op1])) {
+						// Try to use unspecialized handler
+						$op1 = "ANY";
+					}
+					$op2t = $op_types;
+					// For each op2.op_type except ANY
+					foreach($op2t as $op2) {
+						if ($op2 != "ANY") {
+							if (!isset($dsc["op2"][$op2])) {
+								// Try to use unspecialized handler
+								$op2 = "ANY";
+							}
+							// Check if specialized handler is defined 
+							if (isset($dsc["op1"][$op1]) &&
+							    isset($dsc["op2"][$op2])) {
+							  // Emit pointer to specialized handler
+								switch ($kind) {
+									case ZEND_VM_KIND_CALL:
+										out($f,$prolog.$dsc["op"]."_SPEC".$prefix[$op1].$prefix[$op2]."_HANDLER,\n");
+										break;
+									case ZEND_VM_KIND_SWITCH:
+										out($f,$prolog."(opcode_handler_t)".((string)($num*25+$typecode[$op1]*5+$typecode[$op2])).",\n");
+										break;
+									case ZEND_VM_KIND_GOTO:
+										out($f,$prolog."(opcode_handler_t)&&".$dsc["op"]."_SPEC".$prefix[$op1].$prefix[$op2]."_HANDLER,\n");
+										break;
+								}
+							} else {
+							  // Emit pinter to handler of undefined opcode
+								switch ($kind) {
+									case ZEND_VM_KIND_CALL:
+										out($f,$prolog."ZEND_NULL_HANDLER,\n");
+										break;
+									case ZEND_VM_KIND_SWITCH:
+										out($f,$prolog."(opcode_handler_t)-1,\n");
+										break;
+									case ZEND_VM_KIND_GOTO:
+										out($f,$prolog."(opcode_handler_t)&&ZEND_NULL_HANDLER,\n");
+										break;
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	} else {
+	  // Emit labels for unspecialized executor
+
+	  // For each opcode in opcode number order
+		foreach($opcodes as $num => $dsc) {
+			while ($next != $num) {
+			  // If some opcode numbers are not used then fill hole with pointers
+			  // to handler of undefined opcode
+				switch ($kind) {
+					case ZEND_VM_KIND_CALL:
+						out($f,$prolog."ZEND_NULL_HANDLER,\n");
+						break;
+					case ZEND_VM_KIND_SWITCH:
+						out($f,$prolog."(opcode_handler_t)-1,\n");
+						break;
+					case ZEND_VM_KIND_GOTO:
+						out($f,$prolog."(opcode_handler_t)&&ZEND_NULL_HANDLER,\n");
+						break;
+				}
+				$next++;
+			}
+			$next = $num+1;
+		  // Emit pointer to unspecialized handler
+			switch ($kind) {
+				case ZEND_VM_KIND_CALL:
+					out($f,$prolog.$dsc["op"]."_HANDLER,\n");
+					break;
+				case ZEND_VM_KIND_SWITCH:
+					out($f,$prolog."(opcode_handler_t)".((string)$num).",\n");
+					break;
+				case ZEND_VM_KIND_GOTO:
+					out($f,$prolog."(opcode_handler_t)&&".$dsc["op"]."_HANDLER,\n");
+					break;
+			}
+		}
+	}
+
+	// Emit last handler's label (undefined opcode)
+	switch ($kind) {
+		case ZEND_VM_KIND_CALL:
+			out($f,$prolog."ZEND_NULL_HANDLER\n");
+			break;
+		case ZEND_VM_KIND_SWITCH:
+			out($f,$prolog."(opcode_handler_t)-1\n");
+			break;
+		case ZEND_VM_KIND_GOTO:
+			out($f,$prolog."(opcode_handler_t)&&ZEND_NULL_HANDLER\n");
+			break;
+	}
 }
 
 // Generates handler for undefined opcodes (CALL threading model)
 function gen_null_handler($f) {
-  static $done = 0;
-
-  if (!$done) {
-    $done = 1;
-    out($f,"static int ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)\n");
-    out($f,"{\n");
-    out($f,"\tzend_error_noreturn(E_ERROR, \"Invalid opcode %d/%d/%d.\", EX(opline)->opcode, EX(opline)->op1.op_type, EX(opline)->op2.op_type);\n");
-    out($f,"\tZEND_VM_RETURN_FROM_EXECUTE_LOOP();\n");
-    out($f,"}\n\n");
-  }
+	static $done = 0;
+
+	// New and all executors with CALL threading model can use the same handler 
+	// for undefined opcodes, do we emit code for it only once
+	if (!$done) {
+		$done = 1;
+		out($f,"static int ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)\n");
+		out($f,"{\n");
+		out($f,"\tzend_error_noreturn(E_ERROR, \"Invalid opcode %d/%d/%d.\", EX(opline)->opcode, EX(opline)->op1.op_type, EX(opline)->op2.op_type);\n");
+		out($f,"\tZEND_VM_RETURN_FROM_EXECUTE_LOOP();\n");
+		out($f,"}\n\n");
+	}
 }
 
 // Generates all opcode handlers and helpers (specialized or unspecilaized)
 function gen_executor_code($f, $spec, $kind, $prolog) {
-  global $list, $opcodes, $helpers, $op_types;
-
-  if ($spec) {
-    $op1t = $op_types;
-    foreach($op1t as $op1) {
-      $op2t = $op_types;
-      foreach($op2t as $op2) {
-        foreach ($list as $lineno => $dsc) {
-          if (isset($dsc["handler"])) {
-            $num = $dsc["handler"];
-            if (isset($opcodes[$num]["op1"][$op1]) &&
-                isset($opcodes[$num]["op2"][$op2])) {
-              gen_handler($f, 1, $kind, $opcodes[$num]["op"], $op1, $op2, isset($opcodes[$num]["use"]), $opcodes[$num]["code"], $lineno);
-            }
-          } else if (isset($dsc["helper"])) {
-            $num = $dsc["helper"];
-            if (isset($helpers[$num]["op1"][$op1]) &&
-                isset($helpers[$num]["op2"][$op2])) {
-              gen_helper($f, 1, $kind, $num, $op1, $op2, $helpers[$num]["param"], $helpers[$num]["code"], $lineno);
-            }
-          } else {
-            var_dump($dsc);
-            die("??? $kind:$num\n");
-          }
-        }
-      }
-    }
-  } else {
-    foreach ($list as $lineno => $dsc) {
-      if (isset($dsc["handler"])) {
-        $num = $dsc["handler"];
-        gen_handler($f, 0, $kind, $opcodes[$num]["op"], "ANY", "ANY", isset($opcodes[$num]["use"]), $opcodes[$num]["code"], $lineno);
-      } else if (isset($dsc["helper"])) {
-        $num = $dsc["helper"];
-        gen_helper($f, 0, $kind, $num, "ANY", "ANY", $helpers[$num]["param"], $helpers[$num]["code"], $lineno);
-      } else {
-        var_dump($dsc);
-        die("??? $kind:$num\n");
-      }
-    }
-  }
-  if (ZEND_VM_LINES) {
-    out_line($f);
-  }
-
-  // Generate handler for undefined opcodes
-  switch ($kind) {
-    case ZEND_VM_KIND_CALL:
-      gen_null_handler($f);
-      break;
-    case ZEND_VM_KIND_SWITCH:
-      out($f,"default:\n");
-      out($f,"\tzend_error_noreturn(E_ERROR, \"Invalid opcode %d/%d/%d.\", EX(opline)->opcode, EX(opline)->op1.op_type, EX(opline)->op2.op_type);\n");
-      out($f,"\tZEND_VM_RETURN_FROM_EXECUTE_LOOP();\n");
-      break;
-    case ZEND_VM_KIND_GOTO:
-      out($f,"ZEND_NULL_HANDLER:\n");
-      out($f,"\tzend_error_noreturn(E_ERROR, \"Invalid opcode %d/%d/%d.\", EX(opline)->opcode, EX(opline)->op1.op_type, EX(opline)->op2.op_type);\n");
-      out($f,"\tZEND_VM_RETURN_FROM_EXECUTE_LOOP();\n");
-      break;
-  }
+	global $list, $opcodes, $helpers, $op_types;
+
+	if ($spec) {
+		// Produce specialized executor
+		$op1t = $op_types;
+		// for each op1.op_type 
+		foreach($op1t as $op1) {
+			$op2t = $op_types;
+			// for each op2.op_type 
+			foreach($op2t as $op2) {
+				// for each handlers in helpers in original order
+				foreach ($list as $lineno => $dsc) {
+					if (isset($dsc["handler"])) {
+						$num = $dsc["handler"];
+						// Check if handler accepts such types of operands (op1 and op2)
+						if (isset($opcodes[$num]["op1"][$op1]) &&
+						    isset($opcodes[$num]["op2"][$op2])) {
+						  // Generate handler code
+							gen_handler($f, 1, $kind, $opcodes[$num]["op"], $op1, $op2, isset($opcodes[$num]["use"]), $opcodes[$num]["code"], $lineno);
+						}
+					} else if (isset($dsc["helper"])) {
+						$num = $dsc["helper"];
+						// Check if handler accepts such types of operands (op1 and op2)
+						if (isset($helpers[$num]["op1"][$op1]) &&
+						    isset($helpers[$num]["op2"][$op2])) {
+						  // Generate helper code
+							gen_helper($f, 1, $kind, $num, $op1, $op2, $helpers[$num]["param"], $helpers[$num]["code"], $lineno);
+						}
+					} else {
+						var_dump($dsc);
+						die("??? $kind:$num\n");
+					}
+				}
+			}
+		}
+	} else {
+		// Produce unspecialized executor
+
+		// for each handlers in helpers in original order
+		foreach ($list as $lineno => $dsc) {
+			if (isset($dsc["handler"])) {
+				$num = $dsc["handler"];
+			  // Generate handler code
+				gen_handler($f, 0, $kind, $opcodes[$num]["op"], "ANY", "ANY", isset($opcodes[$num]["use"]), $opcodes[$num]["code"], $lineno);
+			} else if (isset($dsc["helper"])) {
+				$num = $dsc["helper"];
+			  // Generate helper code
+				gen_helper($f, 0, $kind, $num, "ANY", "ANY", $helpers[$num]["param"], $helpers[$num]["code"], $lineno);
+			} else {
+				var_dump($dsc);
+				die("??? $kind:$num\n");
+			}
+		}
+	}
+
+	if (ZEND_VM_LINES) {
+		// Reset #line directives
+		out_line($f);
+	}
+
+	// Generate handler for undefined opcodes
+	switch ($kind) {
+		case ZEND_VM_KIND_CALL:
+			gen_null_handler($f);
+			break;
+		case ZEND_VM_KIND_SWITCH:
+			out($f,"default:\n");
+			out($f,"\tzend_error_noreturn(E_ERROR, \"Invalid opcode %d/%d/%d.\", EX(opline)->opcode, EX(opline)->op1.op_type, EX(opline)->op2.op_type);\n");
+			out($f,"\tZEND_VM_RETURN_FROM_EXECUTE_LOOP();\n");
+			break;
+		case ZEND_VM_KIND_GOTO:
+			out($f,"ZEND_NULL_HANDLER:\n");
+			out($f,"\tzend_error_noreturn(E_ERROR, \"Invalid opcode %d/%d/%d.\", EX(opline)->opcode, EX(opline)->op1.op_type, EX(opline)->op2.op_type);\n");
+			out($f,"\tZEND_VM_RETURN_FROM_EXECUTE_LOOP();\n");
+			break;
+	}
 }
 
 function skip_blanks($f, $prolog, $epilog) {
-  if (trim($prolog) != "" || trim($epilog) != "") {
-    out($f, $prolog.$epilog);
-  }
+	if (trim($prolog) != "" || trim($epilog) != "") {
+		out($f, $prolog.$epilog);
+	}
 }
 
 // Generates executor from skeleton file and definition (specialized or unspecialized)
 function gen_executor($f, $skl, $spec, $kind, $executor_name, $initializer_name, $old) {
-  global $params, $skeleton_file, $line_no;
-
-  $lineno      = 0;
-//  $old_line_no = -1;
-  foreach ($skl as $line) {
-//    if (ZEND_VM_LINES) {
-//      ++$lineno;
-//      if ($old_line_no+1 != $line_no) {
-//        out($f,"#line $lineno \"$skeleton_file\" /* $old_line_no, $line_no*/\n");
-//      }
-//      $old_line_no = $line_no;
-//    }
-    if (preg_match("/(.*)[{][%]([A-Z_]*)[%][}](.*)/", $line, $m)) {
-      switch ($m[2]) {
-        case "DEFINES":
-          switch ($kind) {
-            case ZEND_VM_KIND_CALL:
-              out($f,"\n");
-              out($f,"#define ZEND_VM_CONTINUE() return 0\n");
-              out($f,"#define ZEND_VM_RETURN()   return 1\n");
-              break;
-            case ZEND_VM_KIND_SWITCH:
-              out($f,"\n");
-              out($f,"#define ZEND_VM_CONTINUE() goto zend_vm_continue\n");
-              out($f,"#define ZEND_VM_RETURN()   return\n");
-              break;
-            case ZEND_VM_KIND_GOTO:
-              out($f,"\n");
-              out($f,"#define ZEND_VM_CONTINUE() goto *(void**)(EX(opline)->handler)\n");
-              out($f,"#define ZEND_VM_RETURN()   return\n");
-              break;
-          }
-          break;
-        case "EXECUTOR_NAME":
-          out($f, $m[1].$executor_name.$m[3]."\n");
-          break;
-        case "HELPER_VARS":
-          if ($kind != ZEND_VM_KIND_CALL) {
-            foreach ($params as $param => $x) {
-              out($f,$m[1].$param.";\n");
-            }
-          } else {
-            skip_blanks($f, $m[1], $m[3]."\n");
-          }
-          break;
-        case "INTERANL_LABELS":
-          if ($kind == ZEND_VM_KIND_GOTO) {
-            $prolog = $m[1];
-            out($f,$prolog."if (op_array == NULL) {\n");
-            out($f,$prolog."\tstatic const opcode_handler_t labels[] = {\n");
-            gen_labels($f, $spec, $kind, $prolog."\t\t");
-            out($f,$prolog."\t};\n");
-            out($f,$prolog."\tzend_opcode_handlers = (opcode_handler_t*)labels;\n");
-            out($f,$prolog."\treturn;\n");
-            out($f,$prolog."}\n");
-          } else {
-            skip_blanks($f, $m[1], $m[3]);
-          }
-          break;
-        case "ZEND_VM_CONTINUE_LABEL":
-          if ($kind == ZEND_VM_KIND_SWITCH) {
-            out($f,$m[1]."zend_vm_continue:".$m[3]."\n");
-          } else {
-            skip_blanks($f, $m[1], $m[3]);
-          }
-          break;
-        case "ZEND_VM_DISPATCH":
-          switch ($kind) {
-            case ZEND_VM_KIND_CALL:
-              out($f, $m[1]."if (EX(opline)->handler(&execute_data TSRMLS_CC) > 0)".$m[3]."\n");
-              break;
-            case ZEND_VM_KIND_SWITCH:
-              out($f, $m[1]."switch ((int)EX(opline)->handler)".$m[3]."\n");
-              break;
-            case ZEND_VM_KIND_GOTO:
-              out($f, $m[1]."goto *(void**)(EX(opline)->handler);".$m[3]."\n");
-              break;
-          }
-          break;
-        case "INTERNAL_EXECUTOR":
-          if ($kind == ZEND_VM_KIND_CALL) {
-            out($f, $m[1]."return;".$m[3]."\n");
-          } else {
-            gen_executor_code($f, $spec, $kind, $m[1]);
-          }
-          break;
-        case "EXTERNAL_EXECUTOR":
-          if ($kind == ZEND_VM_KIND_CALL) {
-            if (!$old || ZEND_VM_SPEC || (ZEND_VM_KIND != ZEND_VM_KIND_CALL)) {
-              out($f,"#undef EX\n");
-              out($f,"#define EX(element) execute_data->element\n\n");
-              gen_executor_code($f, $spec, $kind, $m[1]);
-            }
-          }
-          break;
-        case "INITIALIZER_NAME":
-          out($f, $m[1].$initializer_name.$m[3]."\n");
-          break;
-        case "EXTERNAL_LABELS":
-          $prolog = $m[1];
-          if ($kind == ZEND_VM_KIND_GOTO) {
-            out($f,$prolog."TSRMLS_FETCH();\n");
-            out($f,$prolog."zend_execute(NULL TSRMLS_CC);\n");
-          } else {
-            if ($old) {
-              out($f,$prolog."static opcode_handler_t labels[512] = {\n");
-            } else {
-              out($f,$prolog."static const opcode_handler_t labels[] = {\n");
-            }
-            gen_labels($f, $spec, $kind, $prolog."\t");
-            out($f,$prolog."};\n");
-            out($f,$prolog."zend_opcode_handlers = (opcode_handler_t*)labels;\n");
-            if ($old) {
-              out($f,$prolog."zend_vm_old_executor = 1;\n");
-              out($f,$prolog."zend_execute = old_execute;\n");
-            }
-          }
-          break;
-        default:
-          die("ERROR: Unknown keyword ".$m[2]." in skeleton file.\n");
-      }
-    } else {
-      out($f, $line);
-    }
-  }  
+	global $params, $skeleton_file, $line_no;
+
+	$lineno      = 0;
+	foreach ($skl as $line) {
+	  // Skeleton file contains special markers in form %NAME% those are
+	  // substituted by custom code
+		if (preg_match("/(.*)[{][%]([A-Z_]*)[%][}](.*)/", $line, $m)) {
+			switch ($m[2]) {
+				case "DEFINES":
+					switch ($kind) {
+						case ZEND_VM_KIND_CALL:
+							out($f,"\n");
+							out($f,"#define ZEND_VM_CONTINUE() return 0\n");
+							out($f,"#define ZEND_VM_RETURN()   return 1\n");
+							break;
+						case ZEND_VM_KIND_SWITCH:
+							out($f,"\n");
+							out($f,"#define ZEND_VM_CONTINUE() goto zend_vm_continue\n");
+							out($f,"#define ZEND_VM_RETURN()   return\n");
+							break;
+						case ZEND_VM_KIND_GOTO:
+							out($f,"\n");
+							out($f,"#define ZEND_VM_CONTINUE() goto *(void**)(EX(opline)->handler)\n");
+							out($f,"#define ZEND_VM_RETURN()   return\n");
+							break;
+					}
+					break;
+				case "EXECUTOR_NAME":
+					out($f, $m[1].$executor_name.$m[3]."\n");
+					break;
+				case "HELPER_VARS":
+					if ($kind != ZEND_VM_KIND_CALL) {
+					  // Emit local variables those are used for helpers' parameters
+						foreach ($params as $param => $x) {
+							out($f,$m[1].$param.";\n");
+						}
+					} else {
+						skip_blanks($f, $m[1], $m[3]."\n");
+					}
+					break;
+				case "INTERANL_LABELS":
+					if ($kind == ZEND_VM_KIND_GOTO) {
+					  // Emit array of labels of opcode handlers and code for
+					  // zend_opcode_handlers initialization
+						$prolog = $m[1];
+						out($f,$prolog."if (op_array == NULL) {\n");
+						out($f,$prolog."\tstatic const opcode_handler_t labels[] = {\n");
+						gen_labels($f, $spec, $kind, $prolog."\t\t");
+						out($f,$prolog."\t};\n");
+						out($f,$prolog."\tzend_opcode_handlers = (opcode_handler_t*)labels;\n");
+						out($f,$prolog."\treturn;\n");
+						out($f,$prolog."}\n");
+					} else {
+						skip_blanks($f, $m[1], $m[3]);
+					}
+					break;
+				case "ZEND_VM_CONTINUE_LABEL":
+					if ($kind == ZEND_VM_KIND_SWITCH) {
+					  // Only SWITCH dispatch method use it
+						out($f,$m[1]."zend_vm_continue:".$m[3]."\n");
+					} else {
+						skip_blanks($f, $m[1], $m[3]);
+					}
+					break;
+				case "ZEND_VM_DISPATCH":
+				  // Emit code that dispatches to opcode handler
+					switch ($kind) {
+						case ZEND_VM_KIND_CALL:
+							out($f, $m[1]."if (EX(opline)->handler(&execute_data TSRMLS_CC) > 0)".$m[3]."\n");
+							break;
+						case ZEND_VM_KIND_SWITCH:
+							out($f, $m[1]."switch ((int)EX(opline)->handler)".$m[3]."\n");
+							break;
+						case ZEND_VM_KIND_GOTO:
+							out($f, $m[1]."goto *(void**)(EX(opline)->handler);".$m[3]."\n");
+							break;
+					}
+					break;
+				case "INTERNAL_EXECUTOR":
+					if ($kind == ZEND_VM_KIND_CALL) {
+					  // Executor is defined as a set of functions
+						out($f, $m[1]."return;".$m[3]."\n");
+					} else {
+					  // Emit executor code
+						gen_executor_code($f, $spec, $kind, $m[1]);
+					}
+					break;
+				case "EXTERNAL_EXECUTOR":
+					if ($kind == ZEND_VM_KIND_CALL) {
+					  // Unspecialized executor with CALL threading is the same as the
+					  // old one, so we don't need to produce code twitch
+						if (!$old || ZEND_VM_SPEC || (ZEND_VM_KIND != ZEND_VM_KIND_CALL)) {
+							out($f,"#undef EX\n");
+							out($f,"#define EX(element) execute_data->element\n\n");
+						  // Emit executor code
+							gen_executor_code($f, $spec, $kind, $m[1]);
+						}
+					}
+					break;
+				case "INITIALIZER_NAME":
+					out($f, $m[1].$initializer_name.$m[3]."\n");
+					break;
+				case "EXTERNAL_LABELS":
+				  // Emit code that initializes zend_opcode_handlers array
+					$prolog = $m[1];
+					if ($kind == ZEND_VM_KIND_GOTO) {
+					  // Labels are defined in the executor itself, so we call it
+					  // with op_array NULL and it sets zend_opcode_handlers array
+						out($f,$prolog."TSRMLS_FETCH();\n");
+						out($f,$prolog."zend_execute(NULL TSRMLS_CC);\n");
+					} else {
+						if ($old) {
+						  // Reserving space for user-defined opcodes
+							out($f,$prolog."static opcode_handler_t labels[512] = {\n");
+						} else {
+							out($f,$prolog."static const opcode_handler_t labels[] = {\n");
+						}
+						gen_labels($f, $spec, $kind, $prolog."\t");
+						out($f,$prolog."};\n");
+						out($f,$prolog."zend_opcode_handlers = (opcode_handler_t*)labels;\n");
+						if ($old) {
+						  // Setup old executor
+							out($f,$prolog."zend_vm_old_executor = 1;\n");
+							out($f,$prolog."zend_execute = old_execute;\n");
+						}
+					}
+					break;
+				default:
+					die("ERROR: Unknown keyword ".$m[2]." in skeleton file.\n");
+			}
+		} else {
+		  // Copy the line as is
+			out($f, $line);
+		}
+	}
 }
 
 function gen_vm($def, $skel) {
-  global $definition_file, $skeleton_file, $executor_file,
-    $op_types, $list, $opcodes, $helpers, $params, $opnames;
-
-  // Load definition file
-  $in = @file($def);
-  if (!$in) {
-    die("ERROR: Can not open definition file '$def'\n");
-  }
-  $definition_file = realpath($def);
-
-  // Load skeleton file
-  $skl = @file($skel);
-  if (!$skl) {
-    die("ERROR: Can not open skeleton file '$skel'\n");
-  }
-  $skeleton_file = realpath($skel);
-
-  // Parse definition file into tree
-  $lineno         = 0;
-  $handler        = null;
-  $helper         = null;
-  $max_opcode_len = 0;
-  $max_opcode     = 0;
-  foreach ($in as $line) {
-    ++$lineno;
-    if (strpos($line,"ZEND_VM_HANDLER(") === 0) {
-      if (preg_match(
-        "/^ZEND_VM_HANDLER\(\s*([0-9]+)\s*,\s*([A-Z_]+)\s*,\s*([A-Z|]+)\s*,\s*([A-Z|]+)\s*\)/",
-        $line,
-        $m) == 0) {
-        die("ERROR ($def:$lineno): Invalid ZEND_VM_HANDLER definition.\n");
-      }
-      $code = (int)$m[1];
-      $op   = $m[2];
-      $len  = strlen($op);
-      $op1  = array_flip(explode("|",$m[3]));
-      $op2  = array_flip(explode("|",$m[4]));
-
-      if ($len > $max_opcode_len) {
-        $max_opcode_len = $len;
-      }
-      if ($code > $max_opcode) {
-        $max_opcode = $code;
-      }
-      if (isset($opcodes[$code])) {
-        die("ERROR ($def:$lineno): Opcode with code '$code' is already defined.\n");
-      }
-      if (isset($opnames[$op])) {
-        die("ERROR ($def:$lineno): Opcode with name '$op' is already defined.\n");
-      }
-      $opcodes[$code] = array("op"=>$op,"op1"=>$op1,"op2"=>$op2,"code"=>"");
-      $opnames[$op] = $code;
-      $handler = $code;
-      $helper = null;
-      $list[$lineno] = array("handler"=>$handler);
-    } else if (strpos($line,"ZEND_VM_HELPER(") === 0) {
-      if (preg_match(
-        "/^ZEND_VM_HELPER\(\s*([A-Za-z_]+)\s*,\s*([A-Z|]+)\s*,\s*([A-Z|]+)\s*\)/",
-        $line,
-        $m) == 0) {
-        die("ERROR ($def:$lineno): Invalid ZEND_VM_HELPER definition.\n");
-      }
-      $helper = $m[1];
-      $op1    = array_flip(explode("|",$m[2]));
-      $op2    = array_flip(explode("|",$m[3]));
-      if (isset($helpers[$helper])) {
-        die("ERROR ($def:$lineno): Helper with name '$helper' is already defined.\n");
-      }
-      $helpers[$helper] = array("op1"=>$op1,"op2"=>$op2,"param"=>null,"code"=>"");
-      $handler = null;
-      $list[$lineno] = array("helper"=>$helper);
-    } else if (strpos($line,"ZEND_VM_HELPER_EX(") === 0) {
-      if (preg_match(
-        "/^ZEND_VM_HELPER_EX\(\s*([A-Za-z_]+)\s*,\s*([A-Z|]+)\s*,\s*([A-Z|]+)\s*,\s*(.*)\s*\)/",
-        $line,
-        $m) == 0) {
-        die("ERROR ($def:$lineno): Invalid ZEND_VM_HELPER definition.\n");
-      }
-      $helper = $m[1];
-      $op1    = array_flip(explode("|",$m[2]));
-      $op2    = array_flip(explode("|",$m[3]));
-      $param  = $m[4];
-      if (isset($helpers[$helper])) {
-        die("ERROR ($def:$lineno): Helper with name '$helper' is already defined.\n");
-      }
-      $params[$param] = 1;
-
-      $helpers[$helper] = array("op1"=>$op1,"op2"=>$op2,"param"=>$param,"code"=>"");
-      $handler = null;
-      $list[$lineno] = array("helper"=>$helper);
-    } else if ($handler !== null) {
-      $opcodes[$handler]["code"] .= $line;
-    } else if ($helper !== null) {
-      $helpers[$helper]["code"] .= $line;
-    }
-  }
-
-  ksort($opcodes);
-
-  // Search for opcode handlers those are used by other opcode handlers
-  foreach ($opcodes as $dsc) {
-    if (preg_match("/ZEND_VM_DISPATCH_TO_HANDLER\(\s*([A-Z_]*)\s*\)/m", $dsc["code"], $m)) {
-      $op = $m[1];
-      if (!isset($opnames[$op])) {
-        die("ERROR ($def:$lineno): Opcode with name '$op' is not defined.\n");
-      }
-      $code = $opnames[$op];
-      $opcodes[$code]['use'] = 1;
-    }
-  }
-
-  // Generate opcode #defines (zend_vm_opcodes.h)
-  $code_len = strlen((string)$max_opcode);
-  $f = fopen("zend_vm_opcodes.h", "w+") or die("ERROR: Cannot create zend_vm_opcodes.h\n");
-  ksort($opcodes);
-  foreach ($opcodes as $code => $dsc) {
-    $code = str_pad((string)$code,$code_len," ",STR_PAD_LEFT);
-    $op = str_pad($dsc["op"],$max_opcode_len);
-    fputs($f,"#define $op $code\n");
-  }
-  fclose($f);
-  echo "zend_vm_opcodes.h generated succesfull.\n";
-
-  // Generate zend_vm_execute.h
-  $f = fopen("zend_vm_execute.h", "w+") or die("ERROR: Cannot create zend_vm_execute.h\n");
-  $executor_file = realpath("zend_vm_execute.h");
-  
-  // Generate specialized executor
-  gen_executor($f, $skl, ZEND_VM_SPEC, ZEND_VM_KIND, "execute", "zend_init_opcodes_handlers", 0);
-
-  // Generate un-specialized executor
-  if (ZEND_VM_OLD_EXECUTOR) {
-    out($f,"\n/* Old executor */\n\n");
-    out($f,"#undef EX\n");
-    out($f,"#define EX(element) execute_data.element\n\n");
-    out($f,"#undef ZEND_VM_CONTINUE\n\n");
-    out($f,"#undef ZEND_VM_RETURN\n\n");
-    gen_executor($f, $skl, 0, ZEND_VM_KIND_CALL, "old_execute", "zend_vm_use_old_executor", 1);
-  }
-
-  // Generate zend_vm_set_opcode_handler() function
-  out($f, "void zend_vm_set_opcode_handler(zend_op* op)\n");
-  out($f, "{\n");
-  if (!ZEND_VM_SPEC) {
-    out($f, "\top->handler = zend_opcode_handlers[op->opcode];\n");
-  } else {
-    if (ZEND_VM_OLD_EXECUTOR) {
-      out($f, "\tif (zend_vm_old_executor) {\n");
-      out($f, "\t\top->handler = zend_opcode_handlers[op->opcode];\n");
-      out($f, "\t} else {\n");
-    }
-    out($f, "\t\tstatic const int zend_vm_decode[] = {\n");
-    out($f, "\t\t\t_UNUSED_CODE, /* 0              */\n");
-    out($f, "\t\t\t_CONST_CODE,  /* 1 = IS_CONST   */\n");
-    out($f, "\t\t\t_TMP_CODE,    /* 2 = IS_TMP_VAR */\n");
-    out($f, "\t\t\t_UNUSED_CODE, /* 3              */\n");
-    out($f, "\t\t\t_VAR_CODE,    /* 4 = IS_VAR     */\n");
-    out($f, "\t\t\t_UNUSED_CODE, /* 5              */\n");
-    out($f, "\t\t\t_UNUSED_CODE, /* 6              */\n");
-    out($f, "\t\t\t_UNUSED_CODE, /* 7              */\n");
-    out($f, "\t\t\t_UNUSED_CODE, /* 8 = IS_UNUSED  */\n");
-    out($f, "\t\t\t_UNUSED_CODE, /* 9              */\n");
-    out($f, "\t\t\t_UNUSED_CODE, /* 10             */\n");
-    out($f, "\t\t\t_UNUSED_CODE, /* 11             */\n");
-    out($f, "\t\t\t_UNUSED_CODE, /* 12             */\n");
-    out($f, "\t\t\t_UNUSED_CODE, /* 13             */\n");
-    out($f, "\t\t\t_UNUSED_CODE, /* 14             */\n");
-    out($f, "\t\t\t_UNUSED_CODE, /* 15             */\n");
-    out($f, "\t\t\t_CV_CODE      /* 16 = IS_CV     */\n");
-    out($f, "\t\t};\n");
-    out($f, "\t\top->handler = zend_opcode_handlers[op->opcode * 25 + zend_vm_decode[op->op1.op_type] * 5 + zend_vm_decode[op->op2.op_type]];\n");
-    if (ZEND_VM_OLD_EXECUTOR) {
-      out($f, "\t}\n");
-    }
-  }
-  out($f, "}\n\n");
-
-  fclose($f);
-  echo "zend_vm_execute.h generated succesfull.\n";
+	global $definition_file, $skeleton_file, $executor_file,
+		$op_types, $list, $opcodes, $helpers, $params, $opnames;
+
+	// Load definition file
+	$in = @file($def);
+	if (!$in) {
+		die("ERROR: Can not open definition file '$def'\n");
+	}
+	// We need absolute path to definition file to use it in #line directives
+	$definition_file = realpath($def);
+
+	// Load skeleton file
+	$skl = @file($skel);
+	if (!$skl) {
+		die("ERROR: Can not open skeleton file '$skel'\n");
+	}
+	// We need absolute path to skeleton file to use it in #line directives
+	$skeleton_file = realpath($skel);
+
+	// Parse definition file into tree
+	$lineno         = 0;
+	$handler        = null;
+	$helper         = null;
+	$max_opcode_len = 0;
+	$max_opcode     = 0;
+	foreach ($in as $line) {
+		++$lineno;
+		if (strpos($line,"ZEND_VM_HANDLER(") === 0) {
+		  // Parsing opcode handler's definition
+			if (preg_match(
+					"/^ZEND_VM_HANDLER\(\s*([0-9]+)\s*,\s*([A-Z_]+)\s*,\s*([A-Z|]+)\s*,\s*([A-Z|]+)\s*\)/",
+					$line,
+					$m) == 0) {
+				die("ERROR ($def:$lineno): Invalid ZEND_VM_HANDLER definition.\n");
+			}
+			$code = (int)$m[1];
+			$op   = $m[2];
+			$len  = strlen($op);
+			$op1  = array_flip(explode("|",$m[3]));
+			$op2  = array_flip(explode("|",$m[4]));
+
+			if ($len > $max_opcode_len) {
+				$max_opcode_len = $len;
+			}
+			if ($code > $max_opcode) {
+				$max_opcode = $code;
+			}
+			if (isset($opcodes[$code])) {
+				die("ERROR ($def:$lineno): Opcode with code '$code' is already defined.\n");
+			}
+			if (isset($opnames[$op])) {
+				die("ERROR ($def:$lineno): Opcode with name '$op' is already defined.\n");
+			}
+			$opcodes[$code] = array("op"=>$op,"op1"=>$op1,"op2"=>$op2,"code"=>"");
+			$opnames[$op] = $code;
+			$handler = $code;
+			$helper = null;
+			$list[$lineno] = array("handler"=>$handler);
+		} else if (strpos($line,"ZEND_VM_HELPER(") === 0) {
+		  // Parsing helper's definition
+			if (preg_match(
+					"/^ZEND_VM_HELPER\(\s*([A-Za-z_]+)\s*,\s*([A-Z|]+)\s*,\s*([A-Z|]+)\s*\)/",
+					$line,
+					$m) == 0) {
+				die("ERROR ($def:$lineno): Invalid ZEND_VM_HELPER definition.\n");
+			}
+			$helper = $m[1];
+			$op1    = array_flip(explode("|",$m[2]));
+			$op2    = array_flip(explode("|",$m[3]));
+			if (isset($helpers[$helper])) {
+				die("ERROR ($def:$lineno): Helper with name '$helper' is already defined.\n");
+			}
+			$helpers[$helper] = array("op1"=>$op1,"op2"=>$op2,"param"=>null,"code"=>"");
+			$handler = null;
+			$list[$lineno] = array("helper"=>$helper);
+		} else if (strpos($line,"ZEND_VM_HELPER_EX(") === 0) {
+		  // Parsing helper with parameter definition
+			if (preg_match(
+					"/^ZEND_VM_HELPER_EX\(\s*([A-Za-z_]+)\s*,\s*([A-Z|]+)\s*,\s*([A-Z|]+)\s*,\s*(.*)\s*\)/",
+					$line,
+					$m) == 0) {
+				die("ERROR ($def:$lineno): Invalid ZEND_VM_HELPER definition.\n");
+			}
+			$helper = $m[1];
+			$op1    = array_flip(explode("|",$m[2]));
+			$op2    = array_flip(explode("|",$m[3]));
+			$param  = $m[4];
+			if (isset($helpers[$helper])) {
+				die("ERROR ($def:$lineno): Helper with name '$helper' is already defined.\n");
+			}
+
+			// Store parameter
+			$params[$param] = 1;
+
+			$helpers[$helper] = array("op1"=>$op1,"op2"=>$op2,"param"=>$param,"code"=>"");
+			$handler = null;
+			$list[$lineno] = array("helper"=>$helper);
+		} else if ($handler !== null) {
+		  // Add line of code to current opcode handler
+			$opcodes[$handler]["code"] .= $line;
+		} else if ($helper !== null) {
+		  // Add line of code to current helper
+			$helpers[$helper]["code"] .= $line;
+		}
+	}
+
+	ksort($opcodes);
+
+	// Search for opcode handlers those are used by other opcode handlers
+	foreach ($opcodes as $dsc) {
+		if (preg_match("/ZEND_VM_DISPATCH_TO_HANDLER\(\s*([A-Z_]*)\s*\)/m", $dsc["code"], $m)) {
+			$op = $m[1];
+			if (!isset($opnames[$op])) {
+				die("ERROR ($def:$lineno): Opcode with name '$op' is not defined.\n");
+			}
+			$code = $opnames[$op];
+			$opcodes[$code]['use'] = 1;
+		}
+	}
+
+	// Generate opcode #defines (zend_vm_opcodes.h)
+	$code_len = strlen((string)$max_opcode);
+	$f = fopen("zend_vm_opcodes.h", "w+") or die("ERROR: Cannot create zend_vm_opcodes.h\n");
+	foreach ($opcodes as $code => $dsc) {
+		$code = str_pad((string)$code,$code_len," ",STR_PAD_LEFT);
+		$op = str_pad($dsc["op"],$max_opcode_len);
+		fputs($f,"#define $op $code\n");
+	}
+	fclose($f);
+	echo "zend_vm_opcodes.h generated succesfull.\n";
+
+	// Generate zend_vm_execute.h
+	$f = fopen("zend_vm_execute.h", "w+") or die("ERROR: Cannot create zend_vm_execute.h\n");
+	$executor_file = realpath("zend_vm_execute.h");
+
+	// Generate specialized executor
+	gen_executor($f, $skl, ZEND_VM_SPEC, ZEND_VM_KIND, "execute", "zend_init_opcodes_handlers", 0);
+
+	// Generate un-specialized executor
+	if (ZEND_VM_OLD_EXECUTOR) {
+		out($f,"\n/* Old executor */\n\n");
+		out($f,"#undef EX\n");
+		out($f,"#define EX(element) execute_data.element\n\n");
+		out($f,"#undef ZEND_VM_CONTINUE\n\n");
+		out($f,"#undef ZEND_VM_RETURN\n\n");
+		gen_executor($f, $skl, 0, ZEND_VM_KIND_CALL, "old_execute", "zend_vm_use_old_executor", 1);
+	}
+
+	// Generate zend_vm_set_opcode_handler() function
+	out($f, "void zend_vm_set_opcode_handler(zend_op* op)\n");
+	out($f, "{\n");
+	if (!ZEND_VM_SPEC) {
+		out($f, "\top->handler = zend_opcode_handlers[op->opcode];\n");
+	} else {
+		if (ZEND_VM_OLD_EXECUTOR) {
+			out($f, "\tif (zend_vm_old_executor) {\n");
+			out($f, "\t\top->handler = zend_opcode_handlers[op->opcode];\n");
+			out($f, "\t} else {\n");
+		}
+		out($f, "\t\tstatic const int zend_vm_decode[] = {\n");
+		out($f, "\t\t\t_UNUSED_CODE, /* 0              */\n");
+		out($f, "\t\t\t_CONST_CODE,  /* 1 = IS_CONST   */\n");
+		out($f, "\t\t\t_TMP_CODE,    /* 2 = IS_TMP_VAR */\n");
+		out($f, "\t\t\t_UNUSED_CODE, /* 3              */\n");
+		out($f, "\t\t\t_VAR_CODE,    /* 4 = IS_VAR     */\n");
+		out($f, "\t\t\t_UNUSED_CODE, /* 5              */\n");
+		out($f, "\t\t\t_UNUSED_CODE, /* 6              */\n");
+		out($f, "\t\t\t_UNUSED_CODE, /* 7              */\n");
+		out($f, "\t\t\t_UNUSED_CODE, /* 8 = IS_UNUSED  */\n");
+		out($f, "\t\t\t_UNUSED_CODE, /* 9              */\n");
+		out($f, "\t\t\t_UNUSED_CODE, /* 10             */\n");
+		out($f, "\t\t\t_UNUSED_CODE, /* 11             */\n");
+		out($f, "\t\t\t_UNUSED_CODE, /* 12             */\n");
+		out($f, "\t\t\t_UNUSED_CODE, /* 13             */\n");
+		out($f, "\t\t\t_UNUSED_CODE, /* 14             */\n");
+		out($f, "\t\t\t_UNUSED_CODE, /* 15             */\n");
+		out($f, "\t\t\t_CV_CODE      /* 16 = IS_CV     */\n");
+		out($f, "\t\t};\n");
+		out($f, "\t\top->handler = zend_opcode_handlers[op->opcode * 25 + zend_vm_decode[op->op1.op_type] * 5 + zend_vm_decode[op->op2.op_type]];\n");
+		if (ZEND_VM_OLD_EXECUTOR) {
+			out($f, "\t}\n");
+		}
+	}
+	out($f, "}\n\n");
+
+	fclose($f);
+	echo "zend_vm_execute.h generated succesfull.\n";
 }
 
 function usage() {
-  echo("\nUsage: php zend_vm_gen.php [options]\n".
-       "\nOptions:".
-       "\n  --with-vm-kind=CALL|SWITCH|GOTO - select threading model (default is CALL)".
-       "\n  --without-specializer           - disable executor specialization".
-       "\n  --without-old-executor          - disable old executor".
-       "\n  --without-lines                 - disable #line directives".
-       "\n\n");
-
+	echo("\nUsage: php zend_vm_gen.php [options]\n".
+	     "\nOptions:".
+	     "\n  --with-vm-kind=CALL|SWITCH|GOTO - select threading model (default is CALL)".
+	     "\n  --without-specializer           - disable executor specialization".
+	     "\n  --without-old-executor          - disable old executor".
+	     "\n  --without-lines                 - disable #line directives".
+	     "\n\n");
 }
 
 // Parse arguments
-for ($i = 1;  $i < $argc; $i++) {  
-  if (strpos($argv[$i],"--with-vm-kind=") === 0) {
-    $kind = substr($argv[$i], strlen("--with-vm-kind="));
-    switch ($kind) {
-      case "CALL":
-        define("ZEND_VM_KIND", ZEND_VM_KIND_CALL);
-        break;
-      case "SWITCH":
-        define("ZEND_VM_KIND", ZEND_VM_KIND_SWITCH);
-        break;
-      case "GOTO":
-        define("ZEND_VM_KIND", ZEND_VM_KIND_GOTO);
-        break;
-      default:
-        echo("ERROR: Invalid vm kind '$kind'\n");
-        usage();
-        die();
-    }
-  } else if ($argv[$i] == "--without-specializer") {
-    define("ZEND_VM_SPEC", 0);
-  } else if ($argv[$i] == "--without-old-executor") {
-    define("ZEND_VM_OLD_EXECUTOR", 0);
-  } else if ($argv[$i] == "--without-lines") {
-    define("ZEND_VM_LINES", 0);
-  } else if ($argv[$i] == "--help") {
-    usage();
-    exit();
-  } else {
-    echo("ERROR: Invalid option '".$argv[$i]."'\n");
-    usage();
-    die();
-  }
+for ($i = 1;  $i < $argc; $i++) {
+	if (strpos($argv[$i],"--with-vm-kind=") === 0) {
+		$kind = substr($argv[$i], strlen("--with-vm-kind="));
+		switch ($kind) {
+			case "CALL":
+				define("ZEND_VM_KIND", ZEND_VM_KIND_CALL);
+				break;
+			case "SWITCH":
+				define("ZEND_VM_KIND", ZEND_VM_KIND_SWITCH);
+				break;
+			case "GOTO":
+				define("ZEND_VM_KIND", ZEND_VM_KIND_GOTO);
+				break;
+			default:
+				echo("ERROR: Invalid vm kind '$kind'\n");
+				usage();
+				die();
+		}
+	} else if ($argv[$i] == "--without-specializer") {
+	  // Disabling specialization
+		define("ZEND_VM_SPEC", 0);
+	} else if ($argv[$i] == "--without-old-executor") {
+	  // Disabling code for old-style executor
+		define("ZEND_VM_OLD_EXECUTOR", 0);
+	} else if ($argv[$i] == "--without-lines") {
+		// Disabling debuging using original zend_vm_def.h
+		define("ZEND_VM_LINES", 0);
+	} else if ($argv[$i] == "--help") {
+		usage();
+		exit();
+	} else {
+		echo("ERROR: Invalid option '".$argv[$i]."'\n");
+		usage();
+		die();
+	}
 }
 
 // Using defaults
 if (!defined("ZEND_VM_KIND")) {
-  define("ZEND_VM_KIND", ZEND_VM_KIND_CALL);
+  // Using CALL threading by default
+	define("ZEND_VM_KIND", ZEND_VM_KIND_CALL);
 }
 if (!defined("ZEND_VM_SPEC")) {
-  define("ZEND_VM_SPEC", 1);
+  // Using specialized executor by default
+	define("ZEND_VM_SPEC", 1);
 }
 if (!defined("ZEND_VM_OLD_EXECUTOR")) {
-  define("ZEND_VM_OLD_EXECUTOR", 1);
+  // Include old-style executor by default
+	define("ZEND_VM_OLD_EXECUTOR", 1);
 }
 if (!defined("ZEND_VM_LINES")) {
-  define("ZEND_VM_LINES", 1);
+  // Using #line directives to debug with original zend_vm_def.h by default
+	define("ZEND_VM_LINES", 1);
 }
 
 gen_vm("zend_vm_def.h", "zend_vm_execute.skl");