def test_while(self): self.stmt(ast.While(ast.Num(3), [], []), "empty body on While") self.stmt(ast.While(ast.Name("x", ast.Store()), [ast.Pass()], []), "must have Load context") self.stmt(ast.While(ast.Num(3), [ast.Pass()], [ast.Expr(ast.Name("x", ast.Store()))]), "must have Load context")
def test_While(self): got = ast.While(None, self.simple_stmt(), self.simple_stmt()) want = ast.While(None, self.simple_stmt(), []) self.check_transform(got, want) got = ast.While(None, self.fancy_stmts(), self.fancy_stmts()) want = ast.While(None, [self.func], [self.func]) self.check_transform(got, want)
def test_empty_While(self): while_ = ast.While(ast.Num(42), [], []) self._test_empty_body(while_) # An empty 'else' clause should be eliminated. while_else = ast.While(ast.Num(42), [ast.Pass()], [ast.Pass()]) expect = ast.While(ast.Num(42), [ast.Pass()], []) self.check_transform(while_else, expect)
def p_stmt_while(self, p): 'stmt : WHILE expr DO stmt_list END' p[0] = ast.While(test=p[2], body=p[4], orelse=[], lineno=p.lineno(1), col_offset=p.lexpos(1))
def visit_FunctionDef(self, node): self.generic_visit(node) if (self.__depth == 2) and (node.name in self.__to_inject_init): # 注入变量 code_init = '\n'.join(self.__to_inject_init[node.name]) location_patcher = LocationPatcher(node) code_init_ast = location_patcher.visit(ast.parse(code_init)) code_loop = '\n'.join( self.__to_inject_loop[node.name]) # 每个信号或函数注入的语句可能都相同 code_loop_ast = location_patcher.visit(ast.parse(code_loop)) barnum_ast = location_patcher.visit( ast.parse('BarNum = get_current_bar()')) while_node = ast.copy_location( ast.While( body=barnum_ast.body + code_loop_ast.body + node.body, test=ast.copy_location(ast.NameConstant(value=True), node), orelse=[]), node) self.return_to_yield(while_node) node.body = code_init_ast.body + [while_node] # 改变函数签名 node.args.kwonlyargs.append( location_patcher.visit( ast.arg(arg='series_id', annotation=None))) node.args.kw_defaults.append(location_patcher.visit(ast.Str(s='')))
def isl2py_for(n): assert n.get_type() == isl.ast_node_type.for_ for_var = n.for_get_iterator() assert for_var.get_type() == isl.ast_expr_type.id for_var_name = for_var.get_id().name # Initialize loop variable py_asign = pyast.Assign( targets=[pyast.Name(for_var_name, pyast.Store())], value=isl2py_exp(n.for_get_init()), ) # Increment statement py_inc = pyast.AugAssign( target=pyast.Name(for_var_name, pyast.Store()), op=pyast.Add(), value=isl2py_exp(n.for_get_inc()), ) # python loop body py_body = isl2py_ast(n.for_get_body()) + [py_inc] ret = [ py_asign, pyast.While(test=isl2py_exp(n.for_get_cond()), body=py_body, orelse=[]), ] return ret
def astForCFor(funcEnv, stmnt): assert isinstance(stmnt, CForStatement) assert len(stmnt.args) == 3 assert isinstance( stmnt.args[1], CStatement ) # second arg is the check; we must be able to evaluate that # introduce dummy 'if' AST so that we have a scope for the for-loop (esp. the first statement) ifAst = ast.If(body=[], orelse=[], test=ast.Name(id="True", ctx=ast.Load())) funcEnv.pushScope(ifAst.body) cStatementToPyAst(funcEnv, stmnt.args[0]) whileAst = ast.While(body=[], orelse=[], test=ast.Name(id="True", ctx=ast.Load())) ifAst.body.append(whileAst) ifTestAst = ast.If(body=[ast.Pass()], orelse=[ast.Break()]) ifTestAst.test = getAstNode_valueFromObj( funcEnv.globalScope.stateStruct, *astAndTypeForCStatement(funcEnv, stmnt.args[1])) whileAst.body.append(ifTestAst) funcEnv.pushScope(whileAst.body) if stmnt.body is not None: cCodeToPyAstList(funcEnv, stmnt.body) cStatementToPyAst(funcEnv, stmnt.args[2]) funcEnv.popScope() # whileAst / main for-body funcEnv.popScope() # ifAst return ifAst
def _parse_iteration_statement(self, env): """ <iteration_statement> Parses the <iteration_statement> language structure. iteration_statement -> 'while' '(' logical_expressoin ')' statement | 'do' statement 'while' '(' logical_expression ')' """ if self._look.tag == lexer.Tag.WHILE: while_node = ast.While() save_stmt = ast.Statement.Enclosing ast.Statement.Enclosing = while_node self._match(lexer.Tag.WHILE, 'whild') self._match('(') expr = self._parse_logical_expression(env) self._match(')') stmt = self._parse_statement(env) while_node.init(expr, stmt) ast.Statement.Enclosing = save_stmt return while_node else: do_node = ast.Do() save_stmt = ast.Statement.Enclosing ast.Statement.Enclosing = do_node self._match(lexer.Tag.DO, 'do') stmt = self._parse_statement(env) self._match(lexer.Tag.WHILE, 'while') self._match('(') expr = self._parse_logical_expression(env) self._match(')') self._match(';') do_node.init(expr, stmt) ast.Statement.Enclosing = save_stmt return do_node
def visit_While(self, node): self.generic_visit(node) return ast.copy_location(ast.While( test=self.wrap_test(node.test), body=node.body, orelse=node.orelse ), node)
def visit_For(self, node): """ Change iteration into while-yield statements """ # TODO: take care of StopIteration conversion? newnode = node if node in self.analysis.loopsToBeConverted: # For(expr target, expr iter, stmt* body, stmt* orelse) # While(expr test, stmt* body, stmt* orelse) # prepend statement to await a value in the coroutine newbody = [ ast.Assign(targets=[node.target], value=ast.Yield(value=None)) ] + node.body whileNode = ast.While(test=ast.Name(id=self.moreValuesAvailableId, ctx=ast.Load()), body=newbody, orelse=[]) # TODO: what to do with orelse newnode = self._tryExceptGeneratorExit( [whileNode], [self._moreValuesAvailableAssignmentNode('False')]) self.generic_visit(newnode) return ast.copy_location(newnode, node)
def while_to_node(self, while_statement): test_node = self.to_node(while_statement.test) body_node = list( map(lambda stmt: self.to_node(stmt), while_statement.body)) orelse_node = self.orelse_to_node(while_statement.orelse) node = ast.While(test=test_node, body=body_node, orelse=orelse_node) return node
def while_(self): self.expect('while') self.expect('(') cond = self.expression() self.expect(')') body = self.statement() return ast.While(cond, body)
def p_while_stmt(p): '''stmt : WHILE expression body | WHILE expression body ELSE body''' if len(p) == 6: orelse = p[5] else: orelse = [] p[0] = ast.While(p[2], p[3], orelse)
def python_ast(self): ptest = self.test.python_ast() pi = self.instructions.python_ast() # ptest,pi,lineno=self.line,col_offset=self.column last = ast.While(lineno=self.line, col_offset=self.column) last.test = ptest last.body = pi last.orelse = [] return last
def p_while_statement(p): ''' while_statement : WHILE LPAREN expr RPAREN statement ''' if DEBUG: print("\nwhile stmt: ", end="") for i in range(len(p)): print(i, " ", p[i], " ", end="") p[0] = ast.While(p[3], p[5])
def visit_While(self, node): new_body = self.if_exists(node.body, self.visit_list) new_orelse = self.if_exists(node.orelse, self.visit_list) new_test = self.visit(node.test) return_list = self.new_stmts + [ ast.copy_location(ast.While(new_test, new_body, new_orelse), node) ] self.new_stmts.clear() return return_list
def wrap_func_body(self, flat_body): var_ast = ast.Assign() var_ast.targets = [ast.Name(id=self.gotoVarName, ctx=ast.Store())] var_ast.value = ast.Name(id="None", ctx=ast.Load()) main_loop_ast = ast.While(orelse=[]) main_loop_ast.test = ast.Name(id="True", ctx=ast.Load()) main_loop_ast.body = self.handle_body(flat_body) main_loop_ast.body += [ast.Break()] return [var_ast, main_loop_ast]
def to_node(self): test = self.condition.to_node() body = [] for statement in self.body.statement: body.append(statement.to_node()) orelse = [] if self.else_body is not None: for statement in self.else_body.statement: orelse.append(statement.to_node()) return ast.While(test=test, body=body, orelse=orelse)
def compute_whileloop_stmt(self, stmt_iter): if len(self.stmt_cond) == 1: assert(isinstance(self.stmt_cond[0], ast.Assign) and isinstance(self.stmt_cond[0].value, ast.UnaryOp)) negated_break_condition = self.stmt_cond[0].value assert(isinstance(negated_break_condition.op, ast.Not)) break_condition = negated_break_condition.operand loop_stmt = [ast.While(test=break_condition, body=stmt_iter, orelse=[])] + self.stmt_ret else: loop_stmt = self.stmt_cond + [ast.While(test=self.break_condition, body=(stmt_iter + self.stmt_cond), orelse=[])] + self.stmt_ret return loop_stmt
def visit_While(self, node: While, *args, **kwargs) -> C.While: test = self.visit(node.test, *args, **kwargs) body = self.visit(node.body, *args, **kwargs) orelse = self.visit(node.orelse, *args, **kwargs) return C.While( test=test, body=body, orelse=orelse, )
def visitWhile(self, node): #('test', 'body', 'orelse') if node.orelse: raise cast.CError(node, NotImplementedError, "while ... else is not yet allowed in openCL") test = self.visit(node.test) body = list(self.visit_list(node.body)) return ast.While(test, body, None)
def test_break(self): assert self.run([ ast.Assign( [ast_store('i')], ast.Num(0), ), ast.While(ast.Compare(ast_load('i'), [ast.Lt()], [ast.Num(10)]), [ ast.Break(), ], []) ], 'i', int) == 0
def visit_While(self, node): if self.done: return node if self.count != self.selection: self.count += 1 return node self.done = True return ast.While(test=node.test, body=node.body + [node, ast.Break()], orelse=[])
def p_infinite_loop_stmt(t): '''stmt : LOOP suite''' one = ast.Num(1) one.lineno = t.lineno(1) one.col_offset = -1 # XXX suite = t[2] t[0] = ast.While(one, suite, []) t[0].lineno = t.lineno(1) t[0].col_offset = -1 # XXX
def compile_while_expression(self, expr): expr.pop(0) # "while" test = self.compile(expr.pop(0)) return ast.While( test=test, body=self._code_branch([self.compile(x) for x in expr], expr.start_line, expr.start_column), orelse=[], lineno=expr.start_line, col_offset=expr.start_column)
def loop(self, tree): if 'loop' in self.templates: return self.node( tmp='loop', parts={ 'body': expression_block(self, tree), } ) return self.visit(ast.While( test=ast.Constant(value=True), body=tree ))
def p_for_stmt(p): '''stmt : FOR expression body body body | FOR expression body body body ELSE body''' if len(p) == 8: orelse = p[7] else: orelse = [] p[5].extend(p[4]) whilel = ast.While(p[2], p[5], orelse) p[3].append(whilel) p[0] = whilel
def _make_for_loops_while(parent_node, names_in_use): """Converts for loops into while loops. Creates an index variable and a call to the len() function as a test for the while loop. All for loop iterators must be indexable. DOES NOT SUPPOT NONINDEXABLE ITERATORS. Parameters: parent_node: ast node Returns: parent node with updates""" #get every index of for loop objects in the body of parent node. Could be done cleaner with a numpy .where, #but we'd have to import numpy pretty much just for that. try: indices_of_for_loops = list(filter(lambda index: isinstance(parent_node.body[index], ast.For), range(len(parent_node.body)))) except: #node has no body. No for loops in it. return parent_node, names_in_use for for_loop_index in indices_of_for_loops: for_loop = parent_node.body[for_loop_index] #make loop incrementor variable name_incrementor_variable = _new_name('loop_index', names_in_use) names_in_use[name_incrementor_variable] = 1 #make a call to built in len() function with the iterator provided in the for loop len_builtin_function = ast.Name(id='len', ctx=ast.Load) len_function_call = ast.Call(func=len_builtin_function, args=[for_loop.iter], keywords=[]) #test for while loop compare_op = ast.Compare(ast.Name(name_incrementor_variable, ctx=ast.Load), ops=[ast.Lt()], comparators=[len_function_call]) #assign current value of loop to for loop target assign_to_for_loop_target = ast.Assign([for_loop.target], ast.Subscript(for_loop.iter, ast.Index(ast.Name(id=name_incrementor_variable, ctx=ast.Load)))) #increment index variable add_1_to_index_variable = ast.AugAssign(ast.Name(id=name_incrementor_variable), ast.Add(), ast.Num(1)) #construct while loop while_loop_body = [assign_to_for_loop_target] + \ for_loop.body + [add_1_to_index_variable] while_loop = ast.While(test=compare_op, body= while_loop_body, orelse=[]) #replace for with while loop parent_node.body[for_loop_index] = while_loop #insert loop incrementor variabel before while loop and set to 0 parent_node.body.insert(for_loop_index - 1, ast.Assign([ast.Name(id=name_incrementor_variable, ctx=ast.Store)], ast.Num(0))) return parent_node, names_in_use
def visit_While(self, while_stmt: ast.While) -> ActionsT: test, test_actions = self.visit_expr(while_stmt.test) self.loop_cond_actions.append(test_actions) body = self.visit_stmt_list(while_stmt.body) self.loop_cond_actions.pop() body += test_actions # Re-compute loop condition at the end of loop body. if while_stmt.orelse: raise NodeNotSupportedError(while_stmt, "While statement orelse not supported.") result_node = ast.While(test=test, body=body, orelse=[]) return test_actions + [result_node]
def while_loop(self): self.lexer.match("while") condition, statements = self.expr(), [] self.lexer.match(":") self.lexer.match_type(TokenType.EndOfLine) self.lexer.match_type(TokenType.StartOfBlock) while self.lexer.waiting_for_type(TokenType.EndOfBlock): statements.append(self.statement()) self.lexer.next() # Pass through EndOfBlock return ast.While(condition, statements)