Try revert parser.mly (Will revert)

Author: aheejin

interpreter/text/parser.mly

@@ -373,16 +373,12 @@ align_opt :
 
 /* Instructions & Expressions */
 
-instr_list :
-  | /* empty */ { fun c -> [] }
-  | instr1 instr_list { fun c -> $1 c @ $2 c }
-  | select_instr_instr_list { $1 }
-  | call_instr_instr_list { $1 }
-
-instr1 :
+instr :
   | plain_instr { let at = at () in fun c -> [$1 c @@ at] }
+  | select_instr_instr { fun c -> let e, es = $1 c in e :: es }
+  | call_instr_instr { fun c -> let e, es = $1 c in e :: es }
   | block_instr { let at = at () in fun c -> [$1 c @@ at] }
-  | expr { $1 }  /* Sugar */
+  | expr { $1 } /* Sugar */
 
 plain_instr :
   | UNREACHABLE { fun c -> unreachable }
@@ -455,51 +451,89 @@ plain_instr :
   | VEC_REPLACE NAT { let at = at () in fun c -> $1 (vec_lane_index $2 at) }
 
 
-select_instr_instr_list :
-  | SELECT select_instr_results_instr_list
+select_instr :
+  | SELECT select_instr_results
+    { let at = at () in fun c -> let b, ts = $2 in
+      select (if b then (Some ts) else None) @@ at }
+
+select_instr_results :
+  | LPAR RESULT value_type_list RPAR select_instr_results
+    { let _, ts = $5 in true, $3 @ ts }
+  | /* empty */
+    { false, [] }
+
+select_instr_instr :
+  | SELECT select_instr_results_instr
     { let at1 = ati 1 in
       fun c -> let b, ts, es = $2 c in
-      (select (if b then (Some ts) else None) @@ at1) :: es }
+      select (if b then (Some ts) else None) @@ at1, es }
 
-select_instr_results_instr_list :
-  | LPAR RESULT value_type_list RPAR select_instr_results_instr_list
+select_instr_results_instr :
+  | LPAR RESULT value_type_list RPAR select_instr_results_instr
     { fun c -> let _, ts, es = $5 c in true, $3 @ ts, es }
-  | instr_list
+  | instr
     { fun c -> false, [], $1 c }
 
 
-call_instr_instr_list :
-  | CALL_INDIRECT var call_instr_type_instr_list
+call_instr :
+  | CALL_INDIRECT var call_instr_type
+    { let at = at () in fun c -> call_indirect ($2 c table) ($3 c) @@ at }
+  | CALL_INDIRECT call_instr_type  /* Sugar */
+    { let at = at () in fun c -> call_indirect (0l @@ at) ($2 c) @@ at }
+
+call_instr_type :
+  | type_use call_instr_params
+    { let at1 = ati 1 in
+      fun c ->
+      match $2 c with
+      | FuncType ([], []) -> $1 c type_
+      | ft -> inline_type_explicit c ($1 c type_) ft at1 }
+  | call_instr_params
+    { let at = at () in fun c -> inline_type c ($1 c) at }
+
+call_instr_params :
+  | LPAR PARAM value_type_list RPAR call_instr_params
+    { fun c -> let FuncType (ts1, ts2) = $5 c in FuncType ($3 @ ts1, ts2) }
+  | call_instr_results
+    { fun c -> FuncType ([], $1 c) }
+
+call_instr_results :
+  | LPAR RESULT value_type_list RPAR call_instr_results
+    { fun c -> $3 @ $5 c }
+  | /* empty */
+    { fun c -> [] }
+
+
+call_instr_instr :
+  | CALL_INDIRECT var call_instr_type_instr
     { let at1 = ati 1 in
-      fun c -> let x, es = $3 c in
-      (call_indirect ($2 c table) x @@ at1) :: es }
-  | CALL_INDIRECT call_instr_type_instr_list  /* Sugar */
+      fun c -> let x, es = $3 c in call_indirect ($2 c table) x @@ at1, es }
+  | CALL_INDIRECT call_instr_type_instr  /* Sugar */
     { let at1 = ati 1 in
-      fun c -> let x, es = $2 c in
-      (call_indirect (0l @@ at1) x @@ at1) :: es }
+      fun c -> let x, es = $2 c in call_indirect (0l @@ at1) x @@ at1, es }
 
-call_instr_type_instr_list :
-  | type_use call_instr_params_instr_list
+call_instr_type_instr :
+  | type_use call_instr_params_instr
     { let at1 = ati 1 in
       fun c ->
       match $2 c with
       | FuncType ([], []), es -> $1 c type_, es
       | ft, es -> inline_type_explicit c ($1 c type_) ft at1, es }
-  | call_instr_params_instr_list
+  | call_instr_params_instr
     { let at = at () in
       fun c -> let ft, es = $1 c in inline_type c ft at, es }
 
-call_instr_params_instr_list :
-  | LPAR PARAM value_type_list RPAR call_instr_params_instr_list
+call_instr_params_instr :
+  | LPAR PARAM value_type_list RPAR call_instr_params_instr
     { fun c ->
       let FuncType (ts1, ts2), es = $5 c in FuncType ($3 @ ts1, ts2), es }
-  | call_instr_results_instr_list
+  | call_instr_results_instr
     { fun c -> let ts, es = $1 c in FuncType ([], ts), es }
 
-call_instr_results_instr_list :
-  | LPAR RESULT value_type_list RPAR call_instr_results_instr_list
+call_instr_results_instr :
+  | LPAR RESULT value_type_list RPAR call_instr_results_instr
     { fun c -> let ts, es = $5 c in $3 @ ts, es }
-  | instr_list
+  | instr
     { fun c -> [], $1 c }
 
 
@@ -710,6 +744,12 @@ try_ :
   | LPAR DO instr_list RPAR handler
     { fun bt c c' -> $5 bt ($3 c') c c' }
 
+instr_list :
+  | /* empty */ { fun c -> [] }
+  | select_instr { fun c -> [$1 c] }
+  | call_instr { fun c -> [$1 c] }
+  | instr instr_list { fun c -> $1 c @ $2 c }
+
 expr_list :
   | /* empty */ { fun c -> [] }
   | expr expr_list { fun c -> $1 c @ $2 c }