Python Parser.parse方法代码示例

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import parse [as 别名]
def main():
    try:
        print('-------------------test file 1-------------------------------')
        parser1 = Parser('test1.py')
        program1 = parser1.parse()
        program1.execute()
        print('-------------------test file 1 end-------------------------------\n\n')

        print('-------------------test file 2-------------------------------')
        parser2 = Parser('test2.py')
        program2 = parser2.parse()
        program2.execute()
        print('-------------------test file 2 end-------------------------------\n\n')

        print('-------------------test file 3-----------------------------------')
        parser3 = Parser('test3.py')
        program3 = parser3.parse()
        program3.execute()
        print('-------------------test file 3 end-------------------------------\n\n')

        print('-------------------test file 4-------------------------------')
        parser4 = Parser('test4.py')
        program4 = parser4.parse()
        program4.execute()
        print('-------------------test file 4 end-------------------------------')


    except FileNotFoundError as e:
        print(e)
    except LexicalException as e:
        print(e)
    except ParserException as e:
        print(e)
    except Exception as e:
        print('unexpected error occurred at interpreter -', e)

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import parse [as 别名]
 def parse(self):
     Parser.parse(self)
     self.getGlobalParameters()
     self.getSpecies()
     self.analyseModelStructure()
     self.analyseFunctions()
     self.analyseRules()
     self.analyseEvents()
     self.renameEverything()

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import parse [as 别名]
def main(args):
    # Checks to make sure the right number of params are given.
    # Params: filename
    if len(args)!=2:
        sys.exit("Usage: "+args[0]+" <filename>")
    inFile = args[1]

    tokenizer = Tokenizer(inFile)
    tokenizer.tokenize()
    tokenizer.toXML(inFile)
    parser = Parser(tokenizer.tokens(),VMWriter(inFile))
    parser.parse()

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import parse [as 别名]
class ParserNode(object):
    def __init__(self):
        self.source_code = []
        self.symtable = SymbolTable()
        self.instr = []
        self.parser = Parser(self.symtable, self.instr)

    def parse(self, code_lines=None):
        if code_lines is None:
            code_lines = self.source_code
        code = '\n'.join(code_lines)
        self.parser.parse(code)

    def add_source_line(self, line):
        self.source_code.append(line)

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import parse [as 别名]
 def test_parser_can_identify_multiple_ctes(self):
     parser = Parser()
     output = parser.parse("with test_cte as ( SELECT 1 ) , test_cte2 as ( SELECT 3 )  Select 2")
     self.assertEqual(len(output), 3)
     self.assertEqual(output[0].query, "SELECT 1".lower())
     self.assertEqual(output[1].query, "SELECT 3".lower())
     self.assertEqual(output[2].query, "SELECT 2".lower())

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import parse [as 别名]
 def test_parser_can_handle_minimal_whitespace(self):
     parser = Parser()
     output = parser.parse("with test_cte as (SELECT 1),test_cte2 as (SELECT 3 )  Select 2")
     self.assertEqual(len(output), 3)
     self.assertEqual(output[0].query, "SELECT 1".lower())
     self.assertEqual(output[1].query, "SELECT 3".lower())
     self.assertEqual(output[2].query, "SELECT 2".lower())

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import parse [as 别名]
def main():
    parserName=sys.argv[1]
    corpusName=sys.argv[2]
    pt=ParseTable()
    lex=Lexicon()
    print "loading parsetable....."
    pt.load("experiments/"+parserName+"/parsetable.pt")
    lex.load("experiments/"+parserName+"/lexicon.lex")
    print "done"
    p=Parser(pt,lex)
    corpus=open(corpusName,"r").readlines()
    if corpus[-1]=="\n":
        corpus=corpus[:-1]
    for line in corpus:
         print line
         p.parse(line)

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import parse [as 别名]
class QueryStringHandler:
	def __init__(self):
		self.parser = Parser()
		self.mathMagic = MathMagic()
	
	#Param: a queryString
	#Return: datasetReport, list of timelines with flags
	def getReport(self, queryString):
		try:
			dset = self.parser.parse(queryString)
			datasetReport = []
			
			timeAxis = dset[0]
			
			for timeline in dset[1:]:
				
				listOfFlags = self.mathMagic.analyze(timeline, timeAxis)
				
				if listOfFlags:
				  timelineFlagList = FlagObj(dset.dsId, dset.title, timeline.cId, timeline.title, listOfFlags)
				  datasetReport.append(timelineFlagList)

			
			return datasetReport
			#TODO Specify exceptions
		except TypeError, e:
			logging.error(traceback.format_exc())
			#logging.error(e)
		except Exception, e:
			logging.error(traceback.format_exc())
			#logging.error(e)
			return []

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import parse [as 别名]
    def validate(cls, variant_string):
        # get the variant breakdown from the parser     
        parser = Parser()
        variant = parser.parse('', variant_string) # for validation we can leave ID(the 1st param) blank
        
        # If parsing failed - ie: no values where properly indexed
        if variant == None:
            return False
        
        # Genomic and cDNA - possibilities: c.112g>t, g.12345678, 12345678, NC_000017.10:12345678 or Chr.17:12345678
        if (variant_string[0].lower() == 'g' or variant_string[0].lower() == 'c' or variant_string[0].lower() == 'n'
            or variant_string[0].isdigit()):
            return Validate_Genomic_cDNA.validate(variant)

        # mRNA
        elif variant_string[0].lower() == 'm':
            return Validate_mRNA.validate(variant)

        # Protein
        elif variant_string[0].lower() == 'p':
            return Validate_Protein.validate(variant)
        
        # if nothing else, then fail
        else:
            return False

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import parse [as 别名]
class Vector:
    def __init__(self, debug = False):
        self.debug = debug
        self.parser = Parser()
        self.interpreter = Interpreter()

    def eval(self, s):
        if self.debug:
            print "Input: " + s
        lexemes = Lexer.lex(s)
        if self.debug:
            print "Lexemes: " + str(lexemes)
        ast = self.parser.parse(lexemes)
        if self.debug:
            print "AST:"
            self.printAST(ast, 0)
        result = self.interpreter.eval(ast)
        if self.debug:
            print "Result: ",
        print str(result)

    def printAST(self, ast, indent):
        if ast == False:
            print "| " * indent + "ERROR"
            return
        print "| " * indent + str(ast[1])
        if len(ast) < 3:
            return
        for c in ast[2]:
            self.printAST(c, indent + 1)

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import parse [as 别名]
 def craw(self, root_url):
     # todo: 层数设置？
     page_count = self.page_count
     UrlManager.add_new_url(root_url)
     try:
         while UrlManager.has_new_url():
             todo_url = UrlManager.get_new_url()
             try:
                 print u"\nNO: %d 正在检测链接:%s" % (page_count, todo_url)
             except:
                 print u"出错", todo_url
                 # todo: 换成 contiune 是不是更好？
             # page_status, bad_links = Downloader.test(todo_url)
             # print u"\n结果：%s" % page_status
             # todo: 加入状态码的说明
             state, content = Downloader.download(todo_url)
             if state:
                 prase_state, new_urls = Parser.parse(todo_url, content)
                 if prase_state:
                     UrlManager.add_new_urls(new_urls)
                 else:
                     Outputer.collect_data(new_urls)
             else:
                 Outputer.collect_data(content)
             page_count += 1
             # except:
             #     print u"页面爬取失败"
             #     UrlManager.add_wrong_url(todo_url)
             # todo:测试代码
             if page_count == 5000:
                 self.page_count = page_count
                 break
             print UrlManager.num_new_url()
     finally:
         Outputer.output_txt(self.page_count)

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import parse [as 别名]
class Interpreter(NodeVisitor):

    def __init__(self, source_code):
        self.parser = Parser(source_code)

    def run(self):
        ast = self.parser.parse()
        return self.visit(ast)

    def visit_Num(self, node):
        return node.token.value

    def visit_BinOp(self, node):
        if node.token.type == TokenTypes.ADD:
            return self.visit(node.left) + self.visit(node.right)

        elif node.token.type == TokenTypes.SUB:
            return self.visit(node.left) - self.visit(node.right)

        elif node.token.type == TokenTypes.MUL:
            return self.visit(node.left) * self.visit(node.right)

        elif node.token.type == TokenTypes.DIV:
            return self.visit(node.left) / self.visit(node.right)

        raise NotImplementedError

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import parse [as 别名]
class CodecPML(CodecODB):


    def __init__(self):
        CodecODB.__init__(self, encoding='pml')

        from Parser import Parser
        self._parser = Parser()

        self.parserFactory = None
        
        return


    def _createRenderer(self):
        from Renderer import Renderer
        return Renderer()


    def _decode(self, shelf):
        """lock and then read the contents of the file into the shelf"""

        stream = file(shelf.name)

        self._locker.lock(stream, self._locker.LOCK_EX)
        document = self._parser.parse(stream, self.parserFactory)
        self._locker.unlock(stream)

        shelf['blade'] = document
        shelf._frozen = True
        
        return

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import parse [as 别名]
 def feedConfig(self, fn):
     fd = open(fn, 'r')
     parser = Parser(fd)
     self.config = parser.parse()
     self.runner = JobRunner(self.config)
     # config file info
     self.fn = fn
     self.ftime = datetime.datetime.fromtimestamp(os.path.getmtime(self.fn))

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import parse [as 别名]
 def evaluate(self):
     #lexer
     lexer = Lexer(self.input)
     token_list = lexer.lex()
 
     #parser
     parser = Parser(token_list)
     value = parser.parse()
     return value