%%

# patterns

<void> Comment = '#.*';
<void> WhiteSpace = '[ \r\t\n]+';
<String> Prolog = '.*%%';
<String> Id = '[a-zA-Z_][-a-zA-Z_0-9.$]*';
<String> String = '\'([^\'\\\r\n]|\\.)*\'';
<String> Epilog = '%%*.';

# rules

<Parser> parser: Prolog rule+ Epilog;
<Node> rule: type? Id ( pattern | rhs ) ';';
<Type> type: '<' ( Id ( ':' Id+ / ',' )? '>' '?'? | '>' );
pattern: '=' String;
rhs: ':' xor;
<Node> xor: sequence+ / '|';
<Sequence> sequence: term+;
<Node> term: item ( optional | some | many )?;
<Node> item: Id | literal | '(' xor ')';
<Object> optional: '?';
<Object> some: '+' list?;
<Object> many: '*' list?;
<Literal> literal: String;
list: '/' item;

%%


package oops3;
public class EbnfParser {

%%

# patterns

<void> Comment = '#.*';
<void> WhiteSpace = '[ \r\t\n]+';
<String> Prolog = '.*%%';
<String> Id = '[a-zA-Z_][-a-zA-Z_0-9.$]*';
<String> String = '\'([^\'\\\r\n]|\\.)*\'';
<String> Epilog = '%%.*';

# rules

<Parser> parser: Prolog rule+ Epilog;
<Node> rule: type? Id ( pattern | rhs ) ';';
<Type> type: '<' ( Id ( ':' Id+ / ',' )? '>' '?'? | '>' );
pattern: '=' String;
rhs: ':' xor;
<Node> xor: sequence+ / '|';
<Sequence> sequence: ( item | someItems | optionalItem )+;
<Node> item: Id | literal | '(' xor ')';
<Repeat> someItems: '{' xor '}';
<Repeat> optionalItem: '[' xor ']';
<Literal> literal: String;

%%
}

package oops3;
public class XbnfParser {

%%

# patterns

<void> Comment = '#.*';
<void> WhiteSpace = '[ \r\t\n]+';
<String> Prolog = '.*%%';
<String> Id = '[a-zA-Z_][-a-zA-Z_0-9.$]*';
<String> String = '\'([^\'\\\r\n]|\\.)*\'';
<Integer> Number = '[1-9][0-9]*';
<String> Epilog = '%%.*';

# rules

<Parser> parser: Prolog rule+ Epilog;
<Node> rule: type? Id ( pattern | rhs ) ';';
<Type> type: '<' ( Id ( ':' Id+ / ',' )? '>' '?'? | '>' );
pattern: '=' String;
rhs: ':' xor;
<Node> xor: sequence+ / '|';
<Sequence> sequence: term+;
<Node> term: item range?;
<Literal> literal: String;
<Object> optional: '?';
list: '/' item;
<Object> some: '+' list?;
<Object> many: '*' list?;
<Node> item: Id | literal | '(' xor ')' | or | and;
range: range1 | range2 | optional | some | many;
<Node> or: '[' xors ',' xors+ / ',' ']' list?;
<Node> and: '{' xors ',' xors+ / ',' '}' list?;
<Sequence> xors: xor+;
<Object> range1: Number ( '..' Number? list? | list )?;
<Object> range2: '..' ( Number? list? )?;

%%
}

package oops3;
public class RfcParser {

%%

# patterns

<void> Comment = '#.*';
<void> WhiteSpace = '[ \r\t\n]+';
<String> Prolog = '.*%%';
<String> Id = '[a-zA-Z_][-a-zA-Z_0-9.$]*';
<String> String = '\'([^\'\\\r\n]|\\.)*\'';
<String> Epilog = '%%.*';

# rules

<Parser> parser: Prolog rule+ Epilog;
<Node> rule: type? Id ( pattern | rhs ) ';';
<Type> type: '<' ( Id ( ':' Id+ / ',' )? '>' '?'? | '>' );
pattern: '=' String;
rhs: ':' xor;
<Node> xor: sequence+ / '|';
<Sequence> sequence: term+;
<Node> term: item ( optional | some | many )?;
<Node> item: Id | literal | '(' xor ')';
<Object> optional: '?';
<Object> some: '+' list?;
<Object> many: '*' list?;
<Literal> literal: String;
list: '/' item;

%%
}

package oops3;
public class EbnfParser {

%%

# patterns

<void> Comment = '#.*';
<void> WhiteSpace = '[ \r\t\n]+';
<String> Prolog = '.*%%';
<String> Id = '[a-zA-Z_][-a-zA-Z_0-9.$]*';
<String> String = '\'([^\'\\\r\n]|\\.)*\'';
<String> Epilog = '%%.*';

# rules

<Parser> parser: Prolog rule+ Epilog;
<Node> rule: type? Id ( pattern | rhs ) ';';
<Type> type: '<' ( Id ( ':' Id ( ',' Id )* )? '>' '?'? | '>' );
pattern: '=' String;
rhs: ':' xor;
<Node> xor: sequence ( '|' sequence )*;
<Sequence> sequence: ( item | someItems | optionalItem )+;
<Node> item: Id | literal | '(' xor ')';
<Repeat> someItems: '{' xor '}';
<Repeat> optionalItem: '[' xor ']';
<Literal> literal: String;

%%
}

package oops3;
public class XbnfParser {

%%

# patterns

<void> Comment = '#.*';
<void> WhiteSpace = '[ \r\t\n]+';
<String> Prolog = '.*%%';
<String> Id = '[a-zA-Z_][-a-zA-Z_0-9.$]*';
<String> String = '\'([^\'\\\r\n]|\\.)*\'';
<Integer> Number = '[1-9][0-9]*';
<String> Epilog = '%%.*';

# rules

<Parser> parser: Prolog rule+ Epilog;
<Node> rule: type? Id ( pattern | rhs ) ';';
<Type> type: '<' ( Id ( ':' Id+ / ',' )? '>' '?'? | '>' );
pattern: '=' String;
rhs: ':' xor;
<Node> xor: sequence+ / '|';
<Sequence> sequence: term+;
<Node> term: item range?;
<Literal> literal: String;
<Object> optional: '?';
list: '/' item;
<Object> some: '+' list?;
<Object> many: '*' list?;
<Node> item: Id | literal | '(' xor ')' | or | and;
range: range1 | range2 | optional | some | many;
<Node> or: '[' xor 2.. / ',' ']' list?;
<Node> and: '{' xor 2.. / ',' '}' list?;
<Object> range1: Number ( '..' Number? list? | list )?;
<Object> range2: '..' ( Number? list? )?;

%%
}

package expr;
public class ExprParser {

%%

# patterns

<void> Comment = '#.*';
<void> WhiteSpace = '[ \r\t\n]+';
<Integer> Number = '[0-9]+';

# rules

<Sum> ? sum: product ( add | subtract )*;
<Product> ? product: term ( multiply | divide )*;
<Add> add: '+' product;
<Subtract> subtract: '-' product;
term: Number | '(' sum ')';
<Multiply> multiply: '*' term;
<Divide> divide: '/' term;

%%
}

package test;
public class Test {

%%

# patterns

<void> spaces = '[ \n\r\t]+';
<Integer> Number = '[0-9]+';

# rules

sequence: Number sequence*;

%%
}

package test;
public class Test {

%%

# patterns

<void> spaces = '[ \n\r\t]+';
<Integer> Number = '[0-9]+';

# rules

<Item> sequence: Number sequence*;

%%
}

package test;
public class Test {

%%

# patterns

<void> spaces = '[ \n\r\t]+';
<Integer> Number = '[0-9]+';

# rules

<Item> sequence: Number nest*;
<Nest> nest: sequence;

%%
}

package test;
import java.util.List;
public class Test {

%%

# patterns

<void> spaces = '[ \n\r\t]+';
<Integer> Number = '[0-9]+';

# rules

<Item> ? sequence: Number+;

%%
  public static class LeftTree extends Tree {
    // destructively represent list as left-associative Item tree
    @SuppressWarnings("unchecked")
    public Object sequence (int position, List list) {
      if (list.size() == 1) return list.get(0);
      Left left = new Left(position, list.subList(0, 2));
      for (int n = 2; n < list.size(); ++ n) {
        list.set(n-1, left);
        left = new Left(position, list.subList(n-1, n+1));
      }
      return left;
    }
    public class Left extends Item {
      protected Left (int position, List list) { super(position, list); }
    }
  }
}

package test;
public class Test {

%%

# patterns

<void> Comment = '#.*';
<Integer> Number = '[0-9]+';
<void> WhiteSpace = '[ \r\t\n]+';

# rules

program: test+;
test: n | nList | pairs | or | orList | and | andList;
<N> n: 'n' ( a | b | c ) 2..3;
<NList> nList: 'nList' ( a | b | c ) 2..3 / Number;
<Pairs> pairs: 'pairs' ( ( a | b | c | d ) 2 / ',' )+;
<Or> or: 'or' [ a | b | c | d ];
<OrList> orList: 'orList' [ a | b 1..2 | c 1..3 | d 2 / '.' ] / Number;
<And> and: 'and' { a | b | c | d };
<AndList> andList: 'andList' { a | b 1..2 | c 1..3 | d 2 / '.' } / Number;
<A> a: 'a';
<B> b: 'b';
<C> c: 'c';
<D> d: 'd';

%%
}


package test;
public class Test {

%%

# patterns

<void> spaces = '[ \n\r\t]+';
<Integer> Number = '[0-9]+';

# rules

sequence: Number sequence+;

%%
}

package test;
public class Test {

%%

# patterns

<void> spaces = '[ \n\r\t]+';
<Integer> Number = '[0-9]+';

# rules

statement: 'if' Number statement ( 'else' statement )? | Number;

%%
}