1 # Copyright (c) 2009 The Hewlett-Packard Development Company
4 # Redistribution and use in source and binary forms, with or without
5 # modification, are permitted provided that the following conditions are
6 # met: redistributions of source code must retain the above copyright
7 # notice, this list of conditions and the following disclaimer;
8 # redistributions in binary form must reproduce the above copyright
9 # notice, this list of conditions and the following disclaimer in the
10 # documentation and/or other materials provided with the distribution;
11 # neither the name of the copyright holders nor the names of its
12 # contributors may be used to endorse or promote products derived from
13 # this software without specific prior written permission.
15 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
18 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
19 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
21 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 # Authors: Nathan Binkert
33 from m5
.util
import code_formatter
34 from m5
.util
.grammar
import Grammar
, TokenError
, ParseError
36 import slicc
.ast
as ast
37 import slicc
.util
as util
38 from slicc
.symbols
import SymbolTable
40 def read_slicc(sources
):
41 if not isinstance(sources
, (list,tuple)):
44 for source
in sources
:
45 for sm_file
in file(source
, "r"):
46 sm_file
= sm_file
.strip()
49 if sm_file
.startswith("#"):
54 def __init__(self
, protocol
, **kwargs
):
55 super(SLICC
, self
).__init
__(**kwargs
)
56 self
.decl_list_vec
= []
57 self
.current_file
= None
58 self
.protocol
= protocol
59 self
.symtab
= SymbolTable(self
)
61 def codeFormatter(self
, *args
, **kwargs
):
62 code
= code_formatter(*args
, **kwargs
)
63 code
['protocol'] = self
.protocol
66 def parse(self
, filename
):
67 self
.current_file
= filename
68 f
= file(filename
, 'r')
71 decl_list
= super(SLICC
, self
).parse(text
)
72 except (TokenError
, ParseError
), e
:
73 sys
.exit("%s: %s:%d" % (e
, filename
, e
.token
.lineno
))
74 self
.decl_list_vec
.append(decl_list
)
75 self
.current_file
= None
77 def _load(self
, *filenames
):
78 filenames
= list(filenames
)
81 if isinstance(f
, (list, tuple)):
82 filenames
[0:0] = list(f
)
86 if f
.endswith(".slicc"):
87 dirname
,basename
= os
.path
.split(f
)
88 filenames
[0:0] = [ os
.path
.join(dirname
, x
) \
89 for x
in read_slicc(f
)]
91 assert f
.endswith(".sm")
94 def load(self
, *filenames
, **kwargs
):
95 verbose
= kwargs
.pop("verbose", False)
99 gen
= self
._load
(*filenames
)
103 # Run out the generator if we don't want the verbosity
107 def findMachines(self
):
108 for decl_list
in self
.decl_list_vec
:
109 decl_list
.findMachines()
112 for decl_list
in self
.decl_list_vec
:
115 def writeCodeFiles(self
, code_path
):
116 util
.makeDir(code_path
)
117 self
.symtab
.writeCodeFiles(code_path
)
119 def writeHTMLFiles(self
, code_path
):
120 util
.makeDir(code_path
)
121 self
.symtab
.writeHTMLFiles(code_path
)
129 for decl_list
in self
.decl_list_vec
:
130 f |
= decl_list
.files()
136 # C or C++ comment (ignore)
137 def t_c_comment(self
, t
):
139 t
.lexer
.lineno
+= t
.value
.count('\n')
141 def t_cpp_comment(self
, t
):
144 # Define a rule so we can track line numbers
145 def t_newline(self
, t
):
147 t
.lexer
.lineno
+= len(t
.value
)
151 'machine' : 'MACHINE',
152 'in_port' : 'IN_PORT',
153 'out_port' : 'OUT_PORT',
155 'transition' : 'TRANS',
156 'structure' : 'STRUCT',
157 'external_type' : 'EXTERN_TYPE',
158 'enumeration' : 'ENUM',
159 'state_declaration' : 'STATE_DECL',
161 'stall_and_wait' : 'STALL_AND_WAIT',
162 'wake_up_dependents' : 'WAKE_UP_DEPENDENTS',
163 'wake_up_all_dependents' : 'WAKE_UP_ALL_DEPENDENTS',
164 'enqueue' : 'ENQUEUE',
165 'copy_head' : 'COPY_HEAD',
166 'check_allocate' : 'CHECK_ALLOCATE',
167 'check_stop_slots' : 'CHECK_STOP_SLOTS',
168 'static_cast' : 'STATIC_CAST',
170 'is_valid' : 'IS_VALID',
171 'is_invalid' : 'IS_INVALID',
181 literals
= ':[]{}(),='
183 tokens
= [ 'EQ', 'NE', 'LT', 'GT', 'LE', 'GE',
184 'LEFTSHIFT', 'RIGHTSHIFT',
186 'PLUS', 'DASH', 'STAR', 'SLASH',
187 'DOUBLE_COLON', 'SEMI',
189 'IDENT', 'LIT_BOOL', 'FLOATNUMBER', 'NUMBER', 'STRING' ]
190 tokens
+= reserved
.values()
207 t_DOUBLE_COLON
= r
'::'
213 ('left', 'AND', 'OR'),
214 ('left', 'EQ', 'NE'),
215 ('left', 'LT', 'GT', 'LE', 'GE'),
216 ('left', 'RIGHTSHIFT', 'LEFTSHIFT'),
217 ('left', 'PLUS', 'DASH'),
218 ('left', 'STAR', 'SLASH'),
219 ('right', 'NOT', 'UMINUS'),
222 def t_IDENT(self
, t
):
223 r
'[a-zA-Z_][a-zA-Z_0-9]*'
224 if t
.value
== 'true':
229 if t
.value
== 'false':
234 # Check for reserved words
235 t
.type = self
.reserved
.get(t
.value
, 'IDENT')
238 def t_FLOATNUMBER(self
, t
):
241 t
.value
= float(t
.value
)
243 raise TokenError("Illegal float", t
)
246 def t_NUMBER(self
, t
):
249 t
.value
= int(t
.value
)
251 raise TokenError("Illegal number", t
)
254 def t_STRING1(self
, t
):
257 t
.value
= t
.value
[1:-1]
260 def t_STRING2(self
, t
):
263 t
.value
= t
.value
[1:-1]
270 def p_empty(self
, p
):
273 def p_decls(self
, p
):
275 p
[0] = ast
.DeclListAST(self
, p
[1])
277 def p_declsx__list(self
, p
):
278 "declsx : decl declsx"
279 p
[0] = [ p
[1] ] + p
[2]
281 def p_declsx__none(self
, p
):
285 def p_decl__machine(self
, p
):
286 "decl : MACHINE '(' ident pairs ')' ':' params '{' decls '}'"
287 p
[0] = ast
.MachineAST(self
, p
[3], p
[4], p
[7], p
[9])
289 def p_decl__action(self
, p
):
290 "decl : ACTION '(' ident pairs ')' statements"
291 p
[0] = ast
.ActionDeclAST(self
, p
[3], p
[4], p
[6])
293 def p_decl__in_port(self
, p
):
294 "decl : IN_PORT '(' ident ',' type ',' var pairs ')' statements"
295 p
[0] = ast
.InPortDeclAST(self
, p
[3], p
[5], p
[7], p
[8], p
[10])
297 def p_decl__out_port(self
, p
):
298 "decl : OUT_PORT '(' ident ',' type ',' var pairs ')' SEMI"
299 p
[0] = ast
.OutPortDeclAST(self
, p
[3], p
[5], p
[7], p
[8])
301 def p_decl__trans0(self
, p
):
302 "decl : TRANS '(' idents ',' idents ',' ident pairs ')' idents"
303 p
[0] = ast
.TransitionDeclAST(self
, p
[3], p
[5], p
[7], p
[8], p
[10])
305 def p_decl__trans1(self
, p
):
306 "decl : TRANS '(' idents ',' idents pairs ')' idents"
307 p
[0] = ast
.TransitionDeclAST(self
, p
[3], p
[5], None, p
[6], p
[8])
309 def p_decl__extern0(self
, p
):
310 "decl : EXTERN_TYPE '(' type pairs ')' SEMI"
311 p
[4]["external"] = "yes"
312 p
[0] = ast
.TypeDeclAST(self
, p
[3], p
[4], [])
314 def p_decl__extern1(self
, p
):
315 "decl : EXTERN_TYPE '(' type pairs ')' '{' type_methods '}'"
316 p
[4]["external"] = "yes"
317 p
[0] = ast
.TypeDeclAST(self
, p
[3], p
[4], p
[7])
319 def p_decl__global(self
, p
):
320 "decl : GLOBAL '(' type pairs ')' '{' type_members '}'"
321 p
[4]["global"] = "yes"
322 p
[0] = ast
.TypeDeclAST(self
, p
[3], p
[4], p
[7])
324 def p_decl__struct(self
, p
):
325 "decl : STRUCT '(' type pairs ')' '{' type_members '}'"
326 p
[0] = ast
.TypeDeclAST(self
, p
[3], p
[4], p
[7])
328 def p_decl__enum(self
, p
):
329 "decl : ENUM '(' type pairs ')' '{' type_enums '}'"
330 p
[4]["enumeration"] = "yes"
331 p
[0] = ast
.EnumDeclAST(self
, p
[3], p
[4], p
[7])
333 def p_decl__state_decl(self
, p
):
334 "decl : STATE_DECL '(' type pairs ')' '{' type_states '}'"
335 p
[4]["enumeration"] = "yes"
336 p
[4]["state_decl"] = "yes"
337 p
[0] = ast
.StateDeclAST(self
, p
[3], p
[4], p
[7])
339 def p_decl__object(self
, p
):
340 "decl : type ident pairs SEMI"
341 p
[0] = ast
.ObjDeclAST(self
, p
[1], p
[2], p
[3])
343 def p_decl__func_decl(self
, p
):
344 """decl : void ident '(' params ')' pairs SEMI
345 | type ident '(' params ')' pairs SEMI"""
346 p
[0] = ast
.FuncDeclAST(self
, p
[1], p
[2], p
[4], p
[6], None)
348 def p_decl__func_def(self
, p
):
349 """decl : void ident '(' params ')' pairs statements
350 | type ident '(' params ')' pairs statements"""
351 p
[0] = ast
.FuncDeclAST(self
, p
[1], p
[2], p
[4], p
[6], p
[7])
354 def p_type_members__list(self
, p
):
355 "type_members : type_member type_members"
356 p
[0] = [ p
[1] ] + p
[2]
358 def p_type_members__empty(self
, p
):
359 "type_members : empty"
362 def p_type_member__1(self
, p
):
363 "type_member : type ident pairs SEMI"
364 p
[0] = ast
.TypeFieldMemberAST(self
, p
[1], p
[2], p
[3], None)
366 def p_type_member__2(self
, p
):
367 "type_member : type ident ASSIGN expr SEMI"
368 p
[0] = ast
.TypeFieldMemberAST(self
, p
[1], p
[2],
369 ast
.PairListAST(self
), p
[4])
372 def p_type_methods__list(self
, p
):
373 "type_methods : type_method type_methods"
374 p
[0] = [ p
[1] ] + p
[2]
376 def p_type_methods(self
, p
):
377 "type_methods : empty"
380 def p_type_method(self
, p
):
381 "type_method : type_or_void ident '(' types ')' pairs SEMI"
382 p
[0] = ast
.TypeFieldMethodAST(self
, p
[1], p
[2], p
[4], p
[6])
385 def p_type_enums__list(self
, p
):
386 "type_enums : type_enum type_enums"
387 p
[0] = [ p
[1] ] + p
[2]
389 def p_type_enums__empty(self
, p
):
393 def p_type_enum(self
, p
):
394 "type_enum : ident pairs SEMI"
395 p
[0] = ast
.TypeFieldEnumAST(self
, p
[1], p
[2])
398 def p_type_states__list(self
, p
):
399 "type_states : type_state type_states"
400 p
[0] = [ p
[1] ] + p
[2]
402 def p_type_states__empty(self
, p
):
403 "type_states : empty"
406 def p_type_state(self
, p
):
407 "type_state : ident ',' enumeration pairs SEMI"
408 p
[0] = ast
.TypeFieldStateAST(self
, p
[1], p
[3], p
[4])
411 def p_types__multiple(self
, p
):
412 "types : type ',' types"
413 p
[0] = [ p
[1] ] + p
[3]
415 def p_types__one(self
, p
):
419 def p_types__empty(self
, p
):
423 def p_typestr__multi(self
, p
):
424 "typestr : typestr DOUBLE_COLON ident"
425 p
[0] = '%s::%s' % (p
[1], p
[3])
427 def p_typestr__single(self
, p
):
431 def p_type__one(self
, p
):
433 p
[0] = ast
.TypeAST(self
, p
[1])
437 p
[0] = ast
.TypeAST(self
, p
[1])
439 def p_type_or_void(self
, p
):
440 """type_or_void : type
445 def p_params__many(self
, p
):
446 "params : param ',' params"
447 p
[0] = [ p
[1] ] + p
[3]
449 def p_params__one(self
, p
):
453 def p_params__none(self
, p
):
457 def p_param(self
, p
):
459 p
[0] = ast
.FormalParamAST(self
, p
[1], p
[2])
461 def p_param__pointer(self
, p
):
462 "param : type STAR ident"
463 p
[0] = ast
.FormalParamAST(self
, p
[1], p
[3], None, True)
465 def p_param__pointer_default(self
, p
):
466 "param : type STAR ident '=' STRING"
467 p
[0] = ast
.FormalParamAST(self
, p
[1], p
[3], p
[5], True)
469 def p_param__default_number(self
, p
):
470 "param : type ident '=' NUMBER"
471 p
[0] = ast
.FormalParamAST(self
, p
[1], p
[2], p
[4])
473 def p_param__default_bool(self
, p
):
474 "param : type ident '=' LIT_BOOL"
475 p
[0] = ast
.FormalParamAST(self
, p
[1], p
[2], p
[4])
477 def p_param__default_string(self
, p
):
478 "param : type ident '=' STRING"
479 p
[0] = ast
.FormalParamAST(self
, p
[1], p
[2], p
[4])
482 def p_idents__braced(self
, p
):
483 "idents : '{' identx '}'"
486 def p_idents__bare(self
, p
):
490 def p_identx__multiple_1(self
, p
):
491 """identx : ident SEMI identx
492 | ident ',' identx"""
493 p
[0] = [ p
[1] ] + p
[3]
495 def p_identx__multiple_2(self
, p
):
496 "identx : ident identx"
497 p
[0] = [ p
[1] ] + p
[2]
499 def p_identx__single(self
, p
):
503 def p_ident(self
, p
):
507 # Pair and pair lists
508 def p_pairs__list(self
, p
):
512 def p_pairs__empty(self
, p
):
514 p
[0] = ast
.PairListAST(self
)
516 def p_pairsx__many(self
, p
):
517 "pairsx : pair ',' pairsx"
521 def p_pairsx__one(self
, p
):
523 p
[0] = ast
.PairListAST(self
)
526 def p_pair__assign(self
, p
):
527 """pair : ident '=' STRING
529 | ident '=' NUMBER"""
530 p
[0] = ast
.PairAST(self
, p
[1], p
[3])
532 def p_pair__literal(self
, p
):
534 p
[0] = ast
.PairAST(self
, "short", p
[1])
536 # Below are the rules for action descriptions
537 def p_statements__inner(self
, p
):
538 "statements : '{' statements_inner '}'"
539 p
[0] = ast
.StatementListAST(self
, p
[2])
541 def p_statements__none(self
, p
):
542 "statements : '{' '}'"
543 p
[0] = ast
.StatementListAST(self
, [])
545 def p_statements_inner__many(self
, p
):
546 "statements_inner : statement statements_inner"
547 p
[0] = [ p
[1] ] + p
[2]
549 def p_statements_inner__one(self
, p
):
550 "statements_inner : statement"
553 def p_exprs__multiple(self
, p
):
554 "exprs : expr ',' exprs"
555 p
[0] = [ p
[1] ] + p
[3]
557 def p_exprs__one(self
, p
):
561 def p_exprs__empty(self
, p
):
565 def p_statement__expression(self, p):
566 "statement
: expr SEMI
"
567 p[0] = ast.ExprStatementAST(self, p[1])
569 def p_statement__assign(self, p):
570 "statement
: expr ASSIGN expr SEMI
"
571 p[0] = ast.AssignStatementAST(self, p[1], p[3])
573 def p_statement__enqueue(self, p):
574 "statement
: ENQUEUE
'(' var
',' type pairs
')' statements
"
575 p[0] = ast.EnqueueStatementAST(self, p[3], p[5], p[6], p[8])
577 def p_statement__stall_and_wait(self, p):
578 "statement
: STALL_AND_WAIT
'(' var
',' var
')' SEMI
"
579 p[0] = ast.StallAndWaitStatementAST(self, p[3], p[5])
581 def p_statement__wake_up_dependents(self, p):
582 "statement
: WAKE_UP_DEPENDENTS
'(' var
')' SEMI
"
583 p[0] = ast.WakeUpDependentsStatementAST(self, p[3])
585 def p_statement__wake_up_all_dependents(self, p):
586 "statement
: WAKE_UP_ALL_DEPENDENTS
'(' ')' SEMI
"
587 p[0] = ast.WakeUpAllDependentsStatementAST(self)
589 def p_statement__peek(self, p):
590 "statement
: PEEK
'(' var
',' type pairs
')' statements
"
591 p[0] = ast.PeekStatementAST(self, p[3], p[5], p[6], p[8], "peek
")
593 def p_statement__copy_head(self, p):
594 "statement
: COPY_HEAD
'(' var
',' var pairs
')' SEMI
"
595 p[0] = ast.CopyHeadStatementAST(self, p[3], p[5], p[6])
597 def p_statement__check_allocate(self, p):
598 "statement
: CHECK_ALLOCATE
'(' var
')' SEMI
"
599 p[0] = ast.CheckAllocateStatementAST(self, p[3])
601 def p_statement__check_stop(self, p):
602 "statement
: CHECK_STOP_SLOTS
'(' var
',' STRING
',' STRING
')' SEMI
"
603 p[0] = ast.CheckStopStatementAST(self, p[3], p[5], p[7])
605 def p_statement__static_cast(self, p):
606 "aexpr
: STATIC_CAST
'(' type ',' expr
')'"
607 p[0] = ast.StaticCastAST(self, p[3], "ref
", p[5])
609 def p_statement__static_cast_ptr(self, p):
610 "aexpr
: STATIC_CAST
'(' type ',' STRING
',' expr
')'"
611 p[0] = ast.StaticCastAST(self, p[3], p[5], p[7])
613 def p_statement__return(self, p):
614 "statement
: RETURN expr SEMI
"
615 p[0] = ast.ReturnStatementAST(self, p[2])
617 def p_statement__if(self, p):
618 "statement
: if_statement
"
621 def p_if_statement__if(self, p):
622 "if_statement
: IF
'(' expr
')' statements
"
623 p[0] = ast.IfStatementAST(self, p[3], p[5], None)
625 def p_if_statement__if_else(self, p):
626 "if_statement
: IF
'(' expr
')' statements ELSE statements
"
627 p[0] = ast.IfStatementAST(self, p[3], p[5], p[7])
629 def p_statement__if_else_if(self, p):
630 "if_statement
: IF
'(' expr
')' statements ELSE if_statement
"
631 p[0] = ast.IfStatementAST(self, p[3], p[5],
632 ast.StatementListAST(self, p[7]))
634 def p_expr__var(self, p):
638 def p_expr__localvar(self, p):
640 p[0] = ast.LocalVariableAST(self, p[1], p[2])
642 def p_expr__literal(self, p):
646 def p_expr__enumeration(self, p):
647 "aexpr
: enumeration
"
650 def p_expr__func_call(self, p):
651 "aexpr
: ident
'(' exprs
')'"
652 p[0] = ast.FuncCallExprAST(self, p[1], p[3])
654 def p_expr__new(self, p):
656 p[0] = ast.NewExprAST(self, p[2])
658 def p_expr__null(self, p):
660 p[0] = ast.OodAST(self)
662 # globally access a local chip component and call a method
663 def p_expr__local_chip_method(self, p):
664 "aexpr
: THIS DOT var
'[' expr
']' DOT var DOT ident
'(' exprs
')'"
665 p[0] = ast.LocalChipMethodAST(self, p[3], p[5], p[8], p[10], p[12])
667 # globally access a local chip component and access a data member
668 def p_expr__local_chip_member(self, p):
669 "aexpr
: THIS DOT var
'[' expr
']' DOT var DOT field
"
670 p[0] = ast.LocalChipMemberAST(self, p[3], p[5], p[8], p[10])
672 # globally access a specified chip component and call a method
673 def p_expr__specified_chip_method(self, p):
674 "aexpr
: CHIP
'[' expr
']' DOT var
'[' expr
']' DOT var DOT ident
'(' exprs
')'"
675 p[0] = ast.SpecifiedChipMethodAST(self, p[3], p[6], p[8], p[11], p[13],
678 # globally access a specified chip component and access a data member
679 def p_expr__specified_chip_member(self, p):
680 "aexpr
: CHIP
'[' expr
']' DOT var
'[' expr
']' DOT var DOT field
"
681 p[0] = ast.SpecifiedChipMemberAST(self, p[3], p[6], p[8], p[11], p[13])
683 def p_expr__member(self, p):
684 "aexpr
: aexpr DOT ident
"
685 p[0] = ast.MemberExprAST(self, p[1], p[3])
687 def p_expr__member_method_call(self, p):
688 "aexpr
: aexpr DOT ident
'(' exprs
')'"
689 p[0] = ast.MemberMethodCallExprAST(self, p[1], p[3], p[5])
691 def p_expr__member_method_call_lookup(self, p):
692 "aexpr
: aexpr
'[' exprs
']'"
693 p[0] = ast.MemberMethodCallExprAST(self, p[1], "lookup
", p[3])
695 def p_expr__class_method_call(self, p):
696 "aexpr
: type DOUBLE_COLON ident
'(' exprs
')'"
697 p[0] = ast.ClassMethodCallExprAST(self, p[1], p[3], p[5])
699 def p_expr__aexpr(self, p):
703 def p_expr__binary_op(self, p):
704 """expr : expr STAR expr
716 | expr RIGHTSHIFT expr
717 | expr LEFTSHIFT expr"""
718 p[0] = ast.InfixOperatorExprAST(self, p[1], p[2], p[3])
721 def p_expr__unary_op(self, p):
723 | DASH expr %prec UMINUS"""
724 p[0] = PrefixOperatorExpr(p[1], p[2])
726 def p_expr__parens(self, p):
727 "aexpr
: '(' expr
')'"
730 def p_expr__is_valid_ptr(self, p):
731 "aexpr
: IS_VALID
'(' var
')'"
732 p[0] = ast.IsValidPtrExprAST(self, p[3], True)
734 def p_expr__is_invalid_ptr(self, p):
735 "aexpr
: IS_INVALID
'(' var
')'"
736 p[0] = ast.IsValidPtrExprAST(self, p[3], False)
738 def p_literal__string(self, p):
740 p[0] = ast.LiteralExprAST(self, p[1], "std
::string
")
742 def p_literal__number(self, p):
744 p[0] = ast.LiteralExprAST(self, p[1], "int")
746 def p_literal__float(self, p):
747 "literal
: FLOATNUMBER
"
748 p[0] = ast.LiteralExprAST(self, p[1], "int")
750 def p_literal__bool(self, p):
752 p[0] = ast.LiteralExprAST(self, p[1], "bool")
754 def p_enumeration(self, p):
755 "enumeration
: ident
':' ident
"
756 p[0] = ast.EnumExprAST(self, ast.TypeAST(self, p[1]), p[3])
760 p[0] = ast.VarExprAST(self, p[1])
762 def p_field(self, p):