Python yacc.yacc函数代码示例

def parse(string):
    lex.lex()
    yacc.yacc()
    rules = yacc.parse(string)

    result = []
    while rules:
        current = rules.pop(0)
        result.extend(current[1])
    return(result)

    def __init__(self, options, stddef_types=True, gnu_types=True):
        self.preprocessor_parser = preprocessor.PreprocessorParser(options,self)
        self.parser = yacc.Parser()
        prototype = yacc.yacc(method        = 'LALR',
                              debug         = False,
                              module        = cgrammar,
                              write_tables  = True,
                              outputdir     = os.path.dirname(__file__),
                              optimize      = True)
        
        # If yacc is reading tables from a file, then it won't find the error
        # function... need to set it manually
        prototype.errorfunc = cgrammar.p_error
        prototype.init_parser(self.parser)
        self.parser.cparser = self

        self.lexer = CLexer(self)
        if stddef_types:
            self.lexer.type_names.add('wchar_t')
            self.lexer.type_names.add('ptrdiff_t')
            self.lexer.type_names.add('size_t')
        if gnu_types:
            self.lexer.type_names.add('__builtin_va_list')
        if sys.platform == 'win32':
            self.lexer.type_names.add('__int64')

def parse(s):

    lexer = lex.lex()
    lexer.input(s)
    parser = yacc.yacc()  # debug=1
    print("Parsing...")
    root = parser.parse(lexer=lexer)  # debug=1
    return root

    def __init__(self, stddef_types=True, gnu_types=True, cache_headers=True):
        self.preprocessor_parser = CPreprocessorParser(self)
        self.parser = yacc.Parser()
        yacc.yacc(method='LALR').init_parser(self.parser)
        self.parser.cparser = self

        self.lexer = CLexer(self)
        if stddef_types:
            self.lexer.type_names.add('wchar_t')
            self.lexer.type_names.add('ptrdiff_t')
            self.lexer.type_names.add('size_t')
        if gnu_types:
            self.lexer.type_names.add('__builtin_va_list')
        if sys.platform == 'win32':
            self.lexer.type_names.add('__int64')

        self.header_cache = {}
        self.cache_headers = cache_headers
        self.load_header_cache()

def doxyyacc(elist=elem_list(), mylexer=doxylex.doxylex()):
    def p_translation_unit(p):
        '''translation_unit : statement
                        | translation_unit statement'''
        pass

    def p_statement_assign(p):
        'statement : KEY expression'
        updatestr(p)
        elist.push([p[1][1:], p[2]])
        if DEBUG_DOXYYACC==1: print(get_cur_info()[0],p[0])
        pass

    def p_statement_line(p):
        'statement : expression'
        if p[1] == '':
            # 如果是空的，可以忽略
            pass
        else:
            # 如果不是空行，应加以保存
            updatestr(p)
            if DEBUG_DOXYYACC==1: print(get_cur_info()[0],p[0])

    def p_expression_com(p):
        'expression : expression WORD NEWLINE'
        #updatestr(p, 1)
        p[0] = ''
        p[0] = p[1] + '\n' + p[2]
        if DEBUG_DOXYYACC==1: print(get_cur_info()[0],p[0])
        pass

    def p_expression_line(p):
        'expression : WORD NEWLINE'
        updatestr(p, 1)
        if DEBUG_DOXYYACC==1: print(get_cur_info()[0],p[0])
        pass

    def p_expression_blankline(p):
        '''expression : BLANKLINE
                       | NEWLINE'''
        p[0] = ''
        if DEBUG_DOXYYACC==1: print(get_cur_info()[0],p[0])

    def p_empty(p):
        'empty : '
        pass

    def p_error(p):
        print("syntax error at '%s %d'" % (p.value, p.lineno))

    lexer = mylexer.lexer
    tokens = mylexer.tokens
    p1=yacc.yacc(method='LALR', tabmodule='doxy_tab', debugfile='doxyparser.out')
    return p1, elist.cm

def create_globals(module, support, debug):
    global parser, lexer, m, spt
    if not parser:
        lexer = lex.lex()
        parser = yacc.yacc(method="LALR", debug=debug, write_tables=0)

    if module is not None:
        m = module
    else:
        m = refpolicy.Module()

    if not support:
        spt = refpolicy.SupportMacros()
    else:
        spt = support

    def __init__(self, language='en'):
        self.language = language
        self.lock = Lock()

        try:
            modname = os.path.split(os.path.splitext(__file__)[0])[1] + "_" + self.__class__.__name__
        except:
            modname = "parser"+"_"+self.__class__.__name__
        self.debugfile = modname + ".dbg"
        self.tabmodule = modname + "_" + "parsetab"

        lex.lex(module=self, debug=False)
        self.p = yacc.yacc(module=self,
                           debug=0,
                           outputdir=outputdir,
                           debugfile=self.debugfile,
                           tabmodule=self.tabmodule,)

def beginParse(program):
    yacc = lexyacc.yacc()
    try:
        result = yacc.parse(program.read(),lexer = lexmelon.lex())
        aux = eval({},result)
        if isinstance(aux,bool):
            aux = str(aux).lower()
        if isinstance(aux,NodoBin):
            if aux.tipo == 'LISTA':
                print  recorrer_list(aux)
        else:
            print aux
    except SyntaxError, e:
        token = e.token
        if token:
            print 'Error de sintaxis en linea ' + str(token.lineno) \
                + ' cerca de token ' + '"' + str(token.value) + '"'
        else:
            print 'Error al final del programa'

def constr_testing(value, constr, var_name):
    global names

    lexer = lex.lex()
    parser = yacc.yacc()
    # print parser.parse('ASSERT(NOT(123 = 123))')

    # print constr

    for index, eachvar in enumerate(var_name):
        str_value = []
        for val in value[index]:
            if val != '':
                # TODO: input concrete value must be integer
                str_val = BitArray(uint = int(val), length = 8)
                str_value.append('0x' + str_val.hex)

        names[eachvar] = str_value
    #print names


    return ([constr[0]], yacc.parse(constr[1]))

    p[0] = '0b' + s.bin

def p_expression_if_then_else_endif(p):
    "expression : if expression then expression else expression endif"
    s1 = BitArray(p[2])
    if int(s1.int > 0):
        p[0] = p[4]
    else:
        p[0] = p[6]

def p_error(p):
    print "Syntax error at '%s'" % p.value


import yacc as yacc
yacc.yacc(errorlog=log)



# test concrete value against a path constraint
def constr_testing(value, constr, var_name):
    global names

    lexer = lex.lex()
    parser = yacc.yacc()
    # print parser.parse('ASSERT(NOT(123 = 123))')

    # print constr

    for index, eachvar in enumerate(var_name):
        str_value = []

 def __init__(self, lexer = None):
     if lexer is None:
         lexer = IndentLexer()
     self.lexer = lexer
     self.parser = yacc.yacc(start="file_input_end")

 def __init__(self):
     Utils.Debug.__init__(self)
     self.lexer = Lexer.Lexer()
     self.parser = yacc.yacc(module=self)

#.........这里部分代码省略.........
    @lex.TOKEN(flow)   
    def t_FLOW(t):
        return t
    
    @lex.TOKEN(ipv4)
    def t_IP(t):
        return t
    
    def t_FLOAT(t):
        r'(\d+)\.(\d*)'
        t.value = float(t.value)
        t.value = round(t.value,2) 
        return t
    
    def t_INT(t):
        r'\d+'
        t.value = int(t.value)
        return t     
    
    # A string containing ignored characters (spaces and tabs)
    t_ignore  = ' \t'
    
    # Error handling rule
    def t_error(t):
        print "Illegal character '%s'" % t.value[0]
        t.lexer.skip(1)
    
    # Build the lexer from my environment and return it    
    
    lex.lex()
    
    def p_query_unary_paren(p):
        ' query : LPAREN query RPAREN '
        p[0]=p[2]
        #print 'rule>> query : LPAREN query RPAREN>> ' + str(p[0])
    
    def p_query_binary(p):
        ''' query : query OR query
                | query AND query
                '''
        if p[2]=='+':
            p[0]={'$and':[p[1],p[3]]} 
        else:
            p[0]={'$or':[p[1],p[3]]} 
     
        #print 'rule>> query : query OR query >> ' + str(p[0])
      
    def p_query_token(p):
        'query : token'
        p[0]=p[1]
        #print ' rule>> query : token >> ' + str(p[0])
        
    def p_token_id(p):
        'token : id'
        p[0]={'content':p[1]}
    
    
    def p_token_attr_val(p):
        'token : attr_val'
        p[0]=p[1]
            
    def p_attr_val(p):
        '''
        attr_val : id EQ id 
                | id GT id   
                | id LT id
        '''
        if p[2]=='>':
            p[0]={p[1]:{'$gt':p[3]}}
        elif p[2]=='<':
            p[0]={p[1]:{'$lt':p[3]}}
        else:
            p[0]={p[1]:p[3]}   
                
    def p_id(p):
        ''' 
        id : INT
              | IP 
              | FLOW
              | FLOAT 
        '''
        #print p[1]
        p[0] = p[1]
        #print p[0]
        
    def p_id_keyword(p):
        ''' 
        id : KEYWORD
        '''
        #print p[1]
        p[0] = p[1].lower()
        #print p[0]       
    # Error rule for syntax errors
    def p_error(p):
        print "Syntax error in input!"
        #print p
    
    parser = yacc.yacc()

    return parser.parse(data)

    t[0] = IfStatement(t[3], t[5], NullNode())

def p_selection_statement_02(t):
    '''selection_statement : IF LPAREN expression RPAREN statement ELSE statement'''
    t[0] = IfStatement(t[3], t[5], t[7])

def p_statement_list_02(t):
    '''statement_list : statement'''
    t[0] = StatementList(t[1])

def p_statement_list_03(t):
    '''statement_list : statement_list statement'''
    t[1].add(t[2])
    t[0] = t[1]

def p_empty(t):
    'empty :'
    pass

def p_error(t):
    print "You've got a syntax error somewhere in your code."
    print "It could be around line %d." % t.lineno
    print "Good luck finding it."
    raise ParseError()

yacc.yacc(debug=1)

#  ---------------------------------------------------------------
#  End of cparse.py
#  ---------------------------------------------------------------

def p_pair(p):
    '''PAIR : string colon VALUE'''
    p[0] = ("pair", p[1], p[3])


    
def p_array(p):
    '''ARRAY : lbracket ELEMENTS rbracket
             | lbracket rbracket
    '''
    p[0] = ("elements", p[2]) if len(p) == 4 else ("elements",)
    


def p_elements(p):
    '''ELEMENTS : VALUE comma ELEMENTS | VALUE'''
    p[0] = p[1] if len(p) == 2 else [p[1]] + [p[3]]




if __name__ == "__main__":
    parser = yacc.yacc(parser='RD')
    tree = parser.parse(sys.stdin.read(), lexer)
    if tree is not None:
        print tree
    else:
        print "Parsing failed!"