1 # cython: auto_cpdef=True, infer_types=True, language_level=3, py2_import=True
6 # This should be done automatically
8 cython.declare(Nodes=object, ExprNodes=object, EncodedString=object)
14 from Cython.Compiler.Scanning import PyrexScanner, FileSourceDescriptor
18 from StringEncoding import EncodedString, BytesLiteral, _unicode, _bytes
19 from ModuleNode import ModuleNode
20 from Errors import error, warning, InternalError
21 from Cython import Utils
28 visibility = 'private'
37 def __init__(self, **kwds):
38 self.__dict__.update(kwds)
40 def __call__(self, **kwds):
43 d.update(self.__dict__)
47 def p_ident(s, message = "Expected an identifier"):
57 while s.sy == 'IDENT':
58 names.append(s.systring)
65 #------------------------------------------
69 #------------------------------------------
71 def p_binop_operator(s):
77 def p_binop_expr(s, ops, p_sub_expr):
80 op, pos = p_binop_operator(s)
82 n1 = ExprNodes.binop_node(pos, op, n1, n2)
84 if Future.division in s.context.future_directives:
85 n1.truedivision = True
87 n1.truedivision = None # unknown
90 #lambdef: 'lambda' [varargslist] ':' test
92 def p_lambdef(s, allow_conditional=True):
98 star_arg = starstar_arg = None
100 args, star_arg, starstar_arg = p_varargslist(
101 s, terminator=':', annotated=False)
103 if allow_conditional:
106 expr = p_test_nocond(s)
107 return ExprNodes.LambdaNode(
109 star_arg = star_arg, starstar_arg = starstar_arg,
112 #lambdef_nocond: 'lambda' [varargslist] ':' test_nocond
114 def p_lambdef_nocond(s):
115 return p_lambdef(s, allow_conditional=False)
117 #test: or_test ['if' or_test 'else' test] | lambdef
129 return ExprNodes.CondExprNode(pos, test=test, true_val=expr, false_val=other)
133 #test_nocond: or_test | lambdef_nocond
135 def p_test_nocond(s):
137 return p_lambdef_nocond(s)
141 #or_test: and_test ('or' and_test)*
144 return p_rassoc_binop_expr(s, ('or',), p_and_test)
146 def p_rassoc_binop_expr(s, ops, p_subexpr):
152 n2 = p_rassoc_binop_expr(s, ops, p_subexpr)
153 n1 = ExprNodes.binop_node(pos, op, n1, n2)
156 #and_test: not_test ('and' not_test)*
159 #return p_binop_expr(s, ('and',), p_not_test)
160 return p_rassoc_binop_expr(s, ('and',), p_not_test)
162 #not_test: 'not' not_test | comparison
168 return ExprNodes.NotNode(pos, operand = p_not_test(s))
170 return p_comparison(s)
172 #comparison: expr (comp_op expr)*
173 #comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'|'is' 'not'
176 n1 = p_starred_expr(s)
177 if s.sy in comparison_ops:
180 n2 = p_starred_expr(s)
181 n1 = ExprNodes.PrimaryCmpNode(pos,
182 operator = op, operand1 = n1, operand2 = n2)
183 if s.sy in comparison_ops:
184 n1.cascade = p_cascaded_cmp(s)
187 def p_test_or_starred_expr(s):
189 return p_starred_expr(s)
193 def p_starred_expr(s):
202 expr = ExprNodes.StarredTargetNode(pos, expr)
205 def p_cascaded_cmp(s):
208 n2 = p_starred_expr(s)
209 result = ExprNodes.CascadedCmpNode(pos,
210 operator = op, operand2 = n2)
211 if s.sy in comparison_ops:
212 result.cascade = p_cascaded_cmp(s)
235 '<', '>', '==', '>=', '<=', '<>', '!=',
239 #expr: xor_expr ('|' xor_expr)*
242 return p_binop_expr(s, ('|',), p_xor_expr)
244 #xor_expr: and_expr ('^' and_expr)*
247 return p_binop_expr(s, ('^',), p_and_expr)
249 #and_expr: shift_expr ('&' shift_expr)*
252 return p_binop_expr(s, ('&',), p_shift_expr)
254 #shift_expr: arith_expr (('<<'|'>>') arith_expr)*
257 return p_binop_expr(s, ('<<', '>>'), p_arith_expr)
259 #arith_expr: term (('+'|'-') term)*
262 return p_binop_expr(s, ('+', '-'), p_term)
264 #term: factor (('*'|'/'|'%') factor)*
267 return p_binop_expr(s, ('*', '/', '%', '//'), p_factor)
269 #factor: ('+'|'-'|'~'|'&'|typecast|sizeof) factor | power
272 # little indirection for C-ification purposes
277 if sy in ('+', '-', '~'):
281 return ExprNodes.unop_node(pos, op, p_factor(s))
286 return ExprNodes.AmpersandNode(pos, operand = arg)
289 elif sy == 'IDENT' and s.systring == "sizeof":
298 base_type = p_c_base_type(s)
299 if base_type.name is None:
300 s.error("Unknown type")
301 declarator = p_c_declarator(s, empty = 1)
308 operand = p_factor(s)
309 return ExprNodes.TypecastNode(pos,
310 base_type = base_type,
311 declarator = declarator,
313 typecheck = typecheck)
316 # s.sy == ident "sizeof"
320 # Here we decide if we are looking at an expression or type
321 # If it is actually a type, but parsable as an expression,
322 # we treat it as an expression here.
323 if looking_at_expr(s):
325 node = ExprNodes.SizeofVarNode(pos, operand = operand)
327 base_type = p_c_base_type(s)
328 declarator = p_c_declarator(s, empty = 1)
329 node = ExprNodes.SizeofTypeNode(pos,
330 base_type = base_type, declarator = declarator)
334 def p_yield_expression(s):
338 if s.sy != ')' and s.sy not in statement_terminators:
342 return ExprNodes.YieldExprNode(pos, arg=arg)
344 def p_yield_statement(s):
346 yield_expr = p_yield_expression(s)
347 return Nodes.ExprStatNode(yield_expr.pos, expr=yield_expr)
349 #power: atom trailer* ('**' factor)*
352 if s.systring == 'new' and s.peek()[0] == 'IDENT':
355 while s.sy in ('(', '[', '.'):
356 n1 = p_trailer(s, n1)
361 n1 = ExprNodes.binop_node(pos, '**', n1, n2)
365 # s.systring == 'new'.
368 cppclass = p_c_base_type(s)
369 return p_call(s, ExprNodes.NewExprNode(pos, cppclass = cppclass))
371 #trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME
373 def p_trailer(s, node1):
376 return p_call(s, node1)
378 return p_index(s, node1)
381 name = EncodedString( p_ident(s) )
382 return ExprNodes.AttributeNode(pos,
383 obj = node1, attribute = name)
385 # arglist: argument (',' argument)* [',']
386 # argument: [test '='] test # Really [keyword '='] test
388 def p_call_parse_args(s, allow_genexp = True):
396 while s.sy not in ('**', ')'):
399 s.error("only one star-arg parameter allowed",
408 s.error("Expected an identifier before '='",
410 encoded_name = EncodedString(arg.name)
411 keyword = ExprNodes.IdentifierStringNode(arg.pos, value = encoded_name)
413 keyword_args.append((keyword, arg))
416 s.error("Non-keyword arg following keyword arg",
419 s.error("Non-keyword arg following star-arg",
421 positional_args.append(arg)
427 if len(positional_args) == 1 and not star_arg:
428 positional_args = [ p_genexp(s, positional_args[0]) ]
431 starstar_arg = p_test(s)
435 return positional_args, keyword_args, star_arg, starstar_arg
437 def p_call_build_packed_args(pos, positional_args, keyword_args, star_arg):
440 if positional_args or not star_arg:
441 arg_tuple = ExprNodes.TupleNode(pos,
442 args = positional_args)
444 star_arg_tuple = ExprNodes.AsTupleNode(pos, arg = star_arg)
446 arg_tuple = ExprNodes.binop_node(pos,
447 operator = '+', operand1 = arg_tuple,
448 operand2 = star_arg_tuple)
450 arg_tuple = star_arg_tuple
452 keyword_args = [ExprNodes.DictItemNode(pos=key.pos, key=key, value=value)
453 for key, value in keyword_args]
454 keyword_dict = ExprNodes.DictNode(pos,
455 key_value_pairs = keyword_args)
456 return arg_tuple, keyword_dict
458 def p_call(s, function):
462 positional_args, keyword_args, star_arg, starstar_arg = \
465 if not (keyword_args or star_arg or starstar_arg):
466 return ExprNodes.SimpleCallNode(pos,
468 args = positional_args)
470 arg_tuple, keyword_dict = p_call_build_packed_args(
471 pos, positional_args, keyword_args, star_arg)
472 return ExprNodes.GeneralCallNode(pos,
474 positional_args = arg_tuple,
475 keyword_args = keyword_dict,
476 starstar_arg = starstar_arg)
478 #lambdef: 'lambda' [varargslist] ':' test
480 #subscriptlist: subscript (',' subscript)* [',']
482 def p_index(s, base):
486 subscripts = p_subscript_list(s)
487 if len(subscripts) == 1 and len(subscripts[0]) == 2:
488 start, stop = subscripts[0]
489 result = ExprNodes.SliceIndexNode(pos,
490 base = base, start = start, stop = stop)
492 indexes = make_slice_nodes(pos, subscripts)
493 if len(indexes) == 1:
496 index = ExprNodes.TupleNode(pos, args = indexes)
497 result = ExprNodes.IndexNode(pos,
498 base = base, index = index)
502 def p_subscript_list(s):
503 items = [p_subscript(s)]
508 items.append(p_subscript(s))
511 #subscript: '.' '.' '.' | test | [test] ':' [test] [':' [test]]
514 # Parse a subscript and return a list of
515 # 1, 2 or 3 ExprNodes, depending on how
516 # many slice elements were encountered.
518 start = p_slice_element(s, (':',))
522 stop = p_slice_element(s, (':', ',', ']'))
526 step = p_slice_element(s, (':', ',', ']'))
527 return [start, stop, step]
529 def p_slice_element(s, follow_set):
530 # Simple expression which may be missing iff
531 # it is followed by something in follow_set.
532 if s.sy not in follow_set:
537 def expect_ellipsis(s):
542 def make_slice_nodes(pos, subscripts):
543 # Convert a list of subscripts as returned
544 # by p_subscript_list into a list of ExprNodes,
545 # creating SliceNodes for elements with 2 or
548 for subscript in subscripts:
549 if len(subscript) == 1:
550 result.append(subscript[0])
552 result.append(make_slice_node(pos, *subscript))
555 def make_slice_node(pos, start, stop = None, step = None):
557 start = ExprNodes.NoneNode(pos)
559 stop = ExprNodes.NoneNode(pos)
561 step = ExprNodes.NoneNode(pos)
562 return ExprNodes.SliceNode(pos,
563 start = start, stop = stop, step = step)
565 #atom: '(' [yield_expr|testlist_comp] ')' | '[' [listmaker] ']' | '{' [dict_or_set_maker] '}' | '`' testlist '`' | NAME | NUMBER | STRING+
573 result = ExprNodes.TupleNode(pos, args = [])
574 elif s.sy == 'yield':
575 result = p_yield_expression(s)
577 result = p_testlist_comp(s)
581 return p_list_maker(s)
583 return p_dict_or_set_maker(s)
585 return p_backquote_expr(s)
588 return ExprNodes.EllipsisNode(pos)
590 return p_int_literal(s)
594 return ExprNodes.FloatNode(pos, value = value)
596 value = s.systring[:-1]
598 return ExprNodes.ImagNode(pos, value = value)
599 elif sy == 'BEGIN_STRING':
600 kind, bytes_value, unicode_value = p_cat_string_literal(s)
602 return ExprNodes.CharNode(pos, value = bytes_value)
604 return ExprNodes.UnicodeNode(pos, value = unicode_value, bytes_value = bytes_value)
606 return ExprNodes.BytesNode(pos, value = bytes_value)
608 return ExprNodes.StringNode(pos, value = bytes_value, unicode_value = unicode_value)
610 name = EncodedString( s.systring )
613 return ExprNodes.NoneNode(pos)
615 return ExprNodes.BoolNode(pos, value=True)
616 elif name == "False":
617 return ExprNodes.BoolNode(pos, value=False)
618 elif name == "NULL" and not s.in_python_file:
619 return ExprNodes.NullNode(pos)
621 return p_name(s, name)
623 s.error("Expected an identifier or literal")
625 def p_int_literal(s):
631 while value[-1] in u"UuLl":
632 if value[-1] in u"Ll":
637 # '3L' is ambiguous in Py2 but not in Py3. '3U' and '3LL' are
638 # illegal in Py2 Python files. All suffixes are illegal in Py3
644 if longness == 'LL' or s.context.language_level >= 3:
648 error(pos, "illegal integer literal syntax in Python source file")
650 return ExprNodes.IntNode(pos,
651 is_c_literal = is_c_literal,
658 if not s.compile_time_expr and name in s.compile_time_env:
659 value = s.compile_time_env.lookup_here(name)
661 if isinstance(value, bool):
662 return ExprNodes.BoolNode(pos, value = value)
663 elif isinstance(value, int):
664 return ExprNodes.IntNode(pos, value = rep)
665 elif isinstance(value, long):
666 return ExprNodes.IntNode(pos, value = rep, longness = "L")
667 elif isinstance(value, float):
668 return ExprNodes.FloatNode(pos, value = rep)
669 elif isinstance(value, _unicode):
670 return ExprNodes.UnicodeNode(pos, value = value)
671 elif isinstance(value, _bytes):
672 return ExprNodes.BytesNode(pos, value = value)
674 error(pos, "Invalid type for compile-time constant: %s"
675 % value.__class__.__name__)
676 return ExprNodes.NameNode(pos, name = name)
678 def p_cat_string_literal(s):
679 # A sequence of one or more adjacent string literals.
680 # Returns (kind, bytes_value, unicode_value)
681 # where kind in ('b', 'c', 'u', '')
682 kind, bytes_value, unicode_value = p_string_literal(s)
683 if kind == 'c' or s.sy != 'BEGIN_STRING':
684 return kind, bytes_value, unicode_value
685 bstrings, ustrings = [bytes_value], [unicode_value]
686 bytes_value = unicode_value = None
687 while s.sy == 'BEGIN_STRING':
689 next_kind, next_bytes_value, next_unicode_value = p_string_literal(s)
691 error(pos, "Cannot concatenate char literal with another string or char literal")
692 elif next_kind != kind:
693 error(pos, "Cannot mix string literals of different types, expected %s'', got %s''" %
696 bstrings.append(next_bytes_value)
697 ustrings.append(next_unicode_value)
698 # join and rewrap the partial literals
699 if kind in ('b', 'c', '') or kind == 'u' and None not in bstrings:
700 # Py3 enforced unicode literals are parsed as bytes/unicode combination
701 bytes_value = BytesLiteral( StringEncoding.join_bytes(bstrings) )
702 bytes_value.encoding = s.source_encoding
703 if kind in ('u', ''):
704 unicode_value = EncodedString( u''.join([ u for u in ustrings if u is not None ]) )
705 return kind, bytes_value, unicode_value
707 def p_opt_string_literal(s, required_type='u'):
708 if s.sy == 'BEGIN_STRING':
709 kind, bytes_value, unicode_value = p_string_literal(s, required_type)
710 if required_type == 'u':
712 elif required_type == 'b':
715 s.error("internal parser configuration error")
719 def check_for_non_ascii_characters(string):
725 def p_string_literal(s, kind_override=None):
726 # A single string or char literal. Returns (kind, bvalue, uvalue)
727 # where kind in ('b', 'c', 'u', ''). The 'bvalue' is the source
728 # code byte sequence of the string literal, 'uvalue' is the
729 # decoded Unicode string. Either of the two may be None depending
730 # on the 'kind' of string, only unprefixed strings have both
733 # s.sy == 'BEGIN_STRING'
736 is_python3_source = s.context.language_level >= 3
737 has_non_ASCII_literal_characters = False
738 kind = s.systring[:1].lower()
743 is_raw = s.systring[1:2].lower() == 'r'
746 if kind == '' and kind_override is None and Future.unicode_literals in s.context.future_directives:
747 chars = StringEncoding.StrLiteralBuilder(s.source_encoding)
750 if kind_override is not None and kind_override in 'ub':
753 chars = StringEncoding.UnicodeLiteralBuilder()
755 chars = StringEncoding.StrLiteralBuilder(s.source_encoding)
757 chars = StringEncoding.BytesLiteralBuilder(s.source_encoding)
762 #print "p_string_literal: sy =", sy, repr(s.systring) ###
765 if is_python3_source and not has_non_ASCII_literal_characters and check_for_non_ascii_characters(systr):
766 has_non_ASCII_literal_characters = True
770 if is_python3_source and not has_non_ASCII_literal_characters \
771 and check_for_non_ascii_characters(systr):
772 has_non_ASCII_literal_characters = True
776 chars.append_charval( int(systr[1:], 8) )
779 elif c in u"abfnrtv":
781 StringEncoding.char_from_escape_sequence(systr))
786 chars.append_charval( int(systr[2:], 16) )
788 s.error("Invalid hex escape '%s'" % systr)
790 if kind in ('u', ''):
791 if len(systr) in (6,10):
792 chrval = int(systr[2:], 16)
793 if chrval > 1114111: # sys.maxunicode:
794 s.error("Invalid unicode escape '%s'" % systr)
796 s.error("Invalid unicode escape '%s'" % systr)
798 # unicode escapes in byte strings are not unescaped
800 chars.append_uescape(chrval, systr)
802 chars.append(u'\\' + systr[1:])
803 if is_python3_source and not has_non_ASCII_literal_characters \
804 and check_for_non_ascii_characters(systr):
805 has_non_ASCII_literal_characters = True
806 elif sy == 'NEWLINE':
808 elif sy == 'END_STRING':
811 s.error("Unclosed string literal", pos = pos)
814 "Unexpected token %r:%r in string literal" %
818 bytes_value = chars.getchar()
819 if len(bytes_value) != 1:
820 error(pos, u"invalid character literal: %r" % bytes_value)
822 bytes_value, unicode_value = chars.getstrings()
823 if is_python3_source and has_non_ASCII_literal_characters:
824 # Python 3 forbids literal non-ASCII characters in byte strings
826 s.error("bytes can only contain ASCII literal characters.", pos = pos)
829 return (kind, bytes_value, unicode_value)
831 # list_display ::= "[" [listmaker] "]"
832 # listmaker ::= expression ( comp_for | ( "," expression )* [","] )
833 # comp_iter ::= comp_for | comp_if
834 # comp_for ::= "for" expression_list "in" testlist [comp_iter]
835 # comp_if ::= "if" test [comp_iter]
843 return ExprNodes.ListNode(pos, args = [])
846 target = ExprNodes.ListNode(pos, args = [])
847 append = ExprNodes.ComprehensionAppendNode(
848 pos, expr=expr, target=ExprNodes.CloneNode(target))
849 loop = p_comp_for(s, append)
851 return ExprNodes.ComprehensionNode(
852 pos, loop=loop, append=append, target=target,
853 # list comprehensions leak their loop variable in Py2
854 has_local_scope = s.context.language_level >= 3)
858 exprs = p_simple_expr_list(s, expr)
862 return ExprNodes.ListNode(pos, args = exprs)
864 def p_comp_iter(s, body):
866 return p_comp_for(s, body)
868 return p_comp_if(s, body)
870 # insert the 'append' operation into the loop
873 def p_comp_for(s, body):
877 kw = p_for_bounds(s, allow_testlist=False)
878 kw.update(dict(else_clause = None, body = p_comp_iter(s, body)))
879 return Nodes.ForStatNode(pos, **kw)
881 def p_comp_if(s, body):
885 test = p_test_nocond(s)
886 return Nodes.IfStatNode(pos,
887 if_clauses = [Nodes.IfClauseNode(pos, condition = test,
888 body = p_comp_iter(s, body))],
891 #dictmaker: test ':' test (',' test ':' test)* [',']
893 def p_dict_or_set_maker(s):
899 return ExprNodes.DictNode(pos, key_value_pairs = [])
901 if s.sy == ',' or s.sy == '}':
908 values.append( p_test(s) )
910 return ExprNodes.SetNode(pos, args=values)
913 target = ExprNodes.SetNode(pos, args=[])
914 append = ExprNodes.ComprehensionAppendNode(
915 item.pos, expr=item, target=ExprNodes.CloneNode(target))
916 loop = p_comp_for(s, append)
918 return ExprNodes.ComprehensionNode(
919 pos, loop=loop, append=append, target=target)
921 # dict literal or comprehension
927 target = ExprNodes.DictNode(pos, key_value_pairs = [])
928 append = ExprNodes.DictComprehensionAppendNode(
929 item.pos, key_expr=key, value_expr=value,
930 target=ExprNodes.CloneNode(target))
931 loop = p_comp_for(s, append)
933 return ExprNodes.ComprehensionNode(
934 pos, loop=loop, append=append, target=target)
937 items = [ExprNodes.DictItemNode(key.pos, key=key, value=value)]
946 ExprNodes.DictItemNode(key.pos, key=key, value=value))
948 return ExprNodes.DictNode(pos, key_value_pairs=items)
952 return ExprNodes.DictNode(pos, key_value_pairs = [])
954 # NOTE: no longer in Py3 :)
955 def p_backquote_expr(s):
962 args.append(p_test(s))
967 arg = ExprNodes.TupleNode(pos, args = args)
968 return ExprNodes.BackquoteNode(pos, arg = arg)
970 def p_simple_expr_list(s, expr=None):
971 exprs = expr is not None and [expr] or []
972 while s.sy not in expr_terminators:
973 exprs.append( p_test(s) )
979 def p_test_or_starred_expr_list(s, expr=None):
980 exprs = expr is not None and [expr] or []
981 while s.sy not in expr_terminators:
982 exprs.append( p_test_or_starred_expr(s) )
989 #testlist: test (',' test)* [',']
996 exprs = p_simple_expr_list(s, expr)
997 return ExprNodes.TupleNode(pos, args = exprs)
1001 # testlist_star_expr: (test|star_expr) ( comp_for | (',' (test|star_expr))* [','] )
1003 def p_testlist_star_expr(s):
1005 expr = p_test_or_starred_expr(s)
1008 exprs = p_test_or_starred_expr_list(s, expr)
1009 return ExprNodes.TupleNode(pos, args = exprs)
1013 # testlist_comp: (test|star_expr) ( comp_for | (',' (test|star_expr))* [','] )
1015 def p_testlist_comp(s):
1017 expr = p_test_or_starred_expr(s)
1020 exprs = p_test_or_starred_expr_list(s, expr)
1021 return ExprNodes.TupleNode(pos, args = exprs)
1023 return p_genexp(s, expr)
1027 def p_genexp(s, expr):
1029 loop = p_comp_for(s, Nodes.ExprStatNode(
1030 expr.pos, expr = ExprNodes.YieldExprNode(expr.pos, arg=expr)))
1031 return ExprNodes.GeneratorExpressionNode(expr.pos, loop=loop)
1033 expr_terminators = (')', ']', '}', ':', '=', 'NEWLINE')
1035 #-------------------------------------------------------
1039 #-------------------------------------------------------
1041 def p_global_statement(s):
1042 # assume s.sy == 'global'
1045 names = p_ident_list(s)
1046 return Nodes.GlobalNode(pos, names = names)
1048 def p_nonlocal_statement(s):
1051 names = p_ident_list(s)
1052 return Nodes.NonlocalNode(pos, names = names)
1054 def p_expression_or_assignment(s):
1055 expr_list = [p_testlist_star_expr(s)]
1059 expr = p_yield_expression(s)
1061 expr = p_testlist_star_expr(s)
1062 expr_list.append(expr)
1063 if len(expr_list) == 1:
1064 if re.match(r"([+*/\%^\&|-]|<<|>>|\*\*|//)=", s.sy):
1066 if not isinstance(lhs, (ExprNodes.AttributeNode, ExprNodes.IndexNode, ExprNodes.NameNode) ):
1067 error(lhs.pos, "Illegal operand for inplace operation.")
1068 operator = s.sy[:-1]
1071 rhs = p_yield_expression(s)
1074 return Nodes.InPlaceAssignmentNode(lhs.pos, operator = operator, lhs = lhs, rhs = rhs)
1076 if isinstance(expr, (ExprNodes.UnicodeNode, ExprNodes.StringNode, ExprNodes.BytesNode)):
1077 return Nodes.PassStatNode(expr.pos)
1079 return Nodes.ExprStatNode(expr.pos, expr = expr)
1082 if len(expr_list) == 2:
1083 return Nodes.SingleAssignmentNode(rhs.pos,
1084 lhs = expr_list[0], rhs = rhs)
1086 return Nodes.CascadedAssignmentNode(rhs.pos,
1087 lhs_list = expr_list[:-1], rhs = rhs)
1089 def p_print_statement(s):
1099 ends_with_comma = s.sy in ('NEWLINE', 'EOF')
1103 if s.sy not in ('NEWLINE', 'EOF'):
1104 args.append(p_test(s))
1107 if s.sy in ('NEWLINE', 'EOF'):
1110 args.append(p_test(s))
1111 arg_tuple = ExprNodes.TupleNode(pos, args = args)
1112 return Nodes.PrintStatNode(pos,
1113 arg_tuple = arg_tuple, stream = stream,
1114 append_newline = not ends_with_comma)
1116 def p_exec_statement(s):
1120 args = [ p_bit_expr(s) ]
1123 args.append(p_test(s))
1126 args.append(p_test(s))
1128 error(pos, "'exec' currently requires a target mapping (globals/locals)")
1129 return Nodes.ExecStatNode(pos, args = args)
1131 def p_del_statement(s):
1135 # FIXME: 'exprlist' in Python
1136 args = p_simple_expr_list(s)
1137 return Nodes.DelStatNode(pos, args = args)
1139 def p_pass_statement(s, with_newline = 0):
1143 s.expect_newline("Expected a newline")
1144 return Nodes.PassStatNode(pos)
1146 def p_break_statement(s):
1150 return Nodes.BreakStatNode(pos)
1152 def p_continue_statement(s):
1153 # s.sy == 'continue'
1156 return Nodes.ContinueStatNode(pos)
1158 def p_return_statement(s):
1162 if s.sy not in statement_terminators:
1163 value = p_testlist(s)
1166 return Nodes.ReturnStatNode(pos, value = value)
1168 def p_raise_statement(s):
1175 if s.sy not in statement_terminators:
1176 exc_type = p_test(s)
1179 exc_value = p_test(s)
1183 if exc_type or exc_value or exc_tb:
1184 return Nodes.RaiseStatNode(pos,
1185 exc_type = exc_type,
1186 exc_value = exc_value,
1189 return Nodes.ReraiseStatNode(pos)
1191 def p_import_statement(s):
1192 # s.sy in ('import', 'cimport')
1196 items = [p_dotted_name(s, as_allowed = 1)]
1199 items.append(p_dotted_name(s, as_allowed = 1))
1201 for pos, target_name, dotted_name, as_name in items:
1202 dotted_name = EncodedString(dotted_name)
1203 if kind == 'cimport':
1204 stat = Nodes.CImportStatNode(pos,
1205 module_name = dotted_name,
1208 if as_name and "." in dotted_name:
1209 name_list = ExprNodes.ListNode(pos, args = [
1210 ExprNodes.IdentifierStringNode(pos, value = EncodedString("*"))])
1213 stat = Nodes.SingleAssignmentNode(pos,
1214 lhs = ExprNodes.NameNode(pos,
1215 name = as_name or target_name),
1216 rhs = ExprNodes.ImportNode(pos,
1217 module_name = ExprNodes.IdentifierStringNode(
1218 pos, value = dotted_name),
1220 name_list = name_list))
1222 return Nodes.StatListNode(pos, stats = stats)
1224 def p_from_import_statement(s, first_statement = 0):
1229 # count relative import level
1234 if s.sy == 'cimport':
1235 s.error("Relative cimport is not supported yet")
1238 if level is not None and s.sy == 'import':
1239 # we are dealing with "from .. import foo, bar"
1240 dotted_name_pos, dotted_name = s.position(), ''
1241 elif level is not None and s.sy == 'cimport':
1243 s.error("Relative cimport is not supported yet")
1245 (dotted_name_pos, _, dotted_name, _) = \
1246 p_dotted_name(s, as_allowed = 0)
1247 if s.sy in ('import', 'cimport'):
1251 s.error("Expected 'import' or 'cimport'")
1253 is_cimport = kind == 'cimport'
1254 is_parenthesized = False
1256 imported_names = [(s.position(), "*", None, None)]
1260 is_parenthesized = True
1262 imported_names = [p_imported_name(s, is_cimport)]
1265 if is_parenthesized and s.sy == ')':
1267 imported_names.append(p_imported_name(s, is_cimport))
1268 if is_parenthesized:
1270 dotted_name = EncodedString(dotted_name)
1271 if dotted_name == '__future__':
1272 if not first_statement:
1273 s.error("from __future__ imports must occur at the beginning of the file")
1274 elif level is not None:
1275 s.error("invalid syntax")
1277 for (name_pos, name, as_name, kind) in imported_names:
1278 if name == "braces":
1279 s.error("not a chance", name_pos)
1282 directive = getattr(Future, name)
1283 except AttributeError:
1284 s.error("future feature %s is not defined" % name, name_pos)
1286 s.context.future_directives.add(directive)
1287 return Nodes.PassStatNode(pos)
1288 elif kind == 'cimport':
1289 return Nodes.FromCImportStatNode(pos,
1290 module_name = dotted_name,
1291 imported_names = imported_names)
1293 imported_name_strings = []
1295 for (name_pos, name, as_name, kind) in imported_names:
1296 encoded_name = EncodedString(name)
1297 imported_name_strings.append(
1298 ExprNodes.IdentifierStringNode(name_pos, value = encoded_name))
1301 ExprNodes.NameNode(name_pos,
1302 name = as_name or name)))
1303 import_list = ExprNodes.ListNode(
1304 imported_names[0][0], args = imported_name_strings)
1305 dotted_name = EncodedString(dotted_name)
1306 return Nodes.FromImportStatNode(pos,
1307 module = ExprNodes.ImportNode(dotted_name_pos,
1308 module_name = ExprNodes.IdentifierStringNode(pos, value = dotted_name),
1310 name_list = import_list),
1313 imported_name_kinds = ('class', 'struct', 'union')
1315 def p_imported_name(s, is_cimport):
1318 if is_cimport and s.systring in imported_name_kinds:
1322 as_name = p_as_name(s)
1323 return (pos, name, as_name, kind)
1325 def p_dotted_name(s, as_allowed):
1327 target_name = p_ident(s)
1329 names = [target_name]
1332 names.append(p_ident(s))
1334 as_name = p_as_name(s)
1335 return (pos, target_name, u'.'.join(names), as_name)
1338 if s.sy == 'IDENT' and s.systring == 'as':
1344 def p_assert_statement(s):
1354 return Nodes.AssertStatNode(pos, cond = cond, value = value)
1356 statement_terminators = (';', 'NEWLINE', 'EOF')
1358 def p_if_statement(s):
1362 if_clauses = [p_if_clause(s)]
1363 while s.sy == 'elif':
1365 if_clauses.append(p_if_clause(s))
1366 else_clause = p_else_clause(s)
1367 return Nodes.IfStatNode(pos,
1368 if_clauses = if_clauses, else_clause = else_clause)
1374 return Nodes.IfClauseNode(pos,
1375 condition = test, body = body)
1377 def p_else_clause(s):
1384 def p_while_statement(s):
1390 else_clause = p_else_clause(s)
1391 return Nodes.WhileStatNode(pos,
1392 condition = test, body = body,
1393 else_clause = else_clause)
1395 def p_for_statement(s):
1399 kw = p_for_bounds(s, allow_testlist=True)
1401 else_clause = p_else_clause(s)
1402 kw.update(dict(body = body, else_clause = else_clause))
1403 return Nodes.ForStatNode(pos, **kw)
1405 def p_for_bounds(s, allow_testlist=True):
1406 target = p_for_target(s)
1409 iterator = p_for_iterator(s, allow_testlist)
1410 return dict( target = target, iterator = iterator )
1411 elif not s.in_python_file:
1414 bound1 = p_bit_expr(s)
1416 # Support shorter "for a <= x < b" syntax
1417 bound1, target = target, None
1418 rel1 = p_for_from_relation(s)
1419 name2_pos = s.position()
1421 rel2_pos = s.position()
1422 rel2 = p_for_from_relation(s)
1423 bound2 = p_bit_expr(s)
1424 step = p_for_from_step(s)
1426 target = ExprNodes.NameNode(name2_pos, name = name2)
1428 if not target.is_name:
1430 "Target of for-from statement must be a variable name")
1431 elif name2 != target.name:
1433 "Variable name in for-from range does not match target")
1434 if rel1[0] != rel2[0]:
1436 "Relation directions in for-from do not match")
1437 return dict(target = target,
1448 def p_for_from_relation(s):
1449 if s.sy in inequality_relations:
1454 s.error("Expected one of '<', '<=', '>' '>='")
1456 def p_for_from_step(s):
1457 if s.sy == 'IDENT' and s.systring == 'by':
1459 step = p_bit_expr(s)
1464 inequality_relations = ('<', '<=', '>', '>=')
1466 def p_target(s, terminator):
1468 expr = p_starred_expr(s)
1472 while s.sy != terminator:
1473 exprs.append(p_starred_expr(s))
1477 return ExprNodes.TupleNode(pos, args = exprs)
1481 def p_for_target(s):
1482 return p_target(s, 'in')
1484 def p_for_iterator(s, allow_testlist=True):
1487 expr = p_testlist(s)
1490 return ExprNodes.IteratorNode(pos, sequence = expr)
1492 def p_try_statement(s):
1499 if s.sy in ('except', 'else'):
1500 while s.sy == 'except':
1501 except_clauses.append(p_except_clause(s))
1504 else_clause = p_suite(s)
1505 body = Nodes.TryExceptStatNode(pos,
1506 body = body, except_clauses = except_clauses,
1507 else_clause = else_clause)
1508 if s.sy != 'finally':
1510 # try-except-finally is equivalent to nested try-except/try-finally
1511 if s.sy == 'finally':
1513 finally_clause = p_suite(s)
1514 return Nodes.TryFinallyStatNode(pos,
1515 body = body, finally_clause = finally_clause)
1517 s.error("Expected 'except' or 'finally'")
1519 def p_except_clause(s):
1526 exc_type = p_test(s)
1527 # normalise into list of single exception tests
1528 if isinstance(exc_type, ExprNodes.TupleNode):
1529 exc_type = exc_type.args
1531 exc_type = [exc_type]
1532 if s.sy == ',' or (s.sy == 'IDENT' and s.systring == 'as'):
1534 exc_value = p_test(s)
1535 elif s.sy == 'IDENT' and s.systring == 'as':
1536 # Py3 syntax requires a name here
1540 exc_value = ExprNodes.NameNode(pos2, name = name)
1542 return Nodes.ExceptClauseNode(pos,
1543 pattern = exc_type, target = exc_value, body = body)
1545 def p_include_statement(s, ctx):
1547 s.next() # 'include'
1548 unicode_include_file_name = p_string_literal(s, 'u')[2]
1549 s.expect_newline("Syntax error in include statement")
1550 if s.compile_time_eval:
1551 include_file_name = unicode_include_file_name
1552 include_file_path = s.context.find_include_file(include_file_name, pos)
1553 if include_file_path:
1554 s.included_files.append(include_file_name)
1555 f = Utils.open_source_file(include_file_path, mode="rU")
1556 source_desc = FileSourceDescriptor(include_file_path)
1557 s2 = PyrexScanner(f, source_desc, s, source_encoding=f.encoding, parse_comments=s.parse_comments)
1559 tree = p_statement_list(s2, ctx)
1566 return Nodes.PassStatNode(pos)
1568 def p_with_statement(s):
1570 if s.systring == 'template' and not s.in_python_file:
1571 node = p_with_template(s)
1573 node = p_with_items(s)
1576 def p_with_items(s):
1578 if not s.in_python_file and s.sy == 'IDENT' and s.systring == 'nogil':
1583 body = p_with_items(s)
1586 return Nodes.GILStatNode(pos, state = state, body = body)
1590 if s.sy == 'IDENT' and s.systring == 'as':
1592 target = p_starred_expr(s)
1595 body = p_with_items(s)
1598 return Nodes.WithStatNode(pos, manager = manager,
1599 target = target, body = body)
1601 def p_with_template(s):
1606 templates.append(s.systring)
1608 while s.systring == ',':
1610 templates.append(s.systring)
1615 s.expect_newline("Syntax error in template function declaration")
1618 body_ctx.templates = templates
1619 func_or_var = p_c_func_or_var_declaration(s, pos, body_ctx)
1623 error(pos, "Syntax error in template function declaration")
1625 def p_simple_statement(s, first_statement = 0):
1626 #print "p_simple_statement:", s.sy, s.systring ###
1627 if s.sy == 'global':
1628 node = p_global_statement(s)
1629 elif s.sy == 'nonlocal':
1630 node = p_nonlocal_statement(s)
1631 elif s.sy == 'print':
1632 node = p_print_statement(s)
1633 elif s.sy == 'exec':
1634 node = p_exec_statement(s)
1636 node = p_del_statement(s)
1637 elif s.sy == 'break':
1638 node = p_break_statement(s)
1639 elif s.sy == 'continue':
1640 node = p_continue_statement(s)
1641 elif s.sy == 'return':
1642 node = p_return_statement(s)
1643 elif s.sy == 'raise':
1644 node = p_raise_statement(s)
1645 elif s.sy in ('import', 'cimport'):
1646 node = p_import_statement(s)
1647 elif s.sy == 'from':
1648 node = p_from_import_statement(s, first_statement = first_statement)
1649 elif s.sy == 'yield':
1650 node = p_yield_statement(s)
1651 elif s.sy == 'assert':
1652 node = p_assert_statement(s)
1653 elif s.sy == 'pass':
1654 node = p_pass_statement(s)
1656 node = p_expression_or_assignment(s)
1659 def p_simple_statement_list(s, ctx, first_statement = 0):
1660 # Parse a series of simple statements on one line
1661 # separated by semicolons.
1662 stat = p_simple_statement(s, first_statement = first_statement)
1665 if not isinstance(stat, Nodes.PassStatNode):
1668 #print "p_simple_statement_list: maybe more to follow" ###
1670 if s.sy in ('NEWLINE', 'EOF'):
1672 stat = p_simple_statement(s, first_statement = first_statement)
1673 if isinstance(stat, Nodes.PassStatNode):
1676 first_statement = False
1679 stat = Nodes.PassStatNode(pos)
1680 elif len(stats) == 1:
1683 stat = Nodes.StatListNode(pos, stats = stats)
1684 s.expect_newline("Syntax error in simple statement list")
1687 def p_compile_time_expr(s):
1688 old = s.compile_time_expr
1689 s.compile_time_expr = 1
1690 expr = p_testlist(s)
1691 s.compile_time_expr = old
1694 def p_DEF_statement(s):
1696 denv = s.compile_time_env
1700 expr = p_compile_time_expr(s)
1701 value = expr.compile_time_value(denv)
1702 #print "p_DEF_statement: %s = %r" % (name, value) ###
1703 denv.declare(name, value)
1705 return Nodes.PassStatNode(pos)
1707 def p_IF_statement(s, ctx):
1709 saved_eval = s.compile_time_eval
1710 current_eval = saved_eval
1711 denv = s.compile_time_env
1714 s.next() # 'IF' or 'ELIF'
1715 expr = p_compile_time_expr(s)
1716 s.compile_time_eval = current_eval and bool(expr.compile_time_value(denv))
1717 body = p_suite(s, ctx)
1718 if s.compile_time_eval:
1725 s.compile_time_eval = current_eval
1726 body = p_suite(s, ctx)
1730 result = Nodes.PassStatNode(pos)
1731 s.compile_time_eval = saved_eval
1734 def p_statement(s, ctx, first_statement = 0):
1735 cdef_flag = ctx.cdef_flag
1737 if s.sy == 'ctypedef':
1738 if ctx.level not in ('module', 'module_pxd'):
1739 s.error("ctypedef statement not allowed here")
1741 # error(s.position(), "'api' not allowed with 'ctypedef'")
1742 return p_ctypedef_statement(s, ctx)
1744 return p_DEF_statement(s)
1746 return p_IF_statement(s, ctx)
1747 elif s.sy == 'DECORATOR':
1748 if ctx.level not in ('module', 'class', 'c_class', 'function', 'property', 'module_pxd', 'c_class_pxd'):
1749 s.error('decorator not allowed here')
1751 decorators = p_decorators(s)
1752 if s.sy not in ('def', 'cdef', 'cpdef', 'class'):
1753 s.error("Decorators can only be followed by functions or classes")
1754 elif s.sy == 'pass' and cdef_flag:
1756 return p_pass_statement(s, with_newline = 1)
1762 elif s.sy == 'cpdef':
1767 if ctx.level not in ('module', 'module_pxd', 'function', 'c_class', 'c_class_pxd'):
1768 s.error('cdef statement not allowed here')
1770 node = p_cdef_statement(s, ctx(overridable = overridable))
1771 if decorators is not None:
1772 if not isinstance(node, (Nodes.CFuncDefNode, Nodes.CVarDefNode, Nodes.CClassDefNode)):
1773 s.error("Decorators can only be followed by functions or classes")
1774 node.decorators = decorators
1778 s.error("'api' not allowed with this statement")
1780 # def statements aren't allowed in pxd files, except
1781 # as part of a cdef class
1782 if ('pxd' in ctx.level) and (ctx.level != 'c_class_pxd'):
1783 s.error('def statement not allowed here')
1785 return p_def_statement(s, decorators)
1786 elif s.sy == 'class':
1787 if ctx.level not in ('module', 'function', 'class', 'other'):
1788 s.error("class definition not allowed here")
1789 return p_class_statement(s, decorators)
1790 elif s.sy == 'include':
1791 if ctx.level not in ('module', 'module_pxd'):
1792 s.error("include statement not allowed here")
1793 return p_include_statement(s, ctx)
1794 elif ctx.level == 'c_class' and s.sy == 'IDENT' and s.systring == 'property':
1795 return p_property_decl(s)
1796 elif s.sy == 'pass' and ctx.level != 'property':
1797 return p_pass_statement(s, with_newline = 1)
1799 if ctx.level in ('c_class_pxd', 'property'):
1800 s.error("Executable statement not allowed here")
1802 return p_if_statement(s)
1803 elif s.sy == 'while':
1804 return p_while_statement(s)
1806 return p_for_statement(s)
1808 return p_try_statement(s)
1809 elif s.sy == 'with':
1810 return p_with_statement(s)
1812 return p_simple_statement_list(
1813 s, ctx, first_statement = first_statement)
1815 def p_statement_list(s, ctx, first_statement = 0):
1816 # Parse a series of statements separated by newlines.
1819 while s.sy not in ('DEDENT', 'EOF'):
1820 stat = p_statement(s, ctx, first_statement = first_statement)
1821 if isinstance(stat, Nodes.PassStatNode):
1824 first_statement = False
1826 return Nodes.PassStatNode(pos)
1827 elif len(stats) == 1:
1830 return Nodes.StatListNode(pos, stats = stats)
1832 def p_suite(s, ctx = Ctx(), with_doc = 0, with_pseudo_doc = 0):
1837 if s.sy == 'NEWLINE':
1840 if with_doc or with_pseudo_doc:
1841 doc = p_doc_string(s)
1842 body = p_statement_list(s, ctx)
1846 s.error("'api' not allowed with this statement")
1847 if ctx.level in ('module', 'class', 'function', 'other'):
1848 body = p_simple_statement_list(s, ctx)
1850 body = p_pass_statement(s)
1851 s.expect_newline("Syntax error in declarations")
1857 def p_positional_and_keyword_args(s, end_sy_set, templates = None):
1859 Parses positional and keyword arguments. end_sy_set
1860 should contain any s.sy that terminate the argument list.
1861 Argument expansion (* and **) are not allowed.
1863 Returns: (positional_args, keyword_args)
1865 positional_args = []
1869 while s.sy not in end_sy_set:
1870 if s.sy == '*' or s.sy == '**':
1871 s.error('Argument expansion not allowed here.')
1874 if s.sy == 'IDENT' and s.peek()[0] == '=':
1876 s.next() # s.sy is '='
1878 if looking_at_expr(s):
1881 base_type = p_c_base_type(s, templates = templates)
1882 declarator = p_c_declarator(s, empty = 1)
1883 arg = Nodes.CComplexBaseTypeNode(base_type.pos,
1884 base_type = base_type, declarator = declarator)
1886 keyword_node = ExprNodes.IdentifierStringNode(
1887 arg.pos, value = EncodedString(ident))
1888 keyword_args.append((keyword_node, arg))
1892 if looking_at_expr(s):
1895 base_type = p_c_base_type(s, templates = templates)
1896 declarator = p_c_declarator(s, empty = 1)
1897 arg = Nodes.CComplexBaseTypeNode(base_type.pos,
1898 base_type = base_type, declarator = declarator)
1900 positional_args.append(arg)
1902 if len(keyword_args) > 0:
1903 s.error("Non-keyword arg following keyword arg",
1907 if s.sy not in end_sy_set:
1909 s.error("Unmatched %s" % " or ".join(end_sy_set))
1912 return positional_args, keyword_args
1914 def p_c_base_type(s, self_flag = 0, nonempty = 0, templates = None):
1915 # If self_flag is true, this is the base type for the
1916 # self argument of a C method of an extension type.
1918 return p_c_complex_base_type(s)
1920 return p_c_simple_base_type(s, self_flag, nonempty = nonempty, templates = templates)
1922 def p_calling_convention(s):
1923 if s.sy == 'IDENT' and s.systring in calling_convention_words:
1930 calling_convention_words = ("__stdcall", "__cdecl", "__fastcall")
1932 def p_c_complex_base_type(s):
1936 base_type = p_c_base_type(s)
1937 declarator = p_c_declarator(s, empty = 1)
1939 return Nodes.CComplexBaseTypeNode(pos,
1940 base_type = base_type, declarator = declarator)
1942 def p_c_simple_base_type(s, self_flag, nonempty, templates = None):
1943 #print "p_c_simple_base_type: self_flag =", self_flag, nonempty
1950 if not s.sy == 'IDENT':
1951 error(pos, "Expected an identifier, found '%s'" % s.sy)
1952 if looking_at_base_type(s):
1953 #print "p_c_simple_base_type: looking_at_base_type at", s.position()
1955 if s.sy == 'IDENT' and s.systring in special_basic_c_types:
1956 signed, longness = special_basic_c_types[s.systring]
1960 signed, longness = p_sign_and_longness(s)
1961 if s.sy == 'IDENT' and s.systring in basic_c_type_names:
1965 name = 'int' # long [int], short [int], long [int] complex, etc.
1966 if s.sy == 'IDENT' and s.systring == 'complex':
1969 elif looking_at_dotted_name(s):
1970 #print "p_c_simple_base_type: looking_at_type_name at", s.position()
1974 module_path.append(name)
1980 if nonempty and s.sy != 'IDENT':
1981 # Make sure this is not a declaration of a variable or function.
1984 if s.sy == '*' or s.sy == '**' or s.sy == '&':
1985 s.put_back('(', '(')
1987 s.put_back('(', '(')
1988 s.put_back('IDENT', name)
1990 elif s.sy not in ('*', '**', '[', '&'):
1991 s.put_back('IDENT', name)
1994 type_node = Nodes.CSimpleBaseTypeNode(pos,
1995 name = name, module_path = module_path,
1996 is_basic_c_type = is_basic, signed = signed,
1997 complex = complex, longness = longness,
1998 is_self_arg = self_flag, templates = templates)
2001 type_node = p_buffer_or_template(s, type_node, templates)
2006 type_node = Nodes.CNestedBaseTypeNode(pos, base_type = type_node, name = name)
2010 def p_buffer_or_template(s, base_type_node, templates):
2014 # Note that buffer_positional_options_count=1, so the only positional argument is dtype.
2015 # For templated types, all parameters are types.
2016 positional_args, keyword_args = (
2017 p_positional_and_keyword_args(s, (']',), templates)
2021 keyword_dict = ExprNodes.DictNode(pos,
2023 ExprNodes.DictItemNode(pos=key.pos, key=key, value=value)
2024 for key, value in keyword_args
2026 result = Nodes.TemplatedTypeNode(pos,
2027 positional_args = positional_args,
2028 keyword_args = keyword_dict,
2029 base_type_node = base_type_node)
2033 def looking_at_name(s):
2034 return s.sy == 'IDENT' and not s.systring in calling_convention_words
2036 def looking_at_expr(s):
2037 if s.systring in base_type_start_words:
2039 elif s.sy == 'IDENT':
2046 dotted_path.append(s.systring)
2048 saved = s.sy, s.systring
2051 elif s.sy == '*' or s.sy == '**':
2053 is_type = s.sy in (')', ']')
2057 is_type = s.sy == '*'
2061 is_type = s.sy == ']'
2063 dotted_path.reverse()
2064 for p in dotted_path:
2065 s.put_back('IDENT', p)
2066 s.put_back('.', '.')
2067 s.put_back('IDENT', name)
2072 def looking_at_base_type(s):
2073 #print "looking_at_base_type?", s.sy, s.systring, s.position()
2074 return s.sy == 'IDENT' and s.systring in base_type_start_words
2076 def looking_at_dotted_name(s):
2080 result = s.sy == '.'
2081 s.put_back('IDENT', name)
2086 basic_c_type_names = ("void", "char", "int", "float", "double", "bint")
2088 special_basic_c_types = {
2089 # name : (signed, longness)
2090 "Py_UNICODE" : (0, 0),
2092 "Py_ssize_t" : (2, 0),
2097 sign_and_longness_words = ("short", "long", "signed", "unsigned")
2099 base_type_start_words = \
2100 basic_c_type_names + sign_and_longness_words + tuple(special_basic_c_types)
2102 def p_sign_and_longness(s):
2105 while s.sy == 'IDENT' and s.systring in sign_and_longness_words:
2106 if s.systring == 'unsigned':
2108 elif s.systring == 'signed':
2110 elif s.systring == 'short':
2112 elif s.systring == 'long':
2115 return signed, longness
2118 literal = p_opt_string_literal(s, 'u')
2119 if literal is not None:
2120 cname = EncodedString(literal)
2121 cname.encoding = s.source_encoding
2126 def p_c_declarator(s, ctx = Ctx(), empty = 0, is_type = 0, cmethod_flag = 0,
2127 assignable = 0, nonempty = 0,
2128 calling_convention_allowed = 0):
2129 # If empty is true, the declarator must be empty. If nonempty is true,
2130 # the declarator must be nonempty. Otherwise we don't care.
2131 # If cmethod_flag is true, then if this declarator declares
2132 # a function, it's a C method of an extension type.
2136 if s.sy == ')' or looking_at_name(s):
2137 base = Nodes.CNameDeclaratorNode(pos, name = EncodedString(u""), cname = None)
2138 result = p_c_func_declarator(s, pos, ctx, base, cmethod_flag)
2140 result = p_c_declarator(s, ctx, empty = empty, is_type = is_type,
2141 cmethod_flag = cmethod_flag,
2142 nonempty = nonempty,
2143 calling_convention_allowed = 1)
2146 result = p_c_simple_declarator(s, ctx, empty, is_type, cmethod_flag,
2147 assignable, nonempty)
2148 if not calling_convention_allowed and result.calling_convention and s.sy != '(':
2149 error(s.position(), "%s on something that is not a function"
2150 % result.calling_convention)
2151 while s.sy in ('[', '('):
2154 result = p_c_array_declarator(s, result)
2157 result = p_c_func_declarator(s, pos, ctx, result, cmethod_flag)
2161 def p_c_array_declarator(s, base):
2169 return Nodes.CArrayDeclaratorNode(pos, base = base, dimension = dim)
2171 def p_c_func_declarator(s, pos, ctx, base, cmethod_flag):
2172 # Opening paren has already been skipped
2173 args = p_c_arg_list(s, ctx, cmethod_flag = cmethod_flag,
2174 nonempty_declarators = 0)
2175 ellipsis = p_optional_ellipsis(s)
2178 exc_val, exc_check = p_exception_value_clause(s)
2179 with_gil = p_with_gil(s)
2180 return Nodes.CFuncDeclaratorNode(pos,
2181 base = base, args = args, has_varargs = ellipsis,
2182 exception_value = exc_val, exception_check = exc_check,
2183 nogil = nogil or ctx.nogil or with_gil, with_gil = with_gil)
2185 supported_overloaded_operators = cython.set([
2186 '+', '-', '*', '/', '%',
2187 '++', '--', '~', '|', '&', '^', '<<', '>>', ',',
2188 '==', '!=', '>=', '>', '<=', '<',
2192 def p_c_simple_declarator(s, ctx, empty, is_type, cmethod_flag,
2193 assignable, nonempty):
2195 calling_convention = p_calling_convention(s)
2198 base = p_c_declarator(s, ctx, empty = empty, is_type = is_type,
2199 cmethod_flag = cmethod_flag,
2200 assignable = assignable, nonempty = nonempty)
2201 result = Nodes.CPtrDeclaratorNode(pos,
2203 elif s.sy == '**': # scanner returns this as a single token
2205 base = p_c_declarator(s, ctx, empty = empty, is_type = is_type,
2206 cmethod_flag = cmethod_flag,
2207 assignable = assignable, nonempty = nonempty)
2208 result = Nodes.CPtrDeclaratorNode(pos,
2209 base = Nodes.CPtrDeclaratorNode(pos,
2213 base = p_c_declarator(s, ctx, empty = empty, is_type = is_type,
2214 cmethod_flag = cmethod_flag,
2215 assignable = assignable, nonempty = nonempty)
2216 result = Nodes.CReferenceDeclaratorNode(pos, base = base)
2220 name = EncodedString(s.systring)
2222 error(s.position(), "Declarator should be empty")
2224 cname = p_opt_cname(s)
2225 if name != 'operator' and s.sy == '=' and assignable:
2230 error(s.position(), "Empty declarator")
2233 if cname is None and ctx.namespace is not None and nonempty:
2234 cname = ctx.namespace + "::" + name
2235 if name == 'operator' and ctx.visibility == 'extern' and nonempty:
2237 if [1 for c in op if c in '+-*/<=>!%&|([^~,']:
2239 # Handle diphthong operators.
2246 if op in ['-', '+', '|', '&'] and s.sy == op:
2252 if op not in supported_overloaded_operators:
2253 s.error("Overloading operator '%s' not yet supported." % op)
2255 result = Nodes.CNameDeclaratorNode(pos,
2256 name = name, cname = cname, default = rhs)
2257 result.calling_convention = calling_convention
2261 if s.sy == 'IDENT' and s.systring == 'nogil':
2270 s.expect_keyword('gil')
2275 def p_exception_value_clause(s):
2278 if s.sy == 'except':
2289 exc_val = p_name(s, name)
2295 return exc_val, exc_check
2297 c_arg_list_terminators = ('*', '**', '.', ')')
2299 def p_c_arg_list(s, ctx = Ctx(), in_pyfunc = 0, cmethod_flag = 0,
2300 nonempty_declarators = 0, kw_only = 0, annotated = 1):
2301 # Comma-separated list of C argument declarations, possibly empty.
2302 # May have a trailing comma.
2304 is_self_arg = cmethod_flag
2305 while s.sy not in c_arg_list_terminators:
2306 args.append(p_c_arg_decl(s, ctx, in_pyfunc, is_self_arg,
2307 nonempty = nonempty_declarators, kw_only = kw_only,
2308 annotated = annotated))
2315 def p_optional_ellipsis(s):
2322 def p_c_arg_decl(s, ctx, in_pyfunc, cmethod_flag = 0, nonempty = 0,
2323 kw_only = 0, annotated = 1):
2325 not_none = or_none = 0
2328 if s.in_python_file:
2329 # empty type declaration
2330 base_type = Nodes.CSimpleBaseTypeNode(pos,
2331 name = None, module_path = [],
2332 is_basic_c_type = 0, signed = 0,
2333 complex = 0, longness = 0,
2334 is_self_arg = cmethod_flag, templates = None)
2336 base_type = p_c_base_type(s, cmethod_flag, nonempty = nonempty)
2337 declarator = p_c_declarator(s, ctx, nonempty = nonempty)
2338 if s.sy in ('not', 'or') and not s.in_python_file:
2341 if s.sy == 'IDENT' and s.systring == 'None':
2344 s.error("Expected 'None'")
2346 error(pos, "'%s None' only allowed in Python functions" % kind)
2347 or_none = kind == 'or'
2348 not_none = kind == 'not'
2349 if annotated and s.sy == ':':
2351 annotation = p_test(s)
2354 if 'pxd' in s.level:
2355 if s.sy not in ['*', '?']:
2356 error(pos, "default values cannot be specified in pxd files, use ? or *")
2357 default = ExprNodes.BoolNode(1)
2361 return Nodes.CArgDeclNode(pos,
2362 base_type = base_type,
2363 declarator = declarator,
2364 not_none = not_none,
2367 annotation = annotation,
2371 if s.sy == 'IDENT' and s.systring == 'api':
2377 def p_cdef_statement(s, ctx):
2379 ctx.visibility = p_visibility(s, ctx.visibility)
2380 ctx.api = ctx.api or p_api(s)
2382 if ctx.visibility not in ('private', 'public'):
2383 error(pos, "Cannot combine 'api' with '%s'" % ctx.visibility)
2384 if (ctx.visibility == 'extern') and s.sy == 'from':
2385 return p_cdef_extern_block(s, pos, ctx)
2386 elif s.sy == 'import':
2388 return p_cdef_extern_block(s, pos, ctx)
2392 error(pos, "cdef blocks cannot be declared cpdef")
2393 return p_cdef_block(s, ctx)
2396 error(pos, "cdef blocks cannot be declared cpdef")
2397 return p_cdef_block(s, ctx)
2398 elif s.sy == 'class':
2399 if ctx.level not in ('module', 'module_pxd'):
2400 error(pos, "Extension type definition not allowed here")
2402 error(pos, "Extension types cannot be declared cpdef")
2403 return p_c_class_definition(s, pos, ctx)
2404 elif s.sy == 'IDENT' and s.systring == 'cppclass':
2405 if ctx.visibility != 'extern':
2406 error(pos, "C++ classes need to be declared extern")
2407 return p_cpp_class_definition(s, pos, ctx)
2408 elif s.sy == 'IDENT' and s.systring in ("struct", "union", "enum", "packed"):
2409 if ctx.level not in ('module', 'module_pxd'):
2410 error(pos, "C struct/union/enum definition not allowed here")
2412 error(pos, "C struct/union/enum cannot be declared cpdef")
2413 if s.systring == "enum":
2414 return p_c_enum_definition(s, pos, ctx)
2416 return p_c_struct_or_union_definition(s, pos, ctx)
2418 return p_c_func_or_var_declaration(s, pos, ctx)
2420 def p_cdef_block(s, ctx):
2421 return p_suite(s, ctx(cdef_flag = 1))
2423 def p_cdef_extern_block(s, pos, ctx):
2425 error(pos, "cdef extern blocks cannot be declared cpdef")
2431 include_file = p_string_literal(s, 'u')[2]
2432 ctx = ctx(cdef_flag = 1, visibility = 'extern')
2433 if s.systring == "namespace":
2435 ctx.namespace = p_string_literal(s, 'u')[2]
2438 body = p_suite(s, ctx)
2439 return Nodes.CDefExternNode(pos,
2440 include_file = include_file,
2442 namespace = ctx.namespace)
2444 def p_c_enum_definition(s, pos, ctx):
2445 # s.sy == ident 'enum'
2450 cname = p_opt_cname(s)
2451 if cname is None and ctx.namespace is not None:
2452 cname = ctx.namespace + "::" + name
2459 if s.sy != 'NEWLINE':
2460 p_c_enum_line(s, ctx, items)
2462 s.next() # 'NEWLINE'
2464 while s.sy not in ('DEDENT', 'EOF'):
2465 p_c_enum_line(s, ctx, items)
2467 return Nodes.CEnumDefNode(
2468 pos, name = name, cname = cname, items = items,
2469 typedef_flag = ctx.typedef_flag, visibility = ctx.visibility,
2470 api = ctx.api, in_pxd = ctx.level == 'module_pxd')
2472 def p_c_enum_line(s, ctx, items):
2474 p_c_enum_item(s, ctx, items)
2477 if s.sy in ('NEWLINE', 'EOF'):
2479 p_c_enum_item(s, ctx, items)
2482 s.expect_newline("Syntax error in enum item list")
2484 def p_c_enum_item(s, ctx, items):
2487 cname = p_opt_cname(s)
2488 if cname is None and ctx.namespace is not None:
2489 cname = ctx.namespace + "::" + name
2494 items.append(Nodes.CEnumDefItemNode(pos,
2495 name = name, cname = cname, value = value))
2497 def p_c_struct_or_union_definition(s, pos, ctx):
2499 if s.systring == 'packed':
2502 if s.sy != 'IDENT' or s.systring != 'struct':
2503 s.expected('struct')
2504 # s.sy == ident 'struct' or 'union'
2508 cname = p_opt_cname(s)
2509 if cname is None and ctx.namespace is not None:
2510 cname = ctx.namespace + "::" + name
2518 while s.sy != 'DEDENT':
2521 p_c_func_or_var_declaration(s, s.position(), body_ctx))
2524 s.expect_newline("Expected a newline")
2527 s.expect_newline("Syntax error in struct or union definition")
2528 return Nodes.CStructOrUnionDefNode(pos,
2529 name = name, cname = cname, kind = kind, attributes = attributes,
2530 typedef_flag = ctx.typedef_flag, visibility = ctx.visibility,
2531 api = ctx.api, in_pxd = ctx.level == 'module_pxd', packed = packed)
2533 def p_visibility(s, prev_visibility):
2535 visibility = prev_visibility
2536 if s.sy == 'IDENT' and s.systring in ('extern', 'public', 'readonly'):
2537 visibility = s.systring
2538 if prev_visibility != 'private' and visibility != prev_visibility:
2539 s.error("Conflicting visibility options '%s' and '%s'"
2540 % (prev_visibility, visibility))
2544 def p_c_modifiers(s):
2545 if s.sy == 'IDENT' and s.systring in ('inline',):
2546 modifier = s.systring
2548 return [modifier] + p_c_modifiers(s)
2551 def p_c_func_or_var_declaration(s, pos, ctx):
2552 cmethod_flag = ctx.level in ('c_class', 'c_class_pxd')
2553 modifiers = p_c_modifiers(s)
2554 base_type = p_c_base_type(s, nonempty = 1, templates = ctx.templates)
2555 declarator = p_c_declarator(s, ctx, cmethod_flag = cmethod_flag,
2556 assignable = 1, nonempty = 1)
2557 declarator.overridable = ctx.overridable
2559 if ctx.level not in ('module', 'c_class', 'module_pxd', 'c_class_pxd') and not ctx.templates:
2560 s.error("C function definition not allowed here")
2561 doc, suite = p_suite(s, Ctx(level = 'function'), with_doc = 1)
2562 result = Nodes.CFuncDefNode(pos,
2563 visibility = ctx.visibility,
2564 base_type = base_type,
2565 declarator = declarator,
2568 modifiers = modifiers,
2570 overridable = ctx.overridable)
2573 # s.error("'api' not allowed with variable declaration")
2574 declarators = [declarator]
2577 if s.sy == 'NEWLINE':
2579 declarator = p_c_declarator(s, ctx, cmethod_flag = cmethod_flag,
2580 assignable = 1, nonempty = 1)
2581 declarators.append(declarator)
2582 s.expect_newline("Syntax error in C variable declaration")
2583 result = Nodes.CVarDefNode(pos,
2584 visibility = ctx.visibility,
2585 base_type = base_type,
2586 declarators = declarators,
2587 in_pxd = ctx.level == 'module_pxd',
2589 overridable = ctx.overridable)
2592 def p_ctypedef_statement(s, ctx):
2593 # s.sy == 'ctypedef'
2596 visibility = p_visibility(s, ctx.visibility)
2598 ctx = ctx(typedef_flag = 1, visibility = visibility)
2602 return p_c_class_definition(s, pos, ctx)
2603 elif s.sy == 'IDENT' and s.systring in ('packed', 'struct', 'union', 'enum'):
2604 if s.systring == 'enum':
2605 return p_c_enum_definition(s, pos, ctx)
2607 return p_c_struct_or_union_definition(s, pos, ctx)
2609 base_type = p_c_base_type(s, nonempty = 1)
2610 if base_type.name is None:
2611 s.error("Syntax error in ctypedef statement")
2612 declarator = p_c_declarator(s, ctx, is_type = 1, nonempty = 1)
2613 s.expect_newline("Syntax error in ctypedef statement")
2614 return Nodes.CTypeDefNode(
2615 pos, base_type = base_type,
2616 declarator = declarator,
2617 visibility = visibility, api = api,
2618 in_pxd = ctx.level == 'module_pxd')
2620 def p_decorators(s):
2622 while s.sy == 'DECORATOR':
2625 decstring = p_dotted_name(s, as_allowed=0)[2]
2626 names = decstring.split('.')
2627 decorator = ExprNodes.NameNode(pos, name=EncodedString(names[0]))
2628 for name in names[1:]:
2629 decorator = ExprNodes.AttributeNode(pos,
2630 attribute=EncodedString(name),
2633 decorator = p_call(s, decorator)
2634 decorators.append(Nodes.DecoratorNode(pos, decorator=decorator))
2635 s.expect_newline("Expected a newline after decorator")
2638 def p_def_statement(s, decorators=None):
2642 name = EncodedString( p_ident(s) )
2644 args, star_arg, starstar_arg = p_varargslist(s, terminator=')')
2647 error(pos, "Python function cannot be declared nogil")
2648 return_type_annotation = None
2651 return_type_annotation = p_test(s)
2652 doc, body = p_suite(s, Ctx(level = 'function'), with_doc = 1)
2653 return Nodes.DefNode(pos, name = name, args = args,
2654 star_arg = star_arg, starstar_arg = starstar_arg,
2655 doc = doc, body = body, decorators = decorators,
2656 return_type_annotation = return_type_annotation)
2658 def p_varargslist(s, terminator=')', annotated=1):
2659 args = p_c_arg_list(s, in_pyfunc = 1, nonempty_declarators = 1,
2660 annotated = annotated)
2666 star_arg = p_py_arg_decl(s, annotated=annotated)
2669 args.extend(p_c_arg_list(s, in_pyfunc = 1,
2670 nonempty_declarators = 1, kw_only = 1, annotated = annotated))
2671 elif s.sy != terminator:
2672 s.error("Syntax error in Python function argument list")
2675 starstar_arg = p_py_arg_decl(s, annotated=annotated)
2676 return (args, star_arg, starstar_arg)
2678 def p_py_arg_decl(s, annotated = 1):
2682 if annotated and s.sy == ':':
2684 annotation = p_test(s)
2685 return Nodes.PyArgDeclNode(pos, name = name, annotation = annotation)
2687 def p_class_statement(s, decorators):
2691 class_name = EncodedString( p_ident(s) )
2692 class_name.encoding = s.source_encoding
2697 positional_args, keyword_args, star_arg, starstar_arg = \
2698 p_call_parse_args(s, allow_genexp = False)
2699 arg_tuple, keyword_dict = p_call_build_packed_args(
2700 pos, positional_args, keyword_args, star_arg)
2701 if arg_tuple is None:
2702 # XXX: empty arg_tuple
2703 arg_tuple = ExprNodes.TupleNode(pos, args = [])
2704 doc, body = p_suite(s, Ctx(level = 'class'), with_doc = 1)
2705 return Nodes.PyClassDefNode(pos,
2708 keyword_args = keyword_dict,
2709 starstar_arg = starstar_arg,
2710 doc = doc, body = body, decorators = decorators)
2712 def p_c_class_definition(s, pos, ctx):
2716 class_name = p_ident(s)
2719 module_path.append(class_name)
2720 class_name = p_ident(s)
2721 if module_path and ctx.visibility != 'extern':
2722 error(pos, "Qualified class name only allowed for 'extern' C class")
2723 if module_path and s.sy == 'IDENT' and s.systring == 'as':
2725 as_name = p_ident(s)
2727 as_name = class_name
2728 objstruct_name = None
2730 base_class_module = None
2731 base_class_name = None
2734 base_class_path = [p_ident(s)]
2737 base_class_path.append(p_ident(s))
2739 s.error("C class may only have one base class")
2741 base_class_module = ".".join(base_class_path[:-1])
2742 base_class_name = base_class_path[-1]
2744 if ctx.visibility not in ('public', 'extern') and not ctx.api:
2745 error(s.position(), "Name options only allowed for 'public', 'api', or 'extern' C class")
2746 objstruct_name, typeobj_name = p_c_class_options(s)
2748 if ctx.level == 'module_pxd':
2749 body_level = 'c_class_pxd'
2751 body_level = 'c_class'
2752 doc, body = p_suite(s, Ctx(level = body_level), with_doc = 1)
2754 s.expect_newline("Syntax error in C class definition")
2757 if ctx.visibility == 'extern':
2759 error(pos, "Module name required for 'extern' C class")
2761 error(pos, "Type object name specification not allowed for 'extern' C class")
2762 elif ctx.visibility == 'public':
2763 if not objstruct_name:
2764 error(pos, "Object struct name specification required for 'public' C class")
2765 if not typeobj_name:
2766 error(pos, "Type object name specification required for 'public' C class")
2767 elif ctx.visibility == 'private':
2769 if not objstruct_name:
2770 error(pos, "Object struct name specification required for 'api' C class")
2771 if not typeobj_name:
2772 error(pos, "Type object name specification required for 'api' C class")
2774 error(pos, "Invalid class visibility '%s'" % ctx.visibility)
2775 return Nodes.CClassDefNode(pos,
2776 visibility = ctx.visibility,
2777 typedef_flag = ctx.typedef_flag,
2779 module_name = ".".join(module_path),
2780 class_name = class_name,
2782 base_class_module = base_class_module,
2783 base_class_name = base_class_name,
2784 objstruct_name = objstruct_name,
2785 typeobj_name = typeobj_name,
2786 in_pxd = ctx.level == 'module_pxd',
2790 def p_c_class_options(s):
2791 objstruct_name = None
2797 if s.systring == 'object':
2799 objstruct_name = p_ident(s)
2800 elif s.systring == 'type':
2802 typeobj_name = p_ident(s)
2806 s.expect(']', "Expected 'object' or 'type'")
2807 return objstruct_name, typeobj_name
2809 def p_property_decl(s):
2811 s.next() # 'property'
2813 doc, body = p_suite(s, Ctx(level = 'property'), with_doc = 1)
2814 return Nodes.PropertyNode(pos, name = name, doc = doc, body = body)
2816 def p_doc_string(s):
2817 if s.sy == 'BEGIN_STRING':
2819 kind, bytes_result, unicode_result = p_cat_string_literal(s)
2821 s.expect_newline("Syntax error in doc string")
2822 if kind in ('u', ''):
2823 return unicode_result
2824 warning(pos, "Python 3 requires docstrings to be unicode strings")
2829 def p_code(s, level=None):
2830 body = p_statement_list(s, Ctx(level = level), first_statement = 1)
2832 s.error("Syntax error in statement [%s,%s]" % (
2833 repr(s.sy), repr(s.systring)))
2836 COMPILER_DIRECTIVE_COMMENT_RE = re.compile(r"^#\s*cython\s*:\s*((\w|[.])+\s*=.*)$")
2838 def p_compiler_directive_comments(s):
2840 while s.sy == 'commentline':
2841 m = COMPILER_DIRECTIVE_COMMENT_RE.match(s.systring)
2843 directives = m.group(1).strip()
2845 result.update( Options.parse_directive_list(
2846 directives, ignore_unknown=True) )
2847 except ValueError, e:
2848 s.error(e.args[0], fatal=False)
2852 def p_module(s, pxd, full_module_name):
2855 directive_comments = p_compiler_directive_comments(s)
2856 s.parse_comments = False
2858 if 'language_level' in directive_comments:
2859 s.context.set_language_level(directive_comments['language_level'])
2861 doc = p_doc_string(s)
2863 level = 'module_pxd'
2867 body = p_statement_list(s, Ctx(level = level), first_statement = 1)
2869 s.error("Syntax error in statement [%s,%s]" % (
2870 repr(s.sy), repr(s.systring)))
2871 return ModuleNode(pos, doc = doc, body = body,
2872 full_module_name = full_module_name,
2873 directive_comments = directive_comments)
2875 def p_cpp_class_definition(s, pos, ctx):
2876 # s.sy == 'cppclass'
2879 class_name = p_ident(s)
2880 cname = p_opt_cname(s)
2881 if cname is None and ctx.namespace is not None:
2882 cname = ctx.namespace + "::" + class_name
2884 error(pos, "Qualified class name not allowed C++ class")
2887 templates = [p_ident(s)]
2890 templates.append(p_ident(s))
2896 base_classes = [p_dotted_name(s, False)[2]]
2899 base_classes.append(p_dotted_name(s, False)[2])
2904 error(s.position(), "Name options not allowed for C++ class")
2910 body_ctx = Ctx(visibility = ctx.visibility)
2911 body_ctx.templates = templates
2912 while s.sy != 'DEDENT':
2913 if s.systring == 'cppclass':
2915 p_cpp_class_definition(s, s.position(), body_ctx))
2916 elif s.sy != 'pass':
2918 p_c_func_or_var_declaration(s, s.position(), body_ctx))
2921 s.expect_newline("Expected a newline")
2925 s.expect_newline("Syntax error in C++ class definition")
2926 return Nodes.CppClassNode(pos,
2929 base_classes = base_classes,
2930 visibility = ctx.visibility,
2931 in_pxd = ctx.level == 'module_pxd',
2932 attributes = attributes,
2933 templates = templates)
2937 #----------------------------------------------
2941 #----------------------------------------------
2943 def print_parse_tree(f, node, level, key = None):
2944 from types import ListType, TupleType
2945 from Nodes import Node
2950 f.write("%s: " % key)
2953 f.write("(%s @ %s\n" % (node[0], node[1]))
2954 for i in xrange(2, len(node)):
2955 print_parse_tree(f, node[i], level+1)
2956 f.write("%s)\n" % ind)
2958 elif isinstance(node, Node):
2961 except AttributeError:
2962 tag = node.__class__.__name__
2963 f.write("%s @ %s\n" % (tag, node.pos))
2964 for name, value in node.__dict__.items():
2965 if name != 'tag' and name != 'pos':
2966 print_parse_tree(f, value, level+1, name)
2970 for i in xrange(len(node)):
2971 print_parse_tree(f, node[i], level+1)
2972 f.write("%s]\n" % ind)
2974 f.write("%s%s\n" % (ind, node))