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 compare_is(left, right, invert=False):
return ast.Compare(
left=ast.Name(id=left, ctx=ast.Load(), lineno=1, col_offset=0),
ops=[ast.Is() if not invert else ast.IsNot()],
comparators=[ast.Name(id=right, ctx=ast.Load(), lineno=1, col_offset=0)],
lineno=1,
col_offset=0)
def __call__(self, cls, obj: Opt, grammar: typing.Optional["Grammar"],
ctx):
body = []
objName = "parsed"
o = ast.Name(id=objName, ctx=ast.Load())
returnTypes = []
objIsAlt = isinstance(obj, Alt)
if isinstance(obj.child, Ref):
processerFunc = getProcessorFuncNameForARef(obj.child.name, ctx)
retType = getReturnTypeForARef(obj.child.name, ctx)
fe = ast.Name(id=objName, ctx=ast.Load())
body.append(
ast.If(
test=ast.Compare(left=fe,
ops=[ast.IsNot()],
comparators=[ASTNone]),
body=[
ast.Return(value=ast.Call(
func=processerFunc,
args=[fe],
keywords=[],
))
],
orelse=[],
))
returnTypes.append(retType)
else:
raise NotImplementedError(
"For compatibility each suff that is `opt`ed must be a `ref`. Otherwise we are unable to process these grammars uniformly for all the supported backends. Please put content of "
+ ("`" + obj.name if hasattr(obj, "name") else
"the `opt` struct in `" + ctx.currentProdName) +
"` into a separate rule")
ctx.members.append(
ast.FunctionDef(
name="process_" + ctx.currentProdName,
args=ast.arguments(
posonlyargs=[],
args=[
astSelfArg,
ast.arg(arg=objName,
annotation=None,
type_comment=None)
],
vararg=None,
kwonlyargs=[],
kw_defaults=[],
kwarg=None,
defaults=[],
),
body=body,
decorator_list=[],
returns=genTypingOptional(retType),
type_comment=None,
))
def _makeIfNotNone(name, lineno=1, indent=""):
left = ast.Name(id=name, lineno=lineno, col_offset=len(f"{indent}if "), ctx=ast.Load())
right = ast.NameConstant(value=None, lineno=lineno, col_offset=len(f"{indent}if {name} is not "))
isnot = ast.IsNot(lineno=lineno, col_offset=len(f"{indent}if {name}"))
test = ast.Compare(left, [isnot], [right], lineno=lineno, col_offset=len(f"{indent}if {name} "))
ifstmt = ast.If(test=test, body=[], orelse=[], lineno=lineno, col_offset=len(indent))
return ifstmt
def visit_Name(self, name):
# Check if the name is local or not.
locs = ast.Call(self.builtin("locals"), [], [], None, None)
globs = ast.Call(self.builtin("globals"), [], [], None, None)
ops = [ast.In(), ast.IsNot()]
test = ast.Compare(ast.Str(name.id), ops, [locs, globs])
expr = ast.IfExp(test, self.display(name), ast.Str(name.id))
return name, self.explanation_param(expr)
def ast(self):
pattern = self.tokens[2].ast()
string = self.tokens[0].ast()
return ast.Compare(
left=ast.Call(func=ast.Attribute(value=RE_MODULE, attr='match',
ctx=ast.Load()),
args=[pattern, string], keywords=[], starargs=None,
kwargs=None),
ops=[ast.IsNot()], comparators=[ast.Name(id='None', ctx=ast.Load())]
)
def missingCheck(check: ast.Compare, el: ast.Subscript,
default: bool) -> ast.BoolOp:
"""Creates AST nodes corresponding to check whether the `el` is None, if it is returns `default`"""
return ast.BoolOp(op=(ast.Or() if default else ast.And()),
values=[
ast.Compare(
left=el,
ops=[(ast.Is() if default else ast.IsNot())],
comparators=[noneCnst]), check
])
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_none_assertion(self, assertion: na.NoneAssertion) -> None:
"""
Creates an assertion of form "assert var0 is None" or "assert var0 is not None".
Args:
assertion: the assertion that is visited.
"""
self._nodes.append(
self._create_constant_assert(
assertion.source,
ast.Is() if assertion.value else ast.IsNot(), None))
def 比较(片段):
对照表 = {
'>': ast.Gt(),
'>=': ast.GtE(),
'<': ast.Lt(),
'<=': ast.LtE(),
'==': ast.Eq(),
'!=': ast.NotEq(),
'===': ast.Is(),
'!==': ast.IsNot()
}
return 语法树.比较(前项=片段[0], 操作符=对照表[片段[1].getstr()], 后项=片段[2], 片段=片段)
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 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 to_ast(self):
call_func = ast_mod.Attribute(value=ast_mod.Name(id=self.module,
ctx=ast_mod.Load()),
attr=self.funcdef.name,
ctx=ast_mod.Load())
call = ast_mod.Call(func=call_func, args=self.args, keywords=[])
if self.return_result is None:
ops = [ast_mod.IsNot()]
comparators = [ast_mod.Constant(value=None)]
elif isinstance(self.return_result, nodes.NameConstant):
ops = [ast_mod.Is()]
comparators = [ast_mod.Constant(value=self.return_result.value)]
else:
ops = [ast_mod.Eq()]
comparators = [self.return_result.to_ast()]
return ast_mod.Assert(test=ast_mod.Compare(left=call,
ops=ops,
comparators=comparators),
msg=None)
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 genAlternative(
o: ast.Name, fieldName: str, processerFunc: ast.Attribute
) -> typing.Iterator[typing.Union[ast.Assign, ast.If]]:
fe = ast.Name(id=fieldName, ctx=ast.Load())
yield ast.Assign(
targets=[ast.Name(id=fieldName, ctx=ast.Store())],
value=unifiedGetAttr(o, fieldName),
type_comment=None,
)
yield ast.If(
test=ast.Compare(left=fe, ops=[ast.IsNot()], comparators=[ASTNone]),
body=[
ast.Return(value=ast.Call(
func=processerFunc,
args=[fe],
keywords=[],
))
],
orelse=[],
)
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 visit_CmpOp(self, node: CmpOp, *args, **kwargs) -> C.cmpop:
if node == CmpOp.Eq:
return C.Eq()
elif node == CmpOp.NotEq:
return C.NotEq()
elif node == CmpOp.Lt:
return C.Lt()
elif node == CmpOp.Lte:
return C.Lte()
elif node == CmpOp.Gt:
return C.Gt()
elif node == CmpOp.Gte:
return C.Gte()
elif node == CmpOp.Is:
return C.Is()
elif node == CmpOp.IsNot:
return C.IsNot()
elif node == CmpOp.In:
return C.In()
elif node == CmpOp.NotIn:
return C.NotIn()
else:
raise Exception(f'unknown CmpOp {node!r}')
def comparison(self) -> ast.expr:
left: ast.expr = self.bit_or()
operators: list[ast.cmpop] = []
extra: list[ast.expr] = []
while self.match_(*TokenGroup.SINGLE_COMPARISON, TokenType.NOT):
if self.previous().type == TokenType.IS:
if self.match_(TokenType.NOT):
operator = ast.IsNot()
else:
operator = ast.Is()
elif self.previous().type == TokenType.NOT:
self.consume(TokenType.IN,
"'in' must follow 'not' in comparison.")
operator = ast.NotIn()
else:
operator = COMPARISON_OPERATORS[self.previous().type]()
right = self.bit_or()
operators.append(operator)
extra.append(right)
if operators:
return ast.Compare(left, operators, extra,
**self.get_loc(left, extra[-1]))
else:
return left
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()
}
def visit_ClassDef(self, node):
if len(node.bases) > 1:
raise Exception('Multiple inheritance not supported')
self.visit(FunctionDef(
node.name,
arguments([], None, None, []),
[
ast.If(
ast.UnaryOp(
ast.Not(),
ast_call(
ast_load('isinstance'),
ast_load('this'),
ast_load('arguments.callee'),
)
),
[
ast.Return(
ast_call(
ast_load('new'),
ast_load('arguments.callee'),
ast_load('arguments'),
)
)
],
[]
),
ast.Assign(
[ast_store('this.__class__')],
ast_load('arguments.callee')
),
ast.Expr(
ast_call(
ast_load('this.__bind__'),
ast_load('this'),
),
),
ast.If(
ast.Compare(
ast_call(
ast_load('type'),
ast_load('this.__init__'),
),
[ast.IsNot()],
[ast.Str('undefined')],
),
[
ast.Expr(
ast_call(
ast_load('this.__init__.apply'),
ast_load('this'),
ast.Subscript(
ast_load('arguments'),
ast.Index(ast.Num(0)),
ast.Load()
)
)
),
],
[]
)
],
[]
))
self.push(ClassContext(self.stack[-1], node.name))
scope = self.stack[-1].scope
if not node.bases:
scope.prefix.pop()
self.visit(
ast.Assign(
[ast_store('prototype')],
ast.Dict(
[
ast.Str('constructor'),
ast.Str('__mro__')
],
[
ast_load(node.name),
ast.List([ast_load(node.name)], ast.Load())
]
)
)
)
scope.prefix.append('prototype')
self.visit(
ast.Assign(
[ast_store('__bind__')],
FunctionDef(
'',
arguments([ast_load('self')], None, None, []),
[
ast.For(
ast_store('i'),
ast_load('this'),
[
ast.If(
ast.Compare(
ast_call(
ast_load('type'),
ast.Subscript(
ast_load('this'),
ast.Index(ast_load('i')),
ast.Load(),
)
),
[ast.Is()],
[ast.Str('function')]
),
[
ast.Assign(
[ast.Subscript(
ast_load('this'),
ast.Index(ast_load('i')),
ast.Store(),
)],
ast_call(
ast.Attribute(
ast.Subscript(
ast_load('this'),
ast.Index(ast_load('i')),
ast.Load(),
),
'bind',
ast.Load(),
),
ast_load('self'),
ast_load('self'),
)
),
],
[]
)
],
[]
),
],
[]
)
)
)
else:
base = node.bases[0]
self.visit(
ast.Assign(
[ast_store(node.name, 'prototype')],
ast_call(
FunctionDef(
'',
arguments([], None, None, []),
[
ast.Assign(
[ast_store('tmp')],
FunctionDef(
'',
arguments([], None, None, []),
[],
[]
)
),
ast.Assign(
[ast_store('tmp', 'prototype')],
ast.Attribute(base, 'prototype', ast.Load()),
),
ast.Return(
ast_call(
ast_load('new'),
ast_load('tmp'),
)
)
],
[]
),
)
)
)
self.visit(
ast.Assign(
[ast_store(node.name, 'prototype.constructor')],
ast_load(node.name)
)
)
self.visit(
ast.Assign(
[ast_store(node.name, 'prototype.__base__')],
base,
)
)
self.visit(
ast.Assign(
[ast_store(node.name, 'prototype.__mro__')],
ast_call(
ast_load(node.name, 'prototype.__mro__.concat'),
ast_load(node.name),
)
)
)
for stmt in node.body:
self.visit(stmt)
self.pop()
if node.decorator_list:
arg = ast_load(node.name)
for decorator in node.decorator_list:
arg = ast_call(decorator, arg)
self.visit(
ast.Assign(
[ast_store(node.name)],
arg
)
)
def from_phpast(self, node):
if node is None:
return py.Name('None', py.Load(**pos(node)), **pos(node))
if isinstance(node, basestring):
return py.Str(node, **pos(node))
if isinstance(node, (int, float, long)):
return py.Num(node, **pos(node))
if isinstance(node, php.Array):
if node.nodes:
if node.nodes[0].key is not None:
keys = []
values = []
for elem in node.nodes:
keys.append(self.from_phpast(elem.key))
values.append(self.from_phpast(elem.value))
ds = py.Dict(keys, values, **pos(node))
else:
ds = py.List([self.from_phpast(x.value) for x in node.nodes],
py.Load(**pos(node)),
**pos(node))
else:
ds = py.List([], py.Load(**pos(node)), **pos(node))
return py.Call(py.Name('PHPArray', py.Load(**pos(node)), **pos(node)),
[ds],
[], None, None, **pos(node))
if isinstance(node, php.InlineHTML):
args = [py.Str(node.data, **pos(node))]
return py.Call(py.Name('inline_html',
py.Load(**pos(node)),
**pos(node)),
args, [], None, None,
**pos(node))
if isinstance(node, php.Echo):
return py.Call(py.Name('echo', py.Load(**pos(node)),
**pos(node)),
map(self.from_phpast, node.nodes),
[], None, None,
**pos(node))
if isinstance(node, php.Print):
return py.Print(None, [self.from_phpast(node.node)], True, **pos(node))
if isinstance(node, php.Exit):
args = []
if node.expr is not None:
args.append(self.from_phpast(node.expr))
return py.Raise(py.Call(py.Name('SystemExit', py.Load(**pos(node)),
**pos(node)),
args, [], None, None, **pos(node)),
None, None, **pos(node))
if isinstance(node, php.Return):
if len(self.scope_stack) > 0:
# return from function
if node.node is None:
return py.Return(None, **pos(node))
else:
return py.Return(self.from_phpast(node.node), **pos(node))
else:
# return from script
args = [self.from_phpast(node.node)]
return py.Raise(py.Call(py.Name('_GlobalReturn', py.Load(**pos(node)),
**pos(node)),
args, [], None, None, **pos(node)),
None, None, **pos(node))
if isinstance(node, php.Break):
assert node.node is None, 'level on break not supported'
return py.Break(**pos(node))
if isinstance(node, php.Continue):
assert node.node is None, 'level on continue not supported'
return py.Continue(**pos(node))
if isinstance(node, php.Silence):
return self.from_phpast(node.expr)
if isinstance(node, php.Block):
return self.from_phpast(php.If(1, node, [], None, lineno=node.lineno))
if isinstance(node, php.Unset):
return py.Delete(map(self.from_phpast, node.nodes), **pos(node))
if isinstance(node, php.IsSet) and len(node.nodes) == 1:
if isinstance(node.nodes[0], php.ArrayOffset):
return py.Compare(self.from_phpast(node.nodes[0].expr),
[py.In(**pos(node))],
[self.from_phpast(node.nodes[0].node)],
**pos(node))
if isinstance(node.nodes[0], php.ObjectProperty):
return py.Call(py.Name('hasattr', py.Load(**pos(node)),
**pos(node)),
[self.from_phpast(node.nodes[0].node),
self.from_phpast(node.nodes[0].name)],
[], None, None, **pos(node))
if isinstance(node.nodes[0], php.Variable):
variable_name = node.nodes[0].name[1:]
static_name = self.get_static(variable_name)
if static_name:
variable_name = static_name
globs = py.Call(py.Name('globals', py.Load(**pos(node)),
**pos(node)),
[], [], None, None, **pos(node))
locs = py.Call(py.Name('locals', py.Load(**pos(node)),
**pos(node)),
[], [], None, None, **pos(node))
return py.Compare(py.Str(static_name, **pos(node)),
[py.In(**pos(node))],
[py.Call(py.Name('all_vars', py.Load(**pos(node)),
**pos(node)),
[globs, locs], [], None, None, **pos(node))],
**pos(node))
return py.Compare(self.from_phpast(node.nodes[0]),
[py.IsNot(**pos(node))],
[py.Name('None', py.Load(**pos(node)), **pos(node))],
**pos(node))
if isinstance(node, php.Empty):
return self.from_phpast(php.UnaryOp('!',
php.BinaryOp('&&',
php.IsSet([node.expr],
lineno=node.lineno),
node.expr,
lineno=node.lineno),
lineno=node.lineno))
if isinstance(node, php.Assignment):
if (isinstance(node.node, php.ArrayOffset)
and node.node.expr is None):
return py.Call(py.Attribute(self.from_phpast(node.node.node),
'append', py.Load(**pos(node)),
**pos(node)),
[self.from_phpast(node.expr)],
[], None, None, **pos(node))
if (isinstance(node.node, php.ObjectProperty)
and isinstance(node.node.name, php.BinaryOp)):
return to_stmt(py.Call(py.Name('setattr', py.Load(**pos(node)),
**pos(node)),
[from_phpast(node.node.node),
from_phpast(node.node.name),
from_phpast(node.expr)],
[], None, None, **pos(node)))
return py.Assign([store(from_phpast(node.node))],
from_phpast(node.expr),
**pos(node))
if isinstance(node, php.ListAssignment):
return py.Assign([py.Tuple(map(store, map(self.from_phpast, node.nodes)),
py.Store(**pos(node)),
**pos(node))],
self.from_phpast(node.expr),
**pos(node))
if isinstance(node, php.AssignOp):
return self.from_phpast(php.Assignment(node.left,
php.BinaryOp(node.op[:-1],
node.left,
node.right,
lineno=node.lineno),
False,
lineno=node.lineno))
if isinstance(node, (php.PreIncDecOp, php.PostIncDecOp)):
return self.from_phpast(php.Assignment(node.expr,
php.BinaryOp(node.op[0],
node.expr,
1,
lineno=node.lineno),
False,
lineno=node.lineno))
if isinstance(node, php.ArrayOffset):
return py.Subscript(self.from_phpast(node.node),
py.Index(self.from_phpast(node.expr), **pos(node)),
py.Load(**pos(node)),
**pos(node))
if isinstance(node, php.ObjectProperty):
if isinstance(node.name, (php.Variable, php.BinaryOp)):
return py.Call(py.Name('getattr', py.Load(**pos(node)),
**pos(node)),
[self.from_phpast(node.node),
self.from_phpast(node.name)],
[], None, None, **pos(node))
return py.Attribute(self.from_phpast(node.node),
node.name,
py.Load(**pos(node)),
**pos(node))
if isinstance(node, php.Constant):
name = node.name
if name.lower() == 'true': name = 'True'
if name.lower() == 'false': name = 'False'
if name.lower() == 'null': name = 'None'
return py.Name(name, py.Load(**pos(node)), **pos(node))
if isinstance(node, php.Variable):
name = node.name[1:]
static_name = self.get_static(name)
if static_name:
name = static_name
if name == 'this': name = 'self'
return py.Name(name, py.Load(**pos(node)), **pos(node))
from hypothesis import assume
from hypothesis._strategies import booleans
from hypothesis.searchstrategy import SearchStrategy
from hypothesis.strategies import integers, lists, binary, sampled_from, recursive, dictionaries
from hypothesis.strategies import text, composite, one_of, floats, complex_numbers, characters, none
comparison_operators = sampled_from([
ast.Eq(),
ast.NotEq(),
ast.Lt(),
ast.LtE(),
ast.Gt(),
ast.GtE(),
ast.Is(),
ast.IsNot(),
ast.In(),
ast.NotIn()
])
# region: Literals
@composite
def Num(draw) -> ast.AST:
def to_node(n) -> ast.AST:
if isinstance(n, int):
return ast.Num(n) if n >= 0 else ast.UnaryOp(
ast.USub(), ast.Num(abs(n)))
elif isinstance(n, float):
return ast.Num(n) if math.copysign(1.0, n) > 0.0 else ast.UnaryOp(
def is_not(self, left, right):
return ast.Compare(left=to_ast(left),
ops=[ast.IsNot()],
comparators=[to_ast(right)])
def visit_Compare(self, node):
if isinstance(node.ops, ast.LtE):
self.counter += 1
if self.counter == self.nodeToMutate:
new_node = ast.Compare()
new_node.left = node.left
new_node.comparators = node.comparators
new_node.ops = [ast.Gt()]
print('changing lessThanEqual {} to greaterThan.'.format(
self.counter))
return ast.copy_location(new_node, node) # helps debugging
if isinstance(node.ops, ast.GtE):
self.counter += 1
if self.counter == self.nodeToMutate:
new_node = ast.Compare()
new_node.left = node.left
new_node.comparators = node.comparators
new_node.op = [ast.Lt()]
print('changing GTE {} to LT.'.format(self.counter))
return ast.copy_location(new_node, node) # helps debugging
if isinstance(node.ops, ast.Gt):
self.counter += 1
if self.counter == self.nodeToMutate:
new_node = ast.Compare()
new_node.left = node.left
new_node.comparators = node.comparators
new_node.ops = [ast.LtE()]
print('changing GT {} to LtE.'.format(self.counter))
return ast.copy_location(new_node, node) # helps debugging
if isinstance(node.ops, ast.Lt):
self.counter += 1
if self.counter == self.nodeToMutate:
new_node = ast.Compare()
new_node.left = node.left
new_node.comparators = node.comparators
new_node.ops = [ast.GtE()]
print('changing LT {} to GtE.'.format(self.counter))
return ast.copy_location(new_node, node) # helps debugging
if isinstance(node.ops, ast.Eq):
self.counter += 1
if self.counter == self.nodeToMutate:
new_node = ast.Compare()
new_node.left = node.left
new_node.comparators = node.comparators
new_node.ops = [ast.NotEq()]
print('changing eq {} to neq.'.format(self.counter))
return ast.copy_location(new_node, node) # helps debugging
if isinstance(node.ops, ast.NotEq):
self.counter += 1
if self.counter == self.nodeToMutate:
new_node = ast.Compare()
new_node.left = node.left
new_node.comparators = node.comparators
new_node.ops = ast.Eq()
print('changing neq {} to eq.'.format(self.counter))
return ast.copy_location(new_node, node) # helps debugging
if isinstance(node.ops, ast.Is):
self.counter += 1
if self.counter == self.nodeToMutate:
new_node = ast.Compare()
new_node.left = node.left
new_node.comparators = node.comparators
new_node.ops = ast.IsNot()
print('changing is {} to isnot.'.format(self.counter))
return ast.copy_location(new_node, node) # helps debugging
if isinstance(node.ops, ast.IsNot):
self.counter += 1
if self.counter == self.nodeToMutate:
new_node = ast.Compare()
new_node.left = node.left
new_node.comparators = node.comparators
new_node.ops = ast.Is()
print('changing isnot {} to is.'.format(self.counter))
return ast.copy_location(new_node, node) # helps debugging
if isinstance(node.ops, ast.In):
self.counter += 1
if self.counter == self.nodeToMutate:
new_node = ast.Compare()
new_node.left = node.left
new_node.comparators = node.comparators
new_node.ops = ast.NotIn()
print('changing In {} to InNot.'.format(self.counter))
return ast.copy_location(new_node, node) # helps debugging
if isinstance(node.ops, ast.NotIn):
self.counter += 1
if self.counter == self.nodeToMutate:
new_node = ast.Compare()
new_node.left = node.left
new_node.comparators = node.comparators
new_node.ops = ast.In()
print('changing Notin {} to in.'.format(self.counter))
return ast.copy_location(new_node, node) # helps debugging
return self.generic_visit(node)
def from_phpast(node):
if node is None:
return py.Pass(**pos(node))
if isinstance(node, str):
return py.Str(node, **pos(node))
if isinstance(node, (int, float)):
return py.Num(node, **pos(node))
if isinstance(node, php.Array):
if node.nodes:
if node.nodes[0].key is not None:
keys = []
values = []
for elem in node.nodes:
keys.append(from_phpast(elem.key))
values.append(from_phpast(elem.value))
return py.Dict(keys, values, **pos(node))
else:
return py.List([from_phpast(x.value) for x in node.nodes],
py.Load(**pos(node)), **pos(node))
else:
return py.List([], py.Load(**pos(node)), **pos(node))
if isinstance(node, php.InlineHTML):
args = [py.Str(node.data, **pos(node))]
return py.Call(
py.Name('inline_html', py.Load(**pos(node)), **pos(node)), args,
[], None, None, **pos(node))
if isinstance(node, php.Echo):
return py.Call(py.Name('echo', py.Load(**pos(node)), **pos(node)),
list(map(from_phpast, node.nodes)), [], None, None,
**pos(node))
if isinstance(node, php.Print):
return py.Print(None, [from_phpast(node.node)], True, **pos(node))
if isinstance(node, php.Exit):
args = []
if node.expr is not None:
args.append(from_phpast(node.expr))
return py.Raise(
py.Call(py.Name('Exit', py.Load(**pos(node)), **pos(node)), args,
[], None, None, **pos(node)), None, None, **pos(node))
if isinstance(node, php.Return):
if node.node is None:
return py.Return(None, **pos(node))
else:
return py.Return(from_phpast(node.node), **pos(node))
if isinstance(node, php.Break):
assert node.node is None, 'level on break not supported'
return py.Break(**pos(node))
if isinstance(node, php.Continue):
assert node.node is None, 'level on continue not supported'
return py.Continue(**pos(node))
if isinstance(node, php.Silence):
return from_phpast(node.expr)
if isinstance(node, php.Block):
return from_phpast(php.If(1, node, [], None, lineno=node.lineno))
if isinstance(node, php.Unset):
return py.Delete(list(map(from_phpast, node.nodes)), **pos(node))
if isinstance(node, php.IsSet) and len(node.nodes) == 1:
if isinstance(node.nodes[0], php.ArrayOffset):
return py.Compare(from_phpast(node.nodes[0].expr),
[py.In(**pos(node))],
[from_phpast(node.nodes[0].node)], **pos(node))
if isinstance(node.nodes[0], php.ObjectProperty):
return py.Call(
py.Name('hasattr', py.Load(**pos(node)), **pos(node)), [
from_phpast(node.nodes[0].node),
from_phpast(node.nodes[0].name)
], [], None, None, **pos(node))
if isinstance(node.nodes[0], php.Variable):
return py.Compare(py.Str(
node.nodes[0].name[1:], **pos(node)), [py.In(**pos(node))], [
py.Call(py.Name('vars', py.Load(**pos(node)), **pos(node)),
[], [], None, None, **pos(node))
], **pos(node))
return py.Compare(from_phpast(node.nodes[0]), [py.IsNot(**pos(node))],
[py.Name('None', py.Load(**pos(node)), **pos(node))],
**pos(node))
if isinstance(node, php.Empty):
return from_phpast(
php.UnaryOp('!',
php.BinaryOp('&&',
php.IsSet([node.expr],
lineno=node.lineno),
node.expr,
lineno=node.lineno),
lineno=node.lineno))
if isinstance(node, php.Assignment):
if (isinstance(node.node, php.ArrayOffset) and node.node.expr is None):
return py.Call(
py.Attribute(from_phpast(node.node.node), 'append',
py.Load(**pos(node)), **pos(node)),
[from_phpast(node.expr)], [], None, None, **pos(node))
if (isinstance(node.node, php.ObjectProperty)
and isinstance(node.node.name, php.BinaryOp)):
return to_stmt(
py.Call(py.Name('setattr', py.Load(**pos(node)), **pos(node)),
[
from_phpast(node.node.node),
from_phpast(node.node.name),
from_phpast(node.expr)
], [], None, None, **pos(node)))
return py.Assign([store(from_phpast(node.node))],
from_phpast(node.expr), **pos(node))
if isinstance(node, php.ListAssignment):
return py.Assign([
py.Tuple(list(map(store, list(map(from_phpast, node.nodes)))),
py.Store(**pos(node)), **pos(node))
], from_phpast(node.expr), **pos(node))
if isinstance(node, php.AssignOp):
return from_phpast(
php.Assignment(node.left,
php.BinaryOp(node.op[:-1],
node.left,
node.right,
lineno=node.lineno),
False,
lineno=node.lineno))
if isinstance(node, (php.PreIncDecOp, php.PostIncDecOp)):
return from_phpast(
php.Assignment(node.expr,
php.BinaryOp(node.op[0],
node.expr,
1,
lineno=node.lineno),
False,
lineno=node.lineno))
if isinstance(node, php.ArrayOffset):
return py.Subscript(from_phpast(node.node),
py.Index(from_phpast(node.expr), **pos(node)),
py.Load(**pos(node)), **pos(node))
if isinstance(node, php.ObjectProperty):
if isinstance(node.name, (php.Variable, php.BinaryOp)):
return py.Call(
py.Name('getattr', py.Load(**pos(node)), **pos(node)),
[from_phpast(node.node),
from_phpast(node.name)], [], None, None, **pos(node))
return py.Attribute(from_phpast(node.node), node.name,
py.Load(**pos(node)), **pos(node))
if isinstance(node, php.Constant):
name = node.name
if name.lower() == 'true': name = 'True'
if name.lower() == 'false': name = 'False'
if name.lower() == 'null': name = 'None'
return py.Name(name, py.Load(**pos(node)), **pos(node))
if isinstance(node, php.Variable):
name = node.name[1:]
if name == 'this': name = 'self'
return py.Name(name, py.Load(**pos(node)), **pos(node))
if isinstance(node, php.Global):
return py.Global([var.name[1:] for var in node.nodes], **pos(node))
if isinstance(node, php.Include):
once = py.Name('True' if node.once else 'False', py.Load(**pos(node)),
**pos(node))
return py.Call(py.Name('include', py.Load(**pos(node)), **pos(node)),
[from_phpast(node.expr), once], [], None, None,
**pos(node))
if isinstance(node, php.Require):
once = py.Name('True' if node.once else 'False', py.Load(**pos(node)),
**pos(node))
return py.Call(py.Name('require', py.Load(**pos(node)), **pos(node)),
[from_phpast(node.expr), once], [], None, None,
**pos(node))
if isinstance(node, php.UnaryOp):
op = unary_ops.get(node.op)
assert op is not None, "unknown unary operator: '%s'" % node.op
op = op(**pos(node))
return py.UnaryOp(op, from_phpast(node.expr), **pos(node))
if isinstance(node, php.BinaryOp):
if node.op == '.':
pattern, pieces = build_format(node.left, node.right)
if pieces:
return py.BinOp(
py.Str(pattern, **pos(node)), py.Mod(**pos(node)),
py.Tuple(list(map(from_phpast, pieces)),
py.Load(**pos(node)), **pos(node)), **pos(node))
else:
return py.Str(pattern % (), **pos(node))
if node.op in bool_ops:
op = bool_ops[node.op](**pos(node))
return py.BoolOp(op,
[from_phpast(node.left),
from_phpast(node.right)], **pos(node))
if node.op in cmp_ops:
op = cmp_ops[node.op](**pos(node))
return py.Compare(from_phpast(node.left), [op],
[from_phpast(node.right)], **pos(node))
op = binary_ops.get(node.op)
if node.op == 'instanceof':
return py.Call(
func=py.Name(id='isinstance', ctx=py.Load(**pos(node))),
args=[from_phpast(node.left),
from_phpast(node.right)],
keywords=[],
starargs=None,
kwargs=None)
assert op is not None, "unknown binary operator: '%s'" % node.op
op = op(**pos(node))
return py.BinOp(from_phpast(node.left), op, from_phpast(node.right),
**pos(node))
if isinstance(node, php.TernaryOp):
return py.IfExp(from_phpast(node.expr), from_phpast(node.iftrue),
from_phpast(node.iffalse), **pos(node))
if isinstance(node, php.Cast):
return py.Call(
py.Name(casts.get(node.type, node.type), py.Load(**pos(node)),
**pos(node)), [from_phpast(node.expr)], [], None, None,
**pos(node))
if isinstance(node, php.If):
orelse = []
if node.else_:
for else_ in map(from_phpast, deblock(node.else_.node)):
orelse.append(to_stmt(else_))
for elseif in reversed(node.elseifs):
orelse = [
py.If(
from_phpast(elseif.expr),
list(
map(to_stmt,
list(map(from_phpast, deblock(elseif.node))))),
orelse, **pos(node))
]
return py.If(
from_phpast(node.expr),
list(map(to_stmt, list(map(from_phpast, deblock(node.node))))),
orelse, **pos(node))
if isinstance(node, php.For):
assert node.test is None or len(node.test) == 1, \
'only a single test is supported in for-loops'
return from_phpast(
php.Block((node.start or []) + [
php.While(node.test[0] if node.test else 1,
php.Block(deblock(node.node) + (node.count or []),
lineno=node.lineno),
lineno=node.lineno)
],
lineno=node.lineno))
if isinstance(node, php.Foreach):
if node.keyvar is None:
target = py.Name(node.valvar.name[1:], py.Store(**pos(node)),
**pos(node))
else:
target = py.Tuple([
py.Name(node.keyvar.name[1:], py.Store(**pos(node))),
py.Name(node.valvar.name[1:], py.Store(**pos(node)))
], py.Store(**pos(node)), **pos(node))
return py.For(
target, from_phpast(node.expr),
list(map(to_stmt, list(map(from_phpast, deblock(node.node))))), [],
**pos(node))
if isinstance(node, php.While):
return py.While(
from_phpast(node.expr),
list(map(to_stmt, list(map(from_phpast, deblock(node.node))))), [],
**pos(node))
if isinstance(node, php.DoWhile):
condition = php.If(php.UnaryOp('!', node.expr, lineno=node.lineno),
php.Break(None, lineno=node.lineno), [],
None,
lineno=node.lineno)
return from_phpast(
php.While(1,
php.Block(deblock(node.node) + [condition],
lineno=node.lineno),
lineno=node.lineno))
if isinstance(node, php.Try):
return py.TryExcept(
list(map(to_stmt, list(map(from_phpast, node.nodes)))), [
py.ExceptHandler(
py.Name(catch.class_, py.Load(**pos(node)), **pos(node)),
store(from_phpast(catch.var)),
list(map(to_stmt, list(map(from_phpast, catch.nodes)))),
**pos(node)) for catch in node.catches
], [], **pos(node))
if isinstance(node, php.Throw):
return py.Raise(from_phpast(node.node), None, None, **pos(node))
if isinstance(node, php.Function):
args = []
defaults = []
for param in node.params:
args.append(
py.Name(param.name[1:], py.Param(**pos(node)), **pos(node)))
if param.default is not None:
defaults.append(from_phpast(param.default))
body = list(map(to_stmt, list(map(from_phpast, node.nodes))))
if not body: body = [py.Pass(**pos(node))]
return py.FunctionDef(node.name,
py.arguments(args, None, None, defaults), body,
[], **pos(node))
if isinstance(node, php.Method):
args = []
defaults = []
decorator_list = []
if 'static' in node.modifiers:
decorator_list.append(
py.Name('classmethod', py.Load(**pos(node)), **pos(node)))
args.append(py.Name('cls', py.Param(**pos(node)), **pos(node)))
else:
args.append(py.Name('self', py.Param(**pos(node)), **pos(node)))
for param in node.params:
args.append(
py.Name(param.name[1:], py.Param(**pos(node)), **pos(node)))
if param.default is not None:
defaults.append(from_phpast(param.default))
body = list(map(to_stmt, list(map(from_phpast, node.nodes))))
if not body: body = [py.Pass(**pos(node))]
return py.FunctionDef(node.name,
py.arguments(args, None, None, defaults), body,
decorator_list, **pos(node))
if isinstance(node, php.Class):
name = node.name
bases = []
extends = node.extends or 'object'
bases.append(py.Name(extends, py.Load(**pos(node)), **pos(node)))
body = list(map(to_stmt, list(map(from_phpast, node.nodes))))
for stmt in body:
if (isinstance(stmt, py.FunctionDef)
and stmt.name in (name, '__construct')):
stmt.name = '__init__'
if not body: body = [py.Pass(**pos(node))]
return py.ClassDef(name, bases, body, [], **pos(node))
if isinstance(node, (php.ClassConstants, php.ClassVariables)):
assert len(node.nodes) == 1, \
'only one class-level assignment supported per line'
if isinstance(node.nodes[0], php.ClassConstant):
name = php.Constant(node.nodes[0].name, lineno=node.lineno)
else:
name = php.Variable(node.nodes[0].name, lineno=node.lineno)
initial = node.nodes[0].initial
if initial is None:
initial = php.Constant('None', lineno=node.lineno)
return py.Assign([store(from_phpast(name))], from_phpast(initial),
**pos(node))
if isinstance(node, (php.FunctionCall, php.New)):
if isinstance(node.name, str):
name = py.Name(node.name, py.Load(**pos(node)), **pos(node))
else:
name = py.Subscript(
py.Call(py.Name('vars', py.Load(**pos(node)), **pos(node)), [],
[], None, None, **pos(node)),
py.Index(from_phpast(node.name), **pos(node)),
py.Load(**pos(node)), **pos(node))
args, kwargs = build_args(node.params)
return py.Call(name, args, kwargs, None, None, **pos(node))
if isinstance(node, php.MethodCall):
args, kwargs = build_args(node.params)
return py.Call(
py.Attribute(from_phpast(node.node), node.name,
py.Load(**pos(node)), **pos(node)), args, kwargs,
None, None, **pos(node))
if isinstance(node, php.StaticMethodCall):
class_ = node.class_
if class_ == 'self': class_ = 'cls'
args, kwargs = build_args(node.params)
return py.Call(
py.Attribute(py.Name(class_, py.Load(**pos(node)),
**pos(node)), node.name, py.Load(**pos(node)),
**pos(node)), args, kwargs, None, None, **pos(node))
if isinstance(node, php.StaticProperty):
class_ = node.node
name = node.name
if isinstance(name, php.Variable):
name = name.name[1:]
return py.Attribute(py.Name(class_, py.Load(**pos(node)), **pos(node)),
name, py.Load(**pos(node)), **pos(node))
return py.Call(py.Name('XXX', py.Load(**pos(node)),
**pos(node)), [py.Str(str(node), **pos(node))], [],
None, None, **pos(node))
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, ast.Eq, ast.NotEq,
ast.Is, ast.IsNot, ast.In, ast.NotIn
]:
if type(op) is ast.Eq:
ops_mutant_Eq = copy.deepcopy(base_node.ops)
ops_mutant_Eq[index_count] = ast.NotEq()
self.mutations.append({"ops": ops_mutant_Eq})
if type(op) is ast.NotEq:
ops_mutant_NotEq = copy.deepcopy(base_node.ops)
ops_mutant_NotEq[index_count] = ast.Eq()
self.mutations.append({"ops": ops_mutant_NotEq})
if type(op) is ast.LtE:
ops_mutant_LtE = copy.deepcopy(base_node.ops)
ops_mutant_LtE[index_count] = ast.Gt()
self.mutations.append({"ops": ops_mutant_LtE})
if type(op) is ast.GtE:
ops_mutant_GtE = copy.deepcopy(base_node.ops)
ops_mutant_GtE[index_count] = ast.Lt()
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.GtE()
self.mutations.append({"ops": ops_mutant_Lt})
if type(op) is ast.Gt:
ops_mutant_Gt = copy.deepcopy(base_node.ops)
ops_mutant_Gt[index_count] = ast.LtE()
self.mutations.append({"ops": ops_mutant_Gt})
if type(op) is ast.Is:
ops_mutant_Is = copy.deepcopy(base_node.ops)
ops_mutant_Is[index_count] = ast.IsNot()
self.mutations.append({"ops": ops_mutant_Is})
if type(op) is ast.IsNot:
ops_mutant_IsNot = copy.deepcopy(base_node.ops)
ops_mutant_IsNot[index_count] = ast.Is()
self.mutations.append({"ops": ops_mutant_IsNot})
if type(op) is ast.In:
ops_mutant_In = copy.deepcopy(base_node.ops)
ops_mutant_In[index_count] = ast.NotIn()
self.mutations.append({"ops": ops_mutant_In})
if type(op) is ast.NotIn:
ops_mutant_NotIn = copy.deepcopy(base_node.ops)
ops_mutant_NotIn[index_count] = ast.In()
self.mutations.append({"ops": ops_mutant_NotIn})
index_count += 1
Symbol.new("/"): compile_divide,
Symbol.new("//"): compile_floordivide,
Symbol.new("%"): lambda p: ast.BinOp(build_ast(p[1]), ast.Mod(), build_ast(p[2])),
Symbol.new("&"): lambda p: ast.BinOp(build_ast(p[1]), ast.BitAnd(), build_ast(p[2])),
Symbol.new("**"): lambda p: ast.BinOp(build_ast(p[1]), ast.Pow(), build_ast(p[2])),
Symbol.new(">>"): lambda p: ast.BinOp(build_ast(p[1]), ast.RShift(), build_ast(p[2])),
Symbol.new("<<"): lambda p: ast.BinOp(build_ast(p[1]), ast.LShift(), build_ast(p[2])),
Symbol.new("^"): lambda p: ast.BinOp(build_ast(p[1]), ast.BitXor(), build_ast(p[2])),
Symbol.new("<"): lambda p: ast.Compare(build_ast(p[1]), [ast.Lt() for x in p[1::2]], [build_ast(x) for x in p[2::2]]),
Symbol.new(">"): lambda p: ast.Compare(build_ast(p[1]), [ast.Gt() for x in p[1::2]], [build_ast(x) for x in p[2::2]]),
Symbol.new("<="): lambda p: ast.Compare(build_ast(p[1]), [ast.LtE() for x in p[1::2]], [build_ast(x) for x in p[2::2]]),
Symbol.new(">="): lambda p: ast.Compare(build_ast(p[1]), [ast.GtE() for x in p[1::2]], [build_ast(x) for x in p[2::2]]),
Symbol.new("=="): compile_equals,
Symbol.new("!="): lambda p: ast.Compare(build_ast(p[1]), [ast.NotEq() for x in p[1::2]], [build_ast(x) for x in p[2::2]]),
Symbol.new("is"): lambda p: ast.Compare(build_ast(p[1]), [ast.Is() for x in p[1::2]], [build_ast(x) for x in p[2::2]]),
Symbol.new("is-not"): lambda p: ast.Compare(build_ast(p[1]), [ast.IsNot() for x in p[1::2]], [build_ast(x) for x in p[2::2]]),
Symbol.new("define"): compile_define,
Symbol.new("dict-set"): lambda p: ast.Assign([ast.Subscript(build_ast(p[1]), ast.Index(build_ast(p[2])), ast.Store())], build_ast(p[3])),
#Symbol.new("caadr"): lambda p: compiler.ast.Subscript(compiler.ast.Subscript(build_ast(p[1]), 0, compiler.ast.Const(1)), 0, compiler.ast.Const(0)),
Symbol.new("caar"): lambda p: ast.Subscript(ast.Subscript(build_ast(p[1]), ast.Index(ast.Num(0)), ast.Load()), ast.Index(ast.Num(0)), ast.Load()),
#Symbol.new("cadddr"): lambda p: compiler.ast.Subscript(build_ast(p[1]), 0, compiler.ast.Const(3)),
#Symbol.new("caddr"): lambda p: compiler.ast.Subscript(build_ast(p[1]), 0, compiler.ast.Const(2)),
Symbol.new("cadr"): lambda p: ast.Subscript(build_ast(p[1]), ast.Index(ast.Num(1)), ast.Load()),
Symbol.new("car"): lambda p: ast.Subscript(build_ast(p[1]), ast.Index(ast.Num(0)), ast.Load()),
Symbol.new("cdar"): lambda p: ast.Subscript(ast.Subscript(build_ast(p[1]), ast.Index(ast.Num(0)), ast.Load()), ast.Slice(ast.Num(1), None, None), ast.Load()),
#Symbol.new("cddr"): lambda p: compiler.ast.Slice(build_ast(p[1]), 0, compiler.ast.Const(2), None),
Symbol.new("cdr"): lambda p: ast.Subscript(build_ast(p[1]), ast.Slice(ast.Num(1), None, None), ast.Load()),
Symbol.new("cons"): lambda p: ast.BinOp(ast.List([build_ast(p[1])], ast.Load()), ast.Add(), build_ast(p[2])),
#Symbol.new("append"): lambda p: ast.Call(ast.Attribute(ast.Name("functools", ast.Load()), "reduce", ast.Load()), [ast.Attribute(ast.Name("operator", ast.Load()), "add", ast.Load()), build_ast(p[1])], [], None, None),
#Symbol.new("apply"): lambda p: ast.Call(build_ast(p[1]), [build_ast(p[2])], [], None, None),
Symbol.new("if"): lambda p: ast.IfExp(build_ast(p[1]), build_ast(p[2]), build_ast(p[3]) if len(p) >= 4 else ast.Name("None", ast.Load())),
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 test_empty_init(self):
# Jython 2.5.0 did not allow empty constructors for many ast node types
# but CPython ast nodes do allow this. For the moment, I don't see a
# reason to allow construction of the super types (like ast.AST and
# ast.stmt) as well as the op types that are implemented as enums in
# Jython (like boolop), but I've left them in but commented out for
# now. We may need them in the future since CPython allows this, but
# it may fall under implementation detail.
#ast.AST()
ast.Add()
ast.And()
ast.Assert()
ast.Assign()
ast.Attribute()
ast.AugAssign()
ast.AugLoad()
ast.AugStore()
ast.BinOp()
ast.BitAnd()
ast.BitOr()
ast.BitXor()
ast.BoolOp()
ast.Break()
ast.Call()
ast.ClassDef()
ast.Compare()
ast.Continue()
ast.Del()
ast.Delete()
ast.Dict()
ast.Div()
ast.Ellipsis()
ast.Eq()
ast.Exec()
ast.Expr()
ast.Expression()
ast.ExtSlice()
ast.FloorDiv()
ast.For()
ast.FunctionDef()
ast.GeneratorExp()
ast.Global()
ast.Gt()
ast.GtE()
ast.If()
ast.IfExp()
ast.Import()
ast.ImportFrom()
ast.In()
ast.Index()
ast.Interactive()
ast.Invert()
ast.Is()
ast.IsNot()
ast.LShift()
ast.Lambda()
ast.List()
ast.ListComp()
ast.Load()
ast.Lt()
ast.LtE()
ast.Mod()
ast.Module()
ast.Mult()
ast.Name()
ast.Not()
ast.NotEq()
ast.NotIn()
ast.Num()
ast.Or()
ast.Param()
ast.Pass()
ast.Pow()
ast.Print()
ast.RShift()
ast.Raise()
ast.Repr()
ast.Return()
ast.Slice()
ast.Store()
ast.Str()
ast.Sub()
ast.Subscript()
ast.Suite()
ast.TryExcept()
ast.TryFinally()
ast.Tuple()
ast.UAdd()
ast.USub()
ast.UnaryOp()
ast.While()
ast.With()
ast.Yield()
ast.alias()
ast.arguments()
#ast.boolop()
#ast.cmpop()
ast.comprehension()
#ast.excepthandler()
#ast.expr()
#ast.expr_context()
ast.keyword()
