Python Forward.parseString方法代码示例

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import parseString [as 别名]
def parse_constraint_group(constraint_group):
	global valgrind_operations, size_by_var, offset_by_var, realsize_by_var, shift_by_var
	
	init_global_vars()
	
	lparen = Literal("(")
	rparen = Literal(")")

	func = Word(alphanums, alphanums+":_")
	integer = Word(nums)
	
	expression = Forward()

	arg = expression | func | integer
	args = arg + ZeroOrMore(","+arg)

	expression << func + lparen + args + rparen	
	expression.setParseAction(parse_function)
	
	valgrind_operations_group = []	
	for constraint in constraint_group:
		valgrind_operations = []
		
		expression.parseString(constraint)
		resize_operands()
		
		valgrind_operations_group.append(valgrind_operations)
	
	return (valgrind_operations_group, size_by_var, offset_by_var, realsize_by_var, shift_by_var)

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import parseString [as 别名]
class RigorousClassicalPropositionalLogicParser:

	def __init__(self):
		self.left_parenthesis = Suppress("(")
		self.right_parenthesis = Suppress(")")
		self.implies = Literal("->")
		self.or_ = Literal("|")
		self.and_ = Literal("&")
		self.not_ = Literal("!") | Literal ("~")
		self.boolean = Keyword("false") | Keyword("true")
		self.symbol = Word(alphas, alphanums)

		self.formula = Forward()
		self.operand = self.boolean | self.symbol

		self.binaryConnective = self.or_ | self.and_ | self.implies

		self.unaryFormula = Group(self.not_ + self.formula)
		self.binaryFormula = Group(self.left_parenthesis + self.formula + self.binaryConnective + self.formula + self.right_parenthesis)

		self.formula << (self.unaryFormula | self.binaryFormula | self.operand)


## Should return a ParserResult object

	def parse(self,text):
		try:
			result = self.formula.parseString(text, parseAll=True)
			assert len(result) == 1

			return  result

		except (ParseException, ParseSyntaxException) as err:
#			print("Syntax error:\n{0.line}\n{1}^".format(err, " " * (err.column - 1)))
			return ""

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import parseString [as 别名]
    def get_enclosed(self,raw):
    
        #Word ::= Ascii - Tokens
        non_token = "!#$%&\'*+,-./:;[email protected]\\^_`|~"
        word = Word(alphanums+non_token)
        #word = Word(printables)
    
        #Tokens ::= {}[]()<>
        tokens = "{}[]()<>"  
    
        o_curly,c_curly,o_brack,c_brack,o_paren,c_paren,o_mayor,c_mayor = map(Suppress,tokens)

        enclosed_data = Forward()
        
        #Enclosed groups
        curly_enclosed = OneOrMore(o_curly + enclosed_data + c_curly)
        brack_enclosed = OneOrMore(o_brack + enclosed_data + c_brack)
        paren_enclosed = OneOrMore(o_paren + enclosed_data + c_paren)
        mayor_enclosed = OneOrMore(o_mayor + enclosed_data + c_mayor)
    
        enclosed = Optional(curly_enclosed) & Optional(brack_enclosed) & Optional(paren_enclosed) & Optional(mayor_enclosed) 
    
        enclosed_data << ((OneOrMore(word) & enclosed) ^ enclosed)
    
        return enclosed_data.parseString(raw)

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import parseString [as 别名]
def __parseNestedList( value,  dtype = float):
    from pyparsing import Word, Group, Forward, OneOrMore, Optional, alphanums, Suppress
    number = Word( alphanums + ".e-" ).setParseAction( lambda s,l,t: dtype(t[0]) )
    arr = Forward()
    element = number | arr
    arr << Group(Suppress('[') + ( OneOrMore(element + Optional(Suppress(",")) ) ) + Suppress(']') )
    return arr.parseString(value, parseAll = True).asList()[0]

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import parseString [as 别名]
    def parse_sexp(data):
        '''parse sexp/S-expression format and return a python list'''
        # define punctuation literals
        LPAR, RPAR, LBRK, RBRK, LBRC, RBRC, VBAR = map(Suppress, "()[]{}|")

        decimal = Word("123456789", nums).setParseAction(lambda t: int(t[0]))
        bytes = Word(printables)
        raw = Group(decimal.setResultsName("len") + Suppress(":") + bytes).setParseAction(OtrPrivateKeys.verifyLen)
        token = Word(alphanums + "-./_:*+=")
        base64_ = Group(Optional(decimal, default=None).setResultsName("len") + VBAR
            + OneOrMore(Word( alphanums +"+/=" )).setParseAction(lambda t: b64decode("".join(t)))
            + VBAR).setParseAction(OtrPrivateKeys.verifyLen)

        hexadecimal = ("#" + OneOrMore(Word(hexnums)) + "#")\
                        .setParseAction(lambda t: int("".join(t[1:-1]),16))
        qString = Group(Optional(decimal, default=None).setResultsName("len") +
                                dblQuotedString.setParseAction(removeQuotes)).setParseAction(OtrPrivateKeys.verifyLen)
        simpleString = raw | token | base64_ | hexadecimal | qString

        display = LBRK + simpleString + RBRK
        string_ = Optional(display) + simpleString

        sexp = Forward()
        sexpList = Group(LPAR + ZeroOrMore(sexp) + RPAR)
        sexp << ( string_ | sexpList )

        try:
            sexpr = sexp.parseString(data)
            return sexpr.asList()[0][1:]
        except ParseFatalException, pfe:
            print("Error:", pfe.msg)
            print(pfe.loc)
            print(pfe.markInputline())

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import parseString [as 别名]
def parseQuery(queryString):
    try:
        parser = Forward();
        # parser << (Word(alphas).setResultsName( "first" ) + \
        #         #(' ').setResultsName( "delim" ) + \
        #         '*' + Word(alphas).setResultsName( "second"))
        # selectSpecialStmt = Forward.setResultsName("selectSpecialStmt");
        # selectSpecialStmt << (selectSpecialToken + "(" + table_columns + ")" + fromToken \
        #             + table.setResultsName("table"));
        selectStmt = Forward().setResultsName("selectStmt");
        selectStmt << ( selectToken + ( '*' | func_table_column | table_columns).setResultsName( "columns" ) \
                    + fromToken + tables.setResultsName("tables") \
                    + Optional(whereToken + whereExpression.setResultsName("conds") ) );
        deleteStmt = Forward().setResultsName("deleteStmt");
        deleteStmt << ( deleteToken + table.setResultsName("table") \
                    + whereToken + whereExpression.setResultsName("conds"));
        insertStmt = Forward().setResultsName("insertStmt");
        insertStmt << ( insertToken + table.setResultsName("table") + valuesToken \
                    + "(" + intNums.setResultsName("intValues") + ")" );
        createStmt = Forward().setResultsName("createStmt");
        createStmt << ( createToken + table.setResultsName("table") + "(" \
                    + Group(delimitedList(column + intToken)).setResultsName("fields") + ")" );
        truncateStmt = Forward().setResultsName("truncateStmt");
        truncateStmt << ( truncateToken + table.setResultsName("table"));
        dropStmt = Forward().setResultsName("dropStmt");
        dropStmt << ( dropToken + table.setResultsName("table"));
        parser = selectStmt | insertStmt | deleteStmt | createStmt | truncateStmt | dropStmt | exitToken;
        tokens = parser.parseString(queryString);
        # import pdb; pdb.set_trace()
        return tokens
    except Exception as e:
        # print e;
        print "Error in format."
        return [];

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import parseString [as 别名]
    def parse(string):
        ''' returns either [atomic], [monoop, [f]] or [binop, [f1], [f2]]
            this method is static (no need for a CTL instance) '''
            
        lparen = Literal('(').suppress()
        rparen = Literal(')').suppress()
        wildcard = Literal('_')
        atom = Combine(Word(alphas) + Optional(Word('.0123456789'))
            ^ 'true' ^ 'false' ^ wildcard)
        
        term = Forward()
        term << (atom
            + Optional(lparen + Group(term) 
                + ZeroOrMore(Literal(',').suppress() + Group(term))
            + rparen))

        A = Optional('<-')+'A'
        E = Optional('<-')+'E'
        G, Gi, F, X, U = map(Literal, ('G', 'Gi', 'F', 'X', 'U'))
        UnOp = wildcard ^ '!' ^ Combine(A + (G^F^X)) ^ Combine(E + (G^Gi^F^X))
        BinOp = wildcard ^ Literal('or') ^ Literal('and') ^ Combine(A + U) ^ Combine(E + U)

        formula = Forward()
        formula << (Group(term) 
              ^ (lparen + formula + rparen) 
              ^ Group(UnOp + formula)
              ^ Group(BinOp + formula + formula))

        # 0 because we expect only one formula in the string
        return formula.parseString(string).asList()[0] 

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import parseString [as 别名]
def parseATL(spec):
    """Parse the spec and return the list of possible ASTs."""
    global __atl
    if __atl is None:
        true = Literal("True")
        true.setParseAction(lambda tokens: TrueExp())
        false = Literal("False")
        false.setParseAction(lambda tokens: FalseExp())
        
        atom = "'" + SkipTo("'") + "'"
        atom.setParseAction(lambda tokens: Atom(tokens[1]))
        
        agent = atom
        group = Group(ZeroOrMore(agent + Suppress(",")) + agent)
        
        proposition = true | false | atom
        
        __atl = Forward()

        notproposition = "~" + proposition
        notproposition.setParseAction(lambda tokens: Not(tokens[1]))
        formula = (proposition | notproposition |
                   Suppress("(") + __atl + Suppress(")"))

        logical = Forward()
        
        
        cax = Literal("[") + group + "]" + "X" + logical
        cax.setParseAction(lambda tokens: CAX(tokens[1], tokens[4]))
        cex = Literal("<") + group + ">" + "X" + logical
        cex.setParseAction(lambda tokens: CEX(tokens[1], tokens[4]))
         
        caf = Literal("[") + group + "]" + "F" + logical
        caf.setParseAction(lambda tokens: CAF(tokens[1], tokens[4]))
        cef = Literal("<") + group + ">" + "F" + logical
        cef.setParseAction(lambda tokens: CEF(tokens[1], tokens[4]))
         
        cag = Literal("[") + group + "]" + "G" + logical
        cag.setParseAction(lambda tokens: CAG(tokens[1], tokens[4]))
        ceg = Literal("<") + group + ">" + "G" + logical           
        ceg.setParseAction(lambda tokens: CEG(tokens[1], tokens[4]))
         
        cau = Literal("[") + group + "]" + "[" + __atl + "U" + __atl + "]"
        cau.setParseAction(lambda tokens: CAU(tokens[1], tokens[4], tokens[6]))
        ceu = Literal("<") + group + ">" + "[" + __atl + "U" + __atl + "]"   
        ceu.setParseAction(lambda tokens: CEU(tokens[1], tokens[4], tokens[6]))
                                                                
        caw = Literal("[") + group + "]" + "[" + __atl + "W" + __atl + "]"   
        caw.setParseAction(lambda tokens: CAW(tokens[1], tokens[4], tokens[6]))
        cew = Literal("<") + group + ">" + "[" + __atl + "W" + __atl + "]"   
        cew.setParseAction(lambda tokens: CEW(tokens[1], tokens[4], tokens[6]))

        strategic = (cax | cex | caf | cef | cag | ceg | cau | ceu | caw | cew)
        
        logical <<= (formula | strategic)

        __atl <<= (_logicals_(logical))
    
    return __atl.parseString(spec, parseAll = True)

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import parseString [as 别名]
    def _string_to_ast(self, input_string):
        """ Parse a smart search string and return it in an AST like form
        """

        # simple words
        # we need to use a regex to match on words because the regular
        # Word(alphanums) will only match on American ASCII alphanums and since
        # we try to be Unicode / internationally friendly we need to match much
        # much more. Trying to expand a word class to catch it all seems futile
        # so we match on everything *except* a few things, like our operators
        comp_word = Regex("[^*\s=><~!]+")
        word = Regex("[^*\s=><~!]+").setResultsName('word')
        # numbers
        comp_number = Word(nums)
        number = Word(nums).setResultsName('number')

        # IPv4 address
        ipv4_oct = Regex("((2(5[0-5]|[0-4][0-9])|[01]?[0-9][0-9]?))")
        comp_ipv4_address = Combine(ipv4_oct + ('.' + ipv4_oct*3))
        ipv4_address = Combine(ipv4_oct + ('.' + ipv4_oct*3)).setResultsName('ipv4_address')

        # IPv6 address
        ipv6_address = Regex("((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(%.+)?").setResultsName('ipv6_address')
        ipv6_prefix = Combine(ipv6_address + Regex("/(12[0-8]|1[01][0-9]|[0-9][0-9]?)")).setResultsName('ipv6_prefix')

        # VRF RTs of the form number:number
        vrf_rt = Combine((comp_ipv4_address | comp_number) + Literal(':') + comp_number).setResultsName('vrf_rt')

        # tags
        tags = Combine( Literal('#') + comp_word).setResultsName('tag')

        # operators for matching
        match_op = oneOf(' '.join(self.match_operators)).setResultsName('operator')
        boolean_op = oneOf(' '.join(self.boolean_operators)).setResultsName('boolean')
        # quoted string
        d_quoted_string = QuotedString('"', unquoteResults=True, escChar='\\')
        s_quoted_string = QuotedString('\'', unquoteResults=True, escChar='\\')
        quoted_string = (s_quoted_string | d_quoted_string).setResultsName('quoted_string')
        # expression to match a certain value for an attribute
        expression = Group(word + match_op + (quoted_string | vrf_rt | word | number)).setResultsName('expression')
        # we work on atoms, which are single quoted strings, match expressions,
        # tags, VRF RT or simple words.
        # NOTE: Place them in order of most exact match first!
        atom = Group(ipv6_prefix | ipv6_address | quoted_string | expression | tags | vrf_rt | boolean_op | word)

        enclosed = Forward()
        parens = nestedExpr('(', ')', content=enclosed)
        enclosed << (
                parens | atom
                ).setResultsName('nested')

        content = Forward()
        content << (
                ZeroOrMore(enclosed)
                )

        res = content.parseString(input_string)
        return res

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import parseString [as 别名]
def parseArctl(spec):
    """Parse the spec and return its AST."""
    global __arctl
    if __arctl is None:
        true = Literal("True")
        true.setParseAction(lambda tokens: TrueExp())
        false = Literal("False")
        false.setParseAction(lambda tokens: FalseExp())
        atom = "'" + SkipTo("'") + "'"
        atom.setParseAction(lambda tokens: Atom(tokens[1]))

        action = _logicals_(atom)

        __arctl = Forward()

        proposition = true | false | atom

        notproposition = "~" + proposition
        notproposition.setParseAction(lambda tokens: Not(tokens[1]))
        formula = proposition | notproposition | Suppress("(") + __arctl + Suppress(")")

        temporal = Forward()

        e = Literal("E") + "<" + action + ">"
        a = Literal("A") + "<" + action + ">"

        eax = e + "X" + temporal
        eax.setParseAction(lambda tokens: EaX(tokens[2], tokens[5]))
        aax = a + "X" + temporal
        aax.setParseAction(lambda tokens: AaX(tokens[2], tokens[5]))

        eaf = e + "F" + temporal
        eaf.setParseAction(lambda tokens: EaF(tokens[2], tokens[5]))
        aaf = a + "F" + temporal
        aaf.setParseAction(lambda tokens: AaF(tokens[2], tokens[5]))

        eag = e + "G" + temporal
        eag.setParseAction(lambda tokens: EaG(tokens[2], tokens[5]))
        aag = a + "G" + temporal
        aag.setParseAction(lambda tokens: AaG(tokens[2], tokens[5]))

        eau = e + "[" + __arctl + "U" + __arctl + "]"
        eau.setParseAction(lambda tokens: EaU(tokens[2], tokens[5], tokens[7]))
        aau = a + "[" + __arctl + "U" + __arctl + "]"
        aau.setParseAction(lambda tokens: AaU(tokens[2], tokens[5], tokens[7]))

        eaw = e + "[" + __arctl + "W" + __arctl + "]"
        eaw.setParseAction(lambda tokens: EaW(tokens[2], tokens[5], tokens[7]))
        aaw = a + "[" + __arctl + "W" + __arctl + "]"
        aaw.setParseAction(lambda tokens: AaW(tokens[2], tokens[5], tokens[7]))

        temporal <<= formula | eax | aax | eaf | aaf | eag | aag | eau | aau | eaw | aaw

        logical = _logicals_(temporal)

        __arctl <<= logical

    return __arctl.parseString(spec, parseAll=True)

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import parseString [as 别名]
def main(s):
    lpar = Literal('(').suppress()
    rpar = Literal(')').suppress()
    integer = Word(nums)
    element = Word(alphas, exact=1)
    formula = Forward()
    term = Group((element | Group(lpar + formula + rpar)('subgroup')) +
            Optional(integer, default=1)('mult'))
    formula << OneOrMore(term)
    integer.setParseAction(process_integer)
    term.setParseAction(process_term)
    formula.setParseAction(process_formula)
    return formula.parseString(s)[0]

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import parseString [as 别名]
def parse (input):
    # parse a string into an element of the abstract representation

    # Grammar:
    #
    # <expr> ::= <integer>
    #            true
    #            false
    #            <identifier>
    #            ( if <expr> <expr> <expr> )
    #            ( let ( ( <name> <expr> ) ) <expr )
    #            ( + <expr> <expr> )
    #            ( * <expr> <expr> )
    #


    idChars = alphas+"_+*-?!=<>"

    pIDENTIFIER = Word(idChars, idChars+"0123456789")
    pIDENTIFIER.setParseAction(lambda result: EId(result[0]))

    # A name is like an identifier but it does not return an EId...
    pNAME = Word(idChars,idChars+"0123456789")

    pINTEGER = Word("-0123456789","0123456789")
    pINTEGER.setParseAction(lambda result: EInteger(int(result[0])))

    pBOOLEAN = Keyword("true") | Keyword("false")
    pBOOLEAN.setParseAction(lambda result: EBoolean(result[0]=="true"))

    pEXPR = Forward()

    pIF = "(" + Keyword("if") + pEXPR + pEXPR + pEXPR + ")"
    pIF.setParseAction(lambda result: EIf(result[2],result[3],result[4]))

    pBINDING = "(" + pNAME + pEXPR + ")"
    pBINDING.setParseAction(lambda result: (result[1],result[2]))

    pLET = "(" + Keyword("let") + "(" + pBINDING + ")" + pEXPR + ")"
    pLET.setParseAction(lambda result: ELet([result[3]],result[5]))

    pPLUS = "(" + Keyword("+") + pEXPR + pEXPR + ")"
    pPLUS.setParseAction(lambda result: ECall("+",[result[2],result[3]]))

    pTIMES = "(" + Keyword("*") + pEXPR + pEXPR + ")"
    pTIMES.setParseAction(lambda result: ECall("*",[result[2],result[3]]))

    pEXPR << (pINTEGER | pBOOLEAN | pIDENTIFIER | pIF | pLET | pPLUS | pTIMES)

    result = pEXPR.parseString(input)[0]
    return result    # the first element of the result is the expression

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import parseString [as 别名]
    def __init__(self, query):
        self._methods = {
            'and': self.evaluate_and,
            'or': self.evaluate_or,
            'not': self.evaluate_not,
            'parenthesis': self.evaluate_parenthesis,
            'quotes': self.evaluate_quotes,
            'word': self.evaluate_word,
        }

        self.line = ''
        self.query = query.lower() if query else ''

        if self.query:
            operator_or = Forward()
            operator_word = Group(Word(alphanums)).setResultsName('word')

            operator_quotes_content = Forward()
            operator_quotes_content << (
                (operator_word + operator_quotes_content) | operator_word
            )

            operator_quotes = Group(
                Suppress('"') + operator_quotes_content + Suppress('"')
            ).setResultsName("quotes") | operator_word

            operator_parenthesis = Group(
                (Suppress("(") + operator_or + Suppress(")"))
            ).setResultsName("parenthesis") | operator_quotes

            operator_not = Forward()
            operator_not << (Group(
                Suppress(Keyword("not", caseless=True)) + operator_not
            ).setResultsName("not") | operator_parenthesis)

            operator_and = Forward()
            operator_and << (Group(
                operator_not + Suppress(Keyword("and", caseless=True)) + operator_and
            ).setResultsName("and") | Group(
                operator_not + OneOrMore(~oneOf("and or") + operator_and)
            ).setResultsName("and") | operator_not)

            operator_or << (Group(
                operator_and + Suppress(Keyword("or", caseless=True)) + operator_or
            ).setResultsName("or") | operator_and)

            self._parser = operator_or.parseString(self.query)[0]
        else:
            self._parser = False

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import parseString [as 别名]
def sandbox():
    """Based on http://stackoverflow.com/a/4802004/623735"""
    loose_grammar = Forward()
    nestedParens = nestedExpr('(', ')', content=loose_grammar) 
    loose_grammar << (
                 OneOrMore(Optional(':').suppress() + Word(alphanums + '-_')) 
               | OneOrMore(Optional('?').suppress() + Word(alphanums + '-_')) 
               | init
               | goal
               | ',' 
               | nestedParens)
    examples = [
        # definitely not PDDL-compliant, but parser does OK anyway (not strict)
        '(some global things (:a (nested list of three varibles (?list0 ?list1 ?list2))))',
        # this is a valid line of STRIPS (subset of PDDL grammar?)
        '(:requirements :strips)',
        # another valid line of STRIPS (subset of PDDL grammar?)
        '(define (domain random-domain))',
        # a complete (if simple) STRIPS problem definition from coursera AI Planning class, HW wk2
        r'''
            (define (problem random-pbl1)
              (:domain random-domain)
              (:init
                 (S B B) (S C B) (S A C)
                 (R B B) (R C B))
              (:goal (and (S A A))))
        ''',
        # a complete STRIPS domain definition from coursera AI Planning class, HW wk2
        r'''
        (define (domain random-domain)
          (:requirements :strips)
          (:action op1
            :parameters (?x1 ?x2 ?x3)
            :precondition (and (S ?x1 ?x2) (R ?x3 ?x1))
            :effect (and (S ?x2 ?x1) (S ?x1 ?x3) (not (R ?x3 ?x1))))
          (:action op2
            :parameters (?x1 ?x2 ?x3)
            :precondition (and (S ?x3 ?x1) (R ?x2 ?x2))
            :effect (and (S ?x1 ?x3) (not (S ?x3 ?x1)))))
        ''',
        ]
    ans = []
    for ex in examples:
        try:
            ans += [loose_grammar.parseString(ex).asList()]
            print(ans[-1])
        except:
            print_exc()
    return ans

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import parseString [as 别名]
    def _string_to_ast(self, input_string):
        """ Parse a smart search string and return it in an AST like form
        """

        # simple words
        comp_word = Word(alphanums + "-./_")
        word = Word(alphanums + "-./_").setResultsName('word')
        # numbers
        comp_number = Word(nums)
        number = Word(nums).setResultsName('number')

        # IPv4 address
        ipv4_oct = Regex("((2(5[0-5]|[0-4][0-9])|[01]?[0-9][0-9]?))")
        comp_ipv4_address = Combine(ipv4_oct + ('.' + ipv4_oct*3))
        ipv4_address = Combine(ipv4_oct + ('.' + ipv4_oct*3)).setResultsName('ipv4_address')

        # VRF RTs of the form number:number
        vrf_rt = Combine((comp_ipv4_address | comp_number) + Literal(':') + comp_number).setResultsName('vrf_rt')

        # tags
        tags = Combine( Literal('#') + comp_word).setResultsName('tag')

        # operators for matching
        match_op = oneOf(' '.join(self.match_operators)).setResultsName('operator')
        boolean_op = oneOf(' '.join(self.boolean_operators)).setResultsName('boolean')
        # quoted string
        quoted_string = QuotedString('"', unquoteResults=True, escChar='\\').setResultsName('quoted_string')
        # expression to match a certain value for an attribute
        expression = Group(word + match_op + (quoted_string | vrf_rt | word | number)).setResultsName('expression')
        # we work on atoms, which are single quoted strings, match expressions,
        # tags, VRF RT or simple words.
        # NOTE: Place them in order of most exact match first!
        atom = Group(quoted_string | expression | tags | vrf_rt | boolean_op | word)

        enclosed = Forward()
        parens = nestedExpr('(', ')', content=enclosed)
        enclosed << (
                parens | atom
                ).setResultsName('nested')

        content = Forward()
        content << (
                ZeroOrMore(enclosed)
                )

        res = content.parseString(input_string)
        return res