parsers.py

Go to the documentation of this file.

#............................................................................
# Copyright (c) 2009,2010,2011 David Car, david.car7@gmail.com
#
# This program is free software; you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation; either version 2 of the License, or (at your option) any later
# version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 59 Temple
# Place, Suite 330, Boston, MA 02111-1307 USA
#..........................................................................
__all__ = ['BlockParser', 'BlockParserError']

from tables import SymbolTable
from scanners import LineScanner
import external.pyparsing as pyp

class BlockParserError(Exception):
    def __init__(self, msg):
        self.msg = msg
    def __str__(self):
        return repr(self.msg)

#................................................................................
# Block parser
#................................................................................
class BlockParser(object):
    
    def __init__(self, scanner=None, ignoreChars='', contChar=None ):
        self._scanner = scanner
        self._blockDict = {}
        self._blockList = []
        self._ignore = ignoreChars
        self._contChar = contChar
        self._GRAMMAR = None
    
    def setScanner(self, scanner):
        '''Set the scanner to use.

        '''
        self._scanner = scanner

    def parse(self):
        raise NotImplementedError("Virtual method 'parse()' in BlockParser")

    def ignore(self, line):
        '''Ignore lines starting with comment character and null strings. 

        '''
        return any([line.startswith(x) for x in self._ignore]) or not line

    def _parse(self, blk):
        scanner = self._scanner
        GRAMMAR = self._GRAMMAR
        contChar = self._contChar
        ignore = self.ignore

        # Keep reading until the end of the block is reached or a new block is
        # found and a branch is made
        _multi_line = None
        while True:
            #.........................
            # Check for comment line
            #.........................
            _line = scanner.nextLine()
            if ignore( _line.lstrip() ):
                blk.addLine( _line )
                continue

            #......................................................
            # Check for continuation character and concatenate
            #......................................................
            line = ''
            if contChar is not None:
                _cont = True
                _multi_line = []
                _multi_line.append( _line )
                while _cont:
                    _loc = _line.rfind( contChar )
                    if _loc != -1 and ignore(_line[_loc+1:].lstrip()):
                        line += _line[ :_loc ]
                        _multi_line.append( scanner.nextLine() )
                        _line = _multi_line[-1].lstrip(' '+contChar)
                    else:
                        line += _line
                        _cont = False
            else:
                line += _line
                    
            #....................
            # Check for sentinel
            #....................
            if blk.sentinel( line ): break

            newBlk = GRAMMAR.searchString( line )
            if newBlk:
                newBlk = newBlk[ 0 ][ 0 ]
                if _multi_line: 
                    newBlk.addLine( ''.join( _multi_line ) )
                else:
                    newBlk.addLine( line )

                #...........................................................
                # The addChild method is called prior to parsing so that
                # dependencies are not generated for blocks within
                # templates, since template status is determined by the
                # enclosing block/scope.  Dependencies are shared with the
                # enclosing block/scope by the shareDeps() method after
                # parsing of the block.  The dependencies are only shared
                # with the parent and not propagated up the tree.
                #...........................................................
                blk.addChild( newBlk )

                try:
                    self._parse( newBlk )
                except EOFError:
                    msg = 'Block (%s) not closed properly'%( newBlk.name(), )
                    raise BlockParserError(msg) 
                    
                newBlk.shareDeps( propagate=False )
                line = ''  # empty line
                
            if line: 
                if _multi_line: 
                    blk.addLine( ''.join( _multi_line ) )
                else: 
                    blk.addLine( line )

    def register(self, block):
        '''Register a block or list of blocks.

        '''
        if isinstance(block, list):
            for blk in block:
                blk.GRAMMAR.setParseAction(blk.factory)
                self._GRAMMAR = \
                    (self._GRAMMAR is None) and \
                    blk.GRAMMAR or \
                    (blk.GRAMMAR|self._GRAMMAR)
                self._blockDict[blk.BLOCKTYPE] = block
            self._blockList.extend(block)
        else:
            block.GRAMMAR.setParseAction(block.factory)
            self._blockList.append(block)
            self._GRAMMAR = \
                (self._GRAMMAR is None) and \
                block.GRAMMAR or \
                (block.GRAMMAR|self._GRAMMAR)
            self._blockDict[block.BLOCKTYPE] = block