@andrivet/z80-assembler 1.3.1 → 1.4.0

package/libs/z80-assembler/src/lib/grammar/z80.peg

@@ -0,0 +1,1252 @@
+---
+/**
+ * Z80 Assembler in Typescript
+ *
+ * File:        z80.peg
+ * Description: PEG grammar of the Z80 assembly language
+ * Author:		Sebastien Andrivet
+ * License:		GPLv3
+ * Copyrights: 	Copyright (C) 2023 Sebastien Andrivet
+ */
+import {
+    r_bits,
+    dd_bits,
+    qq_bits,
+    ss_bits,
+    pp_bits,
+    rr_bits,
+    cc_bits,
+    jj_bits,
+    p_bits,
+    imode
+} from "./LowLevel";
+
+import {
+  parseNumber,
+  parseZX81Char,
+  parseSimpleEscape,
+  parseOctalEscape,
+  parseHexadecimalEscape} from './Parse';
+import {LinesInfo, Address} from '../types/Types';
+
+import {
+    EvalFunc,
+    AstElements,
+    binaryOperation,
+    binaryOperations,
+    unaryOperation,
+    unaryOperations,
+    operatorOr,
+    operatorXor,
+    operatorAnd,
+    operatorLeftShift,
+    operatorRightShift,
+    operatorAdd,
+    operatorSub,
+    operatorMul,
+    operatorDiv,
+    operatorModulo,
+    operatorPlus,
+    operatorNeg,
+    operatorInvert,
+    operatorIdentity,
+    value16LE,
+    value8,
+    index,
+    jrOffset,
+    jrRelativeOffset,
+    dataBytes,
+    dataWords,
+    dataBlock,
+    labelValue,
+    value
+} from '../compiler/Ast';
+
+import {setOutputName, setDevice, includeFile} from '../compiler/Compiler';
+---
+
+// Start (top level symbol) of the grammar
+start := lines=Lines $ // Les followed by the end of the code
+
+// Names of the registers for the different opcodes (the names are from the Z80 CPU User Manual)
+r := 'a' | 'b' | 'c' | 'd' | 'e' | 'h' | 'l'
+dd := 'bc' | 'de' | 'hl' | 'sp'
+ss := dd
+qq := 'bc' | 'de' | 'hl' | 'af'
+pp := 'bc' | 'de' | 'ix' | 'sp'
+rr := 'bc' | 'de' | 'iy' | 'sp'
+
+// 8-bit values
+// Note: binary is before hexadecimal because 0b is ambiguous
+n :=
+    pos=@ binary=binary               .value = number { return parseNumber(pos, binary.raw, 2, 1); } |
+    pos=@ hexadecimal=hexadecimal     .value = number { return parseNumber(pos, hexadecimal.raw, 16, 1); } |
+    pos=@ octal=octal                 .value = number { return parseNumber(pos, octal.raw, 8, 1); } |
+    pos=@ decimal=decimal             .value = number { return parseNumber(pos, decimal.raw, 10, 1); }
+
+// 16-bit values
+// Note: binary is before hexadecimal because 0b is ambiguous
+nn :=
+    pos=@ binary=binary               .value = number { return parseNumber(pos, binary.raw, 2, 2); } |
+    pos=@ hexadecimal=hexadecimal     .value = number { return parseNumber(pos, hexadecimal.raw, 16, 2); } |
+    pos=@ octal=octal                 .value = number { return parseNumber(pos, octal.raw, 8, 2); } |
+    pos=@ decimal=decimal             .value = number { return parseNumber(pos, decimal.raw, 10, 2); }
+
+// A decimal unsigned value with the different allowed syntaxes
+decimal :=
+    raw='[0-9]+' 'd'?
+
+// A binary value with the different allowed syntaxes
+binary :=
+    {'0b' | '%'} raw='[0-1]+' |
+    raw='[0-1]+' 'b'
+
+// An octal value with the different allowed syntaxes
+octal :=
+    {'0q' | '0o' | '@'} raw='[0-7]+' |
+    raw='[0-7]+' {'q' | 'o'}
+
+// An hexadecimal value with the different allowed syntaxes
+// To avoid ambiguity, hexadecimal values are not allowed to be followed by an alphanumerical character
+hexadecimal :=
+    {'0x' | '\$' | '#'} raw='[0-9a-f]+' |
+    raw='[0-9a-f]+' 'h' !'[0-9a-z]'
+
+// Different names used in the Z80 CPU User Manual for 8-bit values
+d := n
+e := n
+p := n
+
+// A bit value
+b := raw='[0-7]'    .value = number { return parseInt(raw); }
+
+// Conditional flags for jumps
+cc := 'nz' | 'z' | 'nc' | 'c' | 'po' | 'pe' | 'p' | 'm' | 's'
+// Conditional flags for djnz
+jj := 'c'  | 'nc' | 'z' | 'nz'
+
+__   := '[ \t]+'                // Mandatory space
+_    := '[ \t]*'                // Optional space
+eos := '[ \t]*(;|\r\n|\n|//)'   // End of statement
+eol := '\r\n|\n'                // End of line
+
+// Lines is a list of lines (can be empty)
+Lines :=
+    Line*
+
+// A line is either an equality or a statement
+Line :=
+  LineEqual | LineStatement
+
+// An equality is a label (mandatory) followed by an equality directive, an optional comment and an end of line.
+LineEqual :=
+  label=LabelDeclaration _ equal=EqualDirective _ comment=Comment? eol
+
+// A line with a statement is an optional label, followed by a statement, an optional comment and an end of line.
+LineStatement :=
+  label=LabelDeclaration? _ statement=Statement? _ comment=Comment? eol
+
+// A statement is either an include, an instruction or a directive
+Statement :=
+    inc=IncludeDirective
+    .info = LinesInfo { return inc.info; } |
+
+    ins=Instruction
+    .elements = AstElements { return ins.elements; } |
+
+    dir=Directive
+    .elements = AstElements { return dir.elements; }
+    .address = Address { return dir.address; }
+
+// An equality directive is 'equ' (or an alias) followed by an expression
+EqualDirective :=
+    '\.?equ|eq|=' __ e=Expression
+
+// A directive is either a data directive, an origin directive, an output directive or a device directive
+Directive :=
+    data=DataDirective
+    .elements = AstElements { return data.elements; }
+    .address = Address { return null; } |
+
+    origin=OriginDirective
+    .elements = AstElements { return []; }
+    .address = Address { return origin.address.value; } |
+
+    directive=OutputDirective
+    .elements = AstElements { return []; }
+    .address = Address { return null; } |
+
+    directive=DeviceDirective
+    .elements = AstElements { return []; }
+    .address = Address { return null; } |
+
+    directive=EndDirective
+    .elements = AstElements { return []; }
+    .address = Address { return null; }
+
+// Names not allowed for a label
+ForbiddenNames :=
+    '\.?block|\.?equ|\.?org|\.?include|\.?output|\.?device|\.?end|\.?byte' |
+    'call|cpdr|cpir|defb|defm|defs|defw|djnz|eq|halt|indr|inir|lddr|ldir|otdr|otir|outd|outi|push|reti|retn|rlca|rrca|\.?word' |
+    'adc|add|and|bit|ccf|cpd|cpi|cpl|daa|dec|exx|inc|ind|ini|ldd|ldi|neg|nop|org|out|pop|res|ret|rla' |
+    'rlc|rld|rra|rrc|rrd|rst|sbc|scf|set|sla|sra|srl|sub|xor' |
+    'cp|db|di|dm|ds|dw|ei|eq|ex|im|in|jp|jr|ld|or|rl|rr'
+
+// A forbidden label is a name not allowed for a label followed by a space, a tabulation, the character ':' or an end of line.
+ForbiddenLabel :=
+    ForbiddenNames '[ \t:\r\n]'
+
+// A label can't have a forbidden name. It is a name or the special pseudo label $ (PC).
+Label :=
+    !ForbiddenLabel pos=@ name='[a-z_\.][a-z0-9_!\?#@\.\$]*|\$'
+
+// A label declaration can't have a forbidden name. It is a name optionally followed by a ':' character.
+LabelDeclaration :=
+    !ForbiddenLabel pos=@ name='[a-z_\.][a-z0-9_!\?#@\.\$]*' '\:'?
+
+
+// An expression is a bitwise OR expression
+Expression :=
+    e1=BitwiseOrExpression
+    .eval = EvalFunc { return e1.eval; }
+
+// Precedences: unary, multiplicative, additive, shift, and, xor, or
+// Associativity: left to right
+
+// A bitwise OR expression is a list of bitwise OR expressions (eventually empty) followed by a bitwise XOR expression
+BitwiseOrExpression :=
+    left={e=BitwiseOrExpression _ '\|'}? _ right=BitwiseXOrExpression
+    .eval = EvalFunc { return binaryOperation(left, right, operatorOr); }
+
+// A bitwise XOR expression is a list of bitwise XOR expressions (eventually empty) followed by a bitwise AND expression
+BitwiseXOrExpression :=
+    left={e=BitwiseXOrExpression _ '\^'}? _ right=BitwiseAndExpression
+    .eval = EvalFunc { return binaryOperation(left, right, operatorXor); }
+
+// A bitwise AND expression is a list of bitwise AND expressions (eventually empty) followed by a bitwise Shift expression
+BitwiseAndExpression :=
+    left={e=BitwiseAndExpression _ '\&'}? _ right=ShiftExpression
+    .eval = EvalFunc { return binaryOperation(left, right, operatorAnd); }
+
+// A bitwise Shift expression is a list of bitwise Shift expressions (eventually empty) followed by an Additive expression
+ShiftExpression :=
+    left={e=ShiftExpression _ op={'<<' | '>>'}}? _ right=AdditiveExpression
+    .eval = EvalFunc { return binaryOperations(left, right, {'<<': operatorLeftShift, '>>': operatorRightShift}); }
+
+// An Additive expression is a list of Additive expressions (eventually empty) followed by a Multiplicative expression
+AdditiveExpression :=
+    left={e=AdditiveExpression _ op={'\+' | '\-'}}? _ right=MultiplicativeExpression
+    .eval = EvalFunc { return binaryOperations(left, right, {'+': operatorAdd, '-': operatorSub}); }
+
+// A Multiplicative expression is a list of Multiplicative expressions (eventually empty) followed by an Unary expression
+MultiplicativeExpression :=
+    left={e=MultiplicativeExpression _ op={'\*' | '%' | '/'}}? _ right=UnaryExpression
+    .eval = EvalFunc { return binaryOperations(left, right, {'*': operatorMul, '/': operatorDiv, '%': operatorModulo} ); }
+
+// An Unary expression is an optional unary operator followed by a Primary expression
+UnaryExpression :=
+    op={'~' | '\+' | '\-'} _ e=PrimaryExpression
+    .eval = EvalFunc { return unaryOperations(e, op, {'~': operatorInvert, '+': operatorPlus, '-': operatorNeg} ); } |
+
+    e=PrimaryExpression
+    .eval = EvalFunc { return unaryOperation(e, operatorIdentity); }
+
+// A Primary expression is a either a number, a label or an expression enclosed in parenthesis
+PrimaryExpression :=
+    nn=nn
+    .eval = EvalFunc { return value(nn.value); } |
+
+    pos=@ label=Label
+    .eval = EvalFunc { return labelValue(pos, label.name); } |
+
+    '\(' e=BitwiseOrExpression '\)'
+    .eval = EvalFunc { return unaryOperation(e, operatorIdentity); }
+
+// A 8-bit register is the name of a 8-bit register but can't be followed by characters such as alphanumerical
+// or symbols. This is to distinguish registers from labels
+Reg8 :=
+    reg=r &'[^a-z0-9_!\?#@\.]'
+
+// IX register with an (optional) offset
+IX :=
+  'ix' offset={ _ s={'\+' | '\-'} _ pos=@ d=Expression }?
+
+// IY register with an (optional) offset
+IY :=
+  'iy' offset={ _ s={'\+' | '\-'} _ pos=@ d=Expression }?
+
+// An instruction
+Instruction :=
+    Load8Instruction |
+    Load16Instruction |
+    ExchangeInstruction |
+    BlockInstruction |
+    ArithmeticLogic8Instruction |
+    IncrementDecrement8Instruction |
+    GeneralPurposeArithmeticInstruction |
+    ArithmeticLogic16Instruction |
+    RotateShiftInstruction |
+    BitManipulationInstruction |
+    JumpInstruction |
+    CallInstruction |
+    ReturnInstruction |
+    InputInstruction |
+    OutputInstruction |
+    CpuControlGroupInstruction
+
+// 8-bit Load
+Load8Instruction :=
+    // LD r, r'
+    'ld' __ r0=Reg8 _ ',' _ r1=Reg8 &eos
+    .elements = AstElements { return [0b01000000 | r_bits(r0.reg, 3) | r_bits(r1.reg)]; } |
+
+    // LD r, (HL)
+    'ld' __ r=r _ ',' _ '\(' 'hl' '\)' &eos
+    .elements = AstElements { return [0b01000110 | r_bits(r, 3)]; } |
+
+    // LD r, (IX+d)
+    'ld' __ r=r _ ',' _ '\(' _ i=IX _ '\)' &eos
+    .elements = AstElements { return [0xDD, 0b01000110 | r_bits(r, 3), index(i.offset)]; } |
+
+    // LD r, (IY+d)
+    'ld' __ r=r _ ',' _ '\(' _ i=IY _ '\)' &eos
+    .elements = AstElements { return [0xFD, 0b01000110 | r_bits(r, 3), index(i.offset)]; } |
+
+    // LD (HL), r
+    'ld' __ '\(' _ 'hl' _ '\)' _ ',' _ r=r &eos
+    .elements = AstElements { return [0b01110000 | r_bits(r)]; } |
+
+    // LD (IX+d), r
+    'ld' __ '\(' _ i=IX _ '\)' _ ',' _ r=r &eos
+    .elements = AstElements { return [0xDD, 0b01110000 | r_bits(r), index(i.offset)]; } |
+
+    // LD (IY+d), r
+    'ld' __ '\(' _ i=IY _ '\)' _ ',' _ r=r &eos
+    .elements = AstElements { return [0xFD, 0b01110000 | r_bits(r), index(i.offset)]; } |
+
+    // LD (HL), n
+    'ld' __ '\(' 'hl' '\)' _ ',' _ pos=@ n=Expression &eos
+    .elements = AstElements { return [0x36, value8(pos, n)]; } |
+
+    // LD (IX+d), n
+    'ld' __ '\(' _ i=IX _ '\)' _ ',' _ pos=@ n=Expression &eos
+    .elements = AstElements { return [0xDD, 0x36, index(i.offset), value8(pos, n)]; } |
+
+    // LD (IY+d), n
+    'ld' __ '\(' _ i=IY _ '\)' _ ',' _ pos=@ n=Expression &eos
+    .elements = AstElements { return [0xFD, 0x36, index(i.offset), value8(pos, n)]; } |
+
+    // LD A, (BC)
+    'ld' __ 'a' _ ',' _ '\(' _ 'bc' _ '\)' &eos
+    .elements = AstElements { return [0x0A]; } |
+
+    // LD A, (DE)
+    'ld' __ 'a' _ ',' _ '\(' _ 'de' _ '\)' &eos
+    .elements = AstElements { return [0x1A]; } |
+
+    // LD A, (nn)
+    'ld' __ 'a' _ ',' _ '\(' _ pos=@ ee=Expression _ '\)' &eos
+    .elements = AstElements { return [0x3A, value16LE(pos, ee)]; } |
+
+    // LD (BC), A
+    'ld' __ '\(' _ 'bc' _ '\)' _ ',' _ 'a' &eos
+    .elements = AstElements { return [0x02]; } |
+
+    // LD (DE), A
+    'ld' __ '\(' _ 'de' _ '\)' _ ',' _ 'a' &eos
+    .elements = AstElements { return [0x12]; } |
+
+    // LD (nn), A
+    'ld' __ '\(' _ pos=@ ee=Expression _ '\)' _ ',' _ 'a' &eos
+    .elements = AstElements { return [0x32, value16LE(pos, ee)]; } |
+
+    // LD A, I
+    'ld' __ 'a' _ ',' _ 'i' &eos
+    .elements = AstElements { return [0xED, 0x57]; } |
+
+    // LD A, R
+    'ld' __ 'a' _ ',' _ 'r' &eos
+    .elements = AstElements { return [0xED, 0x5F]; } |
+
+    // LD I, A
+    'ld' __ 'i' _ ',' _ 'a' &eos
+    .elements = AstElements { return [0xED, 0x47]; } |
+
+    // LD R, A
+    'ld' __ 'r' _ ',' _ 'a' &eos
+    .elements = AstElements { return [0xED, 0x4F]; } |
+
+    // Have to be after the others to avoid ambiguity on n=Expression
+    // LD r, n
+    // Have to be before LD r,r' because it is ambiguous
+    'ld' __ r=Reg8 _ ',' _ pos=@ n=Expression &eos
+    .elements = AstElements { return [0b00000110 | r_bits(r.reg, 3), value8(pos, n)]; }
+
+// 16-bit Load
+Load16Instruction :=
+    // LD IX, (nn)
+    'ld' __ 'ix' _ ',' _ '\(' _ pos=@ ee=Expression _ '\)' &eos
+    .elements = AstElements { return [0xDD, 0x2A, value16LE(pos, ee)]; } |
+
+    // LD IY, (nn)
+    'ld' __ 'iy' _ ',' _ '\(' _ pos=@ ee=Expression _ '\)' &eos
+    .elements = AstElements { return [0xFD, 0x2A, value16LE(pos, ee)]; } |
+
+    // LD IX, nn
+    'ld' __ 'ix' _ ',' _ pos=@ ee=Expression &eos
+    .elements = AstElements { return [0xDD, 0x21, value16LE(pos, ee)]; } |
+
+    // LD IY, nn
+    'ld' __ 'iy' _ ',' _ pos=@ ee=Expression &eos
+    .elements = AstElements { return [0xFD, 0x21, value16LE(pos, ee)]; } |
+
+    // LD HL, (nn)
+    'ld' __ 'hl' _ ',' _ '\(' _ pos=@ ee=Expression _ '\)' &eos
+    .elements = AstElements { return [0x2A, value16LE(pos, ee)]; } |
+
+    // LD dd, (nn)
+    'ld' __ dd=dd _ ',' _ '\(' _ pos=@ ee=Expression _ '\)' &eos
+    .elements = AstElements { return [0xED, 0b01001011 | dd_bits(dd, 4), value16LE(pos, ee)]; } |
+
+    // LD (nn), HL
+    'ld' __ '\(' _ pos=@ ee=Expression _ '\)' _ ',' _ 'hl' &eos
+    .elements = AstElements { return [0x22, value16LE(pos, ee)]; } |
+
+    // LD (nn), dd
+    'ld' __ '\(' _ pos=@ ee=Expression _ '\)' _ ',' _ dd=dd &eos
+    .elements = AstElements { return [0xED, 0b01000011 | dd_bits(dd, 4), value16LE(pos, ee)]; } |
+
+    // LD (nn), IX
+    'ld' __ '\(' _ pos=@ ee=Expression _ '\)' _ ',' _ 'ix' &eos
+    .elements = AstElements { return [0xDD, 0x22, value16LE(pos, ee)]; } |
+
+    // LD (nn), IY
+    'ld' __ '\(' _ pos=@ ee=Expression _ '\)' _ ',' _ 'iy' &eos
+    .elements = AstElements { return [0xFD, 0x22, value16LE(pos, ee)]; } |
+
+    // LD SP, HL
+    'ld' __ 'sp' _ ',' _ 'hl' &eos
+    .elements = AstElements { return [0xF9]; } |
+
+    // LD SP, IX
+    'ld' __ 'sp' _ ',' _ 'ix' &eos
+    .elements = AstElements { return [0xDD, 0xF9]; } |
+
+    // LD SP, IY
+    'ld' __ 'sp' _ ',' _ 'iy' &eos
+    .elements = AstElements { return [0xFD, 0xF9]; } |
+
+    // Have to be after the other LD instructions
+    // LD dd, nn
+    'ld' __ dd=dd _ ',' _ pos=@ ee=Expression &eos
+    .elements = AstElements { return [0b00000001 | dd_bits(dd, 4), value16LE(pos, ee)]; } |
+
+    // PUSH qq
+    'push' __ qq=qq &eos
+    .elements = AstElements { return [0b11000101 | qq_bits(qq, 4)]; } |
+
+    // PUSH IX
+    'push' __ 'ix' &eos
+    .elements = AstElements { return [0xDD, 0xE5]; } |
+
+    // PUSH IY
+    'push' __ 'iy' &eos
+    .elements = AstElements { return [0xFD, 0xE5]; } |
+
+    // POP qq
+    'pop' __ qq=qq &eos
+    .elements = AstElements { return [0b11000001 | qq_bits(qq, 4)]; } |
+
+    // POP IX
+    'pop' __ 'ix' &eos
+    .elements = AstElements { return [0xDD, 0xE1]; } |
+
+    // POP IY
+    'pop' __ 'iy' &eos
+    .elements = AstElements { return [0xFD, 0xE1]; }
+
+// Exchange
+ExchangeInstruction :=
+    // EX DE, HL
+    'ex' __ 'de' _ ',' _ 'hl' &eos
+    .elements = AstElements { return [0xEB]; } |
+
+    // EX AF, AF'
+    'ex' __ 'af' _ ',' _ 'af\'' &eos
+    .elements = AstElements { return [0x08]; } |
+
+    // EXX
+    'exx' &eos
+    .elements = AstElements { return [0xD9]; } |
+
+    // EX (SP), HL
+    'ex' __ '\(' 'sp' '\)' _ ',' _ 'hl' &eos
+    .elements = AstElements { return [0xE3]; } |
+
+    // EX (SP), IX
+    'ex' __ '\(' 'sp' '\)' _ ',' _ 'ix' &eos
+    .elements = AstElements { return [0xDD, 0xE3]; } |
+
+    // EX (SP), IY
+    'ex' __ '\(' 'sp' '\)' _ ',' _ 'iy' &eos
+    .elements = AstElements { return [0xFD, 0xE3]; }
+
+// Block Transfer and Search
+BlockInstruction :=
+    // Have to be before ldi
+    // LDIR
+    'ldir' &eos
+    .elements = AstElements { return [0xED, 0xB0]; } |
+
+    // LDI
+    'ldi' &eos
+    .elements = AstElements { return [0xED, 0xA0]; } |
+
+    // LDDR
+    'lddr' &eos
+    .elements = AstElements { return [0xED, 0xB8]; } |
+
+    // LDD
+    'ldd' &eos
+    .elements = AstElements { return [0xED, 0xA8]; } |
+
+    // CPIR
+    'cpir' &eos
+    .elements = AstElements { return [0xED, 0xB1]; } |
+
+    // CPI
+    'cpi' &eos
+    .elements = AstElements { return [0xED, 0xA1]; } |
+
+    // CPDR
+    'cpdr' &eos
+    .elements = AstElements { return [0xED, 0xB9]; } |
+
+    // CPD
+    'cpd' &eos
+    .elements = AstElements { return [0xED, 0xA9]; }
+
+// 8-bit Arithmetic
+ArithmeticLogic8Instruction :=
+    // ADD A, (HL)
+    'add' __ {'a' _ ',' _}? '\(' _ 'hl'_ '\)' &eos
+    .elements = AstElements { return [0x86]; } |
+
+    // ADD A, (IX+d)
+    'add' __ {'a' _ ',' _}? '\(' _ i=IX _ '\)' &eos
+    .elements = AstElements { return [0xDD, 0x86, index(i.offset)]; } |
+
+    // ADD A, (IY+d)
+    'add' __ {'a' _ ',' _}? '\(' _ i=IY _ '\)' &eos
+    .elements = AstElements { return [0xFD, 0x86, index(i.offset)]; } |
+
+    // ADD A, r
+    'add' __ {'a' _ ',' _}? r=r &eos
+    .elements = AstElements { return [0b10000000 | r_bits(r)]; } |
+
+    // ADD A, n
+    'add' __ {'a' _ ',' _}? pos=@ n=Expression &eos
+    .elements = AstElements { return [0xC6, value8(pos, n)]; } |
+
+    // ADC A, (HL)
+    'adc' __ {'a' _ ',' _}? '\(' _ 'hl'_ '\)' &eos
+    .elements = AstElements { return [0x8E]; } |
+
+    // ADC (IX+d)
+    'adc' __ {'a' _ ',' _}? '\(' _ i=IX _ '\)' &eos
+    .elements = AstElements { return [0xDD, 0x8E, index(i.offset)]; } |
+
+    // ADC (IY+d)
+    'adc' __ {'a' _ ',' _}? '\(' _ i=IY _ '\)' &eos
+    .elements = AstElements { return [0xFD, 0x8E, index(i.offset)]; } |
+
+    // ADC A, r
+    'adc' __ {'a' _ ',' _}? r=r &eos
+    .elements = AstElements { return [0b10001000 | r_bits(r)]; } |
+
+    // ADC A, n
+    'adc' __ {'a' _ ',' _}? pos=@ n=Expression &eos
+    .elements = AstElements { return [0xCE, value8(pos, n)]; } |
+
+    // SUB A, (HL)
+    'sub' __ {'a' _ ',' _}? '\(' _ 'hl'_ '\)' &eos
+    .elements = AstElements { return [0x96]; } |
+
+    // SUB (IX+d)
+    'sub' __ {'a' _ ',' _}? '\(' _ i=IX _ '\)' &eos
+    .elements = AstElements { return [0xDD, 0x96, index(i.offset)]; } |
+
+    // SUB (IY+d)
+    'sub' __ {'a' _ ',' _}? '\(' _ i=IY _ '\)' &eos
+    .elements = AstElements { return [0xFD, 0x96, index(i.offset)]; } |
+
+    // SUB A, r
+    'sub' __ {'a' _ ',' _}? r=r &eos
+    .elements = AstElements { return [0b10010000 | r_bits(r)]; } |
+
+    // SUB A, n
+    'sub' __ {'a' _ ',' _}? pos=@ n=Expression &eos
+    .elements = AstElements { return [0xD6, value8(pos, n)]; } |
+
+    // SBC A, (HL)
+    'sbc' __ {'a' _ ',' _}? '\(' _ 'hl'_ '\)' &eos
+    .elements = AstElements { return [0x9E]; } |
+
+    // SBC (IX+d)
+    'sbc' __ {'a' _ ',' _}? '\(' _ i=IX _ '\)' &eos
+    .elements = AstElements { return [0xDD, 0x9E, index(i.offset)]; } |
+
+    // SBC (IY+d)
+    'sbc' __ {'a' _ ',' _}? '\(' _ i=IY _ '\)' &eos
+    .elements = AstElements { return [0xFD, 0x9E, index(i.offset)]; } |
+
+    // SBC A, r
+    'sbc' __ {'a' _ ',' _}? r=r &eos
+    .elements = AstElements { return [0b10011000 | r_bits(r)]; } |
+
+    // SBC A, n
+    'sbc' __ {'a' _ ',' _}? pos=@ n=Expression &eos
+    .elements = AstElements { return [0xDE, value8(pos, n)]; } |
+
+    // AND A, (HL)
+    'and' __ {'a' _ ',' _}? '\(' _ 'hl'_ '\)' &eos
+    .elements = AstElements { return [0xA6]; } |
+
+    // AND (IX+d)
+    'and' __ {'a' _ ',' _}? '\(' _ i=IX _ '\)' &eos
+    .elements = AstElements { return [0xDD, 0xA6, index(i.offset)]; } |
+
+    // AND (IY+d)
+    'and' __ {'a' _ ',' _}? '\(' _ i=IY _ '\)' &eos
+    .elements = AstElements { return [0xFD, 0xA6, index(i.offset)]; } |
+
+    // AND A, r
+    'and' __ {'a' _ ',' _}? r=r &eos
+    .elements = AstElements { return [0b10100000 | r_bits(r)]; } |
+
+    // AND A, n
+    'and' __ {'a' _ ',' _}? pos=@ n=Expression &eos
+    .elements = AstElements { return [0xE6, value8(pos, n)]; } |
+
+    // OR A, (HL)
+    'or' __ {'a' _ ',' _}? '\(' _ 'hl'_ '\)' &eos
+    .elements = AstElements { return [0xB6]; } |
+
+    // OR (IX+d)
+    'or' __ {'a' _ ',' _}? '\(' _ i=IX _ '\)' &eos
+    .elements = AstElements { return [0xDD, 0xB6, index(i.offset)]; } |
+
+    // OR (IY+d)
+    'or' __ {'a' _ ',' _}? '\(' _ i=IY _ '\)' &eos
+    .elements = AstElements { return [0xFD, 0xB6, index(i.offset)]; } |
+
+    // OR A, r
+    'or' __ {'a' _ ',' _}? r=r &eos
+    .elements = AstElements { return [0b10110000 | r_bits(r)]; } |
+
+    // OR A, n
+    'or' __ {'a' _ ',' _}? pos=@ n=Expression &eos
+    .elements = AstElements { return [0xF6, value8(pos, n)]; } |
+
+    // XOR A, (HL)
+    'xor' __ {'a' _ ',' _}? '\(' _ 'hl'_ '\)' &eos
+    .elements = AstElements { return [0xAE]; } |
+
+    // XOR (IX+d)
+    'xor' __ {'a' _ ',' _}? '\(' _ i=IX _ '\)' &eos
+    .elements = AstElements { return [0xDD, 0xAE, index(i.offset)]; } |
+
+    // XOR (IY+d)
+    'xor' __ {'a' _ ',' _}? '\(' _ i=IY _ '\)' &eos
+    .elements = AstElements { return [0xFD, 0xAE, index(i.offset)]; } |
+
+    // XOR A, r
+    'xor' __ {'a' _ ',' _}? r=r &eos
+    .elements = AstElements { return [0b10101000 | r_bits(r)]; } |
+
+    // XOR A, n
+    'xor' __ {'a' _ ',' _}? pos=@ n=Expression &eos
+    .elements = AstElements { return [0xEE, value8(pos, n)]; } |
+
+    // CP A, (HL)
+    'cp' __ {'a' _ ',' _}? '\(' _ 'hl'_ '\)' &eos
+    .elements = AstElements { return [0xBE]; } |
+
+    // CP (IX+d)
+    'cp' __ {'a' _ ',' _}? '\(' _ i=IX _ '\)' &eos
+    .elements = AstElements { return [0xDD, 0xBE, index(i.offset)]; } |
+
+    // CP (IY+d)
+    'cp' __ {'a' _ ',' _}? '\(' _ i=IY _ '\)' &eos
+    .elements = AstElements { return [0xFD, 0xBE, index(i.offset)]; } |
+
+    // CP A, r
+    'cp' __ {'a' _ ',' _}? r=r &eos
+    .elements = AstElements { return [0b10111000 | r_bits(r)]; } |
+
+    // CP A, n
+    'cp' __ {'a' _ ',' _}? pos=@ n=Expression &eos
+    .elements = AstElements { return [0xFE, value8(pos, n)]; }
+
+
+// 8-bit Increment and Decrement
+IncrementDecrement8Instruction :=
+    // INC r
+    'inc' __ r=r &eos
+    .elements = AstElements { return [0b00000100 | r_bits(r, 3)]; } |
+
+    // INC (HL)
+    'inc' __ '\(' _ 'hl' _ '\)' &eos
+    .elements = AstElements { return [0x34]; } |
+
+    // INC (IX+d)
+    'inc' __ '\(' _ i=IX _ '\)' &eos
+    .elements = AstElements { return [0xDD, 0x34, index(i.offset)]; } |
+
+    // INC (IY+d)
+    'inc' __ '\(' _ i=IY _ '\)' &eos
+    .elements = AstElements { return [0xFD, 0x34, index(i.offset)]; } |
+
+    // DEC r
+    'dec' __ r=r &eos
+    .elements = AstElements { return [0b00000101 | r_bits(r, 3)]; } |
+
+    // DEC (HL)
+    'dec' __ '\(' _ 'hl' _ '\)' &eos
+    .elements = AstElements { return [0x35]; } |
+
+    // DEC (IX+d)
+    'dec' __ '\(' _ i=IX _ '\)' &eos
+    .elements = AstElements { return [0xDD, 0x35, index(i.offset)]; } |
+
+    // DEC (IY+d)
+    'dec' __ '\(' _ i=IY _ '\)' &eos
+    .elements = AstElements { return [0xFD, 0x35, index(i.offset)]; }
+
+// General Purpose Arithmetic Instructions
+GeneralPurposeArithmeticInstruction :=
+    // DAA
+    'daa' &eos
+    .elements = AstElements { return [0x27]; } |
+
+    // CPL
+    'cpl' &eos
+    .elements = AstElements { return [0x2F]; } |
+
+    // NEG
+    'neg' &eos
+    .elements = AstElements { return [0xED, 0x44]; } |
+
+    // CCF
+    'ccf' &eos
+    .elements = AstElements { return [0x3F]; } |
+
+    // SCF
+    'scf' &eos
+    .elements = AstElements { return [0x37]; }
+
+// CPU Control Group Instructions
+CpuControlGroupInstruction :=
+    // NOP
+    'nop' &eos
+    .elements = AstElements { return [0x00]; } |
+
+    // HALT
+    'halt' &eos
+    .elements = AstElements { return [0x76]; } |
+
+    // DI
+    'di' &eos
+    .elements = AstElements { return [0xF3]; } |
+
+    // EI
+    'ei' &eos
+    .elements = AstElements { return [0xFB]; } |
+
+    // IM 0, IM 1, IM 2
+    'im' __ m='[012]' &eos
+    .elements = AstElements { return [0xED, imode(m)]; }
+
+// 16-bit Arithmetic
+ArithmeticLogic16Instruction :=
+    // ADD HL, ss
+    'add' __ 'hl' _ ',' _ ss=ss &eos
+    .elements = AstElements { return [0b00001001 | ss_bits(ss, 4)]; } |
+
+    // ADC HL, ss
+    'adc' __ 'hl' _ ',' _ ss=ss &eos
+    .elements = AstElements { return [0xED, 0b01001010 | ss_bits(ss, 4)]; } |
+
+    // SBC HL, ss
+    'sbc' __ 'hl' _ ',' _ ss=ss &eos
+    .elements = AstElements { return [0xED, 0b01000010 | ss_bits(ss, 4)]; } |
+
+    // ADD IX, pp
+    'add' __ 'ix' _ ',' _ pp=pp &eos
+    .elements = AstElements { return [0xDD, 0b00001001 | pp_bits(pp, 4)]; } |
+
+    // ADD IY, pp
+    'add' __ 'iy' _ ',' _ rr=rr &eos
+    .elements = AstElements { return [0xFD, 0b00001001 | rr_bits(rr, 4)]; } |
+
+    // INC ss
+    'inc' __ ss=ss &eos
+    .elements = AstElements { return [0b00000011 | ss_bits(ss, 4)]; } |
+
+    // INC IX
+    'inc' __ 'ix' &eos
+    .elements = AstElements { return [0xDD, 0x23]; } |
+
+    // INC IY
+    'inc' __ 'iy' &eos
+    .elements = AstElements { return [0xFD, 0x23]; } |
+
+    // DEC ss
+    'dec' __ ss=ss &eos
+    .elements = AstElements { return [0b00001011 | ss_bits(ss, 4)]; } |
+
+    // DEC IX
+    'dec' __ 'ix' &eos
+    .elements = AstElements { return [0xDD, 0x2B]; } |
+
+    // DEC IY
+    'dec' __ 'iy' &eos
+    .elements = AstElements { return [0xFD, 0x2B]; }
+
+// Rotate and Shift
+RotateShiftInstruction :=
+    // RLCA
+    'rlca' &eos
+    .elements = AstElements { return [0x07]; } |
+
+    // RLA
+    'rla' &eos
+    .elements = AstElements { return [0x17]; } |
+
+    // RRCA
+    'rrca' &eos
+    .elements = AstElements { return [0x0F]; } |
+
+    // RRA
+    'rra' &eos
+    .elements = AstElements { return [0x1F]; } |
+
+    // RLC r
+    'rlc' __ r=r &eos
+    .elements = AstElements { return [0xCB, 0b00000000 | r_bits(r)]; } |
+
+    // RLC (HL)
+    'rlc' __ '\(' _ 'hl' _ '\)' &eos
+    .elements = AstElements { return [0xCB, 0x06]; } |
+
+    // RLC (IX+d)
+    'rlc' __ '\(' _ i=IX _ '\)' &eos
+    .elements = AstElements { return [0xDD, 0xCB, index(i.offset), 0x06]; } |
+
+    // RLC (IY+d)
+    'rlc' __ '\(' _ i=IY _ '\)' &eos
+    .elements = AstElements { return [0xFD, 0xCB, index(i.offset), 0x06]; } |
+
+    // RL r
+    'rl' __ r=r &eos
+    .elements = AstElements { return [0xCB, 0b00010000 | r_bits(r)]; } |
+
+    // RL (HL)
+    'rl' __ '\(' _ 'hl' _ '\)' &eos
+    .elements = AstElements { return [0xCB, 0x16]; } |
+
+    // RL (IX+d)
+    'rl' __ '\(' _ i=IX _ '\)' &eos
+    .elements = AstElements { return [0xDD, 0xCB, index(i.offset), 0x16]; } |
+
+    // RL (IY+d)
+    'rl' __ '\(' _ i=IY _ '\)' &eos
+    .elements = AstElements { return [0xFD, 0xCB, index(i.offset), 0x16]; } |
+
+    // RRC r
+    'rrc' __ r=r &eos
+    .elements = AstElements { return [0xCB, 0b00001000 | r_bits(r)]; } |
+
+    // RRC (HL)
+    'rrc' __ '\(' _ 'hl' _ '\)' &eos
+    .elements = AstElements { return [0xCB, 0x0E]; } |
+
+    // RRC (IX+d)
+    'rrc' __ '\(' _ i=IX _ '\)' &eos
+    .elements = AstElements { return [0xDD, 0xCB, index(i.offset), 0x0E]; } |
+
+    // RRC (IY+d)
+    'rrc' __ '\(' _ i=IY _ '\)' &eos
+    .elements = AstElements { return [0xFD, 0xCB, index(i.offset), 0x0E]; } |
+
+    // RR r
+    'rr' __ r=r &eos
+    .elements = AstElements { return [0xCB, 0b00011000 | r_bits(r)]; } |
+
+    // RR (HL)
+    'rr' __ '\(' _ 'hl' _ '\)' &eos
+    .elements = AstElements { return [0xCB, 0x1E]; } |
+
+    // RR (IX+d)
+    'rr' __ '\(' _ i=IX _ '\)' &eos
+    .elements = AstElements { return [0xDD, 0xCB, index(i.offset), 0x1E]; } |
+
+    // RR (IY+d)
+    'rr' __ '\(' _ i=IY _ '\)' &eos
+    .elements = AstElements { return [0xFD, 0xCB, index(i.offset), 0x1E]; } |
+
+    // SLA r
+    'sla' __ r=r &eos
+    .elements = AstElements { return [0xCB, 0b00100000 | r_bits(r)]; } |
+
+    // SLA (HL)
+    'sla' __ '\(' _ 'hl' _ '\)' &eos
+    .elements = AstElements { return [0xCB, 0x26]; } |
+
+    // SLA (IX+d)
+    'sla' __ '\(' _ i=IX _ '\)' &eos
+    .elements = AstElements { return [0xDD, 0xCB, index(i.offset), 0x26]; } |
+
+    // SLA (IY+d)
+    'sla' __ '\(' _ i=IY _ '\)' &eos
+    .elements = AstElements { return [0xFD, 0xCB, index(i.offset), 0x26]; } |
+
+    // SRA r
+    'sra' __ r=r &eos
+    .elements = AstElements { return [0xCB, 0b00101000 | r_bits(r)]; } |
+
+    // SRA (HL)
+    'sra' __ '\(' _ 'hl' _ '\)' &eos
+    .elements = AstElements { return [0xCB, 0x2E]; } |
+
+    // SRA (IX+d)
+    'sra' __ '\(' _ i=IX _ '\)' &eos
+    .elements = AstElements { return [0xDD, 0xCB, index(i.offset), 0x2E]; } |
+
+    // SRA (IY+d)
+    'sra' __ '\(' _ i=IY _ '\)' &eos
+    .elements = AstElements { return [0xFD, 0xCB, index(i.offset), 0x2E]; } |
+
+    // SRL r
+    'srl' __ r=r &eos
+    .elements = AstElements { return [0xCB, 0b00111000 | r_bits(r)]; } |
+
+    // SRL (HL)
+    'srl' __ '\(' _ 'hl' _ '\)' &eos
+    .elements = AstElements { return [0xCB, 0x3E]; } |
+
+    // SRL (IX+d)
+    'srl' __ '\(' _ i=IX _ '\)' &eos
+    .elements = AstElements { return [0xDD, 0xCB, index(i.offset), 0x3E]; } |
+
+    // SRL (IY+d)
+    'srl' __ '\(' _ i=IY _ '\)' &eos
+    .elements = AstElements { return [0xFD, 0xCB, index(i.offset), 0x3E]; } |
+
+    // RLD
+    'rld' &eos
+    .elements = AstElements { return [0xED, 0x6F]; } |
+
+    // RRD
+    'rrd' &eos
+    .elements = AstElements { return [0xED, 0x67]; }
+
+// Bit Manipulation
+BitManipulationInstruction :=
+    // BIT b, r
+    'bit' __ b=b _ ',' _ r=r &eos
+    .elements = AstElements { return [0xCB, 0b01000000 | (b.value << 3) | r_bits(r)]; } |
+
+    // BIT b, (HL)
+    'bit' __ b=b _ ',' _ '\(' _ 'hl' _ '\)' &eos
+    .elements = AstElements { return [0xCB, 0b01000110 | (b.value << 3)]; } |
+
+    // BIT b, (IX+d)
+    'bit' __ b=b _ ',' _ '\(' _ i=IX _ '\)' &eos
+    .elements = AstElements { return [0xDD, 0xCB, index(i.offset), 0b01000110 | (b.value << 3)]; } |
+
+    // BIT b, (IY+d)
+    'bit' __ b=b _ ',' _ '\(' _ i=IY _ '\)' &eos
+    .elements = AstElements { return [0xFD, 0xCB, index(i.offset), 0b01000110 | (b.value << 3)]; } |
+
+    // SET b, r
+    'set' __ b=b _ ',' _ r=r &eos
+    .elements = AstElements { return [0xCB, 0b11000000 | (b.value << 3) | r_bits(r)]; } |
+
+    // SET b, (HL)
+    'set' __ b=b _ ',' _ '\(' _ 'hl' _ '\)' &eos
+    .elements = AstElements { return [0xCB, 0b11000110 | (b.value << 3)]; } |
+
+    // SET b, (IX+d)
+    'set' __ b=b _ ',' _ '\(' _ i=IX _ '\)' &eos
+    .elements = AstElements { return [0xDD, 0xCB, index(i.offset), 0b11000110 | (b.value << 3)]; } |
+
+    // SET b, (IY+d)
+    'set' __ b=b _ ',' _ '\(' _ i=IY _ '\)' &eos
+    .elements = AstElements { return [0xFD, 0xCB, index(i.offset), 0b11000110 | (b.value << 3)]; } |
+
+    // RES b, r
+    'res' __ b=b _ ',' _ r=r &eos
+    .elements = AstElements { return [0xCB, 0b10000000 | (b.value << 3) | r_bits(r)]; } |
+
+    // RES b, (HL)
+    'res' __ b=b _ ',' _ '\(' _ 'hl' _ '\)' &eos
+    .elements = AstElements { return [0xCB, 0b10000110 | (b.value << 3)]; } |
+
+    // RES b, (IX+d)
+    'res' __ b=b _ ',' _ '\(' _ i=IX _ '\)' &eos
+    .elements = AstElements { return [0xDD, 0xCB, index(i.offset), 0b10000110 | (b.value << 3)]; } |
+
+    // RES b, (IY+d)
+    'res' __ b=b _ ',' _ '\(' _ i=IY _ '\)' &eos
+    .elements = AstElements { return [0xFD, 0xCB, index(i.offset), 0b10000110 | (b.value << 3)]; }
+
+Offset :=
+    pos=@ label=Label
+    .eval = EvalFunc { return labelValue(pos, label.name); } |
+
+    e=Expression
+    .eval = EvalFunc { return e.eval; }
+
+// Jumps
+JumpInstruction :=
+    // JP (HL)
+    'jp' __ '\(' _ 'hl' _ '\)' &eos
+    .elements = AstElements { return [0xE9]; } |
+
+    // JP (IX)
+    'jp' __ '\(' _ 'ix' _ '\)' &eos
+    .elements = AstElements { return [0xDD, 0xE9]; } |
+
+    // JP (IY)
+    'jp' __ '\(' _ 'iy' _ '\)' &eos
+    .elements = AstElements { return [0xFD, 0xE9]; } |
+
+    // JP nn
+    'jp' __ pos=@ ee=Expression &eos
+    .elements = AstElements { return [0xC3, value16LE(pos, ee)]; } |
+
+    // JP CC, nn
+    'jp' __ cc=cc _ ',' _ pos=@ ee=Expression &eos
+    .elements = AstElements { return [0b11000010 | cc_bits(cc, 3), value16LE(pos, ee)]; } |
+
+    // JR label
+    'jr' __ pos=@ label=Label &eos
+    .elements = AstElements { return [jj_bits(), jrRelativeOffset(pos, label.name)]; } |
+
+    // JR e
+    'jr' __ pos=@ e=Expression &eos
+    .elements = AstElements { return [jj_bits(), jrOffset(pos, e)]; } |
+
+    // JR jj, label
+    'jr' __ jj=jj _ ',' _ pos=@ label=Label &eos
+    .elements = AstElements { return [jj_bits(jj), jrRelativeOffset(pos, label.name)]; } |
+
+    // JR jj, e
+    'jr' __ jj=jj _ ',' _ pos=@ e=Expression &eos
+    .elements = AstElements { return [jj_bits(jj), jrOffset(pos, e)]; } |
+
+    // DJNZ label
+    'djnz' __ pos=@ label=Label &eos
+    .elements = AstElements { return [0x10, jrRelativeOffset(pos, label.name)]; } |
+
+    // DJNZ e
+    'djnz' __ pos=@ e=Expression &eos
+    .elements = AstElements { return [0x10, jrOffset(pos, e)]; }
+
+// Calls
+CallInstruction :=
+    // CALL nn
+    'call' __ pos=@ ee=Expression &eos
+    .elements = AstElements { return [0xCD, value16LE(pos, ee)]; } |
+
+    // CALL cc, nn
+    'call' __ cc=cc _ ',' _ pos=@ ee=Expression &eos
+    .elements = AstElements { return [0b11000100 | cc_bits(cc, 3), value16LE(pos, ee)]; }
+
+// Returns
+ReturnInstruction :=
+    // RET
+    'ret' &eos
+    .elements = AstElements { return [0xC9]; } |
+
+    // RET cc
+    'ret' __ cc=cc &eos
+    .elements = AstElements { return [0b11000000 | cc_bits(cc, 3)]; } |
+
+    // RETI
+    'reti' &eos
+    .elements = AstElements { return [0xED, 0x4D]; } |
+
+    // RETN
+    'retn' &eos
+    .elements = AstElements { return [0xED, 0x45]; } |
+
+    // RST p
+    'rst' __ p=p &eos
+    .elements = AstElements { return [0b11000111 | p_bits(p.value, 3)]; }
+
+// Inputs
+InputInstruction :=
+    // Have to be before IN A, (n)
+    // IN r, (C)
+    'in' __ r=r _ ',' _ '\(' 'c' '\)' &eos
+    .elements = AstElements { return [0xED, 0b01000000 | r_bits(r, 3)]; } |
+
+    // IN A, (n)
+    'in' __ 'a' _ ',' _ '\(' _ pos=@ n=Expression _ '\)' &eos
+    .elements = AstElements { return [0xDB, value8(pos, n)]; } |
+
+    // INI
+    'ini' &eos
+    .elements = AstElements { return [0xED, 0xA2]; } |
+
+    // INIR
+    'inir' &eos
+    .elements = AstElements { return [0xED, 0xB2]; } |
+
+    // IND
+    'ind' &eos
+    .elements = AstElements { return [0xED, 0xAA]; } |
+
+    // INDR
+    'indr' &eos
+    .elements = AstElements { return [0xED, 0xBA]; }
+
+// Outputs
+OutputInstruction :=
+    // Have to be before OUT (n), A
+    // OUT (C), r
+    'out' __ '\(' 'c' '\)' _ ',' _ r=r &eos
+    .elements = AstElements { return [0xED, 0b01000001 | r_bits(r, 3)]; } |
+
+    // OUT (n), A
+    'out' __ '\(' _ pos=@ n=Expression _ '\)' _ ',' _ 'a' &eos
+    .elements = AstElements { return [0xD3, value8(pos, n)]; } |
+
+    // OUTI
+    'outi' &eos
+    .elements = AstElements { return [0xED, 0xA3]; } |
+
+    // OTIR
+    'otir' &eos
+    .elements = AstElements { return [0xED, 0xB3]; } |
+
+    // OUTD
+    'outd' &eos
+    .elements = AstElements { return [0xED, 0xAB]; } |
+
+    // OTDR
+    'otdr' &eos
+    .elements = AstElements { return [0xED, 0xBB]; }
+
+// Byte directive
+ByteDirective :=
+    'db' | 'dm' | '\.?byte' | 'defb' | 'defm'
+
+// Word directive
+WordDirective :=
+    'dw' | '\.?word' | 'defw'
+
+// Block directive
+BlockDirective :=
+    '\.?block' | 'defs' | 'ds'
+
+// A Byte directive contains either characters, strings, or expressions
+ByteValue :=
+    s=QuottedStr        .elements = AstElements { return s.elements; } |
+    s=DoubleQuottedStr  .elements = AstElements { return s.elements; } |
+    pos=@ e=Expression  .elements = AstElements { return [value8(pos, e)]; }
+
+// A Word directive contains expressions
+WordValue :=
+    pos=@ e=Expression  .elements = AstElements { return [value16LE(pos, e)]; }
+
+// A Data directive is either a Byte directive, a Word directive or a Block directive
+DataDirective :=
+    // byte $FF, ...
+    ByteDirective __ pos0=@ data0=ByteValue data={_ ',' _ inner=ByteValue}* &eos
+    .elements = AstElements { return dataBytes(pos0, data0, data); } |
+
+    // word $FFFF, ...
+    WordDirective __ pos0=@ data0=WordValue data={_ ',' _ inner=WordValue}* &eos
+    .elements = AstElements { return dataWords(pos0, data0, data); } |
+
+    // block length, fill byte
+    BlockDirective __ @pos0=@ nn=Expression data={_ ',' _ pos1=@ b=Expression}? &eos
+    .elements = AstElements { return [dataBlock(pos0, nn, data?.pos1, data?.b)]; }
+
+// An escape sequence is either simple, in octal or in hexadecimal
+EscapeSequence :=
+    SimpleEscapeSequence |
+    OctalEscapeSequence |
+    HexadecimalEscapeSequence
+
+// A simple escape is a backslash followed by a character
+SimpleEscapeSequence :=
+    pos=@ '\\' raw={'"' | 'n'}
+    .elements = AstElements { return parseSimpleEscape(pos, raw); }
+
+// An octal escape is a backslash followed by an octal value
+OctalEscapeSequence :=
+    '\\' pos=@ raw='[0-7]{1,3}'
+    .elements = AstElements { return parseOctalEscape(pos, raw); }
+
+// An hexadecimal escape is a backslash followed by an 'x' and an hexadecimal value
+HexadecimalEscapeSequence :=
+    '\\x' pos=@ raw='[0-9a-f]{1,2}'
+    .elements = AstElements { return parseHexadecimalEscape(pos, raw); }
+
+// A character that is not a quote, a backslash or a newline
+NoQuoteChar :=
+    pos=@ raw='[^\'\\\n]'
+    .elements = AstElements { return parseZX81Char(pos, raw); }
+
+// A character is not a double-quote, a backslash or a newline
+NoDoubleQuoteChar :=
+    pos=@ raw='[^\"\\\n]'
+    .elements = AstElements { return parseZX81Char(pos, raw); }
+
+// A string literal enclosed in double-quotes and containing either simple characters or escape sequences
+QuottedStr :=
+    '\'' pos=@ chars={NoQuoteChar | EscapeSequence}+ '\''
+    .elements = AstElements { return chars.reduce((r, c) => { return r.concat(c.elements); }, [] as AstElements); }
+
+// A string literal is enclosed in double-quotes and contains either simple characters or escape sequences
+DoubleQuottedStr :=
+    '\"' pos=@ chars={NoDoubleQuoteChar | EscapeSequence}+ '\"'
+    .elements = AstElements { return chars.reduce((r, c) => { return r.concat(c.elements); }, [] as AstElements); }
+
+
+// A comment starts with '//' or ';' and goes until the end of the statement
+Comment :=
+    '(//|;)[^\r\n]*'
+
+// An Origin directive is 'org' (or an alias) followed by a 16-bit value and the end of the statement
+OriginDirective :=
+    '\.?org' __ address=nn
+
+// A filename is optionally enclosed in double-quotes and contains a subset of characters.
+Filename :=
+    '"' raw='[^"\\:\*\?<>\|%#\$,]+' '"' |
+    raw='[^ \t\r\n"\\:\*\?<>\|%#\$,]+'
+
+// An Include directive starts with 'include' (or an alias) and is followed by a Filename
+IncludeDirective :=
+    pos=@ '\.?include' __ name=Filename &eos
+    .info = LinesInfo { return includeFile(pos, name.raw); }
+
+// An Output directive starts with 'output' (or an alias) and is followed by a Filename.
+// Optionally, it is followed by a comma, 'sld' and an filename
+OutputDirective :=
+    '\.?output' __ name=Filename sld={_ ',' _ 'sld' __ name=Filename}? &eos
+    .void = void { setOutputName(name.raw, sld?.name.raw); }
+
+// A Device directive starts with 'device' (or an alias) and is followed by a name (the target)
+DeviceDirective :=
+    '\.?device' __ raw='[a-zA-Z][0-9a-zA-Z]*' &eos
+    .void = void { setDevice(raw); }
+
+// A End directive will stop the parsing by eating all the characters
+EndDirective :=
+  '\.?end' &eos '.*'