# module pyparsing.py+ −
+ −
#+ −
+ −
# Copyright (c) 2003-2006 Paul T. McGuire+ −
+ −
#+ −
+ −
# Permission is hereby granted, free of charge, to any person obtaining+ −
+ −
# a copy of this software and associated documentation files (the+ −
+ −
# "Software"), to deal in the Software without restriction, including+ −
+ −
# without limitation the rights to use, copy, modify, merge, publish,+ −
+ −
# distribute, sublicense, and/or sell copies of the Software, and to+ −
+ −
# permit persons to whom the Software is furnished to do so, subject to+ −
+ −
# the following conditions:+ −
+ −
#+ −
+ −
# The above copyright notice and this permission notice shall be+ −
+ −
# included in all copies or substantial portions of the Software.+ −
+ −
#+ −
+ −
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,+ −
+ −
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF+ −
+ −
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.+ −
+ −
# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY+ −
+ −
# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,+ −
+ −
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE+ −
+ −
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.+ −
+ −
#+ −
+ −
#from __future__ import generators+ −
+ −
+ −
+ −
__doc__ = \+ −
"""+ −
+ −
pyparsing module - Classes and methods to define and execute parsing grammars+ −
+ −
+ −
+ −
The pyparsing module is an alternative approach to creating and executing simple grammars, + −
+ −
vs. the traditional lex/yacc approach, or the use of regular expressions. With pyparsing, you+ −
+ −
don't need to learn a new syntax for defining grammars or matching expressions - the parsing module + −
+ −
provides a library of classes that you use to construct the grammar directly in Python.+ −
+ −
+ −
+ −
Here is a program to parse "Hello, World!" (or any greeting of the form "<salutation>, <addressee>!")::+ −
+ −
+ −
+ −
from pyparsing import Word, alphas+ −
+ −
+ −
+ −
# define grammar of a greeting+ −
+ −
greet = Word( alphas ) + "," + Word( alphas ) + "!" + −
+ −
+ −
+ −
hello = "Hello, World!"+ −
+ −
print hello, "->", greet.parseString( hello )+ −
+ −
+ −
+ −
The program outputs the following::+ −
+ −
+ −
+ −
Hello, World! -> ['Hello', ',', 'World', '!']+ −
+ −
+ −
+ −
The Python representation of the grammar is quite readable, owing to the self-explanatory + −
+ −
class names, and the use of '+', '|' and '^' operators.+ −
+ −
+ −
+ −
The parsed results returned from parseString() can be accessed as a nested list, a dictionary, or an + −
+ −
object with named attributes.+ −
+ −
+ −
+ −
The pyparsing module handles some of the problems that are typically vexing when writing text parsers:+ −
+ −
- extra or missing whitespace (the above program will also handle "Hello,World!", "Hello , World !", etc.)+ −
+ −
- quoted strings+ −
+ −
- embedded comments+ −
+ −
"""+ −
+ −
__version__ = "1.4.5"+ −
+ −
__versionTime__ = "16 December 2006 07:20"+ −
+ −
__author__ = "Paul McGuire <ptmcg@users.sourceforge.net>"+ −
+ −
+ −
+ −
import string+ −
+ −
import copy,sys+ −
+ −
import warnings+ −
+ −
import re+ −
+ −
import sre_constants+ −
+ −
import xml.sax.saxutils+ −
+ −
#~ sys.stderr.write( "testing pyparsing module, version %s, %s\n" % (__version__,__versionTime__ ) )+ −
+ −
+ −
+ −
def _ustr(obj):+ −
+ −
"""Drop-in replacement for str(obj) that tries to be Unicode friendly. It first tries+ −
+ −
str(obj). If that fails with a UnicodeEncodeError, then it tries unicode(obj). It+ −
+ −
then < returns the unicode object | encodes it with the default encoding | ... >.+ −
+ −
"""+ −
+ −
try:+ −
+ −
# If this works, then _ustr(obj) has the same behaviour as str(obj), so+ −
+ −
# it won't break any existing code.+ −
+ −
return str(obj)+ −
+ −
+ −
+ −
except UnicodeEncodeError, e:+ −
+ −
# The Python docs (http://docs.python.org/ref/customization.html#l2h-182)+ −
+ −
# state that "The return value must be a string object". However, does a+ −
+ −
# unicode object (being a subclass of basestring) count as a "string+ −
+ −
# object"?+ −
+ −
# If so, then return a unicode object:+ −
+ −
return unicode(obj)+ −
+ −
# Else encode it... but how? There are many choices... :)+ −
+ −
# Replace unprintables with escape codes?+ −
+ −
#return unicode(obj).encode(sys.getdefaultencoding(), 'backslashreplace_errors')+ −
+ −
# Replace unprintables with question marks?+ −
+ −
#return unicode(obj).encode(sys.getdefaultencoding(), 'replace')+ −
+ −
# ...+ −
+ −
+ −
+ −
def _str2dict(strg):+ −
+ −
return dict( [(c,0) for c in strg] )+ −
+ −
#~ return set( [c for c in strg] )+ −
+ −
+ −
+ −
class _Constants(object):+ −
+ −
pass+ −
+ −
+ −
+ −
alphas = string.lowercase + string.uppercase+ −
+ −
nums = string.digits+ −
+ −
hexnums = nums + "ABCDEFabcdef"+ −
+ −
alphanums = alphas + nums + −
+ −
+ −
+ −
class ParseBaseException(Exception):+ −
+ −
"""base exception class for all parsing runtime exceptions"""+ −
+ −
__slots__ = ( "loc","msg","pstr","parserElement" )+ −
+ −
# Performance tuning: we construct a *lot* of these, so keep this+ −
+ −
# constructor as small and fast as possible + −
+ −
def __init__( self, pstr, loc, msg, elem=None ):+ −
+ −
self.loc = loc+ −
+ −
self.msg = msg+ −
+ −
self.pstr = pstr+ −
+ −
self.parserElement = elem+ −
+ −
+ −
+ −
def __getattr__( self, aname ):+ −
+ −
"""supported attributes by name are:+ −
+ −
- lineno - returns the line number of the exception text+ −
+ −
- col - returns the column number of the exception text+ −
+ −
- line - returns the line containing the exception text+ −
+ −
"""+ −
+ −
if( aname == "lineno" ):+ −
+ −
return lineno( self.loc, self.pstr )+ −
+ −
elif( aname in ("col", "column") ):+ −
+ −
return col( self.loc, self.pstr )+ −
+ −
elif( aname == "line" ):+ −
+ −
return line( self.loc, self.pstr )+ −
+ −
else:+ −
+ −
raise AttributeError, aname+ −
+ −
+ −
+ −
def __str__( self ):+ −
+ −
return "%s (at char %d), (line:%d, col:%d)" % ( self.msg, self.loc, self.lineno, self.column )+ −
+ −
def __repr__( self ):+ −
+ −
return _ustr(self)+ −
+ −
def markInputline( self, markerString = ">!<" ):+ −
+ −
"""Extracts the exception line from the input string, and marks + −
+ −
the location of the exception with a special symbol.+ −
+ −
"""+ −
+ −
line_str = self.line+ −
+ −
line_column = self.column - 1+ −
+ −
if markerString:+ −
+ −
line_str = "".join( [line_str[:line_column], markerString, line_str[line_column:]])+ −
+ −
return line_str.strip()+ −
+ −
+ −
+ −
class ParseException(ParseBaseException):+ −
+ −
"""exception thrown when parse expressions don't match class"""+ −
+ −
"""supported attributes by name are:+ −
+ −
- lineno - returns the line number of the exception text+ −
+ −
- col - returns the column number of the exception text+ −
+ −
- line - returns the line containing the exception text+ −
+ −
"""+ −
+ −
pass+ −
+ −
+ −
+ −
class ParseFatalException(ParseBaseException):+ −
+ −
"""user-throwable exception thrown when inconsistent parse content+ −
+ −
is found; stops all parsing immediately"""+ −
+ −
pass+ −
+ −
+ −
+ −
class ReparseException(ParseBaseException):+ −
+ −
def __init_( self, newstring, restartLoc ):+ −
+ −
self.newParseText = newstring+ −
+ −
self.reparseLoc = restartLoc+ −
+ −
+ −
+ −
+ −
+ −
class RecursiveGrammarException(Exception):+ −
+ −
"""exception thrown by validate() if the grammar could be improperly recursive"""+ −
+ −
def __init__( self, parseElementList ):+ −
+ −
self.parseElementTrace = parseElementList+ −
+ −
+ −
+ −
def __str__( self ):+ −
+ −
return "RecursiveGrammarException: %s" % self.parseElementTrace+ −
+ −
+ −
+ −
class ParseResults(object):+ −
+ −
"""Structured parse results, to provide multiple means of access to the parsed data:+ −
+ −
- as a list (len(results))+ −
+ −
- by list index (results[0], results[1], etc.)+ −
+ −
- by attribute (results.<resultsName>)+ −
+ −
"""+ −
+ −
__slots__ = ( "__toklist", "__tokdict", "__doinit", "__name", "__parent", "__accumNames" )+ −
+ −
def __new__(cls, toklist, name=None, asList=True, modal=True ):+ −
+ −
if isinstance(toklist, cls):+ −
+ −
return toklist+ −
+ −
retobj = object.__new__(cls)+ −
+ −
retobj.__doinit = True+ −
+ −
return retobj+ −
+ −
+ −
+ −
# Performance tuning: we construct a *lot* of these, so keep this+ −
+ −
# constructor as small and fast as possible+ −
+ −
def __init__( self, toklist, name=None, asList=True, modal=True ):+ −
+ −
if self.__doinit:+ −
+ −
self.__doinit = False+ −
+ −
self.__name = None+ −
+ −
self.__parent = None+ −
+ −
self.__accumNames = {}+ −
+ −
if isinstance(toklist, list):+ −
+ −
self.__toklist = toklist[:]+ −
+ −
else:+ −
+ −
self.__toklist = [toklist]+ −
+ −
self.__tokdict = dict()+ −
+ −
+ −
+ −
# this line is related to debugging the asXML bug+ −
+ −
#~ asList = False+ −
+ −
+ −
+ −
if name:+ −
+ −
if not modal:+ −
+ −
self.__accumNames[name] = 0+ −
+ −
if isinstance(name,int):+ −
+ −
name = _ustr(name) # will always return a str, but use _ustr for consistency+ −
+ −
self.__name = name+ −
+ −
if not toklist in (None,'',[]):+ −
+ −
if isinstance(toklist,basestring): + −
+ −
toklist = [ toklist ]+ −
+ −
if asList:+ −
+ −
if isinstance(toklist,ParseResults):+ −
+ −
self[name] = (toklist.copy(),-1)+ −
+ −
else:+ −
+ −
self[name] = (ParseResults(toklist[0]),-1)+ −
+ −
self[name].__name = name+ −
+ −
else:+ −
+ −
try:+ −
+ −
self[name] = toklist[0]+ −
+ −
except (KeyError,TypeError):+ −
+ −
self[name] = toklist+ −
+ −
+ −
+ −
def __getitem__( self, i ):+ −
+ −
if isinstance( i, (int,slice) ):+ −
+ −
return self.__toklist[i]+ −
+ −
else:+ −
+ −
if i not in self.__accumNames:+ −
+ −
return self.__tokdict[i][-1][0]+ −
+ −
else:+ −
+ −
return ParseResults([ v[0] for v in self.__tokdict[i] ])+ −
+ −
+ −
+ −
def __setitem__( self, k, v ):+ −
+ −
if isinstance(v,tuple):+ −
+ −
self.__tokdict[k] = self.__tokdict.get(k,list()) + [v]+ −
+ −
sub = v[0]+ −
+ −
elif isinstance(k,int):+ −
+ −
self.__toklist[k] = v+ −
+ −
sub = v+ −
+ −
else:+ −
+ −
self.__tokdict[k] = self.__tokdict.get(k,list()) + [(v,0)]+ −
+ −
sub = v+ −
+ −
if isinstance(sub,ParseResults):+ −
+ −
sub.__parent = self+ −
+ −
+ −
+ −
def __delitem__( self, i ):+ −
+ −
if isinstance(i,(int,slice)):+ −
+ −
del self.__toklist[i]+ −
+ −
else:+ −
+ −
del self._tokdict[i]+ −
+ −
+ −
+ −
def __contains__( self, k ):+ −
+ −
return self.__tokdict.has_key(k)+ −
+ −
+ −
+ −
def __len__( self ): return len( self.__toklist )+ −
+ −
def __nonzero__( self ): return len( self.__toklist ) > 0+ −
+ −
def __iter__( self ): return iter( self.__toklist )+ −
+ −
def keys( self ): + −
+ −
"""Returns all named result keys."""+ −
+ −
return self.__tokdict.keys()+ −
+ −
+ −
+ −
def items( self ): + −
+ −
"""Returns all named result keys and values as a list of tuples."""+ −
+ −
return [(k,self[k]) for k in self.__tokdict.keys()]+ −
+ −
+ −
+ −
def values( self ): + −
+ −
"""Returns all named result values."""+ −
+ −
return [ v[-1][0] for v in self.__tokdict.values() ]+ −
+ −
+ −
+ −
def __getattr__( self, name ):+ −
+ −
if name not in self.__slots__:+ −
+ −
if self.__tokdict.has_key( name ):+ −
+ −
if name not in self.__accumNames:+ −
+ −
return self.__tokdict[name][-1][0]+ −
+ −
else:+ −
+ −
return ParseResults([ v[0] for v in self.__tokdict[name] ])+ −
+ −
else:+ −
+ −
return ""+ −
+ −
return None+ −
+ −
+ −
+ −
def __add__( self, other ):+ −
+ −
ret = self.copy()+ −
+ −
ret += other+ −
+ −
return ret+ −
+ −
+ −
+ −
def __iadd__( self, other ):+ −
+ −
if other.__tokdict:+ −
+ −
offset = len(self.__toklist)+ −
+ −
addoffset = ( lambda a: (a<0 and offset) or (a+offset) )+ −
+ −
otheritems = other.__tokdict.items()+ −
+ −
otherdictitems = [(k,(v[0],addoffset(v[1])) ) for (k,vlist) in otheritems for v in vlist]+ −
+ −
for k,v in otherdictitems:+ −
+ −
self[k] = v+ −
+ −
if isinstance(v[0],ParseResults):+ −
+ −
v[0].__parent = self+ −
+ −
self.__toklist += other.__toklist+ −
+ −
self.__accumNames.update( other.__accumNames )+ −
+ −
del other+ −
+ −
return self+ −
+ −
+ −
+ −
def __repr__( self ):+ −
+ −
return "(%s, %s)" % ( repr( self.__toklist ), repr( self.__tokdict ) )+ −
+ −
+ −
+ −
def __str__( self ):+ −
+ −
out = "["+ −
+ −
sep = ""+ −
+ −
for i in self.__toklist:+ −
+ −
if isinstance(i, ParseResults):+ −
+ −
out += sep + _ustr(i)+ −
+ −
else:+ −
+ −
out += sep + repr(i)+ −
+ −
sep = ", "+ −
+ −
out += "]"+ −
+ −
return out+ −
+ −
+ −
+ −
def _asStringList( self, sep='' ):+ −
+ −
out = []+ −
+ −
for item in self.__toklist:+ −
+ −
if out and sep:+ −
+ −
out.append(sep)+ −
+ −
if isinstance( item, ParseResults ):+ −
+ −
out += item._asStringList()+ −
+ −
else:+ −
+ −
out.append( _ustr(item) )+ −
+ −
return out+ −
+ −
+ −
+ −
def asList( self ):+ −
+ −
"""Returns the parse results as a nested list of matching tokens, all converted to strings."""+ −
+ −
out = []+ −
+ −
for res in self.__toklist:+ −
+ −
if isinstance(res,ParseResults):+ −
+ −
out.append( res.asList() )+ −
+ −
else:+ −
+ −
out.append( res )+ −
+ −
return out+ −
+ −
+ −
+ −
def asDict( self ):+ −
+ −
"""Returns the named parse results as dictionary."""+ −
+ −
return dict( self.items() )+ −
+ −
+ −
+ −
def copy( self ):+ −
+ −
"""Returns a new copy of a ParseResults object."""+ −
+ −
ret = ParseResults( self.__toklist )+ −
+ −
ret.__tokdict = self.__tokdict.copy()+ −
+ −
ret.__parent = self.__parent+ −
+ −
ret.__accumNames.update( self.__accumNames )+ −
+ −
ret.__name = self.__name+ −
+ −
return ret+ −
+ −
+ −
+ −
def asXML( self, doctag=None, namedItemsOnly=False, indent="", formatted=True ):+ −
+ −
"""Returns the parse results as XML. Tags are created for tokens and lists that have defined results names."""+ −
+ −
nl = "\n"+ −
+ −
out = []+ −
+ −
namedItems = dict( [ (v[1],k) for (k,vlist) in self.__tokdict.items() for v in vlist ] )+ −
+ −
nextLevelIndent = indent + " "+ −
+ −
+ −
+ −
# collapse out indents if formatting is not desired+ −
+ −
if not formatted:+ −
+ −
indent = ""+ −
+ −
nextLevelIndent = ""+ −
+ −
nl = ""+ −
+ −
+ −
+ −
selfTag = None+ −
+ −
if doctag is not None:+ −
+ −
selfTag = doctag+ −
+ −
else:+ −
+ −
if self.__name:+ −
+ −
selfTag = self.__name+ −
+ −
+ −
+ −
if not selfTag:+ −
+ −
if namedItemsOnly:+ −
+ −
return ""+ −
+ −
else:+ −
+ −
selfTag = "ITEM"+ −
+ −
+ −
+ −
out += [ nl, indent, "<", selfTag, ">" ]+ −
+ −
+ −
+ −
worklist = self.__toklist+ −
+ −
for i,res in enumerate(worklist):+ −
+ −
if isinstance(res,ParseResults):+ −
+ −
if i in namedItems:+ −
+ −
out += [ res.asXML(namedItems[i], namedItemsOnly and doctag is None, nextLevelIndent,formatted)]+ −
+ −
else:+ −
+ −
out += [ res.asXML(None, namedItemsOnly and doctag is None, nextLevelIndent,formatted)]+ −
+ −
else:+ −
+ −
# individual token, see if there is a name for it+ −
+ −
resTag = None+ −
+ −
if i in namedItems:+ −
+ −
resTag = namedItems[i]+ −
+ −
if not resTag:+ −
+ −
if namedItemsOnly:+ −
+ −
continue+ −
+ −
else:+ −
+ −
resTag = "ITEM"+ −
+ −
xmlBodyText = xml.sax.saxutils.escape(_ustr(res))+ −
+ −
out += [ nl, nextLevelIndent, "<", resTag, ">", xmlBodyText, "</", resTag, ">" ]+ −
+ −
+ −
+ −
out += [ nl, indent, "</", selfTag, ">" ]+ −
+ −
return "".join(out)+ −
+ −
+ −
+ −
def __lookup(self,sub):+ −
+ −
for k,vlist in self.__tokdict.items():+ −
+ −
for v,loc in vlist:+ −
+ −
if sub is v:+ −
+ −
return k+ −
+ −
return None+ −
+ −
+ −
+ −
def getName(self):+ −
+ −
"""Returns the results name for this token expression."""+ −
+ −
if self.__name:+ −
+ −
return self.__name+ −
+ −
elif self.__parent:+ −
+ −
par = self.__parent+ −
+ −
if par:+ −
+ −
return par.__lookup(self)+ −
+ −
else:+ −
+ −
return None+ −
+ −
elif (len(self) == 1 and + −
+ −
len(self.__tokdict) == 1 and+ −
+ −
self.__tokdict.values()[0][0][1] in (0,-1)):+ −
+ −
return self.__tokdict.keys()[0]+ −
+ −
else:+ −
+ −
return None+ −
+ −
+ −
+ −
def dump(self,indent='',depth=0):+ −
+ −
"""Diagnostic method for listing out the contents of a ParseResults.+ −
+ −
Accepts an optional indent argument so that this string can be embedded+ −
+ −
in a nested display of other data."""+ −
+ −
out = []+ −
+ −
out.append( indent+str(self.asList()) )+ −
+ −
keys = self.items()+ −
+ −
keys.sort()+ −
+ −
for k,v in keys:+ −
+ −
if out:+ −
+ −
out.append('\n')+ −
+ −
out.append( "%s%s- %s: " % (indent,(' '*depth), k) )+ −
+ −
if isinstance(v,ParseResults):+ −
+ −
if v.keys():+ −
+ −
#~ out.append('\n')+ −
+ −
out.append( v.dump(indent,depth+1) )+ −
+ −
#~ out.append('\n')+ −
+ −
else:+ −
+ −
out.append(str(v))+ −
+ −
else:+ −
+ −
out.append(str(v))+ −
+ −
#~ out.append('\n')+ −
+ −
return "".join(out)+ −
+ −
+ −
+ −
# add support for pickle protocol+ −
+ −
def __getstate__(self):+ −
+ −
return ( self.__toklist,+ −
+ −
( self.__tokdict.copy(),+ −
+ −
self.__parent,+ −
+ −
self.__accumNames,+ −
+ −
self.__name ) )+ −
+ −
+ −
+ −
def __setstate__(self,state):+ −
+ −
self.__toklist = state[0]+ −
+ −
self.__tokdict, \+ −
+ −
self.__parent, \+ −
+ −
inAccumNames, \+ −
+ −
self.__name = state[1]+ −
+ −
self.__accumNames = {}+ −
+ −
self.__accumNames.update(inAccumNames)+ −
+ −
+ −
+ −
+ −
+ −
def col (loc,strg):+ −
+ −
"""Returns current column within a string, counting newlines as line separators.+ −
+ −
The first column is number 1.+ −
+ −
"""+ −
+ −
return (loc<len(strg) and strg[loc] == '\n') and 1 or loc - strg.rfind("\n", 0, loc)+ −
+ −
+ −
+ −
def lineno(loc,strg):+ −
+ −
"""Returns current line number within a string, counting newlines as line separators.+ −
+ −
The first line is number 1.+ −
+ −
"""+ −
+ −
return strg.count("\n",0,loc) + 1+ −
+ −
+ −
+ −
def line( loc, strg ):+ −
+ −
"""Returns the line of text containing loc within a string, counting newlines as line separators.+ −
+ −
"""+ −
+ −
lastCR = strg.rfind("\n", 0, loc)+ −
+ −
nextCR = strg.find("\n", loc)+ −
+ −
if nextCR > 0:+ −
+ −
return strg[lastCR+1:nextCR]+ −
+ −
else:+ −
+ −
return strg[lastCR+1:]+ −
+ −
+ −
+ −
def _defaultStartDebugAction( instring, loc, expr ):+ −
+ −
print "Match",expr,"at loc",loc,"(%d,%d)" % ( lineno(loc,instring), col(loc,instring) )+ −
+ −
+ −
+ −
def _defaultSuccessDebugAction( instring, startloc, endloc, expr, toks ):+ −
+ −
print "Matched",expr,"->",toks.asList()+ −
+ −
+ −
+ −
def _defaultExceptionDebugAction( instring, loc, expr, exc ):+ −
+ −
print "Exception raised:", exc+ −
+ −
+ −
+ −
def nullDebugAction(*args):+ −
+ −
"""'Do-nothing' debug action, to suppress debugging output during parsing."""+ −
+ −
pass+ −
+ −
+ −
+ −
class ParserElement(object):+ −
+ −
"""Abstract base level parser element class."""+ −
+ −
DEFAULT_WHITE_CHARS = " \n\t\r"+ −
+ −
+ −
+ −
def setDefaultWhitespaceChars( chars ):+ −
+ −
"""Overrides the default whitespace chars+ −
+ −
"""+ −
+ −
ParserElement.DEFAULT_WHITE_CHARS = chars+ −
+ −
setDefaultWhitespaceChars = staticmethod(setDefaultWhitespaceChars)+ −
+ −
+ −
+ −
def __init__( self, savelist=False ):+ −
+ −
self.parseAction = list()+ −
+ −
self.failAction = None+ −
+ −
#~ self.name = "<unknown>" # don't define self.name, let subclasses try/except upcall+ −
+ −
self.strRepr = None+ −
+ −
self.resultsName = None+ −
+ −
self.saveAsList = savelist+ −
+ −
self.skipWhitespace = True+ −
+ −
self.whiteChars = ParserElement.DEFAULT_WHITE_CHARS+ −
+ −
self.copyDefaultWhiteChars = True+ −
+ −
self.mayReturnEmpty = False+ −
+ −
self.keepTabs = False+ −
+ −
self.ignoreExprs = list()+ −
+ −
self.debug = False+ −
+ −
self.streamlined = False+ −
+ −
self.mayIndexError = True+ −
+ −
self.errmsg = ""+ −
+ −
self.modalResults = True+ −
+ −
self.debugActions = ( None, None, None )+ −
+ −
self.re = None+ −
+ −
+ −
+ −
def copy( self ):+ −
+ −
"""Make a copy of this ParserElement. Useful for defining different parse actions+ −
+ −
for the same parsing pattern, using copies of the original parse element."""+ −
+ −
cpy = copy.copy( self )+ −
+ −
cpy.parseAction = self.parseAction[:]+ −
+ −
cpy.ignoreExprs = self.ignoreExprs[:]+ −
+ −
if self.copyDefaultWhiteChars:+ −
+ −
cpy.whiteChars = ParserElement.DEFAULT_WHITE_CHARS+ −
+ −
return cpy+ −
+ −
+ −
+ −
def setName( self, name ):+ −
+ −
"""Define name for this expression, for use in debugging."""+ −
+ −
self.name = name+ −
+ −
self.errmsg = "Expected " + self.name+ −
+ −
return self+ −
+ −
+ −
+ −
def setResultsName( self, name, listAllMatches=False ):+ −
+ −
"""Define name for referencing matching tokens as a nested attribute + −
+ −
of the returned parse results.+ −
+ −
NOTE: this returns a *copy* of the original ParserElement object;+ −
+ −
this is so that the client can define a basic element, such as an+ −
+ −
integer, and reference it in multiple places with different names.+ −
+ −
"""+ −
+ −
newself = self.copy()+ −
+ −
newself.resultsName = name+ −
+ −
newself.modalResults = not listAllMatches+ −
+ −
return newself+ −
+ −
+ −
+ −
def normalizeParseActionArgs( f ):+ −
+ −
"""Internal method used to decorate parse actions that take fewer than 3 arguments,+ −
+ −
so that all parse actions can be called as f(s,l,t)."""+ −
+ −
STAR_ARGS = 4+ −
+ −
+ −
+ −
try:+ −
+ −
restore = None+ −
+ −
if isinstance(f,type):+ −
+ −
restore = f+ −
+ −
f = f.__init__+ −
+ −
if f.func_code.co_flags & STAR_ARGS:+ −
+ −
return f+ −
+ −
numargs = f.func_code.co_argcount+ −
+ −
if hasattr(f,"im_self"):+ −
+ −
numargs -= 1+ −
+ −
if restore:+ −
+ −
f = restore+ −
+ −
except AttributeError:+ −
+ −
try:+ −
+ −
# not a function, must be a callable object, get info from the+ −
+ −
# im_func binding of its bound __call__ method+ −
+ −
if f.__call__.im_func.func_code.co_flags & STAR_ARGS:+ −
+ −
return f+ −
+ −
numargs = f.__call__.im_func.func_code.co_argcount+ −
+ −
if hasattr(f.__call__,"im_self"):+ −
+ −
numargs -= 1+ −
+ −
except AttributeError:+ −
+ −
# not a bound method, get info directly from __call__ method+ −
+ −
if f.__call__.func_code.co_flags & STAR_ARGS:+ −
+ −
return f+ −
+ −
numargs = f.__call__.func_code.co_argcount+ −
+ −
if hasattr(f.__call__,"im_self"):+ −
+ −
numargs -= 1+ −
+ −
+ −
+ −
#~ print "adding function %s with %d args" % (f.func_name,numargs)+ −
+ −
if numargs == 3:+ −
+ −
return f+ −
+ −
else:+ −
+ −
if numargs == 2:+ −
+ −
def tmp(s,l,t):+ −
+ −
return f(l,t)+ −
+ −
elif numargs == 1:+ −
+ −
def tmp(s,l,t):+ −
+ −
return f(t)+ −
+ −
else: #~ numargs == 0:+ −
+ −
def tmp(s,l,t):+ −
+ −
return f()+ −
+ −
return tmp+ −
+ −
normalizeParseActionArgs = staticmethod(normalizeParseActionArgs)+ −
+ −
+ −
+ −
def setParseAction( self, *fns ):+ −
+ −
"""Define action to perform when successfully matching parse element definition.+ −
+ −
Parse action fn is a callable method with 0-3 arguments, called as fn(s,loc,toks),+ −
+ −
fn(loc,toks), fn(toks), or just fn(), where:+ −
+ −
- s = the original string being parsed+ −
+ −
- loc = the location of the matching substring+ −
+ −
- toks = a list of the matched tokens, packaged as a ParseResults object+ −
+ −
If the functions in fns modify the tokens, they can return them as the return+ −
+ −
value from fn, and the modified list of tokens will replace the original.+ −
+ −
Otherwise, fn does not need to return any value."""+ −
+ −
self.parseAction = map(self.normalizeParseActionArgs, list(fns))+ −
+ −
return self+ −
+ −
+ −
+ −
def addParseAction( self, *fns ):+ −
+ −
"""Add parse action to expression's list of parse actions. See setParseAction_."""+ −
+ −
self.parseAction += map(self.normalizeParseActionArgs, list(fns))+ −
+ −
return self+ −
+ −
+ −
+ −
def setFailAction( self, fn ):+ −
+ −
"""Define action to perform if parsing fails at this expression. + −
+ −
Fail acton fn is a callable function that takes the arguments + −
+ −
fn(s,loc,expr,err) where:+ −
+ −
- s = string being parsed+ −
+ −
- loc = location where expression match was attempted and failed+ −
+ −
- expr = the parse expression that failed+ −
+ −
- err = the exception thrown+ −
+ −
The function returns no value. It may throw ParseFatalException+ −
+ −
if it is desired to stop parsing immediately."""+ −
+ −
self.failAction = fn+ −
+ −
return self+ −
+ −
+ −
+ −
def skipIgnorables( self, instring, loc ):+ −
+ −
exprsFound = True+ −
+ −
while exprsFound:+ −
+ −
exprsFound = False+ −
+ −
for e in self.ignoreExprs:+ −
+ −
try:+ −
+ −
while 1:+ −
+ −
loc,dummy = e._parse( instring, loc )+ −
+ −
exprsFound = True+ −
+ −
except ParseException:+ −
+ −
pass+ −
+ −
return loc+ −
+ −
+ −
+ −
def preParse( self, instring, loc ):+ −
+ −
if self.ignoreExprs:+ −
+ −
loc = self.skipIgnorables( instring, loc )+ −
+ −
+ −
+ −
if self.skipWhitespace:+ −
+ −
wt = self.whiteChars+ −
+ −
instrlen = len(instring)+ −
+ −
while loc < instrlen and instring[loc] in wt:+ −
+ −
loc += 1+ −
+ −
+ −
+ −
return loc+ −
+ −
+ −
+ −
def parseImpl( self, instring, loc, doActions=True ):+ −
+ −
return loc, []+ −
+ −
+ −
+ −
def postParse( self, instring, loc, tokenlist ):+ −
+ −
return tokenlist+ −
+ −
+ −
+ −
#~ @profile+ −
+ −
def _parseNoCache( self, instring, loc, doActions=True, callPreParse=True ):+ −
+ −
debugging = ( self.debug ) #and doActions )+ −
+ −
+ −
+ −
if debugging or self.failAction:+ −
+ −
#~ print "Match",self,"at loc",loc,"(%d,%d)" % ( lineno(loc,instring), col(loc,instring) )+ −
+ −
if (self.debugActions[0] ):+ −
+ −
self.debugActions[0]( instring, loc, self )+ −
+ −
if callPreParse:+ −
+ −
preloc = self.preParse( instring, loc )+ −
+ −
else:+ −
+ −
preloc = loc+ −
+ −
tokensStart = loc+ −
+ −
try:+ −
+ −
try:+ −
+ −
loc,tokens = self.parseImpl( instring, preloc, doActions )+ −
+ −
except IndexError:+ −
+ −
raise ParseException( instring, len(instring), self.errmsg, self )+ −
+ −
#~ except ReparseException, retryEx:+ −
+ −
#~ pass+ −
+ −
except ParseException, err:+ −
+ −
#~ print "Exception raised:", err+ −
+ −
if self.debugActions[2]:+ −
+ −
self.debugActions[2]( instring, tokensStart, self, err )+ −
+ −
if self.failAction:+ −
+ −
self.failAction( instring, tokensStart, self, err )+ −
+ −
raise+ −
+ −
else:+ −
+ −
if callPreParse:+ −
+ −
preloc = self.preParse( instring, loc )+ −
+ −
else:+ −
+ −
preloc = loc+ −
+ −
tokensStart = loc+ −
+ −
if self.mayIndexError or loc >= len(instring):+ −
+ −
try:+ −
+ −
loc,tokens = self.parseImpl( instring, preloc, doActions )+ −
+ −
except IndexError:+ −
+ −
raise ParseException( instring, len(instring), self.errmsg, self )+ −
+ −
else:+ −
+ −
loc,tokens = self.parseImpl( instring, preloc, doActions )+ −
+ −
+ −
+ −
tokens = self.postParse( instring, loc, tokens )+ −
+ −
+ −
+ −
retTokens = ParseResults( tokens, self.resultsName, asList=self.saveAsList, modal=self.modalResults )+ −
+ −
if self.parseAction and doActions:+ −
+ −
if debugging:+ −
+ −
try:+ −
+ −
for fn in self.parseAction:+ −
+ −
tokens = fn( instring, tokensStart, retTokens )+ −
+ −
if tokens is not None:+ −
+ −
retTokens = ParseResults( tokens, + −
+ −
self.resultsName, + −
+ −
asList=self.saveAsList and isinstance(tokens,(ParseResults,list)), + −
+ −
modal=self.modalResults )+ −
+ −
except ParseException, err:+ −
+ −
#~ print "Exception raised in user parse action:", err+ −
+ −
if (self.debugActions[2] ):+ −
+ −
self.debugActions[2]( instring, tokensStart, self, err )+ −
+ −
raise+ −
+ −
else:+ −
+ −
for fn in self.parseAction:+ −
+ −
tokens = fn( instring, tokensStart, retTokens )+ −
+ −
if tokens is not None:+ −
+ −
retTokens = ParseResults( tokens, + −
+ −
self.resultsName, + −
+ −
asList=self.saveAsList and isinstance(tokens,(ParseResults,list)), + −
+ −
modal=self.modalResults )+ −
+ −
+ −
+ −
if debugging:+ −
+ −
#~ print "Matched",self,"->",retTokens.asList()+ −
+ −
if (self.debugActions[1] ):+ −
+ −
self.debugActions[1]( instring, tokensStart, loc, self, retTokens )+ −
+ −
+ −
+ −
return loc, retTokens+ −
+ −
+ −
+ −
def tryParse( self, instring, loc ):+ −
+ −
return self._parse( instring, loc, doActions=False )[0]+ −
+ −
+ −
+ −
# this method gets repeatedly called during backtracking with the same arguments -+ −
+ −
# we can cache these arguments and save ourselves the trouble of re-parsing the contained expression+ −
+ −
def _parseCache( self, instring, loc, doActions=True, callPreParse=True ):+ −
+ −
if doActions and self.parseAction:+ −
+ −
return self._parseNoCache( instring, loc, doActions, callPreParse )+ −
+ −
lookup = (self,instring,loc,callPreParse)+ −
+ −
if lookup in ParserElement._exprArgCache:+ −
+ −
value = ParserElement._exprArgCache[ lookup ]+ −
+ −
if isinstance(value,Exception):+ −
+ −
if isinstance(value,ParseBaseException):+ −
+ −
value.loc = loc+ −
+ −
raise value+ −
+ −
return value+ −
+ −
else:+ −
+ −
try:+ −
+ −
ParserElement._exprArgCache[ lookup ] = \+ −
value = self._parseNoCache( instring, loc, doActions, callPreParse )+ −
+ −
return value+ −
+ −
except ParseBaseException, pe:+ −
+ −
ParserElement._exprArgCache[ lookup ] = pe+ −
+ −
raise+ −
+ −
+ −
+ −
_parse = _parseNoCache+ −
+ −
+ −
+ −
# argument cache for optimizing repeated calls when backtracking through recursive expressions+ −
+ −
_exprArgCache = {}+ −
+ −
def resetCache():+ −
+ −
ParserElement._exprArgCache.clear()+ −
+ −
resetCache = staticmethod(resetCache)+ −
+ −
+ −
+ −
_packratEnabled = False+ −
+ −
def enablePackrat():+ −
+ −
"""Enables "packrat" parsing, which adds memoizing to the parsing logic.+ −
+ −
Repeated parse attempts at the same string location (which happens + −
+ −
often in many complex grammars) can immediately return a cached value, + −
+ −
instead of re-executing parsing/validating code. Memoizing is done of+ −
+ −
both valid results and parsing exceptions.+ −
+ −
+ −
+ −
This speedup may break existing programs that use parse actions that + −
+ −
have side-effects. For this reason, packrat parsing is disabled when+ −
+ −
you first import pyparsing. To activate the packrat feature, your+ −
+ −
program must call the class method ParserElement.enablePackrat(). If+ −
+ −
your program uses psyco to "compile as you go", you must call + −
+ −
enablePackrat before calling psyco.full(). If you do not do this,+ −
+ −
Python will crash. For best results, call enablePackrat() immediately+ −
+ −
after importing pyparsing.+ −
+ −
"""+ −
+ −
if not ParserElement._packratEnabled:+ −
+ −
ParserElement._packratEnabled = True+ −
+ −
ParserElement._parse = ParserElement._parseCache+ −
+ −
enablePackrat = staticmethod(enablePackrat)+ −
+ −
+ −
+ −
def parseString( self, instring ):+ −
+ −
"""Execute the parse expression with the given string.+ −
+ −
This is the main interface to the client code, once the complete + −
+ −
expression has been built.+ −
+ −
"""+ −
+ −
ParserElement.resetCache()+ −
+ −
if not self.streamlined:+ −
+ −
self.streamline()+ −
+ −
#~ self.saveAsList = True+ −
+ −
for e in self.ignoreExprs:+ −
+ −
e.streamline()+ −
+ −
if self.keepTabs:+ −
+ −
loc, tokens = self._parse( instring, 0 )+ −
+ −
else:+ −
+ −
loc, tokens = self._parse( instring.expandtabs(), 0 )+ −
+ −
return tokens+ −
+ −
+ −
+ −
def scanString( self, instring, maxMatches=sys.maxint ):+ −
+ −
"""Scan the input string for expression matches. Each match will return the + −
+ −
matching tokens, start location, and end location. May be called with optional+ −
+ −
maxMatches argument, to clip scanning after 'n' matches are found."""+ −
+ −
if not self.streamlined:+ −
+ −
self.streamline()+ −
+ −
for e in self.ignoreExprs:+ −
+ −
e.streamline()+ −
+ −
+ −
+ −
if not self.keepTabs:+ −
+ −
instring = instring.expandtabs()+ −
+ −
instrlen = len(instring)+ −
+ −
loc = 0+ −
+ −
preparseFn = self.preParse+ −
+ −
parseFn = self._parse+ −
+ −
ParserElement.resetCache()+ −
+ −
matches = 0+ −
+ −
while loc <= instrlen and matches < maxMatches:+ −
+ −
try:+ −
+ −
preloc = preparseFn( instring, loc )+ −
+ −
nextLoc,tokens = parseFn( instring, preloc, callPreParse=False )+ −
+ −
except ParseException:+ −
+ −
loc = preloc+1+ −
+ −
else:+ −
+ −
matches += 1+ −
+ −
yield tokens, preloc, nextLoc+ −
+ −
loc = nextLoc+ −
+ −
+ −
+ −
def transformString( self, instring ):+ −
+ −
"""Extension to scanString, to modify matching text with modified tokens that may+ −
+ −
be returned from a parse action. To use transformString, define a grammar and + −
+ −
attach a parse action to it that modifies the returned token list. + −
+ −
Invoking transformString() on a target string will then scan for matches, + −
+ −
and replace the matched text patterns according to the logic in the parse + −
+ −
action. transformString() returns the resulting transformed string."""+ −
+ −
out = []+ −
+ −
lastE = 0+ −
+ −
# force preservation of <TAB>s, to minimize unwanted transformation of string, and to+ −
+ −
# keep string locs straight between transformString and scanString+ −
+ −
self.keepTabs = True+ −
+ −
for t,s,e in self.scanString( instring ):+ −
+ −
out.append( instring[lastE:s] )+ −
+ −
if t:+ −
+ −
if isinstance(t,ParseResults):+ −
+ −
out += t.asList()+ −
+ −
elif isinstance(t,list):+ −
+ −
out += t+ −
+ −
else:+ −
+ −
out.append(t)+ −
+ −
lastE = e+ −
+ −
out.append(instring[lastE:])+ −
+ −
return "".join(out)+ −
+ −
+ −
+ −
def searchString( self, instring, maxMatches=sys.maxint ):+ −
+ −
"""Another extension to scanString, simplifying the access to the tokens found+ −
+ −
to match the given parse expression. May be called with optional+ −
+ −
maxMatches argument, to clip searching after 'n' matches are found.+ −
+ −
"""+ −
+ −
return ParseResults([ t for t,s,e in self.scanString( instring, maxMatches ) ])+ −
+ −
+ −
+ −
def __add__(self, other ):+ −
+ −
"""Implementation of + operator - returns And"""+ −
+ −
if isinstance( other, basestring ):+ −
+ −
other = Literal( other )+ −
+ −
if not isinstance( other, ParserElement ):+ −
+ −
warnings.warn("Cannot add element of type %s to ParserElement" % type(other),+ −
+ −
SyntaxWarning, stacklevel=2)+ −
+ −
return And( [ self, other ] )+ −
+ −
+ −
+ −
def __radd__(self, other ):+ −
+ −
"""Implementation of += operator"""+ −
+ −
if isinstance( other, basestring ):+ −
+ −
other = Literal( other )+ −
+ −
if not isinstance( other, ParserElement ):+ −
+ −
warnings.warn("Cannot add element of type %s to ParserElement" % type(other),+ −
+ −
SyntaxWarning, stacklevel=2)+ −
+ −
return other + self+ −
+ −
+ −
+ −
def __or__(self, other ):+ −
+ −
"""Implementation of | operator - returns MatchFirst"""+ −
+ −
if isinstance( other, basestring ):+ −
+ −
other = Literal( other )+ −
+ −
if not isinstance( other, ParserElement ):+ −
+ −
warnings.warn("Cannot add element of type %s to ParserElement" % type(other),+ −
+ −
SyntaxWarning, stacklevel=2)+ −
+ −
return MatchFirst( [ self, other ] )+ −
+ −
+ −
+ −
def __ror__(self, other ):+ −
+ −
"""Implementation of |= operator"""+ −
+ −
if isinstance( other, basestring ):+ −
+ −
other = Literal( other )+ −
+ −
if not isinstance( other, ParserElement ):+ −
+ −
warnings.warn("Cannot add element of type %s to ParserElement" % type(other),+ −
+ −
SyntaxWarning, stacklevel=2)+ −
+ −
return other | self+ −
+ −
+ −
+ −
def __xor__(self, other ):+ −
+ −
"""Implementation of ^ operator - returns Or"""+ −
+ −
if isinstance( other, basestring ):+ −
+ −
other = Literal( other )+ −
+ −
if not isinstance( other, ParserElement ):+ −
+ −
warnings.warn("Cannot add element of type %s to ParserElement" % type(other),+ −
+ −
SyntaxWarning, stacklevel=2)+ −
+ −
return Or( [ self, other ] )+ −
+ −
+ −
+ −
def __rxor__(self, other ):+ −
+ −
"""Implementation of ^= operator"""+ −
+ −
if isinstance( other, basestring ):+ −
+ −
other = Literal( other )+ −
+ −
if not isinstance( other, ParserElement ):+ −
+ −
warnings.warn("Cannot add element of type %s to ParserElement" % type(other),+ −
+ −
SyntaxWarning, stacklevel=2)+ −
+ −
return other ^ self+ −
+ −
+ −
+ −
def __and__(self, other ):+ −
+ −
"""Implementation of & operator - returns Each"""+ −
+ −
if isinstance( other, basestring ):+ −
+ −
other = Literal( other )+ −
+ −
if not isinstance( other, ParserElement ):+ −
+ −
warnings.warn("Cannot add element of type %s to ParserElement" % type(other),+ −
+ −
SyntaxWarning, stacklevel=2)+ −
+ −
return Each( [ self, other ] )+ −
+ −
+ −
+ −
def __rand__(self, other ):+ −
+ −
"""Implementation of right-& operator"""+ −
+ −
if isinstance( other, basestring ):+ −
+ −
other = Literal( other )+ −
+ −
if not isinstance( other, ParserElement ):+ −
+ −
warnings.warn("Cannot add element of type %s to ParserElement" % type(other),+ −
+ −
SyntaxWarning, stacklevel=2)+ −
+ −
return other & self+ −
+ −
+ −
+ −
def __invert__( self ):+ −
+ −
"""Implementation of ~ operator - returns NotAny"""+ −
+ −
return NotAny( self )+ −
+ −
+ −
+ −
def suppress( self ):+ −
+ −
"""Suppresses the output of this ParserElement; useful to keep punctuation from+ −
+ −
cluttering up returned output.+ −
+ −
"""+ −
+ −
return Suppress( self )+ −
+ −
+ −
+ −
def leaveWhitespace( self ):+ −
+ −
"""Disables the skipping of whitespace before matching the characters in the + −
+ −
ParserElement's defined pattern. This is normally only used internally by+ −
+ −
the pyparsing module, but may be needed in some whitespace-sensitive grammars.+ −
+ −
"""+ −
+ −
self.skipWhitespace = False+ −
+ −
return self+ −
+ −
+ −
+ −
def setWhitespaceChars( self, chars ):+ −
+ −
"""Overrides the default whitespace chars+ −
+ −
"""+ −
+ −
self.skipWhitespace = True+ −
+ −
self.whiteChars = chars+ −
+ −
self.copyDefaultWhiteChars = False+ −
+ −
return self+ −
+ −
+ −
+ −
def parseWithTabs( self ):+ −
+ −
"""Overrides default behavior to expand <TAB>s to spaces before parsing the input string.+ −
+ −
Must be called before parseString when the input grammar contains elements that + −
+ −
match <TAB> characters."""+ −
+ −
self.keepTabs = True+ −
+ −
return self+ −
+ −
+ −
+ −
def ignore( self, other ):+ −
+ −
"""Define expression to be ignored (e.g., comments) while doing pattern + −
+ −
matching; may be called repeatedly, to define multiple comment or other+ −
+ −
ignorable patterns.+ −
+ −
"""+ −
+ −
if isinstance( other, Suppress ):+ −
+ −
if other not in self.ignoreExprs:+ −
+ −
self.ignoreExprs.append( other )+ −
+ −
else:+ −
+ −
self.ignoreExprs.append( Suppress( other ) )+ −
+ −
return self+ −
+ −
+ −
+ −
def setDebugActions( self, startAction, successAction, exceptionAction ):+ −
+ −
"""Enable display of debugging messages while doing pattern matching."""+ −
+ −
self.debugActions = (startAction or _defaultStartDebugAction, + −
+ −
successAction or _defaultSuccessDebugAction, + −
+ −
exceptionAction or _defaultExceptionDebugAction)+ −
+ −
self.debug = True+ −
+ −
return self+ −
+ −
+ −
+ −
def setDebug( self, flag=True ):+ −
+ −
"""Enable display of debugging messages while doing pattern matching."""+ −
+ −
if flag:+ −
+ −
self.setDebugActions( _defaultStartDebugAction, _defaultSuccessDebugAction, _defaultExceptionDebugAction )+ −
+ −
else:+ −
+ −
self.debug = False+ −
+ −
return self+ −
+ −
+ −
+ −
def __str__( self ):+ −
+ −
return self.name+ −
+ −
+ −
+ −
def __repr__( self ):+ −
+ −
return _ustr(self)+ −
+ −
+ −
+ −
def streamline( self ):+ −
+ −
self.streamlined = True+ −
+ −
self.strRepr = None+ −
+ −
return self+ −
+ −
+ −
+ −
def checkRecursion( self, parseElementList ):+ −
+ −
pass+ −
+ −
+ −
+ −
def validate( self, validateTrace=[] ):+ −
+ −
"""Check defined expressions for valid structure, check for infinite recursive definitions."""+ −
+ −
self.checkRecursion( [] )+ −
+ −
+ −
+ −
def parseFile( self, file_or_filename ):+ −
+ −
"""Execute the parse expression on the given file or filename.+ −
+ −
If a filename is specified (instead of a file object),+ −
+ −
the entire file is opened, read, and closed before parsing.+ −
+ −
"""+ −
+ −
try:+ −
+ −
file_contents = file_or_filename.read()+ −
+ −
except AttributeError:+ −
+ −
f = open(file_or_filename, "rb")+ −
+ −
file_contents = f.read()+ −
+ −
f.close()+ −
+ −
return self.parseString(file_contents)+ −
+ −
+ −
+ −
+ −
+ −
class Token(ParserElement):+ −
+ −
"""Abstract ParserElement subclass, for defining atomic matching patterns."""+ −
+ −
def __init__( self ):+ −
+ −
super(Token,self).__init__( savelist=False )+ −
+ −
self.myException = ParseException("",0,"",self)+ −
+ −
+ −
+ −
def setName(self, name):+ −
+ −
s = super(Token,self).setName(name)+ −
+ −
self.errmsg = "Expected " + self.name+ −
+ −
s.myException.msg = self.errmsg+ −
+ −
return s+ −
+ −
+ −
+ −
+ −
+ −
class Empty(Token):+ −
+ −
"""An empty token, will always match."""+ −
+ −
def __init__( self ):+ −
+ −
super(Empty,self).__init__()+ −
+ −
self.name = "Empty"+ −
+ −
self.mayReturnEmpty = True+ −
+ −
self.mayIndexError = False+ −
+ −
+ −
+ −
+ −
+ −
class NoMatch(Token):+ −
+ −
"""A token that will never match."""+ −
+ −
def __init__( self ):+ −
+ −
super(NoMatch,self).__init__()+ −
+ −
self.name = "NoMatch"+ −
+ −
self.mayReturnEmpty = True+ −
+ −
self.mayIndexError = False+ −
+ −
self.errmsg = "Unmatchable token"+ −
+ −
self.myException.msg = self.errmsg+ −
+ −
+ −
+ −
def parseImpl( self, instring, loc, doActions=True ):+ −
+ −
exc = self.myException+ −
+ −
exc.loc = loc+ −
+ −
exc.pstr = instring+ −
+ −
raise exc+ −
+ −
+ −
+ −
+ −
+ −
class Literal(Token):+ −
+ −
"""Token to exactly match a specified string."""+ −
+ −
def __init__( self, matchString ):+ −
+ −
super(Literal,self).__init__()+ −
+ −
self.match = matchString+ −
+ −
self.matchLen = len(matchString)+ −
+ −
try:+ −
+ −
self.firstMatchChar = matchString[0]+ −
+ −
except IndexError:+ −
+ −
warnings.warn("null string passed to Literal; use Empty() instead", + −
+ −
SyntaxWarning, stacklevel=2)+ −
+ −
self.__class__ = Empty+ −
+ −
self.name = '"%s"' % self.match+ −
+ −
self.errmsg = "Expected " + self.name+ −
+ −
self.mayReturnEmpty = False+ −
+ −
self.myException.msg = self.errmsg+ −
+ −
self.mayIndexError = False+ −
+ −
+ −
+ −
# Performance tuning: this routine gets called a *lot*+ −
+ −
# if this is a single character match string and the first character matches,+ −
+ −
# short-circuit as quickly as possible, and avoid calling startswith+ −
+ −
#~ @profile+ −
+ −
def parseImpl( self, instring, loc, doActions=True ):+ −
+ −
if (instring[loc] == self.firstMatchChar and+ −
+ −
(self.matchLen==1 or instring.startswith(self.match,loc)) ):+ −
+ −
return loc+self.matchLen, self.match+ −
+ −
#~ raise ParseException( instring, loc, self.errmsg )+ −
+ −
exc = self.myException+ −
+ −
exc.loc = loc+ −
+ −
exc.pstr = instring+ −
+ −
raise exc+ −
+ −
+ −
+ −
class Keyword(Token):+ −
+ −
"""Token to exactly match a specified string as a keyword, that is, it must be + −
+ −
immediately followed by a non-keyword character. Compare with Literal::+ −
+ −
Literal("if") will match the leading 'if' in 'ifAndOnlyIf'.+ −
+ −
Keyword("if") will not; it will only match the leading 'if in 'if x=1', or 'if(y==2)'+ −
+ −
Accepts two optional constructor arguments in addition to the keyword string:+ −
+ −
identChars is a string of characters that would be valid identifier characters,+ −
+ −
defaulting to all alphanumerics + "_" and "$"; caseless allows case-insensitive+ −
+ −
matching, default is False.+ −
+ −
"""+ −
+ −
DEFAULT_KEYWORD_CHARS = alphanums+"_$"+ −
+ −
+ −
+ −
def __init__( self, matchString, identChars=DEFAULT_KEYWORD_CHARS, caseless=False ):+ −
+ −
super(Keyword,self).__init__()+ −
+ −
self.match = matchString+ −
+ −
self.matchLen = len(matchString)+ −
+ −
try:+ −
+ −
self.firstMatchChar = matchString[0]+ −
+ −
except IndexError:+ −
+ −
warnings.warn("null string passed to Keyword; use Empty() instead", + −
+ −
SyntaxWarning, stacklevel=2)+ −
+ −
self.name = '"%s"' % self.match+ −
+ −
self.errmsg = "Expected " + self.name+ −
+ −
self.mayReturnEmpty = False+ −
+ −
self.myException.msg = self.errmsg+ −
+ −
self.mayIndexError = False+ −
+ −
self.caseless = caseless+ −
+ −
if caseless:+ −
+ −
self.caselessmatch = matchString.upper()+ −
+ −
identChars = identChars.upper()+ −
+ −
self.identChars = _str2dict(identChars)+ −
+ −
+ −
+ −
def parseImpl( self, instring, loc, doActions=True ):+ −
+ −
if self.caseless:+ −
+ −
if ( (instring[ loc:loc+self.matchLen ].upper() == self.caselessmatch) and+ −
+ −
(loc >= len(instring)-self.matchLen or instring[loc+self.matchLen].upper() not in self.identChars) and+ −
+ −
(loc == 0 or instring[loc-1].upper() not in self.identChars) ):+ −
+ −
return loc+self.matchLen, self.match+ −
+ −
else:+ −
+ −
if (instring[loc] == self.firstMatchChar and+ −
+ −
(self.matchLen==1 or instring.startswith(self.match,loc)) and+ −
+ −
(loc >= len(instring)-self.matchLen or instring[loc+self.matchLen] not in self.identChars) and+ −
+ −
(loc == 0 or instring[loc-1] not in self.identChars) ):+ −
+ −
return loc+self.matchLen, self.match+ −
+ −
#~ raise ParseException( instring, loc, self.errmsg )+ −
+ −
exc = self.myException+ −
+ −
exc.loc = loc+ −
+ −
exc.pstr = instring+ −
+ −
raise exc+ −
+ −
+ −
+ −
def copy(self):+ −
+ −
c = super(Keyword,self).copy()+ −
+ −
c.identChars = Keyword.DEFAULT_KEYWORD_CHARS+ −
+ −
return c+ −
+ −
+ −
+ −
def setDefaultKeywordChars( chars ):+ −
+ −
"""Overrides the default Keyword chars+ −
+ −
"""+ −
+ −
Keyword.DEFAULT_KEYWORD_CHARS = chars+ −
+ −
setDefaultKeywordChars = staticmethod(setDefaultKeywordChars) + −
+ −
+ −
+ −
+ −
+ −
class CaselessLiteral(Literal):+ −
+ −
"""Token to match a specified string, ignoring case of letters.+ −
+ −
Note: the matched results will always be in the case of the given+ −
+ −
match string, NOT the case of the input text.+ −
+ −
"""+ −
+ −
def __init__( self, matchString ):+ −
+ −
super(CaselessLiteral,self).__init__( matchString.upper() )+ −
+ −
# Preserve the defining literal.+ −
+ −
self.returnString = matchString+ −
+ −
self.name = "'%s'" % self.returnString+ −
+ −
self.errmsg = "Expected " + self.name+ −
+ −
self.myException.msg = self.errmsg+ −
+ −
+ −
+ −
def parseImpl( self, instring, loc, doActions=True ):+ −
+ −
if instring[ loc:loc+self.matchLen ].upper() == self.match:+ −
+ −
return loc+self.matchLen, self.returnString+ −
+ −
#~ raise ParseException( instring, loc, self.errmsg )+ −
+ −
exc = self.myException+ −
+ −
exc.loc = loc+ −
+ −
exc.pstr = instring+ −
+ −
raise exc+ −
+ −
+ −
+ −
class CaselessKeyword(Keyword):+ −
+ −
def __init__( self, matchString, identChars=Keyword.DEFAULT_KEYWORD_CHARS ):+ −
+ −
super(CaselessKeyword,self).__init__( matchString, identChars, caseless=True )+ −
+ −
+ −
+ −
def parseImpl( self, instring, loc, doActions=True ):+ −
+ −
if ( (instring[ loc:loc+self.matchLen ].upper() == self.caselessmatch) and+ −
+ −
(loc >= len(instring)-self.matchLen or instring[loc+self.matchLen].upper() not in self.identChars) ):+ −
+ −
return loc+self.matchLen, self.match+ −
+ −
#~ raise ParseException( instring, loc, self.errmsg )+ −
+ −
exc = self.myException+ −
+ −
exc.loc = loc+ −
+ −
exc.pstr = instring+ −
+ −
raise exc+ −
+ −
+ −
+ −
class Word(Token):+ −
+ −
"""Token for matching words composed of allowed character sets.+ −
+ −
Defined with string containing all allowed initial characters,+ −
+ −
an optional string containing allowed body characters (if omitted,+ −
+ −
defaults to the initial character set), and an optional minimum,+ −
+ −
maximum, and/or exact length.+ −
+ −
"""+ −
+ −
def __init__( self, initChars, bodyChars=None, min=1, max=0, exact=0 ):+ −
+ −
super(Word,self).__init__()+ −
+ −
self.initCharsOrig = initChars+ −
+ −
self.initChars = _str2dict(initChars)+ −
+ −
if bodyChars :+ −
+ −
self.bodyCharsOrig = bodyChars+ −
+ −
self.bodyChars = _str2dict(bodyChars)+ −
+ −
else:+ −
+ −
self.bodyCharsOrig = initChars+ −
+ −
self.bodyChars = _str2dict(initChars)+ −
+ −
+ −
+ −
self.maxSpecified = max > 0+ −
+ −
+ −
+ −
self.minLen = min+ −
+ −
+ −
+ −
if max > 0:+ −
+ −
self.maxLen = max+ −
+ −
else:+ −
+ −
self.maxLen = sys.maxint+ −
+ −
+ −
+ −
if exact > 0:+ −
+ −
self.maxLen = exact+ −
+ −
self.minLen = exact+ −
+ −
+ −
+ −
self.name = _ustr(self)+ −
+ −
self.errmsg = "Expected " + self.name+ −
+ −
self.myException.msg = self.errmsg+ −
+ −
self.mayIndexError = False+ −
+ −
+ −
+ −
if ' ' not in self.initCharsOrig+self.bodyCharsOrig and (min==1 and max==0 and exact==0):+ −
+ −
if self.bodyCharsOrig == self.initCharsOrig:+ −
+ −
self.reString = "[%s]+" % _escapeRegexRangeChars(self.initCharsOrig)+ −
+ −
elif len(self.bodyCharsOrig) == 1:+ −
+ −
self.reString = "%s[%s]*" % \+ −
(re.escape(self.initCharsOrig),+ −
+ −
_escapeRegexRangeChars(self.bodyCharsOrig),)+ −
+ −
else:+ −
+ −
self.reString = "[%s][%s]*" % \+ −
(_escapeRegexRangeChars(self.initCharsOrig),+ −
+ −
_escapeRegexRangeChars(self.bodyCharsOrig),)+ −
+ −
try:+ −
+ −
self.re = re.compile( self.reString )+ −
+ −
except:+ −
+ −
self.re = None+ −
+ −
+ −
+ −
def parseImpl( self, instring, loc, doActions=True ):+ −
+ −
if self.re:+ −
+ −
result = self.re.match(instring,loc)+ −
+ −
if not result:+ −
+ −
exc = self.myException+ −
+ −
exc.loc = loc+ −
+ −
exc.pstr = instring+ −
+ −
raise exc+ −
+ −
+ −
+ −
loc = result.end()+ −
+ −
return loc,result.group()+ −
+ −
+ −
+ −
if not(instring[ loc ] in self.initChars):+ −
+ −
#~ raise ParseException( instring, loc, self.errmsg )+ −
+ −
exc = self.myException+ −
+ −
exc.loc = loc+ −
+ −
exc.pstr = instring+ −
+ −
raise exc+ −
+ −
start = loc+ −
+ −
loc += 1+ −
+ −
instrlen = len(instring)+ −
+ −
bodychars = self.bodyChars+ −
+ −
maxloc = start + self.maxLen+ −
+ −
maxloc = min( maxloc, instrlen )+ −
+ −
while loc < maxloc and instring[loc] in bodychars:+ −
+ −
loc += 1+ −
+ −
+ −
+ −
throwException = False+ −
+ −
if loc - start < self.minLen:+ −
+ −
throwException = True+ −
+ −
if self.maxSpecified and loc < instrlen and instring[loc] in bodychars:+ −
+ −
throwException = True+ −
+ −
+ −
+ −
if throwException:+ −
+ −
#~ raise ParseException( instring, loc, self.errmsg )+ −
+ −
exc = self.myException+ −
+ −
exc.loc = loc+ −
+ −
exc.pstr = instring+ −
+ −
raise exc+ −
+ −
+ −
+ −
return loc, instring[start:loc]+ −
+ −
+ −
+ −
def __str__( self ):+ −
+ −
try:+ −
+ −
return super(Word,self).__str__()+ −
+ −
except:+ −
+ −
pass+ −
+ −
+ −
+ −
+ −
+ −
if self.strRepr is None:+ −
+ −
+ −
+ −
def charsAsStr(s):+ −
+ −
if len(s)>4:+ −
+ −
return s[:4]+"..."+ −
+ −
else:+ −
+ −
return s+ −
+ −
+ −
+ −
if ( self.initCharsOrig != self.bodyCharsOrig ):+ −
+ −
self.strRepr = "W:(%s,%s)" % ( charsAsStr(self.initCharsOrig), charsAsStr(self.bodyCharsOrig) )+ −
+ −
else:+ −
+ −
self.strRepr = "W:(%s)" % charsAsStr(self.initCharsOrig)+ −
+ −
+ −
+ −
return self.strRepr+ −
+ −
+ −
+ −
+ −
+ −
class Regex(Token):+ −
+ −
"""Token for matching strings that match a given regular expression.+ −
+ −
Defined with string specifying the regular expression in a form recognized by the inbuilt Python re module.+ −
+ −
"""+ −
+ −
def __init__( self, pattern, flags=0):+ −
+ −
"""The parameters pattern and flags are passed to the re.compile() function as-is. See the Python re module for an explanation of the acceptable patterns and flags."""+ −
+ −
super(Regex,self).__init__()+ −
+ −
+ −
+ −
if len(pattern) == 0:+ −
+ −
warnings.warn("null string passed to Regex; use Empty() instead", + −
+ −
SyntaxWarning, stacklevel=2)+ −
+ −
+ −
+ −
self.pattern = pattern+ −
+ −
self.flags = flags+ −
+ −
+ −
+ −
try:+ −
+ −
self.re = re.compile(self.pattern, self.flags)+ −
+ −
self.reString = self.pattern+ −
+ −
except sre_constants.error,e:+ −
+ −
warnings.warn("invalid pattern (%s) passed to Regex" % pattern, + −
+ −
SyntaxWarning, stacklevel=2)+ −
+ −
raise+ −
+ −
+ −
+ −
self.name = _ustr(self)+ −
+ −
self.errmsg = "Expected " + self.name+ −
+ −
self.myException.msg = self.errmsg+ −
+ −
self.mayIndexError = False+ −
+ −
self.mayReturnEmpty = True+ −
+ −
+ −
+ −
def parseImpl( self, instring, loc, doActions=True ):+ −
+ −
result = self.re.match(instring,loc)+ −
+ −
if not result:+ −
+ −
exc = self.myException+ −
+ −
exc.loc = loc+ −
+ −
exc.pstr = instring+ −
+ −
raise exc+ −
+ −
+ −
+ −
loc = result.end()+ −
+ −
d = result.groupdict()+ −
+ −
ret = ParseResults(result.group())+ −
+ −
if d:+ −
+ −
for k in d.keys():+ −
+ −
ret[k] = d[k]+ −
+ −
return loc,ret+ −
+ −
+ −
+ −
def __str__( self ):+ −
+ −
try:+ −
+ −
return super(Regex,self).__str__()+ −
+ −
except:+ −
+ −
pass+ −
+ −
+ −
+ −
if self.strRepr is None:+ −
+ −
self.strRepr = "Re:(%s)" % repr(self.pattern)+ −
+ −
+ −
+ −
return self.strRepr+ −
+ −
+ −
+ −
+ −
+ −
class QuotedString(Token):+ −
+ −
"""Token for matching strings that are delimited by quoting characters.+ −
+ −
"""+ −
+ −
def __init__( self, quoteChar, escChar=None, escQuote=None, multiline=False, unquoteResults=True, endQuoteChar=None):+ −
+ −
"""+ −
+ −
Defined with the following parameters:+ −
+ −
- quoteChar - string of one or more characters defining the quote delimiting string+ −
+ −
- escChar - character to escape quotes, typically backslash (default=None)+ −
+ −
- escQuote - special quote sequence to escape an embedded quote string (such as SQL's "" to escape an embedded ") (default=None)+ −
+ −
- multiline - boolean indicating whether quotes can span multiple lines (default=False)+ −
+ −
- unquoteResults - boolean indicating whether the matched text should be unquoted (default=True)+ −
+ −
- endQuoteChar - string of one or more characters defining the end of the quote delimited string (default=None => same as quoteChar)+ −
+ −
"""+ −
+ −
super(QuotedString,self).__init__()+ −
+ −
+ −
+ −
# remove white space from quote chars - wont work anyway+ −
+ −
quoteChar = quoteChar.strip()+ −
+ −
if len(quoteChar) == 0:+ −
+ −
warnings.warn("quoteChar cannot be the empty string",SyntaxWarning,stacklevel=2)+ −
+ −
raise SyntaxError()+ −
+ −
+ −
+ −
if endQuoteChar is None:+ −
+ −
endQuoteChar = quoteChar+ −
+ −
else:+ −
+ −
endQuoteChar = endQuoteChar.strip()+ −
+ −
if len(endQuoteChar) == 0:+ −
+ −
warnings.warn("endQuoteChar cannot be the empty string",SyntaxWarning,stacklevel=2)+ −
+ −
raise SyntaxError()+ −
+ −
+ −
+ −
self.quoteChar = quoteChar+ −
+ −
self.quoteCharLen = len(quoteChar)+ −
+ −
self.firstQuoteChar = quoteChar[0]+ −
+ −
self.endQuoteChar = endQuoteChar+ −
+ −
self.endQuoteCharLen = len(endQuoteChar)+ −
+ −
self.escChar = escChar+ −
+ −
self.escQuote = escQuote+ −
+ −
self.unquoteResults = unquoteResults+ −
+ −
+ −
+ −
if multiline:+ −
+ −
self.flags = re.MULTILINE | re.DOTALL+ −
+ −
self.pattern = r'%s(?:[^%s%s]' % \+ −
( re.escape(self.quoteChar),+ −
+ −
_escapeRegexRangeChars(self.endQuoteChar[0]),+ −
+ −
(escChar is not None and _escapeRegexRangeChars(escChar) or '') )+ −
+ −
else:+ −
+ −
self.flags = 0+ −
+ −
self.pattern = r'%s(?:[^%s\n\r%s]' % \+ −
( re.escape(self.quoteChar),+ −
+ −
_escapeRegexRangeChars(self.endQuoteChar[0]),+ −
+ −
(escChar is not None and _escapeRegexRangeChars(escChar) or '') )+ −
+ −
if len(self.endQuoteChar) > 1:+ −
+ −
self.pattern += (+ −
+ −
'|(?:' + ')|(?:'.join(["%s[^%s]" % (re.escape(self.endQuoteChar[:i]),+ −
+ −
_escapeRegexRangeChars(self.endQuoteChar[i])) + −
+ −
for i in range(len(self.endQuoteChar)-1,0,-1)]) + ')'+ −
+ −
)+ −
+ −
if escQuote:+ −
+ −
self.pattern += (r'|(?:%s)' % re.escape(escQuote))+ −
+ −
if escChar:+ −
+ −
self.pattern += (r'|(?:%s.)' % re.escape(escChar))+ −
+ −
self.escCharReplacePattern = re.escape(self.escChar)+"(.)"+ −
+ −
self.pattern += (r')*%s' % re.escape(self.endQuoteChar))+ −
+ −
+ −
+ −
try:+ −
+ −
self.re = re.compile(self.pattern, self.flags)+ −
+ −
self.reString = self.pattern+ −
+ −
except sre_constants.error,e:+ −
+ −
warnings.warn("invalid pattern (%s) passed to Regex" % self.pattern, + −
+ −
SyntaxWarning, stacklevel=2)+ −
+ −
raise+ −
+ −
+ −
+ −
self.name = _ustr(self)+ −
+ −
self.errmsg = "Expected " + self.name+ −
+ −
self.myException.msg = self.errmsg+ −
+ −
self.mayIndexError = False+ −
+ −
self.mayReturnEmpty = True+ −
+ −
+ −
+ −
def parseImpl( self, instring, loc, doActions=True ):+ −
+ −
result = instring[loc] == self.firstQuoteChar and self.re.match(instring,loc) or None+ −
+ −
if not result:+ −
+ −
exc = self.myException+ −
+ −
exc.loc = loc+ −
+ −
exc.pstr = instring+ −
+ −
raise exc+ −
+ −
+ −
+ −
loc = result.end()+ −
+ −
ret = result.group()+ −
+ −
+ −
+ −
if self.unquoteResults:+ −
+ −
+ −
+ −
# strip off quotes+ −
+ −
ret = ret[self.quoteCharLen:-self.endQuoteCharLen]+ −
+ −
+ −
+ −
if isinstance(ret,basestring):+ −
+ −
# replace escaped characters+ −
+ −
if self.escChar:+ −
+ −
ret = re.sub(self.escCharReplacePattern,"\g<1>",ret)+ −
+ −
+ −
+ −
# replace escaped quotes+ −
+ −
if self.escQuote:+ −
+ −
ret = ret.replace(self.escQuote, self.endQuoteChar)+ −
+ −
+ −
+ −
return loc, ret+ −
+ −
+ −
+ −
def __str__( self ):+ −
+ −
try:+ −
+ −
return super(QuotedString,self).__str__()+ −
+ −
except:+ −
+ −
pass+ −
+ −
+ −
+ −
if self.strRepr is None:+ −
+ −
self.strRepr = "quoted string, starting with %s ending with %s" % (self.quoteChar, self.endQuoteChar)+ −
+ −
+ −
+ −
return self.strRepr+ −
+ −
+ −
+ −
+ −
+ −
class CharsNotIn(Token):+ −
+ −
"""Token for matching words composed of characters *not* in a given set.+ −
+ −
Defined with string containing all disallowed characters, and an optional + −
+ −
minimum, maximum, and/or exact length.+ −
+ −
"""+ −
+ −
def __init__( self, notChars, min=1, max=0, exact=0 ):+ −
+ −
super(CharsNotIn,self).__init__()+ −
+ −
self.skipWhitespace = False+ −
+ −
self.notChars = notChars+ −
+ −
+ −
+ −
self.minLen = min+ −
+ −
+ −
+ −
if max > 0:+ −
+ −
self.maxLen = max+ −
+ −
else:+ −
+ −
self.maxLen = sys.maxint+ −
+ −
+ −
+ −
if exact > 0:+ −
+ −
self.maxLen = exact+ −
+ −
self.minLen = exact+ −
+ −
+ −
+ −
self.name = _ustr(self)+ −
+ −
self.errmsg = "Expected " + self.name+ −
+ −
self.mayReturnEmpty = ( self.minLen == 0 )+ −
+ −
self.myException.msg = self.errmsg+ −
+ −
self.mayIndexError = False+ −
+ −
+ −
+ −
def parseImpl( self, instring, loc, doActions=True ):+ −
+ −
if instring[loc] in self.notChars:+ −
+ −
#~ raise ParseException( instring, loc, self.errmsg )+ −
+ −
exc = self.myException+ −
+ −
exc.loc = loc+ −
+ −
exc.pstr = instring+ −
+ −
raise exc+ −
+ −
+ −
+ −
start = loc+ −
+ −
loc += 1+ −
+ −
notchars = self.notChars+ −
+ −
maxlen = min( start+self.maxLen, len(instring) )+ −
+ −
while loc < maxlen and (instring[loc] not in notchars):+ −
+ −
loc += 1+ −
+ −
+ −
+ −
if loc - start < self.minLen:+ −
+ −
#~ raise ParseException( instring, loc, self.errmsg )+ −
+ −
exc = self.myException+ −
+ −
exc.loc = loc+ −
+ −
exc.pstr = instring+ −
+ −
raise exc+ −
+ −
+ −
+ −
return loc, instring[start:loc]+ −
+ −
+ −
+ −
def __str__( self ):+ −
+ −
try:+ −
+ −
return super(CharsNotIn, self).__str__()+ −
+ −
except:+ −
+ −
pass+ −
+ −
+ −
+ −
if self.strRepr is None:+ −
+ −
if len(self.notChars) > 4:+ −
+ −
self.strRepr = "!W:(%s...)" % self.notChars[:4]+ −
+ −
else:+ −
+ −
self.strRepr = "!W:(%s)" % self.notChars+ −
+ −
+ −
+ −
return self.strRepr+ −
+ −
+ −
+ −
class White(Token):+ −
+ −
"""Special matching class for matching whitespace. Normally, whitespace is ignored+ −
+ −
by pyparsing grammars. This class is included when some whitespace structures+ −
+ −
are significant. Define with a string containing the whitespace characters to be+ −
+ −
matched; default is " \\t\\n". Also takes optional min, max, and exact arguments,+ −
+ −
as defined for the Word class."""+ −
+ −
whiteStrs = {+ −
+ −
" " : "<SPC>",+ −
+ −
"\t": "<TAB>",+ −
+ −
"\n": "<LF>",+ −
+ −
"\r": "<CR>",+ −
+ −
"\f": "<FF>",+ −
+ −
}+ −
+ −
def __init__(self, ws=" \t\r\n", min=1, max=0, exact=0):+ −
+ −
super(White,self).__init__()+ −
+ −
self.matchWhite = ws+ −
+ −
self.setWhitespaceChars( "".join([c for c in self.whiteChars if c not in self.matchWhite]) )+ −
+ −
#~ self.leaveWhitespace()+ −
+ −
self.name = ("".join([White.whiteStrs[c] for c in self.matchWhite]))+ −
+ −
self.mayReturnEmpty = True+ −
+ −
self.errmsg = "Expected " + self.name+ −
+ −
self.myException.msg = self.errmsg+ −
+ −
+ −
+ −
self.minLen = min+ −
+ −
+ −
+ −
if max > 0:+ −
+ −
self.maxLen = max+ −
+ −
else:+ −
+ −
self.maxLen = sys.maxint+ −
+ −
+ −
+ −
if exact > 0:+ −
+ −
self.maxLen = exact+ −
+ −
self.minLen = exact+ −
+ −
+ −
+ −
def parseImpl( self, instring, loc, doActions=True ):+ −
+ −
if not(instring[ loc ] in self.matchWhite):+ −
+ −
#~ raise ParseException( instring, loc, self.errmsg )+ −
+ −
exc = self.myException+ −
+ −
exc.loc = loc+ −
+ −
exc.pstr = instring+ −
+ −
raise exc+ −
+ −
start = loc+ −
+ −
loc += 1+ −
+ −
maxloc = start + self.maxLen+ −
+ −
maxloc = min( maxloc, len(instring) )+ −
+ −
while loc < maxloc and instring[loc] in self.matchWhite:+ −
+ −
loc += 1+ −
+ −
+ −
+ −
if loc - start < self.minLen:+ −
+ −
#~ raise ParseException( instring, loc, self.errmsg )+ −
+ −
exc = self.myException+ −
+ −
exc.loc = loc+ −
+ −
exc.pstr = instring+ −
+ −
raise exc+ −
+ −
+ −
+ −
return loc, instring[start:loc]+ −
+ −
+ −
+ −
+ −
+ −
class PositionToken(Token):+ −
+ −
def __init__( self ):+ −
+ −
super(PositionToken,self).__init__()+ −
+ −
self.name=self.__class__.__name__+ −
+ −
self.mayReturnEmpty = True+ −
+ −
self.mayIndexError = False+ −
+ −
+ −
+ −
class GoToColumn(PositionToken):+ −
+ −
"""Token to advance to a specific column of input text; useful for tabular report scraping."""+ −
+ −
def __init__( self, colno ):+ −
+ −
super(GoToColumn,self).__init__()+ −
+ −
self.col = colno+ −
+ −
+ −
+ −
def preParse( self, instring, loc ):+ −
+ −
if col(loc,instring) != self.col:+ −
+ −
instrlen = len(instring)+ −
+ −
if self.ignoreExprs:+ −
+ −
loc = self.skipIgnorables( instring, loc )+ −
+ −
while loc < instrlen and instring[loc].isspace() and col( loc, instring ) != self.col :+ −
+ −
loc += 1+ −
+ −
return loc+ −
+ −
+ −
+ −
def parseImpl( self, instring, loc, doActions=True ):+ −
+ −
thiscol = col( loc, instring )+ −
+ −
if thiscol > self.col:+ −
+ −
raise ParseException( instring, loc, "Text not in expected column", self )+ −
+ −
newloc = loc + self.col - thiscol+ −
+ −
ret = instring[ loc: newloc ]+ −
+ −
return newloc, ret+ −
+ −
+ −
+ −
class LineStart(PositionToken):+ −
+ −
"""Matches if current position is at the beginning of a line within the parse string"""+ −
+ −
def __init__( self ):+ −
+ −
super(LineStart,self).__init__()+ −
+ −
self.setWhitespaceChars( " \t" )+ −
+ −
self.errmsg = "Expected start of line"+ −
+ −
self.myException.msg = self.errmsg+ −
+ −
+ −
+ −
def preParse( self, instring, loc ):+ −
+ −
preloc = super(LineStart,self).preParse(instring,loc)+ −
+ −
if instring[preloc] == "\n":+ −
+ −
loc += 1+ −
+ −
return loc+ −
+ −
+ −
+ −
def parseImpl( self, instring, loc, doActions=True ):+ −
+ −
if not( loc==0 or+ −
+ −
(loc == self.preParse( instring, 0 )) or+ −
+ −
(instring[loc-1] == "\n") ): #col(loc, instring) != 1:+ −
+ −
#~ raise ParseException( instring, loc, "Expected start of line" )+ −
+ −
exc = self.myException+ −
+ −
exc.loc = loc+ −
+ −
exc.pstr = instring+ −
+ −
raise exc+ −
+ −
return loc, []+ −
+ −
+ −
+ −
class LineEnd(PositionToken):+ −
+ −
"""Matches if current position is at the end of a line within the parse string"""+ −
+ −
def __init__( self ):+ −
+ −
super(LineEnd,self).__init__()+ −
+ −
self.setWhitespaceChars( " \t" )+ −
+ −
self.errmsg = "Expected end of line"+ −
+ −
self.myException.msg = self.errmsg+ −
+ −
+ −
+ −
def parseImpl( self, instring, loc, doActions=True ):+ −
+ −
if loc<len(instring):+ −
+ −
if instring[loc] == "\n":+ −
+ −
return loc+1, "\n"+ −
+ −
else:+ −
+ −
#~ raise ParseException( instring, loc, "Expected end of line" )+ −
+ −
exc = self.myException+ −
+ −
exc.loc = loc+ −
+ −
exc.pstr = instring+ −
+ −
raise exc+ −
+ −
elif loc == len(instring):+ −
+ −
return loc+1, []+ −
+ −
else:+ −
+ −
exc = self.myException+ −
+ −
exc.loc = loc+ −
+ −
exc.pstr = instring+ −
+ −
raise exc+ −
+ −
+ −
+ −
class StringStart(PositionToken):+ −
+ −
"""Matches if current position is at the beginning of the parse string"""+ −
+ −
def __init__( self ):+ −
+ −
super(StringStart,self).__init__()+ −
+ −
self.errmsg = "Expected start of text"+ −
+ −
self.myException.msg = self.errmsg+ −
+ −
+ −
+ −
def parseImpl( self, instring, loc, doActions=True ):+ −
+ −
if loc != 0:+ −
+ −
# see if entire string up to here is just whitespace and ignoreables+ −
+ −
if loc != self.preParse( instring, 0 ):+ −
+ −
#~ raise ParseException( instring, loc, "Expected start of text" )+ −
+ −
exc = self.myException+ −
+ −
exc.loc = loc+ −
+ −
exc.pstr = instring+ −
+ −
raise exc+ −
+ −
return loc, []+ −
+ −
+ −
+ −
class StringEnd(PositionToken):+ −
+ −
"""Matches if current position is at the end of the parse string"""+ −
+ −
def __init__( self ):+ −
+ −
super(StringEnd,self).__init__()+ −
+ −
self.errmsg = "Expected end of text"+ −
+ −
self.myException.msg = self.errmsg+ −
+ −
+ −
+ −
def parseImpl( self, instring, loc, doActions=True ):+ −
+ −
if loc < len(instring):+ −
+ −
#~ raise ParseException( instring, loc, "Expected end of text" )+ −
+ −
exc = self.myException+ −
+ −
exc.loc = loc+ −
+ −
exc.pstr = instring+ −
+ −
raise exc+ −
+ −
elif loc == len(instring):+ −
+ −
return loc+1, []+ −
+ −
else:+ −
+ −
exc = self.myException+ −
+ −
exc.loc = loc+ −
+ −
exc.pstr = instring+ −
+ −
raise exc+ −
+ −
+ −
+ −
+ −
+ −
class ParseExpression(ParserElement):+ −
+ −
"""Abstract subclass of ParserElement, for combining and post-processing parsed tokens."""+ −
+ −
def __init__( self, exprs, savelist = False ):+ −
+ −
super(ParseExpression,self).__init__(savelist)+ −
+ −
if isinstance( exprs, list ):+ −
+ −
self.exprs = exprs+ −
+ −
elif isinstance( exprs, basestring ):+ −
+ −
self.exprs = [ Literal( exprs ) ]+ −
+ −
else:+ −
+ −
self.exprs = [ exprs ]+ −
+ −
+ −
+ −
def __getitem__( self, i ):+ −
+ −
return self.exprs[i]+ −
+ −
+ −
+ −
def append( self, other ):+ −
+ −
self.exprs.append( other )+ −
+ −
self.strRepr = None+ −
+ −
return self+ −
+ −
+ −
+ −
def leaveWhitespace( self ):+ −
+ −
"""Extends leaveWhitespace defined in base class, and also invokes leaveWhitespace on+ −
+ −
all contained expressions."""+ −
+ −
self.skipWhitespace = False+ −
+ −
self.exprs = [ e.copy() for e in self.exprs ]+ −
+ −
for e in self.exprs:+ −
+ −
e.leaveWhitespace()+ −
+ −
return self+ −
+ −
+ −
+ −
def ignore( self, other ):+ −
+ −
if isinstance( other, Suppress ):+ −
+ −
if other not in self.ignoreExprs:+ −
+ −
super( ParseExpression, self).ignore( other )+ −
+ −
for e in self.exprs:+ −
+ −
e.ignore( self.ignoreExprs[-1] )+ −
+ −
else:+ −
+ −
super( ParseExpression, self).ignore( other )+ −
+ −
for e in self.exprs:+ −
+ −
e.ignore( self.ignoreExprs[-1] )+ −
+ −
return self+ −
+ −
+ −
+ −
def __str__( self ):+ −
+ −
try:+ −
+ −
return super(ParseExpression,self).__str__()+ −
+ −
except:+ −
+ −
pass+ −
+ −
+ −
+ −
if self.strRepr is None:+ −
+ −
self.strRepr = "%s:(%s)" % ( self.__class__.__name__, _ustr(self.exprs) )+ −
+ −
return self.strRepr+ −
+ −
+ −
+ −
def streamline( self ):+ −
+ −
super(ParseExpression,self).streamline()+ −
+ −
+ −
+ −
for e in self.exprs:+ −
+ −
e.streamline()+ −
+ −
+ −
+ −
# collapse nested And's of the form And( And( And( a,b), c), d) to And( a,b,c,d )+ −
+ −
# but only if there are no parse actions or resultsNames on the nested And's+ −
+ −
# (likewise for Or's and MatchFirst's)+ −
+ −
if ( len(self.exprs) == 2 ):+ −
+ −
other = self.exprs[0]+ −
+ −
if ( isinstance( other, self.__class__ ) and+ −
+ −
not(other.parseAction) and+ −
+ −
other.resultsName is None and+ −
+ −
not other.debug ):+ −
+ −
self.exprs = other.exprs[:] + [ self.exprs[1] ]+ −
+ −
self.strRepr = None+ −
+ −
self.mayReturnEmpty |= other.mayReturnEmpty+ −
+ −
self.mayIndexError |= other.mayIndexError+ −
+ −
+ −
+ −
other = self.exprs[-1]+ −
+ −
if ( isinstance( other, self.__class__ ) and+ −
+ −
not(other.parseAction) and+ −
+ −
other.resultsName is None and+ −
+ −
not other.debug ):+ −
+ −
self.exprs = self.exprs[:-1] + other.exprs[:]+ −
+ −
self.strRepr = None+ −
+ −
self.mayReturnEmpty |= other.mayReturnEmpty+ −
+ −
self.mayIndexError |= other.mayIndexError+ −
+ −
+ −
+ −
return self+ −
+ −
+ −
+ −
def setResultsName( self, name, listAllMatches=False ):+ −
+ −
ret = super(ParseExpression,self).setResultsName(name,listAllMatches)+ −
+ −
return ret+ −
+ −
+ −
+ −
def validate( self, validateTrace=[] ):+ −
+ −
tmp = validateTrace[:]+[self]+ −
+ −
for e in self.exprs:+ −
+ −
e.validate(tmp)+ −
+ −
self.checkRecursion( [] )+ −
+ −
+ −
+ −
class And(ParseExpression):+ −
+ −
"""Requires all given ParseExpressions to be found in the given order.+ −
+ −
Expressions may be separated by whitespace.+ −
+ −
May be constructed using the '+' operator.+ −
+ −
"""+ −
+ −
def __init__( self, exprs, savelist = True ):+ −
+ −
super(And,self).__init__(exprs, savelist)+ −
+ −
self.mayReturnEmpty = True+ −
+ −
for e in self.exprs:+ −
+ −
if not e.mayReturnEmpty:+ −
+ −
self.mayReturnEmpty = False+ −
+ −
break+ −
+ −
self.setWhitespaceChars( exprs[0].whiteChars )+ −
+ −
self.skipWhitespace = exprs[0].skipWhitespace+ −
+ −
+ −
+ −
def parseImpl( self, instring, loc, doActions=True ):+ −
+ −
# pass False as last arg to _parse for first element, since we already+ −
+ −
# pre-parsed the string as part of our And pre-parsing+ −
+ −
loc, resultlist = self.exprs[0]._parse( instring, loc, doActions, callPreParse=False )+ −
+ −
for e in self.exprs[1:]:+ −
+ −
loc, exprtokens = e._parse( instring, loc, doActions )+ −
+ −
if exprtokens or exprtokens.keys():+ −
+ −
resultlist += exprtokens+ −
+ −
return loc, resultlist+ −
+ −
+ −
+ −
def __iadd__(self, other ):+ −
+ −
if isinstance( other, basestring ):+ −
+ −
other = Literal( other )+ −
+ −
return self.append( other ) #And( [ self, other ] )+ −
+ −
+ −
+ −
def checkRecursion( self, parseElementList ):+ −
+ −
subRecCheckList = parseElementList[:] + [ self ]+ −
+ −
for e in self.exprs:+ −
+ −
e.checkRecursion( subRecCheckList )+ −
+ −
if not e.mayReturnEmpty:+ −
+ −
break+ −
+ −
+ −
+ −
def __str__( self ):+ −
+ −
if hasattr(self,"name"):+ −
+ −
return self.name+ −
+ −
+ −
+ −
if self.strRepr is None:+ −
+ −
self.strRepr = "{" + " ".join( [ _ustr(e) for e in self.exprs ] ) + "}"+ −
+ −
+ −
+ −
return self.strRepr+ −
+ −
+ −
+ −
+ −
+ −
class Or(ParseExpression):+ −
+ −
"""Requires that at least one ParseExpression is found.+ −
+ −
If two expressions match, the expression that matches the longest string will be used.+ −
+ −
May be constructed using the '^' operator.+ −
+ −
"""+ −
+ −
def __init__( self, exprs, savelist = False ):+ −
+ −
super(Or,self).__init__(exprs, savelist)+ −
+ −
self.mayReturnEmpty = False+ −
+ −
for e in self.exprs:+ −
+ −
if e.mayReturnEmpty:+ −
+ −
self.mayReturnEmpty = True+ −
+ −
break+ −
+ −
+ −
+ −
def parseImpl( self, instring, loc, doActions=True ):+ −
+ −
maxExcLoc = -1+ −
+ −
maxMatchLoc = -1+ −
+ −
for e in self.exprs:+ −
+ −
try:+ −
+ −
loc2 = e.tryParse( instring, loc )+ −
+ −
except ParseException, err:+ −
+ −
if err.loc > maxExcLoc:+ −
+ −
maxException = err+ −
+ −
maxExcLoc = err.loc+ −
+ −
except IndexError, err:+ −
+ −
if len(instring) > maxExcLoc:+ −
+ −
maxException = ParseException(instring,len(instring),e.errmsg,self)+ −
+ −
maxExcLoc = len(instring)+ −
+ −
else:+ −
+ −
if loc2 > maxMatchLoc:+ −
+ −
maxMatchLoc = loc2+ −
+ −
maxMatchExp = e+ −
+ −
+ −
+ −
if maxMatchLoc < 0:+ −
+ −
if self.exprs:+ −
+ −
raise maxException+ −
+ −
else:+ −
+ −
raise ParseException(instring, loc, "no defined alternatives to match", self)+ −
+ −
+ −
+ −
return maxMatchExp._parse( instring, loc, doActions )+ −
+ −
+ −
+ −
def __ixor__(self, other ):+ −
+ −
if isinstance( other, basestring ):+ −
+ −
other = Literal( other )+ −
+ −
return self.append( other ) #Or( [ self, other ] )+ −
+ −
+ −
+ −
def __str__( self ):+ −
+ −
if hasattr(self,"name"):+ −
+ −
return self.name+ −
+ −
+ −
+ −
if self.strRepr is None:+ −
+ −
self.strRepr = "{" + " ^ ".join( [ _ustr(e) for e in self.exprs ] ) + "}"+ −
+ −
+ −
+ −
return self.strRepr+ −
+ −
+ −
+ −
def checkRecursion( self, parseElementList ):+ −
+ −
subRecCheckList = parseElementList[:] + [ self ]+ −
+ −
for e in self.exprs:+ −
+ −
e.checkRecursion( subRecCheckList )+ −
+ −
+ −
+ −
+ −
+ −
class MatchFirst(ParseExpression):+ −
+ −
"""Requires that at least one ParseExpression is found.+ −
+ −
If two expressions match, the first one listed is the one that will match.+ −
+ −
May be constructed using the '|' operator.+ −
+ −
"""+ −
+ −
def __init__( self, exprs, savelist = False ):+ −
+ −
super(MatchFirst,self).__init__(exprs, savelist)+ −
+ −
if exprs:+ −
+ −
self.mayReturnEmpty = False+ −
+ −
for e in self.exprs:+ −
+ −
if e.mayReturnEmpty:+ −
+ −
self.mayReturnEmpty = True+ −
+ −
break+ −
+ −
else:+ −
+ −
self.mayReturnEmpty = True+ −
+ −
+ −
+ −
def parseImpl( self, instring, loc, doActions=True ):+ −
+ −
maxExcLoc = -1+ −
+ −
for e in self.exprs:+ −
+ −
try:+ −
+ −
ret = e._parse( instring, loc, doActions )+ −
+ −
return ret+ −
+ −
except ParseException, err:+ −
+ −
if err.loc > maxExcLoc:+ −
+ −
maxException = err+ −
+ −
maxExcLoc = err.loc+ −
+ −
except IndexError, err:+ −
+ −
if len(instring) > maxExcLoc:+ −
+ −
maxException = ParseException(instring,len(instring),e.errmsg,self)+ −
+ −
maxExcLoc = len(instring)+ −
+ −
+ −
+ −
# only got here if no expression matched, raise exception for match that made it the furthest+ −
+ −
else:+ −
+ −
if self.exprs:+ −
+ −
raise maxException+ −
+ −
else:+ −
+ −
raise ParseException(instring, loc, "no defined alternatives to match", self)+ −
+ −
+ −
+ −
def __ior__(self, other ):+ −
+ −
if isinstance( other, basestring ):+ −
+ −
other = Literal( other )+ −
+ −
return self.append( other ) #MatchFirst( [ self, other ] )+ −
+ −
+ −
+ −
def __str__( self ):+ −
+ −
if hasattr(self,"name"):+ −
+ −
return self.name+ −
+ −
+ −
+ −
if self.strRepr is None:+ −
+ −
self.strRepr = "{" + " | ".join( [ _ustr(e) for e in self.exprs ] ) + "}"+ −
+ −
+ −
+ −
return self.strRepr+ −
+ −
+ −
+ −
def checkRecursion( self, parseElementList ):+ −
+ −
subRecCheckList = parseElementList[:] + [ self ]+ −
+ −
for e in self.exprs:+ −
+ −
e.checkRecursion( subRecCheckList )+ −
+ −
+ −
+ −
class Each(ParseExpression):+ −
+ −
"""Requires all given ParseExpressions to be found, but in any order.+ −
+ −
Expressions may be separated by whitespace.+ −
+ −
May be constructed using the '&' operator.+ −
+ −
"""+ −
+ −
def __init__( self, exprs, savelist = True ):+ −
+ −
super(Each,self).__init__(exprs, savelist)+ −
+ −
self.mayReturnEmpty = True+ −
+ −
for e in self.exprs:+ −
+ −
if not e.mayReturnEmpty:+ −
+ −
self.mayReturnEmpty = False+ −
+ −
break+ −
+ −
self.skipWhitespace = True+ −
+ −
self.optionals = [ e.expr for e in exprs if isinstance(e,Optional) ]+ −
+ −
self.multioptionals = [ e.expr for e in exprs if isinstance(e,ZeroOrMore) ]+ −
+ −
self.multirequired = [ e.expr for e in exprs if isinstance(e,OneOrMore) ]+ −
+ −
self.required = [ e for e in exprs if not isinstance(e,(Optional,ZeroOrMore,OneOrMore)) ]+ −
+ −
self.required += self.multirequired+ −
+ −
+ −
+ −
def parseImpl( self, instring, loc, doActions=True ):+ −
+ −
tmpLoc = loc+ −
+ −
tmpReqd = self.required[:]+ −
+ −
tmpOpt = self.optionals[:]+ −
+ −
matchOrder = []+ −
+ −
+ −
+ −
keepMatching = True+ −
+ −
while keepMatching:+ −
+ −
tmpExprs = tmpReqd + tmpOpt + self.multioptionals + self.multirequired+ −
+ −
failed = []+ −
+ −
for e in tmpExprs:+ −
+ −
try:+ −
+ −
tmpLoc = e.tryParse( instring, tmpLoc )+ −
+ −
except ParseException:+ −
+ −
failed.append(e)+ −
+ −
else:+ −
+ −
matchOrder.append(e)+ −
+ −
if e in tmpReqd:+ −
+ −
tmpReqd.remove(e)+ −
+ −
elif e in tmpOpt:+ −
+ −
tmpOpt.remove(e)+ −
+ −
if len(failed) == len(tmpExprs):+ −
+ −
keepMatching = False+ −
+ −
+ −
+ −
if tmpReqd:+ −
+ −
missing = ", ".join( [ _ustr(e) for e in tmpReqd ] )+ −
+ −
raise ParseException(instring,loc,"Missing one or more required elements (%s)" % missing )+ −
+ −
+ −
+ −
resultlist = []+ −
+ −
for e in matchOrder:+ −
+ −
loc,results = e._parse(instring,loc,doActions)+ −
+ −
resultlist.append(results)+ −
+ −
+ −
+ −
finalResults = ParseResults([])+ −
+ −
for r in resultlist:+ −
+ −
dups = {}+ −
+ −
for k in r.keys():+ −
+ −
if k in finalResults.keys():+ −
+ −
tmp = ParseResults(finalResults[k])+ −
+ −
tmp += ParseResults(r[k])+ −
+ −
dups[k] = tmp+ −
+ −
finalResults += ParseResults(r)+ −
+ −
for k,v in dups.items():+ −
+ −
finalResults[k] = v+ −
+ −
return loc, finalResults+ −
+ −
+ −
+ −
def __str__( self ):+ −
+ −
if hasattr(self,"name"):+ −
+ −
return self.name+ −
+ −
+ −
+ −
if self.strRepr is None:+ −
+ −
self.strRepr = "{" + " & ".join( [ _ustr(e) for e in self.exprs ] ) + "}"+ −
+ −
+ −
+ −
return self.strRepr+ −
+ −
+ −
+ −
def checkRecursion( self, parseElementList ):+ −
+ −
subRecCheckList = parseElementList[:] + [ self ]+ −
+ −
for e in self.exprs:+ −
+ −
e.checkRecursion( subRecCheckList )+ −
+ −
+ −
+ −
+ −
+ −
class ParseElementEnhance(ParserElement):+ −
+ −
"""Abstract subclass of ParserElement, for combining and post-processing parsed tokens."""+ −
+ −
def __init__( self, expr, savelist=False ):+ −
+ −
super(ParseElementEnhance,self).__init__(savelist)+ −
+ −
if isinstance( expr, basestring ):+ −
+ −
expr = Literal(expr)+ −
+ −
self.expr = expr+ −
+ −
self.strRepr = None+ −
+ −
if expr is not None:+ −
+ −
self.mayIndexError = expr.mayIndexError+ −
+ −
self.setWhitespaceChars( expr.whiteChars )+ −
+ −
self.skipWhitespace = expr.skipWhitespace+ −
+ −
self.saveAsList = expr.saveAsList+ −
+ −
+ −
+ −
def parseImpl( self, instring, loc, doActions=True ):+ −
+ −
if self.expr is not None:+ −
+ −
return self.expr._parse( instring, loc, doActions, callPreParse=False )+ −
+ −
else:+ −
+ −
raise ParseException("",loc,self.errmsg,self)+ −
+ −
+ −
+ −
def leaveWhitespace( self ):+ −
+ −
self.skipWhitespace = False+ −
+ −
self.expr = self.expr.copy()+ −
+ −
if self.expr is not None:+ −
+ −
self.expr.leaveWhitespace()+ −
+ −
return self+ −
+ −
+ −
+ −
def ignore( self, other ):+ −
+ −
if isinstance( other, Suppress ):+ −
+ −
if other not in self.ignoreExprs:+ −
+ −
super( ParseElementEnhance, self).ignore( other )+ −
+ −
if self.expr is not None:+ −
+ −
self.expr.ignore( self.ignoreExprs[-1] )+ −
+ −
else:+ −
+ −
super( ParseElementEnhance, self).ignore( other )+ −
+ −
if self.expr is not None:+ −
+ −
self.expr.ignore( self.ignoreExprs[-1] )+ −
+ −
return self+ −
+ −
+ −
+ −
def streamline( self ):+ −
+ −
super(ParseElementEnhance,self).streamline()+ −
+ −
if self.expr is not None:+ −
+ −
self.expr.streamline()+ −
+ −
return self+ −
+ −
+ −
+ −
def checkRecursion( self, parseElementList ):+ −
+ −
if self in parseElementList:+ −
+ −
raise RecursiveGrammarException( parseElementList+[self] )+ −
+ −
subRecCheckList = parseElementList[:] + [ self ]+ −
+ −
if self.expr is not None:+ −
+ −
self.expr.checkRecursion( subRecCheckList )+ −
+ −
+ −
+ −
def validate( self, validateTrace=[] ):+ −
+ −
tmp = validateTrace[:]+[self]+ −
+ −
if self.expr is not None:+ −
+ −
self.expr.validate(tmp)+ −
+ −
self.checkRecursion( [] )+ −
+ −
+ −
+ −
def __str__( self ):+ −
+ −
try:+ −
+ −
return super(ParseElementEnhance,self).__str__()+ −
+ −
except:+ −
+ −
pass+ −
+ −
+ −
+ −
if self.strRepr is None and self.expr is not None:+ −
+ −
self.strRepr = "%s:(%s)" % ( self.__class__.__name__, _ustr(self.expr) )+ −
+ −
return self.strRepr+ −
+ −
+ −
+ −
+ −
+ −
class FollowedBy(ParseElementEnhance):+ −
+ −
"""Lookahead matching of the given parse expression. FollowedBy+ −
+ −
does *not* advance the parsing position within the input string, it only + −
+ −
verifies that the specified parse expression matches at the current + −
+ −
position. FollowedBy always returns a null token list."""+ −
+ −
def __init__( self, expr ):+ −
+ −
super(FollowedBy,self).__init__(expr)+ −
+ −
self.mayReturnEmpty = True+ −
+ −
+ −
+ −
def parseImpl( self, instring, loc, doActions=True ):+ −
+ −
self.expr.tryParse( instring, loc )+ −
+ −
return loc, []+ −
+ −
+ −
+ −
+ −
+ −
class NotAny(ParseElementEnhance):+ −
+ −
"""Lookahead to disallow matching with the given parse expression. NotAny+ −
+ −
does *not* advance the parsing position within the input string, it only + −
+ −
verifies that the specified parse expression does *not* match at the current + −
+ −
position. Also, NotAny does *not* skip over leading whitespace. NotAny + −
+ −
always returns a null token list. May be constructed using the '~' operator."""+ −
+ −
def __init__( self, expr ):+ −
+ −
super(NotAny,self).__init__(expr)+ −
+ −
#~ self.leaveWhitespace()+ −
+ −
self.skipWhitespace = False # do NOT use self.leaveWhitespace(), don't want to propagate to exprs+ −
+ −
self.mayReturnEmpty = True+ −
+ −
self.errmsg = "Found unwanted token, "+_ustr(self.expr)+ −
+ −
self.myException = ParseException("",0,self.errmsg,self)+ −
+ −
+ −
+ −
def parseImpl( self, instring, loc, doActions=True ):+ −
+ −
try:+ −
+ −
self.expr.tryParse( instring, loc )+ −
+ −
except (ParseException,IndexError):+ −
+ −
pass+ −
+ −
else:+ −
+ −
#~ raise ParseException(instring, loc, self.errmsg )+ −
+ −
exc = self.myException+ −
+ −
exc.loc = loc+ −
+ −
exc.pstr = instring+ −
+ −
raise exc+ −
+ −
return loc, []+ −
+ −
+ −
+ −
def __str__( self ):+ −
+ −
if hasattr(self,"name"):+ −
+ −
return self.name+ −
+ −
+ −
+ −
if self.strRepr is None:+ −
+ −
self.strRepr = "~{" + _ustr(self.expr) + "}"+ −
+ −
+ −
+ −
return self.strRepr+ −
+ −
+ −
+ −
+ −
+ −
class ZeroOrMore(ParseElementEnhance):+ −
+ −
"""Optional repetition of zero or more of the given expression."""+ −
+ −
def __init__( self, expr ):+ −
+ −
super(ZeroOrMore,self).__init__(expr)+ −
+ −
self.mayReturnEmpty = True+ −
+ −
+ −
+ −
def parseImpl( self, instring, loc, doActions=True ):+ −
+ −
tokens = []+ −
+ −
try:+ −
+ −
loc, tokens = self.expr._parse( instring, loc, doActions, callPreParse=False )+ −
+ −
hasIgnoreExprs = ( len(self.ignoreExprs) > 0 )+ −
+ −
while 1:+ −
+ −
if hasIgnoreExprs:+ −
+ −
preloc = self.skipIgnorables( instring, loc )+ −
+ −
else:+ −
+ −
preloc = loc+ −
+ −
loc, tmptokens = self.expr._parse( instring, preloc, doActions )+ −
+ −
if tmptokens or tmptokens.keys():+ −
+ −
tokens += tmptokens+ −
+ −
except (ParseException,IndexError):+ −
+ −
pass+ −
+ −
+ −
+ −
return loc, tokens+ −
+ −
+ −
+ −
def __str__( self ):+ −
+ −
if hasattr(self,"name"):+ −
+ −
return self.name+ −
+ −
+ −
+ −
if self.strRepr is None:+ −
+ −
self.strRepr = "[" + _ustr(self.expr) + "]..."+ −
+ −
+ −
+ −
return self.strRepr+ −
+ −
+ −
+ −
def setResultsName( self, name, listAllMatches=False ):+ −
+ −
ret = super(ZeroOrMore,self).setResultsName(name,listAllMatches)+ −
+ −
ret.saveAsList = True+ −
+ −
return ret+ −
+ −
+ −
+ −
+ −
+ −
class OneOrMore(ParseElementEnhance):+ −
+ −
"""Repetition of one or more of the given expression."""+ −
+ −
def parseImpl( self, instring, loc, doActions=True ):+ −
+ −
# must be at least one+ −
+ −
loc, tokens = self.expr._parse( instring, loc, doActions, callPreParse=False )+ −
+ −
try:+ −
+ −
hasIgnoreExprs = ( len(self.ignoreExprs) > 0 )+ −
+ −
while 1:+ −
+ −
if hasIgnoreExprs:+ −
+ −
preloc = self.skipIgnorables( instring, loc )+ −
+ −
else:+ −
+ −
preloc = loc+ −
+ −
loc, tmptokens = self.expr._parse( instring, preloc, doActions )+ −
+ −
if tmptokens or tmptokens.keys():+ −
+ −
tokens += tmptokens+ −
+ −
except (ParseException,IndexError):+ −
+ −
pass+ −
+ −
+ −
+ −
return loc, tokens+ −
+ −
+ −
+ −
def __str__( self ):+ −
+ −
if hasattr(self,"name"):+ −
+ −
return self.name+ −
+ −
+ −
+ −
if self.strRepr is None:+ −
+ −
self.strRepr = "{" + _ustr(self.expr) + "}..."+ −
+ −
+ −
+ −
return self.strRepr+ −
+ −
+ −
+ −
def setResultsName( self, name, listAllMatches=False ):+ −
+ −
ret = super(OneOrMore,self).setResultsName(name,listAllMatches)+ −
+ −
ret.saveAsList = True+ −
+ −
return ret+ −
+ −
+ −
+ −
class _NullToken(object):+ −
+ −
def __bool__(self):+ −
+ −
return False+ −
+ −
def __str__(self):+ −
+ −
return ""+ −
+ −
+ −
+ −
_optionalNotMatched = _NullToken()+ −
+ −
class Optional(ParseElementEnhance):+ −
+ −
"""Optional matching of the given expression.+ −
+ −
A default return string can also be specified, if the optional expression+ −
+ −
is not found.+ −
+ −
"""+ −
+ −
def __init__( self, exprs, default=_optionalNotMatched ):+ −
+ −
super(Optional,self).__init__( exprs, savelist=False )+ −
+ −
self.defaultValue = default+ −
+ −
self.mayReturnEmpty = True+ −
+ −
+ −
+ −
def parseImpl( self, instring, loc, doActions=True ):+ −
+ −
try:+ −
+ −
loc, tokens = self.expr._parse( instring, loc, doActions, callPreParse=False )+ −
+ −
except (ParseException,IndexError):+ −
+ −
if self.defaultValue is not _optionalNotMatched:+ −
+ −
tokens = [ self.defaultValue ]+ −
+ −
else:+ −
+ −
tokens = []+ −
+ −
return loc, tokens+ −
+ −
+ −
+ −
def __str__( self ):+ −
+ −
if hasattr(self,"name"):+ −
+ −
return self.name+ −
+ −
+ −
+ −
if self.strRepr is None:+ −
+ −
self.strRepr = "[" + _ustr(self.expr) + "]"+ −
+ −
+ −
+ −
return self.strRepr+ −
+ −
+ −
+ −
+ −
+ −
class SkipTo(ParseElementEnhance):+ −
+ −
"""Token for skipping over all undefined text until the matched expression is found.+ −
+ −
If include is set to true, the matched expression is also consumed. The ignore+ −
+ −
argument is used to define grammars (typically quoted strings and comments) that + −
+ −
might contain false matches.+ −
+ −
"""+ −
+ −
def __init__( self, other, include=False, ignore=None ):+ −
+ −
super( SkipTo, self ).__init__( other )+ −
+ −
if ignore is not None:+ −
+ −
self.expr = self.expr.copy()+ −
+ −
self.expr.ignore(ignore)+ −
+ −
self.mayReturnEmpty = True+ −
+ −
self.mayIndexError = False+ −
+ −
self.includeMatch = include+ −
+ −
self.asList = False+ −
+ −
self.errmsg = "No match found for "+_ustr(self.expr)+ −
+ −
self.myException = ParseException("",0,self.errmsg,self)+ −
+ −
+ −
+ −
def parseImpl( self, instring, loc, doActions=True ):+ −
+ −
startLoc = loc+ −
+ −
instrlen = len(instring)+ −
+ −
expr = self.expr+ −
+ −
while loc <= instrlen:+ −
+ −
try:+ −
+ −
loc = expr.skipIgnorables( instring, loc )+ −
+ −
expr._parse( instring, loc, doActions=False, callPreParse=False )+ −
+ −
if self.includeMatch:+ −
+ −
skipText = instring[startLoc:loc]+ −
+ −
loc,mat = expr._parse(instring,loc)+ −
+ −
if mat:+ −
+ −
return loc, [ skipText, mat ]+ −
+ −
else:+ −
+ −
return loc, [ skipText ]+ −
+ −
else:+ −
+ −
return loc, [ instring[startLoc:loc] ]+ −
+ −
except (ParseException,IndexError):+ −
+ −
loc += 1+ −
+ −
exc = self.myException+ −
+ −
exc.loc = loc+ −
+ −
exc.pstr = instring+ −
+ −
raise exc+ −
+ −
+ −
+ −
class Forward(ParseElementEnhance):+ −
+ −
"""Forward declaration of an expression to be defined later -+ −
+ −
used for recursive grammars, such as algebraic infix notation.+ −
+ −
When the expression is known, it is assigned to the Forward variable using the '<<' operator.+ −
+ −
+ −
+ −
Note: take care when assigning to Forward not to overlook precedence of operators.+ −
+ −
Specifically, '|' has a lower precedence than '<<', so that::+ −
+ −
fwdExpr << a | b | c+ −
+ −
will actually be evaluated as::+ −
+ −
(fwdExpr << a) | b | c+ −
+ −
thereby leaving b and c out as parseable alternatives. It is recommended that you+ −
+ −
explicitly group the values inserted into the Forward::+ −
+ −
fwdExpr << (a | b | c)+ −
+ −
"""+ −
+ −
def __init__( self, other=None ):+ −
+ −
super(Forward,self).__init__( other, savelist=False )+ −
+ −
+ −
+ −
def __lshift__( self, other ):+ −
+ −
if isinstance( other, basestring ):+ −
+ −
other = Literal(other)+ −
+ −
self.expr = other+ −
+ −
self.mayReturnEmpty = other.mayReturnEmpty+ −
+ −
self.strRepr = None+ −
+ −
return self+ −
+ −
+ −
+ −
def leaveWhitespace( self ):+ −
+ −
self.skipWhitespace = False+ −
+ −
return self+ −
+ −
+ −
+ −
def streamline( self ):+ −
+ −
if not self.streamlined:+ −
+ −
self.streamlined = True+ −
+ −
if self.expr is not None: + −
+ −
self.expr.streamline()+ −
+ −
return self+ −
+ −
+ −
+ −
def validate( self, validateTrace=[] ):+ −
+ −
if self not in validateTrace:+ −
+ −
tmp = validateTrace[:]+[self]+ −
+ −
if self.expr is not None: + −
+ −
self.expr.validate(tmp)+ −
+ −
self.checkRecursion([]) + −
+ −
+ −
+ −
def __str__( self ):+ −
+ −
if hasattr(self,"name"):+ −
+ −
return self.name+ −
+ −
+ −
+ −
self.__class__ = _ForwardNoRecurse+ −
+ −
try:+ −
+ −
if self.expr is not None: + −
+ −
retString = _ustr(self.expr)+ −
+ −
else:+ −
+ −
retString = "None"+ −
+ −
finally:+ −
+ −
self.__class__ = Forward+ −
+ −
return "Forward: "+retString+ −
+ −
+ −
+ −
def copy(self):+ −
+ −
if self.expr is not None:+ −
+ −
return super(Forward,self).copy()+ −
+ −
else:+ −
+ −
ret = Forward()+ −
+ −
ret << self+ −
+ −
return ret+ −
+ −
+ −
+ −
class _ForwardNoRecurse(Forward):+ −
+ −
def __str__( self ):+ −
+ −
return "..."+ −
+ −
+ −
+ −
class TokenConverter(ParseElementEnhance):+ −
+ −
"""Abstract subclass of ParseExpression, for converting parsed results."""+ −
+ −
def __init__( self, expr, savelist=False ):+ −
+ −
super(TokenConverter,self).__init__( expr )#, savelist )+ −
+ −
self.saveAsList = False+ −
+ −
+ −
+ −
+ −
+ −
class Upcase(TokenConverter):+ −
+ −
"""Converter to upper case all matching tokens."""+ −
+ −
def __init__(self, *args):+ −
+ −
super(Upcase,self).__init__(*args)+ −
+ −
warnings.warn("Upcase class is deprecated, use upcaseTokens parse action instead", + −
+ −
DeprecationWarning,stacklevel=2)+ −
+ −
+ −
+ −
def postParse( self, instring, loc, tokenlist ):+ −
+ −
return map( string.upper, tokenlist )+ −
+ −
+ −
+ −
+ −
+ −
class Combine(TokenConverter):+ −
+ −
"""Converter to concatenate all matching tokens to a single string.+ −
+ −
By default, the matching patterns must also be contiguous in the input string;+ −
+ −
this can be disabled by specifying 'adjacent=False' in the constructor.+ −
+ −
"""+ −
+ −
def __init__( self, expr, joinString="", adjacent=True ):+ −
+ −
super(Combine,self).__init__( expr )+ −
+ −
# suppress whitespace-stripping in contained parse expressions, but re-enable it on the Combine itself+ −
+ −
if adjacent:+ −
+ −
self.leaveWhitespace()+ −
+ −
self.adjacent = adjacent+ −
+ −
self.skipWhitespace = True+ −
+ −
self.joinString = joinString+ −
+ −
+ −
+ −
def ignore( self, other ):+ −
+ −
if self.adjacent:+ −
+ −
ParserElement.ignore(self, other)+ −
+ −
else:+ −
+ −
super( Combine, self).ignore( other )+ −
+ −
return self+ −
+ −
+ −
+ −
def postParse( self, instring, loc, tokenlist ):+ −
+ −
retToks = tokenlist.copy()+ −
+ −
del retToks[:]+ −
+ −
retToks += ParseResults([ "".join(tokenlist._asStringList(self.joinString)) ], modal=self.modalResults)+ −
+ −
+ −
+ −
if self.resultsName and len(retToks.keys())>0:+ −
+ −
return [ retToks ]+ −
+ −
else:+ −
+ −
return retToks+ −
+ −
+ −
+ −
class Group(TokenConverter):+ −
+ −
"""Converter to return the matched tokens as a list - useful for returning tokens of ZeroOrMore and OneOrMore expressions."""+ −
+ −
def __init__( self, expr ):+ −
+ −
super(Group,self).__init__( expr )+ −
+ −
self.saveAsList = True+ −
+ −
+ −
+ −
def postParse( self, instring, loc, tokenlist ):+ −
+ −
return [ tokenlist ]+ −
+ −
+ −
+ −
class Dict(TokenConverter):+ −
+ −
"""Converter to return a repetitive expression as a list, but also as a dictionary.+ −
+ −
Each element can also be referenced using the first token in the expression as its key.+ −
+ −
Useful for tabular report scraping when the first column can be used as a item key.+ −
+ −
"""+ −
+ −
def __init__( self, exprs ):+ −
+ −
super(Dict,self).__init__( exprs )+ −
+ −
self.saveAsList = True+ −
+ −
+ −
+ −
def postParse( self, instring, loc, tokenlist ):+ −
+ −
for i,tok in enumerate(tokenlist):+ −
+ −
ikey = _ustr(tok[0]).strip()+ −
+ −
if len(tok)==1:+ −
+ −
tokenlist[ikey] = ("",i)+ −
+ −
elif len(tok)==2 and not isinstance(tok[1],ParseResults):+ −
+ −
tokenlist[ikey] = (tok[1],i)+ −
+ −
else:+ −
+ −
dictvalue = tok.copy() #ParseResults(i)+ −
+ −
del dictvalue[0]+ −
+ −
if len(dictvalue)!= 1 or (isinstance(dictvalue,ParseResults) and dictvalue.keys()):+ −
+ −
tokenlist[ikey] = (dictvalue,i)+ −
+ −
else:+ −
+ −
tokenlist[ikey] = (dictvalue[0],i)+ −
+ −
+ −
+ −
if self.resultsName:+ −
+ −
return [ tokenlist ]+ −
+ −
else:+ −
+ −
return tokenlist+ −
+ −
+ −
+ −
+ −
+ −
class Suppress(TokenConverter):+ −
+ −
"""Converter for ignoring the results of a parsed expression."""+ −
+ −
def postParse( self, instring, loc, tokenlist ):+ −
+ −
return []+ −
+ −
+ −
+ −
def suppress( self ):+ −
+ −
return self+ −
+ −
+ −
+ −
+ −
+ −
class OnlyOnce(object):+ −
+ −
"""Wrapper for parse actions, to ensure they are only called once."""+ −
+ −
def __init__(self, methodCall):+ −
+ −
self.callable = ParserElement.normalizeParseActionArgs(methodCall)+ −
+ −
self.called = False+ −
+ −
def __call__(self,s,l,t):+ −
+ −
if not self.called:+ −
+ −
results = self.callable(s,l,t)+ −
+ −
self.called = True+ −
+ −
return results+ −
+ −
raise ParseException(s,l,"")+ −
+ −
def reset():+ −
+ −
self.called = False+ −
+ −
+ −
+ −
def traceParseAction(f):+ −
+ −
"""Decorator for debugging parse actions."""+ −
+ −
f = ParserElement.normalizeParseActionArgs(f)+ −
+ −
def z(*paArgs):+ −
+ −
thisFunc = f.func_name+ −
+ −
s,l,t = paArgs[-3:]+ −
+ −
if len(paArgs)>3:+ −
+ −
thisFunc = paArgs[0].__class__.__name__ + '.' + thisFunc+ −
+ −
sys.stderr.write( ">>entering %s(line: '%s', %d, %s)\n" % (thisFunc,line(l,s),l,t) )+ −
+ −
try:+ −
+ −
ret = f(*paArgs)+ −
+ −
except Exception, exc:+ −
+ −
sys.stderr.write( "<<leaving %s (exception: %s)\n" % (thisFunc,exc) )+ −
+ −
raise+ −
+ −
sys.stderr.write( "<<leaving %s (ret: %s)\n" % (thisFunc,ret) )+ −
+ −
return ret+ −
+ −
return z+ −
+ −
+ −
+ −
#+ −
+ −
# global helpers+ −
+ −
#+ −
+ −
def delimitedList( expr, delim=",", combine=False ):+ −
+ −
"""Helper to define a delimited list of expressions - the delimiter defaults to ','.+ −
+ −
By default, the list elements and delimiters can have intervening whitespace, and + −
+ −
comments, but this can be overridden by passing 'combine=True' in the constructor.+ −
+ −
If combine is set to True, the matching tokens are returned as a single token+ −
+ −
string, with the delimiters included; otherwise, the matching tokens are returned+ −
+ −
as a list of tokens, with the delimiters suppressed.+ −
+ −
"""+ −
+ −
dlName = _ustr(expr)+" ["+_ustr(delim)+" "+_ustr(expr)+"]..."+ −
+ −
if combine:+ −
+ −
return Combine( expr + ZeroOrMore( delim + expr ) ).setName(dlName)+ −
+ −
else:+ −
+ −
return ( expr + ZeroOrMore( Suppress( delim ) + expr ) ).setName(dlName)+ −
+ −
+ −
+ −
def countedArray( expr ):+ −
+ −
"""Helper to define a counted list of expressions.+ −
+ −
This helper defines a pattern of the form::+ −
+ −
integer expr expr expr...+ −
+ −
where the leading integer tells how many expr expressions follow.+ −
+ −
The matched tokens returns the array of expr tokens as a list - the leading count token is suppressed.+ −
+ −
"""+ −
+ −
arrayExpr = Forward()+ −
+ −
def countFieldParseAction(s,l,t):+ −
+ −
n = int(t[0])+ −
+ −
arrayExpr << (n and Group(And([expr]*n)) or Group(empty))+ −
+ −
return []+ −
+ −
return ( Word(nums).setParseAction(countFieldParseAction) + arrayExpr )+ −
+ −
+ −
+ −
def _flatten(L):+ −
+ −
if type(L) is not list: return [L]+ −
+ −
if L == []: return L+ −
+ −
return _flatten(L[0]) + _flatten(L[1:])+ −
+ −
+ −
+ −
def matchPreviousLiteral(expr):+ −
+ −
"""Helper to define an expression that is indirectly defined from+ −
+ −
the tokens matched in a previous expression, that is, it looks+ −
+ −
for a 'repeat' of a previous expression. For example::+ −
+ −
first = Word(nums)+ −
+ −
second = matchPreviousLiteral(first)+ −
+ −
matchExpr = first + ":" + second+ −
+ −
will match "1:1", but not "1:2". Because this matches a + −
+ −
previous literal, will also match the leading "1:1" in "1:10". + −
+ −
If this is not desired, use matchPreviousExpr.+ −
+ −
Do *not* use with packrat parsing enabled.+ −
+ −
"""+ −
+ −
rep = Forward()+ −
+ −
def copyTokenToRepeater(s,l,t):+ −
+ −
if t:+ −
+ −
if len(t) == 1:+ −
+ −
rep << t[0]+ −
+ −
else:+ −
+ −
# flatten t tokens+ −
+ −
tflat = _flatten(t.asList())+ −
+ −
rep << And( [ Literal(tt) for tt in tflat ] )+ −
+ −
else:+ −
+ −
rep << Empty()+ −
+ −
expr.addParseAction(copyTokenToRepeater)+ −
+ −
return rep+ −
+ −
+ −
+ −
def matchPreviousExpr(expr):+ −
+ −
"""Helper to define an expression that is indirectly defined from+ −
+ −
the tokens matched in a previous expression, that is, it looks+ −
+ −
for a 'repeat' of a previous expression. For example::+ −
+ −
first = Word(nums)+ −
+ −
second = matchPreviousExpr(first)+ −
+ −
matchExpr = first + ":" + second+ −
+ −
will match "1:1", but not "1:2". Because this matches by+ −
+ −
expressions, will *not* match the leading "1:1" in "1:10";+ −
+ −
the expressions are evaluated first, and then compared, so+ −
+ −
"1" is compared with "10".+ −
+ −
Do *not* use with packrat parsing enabled.+ −
+ −
"""+ −
+ −
rep = Forward()+ −
+ −
e2 = expr.copy()+ −
+ −
rep << e2+ −
+ −
def copyTokenToRepeater(s,l,t):+ −
+ −
matchTokens = _flatten(t.asList())+ −
+ −
def mustMatchTheseTokens(s,l,t):+ −
+ −
theseTokens = _flatten(t.asList())+ −
+ −
if theseTokens != matchTokens:+ −
+ −
raise ParseException("",0,"")+ −
+ −
rep.setParseAction( mustMatchTheseTokens )+ −
+ −
expr.addParseAction(copyTokenToRepeater)+ −
+ −
return rep+ −
+ −
+ −
+ −
def _escapeRegexRangeChars(s):+ −
+ −
#~ escape these chars: ^-]+ −
+ −
for c in r"\^-]":+ −
+ −
s = s.replace(c,"\\"+c)+ −
+ −
s = s.replace("\n",r"\n")+ −
+ −
s = s.replace("\t",r"\t")+ −
+ −
return _ustr(s)+ −
+ −
+ −
+ −
def oneOf( strs, caseless=False, useRegex=True ):+ −
+ −
"""Helper to quickly define a set of alternative Literals, and makes sure to do + −
+ −
longest-first testing when there is a conflict, regardless of the input order, + −
+ −
but returns a MatchFirst for best performance. + −
+ −
+ −
+ −
Parameters:+ −
+ −
- strs - a string of space-delimited literals, or a list of string literals+ −
+ −
- caseless - (default=False) - treat all literals as caseless+ −
+ −
- useRegex - (default=True) - as an optimization, will generate a Regex+ −
+ −
object; otherwise, will generate a MatchFirst object (if caseless=True, or+ −
+ −
if creating a Regex raises an exception)+ −
+ −
"""+ −
+ −
if caseless:+ −
+ −
isequal = ( lambda a,b: a.upper() == b.upper() )+ −
+ −
masks = ( lambda a,b: b.upper().startswith(a.upper()) )+ −
+ −
parseElementClass = CaselessLiteral+ −
+ −
else:+ −
+ −
isequal = ( lambda a,b: a == b )+ −
+ −
masks = ( lambda a,b: b.startswith(a) )+ −
+ −
parseElementClass = Literal+ −
+ −
+ −
+ −
if isinstance(strs,(list,tuple)):+ −
+ −
symbols = strs[:]+ −
+ −
elif isinstance(strs,basestring):+ −
+ −
symbols = strs.split()+ −
+ −
else:+ −
+ −
warnings.warn("Invalid argument to oneOf, expected string or list",+ −
+ −
SyntaxWarning, stacklevel=2)+ −
+ −
+ −
+ −
i = 0+ −
+ −
while i < len(symbols)-1:+ −
+ −
cur = symbols[i]+ −
+ −
for j,other in enumerate(symbols[i+1:]):+ −
+ −
if ( isequal(other, cur) ):+ −
+ −
del symbols[i+j+1]+ −
+ −
break+ −
+ −
elif ( masks(cur, other) ):+ −
+ −
del symbols[i+j+1]+ −
+ −
symbols.insert(i,other)+ −
+ −
cur = other+ −
+ −
break+ −
+ −
else:+ −
+ −
i += 1+ −
+ −
+ −
+ −
if not caseless and useRegex:+ −
+ −
#~ print strs,"->", "|".join( [ _escapeRegexChars(sym) for sym in symbols] )+ −
+ −
try:+ −
+ −
if len(symbols)==len("".join(symbols)):+ −
+ −
return Regex( "[%s]" % "".join( [ _escapeRegexRangeChars(sym) for sym in symbols] ) )+ −
+ −
else:+ −
+ −
return Regex( "|".join( [ re.escape(sym) for sym in symbols] ) )+ −
+ −
except:+ −
+ −
warnings.warn("Exception creating Regex for oneOf, building MatchFirst",+ −
+ −
SyntaxWarning, stacklevel=2)+ −
+ −
+ −
+ −
+ −
+ −
# last resort, just use MatchFirst+ −
+ −
return MatchFirst( [ parseElementClass(sym) for sym in symbols ] )+ −
+ −
+ −
+ −
def dictOf( key, value ):+ −
+ −
"""Helper to easily and clearly define a dictionary by specifying the respective patterns+ −
+ −
for the key and value. Takes care of defining the Dict, ZeroOrMore, and Group tokens+ −
+ −
in the proper order. The key pattern can include delimiting markers or punctuation,+ −
+ −
as long as they are suppressed, thereby leaving the significant key text. The value+ −
+ −
pattern can include named results, so that the Dict results can include named token + −
+ −
fields.+ −
+ −
"""+ −
+ −
return Dict( ZeroOrMore( Group ( key + value ) ) )+ −
+ −
+ −
+ −
_bslash = "\\"+ −
+ −
printables = "".join( [ c for c in string.printable if c not in string.whitespace ] )+ −
+ −
+ −
+ −
# convenience constants for positional expressions+ −
+ −
empty = Empty().setName("empty")+ −
+ −
lineStart = LineStart().setName("lineStart")+ −
+ −
lineEnd = LineEnd().setName("lineEnd")+ −
+ −
stringStart = StringStart().setName("stringStart")+ −
+ −
stringEnd = StringEnd().setName("stringEnd")+ −
+ −
+ −
+ −
_escapedPunc = Word( _bslash, r"\[]-*.$+^?()~ ", exact=2 ).setParseAction(lambda s,l,t:t[0][1])+ −
+ −
_printables_less_backslash = "".join([ c for c in printables if c not in r"\]" ])+ −
+ −
_escapedHexChar = Combine( Suppress(_bslash + "0x") + Word(hexnums) ).setParseAction(lambda s,l,t:unichr(int(t[0],16)))+ −
+ −
_escapedOctChar = Combine( Suppress(_bslash) + Word("0","01234567") ).setParseAction(lambda s,l,t:unichr(int(t[0],8)))+ −
+ −
_singleChar = _escapedPunc | _escapedHexChar | _escapedOctChar | Word(_printables_less_backslash,exact=1)+ −
+ −
_charRange = Group(_singleChar + Suppress("-") + _singleChar)+ −
+ −
_reBracketExpr = "[" + Optional("^").setResultsName("negate") + Group( OneOrMore( _charRange | _singleChar ) ).setResultsName("body") + "]"+ −
+ −
+ −
+ −
_expanded = lambda p: (isinstance(p,ParseResults) and ''.join([ unichr(c) for c in range(ord(p[0]),ord(p[1])+1) ]) or p)+ −
+ −
+ −
+ −
def srange(s):+ −
+ −
r"""Helper to easily define string ranges for use in Word construction. Borrows+ −
+ −
syntax from regexp '[]' string range definitions::+ −
+ −
srange("[0-9]") -> "0123456789"+ −
+ −
srange("[a-z]") -> "abcdefghijklmnopqrstuvwxyz"+ −
+ −
srange("[a-z$_]") -> "abcdefghijklmnopqrstuvwxyz$_"+ −
+ −
The input string must be enclosed in []'s, and the returned string is the expanded + −
+ −
character set joined into a single string.+ −
+ −
The values enclosed in the []'s may be::+ −
+ −
a single character+ −
+ −
an escaped character with a leading backslash (such as \- or \])+ −
+ −
an escaped hex character with a leading '\0x' (\0x21, which is a '!' character)+ −
+ −
an escaped octal character with a leading '\0' (\041, which is a '!' character)+ −
+ −
a range of any of the above, separated by a dash ('a-z', etc.)+ −
+ −
any combination of the above ('aeiouy', 'a-zA-Z0-9_$', etc.)+ −
+ −
"""+ −
+ −
try:+ −
+ −
return "".join([_expanded(part) for part in _reBracketExpr.parseString(s).body])+ −
+ −
except:+ −
+ −
return ""+ −
+ −
+ −
+ −
def replaceWith(replStr):+ −
+ −
"""Helper method for common parse actions that simply return a literal value. Especially + −
+ −
useful when used with transformString().+ −
+ −
"""+ −
+ −
def _replFunc(*args):+ −
+ −
return [replStr]+ −
+ −
return _replFunc+ −
+ −
+ −
+ −
def removeQuotes(s,l,t):+ −
+ −
"""Helper parse action for removing quotation marks from parsed quoted strings.+ −
+ −
To use, add this parse action to quoted string using::+ −
+ −
quotedString.setParseAction( removeQuotes )+ −
+ −
"""+ −
+ −
return t[0][1:-1]+ −
+ −
+ −
+ −
def upcaseTokens(s,l,t):+ −
+ −
"""Helper parse action to convert tokens to upper case."""+ −
+ −
return [ str(tt).upper() for tt in t ]+ −
+ −
+ −
+ −
def downcaseTokens(s,l,t):+ −
+ −
"""Helper parse action to convert tokens to lower case."""+ −
+ −
return [ str(tt).lower() for tt in t ]+ −
+ −
+ −
+ −
def keepOriginalText(s,startLoc,t):+ −
+ −
import inspect+ −
+ −
"""Helper parse action to preserve original parsed text,+ −
+ −
overriding any nested parse actions."""+ −
+ −
f = inspect.stack()[1][0]+ −
+ −
try:+ −
+ −
endloc = f.f_locals["loc"]+ −
+ −
finally:+ −
+ −
del f+ −
+ −
return s[startLoc:endloc]+ −
+ −
+ −
+ −
def _makeTags(tagStr, xml):+ −
+ −
"""Internal helper to construct opening and closing tag expressions, given a tag name"""+ −
+ −
if isinstance(tagStr,basestring):+ −
+ −
resname = tagStr+ −
+ −
tagStr = Keyword(tagStr, caseless=not xml)+ −
+ −
else:+ −
+ −
resname = tagStr.name+ −
+ −
+ −
+ −
tagAttrName = Word(alphas,alphanums+"_-")+ −
+ −
if (xml):+ −
+ −
tagAttrValue = dblQuotedString.copy().setParseAction( removeQuotes )+ −
+ −
openTag = Suppress("<") + tagStr + \+ −
Dict(ZeroOrMore(Group( tagAttrName + Suppress("=") + tagAttrValue ))) + \+ −
Optional("/",default=[False]).setResultsName("empty").setParseAction(lambda s,l,t:t[0]=='/') + Suppress(">")+ −
+ −
else:+ −
+ −
printablesLessRAbrack = "".join( [ c for c in printables if c not in ">" ] )+ −
+ −
tagAttrValue = quotedString.copy().setParseAction( removeQuotes ) | Word(printablesLessRAbrack)+ −
+ −
openTag = Suppress("<") + tagStr + \+ −
Dict(ZeroOrMore(Group( tagAttrName.setParseAction(downcaseTokens) + \+ −
+ −
Suppress("=") + tagAttrValue ))) + \+ −
Optional("/",default=[False]).setResultsName("empty").setParseAction(lambda s,l,t:t[0]=='/') + Suppress(">")+ −
+ −
closeTag = Combine("</" + tagStr + ">")+ −
+ −
+ −
+ −
openTag = openTag.setResultsName("start"+"".join(resname.replace(":"," ").title().split())).setName("<%s>" % tagStr)+ −
+ −
closeTag = closeTag.setResultsName("end"+"".join(resname.replace(":"," ").title().split())).setName("</%s>" % tagStr)+ −
+ −
+ −
+ −
return openTag, closeTag+ −
+ −
+ −
+ −
def makeHTMLTags(tagStr):+ −
+ −
"""Helper to construct opening and closing tag expressions for HTML, given a tag name"""+ −
+ −
return _makeTags( tagStr, False )+ −
+ −
+ −
+ −
def makeXMLTags(tagStr):+ −
+ −
"""Helper to construct opening and closing tag expressions for XML, given a tag name"""+ −
+ −
return _makeTags( tagStr, True )+ −
+ −
+ −
+ −
opAssoc = _Constants()+ −
+ −
opAssoc.LEFT = object()+ −
+ −
opAssoc.RIGHT = object()+ −
+ −
+ −
+ −
def operatorPrecedence( baseExpr, opList ):+ −
+ −
"""Helper method for constructing grammars of expressions made up of + −
+ −
operators working in a precedence hierarchy. Operators may be unary or+ −
+ −
binary, left- or right-associative. Parse actions can also be attached+ −
+ −
to operator expressions.+ −
+ −
+ −
+ −
Parameters:+ −
+ −
- baseExpr - expression representing the most basic element for the nested + −
+ −
- opList - list of tuples, one for each operator precedence level in the expression grammar; each tuple is of the form+ −
+ −
(opExpr, numTerms, rightLeftAssoc, parseAction), where:+ −
+ −
- opExpr is the pyparsing expression for the operator;+ −
+ −
may also be a string, which will be converted to a Literal+ −
+ −
- numTerms is the number of terms for this operator (must+ −
+ −
be 1 or 2)+ −
+ −
- rightLeftAssoc is the indicator whether the operator is+ −
+ −
right or left associative, using the pyparsing-defined+ −
+ −
constants opAssoc.RIGHT and opAssoc.LEFT.+ −
+ −
- parseAction is the parse action to be associated with + −
+ −
expressions matching this operator expression (the+ −
+ −
parse action tuple member may be omitted)+ −
+ −
"""+ −
+ −
ret = Forward()+ −
+ −
lastExpr = baseExpr | ( Suppress('(') + ret + Suppress(')') )+ −
+ −
for i,operDef in enumerate(opList):+ −
+ −
opExpr,arity,rightLeftAssoc,pa = (operDef + (None,))[:4]+ −
+ −
thisExpr = Forward().setName("expr%d" % i)+ −
+ −
if rightLeftAssoc == opAssoc.LEFT:+ −
+ −
if arity == 1:+ −
+ −
matchExpr = Group( lastExpr + opExpr )+ −
+ −
elif arity == 2:+ −
+ −
matchExpr = Group( lastExpr + OneOrMore( opExpr + lastExpr ) )+ −
+ −
else:+ −
+ −
raise ValueError, "operator must be unary (1) or binary (2)"+ −
+ −
elif rightLeftAssoc == opAssoc.RIGHT:+ −
+ −
if arity == 1:+ −
+ −
# try to avoid LR with this extra test+ −
+ −
if not isinstance(opExpr, Optional):+ −
+ −
opExpr = Optional(opExpr)+ −
+ −
matchExpr = FollowedBy(opExpr.expr + thisExpr) + Group( opExpr + thisExpr ) + −
+ −
elif arity == 2:+ −
+ −
matchExpr = Group( lastExpr + OneOrMore( opExpr + thisExpr ) )+ −
+ −
else:+ −
+ −
raise ValueError, "operator must be unary (1) or binary (2)"+ −
+ −
else:+ −
+ −
raise ValueError, "operator must indicate right or left associativity"+ −
+ −
if pa:+ −
+ −
matchExpr.setParseAction( pa )+ −
+ −
thisExpr << ( matchExpr | lastExpr )+ −
+ −
lastExpr = thisExpr+ −
+ −
ret << lastExpr+ −
+ −
return ret+ −
+ −
+ −
+ −
alphas8bit = srange(r"[\0xc0-\0xd6\0xd8-\0xf6\0xf8-\0xff]")+ −
+ −
punc8bit = srange(r"[\0xa1-\0xbf\0xd7\0xf7]")+ −
+ −
+ −
+ −
dblQuotedString = Regex(r'"(?:[^"\n\r\\]|(?:"")|(?:\\.))*"').setName("string enclosed in double quotes")+ −
+ −
sglQuotedString = Regex(r"'(?:[^'\n\r\\]|(?:'')|(?:\\.))*'").setName("string enclosed in single quotes")+ −
+ −
quotedString = Regex(r'''(?:"(?:[^"\n\r\\]|(?:"")|(?:\\.))*")|(?:'(?:[^'\n\r\\]|(?:'')|(?:\\.))*')''').setName("quotedString using single or double quotes")+ −
+ −
+ −
+ −
anyOpenTag,anyCloseTag = makeHTMLTags(Word(alphas,alphanums+"_"))+ −
+ −
commonHTMLEntity = Combine("&" + oneOf("gt lt amp nbsp quot").setResultsName("entity") +";")+ −
+ −
_htmlEntityMap = dict(zip("gt lt amp nbsp quot".split(),"><& '"))+ −
+ −
replaceHTMLEntity = lambda t : t.entity in _htmlEntityMap and _htmlEntityMap[t.entity] or None+ −
+ −
+ −
+ −
# it's easy to get these comment structures wrong - they're very common, so may as well make them available+ −
+ −
cStyleComment = Regex(r"/\*(?:[^*]*\*+)+?/").setName("C style comment")+ −
+ −
+ −
+ −
htmlComment = Regex(r"<!--[\s\S]*?-->")+ −
+ −
restOfLine = Regex(r".*").leaveWhitespace()+ −
+ −
dblSlashComment = Regex(r"\/\/(\\\n|.)*").setName("// comment")+ −
+ −
cppStyleComment = Regex(r"/(?:\*(?:[^*]*\*+)+?/|/[^\n]*(?:\n[^\n]*)*?(?:(?<!\\)|\Z))").setName("C++ style comment")+ −
+ −
+ −
+ −
javaStyleComment = cppStyleComment+ −
+ −
pythonStyleComment = Regex(r"#.*").setName("Python style comment")+ −
+ −
_noncomma = "".join( [ c for c in printables if c != "," ] )+ −
+ −
_commasepitem = Combine(OneOrMore(Word(_noncomma) + + −
+ −
Optional( Word(" \t") + + −
+ −
~Literal(",") + ~LineEnd() ) ) ).streamline().setName("commaItem")+ −
+ −
commaSeparatedList = delimitedList( Optional( quotedString | _commasepitem, default="") ).setName("commaSeparatedList")+ −
+ −
+ −
+ −
+ −
+ −
if __name__ == "__main__":+ −
+ −
+ −
+ −
def test( teststring ):+ −
+ −
print teststring,"->",+ −
+ −
try:+ −
+ −
tokens = simpleSQL.parseString( teststring )+ −
+ −
tokenlist = tokens.asList()+ −
+ −
print tokenlist+ −
+ −
print "tokens = ", tokens+ −
+ −
print "tokens.columns =", tokens.columns+ −
+ −
print "tokens.tables =", tokens.tables+ −
+ −
print tokens.asXML("SQL",True)+ −
+ −
except ParseException, err:+ −
+ −
print err.line+ −
+ −
print " "*(err.column-1) + "^"+ −
+ −
print err+ −
+ −
print+ −
+ −
+ −
+ −
selectToken = CaselessLiteral( "select" )+ −
+ −
fromToken = CaselessLiteral( "from" )+ −
+ −
+ −
+ −
ident = Word( alphas, alphanums + "_$" )+ −
+ −
columnName = delimitedList( ident, ".", combine=True ).setParseAction( upcaseTokens )+ −
+ −
columnNameList = Group( delimitedList( columnName ) )#.setName("columns")+ −
+ −
tableName = delimitedList( ident, ".", combine=True ).setParseAction( upcaseTokens )+ −
+ −
tableNameList = Group( delimitedList( tableName ) )#.setName("tables")+ −
+ −
simpleSQL = ( selectToken + \+ −
+ −
( '*' | columnNameList ).setResultsName( "columns" ) + \+ −
+ −
fromToken + \+ −
+ −
tableNameList.setResultsName( "tables" ) )+ −
+ −
+ −
+ −
test( "SELECT * from XYZZY, ABC" )+ −
+ −
test( "select * from SYS.XYZZY" )+ −
+ −
test( "Select A from Sys.dual" )+ −
+ −
test( "Select AA,BB,CC from Sys.dual" )+ −
+ −
test( "Select A, B, C from Sys.dual" )+ −
+ −
test( "Select A, B, C from Sys.dual" )+ −
+ −
test( "Xelect A, B, C from Sys.dual" )+ −
+ −
test( "Select A, B, C frox Sys.dual" )+ −
+ −
test( "Select" )+ −
+ −
test( "Select ^^^ frox Sys.dual" )+ −
+ −
test( "Select A, B, C from Sys.dual, Table2 " )+ −
+ −