dottes: abc2xml/pyparsing.py comparison

comparison abc2xml/pyparsing.py @ 1084:b1dbb76f4eb9 build-default-404

Update abc2xml to latest - Python3 friendly.

author	Jim Hague <jim.hague@acm.org>
date	Fri, 18 Nov 2022 21:42:55 +0000
parents	4fab69a1027d
children

comparison

equal deleted inserted replaced

-:b66bc498220d
+:b1dbb76f4eb9
 # module pyparsing.py
 #
-# Copyright (c) 2003-2011  Paul T. McGuire
+# Copyright (c) 2003-2013  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,
 # 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
 # define grammar of a greeting
 greet = Word( alphas ) + "," + Word( alphas ) + "!"
 hello = "Hello, World!"
-print hello, "->", greet.parseString( hello )
+print (hello, "->", greet.parseString( hello ))
 The program outputs the following::
 Hello, World! -> ['Hello', ',', 'World', '!']
 - extra or missing whitespace (the above program will also handle "Hello,World!", "Hello  ,  World  !", etc.)
 - quoted strings
 - embedded comments
 """
-__version__ = "1.5.6"
+__version__ = "2.0.1"
-__versionTime__ = "26 June 2011 10:53"
+__versionTime__ = "16 July 2013 22:22"
 __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
+import collections
 #~ 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',
 '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',
+'dblSlashComment', 'delimitedList', 'dictOf', 'downcaseTokens', 'empty', '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',
+'indentedBlock', 'originalTextFor', 'ungroup', 'infixNotation',
 ]
-"""
+PY_3 = sys.version.startswith('3')
-Detect if we are running version 3.X and make appropriate changes
+if PY_3:
-Robert A. Clark
-"""
-_PY3K = sys.version_info[0] > 2
-if _PY3K:
 _MAX_INT = sys.maxsize
 basestring = str
 unichr = chr
 _ustr = str
-alphas = string.ascii_lowercase + string.ascii_uppercase
+# build list of single arg builtins, that can be used as parse actions
+singleArgBuiltins = [sum, len, sorted, reversed, list, tuple, set, any, all, min, max]
 else:
 _MAX_INT = sys.maxint
 range = xrange
-set = lambda s : dict( [(c,0) for c in s] )
-alphas = string.lowercase + string.uppercase
 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 | ... >.
 # Replace unprintables with escape codes?
 #return unicode(obj).encode(sys.getdefaultencoding(), 'backslashreplace_errors')
 # Replace unprintables with question marks?
 #return unicode(obj).encode(sys.getdefaultencoding(), 'replace')
 # ...
-alphas = string.lowercase + string.uppercase
+# build list of single arg builtins, tolerant of Python version, that can be used as parse actions
+singleArgBuiltins = []
-# build list of single arg builtins, tolerant of Python version, that can be used as parse actions
+import __builtin__
-singleArgBuiltins = []
+for fname in "sum len sorted reversed list tuple set any all min max".split():
-import __builtin__
+try:
-for fname in "sum len enumerate sorted reversed list tuple set any all".split():
+singleArgBuiltins.append(getattr(__builtin__,fname))
-try:
+except AttributeError:
-singleArgBuiltins.append(getattr(__builtin__,fname))
+continue
-except AttributeError:
-continue
 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()]
+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
-nums       = string.digits
+alphas = string.ascii_lowercase + string.ascii_uppercase
+nums       = "0123456789"
 hexnums    = nums + "ABCDEFabcdef"
 alphanums  = alphas + nums
 _bslash    = chr(92)
-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)
 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
 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],
+line_str = "".join(line_str[:line_column],
-markerString, 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()
+"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
 """user-throwable exception thrown when inconsistent parse content
 is found; stops all parsing immediately"""
 pass
 class ParseSyntaxException(ParseFatalException):
-"""just like C{ParseFatalException}, but thrown internally when an
+"""just like C{L{ParseFatalException}}, but thrown internally when an
-C{ErrorStop} ('-' operator) indicates that parsing is to stop immediately because
+C{L{ErrorStop<And._ErrorStop>}} ('-' operator) 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)
 def __repr__( self ):
 return "(%s, %s)" % ( repr( self.__toklist ), repr( self.__tokdict ) )
 def __str__( self ):
-out = "["
+out = []
-sep = ""
 for i in self.__toklist:
 if isinstance(i, ParseResults):
-out += sep + _ustr(i)
+out.append(_ustr(i))
 else:
-out += sep + repr(i)
+out.append(repr(i))
-sep = ", "
+return '[' + ', '.join(out) + ']'
-out += "]"
-return out
 def _asStringList( self, sep='' ):
 out = []
 for item in self.__toklist:
 if out and sep:
 def asXML( self, doctag=None, namedItemsOnly=False, indent="", formatted=True ):
 """Returns the parse results as XML. Tags are created for tokens and lists that have defined results names."""
 nl = "\n"
 out = []
-namedItems = dict( [ (v[1],k) for (k,vlist) in self.__tokdict.items()
+namedItems = dict((v[1],k) for (k,vlist) in self.__tokdict.items()
-for v in vlist ] )
+for v in vlist)
 nextLevelIndent = indent + "  "
 # collapse out indents if formatting is not desired
 if not formatted:
 indent = ""
 self.__parent = wkref(par)
 else:
 self.__parent = None
 def __dir__(self):
-return dir(super(ParseResults,self)) + self.keys()
+return dir(super(ParseResults,self)) + list(self.keys())
+if hasattr (collections, 'MutableMapping'):
+collections.MutableMapping.register(ParseResults)
+else:
+from collections.abc import MutableMapping
+MutableMapping.register (ParseResults)
 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
+on parsing strings containing C{<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)
 """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
+on parsing strings containing C{<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
 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) ))
+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 ):
 def nullDebugAction(*args):
 """'Do-nothing' debug action, to suppress debugging output during parsing."""
 pass
+# Only works on Python 3.x - nonlocal is toxic to Python 2 installs
+#~ 'decorator to trim function calls to match the arity of the target'
+#~ def _trim_arity(func, maxargs=3):
+#~ if func in singleArgBuiltins:
+#~ return lambda s,l,t: func(t)
+#~ limit = 0
+#~ foundArity = False
+#~ def wrapper(*args):
+#~ nonlocal limit,foundArity
+#~ while 1:
+#~ try:
+#~ ret = func(*args[limit:])
+#~ foundArity = True
+#~ return ret
+#~ except TypeError:
+#~ if limit == maxargs or foundArity:
+#~ raise
+#~ limit += 1
+#~ continue
+#~ return wrapper
+# this version is Python 2.x-3.x cross-compatible
 'decorator to trim function calls to match the arity of the target'
-if not _PY3K:
+def _trim_arity(func, maxargs=2):
-def _trim_arity(func, maxargs=2):
+if func in singleArgBuiltins:
-limit = [0]
+return lambda s,l,t: func(t)
-def wrapper(*args):
+limit = [0]
-while 1:
+foundArity = [False]
-try:
+def wrapper(*args):
-return func(*args[limit[0]:])
+while 1:
-except TypeError:
+try:
-if limit[0] <= maxargs:
+ret = func(*args[limit[0]:])
-limit[0] += 1
+foundArity[0] = True
-continue
+return ret
-raise
+except TypeError:
-return wrapper
+if limit[0] <= maxargs and not foundArity[0]:
-else:
+limit[0] += 1
-def _trim_arity(func, maxargs=2):
+continue
-limit = maxargs
+raise
-def wrapper(*args):
+return wrapper
-#~ nonlocal limit
-while 1:
-try:
-return func(*args[limit:])
-except TypeError:
-if limit:
-limit -= 1
-continue
-raise
-return wrapper
 class ParserElement(object):
 """Abstract base level parser element class."""
 DEFAULT_WHITE_CHARS = " \n\t\r"
 verbose_stacktrace = False
 def setDefaultWhitespaceChars( chars ):
 """Overrides the default whitespace chars
 """
 ParserElement.DEFAULT_WHITE_CHARS = chars
 setDefaultWhitespaceChars = staticmethod(setDefaultWhitespaceChars)
+def inlineLiteralsUsing(cls):
+"""
+Set class to be used for inclusion of string literals into a parser.
+"""
+ParserElement.literalStringClass = cls
+inlineLiteralsUsing = staticmethod(inlineLiteralsUsing)
 def __init__( self, savelist=False ):
 self.parseAction = list()
 self.failAction = None
 #~ self.name = "<unknown>"  # don't define self.name, let subclasses try/except upcall
 """Define action to perform when successfully matching parse element definition.
 Parse action fn is a callable method with 0-3 arguments, called as C{fn(s,loc,toks)},
 C{fn(loc,toks)}, C{fn(toks)}, or just C{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
+- toks = a list of the matched tokens, packaged as a C{L{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
+on parsing strings containing C{<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(_trim_arity, list(fns)))
 self.callDuringTry = ("callDuringTry" in kwargs and kwargs["callDuringTry"])
 C{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 C{ParseFatalException}
+The function returns no value.  It may throw C{L{ParseFatalException}}
 if it is desired to stop parsing immediately."""
 self.failAction = fn
 return self
 def _skipIgnorables( self, instring, loc ):
 try:
 try:
 loc,tokens = self.parseImpl( instring, preloc, doActions )
 except IndexError:
 raise ParseException( instring, len(instring), self.errmsg, self )
-except ParseBaseException:
+except ParseBaseException as err:
 #~ print ("Exception raised:", err)
-err = None
 if self.debugActions[2]:
-err = sys.exc_info()[1]
 self.debugActions[2]( instring, tokensStart, self, err )
 if self.failAction:
-if err is None:
-err = sys.exc_info()[1]
 self.failAction( instring, tokensStart, self, err )
 raise
 else:
 if callPreParse and self.callPreparse:
 preloc = self.preParse( instring, loc )
 if tokens is not None:
 retTokens = ParseResults( tokens,
 self.resultsName,
 asList=self.saveAsList and isinstance(tokens,(ParseResults,list)),
 modal=self.modalResults )
-except ParseBaseException:
+except ParseBaseException as err:
 #~ print "Exception raised in user parse action:", err
 if (self.debugActions[2] ):
-err = sys.exc_info()[1]
 self.debugActions[2]( instring, tokensStart, self, err )
 raise
 else:
 for fn in self.parseAction:
 tokens = fn( instring, tokensStart, retTokens )
 else:
 try:
 value = self._parseNoCache( instring, loc, doActions, callPreParse )
 ParserElement._exprArgCache[ lookup ] = (value[0],value[1].copy())
 return value
-except ParseBaseException:
+except ParseBaseException as pe:
-pe = sys.exc_info()[1]
+pe.__traceback__ = None
 ParserElement._exprArgCache[ lookup ] = pe
 raise
 _parse = _parseNoCache
 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 C{parseAll} to True (equivalent to ending
-the grammar with C{StringEnd()}).
+the grammar with C{L{StringEnd()}}).
 Note: C{parseString} implicitly calls C{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 C{loc} argument to index into the
 loc, tokens = self._parse( instring, 0 )
 if parseAll:
 loc = self.preParse( instring, loc )
 se = Empty() + StringEnd()
 se._parse( instring, loc )
-except ParseBaseException:
+except ParseBaseException as exc:
 if ParserElement.verbose_stacktrace:
 raise
 else:
 # catch and re-raise exception from here, clears out pyparsing internal stack trace
-exc = sys.exc_info()[1]
 raise exc
 else:
 return tokens
 def scanString( self, instring, maxMatches=_MAX_INT, overlap=False ):
 loc += 1
 else:
 loc = nextLoc
 else:
 loc = preloc+1
-except ParseBaseException:
+except ParseBaseException as exc:
 if ParserElement.verbose_stacktrace:
 raise
 else:
 # catch and re-raise exception from here, clears out pyparsing internal stack trace
-exc = sys.exc_info()[1]
 raise exc
 def transformString( self, instring ):
-"""Extension to C{scanString}, to modify matching text with modified tokens that may
+"""Extension to C{L{scanString}}, to modify matching text with modified tokens that may
 be returned from a parse action.  To use C{transformString}, define a grammar and
 attach a parse action to it that modifies the returned token list.
 Invoking C{transformString()} on a target string will then scan for matches,
 and replace the matched text patterns according to the logic in the parse
 action.  C{transformString()} returns the resulting transformed string."""
 out.append(t)
 lastE = e
 out.append(instring[lastE:])
 out = [o for o in out if o]
 return "".join(map(_ustr,_flatten(out)))
-except ParseBaseException:
+except ParseBaseException as exc:
 if ParserElement.verbose_stacktrace:
 raise
 else:
 # catch and re-raise exception from here, clears out pyparsing internal stack trace
-exc = sys.exc_info()[1]
 raise exc
 def searchString( self, instring, maxMatches=_MAX_INT ):
-"""Another extension to C{scanString}, simplifying the access to the tokens found
+"""Another extension to C{L{scanString}}, simplifying the access to the tokens found
 to match the given parse expression.  May be called with optional
 C{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:
+except ParseBaseException as exc:
 if ParserElement.verbose_stacktrace:
 raise
 else:
 # catch and re-raise exception from here, clears out pyparsing internal stack trace
-exc = sys.exc_info()[1]
 raise exc
 def __add__(self, other ):
-"""Implementation of + operator - returns And"""
+"""Implementation of + operator - returns C{L{And}}"""
 if isinstance( other, basestring ):
-other = Literal( other )
+other = ParserElement.literalStringClass( 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 C{ParserElement}"""
+"""Implementation of + operator when left operand is not a C{L{ParserElement}}"""
 if isinstance( other, basestring ):
-other = Literal( other )
+other = ParserElement.literalStringClass( 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 C{And} with error stop"""
+"""Implementation of - operator, returns C{L{And}} with error stop"""
 if isinstance( other, basestring ):
-other = Literal( other )
+other = ParserElement.literalStringClass( 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 C{ParserElement}"""
+"""Implementation of - operator when left operand is not a C{L{ParserElement}}"""
 if isinstance( other, basestring ):
-other = Literal( other )
+other = ParserElement.literalStringClass( 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
 """Implementation of * operator, allows use of C{expr * 3} in place of
 C{expr + expr + expr}.  Expressions may also me multiplied by a 2-integer
 tuple, similar to C{{min,max}} multipliers in regular expressions.  Tuples
 may also include C{None} as in:
 - C{expr*(n,None)} or C{expr*(n,)} is equivalent
-to C{expr*n + ZeroOrMore(expr)}
+to C{expr*n + L{ZeroOrMore}(expr)}
 (read as "at least n instances of C{expr}")
 - C{expr*(None,n)} is equivalent to C{expr*(0,n)}
 (read as "0 to n instances of C{expr}")
-- C{expr*(None,None)} is equivalent to C{ZeroOrMore(expr)}
+- C{expr*(None,None)} is equivalent to C{L{ZeroOrMore}(expr)}
-- C{expr*(1,None)} is equivalent to C{OneOrMore(expr)}
+- C{expr*(1,None)} is equivalent to C{L{OneOrMore}(expr)}
 Note that C{expr*(None,n)} does not raise an exception if
 more than n exprs exist in the input stream; that is,
 C{expr*(None,n)} does not enforce a maximum number of expr
 occurrences.  If this behavior is desired, then write
 def __rmul__(self, other):
 return self.__mul__(other)
 def __or__(self, other ):
-"""Implementation of | operator - returns C{MatchFirst}"""
+"""Implementation of | operator - returns C{L{MatchFirst}}"""
 if isinstance( other, basestring ):
-other = Literal( other )
+other = ParserElement.literalStringClass( 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 C{ParserElement}"""
+"""Implementation of | operator when left operand is not a C{L{ParserElement}}"""
 if isinstance( other, basestring ):
-other = Literal( other )
+other = ParserElement.literalStringClass( 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 C{Or}"""
+"""Implementation of ^ operator - returns C{L{Or}}"""
 if isinstance( other, basestring ):
-other = Literal( other )
+other = ParserElement.literalStringClass( 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 C{ParserElement}"""
+"""Implementation of ^ operator when left operand is not a C{L{ParserElement}}"""
 if isinstance( other, basestring ):
-other = Literal( other )
+other = ParserElement.literalStringClass( 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 C{Each}"""
+"""Implementation of & operator - returns C{L{Each}}"""
 if isinstance( other, basestring ):
-other = Literal( other )
+other = ParserElement.literalStringClass( 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 C{ParserElement}"""
+"""Implementation of & operator when left operand is not a C{L{ParserElement}}"""
 if isinstance( other, basestring ):
-other = Literal( other )
+other = ParserElement.literalStringClass( 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 C{NotAny}"""
+"""Implementation of ~ operator - returns C{L{NotAny}}"""
 return NotAny( self )
 def __call__(self, name):
-"""Shortcut for C{setResultsName}, with C{listAllMatches=default}::
+"""Shortcut for C{L{setResultsName}}, with C{listAllMatches=default}::
 userdata = Word(alphas).setResultsName("name") + Word(nums+"-").setResultsName("socsecno")
 could be written as::
 userdata = Word(alphas)("name") + Word(nums+"-")("socsecno")
 If C{name} is given with a trailing C{'*'} character, then C{listAllMatches} will be
 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")
+f = open(file_or_filename, "r")
 file_contents = f.read()
 f.close()
 try:
 return self.parseString(file_contents, parseAll)
-except ParseBaseException:
+except ParseBaseException as exc:
-# catch and re-raise exception from here, clears out pyparsing internal stack trace
+if ParserElement.verbose_stacktrace:
-exc = sys.exc_info()[1]
+raise
-raise exc
+else:
+# catch and re-raise exception from here, clears out pyparsing internal stack trace
-def getException(self):
+raise exc
-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):
 self.mayReturnEmpty = True
 self.mayIndexError = False
 self.errmsg = "Unmatchable token"
 def parseImpl( self, instring, loc, doActions=True ):
-exc = self.myException
+raise ParseException(instring, loc, self.errmsg, self)
-exc.loc = loc
-exc.pstr = instring
-raise exc
 class Literal(Token):
 """Token to exactly match a specified string."""
 def __init__( self, matchString ):
 #~ @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 )
+raise ParseException(instring, loc, self.errmsg, self)
-exc = self.myException
-exc.loc = loc
-exc.pstr = instring
-raise exc
 _L = Literal
+ParserElement.literalStringClass = 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 C{Literal}::
+immediately followed by a non-keyword character.  Compare with C{L{Literal}}::
 Literal("if") will match the leading C{'if'} in C{'ifAndOnlyIf'}.
 Keyword("if") will not; it will only match the leading C{'if'} in C{'if x=1'}, or C{'if(y==2)'}
 Accepts two optional constructor arguments in addition to the keyword string:
 C{identChars} is a string of characters that would be valid identifier characters,
 defaulting to all alphanumerics + "_" and "$"; C{caseless} allows case-insensitive
 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 )
+raise ParseException(instring, loc, self.errmsg, self)
-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
 self.errmsg = "Expected " + self.name
 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 )
+raise ParseException(instring, loc, self.errmsg, self)
-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 )
+raise ParseException(instring, loc, self.errmsg, self)
-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,
 except for one or two characters, for instance.
 """
 def __init__( self, initChars, bodyChars=None, min=1, max=0, exact=0, asKeyword=False, excludeChars=None ):
 super(Word,self).__init__()
 if excludeChars:
-initChars = ''.join([c for c in initChars if c not in excludeChars])
+initChars = ''.join(c for c in initChars if c not in excludeChars)
 if bodyChars:
-bodyChars = ''.join([c for c in bodyChars if c not in excludeChars])
+bodyChars = ''.join(c for c in bodyChars if c not in excludeChars)
 self.initCharsOrig = initChars
 self.initChars = set(initChars)
 if bodyChars :
 self.bodyCharsOrig = bodyChars
 self.bodyChars = set(bodyChars)
 def parseImpl( self, instring, loc, doActions=True ):
 if self.re:
 result = self.re.match(instring,loc)
 if not result:
-exc = self.myException
+raise ParseException(instring, loc, self.errmsg, self)
-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 )
+raise ParseException(instring, loc, self.errmsg, self)
-exc = self.myException
-exc.loc = loc
-exc.pstr = instring
-raise exc
 start = loc
 loc += 1
 instrlen = len(instring)
 bodychars = self.bodyChars
 maxloc = start + self.maxLen
 if self.asKeyword:
 if (start>0 and instring[start-1] in bodychars) or (loc<instrlen and instring[loc] in bodychars):
 throwException = True
 if throwException:
-#~ raise ParseException( instring, loc, self.errmsg )
+raise ParseException(instring, loc, self.errmsg, self)
-exc = self.myException
-exc.loc = loc
-exc.pstr = instring
-raise exc
 return loc, instring[start:loc]
 def __str__( self ):
 try:
 self.mayReturnEmpty = True
 def parseImpl( self, instring, loc, doActions=True ):
 result = self.re.match(instring,loc)
 if not result:
-exc = self.myException
+raise ParseException(instring, loc, self.errmsg, self)
-exc.loc = loc
-exc.pstr = instring
-raise exc
 loc = result.end()
 d = result.groupdict()
 ret = ParseResults(result.group())
 if d:
 """
 Defined with the following parameters:
 - quoteChar - string of one or more characters defining the quote delimiting string
 - escChar - character to escape quotes, typically backslash (default=None)
 - escQuote - special quote sequence to escape an embedded quote string (such as SQL's "" to escape an embedded ") (default=None)
-- multiline - boolean indicating whether quotes can span multiple lines (default=False)
+- multiline - boolean indicating whether quotes can span multiple lines (default=C{False})
-- unquoteResults - boolean indicating whether the matched text should be unquoted (default=True)
+- unquoteResults - boolean indicating whether the matched text should be unquoted (default=C{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=C{None} => same as quoteChar)
 """
 super(QuotedString,self).__init__()
 # remove white space from quote chars - wont work anyway
 quoteChar = quoteChar.strip()
 ( re.escape(self.quoteChar),
 _escapeRegexRangeChars(self.endQuoteChar[0]),
 (escChar is not None and _escapeRegexRangeChars(escChar) or '') )
 if len(self.endQuoteChar) > 1:
 self.pattern += (
-'|(?:' + ')|(?:'.join(["%s[^%s]" % (re.escape(self.endQuoteChar[:i]),
+'|(?:' + ')|(?:'.join("%s[^%s]" % (re.escape(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:
 self.pattern += (r'|(?:%s)' % re.escape(escQuote))
 if escChar:
 self.pattern += (r'|(?:%s.)' % re.escape(escChar))
 self.mayReturnEmpty = True
 def parseImpl( self, instring, loc, doActions=True ):
 result = instring[loc] == self.firstQuoteChar and self.re.match(instring,loc) or None
 if not result:
-exc = self.myException
+raise ParseException(instring, loc, self.errmsg, self)
-exc.loc = loc
-exc.pstr = instring
-raise exc
 loc = result.end()
 ret = result.group()
 if self.unquoteResults:
 self.mayReturnEmpty = ( self.minLen == 0 )
 self.mayIndexError = False
 def parseImpl( self, instring, loc, doActions=True ):
 if instring[loc] in self.notChars:
-#~ raise ParseException( instring, loc, self.errmsg )
+raise ParseException(instring, loc, self.errmsg, self)
-exc = self.myException
-exc.loc = loc
-exc.pstr = instring
-raise exc
 start = loc
 loc += 1
 notchars = self.notChars
 maxlen = min( start+self.maxLen, len(instring) )
 while loc < maxlen and \
 (instring[loc] not in notchars):
 loc += 1
 if loc - start < self.minLen:
-#~ raise ParseException( instring, loc, self.errmsg )
+raise ParseException(instring, loc, self.errmsg, self)
-exc = self.myException
-exc.loc = loc
-exc.pstr = instring
-raise exc
 return loc, instring[start:loc]
 def __str__( self ):
 try:
 class White(Token):
 """Special matching class for matching whitespace.  Normally, whitespace is ignored
 by pyparsing grammars.  This class is included when some whitespace structures
 are significant.  Define with a string containing the whitespace characters to be
 matched; default is C{" \\t\\r\\n"}.  Also takes optional C{min}, C{max}, and C{exact} arguments,
-as defined for the C{Word} class."""
+as defined for the C{L{Word}} class."""
 whiteStrs = {
 " " : "<SPC>",
 "\t": "<TAB>",
 "\n": "<LF>",
 "\r": "<CR>",
 "\f": "<FF>",
 }
 def __init__(self, ws=" \t\r\n", min=1, max=0, exact=0):
 super(White,self).__init__()
 self.matchWhite = ws
-self.setWhitespaceChars( "".join([c for c in self.whiteChars if c not in self.matchWhite]) )
+self.setWhitespaceChars( "".join(c for c in self.whiteChars if c not in self.matchWhite) )
 #~ self.leaveWhitespace()
-self.name = ("".join([White.whiteStrs[c] for c in self.matchWhite]))
+self.name = ("".join(White.whiteStrs[c] for c in self.matchWhite))
 self.mayReturnEmpty = True
 self.errmsg = "Expected " + self.name
 self.minLen = min
 self.maxLen = exact
 self.minLen = exact
 def parseImpl( self, instring, loc, doActions=True ):
 if not(instring[ loc ] in self.matchWhite):
-#~ raise ParseException( instring, loc, self.errmsg )
+raise ParseException(instring, loc, self.errmsg, self)
-exc = self.myException
-exc.loc = loc
-exc.pstr = instring
-raise exc
 start = loc
 loc += 1
 maxloc = start + self.maxLen
 maxloc = min( maxloc, len(instring) )
 while loc < maxloc and instring[loc] in self.matchWhite:
 loc += 1
 if loc - start < self.minLen:
-#~ raise ParseException( instring, loc, self.errmsg )
+raise ParseException(instring, loc, self.errmsg, self)
-exc = self.myException
-exc.loc = loc
-exc.pstr = instring
-raise exc
 return loc, instring[start:loc]
 class _PositionToken(Token):
 def parseImpl( self, instring, loc, doActions=True ):
 if not( loc==0 or
 (loc == self.preParse( instring, 0 )) or
 (instring[loc-1] == "\n") ): #col(loc, instring) != 1:
-#~ raise ParseException( instring, loc, "Expected start of line" )
+raise ParseException(instring, loc, self.errmsg, self)
-exc = self.myException
-exc.loc = loc
-exc.pstr = instring
-raise exc
 return loc, []
 class LineEnd(_PositionToken):
 """Matches if current position is at the end of a line within the parse string"""
 def __init__( self ):
 def parseImpl( self, instring, loc, doActions=True ):
 if loc<len(instring):
 if instring[loc] == "\n":
 return loc+1, "\n"
 else:
-#~ raise ParseException( instring, loc, "Expected end of line" )
+raise ParseException(instring, loc, self.errmsg, self)
-exc = self.myException
-exc.loc = loc
-exc.pstr = instring
-raise exc
 elif loc == len(instring):
 return loc+1, []
 else:
-exc = self.myException
+raise ParseException(instring, loc, self.errmsg, self)
-exc.loc = loc
-exc.pstr = instring
-raise exc
 class StringStart(_PositionToken):
 """Matches if current position is at the beginning of the parse string"""
 def __init__( self ):
 super(StringStart,self).__init__()
 def parseImpl( self, instring, loc, doActions=True ):
 if loc != 0:
 # see if entire string up to here is just whitespace and ignoreables
 if loc != self.preParse( instring, 0 ):
-#~ raise ParseException( instring, loc, "Expected start of text" )
+raise ParseException(instring, loc, self.errmsg, self)
-exc = self.myException
-exc.loc = loc
-exc.pstr = instring
-raise exc
 return loc, []
 class StringEnd(_PositionToken):
 """Matches if current position is at the end of the parse string"""
 def __init__( self ):
 super(StringEnd,self).__init__()
 self.errmsg = "Expected end of text"
 def parseImpl( self, instring, loc, doActions=True ):
 if loc < len(instring):
-#~ raise ParseException( instring, loc, "Expected end of text" )
+raise ParseException(instring, loc, self.errmsg, self)
-exc = self.myException
-exc.loc = loc
-exc.pstr = instring
-raise exc
 elif loc == len(instring):
 return loc+1, []
 elif loc > len(instring):
 return loc, []
 else:
-exc = self.myException
+raise ParseException(instring, loc, self.errmsg, self)
-exc.loc = loc
-exc.pstr = instring
-raise exc
 class WordStart(_PositionToken):
 """Matches if the current position is at the beginning of a Word, and
 is not preceded by any character in a given set of C{wordChars}
 (default=C{printables}). To emulate the C{\b} behavior of regular expressions,
 def parseImpl(self, instring, loc, doActions=True ):
 if loc != 0:
 if (instring[loc-1] in self.wordChars or
 instring[loc] not in self.wordChars):
-exc = self.myException
+raise ParseException(instring, loc, self.errmsg, self)
-exc.loc = loc
-exc.pstr = instring
-raise exc
 return loc, []
 class WordEnd(_PositionToken):
 """Matches if the current position is at the end of a Word, and
 is not followed by any character in a given set of C{wordChars}
 def parseImpl(self, instring, loc, doActions=True ):
 instrlen = len(instring)
 if instrlen>0 and loc<instrlen:
 if (instring[loc] in self.wordChars or
 instring[loc-1] not in self.wordChars):
-#~ raise ParseException( instring, loc, "Expected end of word" )
+raise ParseException(instring, loc, self.errmsg, self)
-exc = self.myException
-exc.loc = loc
-exc.pstr = instring
-raise exc
 return loc, []
 class ParseExpression(ParserElement):
 """Abstract subclass of ParserElement, for combining and post-processing parsed tokens."""
 May be constructed using the C{'+'} operator.
 """
 class _ErrorStop(Empty):
 def __init__(self, *args, **kwargs):
-super(Empty,self).__init__(*args, **kwargs)
+super(And._ErrorStop,self).__init__(*args, **kwargs)
+self.name = '-'
 self.leaveWhitespace()
 def __init__( self, exprs, savelist = True ):
 super(And,self).__init__(exprs, savelist)
 self.mayReturnEmpty = True
 if errorStop:
 try:
 loc, exprtokens = e._parse( instring, loc, doActions )
 except ParseSyntaxException:
 raise
-except ParseBaseException:
+except ParseBaseException as pe:
-pe = sys.exc_info()[1]
+pe.__traceback__ = None
 raise ParseSyntaxException(pe)
 except IndexError:
 raise ParseSyntaxException( ParseException(instring, len(instring), self.errmsg, self) )
 else:
 loc, exprtokens = e._parse( instring, loc, doActions )
 def __str__( self ):
 if hasattr(self,"name"):
 return self.name
 if self.strRepr is None:
-self.strRepr = "{" + " ".join( [ _ustr(e) for e in self.exprs ] ) + "}"
+self.strRepr = "{" + " ".join(_ustr(e) for e in self.exprs) + "}"
 return self.strRepr
 class Or(ParseExpression):
 maxMatchLoc = -1
 maxException = None
 for e in self.exprs:
 try:
 loc2 = e.tryParse( instring, loc )
-except ParseException:
+except ParseException as err:
-err = sys.exc_info()[1]
+err.__traceback__ = None
 if err.loc > maxExcLoc:
 maxException = err
 maxExcLoc = err.loc
 except IndexError:
 if len(instring) > maxExcLoc:
 return maxMatchExp._parse( instring, loc, doActions )
 def __ixor__(self, other ):
 if isinstance( other, basestring ):
-other = Literal( other )
+other = ParserElement.literalStringClass( other )
 return self.append( other ) #Or( [ self, other ] )
 def __str__( self ):
 if hasattr(self,"name"):
 return self.name
 if self.strRepr is None:
-self.strRepr = "{" + " ^ ".join( [ _ustr(e) for e in self.exprs ] ) + "}"
+self.strRepr = "{" + " ^ ".join(_ustr(e) for e in self.exprs) + "}"
 return self.strRepr
 def checkRecursion( self, parseElementList ):
 subRecCheckList = parseElementList[:] + [ self ]
 maxException = None
 for e in self.exprs:
 try:
 ret = e._parse( instring, loc, doActions )
 return ret
-except ParseException, err:
+except ParseException as err:
 if err.loc > maxExcLoc:
 maxException = err
 maxExcLoc = err.loc
 except IndexError:
 if len(instring) > maxExcLoc:
 else:
 raise ParseException(instring, loc, "no defined alternatives to match", self)
 def __ior__(self, other ):
 if isinstance( other, basestring ):
-other = Literal( other )
+other = ParserElement.literalStringClass( other )
 return self.append( other ) #MatchFirst( [ self, other ] )
 def __str__( self ):
 if hasattr(self,"name"):
 return self.name
 if self.strRepr is None:
-self.strRepr = "{" + " | ".join( [ _ustr(e) for e in self.exprs ] ) + "}"
+self.strRepr = "{" + " | ".join(_ustr(e) for e in self.exprs) + "}"
 return self.strRepr
 def checkRecursion( self, parseElementList ):
 subRecCheckList = parseElementList[:] + [ self ]
 tmpOpt.remove(e)
 if len(failed) == len(tmpExprs):
 keepMatching = False
 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 )
 # add any unmatched Optionals, in case they have default values defined
 matchOrder += [e for e in self.exprs if isinstance(e,Optional) and e.expr in tmpOpt]
 def __str__( self ):
 if hasattr(self,"name"):
 return self.name
 if self.strRepr is None:
-self.strRepr = "{" + " & ".join( [ _ustr(e) for e in self.exprs ] ) + "}"
+self.strRepr = "{" + " & ".join(_ustr(e) for e in self.exprs) + "}"
 return self.strRepr
 def checkRecursion( self, parseElementList ):
 subRecCheckList = parseElementList[:] + [ self ]
 try:
 self.expr.tryParse( instring, loc )
 except (ParseException,IndexError):
 pass
 else:
-#~ raise ParseException(instring, loc, self.errmsg )
+raise ParseException(instring, loc, self.errmsg, self)
-exc = self.myException
-exc.loc = loc
-exc.pstr = instring
-raise exc
 return loc, []
 def __str__( self ):
 if hasattr(self,"name"):
 return self.name
 failParse = False
 if self.ignoreExpr is not None:
 while 1:
 try:
 loc = self.ignoreExpr.tryParse(instring,loc)
-# print "found ignoreExpr, advance to", loc
+# print("found ignoreExpr, advance to", loc)
 except ParseBaseException:
 break
 expr._parse( instring, loc, doActions=False, callPreParse=False )
 skipText = instring[startLoc:loc]
 if self.includeMatch:
 except (ParseException,IndexError):
 if failParse:
 raise
 else:
 loc += 1
-exc = self.myException
+raise ParseException(instring, loc, self.errmsg, self)
-exc.loc = loc
-exc.pstr = instring
-raise exc
 class Forward(ParseElementEnhance):
 """Forward declaration of an expression to be defined later -
 used for recursive grammars, such as algebraic infix notation.
 When the expression is known, it is assigned to the C{Forward} variable using the '<<' operator.
 will actually be evaluated as::
 (fwdExpr << a) | b | c
 thereby leaving b and c out as parseable alternatives.  It is recommended that you
 explicitly group the values inserted into the C{Forward}::
 fwdExpr << (a | b | c)
+Converting to use the '<<=' operator instead will avoid this problem.
 """
 def __init__( self, other=None ):
 super(Forward,self).__init__( other, savelist=False )
-def __lshift__( self, other ):
+def __ilshift__( self, other ):
 if isinstance( other, basestring ):
-other = Literal(other)
+other = ParserElement.literalStringClass(other)
 self.expr = other
 self.mayReturnEmpty = other.mayReturnEmpty
 self.strRepr = None
 self.mayIndexError = self.expr.mayIndexError
 self.mayReturnEmpty = self.expr.mayReturnEmpty
 self.setWhitespaceChars( self.expr.whiteChars )
 self.skipWhitespace = self.expr.skipWhitespace
 self.saveAsList = self.expr.saveAsList
 self.ignoreExprs.extend(self.expr.ignoreExprs)
+return self
+def __lshift__(self, other):
+warnings.warn("Operator '<<' is deprecated, use '<<=' instead",
+DeprecationWarning,stacklevel=2)
+self <<= other
 return None
 def leaveWhitespace( self ):
 self.skipWhitespace = False
 return self
 def streamline( self ):
 super(Upcase,self).__init__(*args)
 warnings.warn("Upcase class is deprecated, use upcaseTokens parse action instead",
 DeprecationWarning,stacklevel=2)
 def postParse( self, instring, loc, tokenlist ):
-return list(map( string.upper, tokenlist ))
+return list(map( str.upper, tokenlist ))
 class Combine(TokenConverter):
 """Converter to concatenate all matching tokens to a single string.
 By default, the matching patterns must also be contiguous in the input string;
 return [ retToks ]
 else:
 return retToks
 class Group(TokenConverter):
-"""Converter to return the matched tokens as a list - useful for returning tokens of C{ZeroOrMore} and C{OneOrMore} expressions."""
+"""Converter to return the matched tokens as a list - useful for returning tokens of C{L{ZeroOrMore}} and C{L{OneOrMore}} expressions."""
 def __init__( self, expr ):
 super(Group,self).__init__( expr )
 self.saveAsList = True
 def postParse( self, instring, loc, tokenlist ):
 if len(paArgs)>3:
 thisFunc = paArgs[0].__class__.__name__ + '.' + thisFunc
 sys.stderr.write( ">>entering %s(line: '%s', %d, %s)\n" % (thisFunc,line(l,s),l,t) )
 try:
 ret = f(*paArgs)
-except Exception:
+except Exception as exc:
-exc = sys.exc_info()[1]
 sys.stderr.write( "<<leaving %s (exception: %s)\n" % (thisFunc,exc) )
 raise
 sys.stderr.write( "<<leaving %s (ret: %s)\n" % (thisFunc,ret) )
 return ret
 try:
 #
 def delimitedList( expr, delim=",", combine=False ):
 """Helper to define a delimited list of expressions - the delimiter defaults to ','.
 By default, the list elements and delimiters can have intervening whitespace, and
 comments, but this can be overridden by passing C{combine=True} in the constructor.
-If C{combine} is set to True, the matching tokens are returned as a single token
+If C{combine} is set to C{True}, the matching tokens are returned as a single token
 string, with the delimiters included; otherwise, the matching tokens are returned
 as a list of tokens, with the delimiters suppressed.
 """
 dlName = _ustr(expr)+" ["+_ustr(delim)+" "+_ustr(expr)+"]..."
 if combine:
 return _ustr(s)
 def oneOf( strs, caseless=False, useRegex=True ):
 """Helper to quickly define a set of alternative Literals, and makes sure to do
 longest-first testing when there is a conflict, regardless of the input order,
-but returns a C{MatchFirst} for best performance.
+but returns a C{L{MatchFirst}} for best performance.
 Parameters:
 - strs - a string of space-delimited literals, or a list of string literals
 - caseless - (default=False) - treat all literals as caseless
 - useRegex - (default=True) - as an optimization, will generate a Regex
 if not caseless and useRegex:
 #~ print (strs,"->", "|".join( [ _escapeRegexChars(sym) for sym in symbols] ))
 try:
 if len(symbols)==len("".join(symbols)):
-return Regex( "[%s]" % "".join( [ _escapeRegexRangeChars(sym) for sym in symbols] ) )
+return Regex( "[%s]" % "".join(_escapeRegexRangeChars(sym) for sym in symbols) )
 else:
-return Regex( "|".join( [ re.escape(sym) for sym in symbols] ) )
+return Regex( "|".join(re.escape(sym) for sym in symbols) )
 except:
 warnings.warn("Exception creating Regex for oneOf, building MatchFirst",
 SyntaxWarning, stacklevel=2)
 # last resort, just use MatchFirst
 return MatchFirst( [ parseElementClass(sym) for sym in symbols ] )
 def dictOf( key, value ):
 """Helper to easily and clearly define a dictionary by specifying the respective patterns
-for the key and value.  Takes care of defining the C{Dict}, C{ZeroOrMore}, and C{Group} tokens
+for the key and value.  Takes care of defining the C{L{Dict}}, C{L{ZeroOrMore}}, and C{L{Group}} tokens
 in the proper order.  The key pattern can include delimiting markers or punctuation,
 as long as they are suppressed, thereby leaving the significant key text.  The value
 pattern can include named results, so that the C{Dict} results can include named token
 fields.
 """
 input text. Simpler to use than the parse action C{L{keepOriginalText}}, and does not
 require the inspect module to chase up the call stack.  By default, returns a
 string containing the original parsed text.
 If the optional C{asString} argument is passed as C{False}, then the return value is a
-C{ParseResults} containing any results names that were originally matched, and a
+C{L{ParseResults}} containing any results names that were originally matched, and a
 single token containing the original matched text from the input string.  So if
 the expression passed to C{L{originalTextFor}} contains expressions with defined
 results names, you must set C{asString} to C{False} if you want to preserve those
 results name values."""
 locMarker = Empty().setParseAction(lambda s,loc,t: loc)
 lineEnd     = LineEnd().setName("lineEnd")
 stringStart = StringStart().setName("stringStart")
 stringEnd   = StringEnd().setName("stringEnd")
 _escapedPunc = Word( _bslash, r"\[]-*.$+^?()~ ", exact=2 ).setParseAction(lambda s,l,t:t[0][1])
-_printables_less_backslash = "".join([ c for c in printables if c not in  r"\]" ])
+_escapedHexChar = Regex(r"\\0?[xX][0-9a-fA-F]+").setParseAction(lambda s,l,t:unichr(int(t[0].lstrip(r'\0x'),16)))
-_escapedHexChar = Regex(r"\\0?[xX][0-9a-fA-F]+").setParseAction(lambda s,l,t:unichr(int(t[0][1:],16)))
 _escapedOctChar = Regex(r"\\0[0-7]+").setParseAction(lambda s,l,t:unichr(int(t[0][1:],8)))
-_singleChar = _escapedPunc | _escapedHexChar | _escapedOctChar | Word(_printables_less_backslash,exact=1)
+_singleChar = _escapedPunc | _escapedHexChar | _escapedOctChar | Word(printables, excludeChars=r'\]', exact=1)
 _charRange = Group(_singleChar + Suppress("-") + _singleChar)
 _reBracketExpr = Literal("[") + 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):
 r"""Helper to easily define string ranges for use in Word construction.  Borrows
 syntax from regexp '[]' string range definitions::
 srange("[0-9]")   -> "0123456789"
 an escaped octal character with a leading '\0' (\041, which is a '!' character)
 a range of any of the above, separated by a dash ('a-z', etc.)
 any combination of the above ('aeiouy', 'a-zA-Z0-9_$', etc.)
 """
 try:
-return "".join([_expanded(part) for part in _reBracketExpr.parseString(s).body])
+return "".join(_expanded(part) for part in _reBracketExpr.parseString(s).body)
 except:
 return ""
 def matchOnlyAtCol(n):
 """Helper method for defining parse actions that require matching at a specific
 raise ParseException(strg,locn,"matched token not at column %d" % n)
 return verifyCol
 def replaceWith(replStr):
 """Helper method for common parse actions that simply return a literal value.  Especially
-useful when used with C{transformString()}.
+useful when used with C{L{transformString<ParserElement.transformString>}()}.
 """
 def _replFunc(*args):
 return [replStr]
 return _replFunc
 def downcaseTokens(s,l,t):
 """Helper parse action to convert tokens to lower case."""
 return [ tt.lower() for tt in map(_ustr,t) ]
 def keepOriginalText(s,startLoc,t):
-"""DEPRECATED - use new helper method C{originalTextFor}.
+"""DEPRECATED - use new helper method C{L{originalTextFor}}.
 Helper parse action to preserve original parsed text,
 overriding any nested parse actions."""
 try:
 endloc = getTokensEndLoc()
 except ParseException:
 tagAttrValue = dblQuotedString.copy().setParseAction( removeQuotes )
 openTag = Suppress("<") + tagStr("tag") + \
 Dict(ZeroOrMore(Group( tagAttrName + Suppress("=") + tagAttrValue ))) + \
 Optional("/",default=[False]).setResultsName("empty").setParseAction(lambda s,l,t:t[0]=='/') + Suppress(">")
 else:
-printablesLessRAbrack = "".join( [ c for c in printables if c not in ">" ] )
+printablesLessRAbrack = "".join(c for c in printables if c not in ">")
 tagAttrValue = quotedString.copy().setParseAction( removeQuotes ) | Word(printablesLessRAbrack)
 openTag = Suppress("<") + tagStr("tag") + \
 Dict(ZeroOrMore(Group( tagAttrName.setParseAction(downcaseTokens) + \
 Optional( Suppress("=") + tagAttrValue ) ))) + \
 Optional("/",default=[False]).setResultsName("empty").setParseAction(lambda s,l,t:t[0]=='/') + Suppress(">")
 """Helper to construct opening and closing tag expressions for XML, given a tag name"""
 return _makeTags( tagStr, True )
 def withAttribute(*args,**attrDict):
 """Helper to create a validating parse action to be used with start tags created
-with C{makeXMLTags} or C{makeHTMLTags}. Use C{withAttribute} to qualify a starting tag
+with C{L{makeXMLTags}} or C{L{makeHTMLTags}}. Use C{withAttribute} to qualify a starting tag
 with a required attribute value, to avoid false matches on common tags such as
 C{<TD>} or C{<DIV>}.
 Call C{withAttribute} with a series of attribute names and values. Specify the list
 of filter attributes names and values as:
 opAssoc = _Constants()
 opAssoc.LEFT = object()
 opAssoc.RIGHT = object()
-def operatorPrecedence( baseExpr, opList ):
+def infixNotation( baseExpr, opList, lpar=Suppress('('), rpar=Suppress(')') ):
 """Helper method for constructing grammars of expressions made up of
 operators working in a precedence hierarchy.  Operators may be unary or
 binary, left- or right-associative.  Parse actions can also be attached
 to operator expressions.
 two operators separating the 3 terms
 - numTerms is the number of terms for this operator (must
 be 1, 2, or 3)
 - rightLeftAssoc is the indicator whether the operator is
 right or left associative, using the pyparsing-defined
-constants opAssoc.RIGHT and opAssoc.LEFT.
+constants C{opAssoc.RIGHT} and C{opAssoc.LEFT}.
 - parseAction is the parse action to be associated with
 expressions matching this operator expression (the
 parse action tuple member may be omitted)
+- lpar - expression for matching left-parentheses (default=Suppress('('))
+- rpar - expression for matching right-parentheses (default=Suppress(')'))
 """
 ret = Forward()
-lastExpr = baseExpr | ( Suppress('(') + ret + Suppress(')') )
+lastExpr = baseExpr | ( lpar + ret + rpar )
 for i,operDef in enumerate(opList):
 opExpr,arity,rightLeftAssoc,pa = (operDef + (None,))[:4]
 if arity == 3:
 if opExpr is None or len(opExpr) != 2:
 raise ValueError("if numterms=3, opExpr must be a tuple or list of two expressions")
 matchExpr.setParseAction( pa )
 thisExpr << ( matchExpr | lastExpr )
 lastExpr = thisExpr
 ret << lastExpr
 return ret
+operatorPrecedence = infixNotation
 dblQuotedString = Regex(r'"(?:[^"\n\r\\]|(?:"")|(?:\\x[0-9a-fA-F]+)|(?:\\.))*"').setName("string enclosed in double quotes")
 sglQuotedString = Regex(r"'(?:[^'\n\r\\]|(?:'')|(?:\\x[0-9a-fA-F]+)|(?:\\.))*'").setName("string enclosed in single quotes")
 quotedString = Regex(r'''(?:"(?:[^"\n\r\\]|(?:"")|(?:\\x[0-9a-fA-F]+)|(?:\\.))*")|(?:'(?:[^'\n\r\\]|(?:'')|(?:\\x[0-9a-fA-F]+)|(?:\\.))*')''').setName("quotedString using single or double quotes")
 unicodeString = Combine(_L('u') + quotedString.copy())
 dblSlashComment = Regex(r"\/\/(\\\n|.)*").setName("// comment")
 cppStyleComment = Regex(r"/(?:\*(?:[^*]*\*+)+?/|/[^\n]*(?:\n[^\n]*)*?(?:(?<!\\)|\Z))").setName("C++ style comment")
 javaStyleComment = cppStyleComment
 pythonStyleComment = Regex(r"#.*").setName("Python style comment")
-_noncomma = "".join( [ c for c in printables if c != "," ] )
+_commasepitem = Combine(OneOrMore(Word(printables, excludeChars=',') +
-_commasepitem = Combine(OneOrMore(Word(_noncomma) +
 Optional( Word(" \t") +
 ~Literal(",") + ~LineEnd() ) ) ).streamline().setName("commaItem")
 commaSeparatedList = delimitedList( Optional( quotedString.copy() | _commasepitem, default="") ).setName("commaSeparatedList")
 print (teststring + "->"   + str(tokenlist))
 print ("tokens = "         + str(tokens))
 print ("tokens.columns = " + str(tokens.columns))
 print ("tokens.tables = "  + str(tokens.tables))
 print (tokens.asXML("SQL",True))
-except ParseBaseException:
+except ParseBaseException as err:
-err = sys.exc_info()[1]
 print (teststring + "->")
 print (err.line)
 print (" "*(err.column-1) + "^")
 print (err)
 print()

Mercurial > dottes

comparison abc2xml/pyparsing.py @ 1084:b1dbb76f4eb9 build-default-404