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!"

 def buildparser(self, **kwargs):
     self.parser = yacc.yacc(module=self, **kwargs)

#.........这里部分代码省略.........
            args=list(t[1].args)
            if len(args) > 250:
                args=[Builtin('vector',tuple(args)),t[3]]
            else:
                args.append(t[3])
            t[1].args=tuple(args)
            t[0]=t[1]
            t[0].isarray = t[1].isarray and (isinstance(t[3],Scalar) or isinstance(t[3],Array))
        else:
            if t[1].isarray:
                t[0]=Data.evaluate(t[1])
            else:
                t[0]=Builtin('vector',t[1].args)

### Switch statement (i.e. switch(_a) {case(42) {statements} case(43) {statements}} )
    def p_case(t):
        """case : CASE LPAREN operand RPAREN braced_statements\n| CASE LPAREN operand RPAREN statement
        | CASE LPAREN operand RPAREN\n| CASE DEFAULT braced_statements
        | CASE DEFAULT statement\n| statement"""
        if len(t)==4:
            t[0]=Builtin('default',(t[3],))
        elif len(t)==5:
            t[0]=Builtin('case',(None,None))
            t[0].args=(t[3],)
            t[0].doAppendCase=True
        elif len(t)==6:
            t[0]=Builtin('case',(t[3],t[5]))
        else:
            t[0]=t[1]

    def p_cases(t):
        """cases : case\n| cases case"""

        def findCaseWithNoStatements(case,parent=None,argidx=0):
            ans=None
            if isinstance(case,Builtin):
                if case.name=='CASE' and len(case.args)==1:
                    ans = {'case':case,'parent':parent,'argidx':argidx}
                else:
                    for idx in range(len(case.args)):
                        ans = findCaseWithNoStatements(case.args[idx],case,idx)
                        if ans is not None:
                            break
            return ans

        def appendCase(cases,case):
            c=findCaseWithNoStatements(cases)
            if c is not None:
                appendTo=c
            else:
                appendTo={'case':cases,'parent':None,'argidx':0}
            if len(appendTo['case'].args) < 250:
                appendTo['case'].args=tuple(list(appendTo['case'].args)+[case,])
                return cases
            else:
                statement = Builtin('statement',(appendTo['case'],case))
                if appendTo['parent']==None:
                    return statement
                else:
                    args=list(appendTo['parent'].args)
                    args[appendTo['idx']]=statement
                    appendTo['parent'].args=tuple(args)
                    return cases

        if len(t)==3:
            t[1]=appendCase(t[1],t[2])
        t[0]=t[1]

    def p_switch(t):
        """operation : SWITCH LPAREN operand RPAREN LBRACE cases RBRACE"""
        t[0]=Builtin('switch',(t[3],t[6]))

### "Equals First" statement (i.e. _gub+=42)
    def p_operand_equal_first(t):
        """operation : ident EQUALSFIRST operand"""
        ops = {'+':'add','-':'subtract','*':'multiply','/':'divide','<':'lt',
                  '>':'gt','^':'power','**':'power','<=':'le','>=':'ge','==':'eq',
                  '>>':'shift_right','<<':'shift_left','&':'iand','&&':'and','!=':'NE',
                  '|':'ior','||':'or','//':'concat'}
        items=ops.items()
        ef_dict=dict()
        for itm in items:
            ef_dict.setdefault(itm[0]+'=',itm[1])
        t[0]=Builtin('equals_first',(Builtin(ef_dict[t[2]],(t[1],t[3])),))

### BACKQUOTED expression (i.e. `getnci(gub,"RECORD")
    def p_operand_backquote(t):
        """operand : BACKQUOTE operand"""
        t[0]=Data.evaluate(t[2])

### Handle syntax errors
    def p_error(t):
        if t is not None:
            print("Syntax error at '%s' in line %d: %s" % (t.value,t.lexer.lineno,t.lexer.lexdata[t.lexer.lexpos-10:t.lexer.lexpos+10]))
        else:
            print("Syntax error")

    import yacc
    yacc.yacc(write_tables=optimized,debug=0,optimize=optimized,tabmodule='tdiparsetab')
    return yacc.parse(text)

                            s&=all_tokens
                    if not s: return False
            else:
                raise ValueError("I can't handle this!")
        else:
            raise ValueError("I can't handle this!")
    if s:
        return True
    else: return False




if __name__==u"__main__":

    e_parser=yacc.yacc()
    expression=u"_ !>/nsubj/ _ >/dobj/ _ >/cop/ _ "

    node=e_parser.parse(expression)
    print "search tree:",node.to_unicode()

    conn=sqlite3.connect("/mnt/ssd/sdata/sdata2.db")
    out=codecs.getwriter("utf-8")(sys.stdout)

    for t in query(conn,node):
        t.to_conll(out)
        

    def parse(self, sentence):
        ''' 
        Perform the actual parsing (lex/yacc), define and use the grammar for
        propositional and first-order logic.
        
        Builds a parse tree and returns the root (an operator with the lowest precedent).
        '''
        
        # build the lexer
        
        # eclipse may warn you that this is an unused variable, but lex will use it
        tokens = (
                  'LBRACE', 'RBRACE', 'AND', 'OR', 'IMPLIES', 'NOT', 'ALL', 'EXISTS',
                  'PREDICATE', 'BINDING'
                  )
        
        #### DEFINE EVERY TOKEN MATCH AS A FUNCTION ###
        # this has the important side-effect of being able
        # to strictly control order of lexical matching
        
        def t_LBRACE (t): 
            r'\{'
            return t
        def t_RBRACE (t): 
            r'\}'
            return t
        def t_PREDICATE(t): 
            '\[[^\]]+\]'
            return t
        
        def t_AND(t):
            r'and'
            return t
        def t_OR(t):
            r'or'
            return t
        def t_IMPLIES(t):
            r'implies|therefore'
            return t
        
        def t_NOT(t):
            r'not'
            return t
        
        def t_ALL(t):
            r'all'
            return t
        
        def t_EXISTS(t):
            r'exists'
            return t
        
        def t_BINDING(t):
            r'[a-zA-Z_][a-zA-Z_0-9]*'
            return t
            
        # eclipse will warn you that this is an unused variable, but yacc/lex will use it
        precedence = (
                      ('left', 'IMPLIES'),
                      ('left', 'OR', 'AND'),
                      ('left', 'EXISTS', 'ALL'),
                      ('left', 'NOT'),
                      ('left', 'PREDICATE')
                      )
        
        # Build the lexer
        # again, eclipse will warn about this being an unused variable, but yacc will use it
        lexer = lex.lex()
        
        
        def p_expression_not(p):
            'expression : NOT expression'
            p[0] = Negation(p[2])
                
        def p_expression_forall_pred(p):
            'expression : ALL BINDING expression'
            p[0] = All(self, str(p[2]), self.domain, p[3])
            preds = p[0].getBoundVariablePreds()
            for x in preds:
                if(x.getFullStatement() in self.predicates.keys()):
                    del self.predicates[x.getFullStatement()]
            
        def p_expression_exists_pred(p):
            'expression : EXISTS BINDING expression'
            p[0] = Exists(self, str(p[2]), self.domain, p[3])
            preds = p[0].getBoundVariablePreds()
            for x in preds:
                if(x.getFullStatement() in self.predicates.keys()):
                    del self.predicates[x.getFullStatement()]
        
        def p_expression_implies(p):
            'expression : expression IMPLIES expression'
            p[0] = Implication(p[1], p[3])
            
            
        def p_expression_and(p):
            'expression : expression AND expression'
            p[0] = Conjunction(p[1], p[3])
            
        def p_expression_or(p):
#.........这里部分代码省略.........

        # tell which is which.  So understanding of colon expressions
        # is put off until after "resolve".
        p[0] = p[1]
        p[0].args.insert(1,p[3])
    else:
        p[0] = node.expr(op=p[2],args=node.expr_list([p[1],p[3]]))

def p_error(p):
    #import pdb; pdb.set_trace()
    #print "p_error",p
    if ("." in options.syntax_errors or
        os.path.basename(options.filename) in options.syntax_errors):
        return p
    raise syntax_error(p)

parser = yacc.yacc(start="top")

def parse(buf,filename=""):
    options.filename = filename
    try:
        new_lexer = lexer.new()
        p = parser.parse(buf,tracking=1,debug=0,lexer=new_lexer)
        return p
    except lexer.IllegalCharacterError as (lineno,column,c):
        #import pdb; pdb.set_trace()
        print 'Error:%s:%s.%s:illegal character:%s' % (filename,lineno,column,c)
        return []
    except NotImplementedError as e:
        print 'Error:%s:not implemented:%s' % (filename,e)
        return []
    except syntax_error as e: