# Grammar for ABCD

# new tokens
$QUESTION '?'
$ELLIPSIS '...'

file_input: abcd_main ENDMARKER

abcd_main: (NEWLINE | abcd_global)* abcd_expr abcd_prop*
abcd_global: import_stmt | abcd_symbol | abcd_typedef | abcd_const | abcd_decl
abcd_spec: (NEWLINE | abcd_decl)* abcd_expr
abcd_decl: abcd_net | abcd_task | abcd_buffer

abcd_const: 'const' NAME '=' testlist
abcd_symbol: 'symbol' abcd_namelist
abcd_typedef: 'typedef' NAME ':' abcd_type
abcd_net: 'net' NAME parameters ':' abcd_suite
abcd_task: 'task' NAME typelist '-' '>' typelist ':' abcd_suite
abcd_suite: abcd_expr | NEWLINE INDENT abcd_spec DEDENT
abcd_buffer: [ decorators ] 'buffer' NAME ['[' test ']'] ':' abcd_type '=' testlist

abcd_namelist: NAME (',' NAME)*
typelist: '(' [abcd_type (',' abcd_type)*] ')'

abcd_type: abcd_and_type ('|' abcd_and_type)*
abcd_and_type: abcd_cross_type ('&' abcd_cross_type)*
abcd_cross_type: abcd_base_type ('*' abcd_base_type)*
abcd_base_type: (NAME ['(' abcd_type (',' abcd_type)* ')']
                 | 'enum' '(' test (',' test)* ')' | '(' abcd_type ')')

abcd_expr: abcd_choice_expr ('|' abcd_choice_expr)*
abcd_choice_expr: abcd_iter_expr ('+' abcd_iter_expr)*
abcd_iter_expr: abcd_seq_expr ('*' abcd_seq_expr)*
abcd_seq_expr: abcd_base_expr (';' abcd_base_expr)*
abcd_base_expr: (abcd_action | '(' abcd_expr ')') (NEWLINE)*
abcd_action: ('[' 'True' ']' |
              '[' 'False' ']' |
              '[' abcd_access_list ['if' test] ']' |
              abcd_instance)
abcd_access_list: abcd_access (',' abcd_access)*
abcd_access: (NAME '+' '(' testlist ')' |
              NAME '?' '(' testlist ')' |
              NAME '-' '(' testlist ')' |
              NAME '<>' '(' testlist '=' testlist ')' |
              NAME '>>' '(' NAME ')' |
              NAME '<<' '(' testlist_comp ')' |
              NAME '.' NAME '(' test (',' test)* ')')
abcd_instance: [NAME ':' ':'] NAME '(' [arglist] ')'

tfpdef: NAME [':' ('net' | 'buffer' | 'task')]

abcd_prop: 'assert' test (NEWLINE)*

#
# the rest is from SNAKES/Python grammar
#

decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE
decorators: decorator+
decorated: decorators (classdef | funcdef)
funcdef: 'def' NAME parameters ['-' '>' test] ':' suite
parameters: '(' [typedargslist] ')'
typedargslist: ((tfpdef ['=' test] ',')*
                ('*' [tfpdef] (',' tfpdef ['=' test])* [',' '**' tfpdef]
                 | '**' tfpdef)
                | tfpdef ['=' test] (',' tfpdef ['=' test])* [','])
varargslist: ((vfpdef ['=' test] ',')*
              ('*' [vfpdef] (',' vfpdef ['=' test])*  [',' '**' vfpdef]
               | '**' vfpdef)
              | vfpdef ['=' test] (',' vfpdef ['=' test])* [','])
vfpdef: NAME

stmt: simple_stmt | compound_stmt
simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE
small_stmt: (expr_stmt | del_stmt | pass_stmt | flow_stmt |
             import_stmt | global_stmt | nonlocal_stmt | assert_stmt)
expr_stmt: testlist (augassign (yield_expr|testlist) |
                     ('=' (yield_expr|testlist))*)
augassign: ('+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^=' |
            '<<=' | '>>=' | '**=' | '//=')
del_stmt: 'del' exprlist
pass_stmt: 'pass'
flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt
break_stmt: 'break'
continue_stmt: 'continue'
return_stmt: 'return' [testlist]
yield_stmt: yield_expr
raise_stmt: 'raise' [test ['from' test]]
import_stmt: import_name | import_from
import_name: 'import' dotted_as_names
import_from: ('from' (('.' | '...')* dotted_name | ('.' | '...')+)
              'import' ('*' | '(' import_as_names ')' | import_as_names))
import_as_name: NAME ['as' NAME]
dotted_as_name: dotted_name ['as' NAME]
import_as_names: import_as_name (',' import_as_name)* [',']
dotted_as_names: dotted_as_name (',' dotted_as_name)*
dotted_name: NAME ('.' NAME)*
global_stmt: 'global' NAME (',' NAME)*
nonlocal_stmt: 'nonlocal' NAME (',' NAME)*
assert_stmt: 'assert' test [',' test]

compound_stmt: (if_stmt | while_stmt | for_stmt | try_stmt | with_stmt
                | funcdef | classdef | decorated)
if_stmt: 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite]
while_stmt: 'while' test ':' suite ['else' ':' suite]
for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]
try_stmt: ('try' ':' suite
           ((except_clause ':' suite)+
	    ['else' ':' suite]
	    ['finally' ':' suite] |
	   'finally' ':' suite))
with_stmt: 'with' test [ with_var ] ':' suite
with_var: 'as' expr
except_clause: 'except' [test ['as' NAME]]
suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT

test: or_test ['if' or_test 'else' test] | lambdef
test_nocond: or_test | lambdef_nocond
lambdef: 'lambda' [varargslist] ':' test
lambdef_nocond: 'lambda' [varargslist] ':' test_nocond
or_test: and_test ('or' and_test)*
and_test: not_test ('and' not_test)*
not_test: 'not' not_test | comparison
comparison: star_expr (comp_op star_expr)*
comp_op: '<'|'>'|'=='|'>='|'<='|'!='|'<>'|'in'|'not' 'in'|'is'|'is' 'not'
star_expr: ['*'] expr
expr: xor_expr ('|' xor_expr)*
xor_expr: and_expr ('^' and_expr)*
and_expr: shift_expr ('&' shift_expr)*
shift_expr: arith_expr (('<<'|'>>') arith_expr)*
arith_expr: term (('+'|'-') term)*
term: factor (('*'|'/'|'%'|'//') factor)*
factor: ('+'|'-'|'~') factor | power
power: atom trailer* ['**' factor]
atom: ('(' [yield_expr|testlist_comp] ')' |
       '[' [testlist_comp] ']' |
       '{' [dictorsetmaker] '}' |
       NAME | NUMBER | STRING+ | '...' | 'None' | 'True' | 'False')
testlist_comp: test ( comp_for | (',' test)* [','] )
trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME
subscriptlist: subscript (',' subscript)* [',']
subscript: test | [test] ':' [test] [sliceop]
sliceop: ':' [test]
exprlist: star_expr (',' star_expr)* [',']
testlist: test (',' test)* [',']
dictorsetmaker: ( (test ':' test (comp_for | (',' test ':' test)* [','])) |
                  (test (comp_for | (',' test)* [','])) )

classdef: 'class' NAME ['(' [arglist] ')'] ':' suite

arglist: (argument ',')* (argument [',']
                         |'*' test (',' argument)* [',' '**' test]
                         |'**' test)
argument: test [comp_for] | test '=' test

comp_iter: comp_for | comp_if
comp_for: 'for' exprlist 'in' or_test [comp_iter]
comp_if: 'if' test_nocond [comp_iter]

yield_expr: 'yield' [testlist]