Merge pull request #734 from mir-protocol/stack-manipulation-empty-lhs

stack manipulation: allow empty LHS

evm/src/cpu/kernel/assembler.rs

@@ -575,8 +575,15 @@ mod tests {
         let swap1 = get_opcode("SWAP1");
         let swap2 = get_opcode("SWAP2");
         let swap3 = get_opcode("SWAP3");
+        let push_one_byte = get_push_opcode(1);
         let push_label = get_push_opcode(BYTES_PER_OFFSET);
 
+        let kernel = parse_and_assemble(&["%stack () -> (1, 2, 3)"]);
+        assert_eq!(
+            kernel.code,
+            vec![push_one_byte, 3, push_one_byte, 2, push_one_byte, 1]
+        );
+
         let kernel = parse_and_assemble(&["%stack (a) -> (a)"]);
         assert_eq!(kernel.code, vec![]);
 
@@ -586,6 +593,9 @@ mod tests {
         let kernel = parse_and_assemble(&["%stack (a, b, c) -> (b)"]);
         assert_eq!(kernel.code, vec![pop, swap1, pop]);
 
+        let kernel = parse_and_assemble(&["%stack (a, b, c) -> (7, b)"]);
+        assert_eq!(kernel.code, vec![pop, swap1, pop, push_one_byte, 7]);
+
         let kernel = parse_and_assemble(&["%stack (a, b: 3, c) -> (c)"]);
         assert_eq!(kernel.code, vec![pop, pop, pop, pop]);
 

evm/src/cpu/kernel/evm_asm.pest

@@ -21,16 +21,19 @@ macro_call = ${ "%" ~ !((^"macro" | ^"endmacro" | ^"rep" | ^"endrep" | ^"stack")
 repeat = { ^"%rep" ~ literal ~ item* ~ ^"%endrep" }
 paramlist = { "(" ~ identifier ~ ("," ~ identifier)* ~ ")" }
 macro_arglist = !{ "(" ~ push_target ~ ("," ~ push_target)* ~ ")" }
+
 stack = { ^"%stack" ~ stack_placeholders ~ "->" ~ stack_replacements }
-stack_placeholders = { "(" ~ stack_placeholder ~ ("," ~ stack_placeholder)* ~ ")" }
+stack_placeholders = { "(" ~ (stack_placeholder ~ ("," ~ stack_placeholder)*)? ~ ")" }
 stack_placeholder = { stack_block | identifier }
 stack_block = { identifier ~ ":" ~ literal_decimal }
 stack_replacements = { "(" ~ stack_replacement ~ ("," ~ stack_replacement)* ~ ")" }
 stack_replacement = { literal | identifier | constant | macro_label | variable }
+
 global_label_decl = ${ ^"GLOBAL " ~ identifier ~ ":" }
 local_label_decl = ${ identifier ~ ":" }
 macro_label_decl = ${ "%%" ~ identifier ~ ":" }
 macro_label = ${ "%%" ~ identifier }
+
 bytes_item = { ^"BYTES " ~ literal ~ ("," ~ literal)* }
 push_instruction = { ^"PUSH " ~ push_target }
 push_target = { literal | identifier | macro_label | variable | constant }

evm/src/cpu/kernel/parser.rs

@@ -99,17 +99,20 @@ fn parse_stack(item: Pair<Rule>) -> Item {
     assert_eq!(item.as_rule(), Rule::stack);
     let mut inner = item.into_inner();
 
-    let params = inner.next().unwrap();
-    assert_eq!(params.as_rule(), Rule::stack_placeholders);
+    let placeholders = inner.next().unwrap();
+    assert_eq!(placeholders.as_rule(), Rule::stack_placeholders);
     let replacements = inner.next().unwrap();
     assert_eq!(replacements.as_rule(), Rule::stack_replacements);
 
-    let params = params.into_inner().map(parse_stack_placeholder).collect();
+    let placeholders = placeholders
+        .into_inner()
+        .map(parse_stack_placeholder)
+        .collect();
     let replacements = replacements
         .into_inner()
         .map(parse_stack_replacement)
         .collect();
-    Item::StackManipulation(params, replacements)
+    Item::StackManipulation(placeholders, replacements)
 }
 
 fn parse_stack_placeholder(target: Pair<Rule>) -> StackPlaceholder {