def parse(tokens):
from ast.expression import Expression
pos = tokens.getPosition()
lhs = Expression.parse(tokens)
t = tokens.getNext()
if t not in AssignOperators:
tokens.setPosition(pos)
return None
rhs = Expression.parse(tokens)
if rhs is None:
raise error.SyntaxError, "Expected an expression, got %s" % tokens.peek()
if t == "=":
expression = rhs
elif t.value.endswith("="):
t.value = t.value[0 : len(t.value) - 1]
if t == "<<" or t == ">>" or t == ">>>":
expression = ShiftExpression(lhs, rhs, t)
elif t == "*" or t == "/" or t == "%":
expression = MultiplyExpression(lhs, rhs, t)
elif t == "+" or t == "-":
expression = AddExpression(lhs, rhs, t)
elif t == "&" or t == "|" or t == "^":
expression = BitwiseExpression(lhs, rhs, t)
else:
raise error.SyntaxError, "Unrecognized assign operator %s=" % t
else:
raise error.SyntaxError, "Everything has gone to shit"
return AssignStatement(lhs, expression)
def parse(tokens):
statementList = []
keyword = tokens.peek()
if keyword != "if":
return None
tokens.getNext()
if keyword == "if":
arg = Expression.parse(tokens)
if arg is None:
raise error.SyntaxError, "Expected expression at %r" % tokens.peek()
if tokens.peek() != ":":
raise error.SyntaxError, "Expected ':' at end of line for '" + str(keyword) + " " + repr(arg) + "'"
tokens.expect(":")
tokens.expect(token.END_OF_STATEMENT)
block = BlockStatement.parse(tokens)
statementList.append((keyword, arg, block))
while True:
keyword = tokens.peek()
if keyword not in ("elif", "else"):
break
tokens.expect(keyword)
if keyword in ("elif",):
arg = Expression.parse(tokens)
if arg is None:
raise error.SyntaxError, "Expected value at " + repr(tokens.peek())
else:
arg = None
if tokens.peek() != ":":
raise error.SyntaxError, "Expected ':' at end of line for '" + str(keyword) + " " + repr(arg) + "'"
tokens.expect(":")
tokens.expect(token.END_OF_STATEMENT)
block = BlockStatement.parse(tokens)
statementList.append((keyword, arg, block))
return IfStatement(statementList)
def parseArgList(tokens):
from ast.expression import Expression
tokens.expect('(')
args = []
# parse arguments
while True:
if tokens.peek() == ')':
break
arg = Expression.parse(tokens)
if arg is None:
raise error.SyntaxError, 'Expected expression, got %r' % tokens.peek()
args.append(arg)
peek = tokens.peek()
if peek == ',':
tokens.expect(',')
elif peek == ')':
break
else:
raise error.SyntaxError, 'Expected comma or end parenth, got %r' % peek
tokens.expect(')')
return args
def parse(tokens):
from ast.expression import Expression
from ast.literalexpression import IntLiteral
from nine.token import Token
if tokens.peek() != 'array':
return None
position = tokens.peek().position
tokens.expect('array')
tokens.expect('(')
arrayType = vartypes.Type.parse(tokens)
if arrayType is None:
raise error.SyntaxError(position, 'Expected type, got %r' % tokens.peek())
arity = IntLiteral(position, 1)
if tokens.peek() == ',':
tokens.expect(',')
arity = Expression.parse(tokens)
if arity is None:
raise error.SyntaxError(position, 'Expected array arity after type, got %r' % tokens.peek())
tokens.expect(')')
return ArrayType(position, arrayType, arity)
def parse(tokens):
from ast.vartypes import Type
from ast.expression import Expression
if tokens.peek() != "array":
return None
position = tokens.peek().position
tokens.expect("array")
tokens.expect("(")
arrayType = Type.parse(tokens)
if arrayType is None:
raise error.SyntaxError(position, 'Expected type after "(", got %r' % tokens.peek())
tokens.expect(",")
size = []
while True:
s = Expression.parse(tokens)
if s is None:
raise error.SyntaxError(position, "Expected expression for array size, got %r" % tokens.peek())
size.append(s)
if tokens.peek() == ",":
tokens.expect(",")
else:
break
tokens.expect(")")
return NewArrayExpression(position, arrayType, size)
def parse(tokens):
if tokens.peek() != 'print':
return None
else:
tokens.getNext()
arg = Expression.parse(tokens)
if arg is None:
raise Exception("Expected value at " + repr(tokens.peek()))
return PrintStatement(arg)
def parse(tokens):
if tokens.peek() != "raise":
return None
position = tokens.peek().position
tokens.expect("raise")
expr = Expression.parse(tokens)
if expr is None:
raise error.SyntaxError(position, "Expected expression, got %r" % tokens.peek())
return RaiseStatement(position, expr)
def parseIndex(tokens):
from ast.expression import Expression
indicies = []
tokens.expect('[')
while True:
indicies.append(Expression.parse(tokens))
if tokens.peek() == ',':
tokens.expect(',')
else:
tokens.expect(']')
break
return indicies
def parse(tokens):
if tokens.peek() != 'while':
return None
tokens.getNext()
arg = Expression.parse(tokens)
if arg is None:
raise SyntaxError(tokens.peek().position, "Expected value at " + repr(tokens.peek()))
tokens.expect(':')
tokens.getNext()
block = BlockStatement.parse(tokens)
return WhileStatement(arg, block)
def parse(tokens):
from ast.identifier import Identifier
from ast import vartypes
flags = memberflags.MemberFlags()
oldPos = tokens.getPosition()
while True:
tok = tokens.getNext()
if tok == 'static':
flags.static = True
else:
tokens.unget()
break
if tokens.peek() != 'var':
tokens.setPosition(oldPos)
return None
tokens.expect('var')
name = tokens.getNext()
if name.type != 'identifier':
raise error.SyntaxError, 'Expected identifier after keyword "var", got %r' % name
initializer = None
type = None
if tokens.peek() == 'as':
tokens.getNext() # eat the 'as'
type = vartypes.Type.parse(tokens)
if type is None:
raise error.SyntaxError, 'Expected type after "as". Got %r' % tokens.peek()
if tokens.peek() == '=':
tokens.getNext() # eat the '=' sign
initializer = Expression.parse(tokens)
if initializer is None:
raise error.SyntaxError, 'Expected expression after "=". Got %r' % tokens.peek()
peek = tokens.peek()
if peek not in (token.END_OF_STATEMENT, token.END_OF_FILE):
raise error.SyntaxError, 'Expected end of statement. Got %r' % peek
return VarDecl(name.value, name.position, type, initializer, flags)
def parse(tokens):
from ast.expression import Expression
from nine import token
if tokens.peek() != 'return':
return None
position = tokens.peek().position
tokens.expect('return')
if tokens.peek() is not token.END_OF_STATEMENT:
value = Expression.parse(tokens)
if value is None:
raise error.SyntaxError(position, 'Expected end of statement or expression, got %r' % tokens.peek())
else:
value = None
return ReturnStatement(position, value)
def parse(tokens):
from ast.blockstatement import BlockStatement
from ast.expression import Expression
from ast.identifier import Identifier
from ast.vardecl import VarDecl
from ast.vartypes import Type
if tokens.peek() != 'for':
return None
position = tokens.peek().position
tokens.expect('for')
ident = Identifier.parse(tokens)
if ident is None:
raise error.SyntaxError(position, 'Expected iterator name, got %r' % tokens.peek())
type = None
"""if tokens.peek() == 'as':
tokens.expect('as')
type = Type.parse(tokens)
if type is None:
raise error.SyntaxError(tokens.peek().position, 'Expected type after "as", got %r' % tokens.peek())"""
tokens.expect('in')
sequence = Expression.parse(tokens)
if sequence is None:
raise error.SyntaxError(tokens.peek().position, 'Expected expression after "in", got %r' % tokens.peek())
tokens.expect(':')
tokens.expect('\n')
body = BlockStatement.parse(tokens)
if body is None:
raise error.SyntaxError(tokens.peek().position, 'Expected loop body after ":", got %r' % tokens.peek())
return ForStatement(position, VarDecl(ident.name, ident.position, type), sequence, body)
def testLeftAssociativity(self):
result = Expression.parse(lex('a.b.c.d'))
assert isinstance(result.lhs, DotExpression), result.lhs
assert result.rhs.name == 'd'
def parse(tokens):
expr = Expression.parse(tokens)
if expr is not None:
return ExpressionStatement(expr)
else:
return None
def testAddMulExpression(self):
ast = Expression.parse(lex('a*a+b*b'))
assert isinstance(ast, AddExpression)
assert isinstance(ast.leftSide, MultiplyExpression)
assert isinstance(ast.rightSide, MultiplyExpression)
