parser-lr 0.4.1 → 0.6.0

package/grammars/6502.grammar

@@ -0,0 +1,233 @@
+// Very simple 6502 assembler (ca65-inspired syntax).
+//
+// Example:
+//
+//   .org $8000
+//   start:
+//       LDA #$01
+//       STA $0200
+//       LDX #$00
+//   loop:
+//       INX
+//       BNE loop
+//       BRK
+
+name "6502" ;
+
+tokens
+    dot = /\./ ;
+    colon = /:/ ;
+    comma = /,/ ;
+    hash = /#/ ;
+    lpar = /\(/ ;
+    rpar = /\)/ ;
+
+    implied_op = /INX|DEX|BRK|NOP/ ;
+    branch_op = /BNE|BEQ|BCS|BCC|JMP|JSR/ ;
+    memory_op = /LDA|STA|LDX|STX|LDY|STY|ADC|SBC|AND|ORA|EOR|CMP|CPX|CPY/ ;
+    identifier = /[A-Za-z_][A-Za-z0-9_]*/ ;
+    hex_number = /\$[0-9A-Fa-f]+/ ;
+    x_reg = /[Xx]/ ;
+    y_reg = /[Yy]/ ;
+
+skip
+    whitespace = /[ \t\r\n]+/ ;
+    comment = /;[^\n\r]*/ ;
+
+start program ;
+
+grammar
+    program =
+        { [line]:line }
+    ;
+
+    line =
+        #directive directive
+      | #labeled [label]:label [colon]:colon [insn]:instruction
+      | #code [insn]:instruction
+    ;
+
+    directive =
+        [dotTok]:dot
+        [sym]:identifier
+        [value]:hex_number
+    ;
+
+    label =
+        [sym]:identifier
+    ;
+
+    instruction =
+        #implied implied
+      | #immediate immediate
+      | #absolute absolute
+      | #indexed_x indexed_x
+      | #indexed_y indexed_y
+      | #indirect_x indirect_x
+      | #relative relative
+    ;
+
+    implied =
+        [op]:implied_op
+    ;
+
+    immediate =
+        [op]:memory_op
+        [hash]:hash
+        [value]:hex_number
+    ;
+
+    absolute =
+        [op]:memory_op
+        [addr]:hex_number
+    ;
+
+    indexed_x =
+        [op]:memory_op
+        [addr]:hex_number
+        [comma]:comma
+        [index]:x_reg
+    ;
+
+    indexed_y =
+        [op]:memory_op
+        [addr]:hex_number
+        [comma]:comma
+        [index]:y_reg
+    ;
+
+    indirect_x =
+        [op]:memory_op
+        [open]:lpar
+        [addr]:hex_number
+        [comma]:comma
+        [index]:x_reg
+        [close]:rpar
+    ;
+
+    relative =
+        [op]:branch_op
+        [target]:identifier
+    ;
+
+ast
+    program =
+        { line }
+    ;
+
+    line =
+        #directive directive
+      | #labeled [label]:label [colon]:colon [insn]:instruction
+      | #code [insn]:instruction
+    ;
+
+    directive =
+        [dotTok]:dot
+        [sym]:identifier
+        [value]:hex_number
+    ;
+
+    label =
+        [sym]:identifier
+    ;
+
+    instruction =
+        #implied implied
+      | #immediate immediate
+      | #absolute absolute
+      | #indexed_x indexed_x
+      | #indexed_y indexed_y
+      | #indirect_x indirect_x
+      | #relative relative
+    ;
+
+    implied =
+        [op]:implied_op
+    ;
+
+    immediate =
+        [op]:memory_op
+        [hash]:hash
+        [value]:hex_number
+    ;
+
+    absolute =
+        [op]:memory_op
+        [addr]:hex_number
+    ;
+
+    indexed_x =
+        [op]:memory_op
+        [addr]:hex_number
+        [comma]:comma
+        [index]:x_reg
+    ;
+
+    indexed_y =
+        [op]:memory_op
+        [addr]:hex_number
+        [comma]:comma
+        [index]:y_reg
+    ;
+
+    indirect_x =
+        [op]:memory_op
+        [open]:lpar
+        [addr]:hex_number
+        [comma]:comma
+        [index]:x_reg
+        [close]:rpar
+    ;
+
+    relative =
+        [op]:branch_op
+        [target]:identifier
+    ;
+
+transform
+    program ->
+        #main pass(program$repeat_0) ;
+
+    program$repeat_0 ->
+        #main flatten(program.#program, line, program$repeat_0) ;
+
+    line ->
+        #directive line.#directive(directive)
+      | #labeled line.#labeled(label, colon, insn)
+      | #code line.#code(insn) ;
+
+    directive ->
+        #main directive.#directive(dotTok, sym, value) ;
+
+    label ->
+        #main pass(sym) ;
+
+    instruction ->
+        #implied pass(implied)
+      | #immediate pass(immediate)
+      | #absolute pass(absolute)
+      | #indexed_x pass(indexed_x)
+      | #indexed_y pass(indexed_y)
+      | #indirect_x pass(indirect_x)
+      | #relative pass(relative) ;
+
+    implied ->
+        #main instruction.#implied(op) ;
+
+    immediate ->
+        #main instruction.#immediate(op, hash, value) ;
+
+    absolute ->
+        #main instruction.#absolute(op, addr) ;
+
+    indexed_x ->
+        #main instruction.#indexed_x(op, addr, comma, index) ;
+
+    indexed_y ->
+        #main instruction.#indexed_y(op, addr, comma, index) ;
+
+    indirect_x ->
+        #main instruction.#indirect_x(op, open, addr, comma, index, close) ;
+
+    relative ->
+        #main instruction.#relative(op, target) ;

package/grammars/calc.grammar

@@ -0,0 +1,30 @@
+// Simple calculator: binary addition with AST transform.
+
+name "calc" ;
+
+tokens
+    number = /[0-9]+/ ;
+    plus = /\+/ ;
+
+skip
+    whitespace = /[ \t\r\n]+/ ;
+
+start expr ;
+
+grammar
+    expr =
+        #binary [left]:expr [operator]:plus [right]:number
+      | #literal number
+    ;
+
+ast
+    expr =
+        #binary [left]:expr [operator]:plus [right]:number
+      | #literal number
+    ;
+
+transform
+    expr ->
+        #binary expr.#binary(left, operator, right)
+      | #literal expr.#literal(number)
+    ;