# php2json.py - Converts PHP to a JSON-based abstract syntax tree
# Usage: php2json.py < input.php > output.json
import sys
sys.path.append('..')
from phply.phplex import lexer
from phply.phpparse import parser
import simplejson
input = sys.stdin
output = sys.stdout
with_lineno = True
def export(items):
result = []
if items:
for item in items:
if hasattr(item, 'generic'):
item = item.generic(with_lineno=with_lineno)
result.append(item)
return result
simplejson.dump(export(parser.parse(input.read(),
lexer=lexer,
tracking=with_lineno)),
output, indent=2)
output.write('\n')
def __init__(self, code, infile):
#
# Init internal variables that hold most information
#
# FuncCall nodes
self.functions = []
# FunctionDeclarations
self.functions_declarations = {}
# class node to create new instances
self.classes = {}
# variableDefs that are objects
self.objects = {}
# used for method traveling
self.methods_deep = []
# keep track of alert messages
self.alerts = []
# relative path of start script
self.path = ''
# Lexer instance
lexer = phplex.lexer.clone()
# Code AST
try:
self.ast_code = parser.parse(code, lexer=lexer)
except SyntaxError, se:
raise CodeSyntaxError, "Error while parsing the code, syntax error: '%s'" % se
def get_source(self):
if not self.original:
self.load()
if not self.source:
try:
self.source = parser.parse(self.original.read(), lexer=lexer, tracking=True)
except SyntaxError as (errno, strerror):
print "Ignoring %s due to advanced syntax" % self.path
print errno
print strerror
return None
def __init__(self,file_name):
self.file_name = file_name
try:
o = open(file_name,'r')
self.file_content = o.read()
#o.close()
try:
lexer = phplex.lexer.clone()
self.parsed_content = parser.parse(self.file_content, lexer=lexer)
resolve_magic_constants(self.parsed_content)
print prettyText("[+] SUCCESS parsing %s" % self.file_name,'green')
except Exception, err:
print prettyText("[-] ERROR parsing %s (%s)" % (self.file_name, str(err)),'red')
self.parsed_content = []
except Exception, err:
print prettyText("[-] ERROR openning file: %s (%s)" % (self.file_name, str(err)),'yellow')
def __init__(self, code=None, file=None):
if not code and not file:
raise ValueError, ("Invalid arguments. Either parameter 'code' or "
"'file' should not be None.")
if file:
with open(file, 'r') as f:
code = f.read()
# Lexer instance
lexer = phplex.lexer.clone()
# Code AST
try:
self._ast_code = parser.parse(code, lexer=lexer)
except SyntaxError, se:
raise CodeSyntaxError, "Error while parsing the code"
def analyze(path):
with codecs.open(path, 'r', 'latin1') as f:
src = f.read()
try:
items = parser.parse(src, tracking=True, lexer=lexer.clone())
except SyntaxError as e:
print "Syntax Error", e.filename, e
except ValueError as e:
print "Syntax Error", e
else:
for ast in items:
if hasattr(ast, 'generic'):
item = ast.generic(with_lineno=True)
else:
item = ast
print item
def eq_ast(input, expected, filename=None):
lexer = phplex.lexer.clone()
lexer.filename = filename
output = parser.parse(input, lexer=lexer)
resolve_magic_constants(output)
print 'Parser output:'
pprint.pprint(output)
print
print 'Node by node:'
for out, exp in zip(output, expected):
print '\tgot:', out, '\texpected:', exp
nose.tools.eq_(out, exp)
assert len(output) == len(expected), \
'output length was %d, expected %s' % (len(output), len(expected))
def eq_ast(input, expected, filename=None):
lexer = phplex.lexer.clone()
lexer.filename = filename
output = parser.parse(input, lexer=lexer)
resolve_magic_constants(output)
print 'Parser output:'
pprint.pprint(output)
print
print 'Node by node:'
for out, exp in zip(output, expected):
print '\tgot:', out, '\texpected:', exp
nose.tools.eq_(out, exp)
assert len(output) == len(expected), \
'output length was %d, expected %s' % (len(output), len(expected))
def parse_code(self, filename):
basedir = self.state.document.settings.env.doctreedir
cachename = os.path.join(basedir, basename(filename, 'parse'))
if is_same_mtime(filename, cachename):
tree = pickle.load(open(cachename, 'rb'))
else:
try:
with codecs.open(filename, 'r', 'utf-8') as f:
tree = parser.parse(f.read(), lexer=lexer.clone())
with open(cachename, 'wb') as f:
pickle.dump(tree, f)
mtime = os.stat(filename).st_mtime
os.utime(cachename, (mtime, mtime))
except Exception:
raise
return tree
def parse_include_require(self, node, state, currentscope):
# TO DO: Smarter filename detection. For example if file is set in variable.
# Open file
infile = os.path.join(state.path, str(node.expr))
try:
f = open(infile, 'r')
except IOError as e:
return
code = f.read()
# Lexer instance
sublexer = phplex.lexer.clone()
# Code AST
try:
new_ast_code = parser.parse(code, lexer=sublexer)
except SyntaxError, se:
state.alerts.append("Error while parsing the code of include file '%s', syntax error: '%s'" % (infile, se))
return
def __init__(self, code, debugmode=False):
lexer = phplex.lexer.clone()
self._ast_code = parser.parse(code, lexer=lexer)
GlobalParentNodeType = phpast.node('GlobalParentNodeType', \
['name', 'children', '_parent_node'])
self._global_pnode = GlobalParentNodeType('dummy', self._ast_code, None)
# Define scope
scope = Scope(self._global_pnode, parent_scope=None)
#
# TODO: NO! Move this vars to a parent scope!!!
# (it'd be a special *Global* scope!)
# When this is done change the "set" calculus below
#
self._user_vars = [VariableDef(uv, -1, scope) \
for uv in VariableDef.USER_VARS]
map(scope.add_var, self._user_vars)
self._scopes = [scope]
# FuncCall nodes
self._functions = []
# Debugging purpose
self.debugmode = False
#!/usr/bin/env python
# php2python.py - Converts PHP to Python using unparse.py
# Usage: php2python.py < input.php > output.py
import sys
sys.path.append('..')
from phply.phplex import lexer
from phply.phpparse import parser
from phply import pythonast
from ast import Module
from unparse import Unparser
input = sys.stdin
output = sys.stdout
body = [
pythonast.from_phpast(ast)
for ast in parser.parse(input.read(), lexer=lexer)
]
Unparser(body, output)
print(" ", ast.dump(code, include_attributes=True))
def php_eval(nodes):
body = []
for node in nodes:
stmt = pythonast.to_stmt(pythonast.from_phpast(node))
body.append(stmt)
code = ast.Module(body)
# ast_dump(code)
eval(compile(code, "<string>", mode="exec"), globals())
s = ""
lexer = phplex.lexer
parser.parse("<?", lexer=lexer)
while True:
if s:
prompt = " "
else:
prompt = lexer.current_state()
if prompt == "INITIAL":
prompt = "html"
prompt += "> "
try:
s += input(prompt)
except EOFError:
break
# Usage: php2json.py < input.php > output.json
import sys
sys.path.append('..')
from phply.phplex import lexer
from phply.phpparse import parser
import simplejson
input = sys.stdin
output = sys.stdout
with_lineno = True
def export(items):
result = []
if items:
for item in items:
if hasattr(item, 'generic'):
item = item.generic(with_lineno=with_lineno)
result.append(item)
return result
simplejson.dump(export(
parser.parse(input.read(), lexer=lexer, tracking=with_lineno)),
output,
indent=2)
output.write('\n')
if isinstance(e, str):
return e
elif isinstance(e, FunctionCall):
return function_call2(state, e)
elif isinstance(e, int):
return e
elif isinstance(e, BinaryOp) and e.op == '.':
return eval2(state, e.left) + eval2(state, e.right)
elif isinstance(e, MagicConstant):
if e.name == '__FILE__':
return filename
elif isinstance(e, Constant):
if e.name in state.variables:
return state.variables[e.name]
elif e.name in DEFINES:
return DEFINES[e.name]
return ''
statements(State(), ast)
print 'forks: ', forks
if len(sys.argv) < 2:
ast = parser.parse(sys.stdin.read(), lexer=lexer)
analyze(ast, '')
else:
print '======================================'
print 'ANALYZING: ', os.path.abspath(sys.argv[1])
analyze(load_and_parse(sys.argv[1]), os.path.abspath(sys.argv[1]))
params = [unparse_node(x.node, True) for x in node.params[1:]]
if is_expr:
return '%s %% (%s,)' % (unparse_node(node.params[0].node, True),
', '.join(params))
else:
return '{{ %s %% (%s,) }}' % (unparse_node(node.params[0].node, True),
', '.join(params))
params = ', '.join(unparse_node(param.node, True)
for param in node.params)
if is_expr:
return '%s(%s)' % (node.name, params)
else:
return '{{ %s(%s) }}' % (node.name, params)
if isinstance(node, MethodCall):
params = ', '.join(unparse_node(param.node, True)
for param in node.params)
if is_expr:
return '%s.%s(%s)' % (unparse_node(node.node, True),
node.name, params)
else:
return '{{ %s.%s(%s) }}' % (unparse_node(node.node, True),
node.name, params)
if is_expr:
return 'XXX(%r)' % str(node)
else:
return '{# XXX %s #}' % node
output.write(unparse(parser.parse(input.read(), lexer=lexer)))
#!/usr/bin/env python
# php2python.py - Converts PHP to Python using unparse.py
# Usage: php2python.py < input.php > output.py
import sys
sys.path.append('..')
from phply.phplex import lexer
from phply.phpparse import parser
from phply import pythonast
from ast import Module
from unparse import Unparser
input = sys.stdin
output = sys.stdout
body = [pythonast.from_phpast(ast)
for ast in parser.parse(input.read(), lexer=lexer)]
Unparser(body, output)
def ast_dump(code):
print 'AST dump:'
print ' ', ast.dump(code, include_attributes=True)
def php_eval(nodes):
body = []
for node in nodes:
stmt = pythonast.to_stmt(pythonast.from_phpast(node))
body.append(stmt)
code = ast.Module(body)
# ast_dump(code)
eval(compile(code, '<string>', mode='exec'), globals())
s = ''
lexer = phplex.lexer
parser.parse('<?', lexer=lexer)
while True:
if s:
prompt = ' '
else:
prompt = lexer.current_state()
if prompt == 'INITIAL': prompt = 'html'
prompt += '> '
try:
s += raw_input(prompt)
except EOFError:
break
if not s: continue
