|
|
# -*- coding: utf-8 -*-
|
|
|
# module pyparsing.py
|
|
|
#
|
|
|
# Copyright (c) 2003-2009 Paul T. McGuire
|
|
|
#
|
|
|
# Permission is hereby granted, free of charge, to any person obtaining
|
|
|
# a copy of this software and associated documentation files (the
|
|
|
# "Software"), to deal in the Software without restriction, including
|
|
|
# without limitation the rights to use, copy, modify, merge, publish,
|
|
|
# distribute, sublicense, and/or sell copies of the Software, and to
|
|
|
# permit persons to whom the Software is furnished to do so, subject to
|
|
|
# the following conditions:
|
|
|
#
|
|
|
# The above copyright notice and this permission notice shall be
|
|
|
# included in all copies or substantial portions of the Software.
|
|
|
#
|
|
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
|
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
|
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
|
# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
|
|
# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
|
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
|
|
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
#
|
|
|
#from __future__ import generators
|
|
|
|
|
|
__doc__ = \
|
|
|
"""
|
|
|
pyparsing module - Classes and methods to define and execute parsing grammars
|
|
|
|
|
|
The pyparsing module is an alternative approach to creating and executing simple grammars,
|
|
|
vs. the traditional lex/yacc approach, or the use of regular expressions. With pyparsing, you
|
|
|
don't need to learn a new syntax for defining grammars or matching expressions - the parsing module
|
|
|
provides a library of classes that you use to construct the grammar directly in Python.
|
|
|
|
|
|
Here is a program to parse "Hello, World!" (or any greeting of the form "<salutation>, <addressee>!")::
|
|
|
|
|
|
from pyparsing import Word, alphas
|
|
|
|
|
|
# define grammar of a greeting
|
|
|
greet = Word( alphas ) + "," + Word( alphas ) + "!"
|
|
|
|
|
|
hello = "Hello, World!"
|
|
|
print hello, "->", greet.parseString( hello )
|
|
|
|
|
|
The program outputs the following::
|
|
|
|
|
|
Hello, World! -> ['Hello', ',', 'World', '!']
|
|
|
|
|
|
The Python representation of the grammar is quite readable, owing to the self-explanatory
|
|
|
class names, and the use of '+', '|' and '^' operators.
|
|
|
|
|
|
The parsed results returned from parseString() can be accessed as a nested list, a dictionary, or an
|
|
|
object with named attributes.
|
|
|
|
|
|
The pyparsing module handles some of the problems that are typically vexing when writing text parsers:
|
|
|
- extra or missing whitespace (the above program will also handle "Hello,World!", "Hello , World !", etc.)
|
|
|
- quoted strings
|
|
|
- embedded comments
|
|
|
"""
|
|
|
|
|
|
__version__ = "1.5.2"
|
|
|
__versionTime__ = "17 February 2009 19:45"
|
|
|
__author__ = "Paul McGuire <ptmcg@users.sourceforge.net>"
|
|
|
|
|
|
import string
|
|
|
from weakref import ref as wkref
|
|
|
import copy
|
|
|
import sys
|
|
|
import warnings
|
|
|
import re
|
|
|
import sre_constants
|
|
|
#~ sys.stderr.write( "testing pyparsing module, version %s, %s\n" % (__version__,__versionTime__ ) )
|
|
|
|
|
|
__all__ = [
|
|
|
'And', 'CaselessKeyword', 'CaselessLiteral', 'CharsNotIn', 'Combine', 'Dict', 'Each', 'Empty',
|
|
|
'FollowedBy', 'Forward', 'GoToColumn', 'Group', 'Keyword', 'LineEnd', 'LineStart', 'Literal',
|
|
|
'MatchFirst', 'NoMatch', 'NotAny', 'OneOrMore', 'OnlyOnce', 'Optional', 'Or',
|
|
|
'ParseBaseException', 'ParseElementEnhance', 'ParseException', 'ParseExpression', 'ParseFatalException',
|
|
|
'ParseResults', 'ParseSyntaxException', 'ParserElement', 'QuotedString', 'RecursiveGrammarException',
|
|
|
'Regex', 'SkipTo', 'StringEnd', 'StringStart', 'Suppress', 'Token', 'TokenConverter', 'Upcase',
|
|
|
'White', 'Word', 'WordEnd', 'WordStart', 'ZeroOrMore',
|
|
|
'alphanums', 'alphas', 'alphas8bit', 'anyCloseTag', 'anyOpenTag', 'cStyleComment', 'col',
|
|
|
'commaSeparatedList', 'commonHTMLEntity', 'countedArray', 'cppStyleComment', 'dblQuotedString',
|
|
|
'dblSlashComment', 'delimitedList', 'dictOf', 'downcaseTokens', 'empty', 'getTokensEndLoc', 'hexnums',
|
|
|
'htmlComment', 'javaStyleComment', 'keepOriginalText', 'line', 'lineEnd', 'lineStart', 'lineno',
|
|
|
'makeHTMLTags', 'makeXMLTags', 'matchOnlyAtCol', 'matchPreviousExpr', 'matchPreviousLiteral',
|
|
|
'nestedExpr', 'nullDebugAction', 'nums', 'oneOf', 'opAssoc', 'operatorPrecedence', 'printables',
|
|
|
'punc8bit', 'pythonStyleComment', 'quotedString', 'removeQuotes', 'replaceHTMLEntity',
|
|
|
'replaceWith', 'restOfLine', 'sglQuotedString', 'srange', 'stringEnd',
|
|
|
'stringStart', 'traceParseAction', 'unicodeString', 'upcaseTokens', 'withAttribute',
|
|
|
'indentedBlock', 'originalTextFor',
|
|
|
]
|
|
|
|
|
|
|
|
|
"""
|
|
|
Detect if we are running version 3.X and make appropriate changes
|
|
|
Robert A. Clark
|
|
|
"""
|
|
|
if sys.version_info[0] > 2:
|
|
|
_PY3K = True
|
|
|
_MAX_INT = sys.maxsize
|
|
|
basestring = str
|
|
|
else:
|
|
|
_PY3K = False
|
|
|
_MAX_INT = sys.maxint
|
|
|
|
|
|
if not _PY3K:
|
|
|
def _ustr(obj):
|
|
|
"""Drop-in replacement for str(obj) that tries to be Unicode friendly. It first tries
|
|
|
str(obj). If that fails with a UnicodeEncodeError, then it tries unicode(obj). It
|
|
|
then < returns the unicode object | encodes it with the default encoding | ... >.
|
|
|
"""
|
|
|
if isinstance(obj,unicode):
|
|
|
return obj
|
|
|
|
|
|
try:
|
|
|
# If this works, then _ustr(obj) has the same behaviour as str(obj), so
|
|
|
# it won't break any existing code.
|
|
|
return str(obj)
|
|
|
|
|
|
except UnicodeEncodeError:
|
|
|
# The Python docs (http://docs.python.org/ref/customization.html#l2h-182)
|
|
|
# state that "The return value must be a string object". However, does a
|
|
|
# unicode object (being a subclass of basestring) count as a "string
|
|
|
# object"?
|
|
|
# If so, then return a unicode object:
|
|
|
return unicode(obj)
|
|
|
# Else encode it... but how? There are many choices... :)
|
|
|
# Replace unprintables with escape codes?
|
|
|
#return unicode(obj).encode(py3compat.getdefaultencoding(), 'backslashreplace_errors')
|
|
|
# Replace unprintables with question marks?
|
|
|
#return unicode(obj).encode(py3compat.getdefaultencoding(), 'replace')
|
|
|
# ...
|
|
|
else:
|
|
|
_ustr = str
|
|
|
unichr = chr
|
|
|
|
|
|
if not _PY3K:
|
|
|
def _str2dict(strg):
|
|
|
return dict( [(c,0) for c in strg] )
|
|
|
else:
|
|
|
_str2dict = set
|
|
|
|
|
|
def _xml_escape(data):
|
|
|
"""Escape &, <, >, ", ', etc. in a string of data."""
|
|
|
|
|
|
# ampersand must be replaced first
|
|
|
from_symbols = '&><"\''
|
|
|
to_symbols = ['&'+s+';' for s in "amp gt lt quot apos".split()]
|
|
|
for from_,to_ in zip(from_symbols, to_symbols):
|
|
|
data = data.replace(from_, to_)
|
|
|
return data
|
|
|
|
|
|
class _Constants(object):
|
|
|
pass
|
|
|
|
|
|
if not _PY3K:
|
|
|
alphas = string.lowercase + string.uppercase
|
|
|
else:
|
|
|
alphas = string.ascii_lowercase + string.ascii_uppercase
|
|
|
nums = string.digits
|
|
|
hexnums = nums + "ABCDEFabcdef"
|
|
|
alphanums = alphas + nums
|
|
|
_bslash = chr(92)
|
|
|
printables = "".join( [ c for c in string.printable if c not in string.whitespace ] )
|
|
|
|
|
|
class ParseBaseException(Exception):
|
|
|
"""base exception class for all parsing runtime exceptions"""
|
|
|
# Performance tuning: we construct a *lot* of these, so keep this
|
|
|
# constructor as small and fast as possible
|
|
|
def __init__( self, pstr, loc=0, msg=None, elem=None ):
|
|
|
self.loc = loc
|
|
|
if msg is None:
|
|
|
self.msg = pstr
|
|
|
self.pstr = ""
|
|
|
else:
|
|
|
self.msg = msg
|
|
|
self.pstr = pstr
|
|
|
self.parserElement = elem
|
|
|
|
|
|
def __getattr__( self, aname ):
|
|
|
"""supported attributes by name are:
|
|
|
- lineno - returns the line number of the exception text
|
|
|
- col - returns the column number of the exception text
|
|
|
- line - returns the line containing the exception text
|
|
|
"""
|
|
|
if( aname == "lineno" ):
|
|
|
return lineno( self.loc, self.pstr )
|
|
|
elif( aname in ("col", "column") ):
|
|
|
return col( self.loc, self.pstr )
|
|
|
elif( aname == "line" ):
|
|
|
return line( self.loc, self.pstr )
|
|
|
else:
|
|
|
raise AttributeError(aname)
|
|
|
|
|
|
def __str__( self ):
|
|
|
return "%s (at char %d), (line:%d, col:%d)" % \
|
|
|
( self.msg, self.loc, self.lineno, self.column )
|
|
|
def __repr__( self ):
|
|
|
return _ustr(self)
|
|
|
def markInputline( self, markerString = ">!<" ):
|
|
|
"""Extracts the exception line from the input string, and marks
|
|
|
the location of the exception with a special symbol.
|
|
|
"""
|
|
|
line_str = self.line
|
|
|
line_column = self.column - 1
|
|
|
if markerString:
|
|
|
line_str = "".join( [line_str[:line_column],
|
|
|
markerString, line_str[line_column:]])
|
|
|
return line_str.strip()
|
|
|
def __dir__(self):
|
|
|
return "loc msg pstr parserElement lineno col line " \
|
|
|
"markInputLine __str__ __repr__".split()
|
|
|
|
|
|
class ParseException(ParseBaseException):
|
|
|
"""exception thrown when parse expressions don't match class;
|
|
|
supported attributes by name are:
|
|
|
- lineno - returns the line number of the exception text
|
|
|
- col - returns the column number of the exception text
|
|
|
- line - returns the line containing the exception text
|
|
|
"""
|
|
|
pass
|
|
|
|
|
|
class ParseFatalException(ParseBaseException):
|
|
|
"""user-throwable exception thrown when inconsistent parse content
|
|
|
is found; stops all parsing immediately"""
|
|
|
pass
|
|
|
|
|
|
class ParseSyntaxException(ParseFatalException):
|
|
|
"""just like ParseFatalException, but thrown internally when an
|
|
|
ErrorStop indicates that parsing is to stop immediately because
|
|
|
an unbacktrackable syntax error has been found"""
|
|
|
def __init__(self, pe):
|
|
|
super(ParseSyntaxException, self).__init__(
|
|
|
pe.pstr, pe.loc, pe.msg, pe.parserElement)
|
|
|
|
|
|
#~ class ReparseException(ParseBaseException):
|
|
|
#~ """Experimental class - parse actions can raise this exception to cause
|
|
|
#~ pyparsing to reparse the input string:
|
|
|
#~ - with a modified input string, and/or
|
|
|
#~ - with a modified start location
|
|
|
#~ Set the values of the ReparseException in the constructor, and raise the
|
|
|
#~ exception in a parse action to cause pyparsing to use the new string/location.
|
|
|
#~ Setting the values as None causes no change to be made.
|
|
|
#~ """
|
|
|
#~ def __init_( self, newstring, restartLoc ):
|
|
|
#~ self.newParseText = newstring
|
|
|
#~ self.reparseLoc = restartLoc
|
|
|
|
|
|
class RecursiveGrammarException(Exception):
|
|
|
"""exception thrown by validate() if the grammar could be improperly recursive"""
|
|
|
def __init__( self, parseElementList ):
|
|
|
self.parseElementTrace = parseElementList
|
|
|
|
|
|
def __str__( self ):
|
|
|
return "RecursiveGrammarException: %s" % self.parseElementTrace
|
|
|
|
|
|
class _ParseResultsWithOffset(object):
|
|
|
def __init__(self,p1,p2):
|
|
|
self.tup = (p1,p2)
|
|
|
def __getitem__(self,i):
|
|
|
return self.tup[i]
|
|
|
def __repr__(self):
|
|
|
return repr(self.tup)
|
|
|
def setOffset(self,i):
|
|
|
self.tup = (self.tup[0],i)
|
|
|
|
|
|
class ParseResults(object):
|
|
|
"""Structured parse results, to provide multiple means of access to the parsed data:
|
|
|
- as a list (len(results))
|
|
|
- by list index (results[0], results[1], etc.)
|
|
|
- by attribute (results.<resultsName>)
|
|
|
"""
|
|
|
__slots__ = ( "__toklist", "__tokdict", "__doinit", "__name", "__parent", "__accumNames", "__weakref__" )
|
|
|
def __new__(cls, toklist, name=None, asList=True, modal=True ):
|
|
|
if isinstance(toklist, cls):
|
|
|
return toklist
|
|
|
retobj = object.__new__(cls)
|
|
|
retobj.__doinit = True
|
|
|
return retobj
|
|
|
|
|
|
# Performance tuning: we construct a *lot* of these, so keep this
|
|
|
# constructor as small and fast as possible
|
|
|
def __init__( self, toklist, name=None, asList=True, modal=True ):
|
|
|
if self.__doinit:
|
|
|
self.__doinit = False
|
|
|
self.__name = None
|
|
|
self.__parent = None
|
|
|
self.__accumNames = {}
|
|
|
if isinstance(toklist, list):
|
|
|
self.__toklist = toklist[:]
|
|
|
else:
|
|
|
self.__toklist = [toklist]
|
|
|
self.__tokdict = dict()
|
|
|
|
|
|
if name:
|
|
|
if not modal:
|
|
|
self.__accumNames[name] = 0
|
|
|
if isinstance(name,int):
|
|
|
name = _ustr(name) # will always return a str, but use _ustr for consistency
|
|
|
self.__name = name
|
|
|
if not toklist in (None,'',[]):
|
|
|
if isinstance(toklist,basestring):
|
|
|
toklist = [ toklist ]
|
|
|
if asList:
|
|
|
if isinstance(toklist,ParseResults):
|
|
|
self[name] = _ParseResultsWithOffset(toklist.copy(),0)
|
|
|
else:
|
|
|
self[name] = _ParseResultsWithOffset(ParseResults(toklist[0]),0)
|
|
|
self[name].__name = name
|
|
|
else:
|
|
|
try:
|
|
|
self[name] = toklist[0]
|
|
|
except (KeyError,TypeError,IndexError):
|
|
|
self[name] = toklist
|
|
|
|
|
|
def __getitem__( self, i ):
|
|
|
if isinstance( i, (int,slice) ):
|
|
|
return self.__toklist[i]
|
|
|
else:
|
|
|
if i not in self.__accumNames:
|
|
|
return self.__tokdict[i][-1][0]
|
|
|
else:
|
|
|
return ParseResults([ v[0] for v in self.__tokdict[i] ])
|
|
|
|
|
|
def __setitem__( self, k, v ):
|
|
|
if isinstance(v,_ParseResultsWithOffset):
|
|
|
self.__tokdict[k] = self.__tokdict.get(k,list()) + [v]
|
|
|
sub = v[0]
|
|
|
elif isinstance(k,int):
|
|
|
self.__toklist[k] = v
|
|
|
sub = v
|
|
|
else:
|
|
|
self.__tokdict[k] = self.__tokdict.get(k,list()) + [_ParseResultsWithOffset(v,0)]
|
|
|
sub = v
|
|
|
if isinstance(sub,ParseResults):
|
|
|
sub.__parent = wkref(self)
|
|
|
|
|
|
def __delitem__( self, i ):
|
|
|
if isinstance(i,(int,slice)):
|
|
|
mylen = len( self.__toklist )
|
|
|
del self.__toklist[i]
|
|
|
|
|
|
# convert int to slice
|
|
|
if isinstance(i, int):
|
|
|
if i < 0:
|
|
|
i += mylen
|
|
|
i = slice(i, i+1)
|
|
|
# get removed indices
|
|
|
removed = list(range(*i.indices(mylen)))
|
|
|
removed.reverse()
|
|
|
# fixup indices in token dictionary
|
|
|
for name in self.__tokdict:
|
|
|
occurrences = self.__tokdict[name]
|
|
|
for j in removed:
|
|
|
for k, (value, position) in enumerate(occurrences):
|
|
|
occurrences[k] = _ParseResultsWithOffset(value, position - (position > j))
|
|
|
else:
|
|
|
del self.__tokdict[i]
|
|
|
|
|
|
def __contains__( self, k ):
|
|
|
return k in self.__tokdict
|
|
|
|
|
|
def __len__( self ): return len( self.__toklist )
|
|
|
def __bool__(self): return len( self.__toklist ) > 0
|
|
|
__nonzero__ = __bool__
|
|
|
def __iter__( self ): return iter( self.__toklist )
|
|
|
def __reversed__( self ): return iter( reversed(self.__toklist) )
|
|
|
def keys( self ):
|
|
|
"""Returns all named result keys."""
|
|
|
return self.__tokdict.keys()
|
|
|
|
|
|
def pop( self, index=-1 ):
|
|
|
"""Removes and returns item at specified index (default=last).
|
|
|
Will work with either numeric indices or dict-key indicies."""
|
|
|
ret = self[index]
|
|
|
del self[index]
|
|
|
return ret
|
|
|
|
|
|
def get(self, key, defaultValue=None):
|
|
|
"""Returns named result matching the given key, or if there is no
|
|
|
such name, then returns the given defaultValue or None if no
|
|
|
defaultValue is specified."""
|
|
|
if key in self:
|
|
|
return self[key]
|
|
|
else:
|
|
|
return defaultValue
|
|
|
|
|
|
def insert( self, index, insStr ):
|
|
|
self.__toklist.insert(index, insStr)
|
|
|
# fixup indices in token dictionary
|
|
|
for name in self.__tokdict:
|
|
|
occurrences = self.__tokdict[name]
|
|
|
for k, (value, position) in enumerate(occurrences):
|
|
|
occurrences[k] = _ParseResultsWithOffset(value, position + (position > index))
|
|
|
|
|
|
def items( self ):
|
|
|
"""Returns all named result keys and values as a list of tuples."""
|
|
|
return [(k,self[k]) for k in self.__tokdict]
|
|
|
|
|
|
def values( self ):
|
|
|
"""Returns all named result values."""
|
|
|
return [ v[-1][0] for v in self.__tokdict.itervalues() ]
|
|
|
|
|
|
def __getattr__( self, name ):
|
|
|
if name not in self.__slots__:
|
|
|
if name in self.__tokdict:
|
|
|
if name not in self.__accumNames:
|
|
|
return self.__tokdict[name][-1][0]
|
|
|
else:
|
|
|
return ParseResults([ v[0] for v in self.__tokdict[name] ])
|
|
|
else:
|
|
|
return ""
|
|
|
return None
|
|
|
|
|
|
def __add__( self, other ):
|
|
|
ret = self.copy()
|
|
|
ret += other
|
|
|
return ret
|
|
|
|
|
|
def __iadd__( self, other ):
|
|
|
if other.__tokdict:
|
|
|
offset = len(self.__toklist)
|
|
|
addoffset = ( lambda a: (a<0 and offset) or (a+offset) )
|
|
|
otheritems = other.__tokdict.iteritems()
|
|
|
otherdictitems = [(k, _ParseResultsWithOffset(v[0],addoffset(v[1])) )
|
|
|
for (k,vlist) in otheritems for v in vlist]
|
|
|
for k,v in otherdictitems:
|
|
|
self[k] = v
|
|
|
if isinstance(v[0],ParseResults):
|
|
|
v[0].__parent = wkref(self)
|
|
|
|
|
|
self.__toklist += other.__toklist
|
|
|
self.__accumNames.update( other.__accumNames )
|
|
|
del other
|
|
|
return self
|
|
|
|
|
|
def __repr__( self ):
|
|
|
return "(%s, %s)" % ( repr( self.__toklist ), repr( self.__tokdict ) )
|
|
|
|
|
|
def __str__( self ):
|
|
|
out = "["
|
|
|
sep = ""
|
|
|
for i in self.__toklist:
|
|
|
if isinstance(i, ParseResults):
|
|
|
out += sep + _ustr(i)
|
|
|
else:
|
|
|
out += sep + repr(i)
|
|
|
sep = ", "
|
|
|
out += "]"
|
|
|
return out
|
|
|
|
|
|
def _asStringList( self, sep='' ):
|
|
|
out = []
|
|
|
for item in self.__toklist:
|
|
|
if out and sep:
|
|
|
out.append(sep)
|
|
|
if isinstance( item, ParseResults ):
|
|
|
out += item._asStringList()
|
|
|
else:
|
|
|
out.append( _ustr(item) )
|
|
|
return out
|
|
|
|
|
|
def asList( self ):
|
|
|
"""Returns the parse results as a nested list of matching tokens, all converted to strings."""
|
|
|
out = []
|
|
|
for res in self.__toklist:
|
|
|
if isinstance(res,ParseResults):
|
|
|
out.append( res.asList() )
|
|
|
else:
|
|
|
out.append( res )
|
|
|
return out
|
|
|
|
|
|
def asDict( self ):
|
|
|
"""Returns the named parse results as dictionary."""
|
|
|
return dict( self.items() )
|
|
|
|
|
|
def copy( self ):
|
|
|
"""Returns a new copy of a ParseResults object."""
|
|
|
ret = ParseResults( self.__toklist )
|
|
|
ret.__tokdict = self.__tokdict.copy()
|
|
|
ret.__parent = self.__parent
|
|
|
ret.__accumNames.update( self.__accumNames )
|
|
|
ret.__name = self.__name
|
|
|
return ret
|
|
|
|
|
|
def asXML( self, doctag=None, namedItemsOnly=False, indent="", formatted=True ):
|
|
|
"""Returns the parse results as XML. Tags are created for tokens and lists that have defined results names."""
|
|
|
nl = "\n"
|
|
|
out = []
|
|
|
namedItems = dict([(v[1],k) for (k,vlist) in self.__tokdict.iteritems()
|
|
|
for v in vlist ] )
|
|
|
nextLevelIndent = indent + " "
|
|
|
|
|
|
# collapse out indents if formatting is not desired
|
|
|
if not formatted:
|
|
|
indent = ""
|
|
|
nextLevelIndent = ""
|
|
|
nl = ""
|
|
|
|
|
|
selfTag = None
|
|
|
if doctag is not None:
|
|
|
selfTag = doctag
|
|
|
else:
|
|
|
if self.__name:
|
|
|
selfTag = self.__name
|
|
|
|
|
|
if not selfTag:
|
|
|
if namedItemsOnly:
|
|
|
return ""
|
|
|
else:
|
|
|
selfTag = "ITEM"
|
|
|
|
|
|
out += [ nl, indent, "<", selfTag, ">" ]
|
|
|
|
|
|
worklist = self.__toklist
|
|
|
for i,res in enumerate(worklist):
|
|
|
if isinstance(res,ParseResults):
|
|
|
if i in namedItems:
|
|
|
out += [ res.asXML(namedItems[i],
|
|
|
namedItemsOnly and doctag is None,
|
|
|
nextLevelIndent,
|
|
|
formatted)]
|
|
|
else:
|
|
|
out += [ res.asXML(None,
|
|
|
namedItemsOnly and doctag is None,
|
|
|
nextLevelIndent,
|
|
|
formatted)]
|
|
|
else:
|
|
|
# individual token, see if there is a name for it
|
|
|
resTag = None
|
|
|
if i in namedItems:
|
|
|
resTag = namedItems[i]
|
|
|
if not resTag:
|
|
|
if namedItemsOnly:
|
|
|
continue
|
|
|
else:
|
|
|
resTag = "ITEM"
|
|
|
xmlBodyText = _xml_escape(_ustr(res))
|
|
|
out += [ nl, nextLevelIndent, "<", resTag, ">",
|
|
|
xmlBodyText,
|
|
|
"</", resTag, ">" ]
|
|
|
|
|
|
out += [ nl, indent, "</", selfTag, ">" ]
|
|
|
return "".join(out)
|
|
|
|
|
|
def __lookup(self,sub):
|
|
|
for k,vlist in self.__tokdict.iteritems():
|
|
|
for v,loc in vlist:
|
|
|
if sub is v:
|
|
|
return k
|
|
|
return None
|
|
|
|
|
|
def getName(self):
|
|
|
"""Returns the results name for this token expression."""
|
|
|
if self.__name:
|
|
|
return self.__name
|
|
|
elif self.__parent:
|
|
|
par = self.__parent()
|
|
|
if par:
|
|
|
return par.__lookup(self)
|
|
|
else:
|
|
|
return None
|
|
|
elif (len(self) == 1 and
|
|
|
len(self.__tokdict) == 1 and
|
|
|
self.__tokdict.values()[0][0][1] in (0,-1)):
|
|
|
return self.__tokdict.keys()[0]
|
|
|
else:
|
|
|
return None
|
|
|
|
|
|
def dump(self,indent='',depth=0):
|
|
|
"""Diagnostic method for listing out the contents of a ParseResults.
|
|
|
Accepts an optional indent argument so that this string can be embedded
|
|
|
in a nested display of other data."""
|
|
|
out = []
|
|
|
out.append( indent+_ustr(self.asList()) )
|
|
|
keys = self.items()
|
|
|
keys.sort()
|
|
|
for k,v in keys:
|
|
|
if out:
|
|
|
out.append('\n')
|
|
|
out.append( "%s%s- %s: " % (indent,(' '*depth), k) )
|
|
|
if isinstance(v,ParseResults):
|
|
|
if v.keys():
|
|
|
#~ out.append('\n')
|
|
|
out.append( v.dump(indent,depth+1) )
|
|
|
#~ out.append('\n')
|
|
|
else:
|
|
|
out.append(_ustr(v))
|
|
|
else:
|
|
|
out.append(_ustr(v))
|
|
|
#~ out.append('\n')
|
|
|
return "".join(out)
|
|
|
|
|
|
# add support for pickle protocol
|
|
|
def __getstate__(self):
|
|
|
return ( self.__toklist,
|
|
|
( self.__tokdict.copy(),
|
|
|
self.__parent is not None and self.__parent() or None,
|
|
|
self.__accumNames,
|
|
|
self.__name ) )
|
|
|
|
|
|
def __setstate__(self,state):
|
|
|
self.__toklist = state[0]
|
|
|
self.__tokdict, \
|
|
|
par, \
|
|
|
inAccumNames, \
|
|
|
self.__name = state[1]
|
|
|
self.__accumNames = {}
|
|
|
self.__accumNames.update(inAccumNames)
|
|
|
if par is not None:
|
|
|
self.__parent = wkref(par)
|
|
|
else:
|
|
|
self.__parent = None
|
|
|
|
|
|
def __dir__(self):
|
|
|
return dir(super(ParseResults,self)) + self.keys()
|
|
|
|
|
|
def col (loc,strg):
|
|
|
"""Returns current column within a string, counting newlines as line separators.
|
|
|
The first column is number 1.
|
|
|
|
|
|
Note: the default parsing behavior is to expand tabs in the input string
|
|
|
before starting the parsing process. See L{I{ParserElement.parseString}<ParserElement.parseString>} for more information
|
|
|
on parsing strings containing <TAB>s, and suggested methods to maintain a
|
|
|
consistent view of the parsed string, the parse location, and line and column
|
|
|
positions within the parsed string.
|
|
|
"""
|
|
|
return (loc<len(strg) and strg[loc] == '\n') and 1 or loc - strg.rfind("\n", 0, loc)
|
|
|
|
|
|
def lineno(loc,strg):
|
|
|
"""Returns current line number within a string, counting newlines as line separators.
|
|
|
The first line is number 1.
|
|
|
|
|
|
Note: the default parsing behavior is to expand tabs in the input string
|
|
|
before starting the parsing process. See L{I{ParserElement.parseString}<ParserElement.parseString>} for more information
|
|
|
on parsing strings containing <TAB>s, and suggested methods to maintain a
|
|
|
consistent view of the parsed string, the parse location, and line and column
|
|
|
positions within the parsed string.
|
|
|
"""
|
|
|
return strg.count("\n",0,loc) + 1
|
|
|
|
|
|
def line( loc, strg ):
|
|
|
"""Returns the line of text containing loc within a string, counting newlines as line separators.
|
|
|
"""
|
|
|
lastCR = strg.rfind("\n", 0, loc)
|
|
|
nextCR = strg.find("\n", loc)
|
|
|
if nextCR > 0:
|
|
|
return strg[lastCR+1:nextCR]
|
|
|
else:
|
|
|
return strg[lastCR+1:]
|
|
|
|
|
|
def _defaultStartDebugAction( instring, loc, expr ):
|
|
|
print ("Match " + _ustr(expr) + " at loc " + _ustr(loc) + "(%d,%d)" % ( lineno(loc,instring), col(loc,instring) ))
|
|
|
|
|
|
def _defaultSuccessDebugAction( instring, startloc, endloc, expr, toks ):
|
|
|
print ("Matched " + _ustr(expr) + " -> " + str(toks.asList()))
|
|
|
|
|
|
def _defaultExceptionDebugAction( instring, loc, expr, exc ):
|
|
|
print ("Exception raised:" + _ustr(exc))
|
|
|
|
|
|
def nullDebugAction(*args):
|
|
|
"""'Do-nothing' debug action, to suppress debugging output during parsing."""
|
|
|
pass
|
|
|
|
|
|
class ParserElement(object):
|
|
|
"""Abstract base level parser element class."""
|
|
|
DEFAULT_WHITE_CHARS = " \n\t\r"
|
|
|
|
|
|
def setDefaultWhitespaceChars( chars ):
|
|
|
"""Overrides the default whitespace chars
|
|
|
"""
|
|
|
ParserElement.DEFAULT_WHITE_CHARS = chars
|
|
|
setDefaultWhitespaceChars = staticmethod(setDefaultWhitespaceChars)
|
|
|
|
|
|
def __init__( self, savelist=False ):
|
|
|
self.parseAction = list()
|
|
|
self.failAction = None
|
|
|
#~ self.name = "<unknown>" # don't define self.name, let subclasses try/except upcall
|
|
|
self.strRepr = None
|
|
|
self.resultsName = None
|
|
|
self.saveAsList = savelist
|
|
|
self.skipWhitespace = True
|
|
|
self.whiteChars = ParserElement.DEFAULT_WHITE_CHARS
|
|
|
self.copyDefaultWhiteChars = True
|
|
|
self.mayReturnEmpty = False # used when checking for left-recursion
|
|
|
self.keepTabs = False
|
|
|
self.ignoreExprs = list()
|
|
|
self.debug = False
|
|
|
self.streamlined = False
|
|
|
self.mayIndexError = True # used to optimize exception handling for subclasses that don't advance parse index
|
|
|
self.errmsg = ""
|
|
|
self.modalResults = True # used to mark results names as modal (report only last) or cumulative (list all)
|
|
|
self.debugActions = ( None, None, None ) #custom debug actions
|
|
|
self.re = None
|
|
|
self.callPreparse = True # used to avoid redundant calls to preParse
|
|
|
self.callDuringTry = False
|
|
|
|
|
|
def copy( self ):
|
|
|
"""Make a copy of this ParserElement. Useful for defining different parse actions
|
|
|
for the same parsing pattern, using copies of the original parse element."""
|
|
|
cpy = copy.copy( self )
|
|
|
cpy.parseAction = self.parseAction[:]
|
|
|
cpy.ignoreExprs = self.ignoreExprs[:]
|
|
|
if self.copyDefaultWhiteChars:
|
|
|
cpy.whiteChars = ParserElement.DEFAULT_WHITE_CHARS
|
|
|
return cpy
|
|
|
|
|
|
def setName( self, name ):
|
|
|
"""Define name for this expression, for use in debugging."""
|
|
|
self.name = name
|
|
|
self.errmsg = "Expected " + self.name
|
|
|
if hasattr(self,"exception"):
|
|
|
self.exception.msg = self.errmsg
|
|
|
return self
|
|
|
|
|
|
def setResultsName( self, name, listAllMatches=False ):
|
|
|
"""Define name for referencing matching tokens as a nested attribute
|
|
|
of the returned parse results.
|
|
|
NOTE: this returns a *copy* of the original ParserElement object;
|
|
|
this is so that the client can define a basic element, such as an
|
|
|
integer, and reference it in multiple places with different names.
|
|
|
"""
|
|
|
newself = self.copy()
|
|
|
newself.resultsName = name
|
|
|
newself.modalResults = not listAllMatches
|
|
|
return newself
|
|
|
|
|
|
def setBreak(self,breakFlag = True):
|
|
|
"""Method to invoke the Python pdb debugger when this element is
|
|
|
about to be parsed. Set breakFlag to True to enable, False to
|
|
|
disable.
|
|
|
"""
|
|
|
if breakFlag:
|
|
|
_parseMethod = self._parse
|
|
|
def breaker(instring, loc, doActions=True, callPreParse=True):
|
|
|
import pdb
|
|
|
pdb.set_trace()
|
|
|
return _parseMethod( instring, loc, doActions, callPreParse )
|
|
|
breaker._originalParseMethod = _parseMethod
|
|
|
self._parse = breaker
|
|
|
else:
|
|
|
if hasattr(self._parse,"_originalParseMethod"):
|
|
|
self._parse = self._parse._originalParseMethod
|
|
|
return self
|
|
|
|
|
|
def _normalizeParseActionArgs( f ):
|
|
|
"""Internal method used to decorate parse actions that take fewer than 3 arguments,
|
|
|
so that all parse actions can be called as f(s,l,t)."""
|
|
|
STAR_ARGS = 4
|
|
|
|
|
|
try:
|
|
|
restore = None
|
|
|
if isinstance(f,type):
|
|
|
restore = f
|
|
|
f = f.__init__
|
|
|
if not _PY3K:
|
|
|
codeObj = f.func_code
|
|
|
else:
|
|
|
codeObj = f.code
|
|
|
if codeObj.co_flags & STAR_ARGS:
|
|
|
return f
|
|
|
numargs = codeObj.co_argcount
|
|
|
if not _PY3K:
|
|
|
if hasattr(f,"im_self"):
|
|
|
numargs -= 1
|
|
|
else:
|
|
|
if hasattr(f,"__self__"):
|
|
|
numargs -= 1
|
|
|
if restore:
|
|
|
f = restore
|
|
|
except AttributeError:
|
|
|
try:
|
|
|
if not _PY3K:
|
|
|
call_im_func_code = f.__call__.im_func.func_code
|
|
|
else:
|
|
|
call_im_func_code = f.__code__
|
|
|
|
|
|
# not a function, must be a callable object, get info from the
|
|
|
# im_func binding of its bound __call__ method
|
|
|
if call_im_func_code.co_flags & STAR_ARGS:
|
|
|
return f
|
|
|
numargs = call_im_func_code.co_argcount
|
|
|
if not _PY3K:
|
|
|
if hasattr(f.__call__,"im_self"):
|
|
|
numargs -= 1
|
|
|
else:
|
|
|
if hasattr(f.__call__,"__self__"):
|
|
|
numargs -= 0
|
|
|
except AttributeError:
|
|
|
if not _PY3K:
|
|
|
call_func_code = f.__call__.func_code
|
|
|
else:
|
|
|
call_func_code = f.__call__.__code__
|
|
|
# not a bound method, get info directly from __call__ method
|
|
|
if call_func_code.co_flags & STAR_ARGS:
|
|
|
return f
|
|
|
numargs = call_func_code.co_argcount
|
|
|
if not _PY3K:
|
|
|
if hasattr(f.__call__,"im_self"):
|
|
|
numargs -= 1
|
|
|
else:
|
|
|
if hasattr(f.__call__,"__self__"):
|
|
|
numargs -= 1
|
|
|
|
|
|
|
|
|
#~ print ("adding function %s with %d args" % (f.func_name,numargs))
|
|
|
if numargs == 3:
|
|
|
return f
|
|
|
else:
|
|
|
if numargs > 3:
|
|
|
def tmp(s,l,t):
|
|
|
return f(f.__call__.__self__, s,l,t)
|
|
|
if numargs == 2:
|
|
|
def tmp(s,l,t):
|
|
|
return f(l,t)
|
|
|
elif numargs == 1:
|
|
|
def tmp(s,l,t):
|
|
|
return f(t)
|
|
|
else: #~ numargs == 0:
|
|
|
def tmp(s,l,t):
|
|
|
return f()
|
|
|
try:
|
|
|
tmp.__name__ = f.__name__
|
|
|
except (AttributeError,TypeError):
|
|
|
# no need for special handling if attribute doesnt exist
|
|
|
pass
|
|
|
try:
|
|
|
tmp.__doc__ = f.__doc__
|
|
|
except (AttributeError,TypeError):
|
|
|
# no need for special handling if attribute doesnt exist
|
|
|
pass
|
|
|
try:
|
|
|
tmp.__dict__.update(f.__dict__)
|
|
|
except (AttributeError,TypeError):
|
|
|
# no need for special handling if attribute doesnt exist
|
|
|
pass
|
|
|
return tmp
|
|
|
_normalizeParseActionArgs = staticmethod(_normalizeParseActionArgs)
|
|
|
|
|
|
def setParseAction( self, *fns, **kwargs ):
|
|
|
"""Define action to perform when successfully matching parse element definition.
|
|
|
Parse action fn is a callable method with 0-3 arguments, called as fn(s,loc,toks),
|
|
|
fn(loc,toks), fn(toks), or just fn(), where:
|
|
|
- s = the original string being parsed (see note below)
|
|
|
- loc = the location of the matching substring
|
|
|
- toks = a list of the matched tokens, packaged as a ParseResults object
|
|
|
If the functions in fns modify the tokens, they can return them as the return
|
|
|
value from fn, and the modified list of tokens will replace the original.
|
|
|
Otherwise, fn does not need to return any value.
|
|
|
|
|
|
Note: the default parsing behavior is to expand tabs in the input string
|
|
|
before starting the parsing process. See L{I{parseString}<parseString>} for more information
|
|
|
on parsing strings containing <TAB>s, and suggested methods to maintain a
|
|
|
consistent view of the parsed string, the parse location, and line and column
|
|
|
positions within the parsed string.
|
|
|
"""
|
|
|
self.parseAction = list(map(self._normalizeParseActionArgs, list(fns)))
|
|
|
self.callDuringTry = ("callDuringTry" in kwargs and kwargs["callDuringTry"])
|
|
|
return self
|
|
|
|
|
|
def addParseAction( self, *fns, **kwargs ):
|
|
|
"""Add parse action to expression's list of parse actions. See L{I{setParseAction}<setParseAction>}."""
|
|
|
self.parseAction += list(map(self._normalizeParseActionArgs, list(fns)))
|
|
|
self.callDuringTry = self.callDuringTry or ("callDuringTry" in kwargs and kwargs["callDuringTry"])
|
|
|
return self
|
|
|
|
|
|
def setFailAction( self, fn ):
|
|
|
"""Define action to perform if parsing fails at this expression.
|
|
|
Fail acton fn is a callable function that takes the arguments
|
|
|
fn(s,loc,expr,err) where:
|
|
|
- s = string being parsed
|
|
|
- loc = location where expression match was attempted and failed
|
|
|
- expr = the parse expression that failed
|
|
|
- err = the exception thrown
|
|
|
The function returns no value. It may throw ParseFatalException
|
|
|
if it is desired to stop parsing immediately."""
|
|
|
self.failAction = fn
|
|
|
return self
|
|
|
|
|
|
def _skipIgnorables( self, instring, loc ):
|
|
|
exprsFound = True
|
|
|
while exprsFound:
|
|
|
exprsFound = False
|
|
|
for e in self.ignoreExprs:
|
|
|
try:
|
|
|
while 1:
|
|
|
loc,dummy = e._parse( instring, loc )
|
|
|
exprsFound = True
|
|
|
except ParseException:
|
|
|
pass
|
|
|
return loc
|
|
|
|
|
|
def preParse( self, instring, loc ):
|
|
|
if self.ignoreExprs:
|
|
|
loc = self._skipIgnorables( instring, loc )
|
|
|
|
|
|
if self.skipWhitespace:
|
|
|
wt = self.whiteChars
|
|
|
instrlen = len(instring)
|
|
|
while loc < instrlen and instring[loc] in wt:
|
|
|
loc += 1
|
|
|
|
|
|
return loc
|
|
|
|
|
|
def parseImpl( self, instring, loc, doActions=True ):
|
|
|
return loc, []
|
|
|
|
|
|
def postParse( self, instring, loc, tokenlist ):
|
|
|
return tokenlist
|
|
|
|
|
|
#~ @profile
|
|
|
def _parseNoCache( self, instring, loc, doActions=True, callPreParse=True ):
|
|
|
debugging = ( self.debug ) #and doActions )
|
|
|
|
|
|
if debugging or self.failAction:
|
|
|
#~ print ("Match",self,"at loc",loc,"(%d,%d)" % ( lineno(loc,instring), col(loc,instring) ))
|
|
|
if (self.debugActions[0] ):
|
|
|
self.debugActions[0]( instring, loc, self )
|
|
|
if callPreParse and self.callPreparse:
|
|
|
preloc = self.preParse( instring, loc )
|
|
|
else:
|
|
|
preloc = loc
|
|
|
tokensStart = loc
|
|
|
try:
|
|
|
try:
|
|
|
loc,tokens = self.parseImpl( instring, preloc, doActions )
|
|
|
except IndexError:
|
|
|
raise ParseException( instring, len(instring), self.errmsg, self )
|
|
|
except ParseBaseException, err:
|
|
|
#~ print ("Exception raised:", err)
|
|
|
if self.debugActions[2]:
|
|
|
self.debugActions[2]( instring, tokensStart, self, err )
|
|
|
if self.failAction:
|
|
|
self.failAction( instring, tokensStart, self, err )
|
|
|
raise
|
|
|
else:
|
|
|
if callPreParse and self.callPreparse:
|
|
|
preloc = self.preParse( instring, loc )
|
|
|
else:
|
|
|
preloc = loc
|
|
|
tokensStart = loc
|
|
|
if self.mayIndexError or loc >= len(instring):
|
|
|
try:
|
|
|
loc,tokens = self.parseImpl( instring, preloc, doActions )
|
|
|
except IndexError:
|
|
|
raise ParseException( instring, len(instring), self.errmsg, self )
|
|
|
else:
|
|
|
loc,tokens = self.parseImpl( instring, preloc, doActions )
|
|
|
|
|
|
tokens = self.postParse( instring, loc, tokens )
|
|
|
|
|
|
retTokens = ParseResults( tokens, self.resultsName, asList=self.saveAsList, modal=self.modalResults )
|
|
|
if self.parseAction and (doActions or self.callDuringTry):
|
|
|
if debugging:
|
|
|
try:
|
|
|
for fn in self.parseAction:
|
|
|
tokens = fn( instring, tokensStart, retTokens )
|
|
|
if tokens is not None:
|
|
|
retTokens = ParseResults( tokens,
|
|
|
self.resultsName,
|
|
|
asList=self.saveAsList and isinstance(tokens,(ParseResults,list)),
|
|
|
modal=self.modalResults )
|
|
|
except ParseBaseException, err:
|
|
|
#~ print "Exception raised in user parse action:", err
|
|
|
if (self.debugActions[2] ):
|
|
|
self.debugActions[2]( instring, tokensStart, self, err )
|
|
|
raise
|
|
|
else:
|
|
|
for fn in self.parseAction:
|
|
|
tokens = fn( instring, tokensStart, retTokens )
|
|
|
if tokens is not None:
|
|
|
retTokens = ParseResults( tokens,
|
|
|
self.resultsName,
|
|
|
asList=self.saveAsList and isinstance(tokens,(ParseResults,list)),
|
|
|
modal=self.modalResults )
|
|
|
|
|
|
if debugging:
|
|
|
#~ print ("Matched",self,"->",retTokens.asList())
|
|
|
if (self.debugActions[1] ):
|
|
|
self.debugActions[1]( instring, tokensStart, loc, self, retTokens )
|
|
|
|
|
|
return loc, retTokens
|
|
|
|
|
|
def tryParse( self, instring, loc ):
|
|
|
try:
|
|
|
return self._parse( instring, loc, doActions=False )[0]
|
|
|
except ParseFatalException:
|
|
|
raise ParseException( instring, loc, self.errmsg, self)
|
|
|
|
|
|
# this method gets repeatedly called during backtracking with the same arguments -
|
|
|
# we can cache these arguments and save ourselves the trouble of re-parsing the contained expression
|
|
|
def _parseCache( self, instring, loc, doActions=True, callPreParse=True ):
|
|
|
lookup = (self,instring,loc,callPreParse,doActions)
|
|
|
if lookup in ParserElement._exprArgCache:
|
|
|
value = ParserElement._exprArgCache[ lookup ]
|
|
|
if isinstance(value,Exception):
|
|
|
raise value
|
|
|
return value
|
|
|
else:
|
|
|
try:
|
|
|
value = self._parseNoCache( instring, loc, doActions, callPreParse )
|
|
|
ParserElement._exprArgCache[ lookup ] = (value[0],value[1].copy())
|
|
|
return value
|
|
|
except ParseBaseException, pe:
|
|
|
ParserElement._exprArgCache[ lookup ] = pe
|
|
|
raise
|
|
|
|
|
|
_parse = _parseNoCache
|
|
|
|
|
|
# argument cache for optimizing repeated calls when backtracking through recursive expressions
|
|
|
_exprArgCache = {}
|
|
|
def resetCache():
|
|
|
ParserElement._exprArgCache.clear()
|
|
|
resetCache = staticmethod(resetCache)
|
|
|
|
|
|
_packratEnabled = False
|
|
|
def enablePackrat():
|
|
|
"""Enables "packrat" parsing, which adds memoizing to the parsing logic.
|
|
|
Repeated parse attempts at the same string location (which happens
|
|
|
often in many complex grammars) can immediately return a cached value,
|
|
|
instead of re-executing parsing/validating code. Memoizing is done of
|
|
|
both valid results and parsing exceptions.
|
|
|
|
|
|
This speedup may break existing programs that use parse actions that
|
|
|
have side-effects. For this reason, packrat parsing is disabled when
|
|
|
you first import pyparsing. To activate the packrat feature, your
|
|
|
program must call the class method ParserElement.enablePackrat(). If
|
|
|
your program uses psyco to "compile as you go", you must call
|
|
|
enablePackrat before calling psyco.full(). If you do not do this,
|
|
|
Python will crash. For best results, call enablePackrat() immediately
|
|
|
after importing pyparsing.
|
|
|
"""
|
|
|
if not ParserElement._packratEnabled:
|
|
|
ParserElement._packratEnabled = True
|
|
|
ParserElement._parse = ParserElement._parseCache
|
|
|
enablePackrat = staticmethod(enablePackrat)
|
|
|
|
|
|
def parseString( self, instring, parseAll=False ):
|
|
|
"""Execute the parse expression with the given string.
|
|
|
This is the main interface to the client code, once the complete
|
|
|
expression has been built.
|
|
|
|
|
|
If you want the grammar to require that the entire input string be
|
|
|
successfully parsed, then set parseAll to True (equivalent to ending
|
|
|
the grammar with StringEnd()).
|
|
|
|
|
|
Note: parseString implicitly calls expandtabs() on the input string,
|
|
|
in order to report proper column numbers in parse actions.
|
|
|
If the input string contains tabs and
|
|
|
the grammar uses parse actions that use the loc argument to index into the
|
|
|
string being parsed, you can ensure you have a consistent view of the input
|
|
|
string by:
|
|
|
- calling parseWithTabs on your grammar before calling parseString
|
|
|
(see L{I{parseWithTabs}<parseWithTabs>})
|
|
|
- define your parse action using the full (s,loc,toks) signature, and
|
|
|
reference the input string using the parse action's s argument
|
|
|
- explictly expand the tabs in your input string before calling
|
|
|
parseString
|
|
|
"""
|
|
|
ParserElement.resetCache()
|
|
|
if not self.streamlined:
|
|
|
self.streamline()
|
|
|
#~ self.saveAsList = True
|
|
|
for e in self.ignoreExprs:
|
|
|
e.streamline()
|
|
|
if not self.keepTabs:
|
|
|
instring = instring.expandtabs()
|
|
|
try:
|
|
|
loc, tokens = self._parse( instring, 0 )
|
|
|
if parseAll:
|
|
|
loc = self.preParse( instring, loc )
|
|
|
StringEnd()._parse( instring, loc )
|
|
|
except ParseBaseException, exc:
|
|
|
# catch and re-raise exception from here, clears out pyparsing internal stack trace
|
|
|
raise exc
|
|
|
else:
|
|
|
return tokens
|
|
|
|
|
|
def scanString( self, instring, maxMatches=_MAX_INT ):
|
|
|
"""Scan the input string for expression matches. Each match will return the
|
|
|
matching tokens, start location, and end location. May be called with optional
|
|
|
maxMatches argument, to clip scanning after 'n' matches are found.
|
|
|
|
|
|
Note that the start and end locations are reported relative to the string
|
|
|
being parsed. See L{I{parseString}<parseString>} for more information on parsing
|
|
|
strings with embedded tabs."""
|
|
|
if not self.streamlined:
|
|
|
self.streamline()
|
|
|
for e in self.ignoreExprs:
|
|
|
e.streamline()
|
|
|
|
|
|
if not self.keepTabs:
|
|
|
instring = _ustr(instring).expandtabs()
|
|
|
instrlen = len(instring)
|
|
|
loc = 0
|
|
|
preparseFn = self.preParse
|
|
|
parseFn = self._parse
|
|
|
ParserElement.resetCache()
|
|
|
matches = 0
|
|
|
try:
|
|
|
while loc <= instrlen and matches < maxMatches:
|
|
|
try:
|
|
|
preloc = preparseFn( instring, loc )
|
|
|
nextLoc,tokens = parseFn( instring, preloc, callPreParse=False )
|
|
|
except ParseException:
|
|
|
loc = preloc+1
|
|
|
else:
|
|
|
matches += 1
|
|
|
yield tokens, preloc, nextLoc
|
|
|
loc = nextLoc
|
|
|
except ParseBaseException, pe:
|
|
|
raise pe
|
|
|
|
|
|
def transformString( self, instring ):
|
|
|
"""Extension to scanString, to modify matching text with modified tokens that may
|
|
|
be returned from a parse action. To use transformString, define a grammar and
|
|
|
attach a parse action to it that modifies the returned token list.
|
|
|
Invoking transformString() on a target string will then scan for matches,
|
|
|
and replace the matched text patterns according to the logic in the parse
|
|
|
action. transformString() returns the resulting transformed string."""
|
|
|
out = []
|
|
|
lastE = 0
|
|
|
# force preservation of <TAB>s, to minimize unwanted transformation of string, and to
|
|
|
# keep string locs straight between transformString and scanString
|
|
|
self.keepTabs = True
|
|
|
try:
|
|
|
for t,s,e in self.scanString( instring ):
|
|
|
out.append( instring[lastE:s] )
|
|
|
if t:
|
|
|
if isinstance(t,ParseResults):
|
|
|
out += t.asList()
|
|
|
elif isinstance(t,list):
|
|
|
out += t
|
|
|
else:
|
|
|
out.append(t)
|
|
|
lastE = e
|
|
|
out.append(instring[lastE:])
|
|
|
return "".join(map(_ustr,out))
|
|
|
except ParseBaseException, pe:
|
|
|
raise pe
|
|
|
|
|
|
def searchString( self, instring, maxMatches=_MAX_INT ):
|
|
|
"""Another extension to scanString, simplifying the access to the tokens found
|
|
|
to match the given parse expression. May be called with optional
|
|
|
maxMatches argument, to clip searching after 'n' matches are found.
|
|
|
"""
|
|
|
try:
|
|
|
return ParseResults([ t for t,s,e in self.scanString( instring, maxMatches ) ])
|
|
|
except ParseBaseException, pe:
|
|
|
raise pe
|
|
|
|
|
|
def __add__(self, other ):
|
|
|
"""Implementation of + operator - returns And"""
|
|
|
if isinstance( other, basestring ):
|
|
|
other = Literal( other )
|
|
|
if not isinstance( other, ParserElement ):
|
|
|
warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
|
|
|
SyntaxWarning, stacklevel=2)
|
|
|
return None
|
|
|
return And( [ self, other ] )
|
|
|
|
|
|
def __radd__(self, other ):
|
|
|
"""Implementation of + operator when left operand is not a ParserElement"""
|
|
|
if isinstance( other, basestring ):
|
|
|
other = Literal( other )
|
|
|
if not isinstance( other, ParserElement ):
|
|
|
warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
|
|
|
SyntaxWarning, stacklevel=2)
|
|
|
return None
|
|
|
return other + self
|
|
|
|
|
|
def __sub__(self, other):
|
|
|
"""Implementation of - operator, returns And with error stop"""
|
|
|
if isinstance( other, basestring ):
|
|
|
other = Literal( other )
|
|
|
if not isinstance( other, ParserElement ):
|
|
|
warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
|
|
|
SyntaxWarning, stacklevel=2)
|
|
|
return None
|
|
|
return And( [ self, And._ErrorStop(), other ] )
|
|
|
|
|
|
def __rsub__(self, other ):
|
|
|
"""Implementation of - operator when left operand is not a ParserElement"""
|
|
|
if isinstance( other, basestring ):
|
|
|
other = Literal( other )
|
|
|
if not isinstance( other, ParserElement ):
|
|
|
warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
|
|
|
SyntaxWarning, stacklevel=2)
|
|
|
return None
|
|
|
return other - self
|
|
|
|
|
|
def __mul__(self,other):
|
|
|
if isinstance(other,int):
|
|
|
minElements, optElements = other,0
|
|
|
elif isinstance(other,tuple):
|
|
|
other = (other + (None, None))[:2]
|
|
|
if other[0] is None:
|
|
|
other = (0, other[1])
|
|
|
if isinstance(other[0],int) and other[1] is None:
|
|
|
if other[0] == 0:
|
|
|
return ZeroOrMore(self)
|
|
|
if other[0] == 1:
|
|
|
return OneOrMore(self)
|
|
|
else:
|
|
|
return self*other[0] + ZeroOrMore(self)
|
|
|
elif isinstance(other[0],int) and isinstance(other[1],int):
|
|
|
minElements, optElements = other
|
|
|
optElements -= minElements
|
|
|
else:
|
|
|
raise TypeError("cannot multiply 'ParserElement' and ('%s','%s') objects", type(other[0]),type(other[1]))
|
|
|
else:
|
|
|
raise TypeError("cannot multiply 'ParserElement' and '%s' objects", type(other))
|
|
|
|
|
|
if minElements < 0:
|
|
|
raise ValueError("cannot multiply ParserElement by negative value")
|
|
|
if optElements < 0:
|
|
|
raise ValueError("second tuple value must be greater or equal to first tuple value")
|
|
|
if minElements == optElements == 0:
|
|
|
raise ValueError("cannot multiply ParserElement by 0 or (0,0)")
|
|
|
|
|
|
if (optElements):
|
|
|
def makeOptionalList(n):
|
|
|
if n>1:
|
|
|
return Optional(self + makeOptionalList(n-1))
|
|
|
else:
|
|
|
return Optional(self)
|
|
|
if minElements:
|
|
|
if minElements == 1:
|
|
|
ret = self + makeOptionalList(optElements)
|
|
|
else:
|
|
|
ret = And([self]*minElements) + makeOptionalList(optElements)
|
|
|
else:
|
|
|
ret = makeOptionalList(optElements)
|
|
|
else:
|
|
|
if minElements == 1:
|
|
|
ret = self
|
|
|
else:
|
|
|
ret = And([self]*minElements)
|
|
|
return ret
|
|
|
|
|
|
def __rmul__(self, other):
|
|
|
return self.__mul__(other)
|
|
|
|
|
|
def __or__(self, other ):
|
|
|
"""Implementation of | operator - returns MatchFirst"""
|
|
|
if isinstance( other, basestring ):
|
|
|
other = Literal( other )
|
|
|
if not isinstance( other, ParserElement ):
|
|
|
warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
|
|
|
SyntaxWarning, stacklevel=2)
|
|
|
return None
|
|
|
return MatchFirst( [ self, other ] )
|
|
|
|
|
|
def __ror__(self, other ):
|
|
|
"""Implementation of | operator when left operand is not a ParserElement"""
|
|
|
if isinstance( other, basestring ):
|
|
|
other = Literal( other )
|
|
|
if not isinstance( other, ParserElement ):
|
|
|
warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
|
|
|
SyntaxWarning, stacklevel=2)
|
|
|
return None
|
|
|
return other | self
|
|
|
|
|
|
def __xor__(self, other ):
|
|
|
"""Implementation of ^ operator - returns Or"""
|
|
|
if isinstance( other, basestring ):
|
|
|
other = Literal( other )
|
|
|
if not isinstance( other, ParserElement ):
|
|
|
warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
|
|
|
SyntaxWarning, stacklevel=2)
|
|
|
return None
|
|
|
return Or( [ self, other ] )
|
|
|
|
|
|
def __rxor__(self, other ):
|
|
|
"""Implementation of ^ operator when left operand is not a ParserElement"""
|
|
|
if isinstance( other, basestring ):
|
|
|
other = Literal( other )
|
|
|
if not isinstance( other, ParserElement ):
|
|
|
warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
|
|
|
SyntaxWarning, stacklevel=2)
|
|
|
return None
|
|
|
return other ^ self
|
|
|
|
|
|
def __and__(self, other ):
|
|
|
"""Implementation of & operator - returns Each"""
|
|
|
if isinstance( other, basestring ):
|
|
|
other = Literal( other )
|
|
|
if not isinstance( other, ParserElement ):
|
|
|
warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
|
|
|
SyntaxWarning, stacklevel=2)
|
|
|
return None
|
|
|
return Each( [ self, other ] )
|
|
|
|
|
|
def __rand__(self, other ):
|
|
|
"""Implementation of & operator when left operand is not a ParserElement"""
|
|
|
if isinstance( other, basestring ):
|
|
|
other = Literal( other )
|
|
|
if not isinstance( other, ParserElement ):
|
|
|
warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
|
|
|
SyntaxWarning, stacklevel=2)
|
|
|
return None
|
|
|
return other & self
|
|
|
|
|
|
def __invert__( self ):
|
|
|
"""Implementation of ~ operator - returns NotAny"""
|
|
|
return NotAny( self )
|
|
|
|
|
|
def __call__(self, name):
|
|
|
"""Shortcut for setResultsName, with listAllMatches=default::
|
|
|
userdata = Word(alphas).setResultsName("name") + Word(nums+"-").setResultsName("socsecno")
|
|
|
could be written as::
|
|
|
userdata = Word(alphas)("name") + Word(nums+"-")("socsecno")
|
|
|
"""
|
|
|
return self.setResultsName(name)
|
|
|
|
|
|
def suppress( self ):
|
|
|
"""Suppresses the output of this ParserElement; useful to keep punctuation from
|
|
|
cluttering up returned output.
|
|
|
"""
|
|
|
return Suppress( self )
|
|
|
|
|
|
def leaveWhitespace( self ):
|
|
|
"""Disables the skipping of whitespace before matching the characters in the
|
|
|
ParserElement's defined pattern. This is normally only used internally by
|
|
|
the pyparsing module, but may be needed in some whitespace-sensitive grammars.
|
|
|
"""
|
|
|
self.skipWhitespace = False
|
|
|
return self
|
|
|
|
|
|
def setWhitespaceChars( self, chars ):
|
|
|
"""Overrides the default whitespace chars
|
|
|
"""
|
|
|
self.skipWhitespace = True
|
|
|
self.whiteChars = chars
|
|
|
self.copyDefaultWhiteChars = False
|
|
|
return self
|
|
|
|
|
|
def parseWithTabs( self ):
|
|
|
"""Overrides default behavior to expand <TAB>s to spaces before parsing the input string.
|
|
|
Must be called before parseString when the input grammar contains elements that
|
|
|
match <TAB> characters."""
|
|
|
self.keepTabs = True
|
|
|
return self
|
|
|
|
|
|
def ignore( self, other ):
|
|
|
"""Define expression to be ignored (e.g., comments) while doing pattern
|
|
|
matching; may be called repeatedly, to define multiple comment or other
|
|
|
ignorable patterns.
|
|
|
"""
|
|
|
if isinstance( other, Suppress ):
|
|
|
if other not in self.ignoreExprs:
|
|
|
self.ignoreExprs.append( other )
|
|
|
else:
|
|
|
self.ignoreExprs.append( Suppress( other ) )
|
|
|
return self
|
|
|
|
|
|
def setDebugActions( self, startAction, successAction, exceptionAction ):
|
|
|
"""Enable display of debugging messages while doing pattern matching."""
|
|
|
self.debugActions = (startAction or _defaultStartDebugAction,
|
|
|
successAction or _defaultSuccessDebugAction,
|
|
|
exceptionAction or _defaultExceptionDebugAction)
|
|
|
self.debug = True
|
|
|
return self
|
|
|
|
|
|
def setDebug( self, flag=True ):
|
|
|
"""Enable display of debugging messages while doing pattern matching.
|
|
|
Set flag to True to enable, False to disable."""
|
|
|
if flag:
|
|
|
self.setDebugActions( _defaultStartDebugAction, _defaultSuccessDebugAction, _defaultExceptionDebugAction )
|
|
|
else:
|
|
|
self.debug = False
|
|
|
return self
|
|
|
|
|
|
def __str__( self ):
|
|
|
return self.name
|
|
|
|
|
|
def __repr__( self ):
|
|
|
return _ustr(self)
|
|
|
|
|
|
def streamline( self ):
|
|
|
self.streamlined = True
|
|
|
self.strRepr = None
|
|
|
return self
|
|
|
|
|
|
def checkRecursion( self, parseElementList ):
|
|
|
pass
|
|
|
|
|
|
def validate( self, validateTrace=[] ):
|
|
|
"""Check defined expressions for valid structure, check for infinite recursive definitions."""
|
|
|
self.checkRecursion( [] )
|
|
|
|
|
|
def parseFile( self, file_or_filename, parseAll=False ):
|
|
|
"""Execute the parse expression on the given file or filename.
|
|
|
If a filename is specified (instead of a file object),
|
|
|
the entire file is opened, read, and closed before parsing.
|
|
|
"""
|
|
|
try:
|
|
|
file_contents = file_or_filename.read()
|
|
|
except AttributeError:
|
|
|
f = open(file_or_filename, "rb")
|
|
|
file_contents = f.read()
|
|
|
f.close()
|
|
|
try:
|
|
|
return self.parseString(file_contents, parseAll)
|
|
|
except ParseBaseException, exc:
|
|
|
# catch and re-raise exception from here, clears out pyparsing internal stack trace
|
|
|
raise exc
|
|
|
|
|
|
def getException(self):
|
|
|
return ParseException("",0,self.errmsg,self)
|
|
|
|
|
|
def __getattr__(self,aname):
|
|
|
if aname == "myException":
|
|
|
self.myException = ret = self.getException();
|
|
|
return ret;
|
|
|
else:
|
|
|
raise AttributeError("no such attribute " + aname)
|
|
|
|
|
|
def __eq__(self,other):
|
|
|
if isinstance(other, ParserElement):
|
|
|
return self is other or self.__dict__ == other.__dict__
|
|
|
elif isinstance(other, basestring):
|
|
|
try:
|
|
|
self.parseString(_ustr(other), parseAll=True)
|
|
|
return True
|
|
|
except ParseBaseException:
|
|
|
return False
|
|
|
else:
|
|
|
return super(ParserElement,self)==other
|
|
|
|
|
|
def __ne__(self,other):
|
|
|
return not (self == other)
|
|
|
|
|
|
def __hash__(self):
|
|
|
return hash(id(self))
|
|
|
|
|
|
def __req__(self,other):
|
|
|
return self == other
|
|
|
|
|
|
def __rne__(self,other):
|
|
|
return not (self == other)
|
|
|
|
|
|
|
|
|
class Token(ParserElement):
|
|
|
"""Abstract ParserElement subclass, for defining atomic matching patterns."""
|
|
|
def __init__( self ):
|
|
|
super(Token,self).__init__( savelist=False )
|
|
|
#self.myException = ParseException("",0,"",self)
|
|
|
|
|
|
def setName(self, name):
|
|
|
s = super(Token,self).setName(name)
|
|
|
self.errmsg = "Expected " + self.name
|
|
|
#s.myException.msg = self.errmsg
|
|
|
return s
|
|
|
|
|
|
|
|
|
class Empty(Token):
|
|
|
"""An empty token, will always match."""
|
|
|
def __init__( self ):
|
|
|
super(Empty,self).__init__()
|
|
|
self.name = "Empty"
|
|
|
self.mayReturnEmpty = True
|
|
|
self.mayIndexError = False
|
|
|
|
|
|
|
|
|
class NoMatch(Token):
|
|
|
"""A token that will never match."""
|
|
|
def __init__( self ):
|
|
|
super(NoMatch,self).__init__()
|
|
|
self.name = "NoMatch"
|
|
|
self.mayReturnEmpty = True
|
|
|
self.mayIndexError = False
|
|
|
self.errmsg = "Unmatchable token"
|
|
|
#self.myException.msg = self.errmsg
|
|
|
|
|
|
def parseImpl( self, instring, loc, doActions=True ):
|
|
|
exc = self.myException
|
|
|
exc.loc = loc
|
|
|
exc.pstr = instring
|
|
|
raise exc
|
|
|
|
|
|
|
|
|
class Literal(Token):
|
|
|
"""Token to exactly match a specified string."""
|
|
|
def __init__( self, matchString ):
|
|
|
super(Literal,self).__init__()
|
|
|
self.match = matchString
|
|
|
self.matchLen = len(matchString)
|
|
|
try:
|
|
|
self.firstMatchChar = matchString[0]
|
|
|
except IndexError:
|
|
|
warnings.warn("null string passed to Literal; use Empty() instead",
|
|
|
SyntaxWarning, stacklevel=2)
|
|
|
self.__class__ = Empty
|
|
|
self.name = '"%s"' % _ustr(self.match)
|
|
|
self.errmsg = "Expected " + self.name
|
|
|
self.mayReturnEmpty = False
|
|
|
#self.myException.msg = self.errmsg
|
|
|
self.mayIndexError = False
|
|
|
|
|
|
# Performance tuning: this routine gets called a *lot*
|
|
|
# if this is a single character match string and the first character matches,
|
|
|
# short-circuit as quickly as possible, and avoid calling startswith
|
|
|
#~ @profile
|
|
|
def parseImpl( self, instring, loc, doActions=True ):
|
|
|
if (instring[loc] == self.firstMatchChar and
|
|
|
(self.matchLen==1 or instring.startswith(self.match,loc)) ):
|
|
|
return loc+self.matchLen, self.match
|
|
|
#~ raise ParseException( instring, loc, self.errmsg )
|
|
|
exc = self.myException
|
|
|
exc.loc = loc
|
|
|
exc.pstr = instring
|
|
|
raise exc
|
|
|
_L = Literal
|
|
|
|
|
|
class Keyword(Token):
|
|
|
"""Token to exactly match a specified string as a keyword, that is, it must be
|
|
|
immediately followed by a non-keyword character. Compare with Literal::
|
|
|
Literal("if") will match the leading 'if' in 'ifAndOnlyIf'.
|
|
|
Keyword("if") will not; it will only match the leading 'if in 'if x=1', or 'if(y==2)'
|
|
|
Accepts two optional constructor arguments in addition to the keyword string:
|
|
|
identChars is a string of characters that would be valid identifier characters,
|
|
|
defaulting to all alphanumerics + "_" and "$"; caseless allows case-insensitive
|
|
|
matching, default is False.
|
|
|
"""
|
|
|
DEFAULT_KEYWORD_CHARS = alphanums+"_$"
|
|
|
|
|
|
def __init__( self, matchString, identChars=DEFAULT_KEYWORD_CHARS, caseless=False ):
|
|
|
super(Keyword,self).__init__()
|
|
|
self.match = matchString
|
|
|
self.matchLen = len(matchString)
|
|
|
try:
|
|
|
self.firstMatchChar = matchString[0]
|
|
|
except IndexError:
|
|
|
warnings.warn("null string passed to Keyword; use Empty() instead",
|
|
|
SyntaxWarning, stacklevel=2)
|
|
|
self.name = '"%s"' % self.match
|
|
|
self.errmsg = "Expected " + self.name
|
|
|
self.mayReturnEmpty = False
|
|
|
#self.myException.msg = self.errmsg
|
|
|
self.mayIndexError = False
|
|
|
self.caseless = caseless
|
|
|
if caseless:
|
|
|
self.caselessmatch = matchString.upper()
|
|
|
identChars = identChars.upper()
|
|
|
self.identChars = _str2dict(identChars)
|
|
|
|
|
|
def parseImpl( self, instring, loc, doActions=True ):
|
|
|
if self.caseless:
|
|
|
if ( (instring[ loc:loc+self.matchLen ].upper() == self.caselessmatch) and
|
|
|
(loc >= len(instring)-self.matchLen or instring[loc+self.matchLen].upper() not in self.identChars) and
|
|
|
(loc == 0 or instring[loc-1].upper() not in self.identChars) ):
|
|
|
return loc+self.matchLen, self.match
|
|
|
else:
|
|
|
if (instring[loc] == self.firstMatchChar and
|
|
|
(self.matchLen==1 or instring.startswith(self.match,loc)) and
|
|
|
(loc >= len(instring)-self.matchLen or instring[loc+self.matchLen] not in self.identChars) and
|
|
|
(loc == 0 or instring[loc-1] not in self.identChars) ):
|
|
|
return loc+self.matchLen, self.match
|
|
|
#~ raise ParseException( instring, loc, self.errmsg )
|
|
|
exc = self.myException
|
|
|
exc.loc = loc
|
|
|
exc.pstr = instring
|
|
|
raise exc
|
|
|
|
|
|
def copy(self):
|
|
|
c = super(Keyword,self).copy()
|
|
|
c.identChars = Keyword.DEFAULT_KEYWORD_CHARS
|
|
|
return c
|
|
|
|
|
|
def setDefaultKeywordChars( chars ):
|
|
|
"""Overrides the default Keyword chars
|
|
|
"""
|
|
|
Keyword.DEFAULT_KEYWORD_CHARS = chars
|
|
|
setDefaultKeywordChars = staticmethod(setDefaultKeywordChars)
|
|
|
|
|
|
class CaselessLiteral(Literal):
|
|
|
"""Token to match a specified string, ignoring case of letters.
|
|
|
Note: the matched results will always be in the case of the given
|
|
|
match string, NOT the case of the input text.
|
|
|
"""
|
|
|
def __init__( self, matchString ):
|
|
|
super(CaselessLiteral,self).__init__( matchString.upper() )
|
|
|
# Preserve the defining literal.
|
|
|
self.returnString = matchString
|
|
|
self.name = "'%s'" % self.returnString
|
|
|
self.errmsg = "Expected " + self.name
|
|
|
#self.myException.msg = self.errmsg
|
|
|
|
|
|
def parseImpl( self, instring, loc, doActions=True ):
|
|
|
if instring[ loc:loc+self.matchLen ].upper() == self.match:
|
|
|
return loc+self.matchLen, self.returnString
|
|
|
#~ raise ParseException( instring, loc, self.errmsg )
|
|
|
exc = self.myException
|
|
|
exc.loc = loc
|
|
|
exc.pstr = instring
|
|
|
raise exc
|
|
|
|
|
|
class CaselessKeyword(Keyword):
|
|
|
def __init__( self, matchString, identChars=Keyword.DEFAULT_KEYWORD_CHARS ):
|
|
|
super(CaselessKeyword,self).__init__( matchString, identChars, caseless=True )
|
|
|
|
|
|
def parseImpl( self, instring, loc, doActions=True ):
|
|
|
if ( (instring[ loc:loc+self.matchLen ].upper() == self.caselessmatch) and
|
|
|
(loc >= len(instring)-self.matchLen or instring[loc+self.matchLen].upper() not in self.identChars) ):
|
|
|
return loc+self.matchLen, self.match
|
|
|
#~ raise ParseException( instring, loc, self.errmsg )
|
|
|
exc = self.myException
|
|
|
exc.loc = loc
|
|
|
exc.pstr = instring
|
|
|
raise exc
|
|
|
|
|
|
class Word(Token):
|
|
|
"""Token for matching words composed of allowed character sets.
|
|
|
Defined with string containing all allowed initial characters,
|
|
|
an optional string containing allowed body characters (if omitted,
|
|
|
defaults to the initial character set), and an optional minimum,
|
|
|
maximum, and/or exact length. The default value for min is 1 (a
|
|
|
minimum value < 1 is not valid); the default values for max and exact
|
|
|
are 0, meaning no maximum or exact length restriction.
|
|
|
"""
|
|
|
def __init__( self, initChars, bodyChars=None, min=1, max=0, exact=0, asKeyword=False ):
|
|
|
super(Word,self).__init__()
|
|
|
self.initCharsOrig = initChars
|
|
|
self.initChars = _str2dict(initChars)
|
|
|
if bodyChars :
|
|
|
self.bodyCharsOrig = bodyChars
|
|
|
self.bodyChars = _str2dict(bodyChars)
|
|
|
else:
|
|
|
self.bodyCharsOrig = initChars
|
|
|
self.bodyChars = _str2dict(initChars)
|
|
|
|
|
|
self.maxSpecified = max > 0
|
|
|
|
|
|
if min < 1:
|
|
|
raise ValueError("cannot specify a minimum length < 1; use Optional(Word()) if zero-length word is permitted")
|
|
|
|
|
|
self.minLen = min
|
|
|
|
|
|
if max > 0:
|
|
|
self.maxLen = max
|
|
|
else:
|
|
|
self.maxLen = _MAX_INT
|
|
|
|
|
|
if exact > 0:
|
|
|
self.maxLen = exact
|
|
|
self.minLen = exact
|
|
|
|
|
|
self.name = _ustr(self)
|
|
|
self.errmsg = "Expected " + self.name
|
|
|
#self.myException.msg = self.errmsg
|
|
|
self.mayIndexError = False
|
|
|
self.asKeyword = asKeyword
|
|
|
|
|
|
if ' ' not in self.initCharsOrig+self.bodyCharsOrig and (min==1 and max==0 and exact==0):
|
|
|
if self.bodyCharsOrig == self.initCharsOrig:
|
|
|
self.reString = "[%s]+" % _escapeRegexRangeChars(self.initCharsOrig)
|
|
|
elif len(self.bodyCharsOrig) == 1:
|
|
|
self.reString = "%s[%s]*" % \
|
|
|
(re.escape(self.initCharsOrig),
|
|
|
_escapeRegexRangeChars(self.bodyCharsOrig),)
|
|
|
else:
|
|
|
self.reString = "[%s][%s]*" % \
|
|
|
(_escapeRegexRangeChars(self.initCharsOrig),
|
|
|
_escapeRegexRangeChars(self.bodyCharsOrig),)
|
|
|
if self.asKeyword:
|
|
|
self.reString = r"\b"+self.reString+r"\b"
|
|
|
try:
|
|
|
self.re = re.compile( self.reString )
|
|
|
except:
|
|
|
self.re = None
|
|
|
|
|
|
def parseImpl( self, instring, loc, doActions=True ):
|
|
|
if self.re:
|
|
|
result = self.re.match(instring,loc)
|
|
|
if not result:
|
|
|
exc = self.myException
|
|
|
exc.loc = loc
|
|
|
exc.pstr = instring
|
|
|
raise exc
|
|
|
|
|
|
loc = result.end()
|
|
|
return loc,result.group()
|
|
|
|
|
|
if not(instring[ loc ] in self.initChars):
|
|
|
#~ raise ParseException( instring, loc, self.errmsg )
|
|
|
exc = self.myException
|
|
|
exc.loc = loc
|
|
|
exc.pstr |
