Python yacc.parse函数代码示例

 def parseInput(self):
     if self.__haveSerialPort:        
         waitingCount = self.__ser.inWaiting()
         #waitingCount = 1
         if waitingCount == 0:
             return
         x = self.__ser.read(waitingCount)
         self.parseStr += x
     else:
         self.parseStr = ' <OK> '
     while len(self.parseStr) >= 1:
         #print "before:", self.parseStr
         foundEndTokenIndex = self.parseStr.find(">")
         if foundEndTokenIndex != -1:
             # Found '>' token delimiter
             newTokenString = self.parseStr[:foundEndTokenIndex+1]
             foundBeginTokenIndex = newTokenString.rfind("<")
             if foundBeginTokenIndex != -1 and foundBeginTokenIndex < foundEndTokenIndex:
                 yaccInput = newTokenString[foundBeginTokenIndex:]
                 if yaccInput != '<OK>':
                     print "yacc:", yaccInput
                 currentToken = 0
                 yacc.parse(yaccInput, debug=1)
             # Remove up to end of token from string
             self.parseStr = self.parseStr[foundEndTokenIndex+1:]
             #print "after:", self.parseStr
         else:
             break

def parse(formula):
    """Alias for yacc.parse.

    This function is used as method of the 'class' parse (this module).

    """
    return yacc.parse(formula)

def mk_rpn_query (query):
    tmp = tree_to_q (yacc.parse (query))
    if isinstance (tmp[0], asn1.OidVal): # XXX yuck, bad style
        attrset = tmp [0]
        tmp = tmp [1]
    else:
        attrset = z3950.bib1
    rpnq = z3950.RPNQuery (attributeSet = attrset)
    rpnq.rpn = tmp
    return ('type-1', rpnq)

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 test (s, fn):
    ast = yacc.parse (s)
    ctx = Ctx ()
    print "### Auto-generated at %s from %s" % (
        time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime()),
        fn)
    print "import rpchelp"
    tmp = ast.to_str (ctx)
    print ctx.finish ()
    print tmp

 def parse(self, query, operator):
     
     try:
         return yacc.parse( query )
     except QueryParserError:
         raise 
     except:
         import traceback
         traceback.print_exc()
         raise QueryParserError, 'parser failed for query: %s' % query

def read_configuration(filename):
    try:
        file = open(filename)
    except:
        print "Failed opening checkpoint file '%s'" % filename
        raise Exception
    try:
        return yacc.parse(string.join(file.readlines()))
    except Exception, msg:
        print "Failed parsing checkpoint file '%s'" % filename
        print "Error: %s" % msg
        sys.exit(1)

def expr(s, p, hexadecimal=False):
    global proc
    proc = p

    value, (ptrcount, local, type, size) = yacc.parse(s)
    if hexadecimal:
        if value < 0: # hex asked, negative value: make positive
            value = 256**size+value
        s = hex(value).replace('L','').lower()
    else:
        if value < 0: s = '-'+str(abs(value))
        else: s = str(value)
       
    return (value, s)

def parseFile(filename):
    """
    This funstion returns a tuple containing a list of opcodes
    and a list of symbols.
    Every opcode is a tuple of the form 
    (commandname, parameter, parameter, ...).
    Every symbol is a tuple of the form (type, name).
    """
    global commands
    global symbols
    commands = []
    symbols = []
    try:
        f = open(filename, "r")
        for line in f.readlines():
            line = line.strip()
            yacc.parse(line)
        f.close()
        result = (commands[:], symbols[:])
        commands = []
        symbols = []
        return result
    except IOError:
        return ()

def _myparse(x, outfile=sys.stdout):
    global _more, _xbuf, _outfile, _last_line
    _outfile = outfile
    _last_line = _xbuf + x
    ret = yacc.parse(_xbuf + x)
    if _more:
        # this takes care of the newline inside of [] and {}. We don't want
        # to have the newline as another token
        _xbuf += x.strip()
        if not _xbuf.endswith(";"):
            _xbuf += ";"
        _more = False
    else:
        _xbuf = ""
        more = False
    return ret

def mk_rpn_query (query):
    """Transform a CCL query into an RPN query."""
    # need to copy or create a new lexer because it contains globals
    # PLY 1.0 lacks __copy__
    # PLY 1.3.1-1.5 have __copy__, but it's broken and returns None
    # I sent David Beazley a patch, so future PLY releases will
    # presumably work correctly.
    # Recreating the lexer each time is noticeably slower, so this solution
    # is suboptimal for PLY <= 1.5, but better than being thread-unsafe.
    # Perhaps I should have per-thread lexer instead XXX
    # with example/twisted/test.py set to parse_only, I get 277 parses/sec
    # with fixed PLY, vs. 63 parses/sec with broken PLY, on my 500 MHz PIII
    # laptop.
    
    copiedlexer = None
    if hasattr (lexer, '__copy__'):
        copiedlexer = lexer.__copy__ ()
    if copiedlexer == None:
        copiedlexer = lex.lex ()
    ast = yacc.parse (query, copiedlexer)
    return ast_to_rpn (ast)

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]))

def compute_string(s, debug=False):
    lex.input(s)
    
    if debug:
        while 1:
            tok = lex.token()
            if not tok: break
            if tok.type != 'NEWLINE':
                print "line %d:%s(%s)"%(tok.lineno, tok.type, tok.value)
            else:
                print("line %d:%s(\\n)"%(tok.lineno, tok.type))
    
    result = yacc.parse(s) #, debug=2)
    print result.__class__
    print(explore(result,0))
    print("------------------ End Explore ------------------")
    r = compute(result)
    print("\nResult = %s of type %s" % (r, r.__class__))
    print("\nListing vars")
    for k in vars:
        print("%s:%s:%s" % (k, vars[k].__class__, vars[k]))
    return r

def parseCode(code):
	print "----------------"
	print "PARSING CODE:"
	print "----------------"
	return yacc.parse(code)

def get_ast(string):
    ast = yacc.parse(string) #, debug=2)
    return ast