def visit_Compare(self, node): # cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn print(" in MyTransformer.visit_Compare()") print(" node =", node) print(" op =", node.ops[0]) curr_op = node.ops[0] comp_negate = curr_op rand_num = random.randint(1, 10) if rand_num >= 7: print(" negating...") if isinstance(curr_op, ast.Eq): comp_negate = ast.NotEq() elif isinstance(curr_op, ast.NotEq): comp_negate = ast.Eq() elif isinstance(curr_op, ast.Lt): comp_negate = ast.GtE() elif isinstance(curr_op, ast.LtE): comp_negate = ast.Gt() elif isinstance(curr_op, ast.Gt): comp_negate = ast.LtE() elif isinstance(curr_op, ast.GtE): comp_negate = ast.Lt() elif isinstance(curr_op, ast.Is): comp_negate = ast.IsNot() elif isinstance(curr_op, ast.IsNot): comp_negate = ast.Is() elif isinstance(curr_op, ast.In): comp_negate = ast.NotIn() elif isinstance(curr_op, ast.NotIn): comp_negate = ast.In() else: comp_negate = ast.Eq() else: print(" mixing up...") if isinstance(curr_op, ast.Lt): comp_negate = ast.LtE() elif isinstance(curr_op, ast.LtE): comp_negate = ast.And() elif isinstance(curr_op, ast.Gt): comp_negate = ast.Or() elif isinstance(curr_op, ast.GtE): comp_negate = ast.Gt() elif isinstance(curr_op, ast.Is): comp_negate = ast.Gt() elif isinstance(curr_op, ast.IsNot): comp_negate = ast.Lt() elif isinstance(curr_op, ast.In): comp_negate = ast.In( ) #leave the same for for loops (for x in this) elif isinstance(curr_op, ast.NotIn): comp_negate = ast.Lt() else: comp_negate = ast.Eq() print(" new comparator =", comp_negate) # create negated node | Compare(expr left, cmpop* ops, expr* comparators) new_node = node new_node.ops = [comp_negate] ast.copy_location(new_node, node) ast.fix_missing_locations(new_node) return new_node
def visit_Compare(self, node): self.generic_visit(node) self.binop_count += 1 if (self.binop_count == self.count_of_node_to_mutate): new_node = copy.deepcopy(node) print('IN COMPARE') print('THIS IS THE PREVIOUS OP', node.ops) for (i, op) in enumerate(node.ops): if (isinstance(op, ast.Gt)): num = random.randint(0, 2) if num == 0: new_node.ops[i] = ast.GtE() if num == 1: new_node.ops[i] = ast.LtE() if num == 2: new_node.ops[i] = ast.Lt() if (isinstance(op, ast.GtE)): num = random.randint(0, 2) if num == 0: new_node.ops[i] = ast.Gt() if num == 1: new_node.ops[i] = ast.Lt() if num == 2: new_node.ops[i] = ast.LtE() if (isinstance(op, ast.Lt)): num = random.randint(0, 2) if num == 0: new_node.ops[i] = ast.LtE() if num == 1: new_node.ops[i] = ast.GtE() if num == 2: new_node.ops[i] = ast.Gt() if (isinstance(op, ast.LtE)): num = random.randint(0, 2) if num == 0: new_node.ops[i] = ast.Lt() if num == 1: new_node.ops[i] = ast.GtE() if num == 2: new_node.ops[i] = ast.Gt() if (isinstance(op, ast.Eq)): new_node.ops[i] = ast.NotEq() if (isinstance(op, ast.NotEq)): new_node.ops[i] = ast.Eq() if (isinstance(op, ast.Is)): new_node.ops[i] = ast.IsNot() if (isinstance(op, ast.IsNot)): new_node.ops[i] = ast.Is() print('THIS IS THE NEW OP', new_node.ops) print('I AM CREATING A NEW NODE HERE', self.binop_count) return new_node return node
def __le__(self, other): if isinstance(other, Expr): comp = ast.Compare(left=self._expr, ops=[ast.LtE()], comparators=[other._expr]) return Expr(comp) elif other is not None: comp = ast.Compare( left=self._expr, ops=[ast.LtE()], comparators=[ast.Constant(value=other)], ) return Expr(comp) else: return False
def visit_Compare(self, node): global visit_count, visit_target visit_count += 1 if (visit_count == visit_target): ##print("Rewrite compare Line: ", node.lineno) if (isinstance(node.ops[0], ast.GtE)): new_node = ast.Compare(left=node.left, ops=[ast.Lt()], comparators=node.comparators) return new_node elif (isinstance(node.ops[0], ast.LtE)): new_node = ast.Compare(left=node.left, ops=[ast.Gt()], comparators=node.comparators) return new_node elif (isinstance(node.ops[0], ast.Gt)): new_node = ast.Compare(left=node.left, ops=[ast.LtE()], comparators=node.comparators) return new_node elif (isinstance(node.ops[0], ast.Lt)): new_node = ast.Compare(left=node.left, ops=[ast.GtE()], comparators=node.comparators) return new_node return node
def visit_Compare(self, node): global number_of_comparisons if (isinstance(node.ops[0], ast.GtE)): new_node = ast.Compare(left=node.left, ops=[ast.Lt()], comparators=node.comparators) number_of_comparisons += 1 elif (isinstance(node.ops[0], ast.LtE)): new_node = ast.Compare(left=node.left, ops=[ast.Gt()], comparators=node.comparators) number_of_comparisons += 1 elif (isinstance(node.ops[0], ast.Gt)): new_node = ast.Compare(left=node.left, ops=[ast.LtE()], comparators=node.comparators) number_of_comparisons += 1 elif (isinstance(node.ops[0], ast.Lt)): new_node = ast.Compare(left=node.left, ops=[ast.GtE()], comparators=node.comparators) number_of_comparisons += 1 return node
def __compare(self, compare): return ast.Compare(left=ast.Attribute(value=ast.Name(id=self.id, ctx=ast.Load()), attr='level', ctx=ast.Load()), ops=[ast.LtE()], comparators=[compare])
def __init__(self, base_node): BaseMutator.__init__(self, base_node) self.original_ops = base_node.ops index_count = 0 for op in base_node.ops: if type(op) in [ast.Gt, ast.GtE, ast.Lt, ast.LtE]: if type(op) is ast.Gt: ops_mutant_Gt = copy.deepcopy(base_node.ops) ops_mutant_Gt[index_count] = ast.GtE() self.mutations.append({"ops": ops_mutant_Gt}) if type(op) is ast.GtE: ops_mutant_GtE = copy.deepcopy(base_node.ops) ops_mutant_GtE[index_count] = ast.Gt() self.mutations.append({"ops": ops_mutant_GtE}) if type(op) is ast.Lt: ops_mutant_Lt = copy.deepcopy(base_node.ops) ops_mutant_Lt[index_count] = ast.LtE() self.mutations.append({"ops": ops_mutant_Lt}) if type(op) is ast.LtE: ops_mutant_LtE = copy.deepcopy(base_node.ops) ops_mutant_LtE[index_count] = ast.Lt() self.mutations.append({"ops": ops_mutant_LtE}) index_count += 1
def to_node(self): if len(self.operator) == 0: return self.left.to_node() else: right_nodes = [] comp_operator = [] for i in range(len(self.right)): right_nodes.append(self.right[i].to_node()) if self.operator[i] in ['<', 'is lower than']: comp_operator.append(ast.Lt()) elif self.operator[i] in ['<=', 'is lower or equal to']: comp_operator.append(ast.LtE()) elif self.operator[i] in ['>', 'is greater than']: comp_operator.append(ast.Gt()) elif self.operator[i] in ['>=', 'is greater or equal to']: comp_operator.append(ast.GtE()) elif self.operator[i] in ['==', 'is equal to']: comp_operator.append(ast.Eq()) elif self.operator[i] in ['!=', 'is different from', 'is not equal to']: comp_operator.append(ast.NotEq()) elif self.operator[i] == 'in': comp_operator.append(ast.In()) elif self.operator[i] == 'not in': comp_operator.append(ast.NotIn()) elif self.operator[i] == 'is': comp_operator.append(ast.Is()) elif self.operator[i] == 'is not': comp_operator.append(ast.IsNot()) else: raise Exception("Unrecognized argument in Comparison") return ast.Compare(left=self.left.to_node(), ops=comp_operator, comparators=right_nodes)
def visit_Compare(self, node): """ For ==, !=, >, >=, <, <= : put the arguments in alphabetical order. Replace >= and <= by > and > is the other value is a number """ self.generic_visit(node) if len(node.ops) != 1: return node if isinstance(node.ops[0], (ast.NotEq, ast.Eq, ast.Gt, ast.GtE, ast.Lt, ast.LtE)): left = ast.dump(node.left, annotate_fields=False) right = ast.dump(node.comparators[0], annotate_fields=False) if left > right: node.left, node.comparators[0] = node.comparators[0], node.left if isinstance(node.ops[0], ast.Gt): node.ops[0] = ast.Lt() elif isinstance(node.ops[0], ast.GtE): node.ops[0] = ast.LtE() elif isinstance(node.ops[0], ast.Lt): node.ops[0] = ast.Gt() elif isinstance(node.ops[0], ast.LtE): node.ops[0] = ast.GtE() if (len(node.comparators) == 1 and isinstance(node.comparators[0], ast.Num)): if isinstance(node.ops[0], ast.LtE): # <= 6 ===> < 7 node.ops[0] = ast.Lt() node.comparators[0].n += 1 elif isinstance(node.ops[0], ast.GtE): # >= 6 ===> > 5 node.ops[0] = ast.Gt() node.comparators[0].n -= 1 return node
def test_visit_Compare(self, get_logger_mock): node = MagicMock() node.left = "left" node.comparators = ["middle", "right"] node.ops = [ast.LtE(), ast.IsNot()] analyzer = ExpressionAnalyzer() self.assertIsNone(analyzer.visit_Compare(node)) self.assertEqual( analyzer.parts, ["left", " ", "<=", " ", "middle", " ", "is not", " ", "right"], ) node.ops = [ast.LtE(), ast.Import] analyzer = ExpressionAnalyzer() self.assertIsNone(analyzer.visit_Compare(node)) self.assertEqual( analyzer.parts, ["left", " ", "<=", " ", "middle", " ", "...", " ", "right"]) get_logger_mock().warning.assert_called_once_with(ANY)
def with_guard(node, lowest, highest): if lowest is None: # sys.version_info <= highest assert highest is not None condition = ast.Compare(_SYS_VERSION, [ast.LtE()], [ast.Constant(highest)]) elif highest is None: # sys.version_info >= highest assert lowest is not None condition = ast.Compare(_SYS_VERSION, [ast.GtE()], [ast.Constant(lowest)]) else: # lowest <= sys.version_info <= highest condition = ast.Compare( ast.Constant(lowest), [ast.LtE()] * 2, [_SYS_VERSION, ast.Constant(highest)], ) return ast.If(condition, body=[node], orelse=[])
def 比较(片段): 对照表 = { '>': ast.Gt(), '>=': ast.GtE(), '<': ast.Lt(), '<=': ast.LtE(), '==': ast.Eq(), '!=': ast.NotEq(), '===': ast.Is(), '!==': ast.IsNot() } return 语法树.比较(前项=片段[0], 操作符=对照表[片段[1].getstr()], 后项=片段[2], 片段=片段)
def Random_Compare(self): random_int = random.randint(0, 5) if random_int == 0: return ast.Eq() elif random_int == 1: return ast.NotEq() elif random_int == 2: return ast.Gt() elif random_int == 3: return ast.Lt() elif random_int == 4: return ast.GtE() else: return ast.LtE()
def undoReverse(a): tmp = None if type(a) == ast.Lt: tmp = ast.Gt() elif type(a) == ast.LtE: tmp = ast.GtE() elif type(a) == ast.Gt: tmp = ast.Lt() elif type(a) == ast.GtE: tmp = ast.LtE() else: return a transferMetaData(a, tmp) return tmp
class BinaryInfixOperand(object): n_terms = 2 assoc = 'LEFT' keyword_aliases = _kw( (['and', '&&'], ast.And()), (['or', '||'], ast.Or()), (['<', 'lt'], ast.Lt()), (['==', 'eq'], ast.Eq()), (['<=', 'le'], ast.LtE()), (['!=', 'ne'], ast.NotEq()), (['>=', 'ge'], ast.GtE()), (['>', 'gt'], ast.Gt()), ) def __init__(self, tokens): tokens = tokens[0] if len(tokens) % 2 == 1: self.op_token = tokens[1] self.comparators = tokens[::2] else: err = "Invalid number of infix expressions: {}" err = err.format(len(tokens)) raise ParseException(err) assert self.op_token in self.keyword_aliases # Check for too many literals and not enough keywords op = self.keyword_aliases[self.op_token] if isinstance(op, ast.boolop): if any(isinstance(c, Literal) for c in self.comparators): raise ValueError("Cannot use literals as truth") else: if all(isinstance(c, Literal) for c in self.comparators): raise ValueError("Cannot compare literals.") def ast(self): op = self.keyword_aliases[self.op_token] if isinstance(op, ast.boolop): # and and or use one type of AST node value = ast.BoolOp(op=op, values=[e.ast() for e in self.comparators]) else: # remaining operators use another value = ast.Compare( left=self.comparators[0].ast(), ops=[op], comparators=[e.ast() for e in self.comparators[1:]]) return value
def p_comp_op(p): '''comp_op : ">" | "<" | OP_EQ | OP_GE | OP_LE | OP_NE | OP_NNE | TAG_IN | TAG_NOT TAG_IN | TAG_IS | TAG_IS TAG_NOT''' if len(p) == 2: if p.get_item(1).type == 'OP_EQ': p[0] = ast.Eq() elif p.get_item(1).type == '>': p[0] = ast.Gt() elif p.get_item(1).type == '<': p[0] = ast.Lt() elif p.get_item(1).type == 'OP_GE': p[0] = ast.GtE() elif p.get_item(1).type == 'OP_LE': p[0] = ast.LtE() elif p.get_item(1).type == 'OP_NE': p[0] = ast.NotEq() elif p.get_item(1).type == 'OP_NNE': p[0] = ast.NotEq() elif p[1] == 'is': p[0] = ast.Is() elif p[1] == 'in': p[0] = ast.In() elif len(p) == 3: if p[1] == 'is': p[0] = ast.IsNot() elif p[1] == 'not': p[0] = ast.NotIn() return
def mutate(cls, node): if node not in config.visited_nodes: if node.__class__ in [ ast.Eq, ast.NotEq, ast.Lt, ast.Gt, ast.LtE, ast.GtE ]: if node.__class__ in config.comparison_operators: config.comparison_operators.remove(node.__class__) while len(config.comparison_operators) > 0: original_node = deepcopy(node) parent = config.parent_dict[node] del config.parent_dict[node] node_type = config.comparison_operators.pop() if node_type is ast.Eq: node = ast.Eq() elif node_type is ast.NotEq: node = ast.NotEq() elif node_type is ast.Lt: node = ast.Lt() elif node_type is ast.Gt: node = ast.Gt() elif node_type is ast.LtE: node = ast.LtE() elif node_type is ast.GtE: node = ast.GtE() else: print "TypeError in AOR" config.parent_dict[node] = parent config.node_pairs[node] = original_node config.current_mutated_node = node config.mutated = True return node if len(config.arithmetic_operators) == 0: config.arithmetic_operators = [ ast.Eq, ast.NotEq, ast.Lt, ast.Gt, ast.LtE, ast.GtE ] config.visited_nodes.add(node) return node
def _revert_compare(node): """ Helper function to revert a compare node to its negation. """ rev_node = copy.deepcopy(node) op = rev_node.ops[0] if isinstance(op, ast.Is): rev_node.ops = [ast.IsNot()] elif isinstance(op, ast.Gt): rev_node.ops = [ast.LtE()] elif isinstance(op, ast.Lt): rev_node.ops = [ast.GtE()] elif isinstance(op, ast.Eq): rev_node.ops = [ast.NotEq()] elif isinstance(op, ast.In): rev_node.ops = [ast.NotIn()] else: raise ConstraintError('Unknown operator: %s' % op) return rev_node
def branch_dist_boolop(op, values, args): if len(values) == 1: return branch_dist(values[0], args) else: return ast.Call(func=ast.Lambda( args=ast.arguments( args=[ast.arg(arg=args.lambda_arg, annotation=None)], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=ast.IfExp(test=ast.Compare( left=ast.Name(id=args.lambda_arg), ops=[ast.Gt() if isinstance(op, ast.And) else ast.LtE()], comparators=[ast.Num(n=0)]), body=ast.Name(id=args.lambda_arg), orelse=branch_dist_boolop(op, values[1:], args))), args=[branch_dist(values[0], args)], keywords=[])
def resolve_value(value, scope): if isinstance(value, EId): node = ast.Name(id=value.v, ctx=ast.Load()) elif isinstance(value, EInt): node = ast.Num(n=value.v) elif isinstance(value, EList): lst = [resolve_value(a, scope) for a in value.v] node = ast.List(elts=lst, ctx=ast.Load()) elif isinstance(value, EOp): lft, rgt = value.v lft = resolve_value(lft, scope) rgt = resolve_value(rgt, scope) operators = { '+': ast.Add(), '-': ast.Sub(), '*': ast.Mult(), '/': ast.Div(), '%': ast.Mod(), } node = ast.BinOp(left=lft, right=rgt, op=operators[value.t]) elif isinstance(value, ECompare): lft, rgt = value.v lft = resolve_value(lft, scope) rgt = resolve_value(rgt, scope) operators = { '<': ast.Lt(), '>': ast.Gt(), '<=': ast.LtE(), '>=': ast.GtE(), '==': ast.Eq(), } node = ast.Compare(left=lft, ops=[operators[value.t]], comparators=[rgt]) return ast.fix_missing_locations(node)
def p_expr_compare(self, p): '''expr : expr EQUALITY expr | expr INEQUALITY expr | expr LESSTHAN expr | expr GREATERTHAN expr | expr LESSTHANOREQUAL expr | expr GREATERTHANOREQUAL expr ''' op = None if p[2] == '==': op = ast.Eq() elif p[2] == '!=': op = ast.NotEq() elif p[2] == '<': op = ast.Lt() elif p[2] == '>': op = ast.Gt() elif p[2] == '<=': op = ast.LtE() elif p[2] == '>=': op = ast.GtE() p[0] = ast.Compare(left=p[1], ops=[op], comparators=[p[3]])
def neg(pred): ops = pred.ops[0] if type(ops) == ast.Eq: pred.ops[0] = ast.NotEq() return pred elif type(ops) == ast.NotEq: pred.ops[0] = ast.Eq() return pred elif type(ops) == ast.Lt: pred.ops[0] = ast.GtE() return pred elif type(ops) == ast.Gt: pred.ops[0] = ast.LtE() return pred elif type(ops) == ast.LtE: pred.ops[0] = ast.Gt() return pred elif type(ops) == ast.GtE: pred.ops[0] = ast.Lt() return pred else: print('%s Not Supported' % type(ops).__name__) exit(1)
def create_boolean_entity_node(self, boolean_entity): left_node = self.to_node(boolean_entity.left) if boolean_entity.operator is None: return left_node elif boolean_entity.operator in ['==', 'is equal to']: python_cmp_op = ast.Eq() elif boolean_entity.operator in [ '!=', 'is not equal to', 'is different from' ]: python_cmp_op = ast.NotEq() elif boolean_entity.operator in ['>', 'is greater than']: python_cmp_op = ast.Gt() elif boolean_entity.operator in ['>=', 'is greater or equal to']: python_cmp_op = ast.GtE() elif boolean_entity.operator in ['<', 'is lower than']: python_cmp_op = ast.Lt() elif boolean_entity.operator in ['<=', 'is lower or equal to']: python_cmp_op = ast.LtE() else: raise right_node = self.to_node(boolean_entity.right) return ast.Compare(left_node, (python_cmp_op, ), (right_node, ))
def parse_lookup(ast_state, l): assert isinstance(l, dict) assert set(l.keys()) >= set(('key', 'op', 'table')) key = ast_value(ast_state, l['key']) # only support >=, <= for now assert l['op'] in ['>=', '<='] op = ast.GtE() if l['op'] == '>=' else ast.LtE() default = ast_value(ast_state, l.get('default')) table = l['table'] assert isinstance(table, list) expr = default for entry in reversed(table): assert isinstance(entry, list) assert len(entry) == 2 output, cond = entry test = ast.Compare(key, [op], [ast_value(ast_state, cond)]) expr = ast.IfExp(test, ast_value(ast_state, output), expr) return expr
def compare_action(s, loc, tokens): node = tokens[0] ops = [] comparators = [] for op_char, right in tokens[1:]: if op_char == '==': ops.append(ast.Eq()) elif op_char == '<': ops.append(ast.Lt()) elif op_char == '<=': ops.append(ast.LtE()) elif op_char == '>': ops.append(ast.Gt()) elif op_char == '>=': ops.append(ast.GtE()) else: # != ops.append(ast.NotEq) comparators.append(right) if len(ops) > 0: node = ast.Compare(left=node, ops=ops, comparators=comparators) return node
def branch_dist_comp(test, args): if isinstance(test.ops[0], ast.Eq): op_type = 0 br_dist = ast.Call(func=ast.Name(id='abs'), args=[ ast.BinOp(left=test.left, op=ast.Sub(), right=test.comparators[0]) ], keywords=[], starags=None, kwargs=None) elif isinstance(test.ops[0], ast.NotEq): op_type = 1 br_dist = ast.UnaryOp(op=ast.USub(), operand=ast.Call( func=ast.Name(id='abs'), args=[ ast.BinOp(left=test.left, op=ast.Sub(), right=test.comparators[0]) ], keywords=[], starags=None, kwargs=None)) elif isinstance(test.ops[0], ast.Lt): op_type = 1 br_dist = ast.BinOp(left=test.left, op=ast.Sub(), right=test.comparators[0]) elif isinstance(test.ops[0], ast.LtE): op_type = 0 br_dist = ast.BinOp(left=test.left, op=ast.Sub(), right=test.comparators[0]) elif isinstance(test.ops[0], ast.Gt): op_type = 1 br_dist = ast.BinOp(left=test.comparators[0], op=ast.Sub(), right=test.left) elif isinstance(test.ops[0], ast.GtE): op_type = 0 br_dist = ast.BinOp(left=test.comparators[0], op=ast.Sub(), right=test.left) return ast.Call(func=ast.Lambda( args=ast.arguments( args=[ast.arg(arg=args.lambda_arg, annotation=None)], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=ast.IfExp(test=ast.Compare( left=ast.Name(id=args.lambda_arg), ops=[ast.LtE() if op_type == 0 else ast.Lt()], comparators=[ast.Num(n=0)]), body=ast.Name(id=args.lambda_arg), orelse=ast.BinOp(left=ast.Name(id=args.lambda_arg), op=ast.Add(), right=ast.Num(args.k)))), args=[br_dist], keywords=[])
def find_if(body, parent, args, reach): try: for field in body._fields: find_if(getattr(body, field), parent, args, reach) except AttributeError: if isinstance(body, list): ind = 0 while ind in range(len(body)): line = body[ind] if isinstance(line, ast.Return): reach = False elif isinstance(line, ast.If) or isinstance(line, ast.While): node = branch_dist(line.test, args) new_branch = branch(parent, line.lineno, reach) # Assign branch distance to temporary variable body.insert( ind, ast.Assign(targets=[ast.Name(id=args.temp_name)], value=node)) # Print branch_id, op_type, branch distance in order body.insert( ind + 1, ast.Expr(value=ast.Call( func=ast.Attribute(value=ast.Name( id=args.file_name), attr='write'), args=[ ast.Call(func=ast.Attribute( value=ast.Str(s='{} {}\n'), attr='format'), args=[ ast.Num(n=new_branch.ind), ast.Name(id=args.temp_name) ], keywords=[], starargs=None, kwargs=None) ], keywords=[], starargs=None, kwargs=None))) line.test = ast.Compare(left=ast.Name(id=args.temp_name), ops=[ast.LtE()], comparators=[ast.Num(n=0)]) if isinstance(line, ast.While): line.body.append(body[ind]) line.body.append(body[ind + 1]) find_if(line.body, new_branch.ind, args, reach) find_if(line.orelse, -new_branch.ind, args, reach) ind += 2 else: find_if(line, parent, args, reach) ind += 1
def ast(self): return ast.Compare(left=self._center.ast(), ops=[ast.LtE(), ast.LtE()], comparators=[self._from.ast(), self._to.ast()])
def as_ast(dct): """See https://docs.python.org/2/library/ast.html""" if dct['ast_type'] == "Module": return ast.Module(dct["body"]) elif dct['ast_type'] == "Interactive": return ast.Interactive(dct["body"]) elif dct['ast_type'] == "Expression": return ast.Expression(dct["body"]) elif dct['ast_type'] == "Suite": return ast.Suite(dct["body"]) elif dct['ast_type'] == "FunctionDef": return ast.FunctionDef(dct["name"], dct["args"], dct["body"], dct["decorator_list"]) elif dct['ast_type'] == "ClassDef": return ast.ClassDef(dct["name"], dct["bases"], dct["body"], dct["decorator_list"]) elif dct['ast_type'] == "Return": return ast.Return(dct["value"]) elif dct['ast_type'] == "Delete": return ast.Delete(dct["targets"]) elif dct['ast_type'] == "Assign": return ast.Assign(dct["targets"], dct["value"]) elif dct['ast_type'] == "AugAssign": return ast.AugAssign(dct["target"], dct["op"], dct["value"]) elif dct['ast_type'] == "Print": return ast.Print(dct["dest"], dct["values"], dct["nl"]) elif dct['ast_type'] == "For": return ast.For(dct["target"], dct["iter"], dct["body"], dct["orelse"]) elif dct['ast_type'] == "While": return ast.While(dct["test"], dct["body"], dct["orelse"]) elif dct['ast_type'] == "If": return ast.If(dct["test"], dct["body"], dct["orelse"]) elif dct['ast_type'] == "With": return ast.With(dct["context_expr"], dct["optional_vars"], dct["body"]) elif dct['ast_type'] == "Raise": return ast.Raise(dct["type"], dct["inst"], dct["tback"]) elif dct['ast_type'] == "TryExcept": return ast.TryExcept(dct["body"], dct["handlers"], dct["orelse"]) elif dct['ast_type'] == "TryFinally": return ast.TryFinally(dct["body"], dct["finalbody"]) elif dct['ast_type'] == "Assert": return ast.Assert(dct["test"], dct["msg"]) elif dct['ast_type'] == "Import": return ast.Import(dct["names"]) elif dct['ast_type'] == "ImportFrom": return ast.ImportFrom(dct["module"], dct["names"], dct["level"]) elif dct['ast_type'] == "Exec": return ast.Exec(dct["body"], dct["globals"], dct["locals"]) elif dct['ast_type'] == "Global": return ast.Global(dct["names"]) elif dct['ast_type'] == "Expr": return ast.Expr(dct["value"]) elif dct['ast_type'] == "Pass": return ast.Pass() elif dct['ast_type'] == "Break": return ast.Break() elif dct['ast_type'] == "Continue": return ast.Continue() elif dct['ast_type'] == "BoolOp": return ast.BoolOp(dct["op"], dct["values"]) elif dct['ast_type'] == "BinOp": return ast.BinOp(dct["left"], dct["op"], dct["right"]) elif dct['ast_type'] == "UnaryOp": return ast.UnaryOp(dct["op"], dct["operand"]) elif dct['ast_type'] == "Lambda": return ast.Lambda(dct["args"], dct["body"]) elif dct['ast_type'] == "IfExp": return ast.IfExp(dct["test"], dct["body"], dct["orelse"]) elif dct['ast_type'] == "Dict": return ast.Dict(dct["keys"], dct["values"]) elif dct['ast_type'] == "Set": return ast.Set(dct["elts"]) elif dct['ast_type'] == "ListComp": return ast.ListComp(dct["elt"], dct["generators"]) elif dct['ast_type'] == "SetComp": return ast.SetComp(dct["elt"], dct["generators"]) elif dct['ast_type'] == "DictComp": return ast.DictComp(dct["key"], dct["value"], dct["generators"]) elif dct['ast_type'] == "GeneratorExp": return ast.GeneratorExp(dct["elt"], dct["generators"]) elif dct['ast_type'] == "Yield": return ast.Yield(dct["value"]) elif dct['ast_type'] == "Compare": return ast.Compare(dct["left"], dct["ops"], dct["comparators"]) elif dct['ast_type'] == "Call": return ast.Call(dct["func"], dct["args"], dct["keywords"], dct["starargs"], dct["kwargs"]) elif dct['ast_type'] == "Repr": return ast.Repr(dct["value"]) elif dct['ast_type'] == "Num": return ast.Num(dct["n"]) elif dct['ast_type'] == "Str": # Converting to ASCII return ast.Str(dct["s"].encode('ascii', 'ignore')) elif dct['ast_type'] == "Attribute": return ast.Attribute(dct["value"], dct["attr"], dct["ctx"]) elif dct['ast_type'] == "Subscript": return ast.Subscript(dct["value"], dct["slice"], dct["ctx"]) elif dct['ast_type'] == "Name": return ast.Name(dct["id"], dct["ctx"]) elif dct['ast_type'] == "List": return ast.List(dct["elts"], dct["ctx"]) elif dct['ast_type'] == "Tuple": return ast.Tuple(dct["elts"], dct["ctx"]) elif dct['ast_type'] == "Load": return ast.Load() elif dct['ast_type'] == "Store": return ast.Store() elif dct['ast_type'] == "Del": return ast.Del() elif dct['ast_type'] == "AugLoad": return ast.AugLoad() elif dct['ast_type'] == "AugStore": return ast.AugStore() elif dct['ast_type'] == "Param": return ast.Param() elif dct['ast_type'] == "Ellipsis": return ast.Ellipsis() elif dct['ast_type'] == "Slice": return ast.Slice(dct["lower"], dct["upper"], dct["step"]) elif dct['ast_type'] == "ExtSlice": return ast.ExtSlice(dct["dims"]) elif dct['ast_type'] == "Index": return ast.Index(dct["value"]) elif dct['ast_type'] == "And": return ast.And() elif dct['ast_type'] == "Or": return ast.Or() elif dct['ast_type'] == "Add": return ast.Add() elif dct['ast_type'] == "Sub": return ast.Sub() elif dct['ast_type'] == "Mult": return ast.Mult() elif dct['ast_type'] == "Div": return ast.Div() elif dct['ast_type'] == "Mod": return ast.Mod() elif dct['ast_type'] == "Pow": return ast.Pow() elif dct['ast_type'] == "LShift": return ast.LShift() elif dct['ast_type'] == "RShift": return ast.RShift() elif dct['ast_type'] == "BitOr": return ast.BitOr() elif dct['ast_type'] == "BitXor": return ast.BitXor() elif dct['ast_type'] == "BitAnd": return ast.BitAnd() elif dct['ast_type'] == "FloorDiv": return ast.FloorDiv() elif dct['ast_type'] == "Invert": return ast.Invert() elif dct['ast_type'] == "Not": return ast.Not() elif dct['ast_type'] == "UAdd": return ast.UAdd() elif dct['ast_type'] == "USub": return ast.USub() elif dct['ast_type'] == "Eq": return ast.Eq() elif dct['ast_type'] == "NotEq": return ast.NotEq() elif dct['ast_type'] == "Lt": return ast.Lt() elif dct['ast_type'] == "LtE": return ast.LtE() elif dct['ast_type'] == "Gt": return ast.Gt() elif dct['ast_type'] == "GtE": return ast.GtE() elif dct['ast_type'] == "Is": return ast.Is() elif dct['ast_type'] == "IsNot": return ast.IsNot() elif dct['ast_type'] == "In": return ast.In() elif dct['ast_type'] == "NotIn": return ast.NotIn() elif dct['ast_type'] == "comprehension": return ast.comprehension(dct["target"], dct["iter"], dct["ifs"]) elif dct['ast_type'] == "ExceptHandler": return ast.ExceptHandler(dct["type"], dct["name"], dct["body"]) elif dct['ast_type'] == "arguments": return ast.arguments(dct["args"], dct["vararg"], dct["kwarg"], dct["defaults"]) elif dct['ast_type'] == "keyword": return ast.keyword(dct["arg"], dct["value"]) elif dct['ast_type'] == "alias": return ast.alias(dct["name"], dct["asname"]) else: return dct
def __init__(self, str, lineno=0): self.value = str self.lineno = lineno op_ast_map = { '+': ast.Add(), '-': ast.Sub(), '*': ast.Mult(), '/': ast.Div(), '%': ast.Mod(), '**': ast.Pow(), '<<': ast.LShift(), '>>': ast.RShift(), '|': ast.BitOr(), '^^': ast.BitXor(), '&&': ast.BitAnd(), '//': ast.FloorDiv(), '==': ast.Eq(), '!=': ast.NotEq(), '<': ast.Lt(), '<=': ast.LtE(), '>': ast.Gt(), '>=': ast.GtE(), 'is': ast.Is(), 'is_not': ast.IsNot(), 'in': ast.In(), 'not_in': ast.NotIn(), 'and': ast.And(), 'or': ast.Or() }