Thread: SF.net SVN: matplotlib: [5380] trunk/matplotlib (Page 12)

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

Revision: 5380
          http://matplotlib.svn.sourceforge.net/matplotlib/?rev=5380&view=rev
Author:   mdboom
Date:     2008-06-04 06:09:55 -0700 (Wed, 04 Jun 2008)

Log Message:
-----------
Update pyparsing to get better error reporting from mathtext.  Update
mathtext_examples to include "$$" as a test.

Modified Paths:
--------------
    trunk/matplotlib/examples/pylab_examples/mathtext_examples.py
    trunk/matplotlib/lib/matplotlib/mathtext.py
    trunk/matplotlib/lib/matplotlib/pyparsing.py

Modified: trunk/matplotlib/examples/pylab_examples/mathtext_examples.py
===================================================================

--- trunk/matplotlib/examples/pylab_examples/mathtext_examples.py	2008-06-03 20:57:02 UTC (rev 5379)
+++ trunk/matplotlib/examples/pylab_examples/mathtext_examples.py	2008-06-04 13:09:55 UTC (rev 5380)
@@ -5,7 +5,7 @@
 import gc
 
 stests = [
-    r'Kerning: AVA $AVA$',
+    r'Kerning: AVA $AVA$ $$',
     r'\$100.00 $\alpha \_$',
     r'$\frac{\$100.00}{y}$',
     r'$x   y$',

Modified: trunk/matplotlib/lib/matplotlib/mathtext.py
===================================================================
--- trunk/matplotlib/lib/matplotlib/mathtext.py	2008-06-03 20:57:02 UTC (rev 5379)
+++ trunk/matplotlib/lib/matplotlib/mathtext.py	2008-06-04 13:09:55 UTC (rev 5380)
@@ -2024,7 +2024,7 @@
 
         lbrace       = Literal('{').suppress()
         rbrace       = Literal('}').suppress()
-        start_group  = (Optional(latexfont) + lbrace)
+        start_group  = (Optional(latexfont) - lbrace)
         start_group.setParseAction(self.start_group)
         end_group    = rbrace.copy()
         end_group.setParseAction(self.end_group)
@@ -2049,9 +2049,9 @@
                       ).setParseAction(self.space).setName('space')
 
         customspace  =(Literal(r'\hspace')
-                     + (( lbrace
-                        + float
-                        + rbrace
+                     - (( lbrace
+                        - float
+                        - rbrace
                        ) | Error(r"Expected \hspace{n}"))
                      ).setParseAction(self.customspace).setName('customspace')
 
@@ -2070,7 +2070,7 @@
         accent       = Group(
                          Suppress(bslash)
                        + accent
-                       + placeable
+                       - placeable
                      ).setParseAction(self.accent).setName("accent")
 
         function     =(Suppress(bslash)
@@ -2082,7 +2082,7 @@
                        + ZeroOrMore(
                            autoDelim
                          | simple)
-                       + end_group
+                       - end_group
                      ).setParseAction(self.group).setName("group")
 
         font        <<(Suppress(bslash)
@@ -2101,20 +2101,30 @@
                        Suppress(Literal(r"\sqrt"))
                      + Optional(
                          Suppress(Literal("["))
-                       + Regex("[0-9]+")
-                       + Suppress(Literal("]")),
+                       - Regex("[0-9]+")
+                       - Suppress(Literal("]")),
                          default = None
                        )
                      + (group | Error("Expected \sqrt{value}"))
                      ).setParseAction(self.sqrt).setName("sqrt")
 
+        print (accent
+         ^ function
+         ^ (c_over_c | symbol)
+         ^ group
+         ^ frac
+         ^ sqrt
+         ) | Error("Expected symbol or group")
+
+        print Error("Expected symbol or group")
+
         placeable   <<(accent
                      ^ function
                      ^ (c_over_c | symbol)
                      ^ group
                      ^ frac
                      ^ sqrt
-                     ) | Error("Expected symbol or group")
+                     )
 
         simple      <<(space
                      | customspace
@@ -2128,7 +2138,7 @@
                          ( Optional(placeable)
                          + OneOrMore(
                              subsuperop
-                           + placeable
+                           - placeable
                            )
                          )
                        | placeable
@@ -2160,7 +2170,7 @@
             non_math
           + ZeroOrMore(
                 Suppress(math_delim)
-              + math
+              + Optional(math)
               + (Suppress(math_delim)
                  | Error("Expected end of math '$'"))
               + non_math

Modified: trunk/matplotlib/lib/matplotlib/pyparsing.py
===================================================================
--- trunk/matplotlib/lib/matplotlib/pyparsing.py	2008-06-03 20:57:02 UTC (rev 5379)
+++ trunk/matplotlib/lib/matplotlib/pyparsing.py	2008-06-04 13:09:55 UTC (rev 5380)
@@ -1,6 +1,6 @@
 # module pyparsing.py
 #
-# Copyright (c) 2003-2007  Paul T. McGuire
+# Copyright (c) 2003-2008  Paul T. McGuire
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -58,8 +58,8 @@
  - embedded comments
 """
 
-__version__ = "1.4.8"
-__versionTime__ = "7 October 2007 00:25"
+__version__ = "1.5.0"
+__versionTime__ = "28 May 2008 10:05"
 __author__ = "Paul McGuire <pt...@us...>"
 
 import string
@@ -68,50 +68,68 @@
 import warnings
 import re
 import sre_constants
-try:
-    from xml.sax.saxutils import escape as xml_escape
-except ImportError:
-    def xml_escape(data, entities={}):
-        """Escape &, <, and > in a string of data.
+import xml.sax.saxutils
+#~ sys.stderr.write( "testing pyparsing module, version %s, %s\n" % (__version__,__versionTime__ ) )
 
-        You can escape other strings of data by passing a dictionary as
-        the optional entities parameter.  The keys and values must all be
-        strings; each key will be replaced with its corresponding value.
-        """
+__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',
+]
 
-        # must do ampersand first
-        data = data.replace("&", "&amp;")
-        data = data.replace(">", "&gt;")
-        data = data.replace("<", "&lt;")
-        if entities:
-            data = __dict_replace(data, entities)
-        return data
 
-#~ sys.stderr.write( "testing pyparsing module, version %s, %s\n" % (__version__,__versionTime__ ) )
+"""
+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
 
-def _ustr(obj):
-    """Drop-in replacement for str(obj) that tries to be Unicode friendly. It first tries
-       str(obj). If that fails with a UnicodeEncodeError, then it tries unicode(obj). It
-       then < returns the unicode object | encodes it with the default encoding | ... >.
-    """
-    try:
-        # If this works, then _ustr(obj) has the same behaviour as str(obj), so
-        # it won't break any existing code.
-        return str(obj)
+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 | ... >.
+        """
+        try:
+            # If this works, then _ustr(obj) has the same behaviour as str(obj), so
+            # it won't break any existing code.
+            return str(obj)
 
-    except UnicodeEncodeError, e:
-        # The Python docs (http://docs.python.org/ref/customization.html#l2h-182)
-        # state that "The return value must be a string object". However, does a
-        # unicode object (being a subclass of basestring) count as a "string
-        # object"?
-        # If so, then return a unicode object:
-        return unicode(obj)
-        # Else encode it... but how? There are many choices... :)
-        # Replace unprintables with escape codes?
-        #return unicode(obj).encode(sys.getdefaultencoding(), 'backslashreplace_errors')
-        # Replace unprintables with question marks?
-        #return unicode(obj).encode(sys.getdefaultencoding(), 'replace')
-        # ...
+        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(sys.getdefaultencoding(), 'backslashreplace_errors')
+            # Replace unprintables with question marks?
+            #return unicode(obj).encode(sys.getdefaultencoding(), 'replace')
+            # ...
+else:
+    _ustr = str
 
 def _str2dict(strg):
     return dict( [(c,0) for c in strg] )
@@ -120,10 +138,15 @@
 class _Constants(object):
     pass
 
-alphas     = string.lowercase + string.uppercase
+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 = "\\"
+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"""
@@ -153,7 +176,7 @@
         elif( aname == "line" ):
             return line( self.loc, self.pstr )
         else:
-            raise AttributeError, aname
+            raise AttributeError(aname)
 
     def __str__( self ):
         return "%s (at char %d), (line:%d, col:%d)" % \
@@ -185,6 +208,14 @@
        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:
@@ -283,31 +314,72 @@
             self.__toklist[k] = v
             sub = v
         else:
-            self.__tokdict[k] = self.__tokdict.get(k,list()) + [(v,0)]
+            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 self.__tokdict.has_key(k)
+        return k in self.__tokdict
 
     def __len__( self ): return len( self.__toklist )
     def __bool__(self): return len( self.__toklist ) > 0
-    def __nonzero__( self ): return self.__bool__()
+    __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 > j))
+
     def items( self ):
         """Returns all named result keys and values as a list of tuples."""
-        return [(k,self[k]) for k in self.__tokdict.keys()]
+        return [(k,self[k]) for k in self.__tokdict]
 
     def values( self ):
         """Returns all named result values."""
@@ -315,7 +387,7 @@
 
     def __getattr__( self, name ):
         if name not in self.__slots__:
-            if self.__tokdict.has_key( name ):
+            if name in self.__tokdict:
                 if name not in self.__accumNames:
                     return self.__tokdict[name][-1][0]
                 else:
@@ -446,7 +518,7 @@
                         continue
                     else:
                         resTag = "ITEM"
-                xmlBodyText = xml_escape(_ustr(res))
+                xmlBodyText = xml.sax.saxutils.escape(_ustr(res))
                 out += [ nl, nextLevelIndent, "<", resTag, ">",
                                                 xmlBodyText,
                                                 "</", resTag, ">" ]
@@ -559,13 +631,13 @@
         return strg[lastCR+1:]
 
 def _defaultStartDebugAction( instring, loc, expr ):
-    print "Match",_ustr(expr),"at loc",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),"->",toks.asList()
+    print ("Matched " + _ustr(expr) + " -> " + str(toks.asList()))
 
 def _defaultExceptionDebugAction( instring, loc, expr, exc ):
-    print "Exception raised:", _ustr(exc)
+    print ("Exception raised:" + _ustr(exc))
 
 def nullDebugAction(*args):
     """'Do-nothing' debug action, to suppress debugging output during parsing."""
@@ -652,7 +724,7 @@
                 self._parse = self._parse._originalParseMethod
         return self
 
-    def normalizeParseActionArgs( f ):
+    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
@@ -662,34 +734,63 @@
             if isinstance(f,type):
                 restore = f
                 f = f.__init__
-            if f.func_code.co_flags & STAR_ARGS:
+            if not _PY3K:
+                codeObj = f.func_code
+            else:
+                codeObj = f.code
+            if codeObj.co_flags & STAR_ARGS:
                 return f
-            numargs = f.func_code.co_argcount
-            if hasattr(f,"im_self"):
-                numargs -= 1
+            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 f.__call__.im_func.func_code.co_flags & STAR_ARGS:
+                if call_im_func_code.co_flags & STAR_ARGS:
                     return f
-                numargs = f.__call__.im_func.func_code.co_argcount
-                if hasattr(f.__call__,"im_self"):
-                    numargs -= 1
+                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 f.__call__.func_code.co_flags & STAR_ARGS:
+                if call_func_code.co_flags & STAR_ARGS:
                     return f
-                numargs = f.__call__.func_code.co_argcount
-                if hasattr(f.__call__,"im_self"):
-                    numargs -= 1
+                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)
+
+        #~ 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)
@@ -701,21 +802,21 @@
                     return f()
             try:
                 tmp.__name__ = f.__name__
-            except AttributeError:
+            except (AttributeError,TypeError):
                 # no need for special handling if attribute doesnt exist
                 pass
             try:
                 tmp.__doc__ = f.__doc__
-            except AttributeError:
+            except (AttributeError,TypeError):
                 # no need for special handling if attribute doesnt exist
                 pass
             try:
                 tmp.__dict__.update(f.__dict__)
-            except AttributeError:
+            except (AttributeError,TypeError):
                 # no need for special handling if attribute doesnt exist
                 pass
             return tmp
-    normalizeParseActionArgs = staticmethod(normalizeParseActionArgs)
+    _normalizeParseActionArgs = staticmethod(_normalizeParseActionArgs)
 
     def setParseAction( self, *fns, **kwargs ):
         """Define action to perform when successfully matching parse element definition.
@@ -734,13 +835,13 @@
            consistent view of the parsed string, the parse location, and line and column
            positions within the parsed string.
            """
-        self.parseAction = map(self.normalizeParseActionArgs, list(fns))
+        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 += map(self.normalizeParseActionArgs, list(fns))
+        self.parseAction += list(map(self._normalizeParseActionArgs, list(fns)))
         self.callDuringTry = self.callDuringTry or ("callDuringTry" in kwargs and kwargs["callDuringTry"])
         return self
 
@@ -757,7 +858,7 @@
         self.failAction = fn
         return self
 
-    def skipIgnorables( self, instring, loc ):
+    def _skipIgnorables( self, instring, loc ):
         exprsFound = True
         while exprsFound:
             exprsFound = False
@@ -772,7 +873,7 @@
 
     def preParse( self, instring, loc ):
         if self.ignoreExprs:
-            loc = self.skipIgnorables( instring, loc )
+            loc = self._skipIgnorables( instring, loc )
 
         if self.skipWhitespace:
             wt = self.whiteChars
@@ -793,7 +894,7 @@
         debugging = ( self.debug ) #and doActions )
 
         if debugging or self.failAction:
-            #~ print "Match",self,"at loc",loc,"(%d,%d)" % ( lineno(loc,instring), col(loc,instring) )
+            #~ print ("Match",self,"at loc",loc,"(%d,%d)" % ( lineno(loc,instring), col(loc,instring) ))
             if (self.debugActions[0] ):
                 self.debugActions[0]( instring, loc, self )
             if callPreParse and self.callPreparse:
@@ -806,8 +907,8 @@
                     loc,tokens = self.parseImpl( instring, preloc, doActions )
                 except IndexError:
                     raise ParseException( instring, len(instring), self.errmsg, self )
-            except ParseException, err:
-                #~ print "Exception raised:", err
+            except ParseBaseException, err:
+                #~ print ("Exception raised:", err)
                 if self.debugActions[2]:
                     self.debugActions[2]( instring, tokensStart, self, err )
                 if self.failAction:
@@ -840,7 +941,7 @@
                                                       self.resultsName,
                                                       asList=self.saveAsList and isinstance(tokens,(ParseResults,list)),
                                                       modal=self.modalResults )
-                except ParseException, err:
+                except ParseBaseException, err:
                     #~ print "Exception raised in user parse action:", err
                     if (self.debugActions[2] ):
                         self.debugActions[2]( instring, tokensStart, self, err )
@@ -855,14 +956,17 @@
                                                   modal=self.modalResults )
 
         if debugging:
-            #~ print "Matched",self,"->",retTokens.asList()
+            #~ print ("Matched",self,"->",retTokens.asList())
             if (self.debugActions[1] ):
                 self.debugActions[1]( instring, tokensStart, loc, self, retTokens )
 
         return loc, retTokens
 
     def tryParse( self, instring, loc ):
-        return self._parse( instring, loc, doActions=False )[0]
+        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
@@ -871,10 +975,8 @@
         if lookup in ParserElement._exprArgCache:
             value = ParserElement._exprArgCache[ lookup ]
             if isinstance(value,Exception):
-                if isinstance(value,ParseBaseException):
-                    value.loc = loc
                 raise value
-            return (value[0],value[1].copy())
+            return value
         else:
             try:
                 value = self._parseNoCache( instring, loc, doActions, callPreParse )
@@ -914,11 +1016,15 @@
             ParserElement._parse = ParserElement._parseCache
     enablePackrat = staticmethod(enablePackrat)
 
-    def parseString( self, instring ):
+    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
@@ -938,13 +1044,14 @@
             #~ self.saveAsList = True
         for e in self.ignoreExprs:
             e.streamline()
-        if self.keepTabs:
-            loc, tokens = self._parse( instring, 0 )
-        else:
-            loc, tokens = self._parse( instring.expandtabs(), 0 )
+        if not self.keepTabs:
+            instring = instring.expandtabs()
+        loc, tokens = self._parse( instring, 0 )
+        if parseAll:
+            StringEnd()._parse( instring, loc )
         return tokens
 
-    def scanString( self, instring, maxMatches=sys.maxint ):
+    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.
@@ -1001,7 +1108,7 @@
         out.append(instring[lastE:])
         return "".join(map(_ustr,out))
 
-    def searchString( self, instring, maxMatches=sys.maxint ):
+    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.
@@ -1013,35 +1120,117 @@
         if isinstance( other, basestring ):
             other = Literal( other )
         if not isinstance( other, ParserElement ):
-            warnings.warn("Cannot add element of type %s to ParserElement" % type(other),
+            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"""
+        """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 add element of type %s to ParserElement" % type(other),
+            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):
+            if len(other)==0:
+                other = (None,None)
+            elif len(other)==1:
+                other = (other[0],None)
+            if len(other)==2:
+                if other[0] is None:
+                    other = (0, other[1])
+                if isinstance(other[0],int) and other[1] is None:
+                    if other[0] == 0:
+          ...
 
[truncated message content]

Thread: SF.net SVN: matplotlib: [5380] trunk/matplotlib (Page 12)

matplotlib-checkins