Typo in README. Parser updates.
authorFrederic Jolliton <frederic@jolliton.com>
Thu, 21 Jul 2005 12:31:39 +0000 (12:31 +0000)
committerFrederic Jolliton <frederic@jolliton.com>
Thu, 21 Jul 2005 12:31:39 +0000 (12:31 +0000)
Parser in basicparser:

 * Allow list (or tuple) as tokens regex in addition to dictionary.
   This is mainly to ensure that regex are checked in a determinist
   order.

 * Renamed members variable with '__' prefix where appropriate.

Misc:

 * Small typo in README.
git-archimport-id: frederic@jolliton.com--2005-private/confparser--main--0.1--patch-17

README
basicparser.py
confparser_ext.py

diff --git a/README b/README
index 85832af..c37ca20 100644 (file)
--- a/README
+++ b/README
@@ -72,7 +72,7 @@ all the top elements of the configuration.
 
 But it's not practical to work with such structure.
 
-A recent addition to confparser allow to get an object tree (mode of
+A recent addition to confparser allow to get an object tree (made of
 NodeSet/Node objects) instead of this raw structure (which is made of
 list, tuple, string and integer.) The function parseExt do that.
 
index 5952f4a..b9350da 100644 (file)
@@ -20,7 +20,6 @@
 #
 
 import re
-import types
 
 #-----------------------------------------------------------------------------
 
@@ -28,25 +27,37 @@ class ParserError( Exception ) : pass
 
 class Parser :
 
-       def __init__( self , tokens , text ) :
+       def __init__( self , tokens , text , defaultRegexFlags = 0 ) :
 
-               self.tokenMatches = {}
-               for k , v in tokens.items() :
-                       if type( v ) in types.StringTypes :
-                               v = re.compile( v )
-                       self.tokenMatches[ k ] = v
-               self.text = text
-               self.pos = 0
-               self.tokensToIgnore = ()
-               self.x = 1
-               self.y = 1
+               '''Create an instance to tokenise 'text' with tokens 'tokens'.'''
+
+               self.__tokenMatches = {}
+               self.__keys = []
+               if isinstance( tokens , dict ) :
+                       tokens = tokens.items()
+               self.__keys = map( lambda e : e[ 0 ] , tokens )
+               for k , v in tokens :
+                       if isinstance( v , ( str , unicode ) ) :
+                               v = re.compile( v , defaultRegexFlags )
+                       self.__tokenMatches[ k ] = v
+               self.__text = text
+               self.__pos = 0
+               self.__tokensToIgnore = ()
+               self.__x = 1
+               self.__y = 1
+
+       def __getX( self ) : return self.__x
+       def __getY( self ) : return self.__y
+
+       x = property( __getX )
+       y = property( __getY )
 
        def ignore( self , *tokens ) :
 
                '''Declare tokens 'tokens' as tokens to ignore when
                parsing.'''
 
-               self.tokensToIgnore = tokens
+               self.__tokensToIgnore = tokens
 
        def peek( self , *set ) :
 
@@ -56,32 +67,32 @@ class Parser :
 
                tokens = []
                if not set :
-                       set = self.tokenMatches.keys()
+                       set = self.__keys
                for tokenName in set :
-                       tokenMatch = self.tokenMatches.get( tokenName )
+                       tokenMatch = self.__tokenMatches.get( tokenName )
                        if tokenMatch :
-                               m = tokenMatch.match( self.text , self.pos )
+                               m = tokenMatch.match( self.__text , self.__pos )
                                if m :
                                        tk = m.group( 0 )
                                        tokens.append( ( tokenName , tk ) )
                tokens.sort( lambda a , b : cmp( len( a[ 1 ] ) , len( b[ 1 ] ) ) )
                return tokens
 
-       def advance( self , n ) :
+       def __advance( self , n ) :
 
                '''Update current position (line,column) for the 'n'
                next characters (if 'n' is an integer, or for the length of
                the 'n' string otherwise.)'''
 
-               if type( n ) in types.StringTypes :
+               if isinstance( n , ( str , unicode ) ) :
                        n = len( n )
-               p = self.text.rfind( '\n' , self.pos , self.pos + n )
+               p = self.__text.rfind( '\n' , self.__pos , self.__pos + n )
                if p == -1 :
-                       self.x += n
+                       self.__x += n
                else :
-                       self.x = self.pos + n - p
-                       self.y += self.text.count( '\n' , self.pos , self.pos + n )
-               self.pos += n
+                       self.__x = self.__pos + n - p
+                       self.__y += self.__text.count( '\n' , self.__pos , self.__pos + n )
+               self.__pos += n
 
        def snext( self , *set ) :
 
@@ -89,17 +100,17 @@ class Parser :
                (or only from one of set 'set' if specified.) If no tokens
                match, None is returned.'''
 
-               set += self.tokensToIgnore
+               set += self.__tokensToIgnore
                r = None
                while 1 :
                        r = self.peek( *set )
                        if not r :
                                break
                        r = r[ 0 ]
-                       self.advance( r[ 1 ] )
-                       if r[ 0 ] not in self.tokensToIgnore :
+                       self.__advance( r[ 1 ] )
+                       if r[ 0 ] not in self.__tokensToIgnore :
                                break
-               return r
+               return r or None
 
        def next( self , *set ) :
 
@@ -122,21 +133,21 @@ class Parser :
 
                '''Return current position in a texture representation.'''
 
-               return 'at line %d, column %d' % ( self.y , self.x )
+               return 'at line %d, column %d' % ( self.__y , self.__x )
 
        def point( self ) :
 
                '''Return a multiple-line string to show where an error
                happened.'''
 
-               lineStart = self.text.rfind( '\n' , 0 , self.pos + 1 ) + 1
-               lineEnd = self.text.find( '\n' , self.pos + 1 )
+               lineStart = self.__text.rfind( '\n' , 0 , self.__pos + 1 ) + 1
+               lineEnd = self.__text.find( '\n' , self.__pos + 1 )
                if lineEnd == -1 :
-                       lineEnd = len( self.text )
-               prefix = 'line %s: ' % self.y
+                       lineEnd = len( self.__text )
+               prefix = 'line %s: ' % self.__y
                r = ''
-               r += prefix + self.text[ lineStart : lineEnd ].replace( '\t' , ' ' ) + '\n'
-               r += prefix + ' ' * ( self.pos - lineStart ) + '^' + '\n'
+               r += prefix + self.__text[ lineStart : lineEnd ].replace( '\t' , ' ' ) + '\n'
+               r += prefix + ' ' * ( self.__pos - lineStart ) + '^' + '\n'
                return r
 
 # Local Variables:
index e6a0443..c7d92ef 100644 (file)
@@ -158,9 +158,6 @@ def confToNodeset( node ) :
 
        return NodeSet( confToNodeset_( node ) )
 
-#
-# FIXME: UGLY
-#
 def select( nodeset , path ) :
 
        def matchValue_( match , value ) :