peruby 0.1.0

data/lib/peruby/parser/grammar.y

@@ -0,0 +1,576 @@
+# frozen_string_literal: true
+
+class Peruby::Parser::Grammar
+  token NUMBER VERSION STRING ISTRING HEREDOC BACKTICK MATCH QR SUBST TRANS BAREWORD PACKAGE_NAME FUNC LISTOP SORT_SUB
+        MAP_EXPR GREP_EXPR NAMED_UNARY PROTOTYPE
+        SCALAR_VAR ARRAY_VAR HASH_VAR CODE_VAR GLOB_VAR SPECIAL_VAR ARRAY_LAST
+        SCALAR_DEREF ARRAY_DEREF HASH_DEREF CODE_DEREF
+        SCALAR_DEREF_OPEN ARRAY_DEREF_OPEN HASH_DEREF_OPEN CODE_DEREF_OPEN
+        HASHREF_LBRACE SUBSCRIPT_LBRACE FILEHANDLE
+        PRINT PRINTF SAY MY OUR LOCAL STATE RETURN IF ELSIF ELSE UNLESS WHILE UNTIL SUB SUB_NAME FOR FOREACH PACKAGE GOTO
+        LAST NEXT REDO CONTINUE DO
+        READLINE FILETEST
+        SORT MAP GREP FATCOMMA
+        POSTFIX
+        USE NO REQUIRE QW
+        BEGIN CHECK INIT END EVAL
+        CONSTANT
+        ASSIGNOP POW REPEAT LSHIFT RSHIFT EQ NE LE GE CMP SEQ SNE SLT SGT SLE SGE SCMP
+        ANDAND OROR DORDOR AND OR XOR NOT MATCHOP NOTMATCHOP DOTDOT DOTDOTDOT
+        INC DEC REFGEN ARROW
+        LBRACE RBRACE
+
+  # perldoc perlop: Terms and List Operators through logical or/xor, highest first.
+  prechigh
+    right POW
+    left INC DEC ARROW '[' SUBSCRIPT_LBRACE
+    left POSTFIX
+    right '!' '~' UMINUS REFGEN
+    left MATCHOP NOTMATCHOP
+    left '*' '/' '%' REPEAT
+    left '+' '-' '.'
+    left LSHIFT RSHIFT
+    nonassoc '<' '>' LE GE SLT SGT SLE SGE
+    nonassoc EQ NE CMP SEQ SNE SCMP
+    left '&'
+    left '|' '^'
+    left ANDAND
+    left OROR DORDOR
+    nonassoc DOTDOT DOTDOTDOT
+    right '?' ':'
+    right '=' ASSIGNOP
+    left ',' FATCOMMA
+    right LISTOP
+    right NOT
+    left AND
+    left OR XOR
+  preclow
+
+  rule
+    program
+      : stmtseq { result = node(:Program, val[0], token: first_token(val[0])) }
+
+    stmtseq
+      : /* empty */ { result = [] }
+      | stmtseq statement { result = val[0] << val[1] }
+
+    statement
+      : ';' { result = node(:Nop, token: val[0]) }
+      | modifiable_statement ';' { result = val[0] }
+      | modifiable_statement IF expr ';' {
+          result = node(:ModifierCondition, val[0], val[2], :if, token: token_of(val[0]))
+        }
+      | modifiable_statement UNLESS expr ';' {
+          result = node(:ModifierCondition, val[0], val[2], :unless, token: token_of(val[0]))
+        }
+      | modifiable_statement WHILE expr ';' {
+          result = node(:ModifierCondition, val[0], val[2], :while, token: token_of(val[0]))
+        }
+      | modifiable_statement UNTIL expr ';' {
+          result = node(:ModifierCondition, val[0], val[2], :until, token: token_of(val[0]))
+        }
+      | modifiable_statement FOR expr ';' { result = node(:ModifierFor, val[0], val[2], token: val[1]) }
+      | modifiable_statement FOREACH expr ';' { result = node(:ModifierFor, val[0], val[2], token: val[1]) }
+      | MY variable initializer_opt ';' { result = node(:My, val[1], val[2], token: val[0]) }
+      | STATE variable initializer_opt ';' { result = node(:State, val[1], val[2], token: val[0]) }
+      | OUR variable initializer_opt ';' { result = node(:Our, package_variable(val[1]), val[2], token: val[0]) }
+      | LOCAL postfix initializer_opt ';' { result = node(:Local, val[1], val[2], token: val[0]) }
+      | PACKAGE package_name ';' { @package = val[1]; result = node(:Package, val[1], token: val[0]) }
+      | package_block_start stmtseq RBRACE {
+          @package = val[0][1]
+          body = node(:Block, val[1], token: val[0][0])
+          @unit&.leave_compile_scope
+          result = node(:PackageBlock, val[0][2], body, token: val[0][0])
+        }
+      | USE package_name use_args ';' {
+          register_module_imports(val[1], val[2])
+          register_mro(val[1], val[2])
+          result = compile_time_use(node(:Use, val[1], val[2], false, @package, token: val[0]))
+        }
+      | NO package_name use_args ';' {
+          result = compile_time_use(node(:Use, val[1], val[2], true, @package, token: val[0]))
+        }
+      | USE package_name VERSION use_args ';' {
+          imports = ['__VERSION__', val[2].value, *val[3]]
+          register_module_imports(val[1], val[3])
+          result = compile_time_use(node(:Use, val[1], imports, false, @package, token: val[0]))
+        }
+      | USE package_name NUMBER use_args ';' {
+          imports = ['__VERSION__', val[2].value, *val[3]]
+          register_module_imports(val[1], val[3])
+          result = compile_time_use(node(:Use, val[1], imports, false, @package, token: val[0]))
+        }
+      | USE VERSION ';' { result = node(:Nop, token: val[0]) }
+      | USE NUMBER ';' { result = node(:Nop, token: val[0]) }
+      | USE CONSTANT STRING FATCOMMA assignment ';' {
+          @known_subs[val[2].value] = ''
+          result = node(:Constant, qualify(val[2].value), val[4], token: val[0])
+          @unit&.run_at_compile_time(result)
+          result = node(:Nop, token: val[0]) if @unit
+        }
+      | USE package_name STRING FATCOMMA assignment overload_tail ';' {
+          register_module_imports(val[1], [])
+          imports = [literal_value(val[2]), literal_option(val[4]), *val[5]]
+          result = compile_time_use(node(:Use, val[1], imports, false, @package, token: val[0]))
+        }
+      | BEGIN block { phase(:begin, val[1], val[0], @package); result = node(:Nop, token: val[0]) }
+      | CHECK block { phase(:check, val[1], val[0], @package); result = node(:Nop, token: val[0]) }
+      | INIT block { phase(:init, val[1], val[0], @package); result = node(:Nop, token: val[0]) }
+      | END block { phase(:end, val[1], val[0], @package); result = node(:Nop, token: val[0]) }
+      | GOTO CODE_VAR ';' { result = node(:Goto, val[1].value, token: val[0]) }
+      | SUB SUB_NAME prototype_opt block {
+          @known_subs[val[1].value] = val[2]&.start_with?('&') ? :listop : val[2]
+          result = node(:SubDef, qualify(val[1].value), val[2], val[3], token: val[0])
+        }
+      | SUB SUB_NAME prototype_opt ';' {
+          @known_subs[val[1].value] = val[2]&.start_with?('&') ? :listop : val[2]
+          result = node(:Nop, token: val[0])
+        }
+      | MY '(' expr ')' initializer_opt ';' { result = node(:My, ensure_list(val[2]), val[4], token: val[0]) }
+      | BAREWORD ':' while_statement { result = val[2].with(label: val[0].value) }
+      | BAREWORD ':' for_statement { result = val[2].with(label: val[0].value) }
+      | BAREWORD ':' block { result = node(:BareBlock, val[2], val[0].value, token: val[0]) }
+      | if_statement
+      | while_statement
+      | for_statement
+      | block { result = node(:BareBlock, val[0], nil, token: token_of(val[0])) }
+
+    modifiable_statement
+      : expr
+      | RETURN expr_opt { result = node(:Return, val[1], token: val[0]) }
+      | loop_jump
+      | PRINT filehandle_opt expr_opt { result = output_statement(:Print, val[1], val[2], val[0]) }
+      | PRINTF filehandle_opt expr_opt { result = output_statement(:Printf, val[1], val[2], val[0]) }
+      | SAY filehandle_opt expr_opt { result = output_statement(:Say, val[1], val[2], val[0]) }
+
+    initializer_opt
+      : /* empty */ { result = nil }
+      | '=' assignment { result = val[1] }
+
+    if_statement
+      : IF '(' expr ')' block else_opt { result = node(:If, val[2], val[4], val[5], token: val[0]) }
+      | UNLESS '(' expr ')' block else_opt { result = node(:If, node(:Unary, :not, val[2], token: val[0]), val[4], val[5], token: val[0]) }
+
+    else_opt
+      : /* empty */ { result = nil }
+      | ELSE block { result = val[1] }
+      | ELSIF '(' expr ')' block else_opt { result = node(:If, val[2], val[4], val[5], token: val[0]) }
+
+    while_statement
+      : WHILE '(' expr ')' block continue_opt { result = node(:While, val[2], val[4], false, val[5], nil, token: val[0]) }
+      | UNTIL '(' expr ')' block continue_opt { result = node(:While, val[2], val[4], true, val[5], nil, token: val[0]) }
+
+    for_statement
+      : for_my_start block continue_opt {
+          result = node(:ForEach, val[0][1], val[0][2], val[1], val[2], nil, true, token: val[0][0])
+          @unit&.leave_compile_scope
+        }
+      | FOR SCALAR_VAR '(' expr ')' block continue_opt {
+          result = node(:ForEach, variable(:scalar, val[1]), val[3], val[5], val[6], nil, false, token: val[0])
+        }
+      | FOREACH SCALAR_VAR '(' expr ')' block continue_opt {
+          result = node(:ForEach, variable(:scalar, val[1]), val[3], val[5], val[6], nil, false, token: val[0])
+        }
+      | FOR '(' expr ')' block continue_opt {
+          result = node(:ForEach, node(:Variable, :scalar, '_', token: val[0]), val[2], val[4], val[5], nil, false,
+                        token: val[0])
+        }
+      | FOREACH '(' expr ')' block continue_opt {
+          result = node(:ForEach, node(:Variable, :scalar, '_', token: val[0]), val[2], val[4], val[5], nil, false,
+                        token: val[0])
+        }
+      | FOR '(' for_initializer ';' expr_opt ';' expr_opt ')' block continue_opt {
+          result = node(:CFor, val[2][0], val[4], val[6], val[8], val[9], nil, token: val[0])
+          @unit&.leave_compile_scope if val[2][1]
+        }
+
+    for_my_start
+      : FOR MY SCALAR_VAR '(' expr ')' {
+          variable = variable(:scalar, val[2])
+          @unit&.enter_compile_scope
+          @unit&.predeclare_variable(variable)
+          result = [val[0], variable, val[4]]
+        }
+      | FOREACH MY SCALAR_VAR '(' expr ')' {
+          variable = variable(:scalar, val[2])
+          @unit&.enter_compile_scope
+          @unit&.predeclare_variable(variable)
+          result = [val[0], variable, val[4]]
+        }
+
+    for_initializer
+      : /* empty */ { result = [nil, false] }
+      | expr { result = [val[0], false] }
+      | MY variable initializer_opt {
+          @unit&.enter_compile_scope
+          result = [node(:My, val[1], val[2], token: val[0]), true]
+        }
+
+    continue_opt
+      : /* empty */ { result = nil }
+      | CONTINUE block { result = val[1] }
+
+    loop_jump
+      : LAST label_opt { result = node(:LoopJump, :last, val[1], token: val[0]) }
+      | NEXT label_opt { result = node(:LoopJump, :next, val[1], token: val[0]) }
+      | REDO label_opt { result = node(:LoopJump, :redo, val[1], token: val[0]) }
+
+    label_opt
+      : /* empty */ { result = nil }
+      | BAREWORD { result = val[0].value }
+
+    block_start
+      : LBRACE { @unit&.enter_compile_scope; result = [val[0], @package] }
+
+    package_block_start
+      : PACKAGE package_name LBRACE {
+          @unit&.enter_compile_scope
+          result = [val[2], @package, val[1]]
+          @package = val[1]
+        }
+
+    block
+      : block_start stmtseq RBRACE {
+          @package = val[0][1]
+          result = node(:Block, val[1], token: val[0][0])
+          @unit&.leave_compile_scope
+        }
+      | block_start stmtseq expr RBRACE {
+          @package = val[0][1]
+          result = node(:Block, val[1] << val[2], token: val[0][0])
+          @unit&.leave_compile_scope
+        }
+      | block_start stmtseq RETURN expr RBRACE {
+          @package = val[0][1]
+          result = node(:Block, val[1] << node(:Return, val[3], token: val[2]), token: val[0][0])
+          @unit&.leave_compile_scope
+        }
+
+    expr_opt
+      : /* empty */ { result = nil }
+      | expr
+
+    expr
+      : assignment
+      | expr ',' assignment { result = append_list(val[0], val[2]) }
+      | expr FATCOMMA assignment { result = append_list(val[0], val[2]) }
+
+    assignment
+      : ternary
+      | LISTOP expr { result = node(:Call, val[0].value, list_items(val[1]), token: val[0]) }
+      | unary '=' assignment { result = node(:Assign, :'=', val[0], val[2], token: token_of(val[0])) }
+      | unary ASSIGNOP assignment { result = node(:Assign, val[1].value.to_sym, val[0], val[2], token: val[1]) }
+
+    ternary
+      : binary
+      | binary '?' assignment ':' assignment { result = node(:Ternary, val[0], val[2], val[4], token: token_of(val[0])) }
+
+    binary
+      : unary
+      | binary '+' binary { result = binary(:+, val) }
+      | binary '-' binary { result = binary(:-, val) }
+      | binary '*' binary { result = binary(:*, val) }
+      | binary '/' binary { result = binary(:divide, val) }
+      | binary '%' binary { result = binary(:modulo, val) }
+      | binary '.' binary { result = binary(:concat, val) }
+      | binary LSHIFT binary { result = binary(:left_shift, val) }
+      | binary RSHIFT binary { result = binary(:right_shift, val) }
+      | binary POW binary { result = binary(:pow, val) }
+      | binary REPEAT binary { result = binary(:repeat, val) }
+      | binary EQ binary { result = binary(:num_eq, val) }
+      | binary NE binary { result = binary(:num_ne, val) }
+      | binary '<' binary { result = binary(:num_lt, val) }
+      | binary '>' binary { result = binary(:num_gt, val) }
+      | binary LE binary { result = binary(:num_le, val) }
+      | binary GE binary { result = binary(:num_ge, val) }
+      | binary CMP binary { result = binary(:num_cmp, val) }
+      | binary SEQ binary { result = binary(:str_eq, val) }
+      | binary SNE binary { result = binary(:str_ne, val) }
+      | binary SLT binary { result = binary(:str_lt, val) }
+      | binary SGT binary { result = binary(:str_gt, val) }
+      | binary SLE binary { result = binary(:str_le, val) }
+      | binary SGE binary { result = binary(:str_ge, val) }
+      | binary SCMP binary { result = binary(:str_cmp, val) }
+      | binary ANDAND binary { result = binary(:and, val) }
+      | binary OROR binary { result = binary(:or, val) }
+      | binary DORDOR binary { result = binary(:defined_or, val) }
+      | binary '&' binary { result = binary(:bit_and, val) }
+      | binary '|' binary { result = binary(:bit_or, val) }
+      | binary '^' binary { result = binary(:bit_xor, val) }
+      | binary AND binary { result = binary(:and, val) }
+      | binary OR binary { result = binary(:or, val) }
+      | binary XOR binary { result = binary(:xor, val) }
+      | binary DOTDOT binary { result = binary(:range, val) }
+      | binary DOTDOTDOT binary { result = binary(:range_exclusive, val) }
+      | binary MATCHOP binary { result = node(:Bind, val[0], val[2], false, token: val[1]) }
+      | binary NOTMATCHOP binary { result = node(:Bind, val[0], val[2], true, token: val[1]) }
+
+    unary
+      : postfix =POSTFIX
+      | '-' unary =UMINUS { result = node(:Unary, :negate, val[1], token: val[0]) }
+      | '+' unary =UMINUS { result = node(:Unary, :positive, val[1], token: val[0]) }
+      | '!' unary { result = node(:Unary, :not, val[1], token: val[0]) }
+      | NOT unary { result = node(:Unary, :not, val[1], token: val[0]) }
+      | '~' unary { result = node(:Unary, :bit_not, val[1], token: val[0]) }
+      | REFGEN unary { result = node(:Unary, :reference, val[1], token: val[0]) }
+      | INC unary { result = node(:Prefix, :increment, val[1], token: val[0]) }
+      | DEC unary { result = node(:Prefix, :decrement, val[1], token: val[0]) }
+      | NAMED_UNARY unary { result = node(:Call, val[0].value, list_items(val[1]), token: val[0]) }
+      | FILETEST unary { result = node(:FileTest, val[0].value, val[1], token: val[0]) }
+      | REQUIRE unary { result = node(:Require, val[1], token: val[0]) }
+      | EVAL block { result = node(:Eval, val[1], false, token: val[0]) }
+      | EVAL unary { result = node(:Eval, val[1], true, token: val[0]) }
+      | DO block { result = val[1] }
+
+    postfix
+      : term
+      | postfix '[' expr ']' { result = node(:Element, val[0], val[2], :array, false, token: token_of(val[0])) }
+      | postfix SUBSCRIPT_LBRACE expr RBRACE { result = node(:Element, val[0], val[2], :hash, false, token: token_of(val[0])) }
+      | postfix ARROW '[' expr ']' { result = node(:Element, val[0], val[3], :array, true, token: token_of(val[0])) }
+      | postfix ARROW SUBSCRIPT_LBRACE expr RBRACE { result = node(:Element, val[0], val[3], :hash, true, token: token_of(val[0])) }
+      | postfix ARROW BAREWORD '(' expr_opt ')' { result = node(:MethodCall, val[0], val[2].value, list_items(val[4]), token: token_of(val[0])) }
+      | postfix ARROW FUNC '(' expr_opt ')' { result = node(:MethodCall, val[0], val[2].value, list_items(val[4]), token: token_of(val[0])) }
+      | postfix ARROW PACKAGE_NAME '(' expr_opt ')' { result = node(:MethodCall, val[0], val[2].value, list_items(val[4]), token: token_of(val[0])) }
+      | postfix ARROW SCALAR_VAR '(' expr_opt ')' { result = node(:MethodCall, val[0], variable(:scalar, val[2]), list_items(val[4]), token: token_of(val[0])) }
+      | postfix ARROW '(' expr_opt ')' { result = node(:CodeCall, val[0], list_items(val[3]), token: token_of(val[0])) }
+      | postfix INC { result = node(:Postfix, :increment, val[0], token: val[1]) }
+      | postfix DEC { result = node(:Postfix, :decrement, val[0], token: val[1]) }
+      | postfix ARROW BAREWORD { result = node(:MethodCall, val[0], val[2].value, [], token: token_of(val[0])) }
+      | postfix ARROW PACKAGE_NAME { result = node(:MethodCall, val[0], val[2].value, [], token: token_of(val[0])) }
+      | postfix ARROW ARRAY_VAR { result = postfix_dereference(val[0], val[2], :array) }
+      | postfix ARROW HASH_VAR { result = postfix_dereference(val[0], val[2], :hash) }
+
+    term
+      : NUMBER { result = node(:Literal, val[0].value, token: val[0]) }
+      | VERSION { result = node(:Literal, val[0].value, token: val[0]) }
+      | STRING { result = node(:Literal, literal_value(val[0]), token: val[0]) }
+      | ISTRING { result = node(:Literal, val[0].value, token: val[0]) }
+      | HEREDOC { result = node(:Literal, val[0].value, token: val[0]) }
+      | BACKTICK { result = node(:Literal, val[0].value, token: val[0]) }
+      | MATCH { result = node(:Match, val[0].value, token: val[0]) }
+      | QR { result = node(:Regexp, val[0].value, token: val[0]) }
+      | SUBST { result = node(:Substitute, val[0].value, token: val[0]) }
+      | TRANS { result = node(:Transliterate, val[0].value, token: val[0]) }
+      | READLINE { result = node(:Readline, val[0].value, token: val[0]) }
+      | QW {
+          words = val[0].value.parts.first.split.map { |word| node(:Literal, word, token: val[0]) }
+          result = node(:List, words, token: val[0])
+        }
+      | BAREWORD { result = node(:Bareword, val[0].value, token: val[0]) }
+      | PACKAGE_NAME { result = node(:Literal, val[0].value.delete_suffix('::'), token: val[0]) }
+      | variable
+      | SCALAR_DEREF_OPEN expr RBRACE { result = node(:DereferenceExpr, :scalar, val[1], token: val[0]) }
+      | ARRAY_DEREF_OPEN expr RBRACE { result = node(:DereferenceExpr, :array, val[1], token: val[0]) }
+      | HASH_DEREF_OPEN expr RBRACE { result = node(:DereferenceExpr, :hash, val[1], token: val[0]) }
+      | CODE_DEREF_OPEN expr RBRACE { result = node(:DereferenceExpr, :code, val[1], token: val[0]) }
+      | '(' expr ')' { result = node(:Group, val[1], token: val[0]) }
+      | '[' expr_opt ']' { result = node(:ArrayLiteral, list_items(val[1]), token: val[0]) }
+      | HASHREF_LBRACE expr_opt RBRACE { result = node(:HashLiteral, list_items(val[1]), token: val[0]) }
+      | FUNC '(' expr_opt ')' { result = node(:Call, val[0].value, list_items(val[2]), token: val[0]) }
+      | FUNC { result = node(:Call, qualify(val[0].value), [], token: val[0]) }
+      | LISTOP { result = node(:Call, qualify(val[0].value), [], token: val[0]) }
+      | SUB prototype_opt block { result = node(:AnonSub, val[1], val[2], token: val[0]) }
+      | LISTOP '(' MY SCALAR_VAR ',' expr ')' {
+          declaration = node(:My, variable(:scalar, val[3]), nil, token: val[2])
+          result = node(:Call, val[0].value, [declaration, *list_items(val[5])], token: val[0])
+        }
+      | FUNC '(' MY SCALAR_VAR ',' expr ')' {
+          declaration = node(:My, variable(:scalar, val[3]), nil, token: val[2])
+          result = node(:Call, val[0].value, [declaration, *list_items(val[5])], token: val[0])
+        }
+      | LISTOP block unary {
+          block = node(:AnonSub, nil, val[1], token: val[0])
+          result = node(:Call, qualify(val[0].value), [block, val[2]], token: val[0])
+        }
+      | SORT unary { result = node(:Sort, nil, val[1], @package, token: val[0]) }
+      | SORT block unary { result = node(:Sort, val[1], val[2], @package, token: val[0]) }
+      | SORT SORT_SUB unary { result = node(:Sort, qualify(val[1].value), val[2], @package, token: val[0]) }
+      | MAP block unary { result = node(:Map, val[1], val[2], false, token: val[0]) }
+      | GREP block unary { result = node(:Map, val[1], val[2], true, token: val[0]) }
+      | MAP_EXPR unary { result = node(:Map, embedded_expression(val[0]), val[1], false, token: val[0]) }
+      | GREP_EXPR unary { result = node(:Map, embedded_expression(val[0]), val[1], true, token: val[0]) }
+
+    variable
+      : SCALAR_VAR { result = variable(:scalar, val[0]) }
+      | ARRAY_VAR { result = variable(:array, val[0]) }
+      | HASH_VAR { result = variable(:hash, val[0]) }
+      | CODE_VAR { result = variable(:code, val[0]) }
+      | GLOB_VAR { result = variable(:glob, val[0]) }
+      | SPECIAL_VAR { result = variable(:scalar, val[0]) }
+      | ARRAY_LAST { result = variable(:array_last, val[0]) }
+      | SCALAR_DEREF { result = node(:Dereference, :scalar, val[0].value, token: val[0]) }
+      | ARRAY_DEREF { result = node(:Dereference, :array, val[0].value, token: val[0]) }
+      | HASH_DEREF { result = node(:Dereference, :hash, val[0].value, token: val[0]) }
+      | CODE_DEREF { result = node(:Dereference, :code, val[0].value, token: val[0]) }
+
+    filehandle_opt
+      : /* empty */ { result = nil }
+      | FILEHANDLE { result = val[0].value }
+
+    package_name
+      : BAREWORD { result = val[0].value }
+      | PACKAGE_NAME { result = val[0].value }
+
+    prototype_opt
+      : /* empty */ { result = nil }
+      | PROTOTYPE { result = val[0].value }
+
+    use_args
+      : /* empty */ { result = [] }
+      | '(' ')' { result = ['__NO_IMPORT__'] }
+      | QW { result = val[0].value.parts.first.split }
+      | STRING { result = [literal_value(val[0])] }
+      | ISTRING { result = [literal_value(val[0])] }
+
+    overload_tail
+      : /* empty */ { result = [] }
+      | ',' assignment FATCOMMA assignment overload_tail {
+          result = [literal_option(val[1]), literal_option(val[3]), *val[4]]
+        }
+  end
+
+---- header
+require 'racc/parser'
+require_relative '../node'
+require_relative '../lexer'
+
+module Peruby
+  module Parser
+  end
+end
+
+---- inner
+def parse(source, file: '-e', known_subs: {}, unit: nil, package: 'main')
+  @package = package
+  @unit = unit
+  @known_subs = known_subs
+  @tokens = Lexer.new(source, file:, known_subs:, implicit_semicolon: true).each
+  do_parse
+end
+
+def register_module_imports(module_name, imports)
+  defaults = { 'Test::More' => %w[plan ok is isnt like is_deeply pass fail subtest done_testing diag],
+               'Test::Simple' => %w[plan ok],
+               'List::Util' => %w[first sum sum0 min max minstr maxstr reduce any all none shuffle uniq pairs],
+               'Scalar::Util' => %w[blessed reftype refaddr weaken dualvar looks_like_number] }
+  names = imports.reject { |name| name.to_s.start_with?('__') }
+  names = defaults.fetch(module_name, []) if names.empty? && !imports.include?('__NO_IMPORT__')
+  names.each do |name|
+    prototype = ModuleLoader.prototype(module_name, name)
+    @known_subs[name] = prototype&.start_with?('&') ? :listop : (prototype || :listop)
+  end
+end
+
+def compile_time_use(use_node)
+  return use_node unless @unit
+
+  @unit.run_at_compile_time(use_node)
+  use_node.imports.reject { |name| name.to_s.start_with?('__') || name.is_a?(Numeric) }.each do |name|
+    prototype = @unit.runtime.stash.fetch("#{use_node.module_name}::#{name}")&.code&.prototype
+    @known_subs[name] = prototype&.start_with?('&') ? :listop : (prototype || :listop)
+  end
+  %w[strict warnings utf8 feature integer bytes vars].include?(use_node.module_name) ? use_node : node(:Nop, token: use_node)
+end
+
+def phase(kind, block, token, package)
+  @unit&.register_phase(kind, block, token, package)
+end
+
+def qualify(name)
+  @package == 'main' || name.include?('::') ? name : "#{@package}::#{name}"
+end
+
+def package_variable(variable)
+  Node::Variable.new(variable.sigil, qualify(variable.name), variable.file, variable.line)
+end
+
+def next_token
+  token = @tokens.next
+  type = { :'{' => :LBRACE, :'}' => :RBRACE }.fetch(token.type, token.type)
+  type = type.to_s if type.to_s.length == 1
+  [type, token]
+rescue StopIteration
+  [false, false]
+end
+
+def on_error(_token_id, token, _stack)
+  near = token ? token.value.inspect : 'EOF'
+  line = token.respond_to?(:line) ? token.line : 1
+  file = token.respond_to?(:file) ? token.file : '-e'
+  raise CompileError, "syntax error at #{file} line #{line}, near #{near}"
+end
+
+def node(name, *values, token:)
+  if name == :Call && values[0] == 'bless' && values[1].one?
+    values[1] << Node::Literal.new(@package, token&.file, token&.line)
+  end
+  result = Node.const_get(name).new(*values, token&.file, token&.line)
+  @unit&.predeclare(result) if %i[My State].include?(name)
+  result
+end
+
+def register_mro(module_name, imports)
+  return unless module_name == 'mro' && imports.first
+
+  @unit&.runtime&.mro&.set(@package, imports.first)
+end
+
+def embedded_expression(token)
+  self.class.new.parse("#{token.value};", file: token.file, known_subs: @known_subs).statements.first
+end
+
+def variable(sigil, token)
+  node(:Variable, sigil, token.value, token:)
+end
+
+def postfix_dereference(expression, token, kind)
+  raise CompileError, "syntax error at #{token.file} line #{token.line}, near #{token.value.inspect}" unless token.value == '*'
+
+  node(:DereferenceExpr, kind, expression, token: token_of(expression))
+end
+
+def output_statement(kind, handle, arguments, token)
+  return node(kind, handle, arguments, token:) unless arguments.is_a?(Node::List) &&
+                                                      arguments.items.first.is_a?(Node::Group)
+
+  output = node(kind, handle, arguments.items.first, token:)
+  node(:List, [output, *arguments.items.drop(1)], token:)
+end
+
+def binary(operator, values)
+  node(:Binary, operator, values[0], values[2], token: token_of(values[0]))
+end
+
+def append_list(left, right)
+  items = left.is_a?(Node::List) ? left.items : [left]
+  node(:List, items + [right], token: token_of(left))
+end
+
+def list_items(value)
+  return [] unless value
+
+  value = value.expression if value.is_a?(Node::Group)
+  value.is_a?(Node::List) ? value.items : [value]
+end
+
+def ensure_list(value)
+  return value if value.is_a?(Node::List)
+
+  node(:List, [value], token: token_of(value))
+end
+
+def literal_value(token)
+  token.value.is_a?(Lexer::Quote) ? token.value.parts.first : token.value
+end
+
+def literal_option(value)
+  value.respond_to?(:value) ? value.value : nil
+end
+
+def token_of(value)
+  Struct.new(:file, :line).new(value.file, value.line)
+end
+
+def first_token(values)
+  values.empty? ? nil : token_of(values.first)
+end

data/lib/peruby/parser.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative 'parser/grammar'
+
+module Peruby
+  # Public parser facade.
+  module Parser
+    module_function
+
+    def parse(source, file: '-e', known_subs: {}, unit: nil, package: 'main')
+      Grammar.new.parse(source, file:, known_subs:, unit:, package:)
+    end
+  end
+end

data/lib/peruby/runtime/code.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Peruby
+  # Compiled Perl subroutine and its captured lexical environment.
+  Code = Data.define(:name, :body, :environment, :package, :prototype)
+  GotoRequest = Data.define(:code)
+
+  # Adapter for core-module functions implemented in Ruby.
+  class NativeBody
+    def initialize(&block)
+      @block = block
+    end
+
+    def run_subroutine(env, context)
+      result = @block.call(env, env.fetch(:array, '_').cells, context)
+      return Array(result).map { |value| value.is_a?(Scalar) ? value : Scalar.new(value) } if context == :list
+
+      result.is_a?(Scalar) ? result.get : result
+    end
+  end
+end