def p_assignment_expression(self, p): """assignment_expression : expr | unary_expression assignment_operator assignment_expression """ p[0] = ( p[1] if len(p) == 2 else ast.Assignment(p[2], p[1], p[3], coord=p[1].coord) )
def assignment(self, level): """ Assignment -> Identifier '=' Expression ';' :param level: indicates level of assignment; type(level) - int :return: An ast.Assignment object :raise CliteSyntaxError if an unexpected token is seen """ # Save and consume identifier identifier = self.curr_tok self.curr_tok = self.lex.__next__() # Match equal sign if self.curr_tok[self.CODE] != tokens.SINGLE_TOKENS[tokens.ASSIGN][0]: raise errors.CliteSyntaxError("An assignment statement expected!", self.curr_tok[self.LINE]) # Consume equal sign self.curr_tok = self.lex.__next__() expr = self.expression() # Match semicolon if self.curr_tok[self.CODE] != tokens.SINGLE_TOKENS[tokens.SEMICOLON][0]: raise errors.CliteSyntaxError("Semicolon expected!", self.curr_tok[self.LINE]) # Consume semicolon self.curr_tok = self.lex.__next__() # Check if the identifier is declared if identifier[2] not in self.decls: raise errors.CliteSyntaxError("Identifier is not declared!", self.curr_tok[self.LINE]) return ast.Assignment(identifier[2], expr, level)
def p_assignment(p): '''statement : ID ASSIGN expr SEMICOL | index ASSIGN expr SEMICOL''' ref = p[1] if isinstance(ref, str): ref = ast.VarUse(ref).at(loc(p, 1)) p[0] = ast.Assignment(ref, p[3]).at(loc(p))
def p_assignment_expression(self, p): """ assignment_expression : conditional_expression | unary_expression assignment_operator assignment_expression """ if len(p) == 2: p[0] = p[1] else: p[0] = ast.Assignment(p[2], p[1], p[3])
def p_assignment_expr(p): ''' assignment_expr : conditional_expr | conditional_expr EQUALS conditional_expr ''' if DEBUG: print("\nassignment expr: ", end="") for i in range(len(p)): print(i, " ", p[i], " ", end="") # only w/ constant if len(p) == 4: p[0] = ast.Assignment(p[2], p[1], p[3]) else: p[0] = p[1]
def assignment(self): """ Assignment ⇒ Identifier = Expression ; """ # Check for an identifier. if self.currToken[0] == lexer.Lexer.ID: # Check if the identifier has been declared. if self.currToken[2] in self.parseTree.declarations.keys(): # Capture the identifier to create an Assignment object. identify = self.currToken[2] # Move to the next token. self.currToken = next(self.tokens) # Check for '='. if self.currToken[0] == lexer.Lexer.ASSIGN: # Move to the next token. self.currToken = next(self.tokens) # Check for an expression and capture it to create an Assignment object. expr = self.expression() # Check for ';'. if self.currToken[0] == lexer.Lexer.SEMICOLON: # Move to the next token. self.currToken = next(self.tokens) # Create an Assignemt object. assign = ast.Assignment(identify, expr) # Return the assignment object. return assign # Unexpected token encountered. else: raise CLiteSyntaxError(self.currToken, ';') # Unexpected token encountered. else: raise CLiteSyntaxError(self.currToken, '=') # Unexpected token encountered. else: raise CLiteSyntaxError(self.currToken, 'N/A', 'Undeclared variable encountered') # Unexpected token encountered. else: raise CLiteSyntaxError(self.currToken, 'Identifier')
def parse_name_expr(source): global loc if (source[loc] == '='): # Whitespace already skipped loc += 1 name = buff return ast.Assignment(name, parse_expr(source)) elif not isname(source[loc]): # Variable return ast.Lookup(buff) else: # So it's a call name = buff q = tok(source) assert q == 'name' name2 = buff # try: return ast.Call(name, name2, [parse_expr(source)])
def parse_let(self): tok = self.current self.step() if not isinstance(self.current, tokens.IDENT): raise ParserError( f"Expected identifer after `let` keyword, found {self.current}" ) ident = self.parse_identifier() if not isinstance(self.current, tokens.ASSIGN): raise ParserError( f"Expected `=` after identifier keyword, found {self.current}") self.step() expr = self.parse_expr() return ast.Assignment(ident, expr)
def resolveName_FuncDef(self, func): # self.logger.debug('resolveName_FuncDef', func.name, func, func.owner) if isinstance(func.owner, ast.ExtensionDef): func.cls = func.owner.cls func.owner.cls.addSymbol(func) owner = func.owner if func.info.type == ast.FuncType.constructor: # self.logger.debug('resolveName_FuncDef constructor returnType', func.name, func, func.owner) assert func.spec.returnType is None func.spec.returnType = ast.UserType([func.cls.name]) self.setupNewItem(func.spec.returnType, func.spec, False) assert isinstance(owner, ast.ClassDef) or isinstance(owner, ast.CodeUnit) or isinstance(owner, ast.ExtensionDef), 'resolveName_FuncDef owner is invalid: %s %s' % (owner, func) if func.info.type == ast.FuncType.constructor: for var in func.owner.vars: if var.initial: stmt = ast.Assignment([ast.Identifier(var.name)], '=', [var.initial]) func.body.statements.insert(0, stmt) # self.logger.debug('resolveName_FuncDef initialize var', func.name, stmt, var, var.initial) self.setupNewItem(stmt, func.body, False) func.visitChildren(self)
# == LVALUES == lvalue = MatchFirst([lvariable, mem_lvalue, special_loc, struct_access]) declarevar = (Keyword('var') + identifier + Optional(Literal(':=').suppress() + expr, default=None) ).setParseAction(lambda t: ast.DeclareVar(t[1], t[2])) declarefn = (Keyword('declare') + identifier + Optional(Keyword('returns').setParseAction(lambda t: True), default = False))\ .setParseAction(lambda t: ast.DeclareFunction(t[1], t[2])) declare_struct = (Keyword('struct') + type_identifier + '{' + identifier_list + '}').setParseAction(lambda t: ast.DeclareStruct(t[1], t[3])) assignment = (lvalue + Literal(':=') + expr).setParseAction(lambda t: ast.Assignment(t[0], t[2])) return_ = ( Keyword('return') + Optional(expr, default=None)).setParseAction(lambda t: ast.Return(t[1])) halt = Keyword('halt').setParseAction(lambda t: ast.Halt()) expr_statement = expr.copy().setParseAction(lambda t: ast.ExprStatement(t[0])) if_ = (Keyword('if') + '(' + expr + ')' + block_sequence + Optional(Keyword('else').suppress() + block_sequence, default=None))\ .setParseAction(lambda t: ast.If(t[2], t[4], t[5])) while_ = (Keyword('while') + '(' + expr + ')' + block_sequence)\ .setParseAction(lambda t: ast.While(t[2], t[4]))
def p_assignment(p): ''' assignment : ID ASSIGN expression ''' p[0] = ast.Assignment(ast.Identifier(p[1]), p[3])
def p_expr_assign(p): ''' expr : identifier equal_tok assignable ''' p[0] = ast.Assignment(p[1], p[3])
def p_statement_assign(p): 'statement : NAME "=" expression' names[p[1]] = p[3] p[0] = ast.Assignment(p[1], p[3])
def p_assignment(self, p): """ assignment : variable assignment_operator expression """ p[0] = ast.Assignment(p[1], p[2], p[3], p.lexer.lexer.lineno)
def statement_assign(s): return ast.Assignment(s[0].getstr(), s[2])
def p_expression_assignment(self, parse): ''' expression : ID ASSIGN expression ''' parse[0] = AST.Assignment(AST.Object(name=parse[1]), expression=parse[3])
def p_expression_assignment(self, parse): """ expression : ID ASSIGN expression """ parse[0] = AST.Assignment(AST.Object(name=parse[1]), expr=parse[3])
def assign(p): assert p[0].gettokentype() == "ID" return ast.Assignment(ast.IdentifierReference(p[0].getstr()), p[2])
def parse(self, parser, tokens, left): tokens.consume_expected('ASSIGN') right = Expression().parse(parser, tokens) tokens.consume_expected('NEWLINE') return ast.Assignment(left, right)