owl-basic 0.6.0__py3-none-any.whl

owl_basic/simplify_visitor.py

@@ -0,0 +1,204 @@
+import logging
+
+from owl_basic.utility import camelCaseToUnderscores
+from owl_basic.visitor import Visitor
+from owl_basic.node import *
+from owl_basic.options import *
+from owl_basic.ast_utils import elideNode, insertStatementAfter
+from owl_basic.syntax.ast import StatementList, Next
+
+logger = logging.getLogger('simplify_visitor')
+
+class SimplifyStatementListVisitor(Visitor):
+    """
+    Visitor for simplifying nested StatementList nodes by flattening the
+    list of statements.
+    """
+    def __init__(self):
+        self._accumulated_statements = []
+    
+    def visitAstNode(self, node):
+        if node is not None:
+            self._accumulated_statements.append(node)
+            
+    def visitStatementList(self, statement_list):
+        statement_list.forEachChild(self.visit)
+        
+    def visitAstStatement(self, statement):
+        self._accumulated_statements.append(statement)
+                    
+    def _accumulatedStatements(self):
+        return self._accumulated_statements;
+    
+    accumulatedStatements = property(_accumulatedStatements)
+    
+class SimplificationVisitor(Visitor):
+    """
+    AST visitor for simplifying the AST, by removing redundant nodes.
+    """
+    
+    def visitAstNode(self, node):
+        node.forEachChild(self.visit)
+    
+    def visitStatementList(self, statement_list):
+        "Flatten nested StatementLists and remove Statement nodes."
+        if not hasattr(statement_list, "parent"):
+            print(statement_list.statements)
+            assert 0
+        sslv = SimplifyStatementListVisitor()
+        sslv.visit(statement_list)
+        statement_list.statements = sslv.accumulatedStatements
+        for index, statement in enumerate(statement_list.statements):
+            statement.parent = statement_list
+            statement.parent_property = "statements"
+            statement.parent_index = index
+            self.visit(statement)
+            
+        statement_list.parent.child_infos["statements"] = statement_list.child_infos["statements"]
+        assert hasattr(statement_list, "statements")
+        statement_list.parent.statements = statement_list.statements
+    
+    def visitIf(self, iff):
+        if isinstance(iff.trueClause, StatementList):
+            sslv = SimplifyStatementListVisitor()
+            sslv.visit(iff.trueClause)
+            iff.child_infos['true_clause'] = iff.trueClause.child_infos['statements']
+            iff.trueClause = sslv.accumulatedStatements
+            if len(iff.trueClause) == 0:
+                iff.trueClause = None
+            else:
+                for index, statement in enumerate(iff.trueClause):
+                    statement.parent = iff
+                    statement.parent_property = 'trueClause'
+                    statement.parent_index = index
+                    self.visit(statement)
+        else:
+            self.visit(iff.trueClause)
+                
+        if isinstance(iff.falseClause, StatementList):
+            sslv = SimplifyStatementListVisitor()
+            sslv.visit(iff.falseClause)
+            iff.child_infos['false_clause'] = iff.falseClause.child_infos['statements']
+            iff.falseClause = sslv.accumulatedStatements
+            if len(iff.falseClause) == 0:
+                iff.falseClause = None
+            else:
+                for index, statement in enumerate(iff.falseClause):
+                    statement.parent = iff
+                    statement.parent_property = 'falseClause'
+                    statement.parent_index = index
+                    self.visit(statement)
+        else:
+            self.visit(iff.falseClause)
+                    
+        self.visit(iff.condition)
+    
+    def visitOnGoto(self, ongoto):
+        if ongoto.outOfRangeClause is not None:
+            if isinstance(ongoto.outOfRangeClause, StatementList):
+                sslv = SimplifyStatementListVisitor()
+                sslv.visit(ongoto.outOfRangeClause)
+                ongoto.child_infos['out_of_range_clause'] = ongoto.outOfRangeClause.child_infos['statements']
+                ongoto.outOfRangeClause = sslv.accumulatedStatements
+                if len(ongoto.outOfRangeClause) == 0:
+                    ongoto.outOfRangeClause = None
+                else:
+                    for index, statement in enumerate(ongoto.outOfRangeClause):
+                        statement.parent = ongoto
+                        statement.parent_property = 'outOfRangeClause'
+                        statement.parent_index = index
+                        self.visit(statement)
+            else:
+                self.visit(ongoto.outOfRangeClause)
+                
+        self.visit(ongoto.switch)
+        self.visit(ongoto.targetLogicalLines)
+            
+    def visitCase(self, case):
+        "Remove the WhenClauseList level from the AST"
+        case.child_infos["when_clauses"] = case.whenClauses.child_infos["clauses"]
+        case.whenClauses = case.whenClauses.clauses
+        for clause in case.whenClauses:
+            clause.parent = case
+            self.visit(clause)
+            
+    def visitMarkerStatement(self, marker):
+        """
+        Remove the followingStatement from the Repeat, DefineProcedure, etc, moving it to immediately
+        after the statement in the parent StatementList
+        """
+        logger.debug("visitMarkerStatement %s at line number %s", marker, marker.lineNum)
+        if marker.followingStatement is not None:
+            following = marker.followingStatement
+            marker.followingStatement = None
+            insertStatementAfter(marker, following)
+            # TODO: Does the moved statement node ever get visited? Are we inserting into a sequence during iteration?
+            #self.visit(following)
+                   
+    def visitExpressionList(self, expr_list):
+        """
+        Remove ExpressionList level from the AST by replacing the contents of
+        the owning attribute of its parents with the ExpressionList's own list of expressions 
+        """
+        expr_list.forEachChild(self.visit)
+        elideNode(expr_list, liftFormalTypes=True)
+        
+    def visitVduList(self, vdu_list):
+        """
+        Remove VduList level from the AST by replacing the contents of
+        the owning attribute of its parent with the VduList's own list of items 
+        """
+        vdu_list.forEachChild(self.visit)
+        elideNode(vdu_list, liftFormalTypes=True)
+
+    def visitActualArgList(self, actual_arg_list):
+        """
+        Remove the ActualArgList level from the AST by replacing the contents of
+        the owning attribute of its parent with the ActualArgList's own list of arguments
+        """
+        actual_arg_list.forEachChild(self.visit)
+        elideNode(actual_arg_list, liftFormalTypes=True)
+
+    def visitFormalArgList(self, formal_arg_list):
+        """
+        Remove the FormalArgList level from the AST by replacing the contents of
+        the owning attribute of its parent with the FormalArgList's own list of arguments
+        """
+        formal_arg_list.forEachChild(self.visit)
+        elideNode(formal_arg_list, liftFormalTypes=True)
+        
+    def visitPrintList(self, print_list):
+        """
+        Remove the PrintList level from the AST by replacing the contents of the
+        owning attribute of its parent.
+        """
+        print_list.forEachChild(self.visit)
+        elideNode(print_list, liftFormalTypes=True)
+    
+    def visitInputList(self, input_list):
+        """
+        Remove the InputList level from the AST by replacing the contents of the
+        owning attribute of its parent.
+        """
+        input_list.forEachChild(self.visit)
+        elideNode(input_list, liftFormalTypes=True)
+        
+    def visitVariableList(self, variable_list):
+        """
+        Remove the VariableList level from the AST by replacing the contents of the
+        owning attribute of its parent.
+        """
+        variable_list.forEachChild(self.visit)
+        elideNode(variable_list, liftFormalTypes=True)
+    
+    def visitExpressionList(self, expression_list):
+        """
+        Remove the ExpresionList level from the AST by replacing the contents of the
+        owning attribute of its parent.
+        """
+        expression_list.forEachChild(self.visit)
+        elideNode(expression_list, liftFormalTypes=True)
+
+    # TODO: visitInputList
+    
+    

owl_basic/singleton.py

@@ -0,0 +1,127 @@
+"""
+A Python Singleton mixin class that makes use of some of the ideas
+found at http://c2.com/cgi/wiki?PythonSingleton. Just inherit
+from it and you have a singleton. No code is required in
+subclasses to create singleton behavior -- inheritance from 
+Singleton is all that is needed.
+
+Assume S is a class that inherits from Singleton. Useful behaviors
+are:
+
+1) Getting the singleton:
+
+    S.getInstance() 
+    
+returns the instance of S. If none exists, it is created. 
+
+2) The usual idiom to construct an instance by calling the class, i.e.
+
+    S()
+    
+is disabled for the sake of clarity. If it were allowed, a programmer
+who didn't happen  notice the inheritance from Singleton might think he
+was creating a new instance. So it is felt that it is better to
+make that clearer by requiring the call of a class method that is defined in
+Singleton. An attempt to instantiate via S() will restult in an SingletonException
+being raised.
+
+3) If S.__init__(.) requires parameters, include them in the
+first call to S.getInstance(.). If subsequent calls have parameters,
+a SingletonException is raised.
+
+4) As an implementation detail, classes that inherit 
+from Singleton may not have their own __new__
+methods. To make sure this requirement is followed, 
+an exception is raised if a Singleton subclass includ
+es __new__. This happens at subclass instantiation
+time (by means of the MetaSingleton metaclass.
+
+By Gary Robinson, grobinson@transpose.com. No rights reserved -- 
+placed in the public domain -- which is only reasonable considering
+how much it owes to other people's version which are in the
+public domain. The idea of using a metaclass came from 
+a  comment on Gary's blog (see 
+http://www.garyrobinson.net/2004/03/python_singleto.html#comments). 
+Other improvements came from comments and email from other
+people who saw it online. (See the blog post and comments
+for further credits.)
+
+Not guaranteed to be fit for any particular purpose. Use at your
+own risk. 
+"""
+
+
+
+
+
+class SingletonException(Exception):
+    pass
+
+
+class MetaSingleton(type):
+    def __new__(metaclass, strName, tupBases, dict):
+        if '__new__' in dict:
+            raise SingletonException('Can not override __new__ in a Singleton')
+        return super(MetaSingleton,metaclass).__new__(metaclass, strName, tupBases, dict)
+        
+    def __call__(cls, *lstArgs, **dictArgs):
+        raise SingletonException('Singletons may only be instantiated through getInstance()')
+        
+class Singleton(object, metaclass=MetaSingleton):
+    def __init__(self, *args, **kwargs):
+        """
+        Provided for compatibility with subclasses which call super() in their __init__
+        """
+        super(Singleton, self).__init__(*args, **kwargs)
+    
+    # @TODO: This method NEEDS to be thread-safe
+    def getInstance(cls, *lstArgs, **kwargs):
+        """
+        Call this to instantiate an instance or retrieve the existing instance.
+        If the singleton requires args to be instantiated, include them the first
+        time you call getInstance.        
+        """
+        if cls._isInstantiated():
+            if len(lstArgs) + len(kwargs) != 0:
+                raise SingletonException('If no supplied args, singleton must already be instantiated, or __init__ must require no args')
+        else:
+            instance = cls.__new__(cls)
+            instance.__init__(*lstArgs, **kwargs)
+            cls.cInstance = instance
+        return cls.cInstance
+    getInstance = classmethod(getInstance)
+    
+    def _isInstantiated(cls):
+        return hasattr(cls, 'cInstance')
+    _isInstantiated = classmethod(_isInstantiated)  
+
+    def _getConstructionArgCountNotCountingSelf(cls):
+        return cls.__init__.im_func.func_code.co_argcount - 1
+    _getConstructionArgCountNotCountingSelf = classmethod(_getConstructionArgCountNotCountingSelf)
+
+    def _forgetClassInstanceReferenceForTesting(cls):
+        """
+        This is designed for convenience in testing -- sometimes you 
+        want to get rid of a singleton during test code to see what
+        happens when you call getInstance() under a new situation.
+        
+        To really delete the object, all external references to it
+        also need to be deleted.
+        """
+        try:
+            delattr(cls,'cInstance')
+        except AttributeError:
+            # run up the chain of base classes until we find the one that has the instance
+            # and then delete it there
+            for baseClass in cls.__bases__: 
+                if issubclass(baseClass, Singleton):
+                    baseClass._forgetClassInstanceReferenceForTesting()
+    _forgetClassInstanceReferenceForTesting = classmethod(_forgetClassInstanceReferenceForTesting)
+    
+
+
+if __name__ == '__main__':
+    
+    unittest.main()
+
+    

owl_basic/source_debugging.py

@@ -0,0 +1,124 @@
+import logging
+import re
+from bisect import bisect_right
+
+from owl_basic.visitor import Visitor
+
+class SourceDebuggingVisitor(Visitor):
+    '''
+    A visitor for computing start and end character columns based upon
+    file offsets attached to each AstStatement node and offsets to the beginning
+    of each line. The operation of this visitor assumes that a depth-first traversal
+    of the AST will visit all statements in source program order.
+    '''
+    def __init__(self, data, line_offsets, line_number_prefixes):
+        '''
+        :param data: The source file as a string
+        :param line_offsets: an array of line offsets
+        :param line_number_prexies: an array of the lengths of the line-number and
+                                    whitespace prefix to each source line
+        '''
+        self.__data = data
+        self.__line_offsets = line_offsets
+        self.__line_number_prefixes = line_number_prefixes
+        self.__previous_statement = None
+        self.__separator_regex = re.compile(r'\s*([\n:]|ELSE)')
+
+    def visitAstNode(self, node):
+        node.forEachChild(self.visit)
+    
+    def visitAstStatement(self, statement):
+        '''
+        Get the startPos of the visited statement. Use this value, together with the
+        probably innaccurate endPos of the *previous* statement to locate the end of
+        the previous statement, and update its endPos value.
+        '''
+        #print statement
+        self.setPreviousStatementColumns(statement)
+        self.__previous_statement = statement
+        # There is no need to visit the children of most statements
+    
+    def visitIf(self, statement):
+        #print statement
+        self.setPreviousStatementColumns(statement)
+        # If statements, don't need adjusting, so we unset self.__previous_statement
+        self.__previous_statement = None
+        # We must visit the children of IF statements
+        if statement.trueClause is not None:
+            #print "visiting trueClause"
+            self.visit(statement.trueClause)
+
+        if statement.falseClause is not None:
+            #print "visiting falseClause"
+            self.visit(statement.falseClause)
+        
+        # Set up the columns for this IF statement itself
+        self.setStartAndEndColumns(statement)
+    
+    def setPreviousStatementColumns(self, statement):
+        '''
+        Update the endPos attribute on self.__previous_statement based upon the startPos attribute
+        of the statement parameters.  A search between the two statements for a statement separator
+        is performed, and computations of the start and end character columns for __previous_statement
+        are performed and these attributes set.
+        Note: Assumes that self.__previous statement is the prior statement in the program
+              order to statement
+        :param statement: The statement being visited, the start of which marks the latest position
+                          for the end of the previous statement.
+        '''
+        if self.__previous_statement is not None:
+            self.adjustEndPos(self.__previous_statement, statement.startPos)
+            self.setStartAndEndColumns(self.__previous_statement)
+
+    def adjustEndPos(self, statement, limit_pos):
+        '''
+        Adjust the endPos attribute of statement forwards by searching from its existing
+        location forwards up to limit_pos for a statement separator (colon or newline)
+        '''
+        # Define a half-open range [search_start_pos, search_end_pos) within which we expect
+        # to locate a statement boundary.
+        #print statement
+        #print statement.startPos
+        #print statement.endPos
+        search_start_pos = statement.endPos
+        search_end_pos = limit_pos
+        assert search_start_pos is not None
+        assert search_end_pos is not None
+        if search_start_pos < search_end_pos - 1:
+            # TODO: Some possible issue here with line end markers (because of normalised line endings), ignoring the contents of REMs, DATA and LiteralStrings
+            #       and line continuation
+            # Search for new-lines or COLONs within the search string
+            m = self.__separator_regex.search(self.__data, search_start_pos, search_end_pos)
+            if m is not None:
+                statement.endPos = m.start()
+            else:
+                print("Error: Could not locate statement separator in >>>%s<<<" % self.__data[search_start_pos:search_end_pos])
+        #print ">>>%s<<<" % self.__data[statement.startPos:statement.endPos]
+    
+    def setStartAndEndColumns(self, statement):
+        '''
+        Sets the start and end columns on statement from start and end lexing positions.
+        :param statement: The statement node to be modified.
+        '''
+        statement.startColumn = self.columnFromPos(statement.startPos)
+        statement.endColumn = self.columnFromPos(statement.endPos)
+    
+    def columnFromPos(self, pos):
+        '''
+        :param pos: An zero-based offset from the beginning of the source file
+        :returns: A one-based character column from the beginning of the line
+        '''
+        # TODO: Could make this faster by passing in a range on lines to check
+        #print "pos =", pos
+        index = bisect_right(self.__line_offsets, pos) - 1
+        #print "index =", index
+        line_start_pos = self.__line_offsets[index]
+        #print "line_start_pos =", line_start_pos
+        prefix_length = self.__line_number_prefixes[index]
+        #print "prefix_length =", prefix_length
+        column = pos - line_start_pos + prefix_length + 1 # One based
+        #print "column =", column
+        #print
+        return column
+        
+        

owl_basic/symbol_table_visitor.py

@@ -0,0 +1,220 @@
+# A visitor for performing type-checking over the Abstract Syntax Tree
+
+import logging
+from functools import partial
+
+from owl_basic.visitor import Visitor
+from owl_basic.errors import *
+from owl_basic.symbol_tables import *
+from owl_basic.syntax.ast import FormalArgument, FormalReferenceArgument, Variable, AstStatement
+from owl_basic.ast_utils import findNode
+from owl_basic import sigil
+
+logger = logging.getLogger('symbol_table_visitor')
+
+class SymbolTableVisitor(Visitor):
+    """
+    CFG visitor for annotating statement nodes with
+    references to a symbol table.
+    """
+    def __init__(self):
+        self.__global_symbols = SymbolTable("global symbol table",
+                                            protection=SymbolTable.writable,
+                                            parent=SystemSymbolTable.getInstance())
+    
+    def _getGlobalSymbols(self):
+        return self.__global_symbols
+    
+    globalSymbols = property(_getGlobalSymbols)
+    
+    def followSuccessors(self, statement):
+        # Visit successors - depth first through CFG
+        for out_edge in statement.outEdges:
+            if out_edge.symbolTable is None:
+                self.visit(out_edge)
+                
+    def checkPredecessorsAndRefer(self, statement):
+        """
+        Given a statement, return the symbol table of the
+        preceding statement. If a statement has multiple predecessors,
+        check that all predecessors refer to the same
+        symbol table - raise an error if not.
+        """
+        if statement.symbolTable is None:
+            symbol_table = None
+            for in_edge in statement.inEdges:
+                if in_edge.symbolTable is not None:
+                    if symbol_table is None:
+                        symbol_table = in_edge.symbolTable
+                    else:
+                        if in_edge.symbolTable is not symbol_table:
+                            errors.fatalError("Inconsistent variable scopes for %s at line %s" % statement, statement.lineNum)
+            assert symbol_table is not None                
+            return symbol_table
+        return statement.symbolTable
+    
+    def tryAddVariable(self, symbol_table, variable):
+        if (isinstance(variable, Variable)):
+            symbol_info = SymbolInfo(variable.identifier, variable.actualType)
+            symbol_table.tryAdd(symbol_info)
+        else:
+            assert 0, "%s is not a variable" % variable
+            # TODO: What?
+            pass
+    
+    def visitAstStatement(self, statement):
+        """
+        Attaches the same symbol table as the predecessor statement to this
+        statement Depth first search visit of successors statements
+        """
+        #logger.debug("SymbolTableVisitor.visitAstStatement %s at %s", statement, statement.lineNum)
+        statement.symbolTable = self.checkPredecessorsAndRefer(statement)
+        assert statement.symbolTable is not None
+        # TODO: Check that all other variable references within this statement can
+        #       be successfully looked up.
+        self.followSuccessors(statement)
+        
+    def visitDefinitionStatement(self, defproc):
+        """
+        Visit DEFPROC DEFFN. Create a new symbol table containing the formal
+        parameters of the procedure or function, which also refers to the global symbol
+        table.
+        """
+        #logger.debug("SymbolTableVisitor.visitDefinitionStatement")
+        if defproc.symbolTable is None:
+            symbol_table = None
+            if defproc.formalParameters is None or len(defproc.formalParameters.arguments) == 0:
+                # If there are no parameters, we just use the
+                # global symbol table
+                symbol_table = self.__global_symbols
+            else:
+                symbol_infos = []
+                
+                for formal_argument in defproc.formalParameters.arguments:
+                    name = formal_argument.argument.identifier
+                    type = formal_argument.argument.actualType
+                    if isinstance(formal_argument.argument, FormalArgument):
+                        modifier = SymbolInfo.modifier_arg    
+                    elif isinstance(formal_argument.argument, FormalReferenceArgument):
+                        modifier = SymbolInfo.modifier_ref_arg
+                    symbol_info = SymbolInfo(name, type, SymbolInfo.modifier_arg)
+                    symbol_infos.append(symbol_info)
+                symbol_table = FormalParameterSymbolTable(symbol_infos, defproc.name, self.__global_symbols)
+            assert symbol_table is not None  
+            defproc.symbolTable = symbol_table
+        self.followSuccessors(defproc)
+                    
+    def visitLocal(self, local):
+        #logger.debug("SymbolTableVisitor.visitLocal")
+        # TODO: We should have a warning if LOCAL and PRIVATE are not the first
+        #       statements in a definition
+        # TODO: REFACTOR This is almost identical to visitPrivate
+        if 'MAIN' in local.entryPoints:
+            errors.fatalError("Items can only be made local in a function or procedure at line %s" % local.lineNum)
+        if local.symbolTable is None:
+            symbol_infos = []
+            for variable in local.variables:
+                name = variable.identifier
+                type = variable.actualType
+                symbol_info = SymbolInfo(name, type, SymbolInfo.modifier_local)
+                symbol_infos.append(symbol_info)
+            assert len(local.entryPoints) == 1
+            procedure = iter(local.entryPoints).next()
+            symbol_table = LocalSymbolTable(symbol_infos, procedure, self.checkPredecessorsAndRefer(local))
+            assert symbol_table is not None  
+            local.symbolTable = symbol_table
+        self.followSuccessors(local)
+    
+    def visitPrivate(self, private):
+        #logger.debug("SymbolTableVisitor.visitPrivate")
+        # TODO: We should have a warning if LOCAL and PRIVATE are not the first
+        #       statements in a definition
+        # TODO: REFACTOR This is almost identical to visitLocal
+        if 'MAIN' in private.entryPoints:
+            errors.fatalError("Items can only be made local in a function or procedure at line %s" % local.lineNum)
+        if private.symbolTable is None:
+            symbol_infos = []
+            for variable in private.variables:
+                name = variable.identifier
+                type = variable.actualType
+                symbol_info = SymbolInfo(name, type, SymbolInfo.modifier_private)
+                symbol_infos.append(symbol_info)
+            assert len(private.entryPoints) == 1
+            procedure = iter(private.entryPoints).next()
+            symbol_table = PrivateSymbolTable(symbol_infos, procedure, self.checkPredecessorsAndRefer(private))
+            assert symbol_table is not None  
+            private.symbolTable = symbol_table
+        self.followSuccessors(private)
+    
+    def visitAssignment(self, statement):
+        logger.debug("SymbolTableVisitor.visitAssignment")
+        print(statement)
+        #assert statement.symbolTable is not None
+        statement.symbolTable = self.checkPredecessorsAndRefer(statement)
+        #self.tryAddVariable(statement.symbolTable, statement.lValue)
+        statement.lValue.accept(self)
+        self.followSuccessors(statement)
+    
+    def visitVariable(self, variable):
+        logger.debug("SymbolTableVisitor.visitVariable")
+        statement_node = findNode(variable, lambda node: isinstance(node, AstStatement))
+        symbol_table = statement_node.symbolTable
+        self.tryAddVariable(symbol_table, variable)
+        
+    def visitAllocateArray(self, statement):
+        logger.debug("SymbolTableVisitor.allocateArray")
+        statement.symbolTable = self.checkPredecessorsAndRefer(statement)    
+        symbol_info = SymbolInfo(statement.identifier, sigil.identifierToType(statement.identifier),
+                                 rank=len(statement.dimensions))
+        statement.symbolTable.tryAdd(symbol_info)
+        self.followSuccessors(statement)
+        
+    def visitAllocateBlock(self, statement):
+        #logger.debug("SymbolTableVisitor.allocateBlock")
+        statement.symbolTable = self.checkPredecessorsAndRefer(statement)    
+        assert statement.symbolTable is not None
+        symbol_info = SymbolInfo(statement.identifier, PtrType)
+        self.followSuccessors(statement)
+    
+    def visitForToStep(self, statement):
+        #logger.debug("SymbolTableVisitor.visitForToStep")
+        statement.symbolTable = self.checkPredecessorsAndRefer(statement)    
+        assert statement.symbolTable is not None
+        self.tryAddVariable(statement.symbolTable, statement.identifier)
+        self.followSuccessors(statement)
+        
+    def visitInput(self, statement):
+        #logger.debug("SymbolTableVisitor.visitInput")
+        statement.symbolTable = self.checkPredecessorsAndRefer(statement)       
+        assert statement.symbolTable is not None
+        variables = (item for item in statement.inputList if isinstance(item, Variable))
+        for variable in variables:
+            self.tryAddVariable(statement.symbolTable, variable)
+        self.followSuccessors(statement)
+        
+    def visitInputFile(self, input):
+        #logger.debug("SymbolTableVisitor.visitInputFile")
+        statement.symbolTable = self.checkPredecessorsAndRefer(statement)       
+        assert statement.symbolTable is not None
+        for item in statement.inputList:
+            self.tryAddVariable(statement.symbolTable, item)
+        self.followSuccessors(input)
+        
+    def visitMouse(self, mouse):
+        #logger.debug("SymbolTableVisitor.visitInput")
+        statement.symbolTable = self.checkPredecessorsAndRefer(statement)
+        assert statement.symbolTable is not None
+        self.tryAddVariable(statement.symbolTable, statement.xCoord)
+        self.tryAddVariable(statement.symbolTable, statement.yCoord)
+        self.tryAddVariable(statement.symbolTable, statement.buttons)
+        self.tryAddVariable(statement.symbolTable, statement.time)
+        self.followSuccessors(statement)
+        
+    def visitRead(self, statement):
+        #logger.debug("SymbolTableVisitior.visitRead")
+        statement.symbolTable = self.checkPredecessorsAndRefer(statement)
+        assert statement.symbolTable is not None
+        for writable in statement.writables.writables:
+            self.tryAddVariable(statement.symbolTable, writable)
+        
+