# 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 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