def testSemantic(self): '''Also tests variable declaration/expression things. The basic jist is that, once semantic testing has been done, an Identifier should no longer be an Identifier; it should be a VariableExpression. ''' from ast.vardecl import VarDecl from ast.variableexpression import VariableExpression decl = VarDecl('testvar', (0, '<test>'), vartypes.IntType) scope = Scope(parent=None) scope['testvar'] = decl tokens = lex('testvar nonexist') expr1 = Identifier.parse(tokens) expr2 = Identifier.parse(tokens) result = expr1.semantic(scope) self.failUnlessEqual(type(result), VariableExpression) self.failUnlessEqual(result.variable, decl) self.failUnlessRaises( error.NameError, lambda: expr2.semantic(scope) )
def parse(tokens): from ast.primitiveexpression import PrimitiveExpression lhs = PrimitiveExpression.parse(tokens) if lhs is None: return None if tokens.peek() != '.': return lhs tokens.expect('.') expr = lhs while True: position = tokens.peek().position rhs = Identifier.parse(tokens) if rhs is None: raise error.SyntaxError, 'Expected identifier, got %r' % tokens.peek() expr = DotExpression(position, expr, rhs) if tokens.peek() != '.': break tokens.expect('.') continue return expr
def parse(tokens): if tokens.peek() is not token.BEGIN_BLOCK: return None decls = [] tokens.expect(token.BEGIN_BLOCK) while tokens.peek() is not token.END_BLOCK: decl = ( AssignStatement.parse(tokens) or Identifier.parse(tokens) or PassStatement.parse(tokens) ) if decl is None: raise error.SyntaxError, 'Expected end block, value declaration, or pass statement. Got %r' % tokens.peek() while tokens.peek() is token.END_OF_STATEMENT: tokens.getNext() if isinstance(decl, PassStatement): continue # Don't store pass statements. They're not useful. decls.append(decl) tokens.expect(token.END_BLOCK) return EnumBody(decls)
def parse(tokens): from ast.identifier import Identifier expr = Identifier.parse(tokens) if expr is None: raise error.SyntaxError, 'Expected identifier, got %r' % tokens.peek() while tokens.peek() == '.': tokens.expect('.') rhs = Identifier.parse(tokens) if rhs is None: raise error.SyntaxError, 'Expected identifier after ".", got %r' % tokens.peek() expr = QualifiedName(expr, rhs) return expr
def testSemantic(self): # Also tests Identifier and name resolution. decl = VarDecl('testvar', (0, '<test>'), vartypes.IntType) scope = Scope(parent=None) scope['testvar'] = decl tokens = lex('testvar') expr = Identifier.parse(tokens) result = expr.semantic(scope) self.failUnlessEqual(type(result), VariableExpression) self.failUnlessEqual(result.variable, decl)
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 parse(tokens): from ast.primitiveexpression import PrimitiveExpression from ast.dotexpression import DotExpression from ast.functioncallexpression import FunctionCallExpression from ast.indexexpression import IndexExpression from ast.castexpression import CastExpression position = tokens.peek().position lhs = PrimitiveExpression.parse(tokens) if lhs is None: return None while True: if tokens.peek() == '(': args = FunctionCallExpression.parseArgList(tokens) lhs = FunctionCallExpression(lhs.position, lhs, args) elif tokens.peek() == '[': indicies = IndexExpression.parseIndex(tokens) lhs = IndexExpression(lhs.position, lhs, indicies) elif tokens.peek() == 'as': type = CastExpression.parseCast(tokens) lhs = CastExpression(lhs.position, lhs, type) elif tokens.peek() == '.': from ast.identifier import Identifier tokens.expect('.') rhs = Identifier.parse(tokens) if rhs is None: raise error.SyntaxError(tokens.peek().position, 'Expected identifier, got %r' % tokens.peek()) lhs = DotExpression(lhs.position, lhs, rhs) else: return lhs
def testParseKeywords(self): from ast import vartypes tokens = lex('int string x y') result = [Identifier.parse(tokens) for i in range(4)]
def testFailParseKeyword(self): tokens = lex('print') result = Identifier.parse(tokens) self.failUnless(result is None)
def testGoodParse(self): tokens = lex('foo') result = Identifier.parse(tokens) self.failIf(result is None)