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