[Cpptool-cvs] rfta/src/pyrfta/test/rfta codeanalysis.py,1.2,1.3 codeanalysistest.py,1.2,1.3

[<bl...@us...>]

Update of /cvsroot/cpptool/rfta/src/pyrfta/test/rfta
In directory sc8-pr-cvs1:/tmp/cvs-serv17464/src/pyrfta/test/rfta

Modified Files:
	codeanalysis.py codeanalysistest.py 
Log Message:
* added scope handling
* added locale variable resolution
* added using declaration support in scope

Index: codeanalysis.py
===================================================================
RCS file: /cvsroot/cpptool/rfta/src/pyrfta/test/rfta/codeanalysis.py,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** codeanalysis.py	29 May 2003 17:03:06 -0000	1.2
--- codeanalysis.py	29 May 2003 21:15:18 -0000	1.3
***************
*** 1,3 ****
--- 1,4 ----
  import rfta
+ import string
  
  
***************
*** 17,23 ****
          self.resolver.exitScope()
  
-     def visitNullStatement( self, statement ):
-         pass
- 
      def visitDeclarationStatement( self, statement ):
          statement.declaration.accept( self )
--- 18,21 ----
***************
*** 25,43 ****
      def visitDeclaratorExpression( self, expression ):
          for declarator in expression.getDeclarators():
!             self.resolver.declareVariable( declarator.name.identifier )
!         
  
! class LocalVariableResolver:
!     def isLocaleVariable(self, variableName):
!         return false
  
!     def declareVariable(self, variableName):
!         pass
  
!     def enterScope(self):
          pass
  
!     def exitScope(self):
!         pass
  
  
--- 23,151 ----
      def visitDeclaratorExpression( self, expression ):
          for declarator in expression.getDeclarators():
!             self.resolver.declareVariable( declarator.name.identifier, expression )
  
!     def visitForStatement( self, statement ):
!         self.resolver.enterForScope()
!         statement.declaration.accept( self )
!         self._visitScopedSubstatement( statement.iteratedStatement )
!         self.resolver.exitForScope()
  
!     def visitIfStatement( self, statement ):
!         self._visitScopedSubstatement( statement.thenStatement )
!         if statement.hasElseStatement():
!             self._visitScopedSubstatement( statement.elseStatement )
  
!     def visitNullStatement( self, statement ):
          pass
  
!     def visitWhileStatement( self, statement ):
!         self._visitScopedSubstatement( statement.iteratedStatement )
! 
!     def _visitScopedSubstatement( self, statement ):        
!         self.resolver.enterScope()
!         statement.accept( self )
!         self.resolver.exitScope()
! 
! class Identifier:
!     def __init__( self, identifier ):
!         self.identifier = identifier
! 
!     def name( self ):
!         pos = string.rfind( self.identifier, '::' )
!         if pos == -1:
!             return self.identifier
!         return self.identifier[pos:]
! 
! IDTYPE_LOCALVARIABLE = 1
! IDTYPE_IMPORTEDID = 2
! 
! class Scope:
!     children = []
! 
!     def __init__( self, parent_scope ):
!         self.parent_scope = parent_scope
!         if self.parent_scope:
!             self.parent_scope.children.append( self )
! 
!     def resolve( self, identifier ):
!         return None
! 
!     def parentResolve( self, identifier ):
!         if self.parent_scope:
!             return self.parent_scope.resolve( self, identifier )
!         return None
! 
! class FunctionScope(Scope):
!     def __init__( self, function ):
!         Scope.__init__( self, None )
!         self.function = function
! 
! class LocalVariableScope(Scope):
!     declared = {}
! 
!     def __init__( self, parent_scope ):
!         Scope.__init__( self, parent_scope )
! 
!     def declare( self, variableName, declExpr ):
!         self.declared[variableName] = declExpr
! 
!     def declareLocalVariable( self, variableName ):
!         return variableName in self.declared
! 
!     def resolve( self, identifier ):
!         if self.declareLocalVariable( identifier ):
!             return (IDTYPE_LOCALVARIABLE, self.declared[identifier])
!         return self.parentResolve( identifier )
! 
! class UsingDeclScope(Scope):
!     imported = {}
! 
!     def __init__( self, parent_scope ):
!         Scope.__init__( self, parent_scope )
! 
!     def importIdentifier( self, identifier ):
!         imported[ Identifier(identifier).name() ] = identifier
! 
!     def resolve( self, identifier ):
!         if declareLocalVariable( self, identifier ):
!             return (IDTYPE_IMPORTEDID, imported[identifier])
!         return self.parentResolve( identifier )
! 
! class LocalVariableResolver:
!     standard_for_scope = True
!     scope_depth = 0
!     resolved = {}
!     
!     def __init__( self, function_scope ):
!         self.current_scope = function_scope
! 
!     def resolveVariable( self, variableName, variable_name_element ):
!         variableDecl = self.current_scope.resolve( variableName )
!         if variableDecl:
!             self.resolved[ variable_name_element ] = variableDecl
!     
!     def declareVariable( self, variableName, declExpr ):
!         assert( self.scope_depth > 0 )
!         self.current_scope.declare( variableName, declExpr )
! 
!     def findVariable( self, variable_name_element ):
!         return self.resolved.get( variable_name_element, None )
! 
!     def enterScope( self ):
!         self.current_scope = LocalVariableScope( self.current_scope )
!         self.scope_depth += 1
! 
!     def exitScope( self ):
!         assert( self.scope_depth > 0 )
!         self.scope_depth -= 1
!         self.current_scope = self.current_scope.parent_scope
! 
!     def enterForScope( self ):
!         if self.standard_for_scope:
!             self.enterScope()
! 
!     def exitForScope( self ):
!         if self.standard_for_scope:
!             self.exitScope()
  
  

Index: codeanalysistest.py
===================================================================
RCS file: /cvsroot/cpptool/rfta/src/pyrfta/test/rfta/codeanalysistest.py,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** codeanalysistest.py	29 May 2003 17:03:06 -0000	1.2
--- codeanalysistest.py	29 May 2003 21:15:18 -0000	1.3
***************
*** 5,15 ****
  from mock import MockFactory
  
! class LocaleVariableDeclaratorTest(unittest.TestCase):
      """LocaleVariableDeclarator tests"""
  
      def setUp( self ):
!         self.resolver = self.createMockInstance( LocalVariableResolver, [] )
          self.declarator = LocalVariableDeclarator( self.resolver )
-         self.body = rfta.CompoundStatement()
  
      def tearDown( self ):
--- 5,79 ----
  from mock import MockFactory
  
! 
! class CodeMother:
!     """code model object mother"""
! 
!     def makeType( self, name ):
!         return rfta.Type( name )
! 
!     def makeFunctionName( self, name ):
!         return rfta.FunctionName( name )
! 
!     def makeParameters( self ):
!         return rfta.Parameters()
! 
!     def makeFunctionDecl( self, return_type, name, parameters, body = None ):
!         return rfta.FunctionDeclaration( return_type, name, parameters, body )
! 
!     def makeQuickFunctionDecl( self, return_type, name ):
!         return self.makeFunctionDecl( self.makeType( return_type ),
!                                       self.makeFunctionName( name ),
!                                       self.makeParameters(),
!                                       self.makeCompound() )
! 
!     def makeCompound( self ):
!         return rfta.CompoundStatement()
! 
!     def makeVariableDeclExpr( self, variables ):
!         declExpr = rfta.DeclaratorExpression( rfta.TypePart( "int" ) )
!         for variable in variables:
!             declarator = rfta.Declarator( rfta.TypePart(),
!                                           rfta.Identifier(variable[0]),
!                                           rfta.TypePart(),
!                                           rfta.AssignInitializerExpression( rfta.GenericExpression( variable[1] ) ) )
!             declExpr.appendDeclarator( declarator )
!         return declExpr
! 
!     def makeVariableDecl( self, variables ):
!         return rfta.DeclarationStatement( self.makeVariableDeclExpr( variables ) )
! 
!     def makeVariableName( self, name ):
!         return rfta.VariableName( name )
! 
!     def makeWhile( self, condition, substatement ):
!         return rfta.WhileStatement( condition, substatement )
! 
!     def makeFor( self, init, condition, update, substatement ):
!         return rfta.ForStatement( init, condition, update, substatement )
! 
!     def makeIf( self, condition, then_statment, else_statement = None ):
!         return rfta.IfStatement( condition, then_statment, else_statement )
! 
!     def makeNullStatement( self ):
!         return rfta.NullStatement()
! 
!     def makeNull( self ):
!         return rfta.NullExpression()
! 
!     def makeExpr( self, value ):
!         return rfta.GenericExpression( value )
! 
!     def makeTrue( self ):
!         return self.makeExpr( "true" )
! 
! 
! class LocaleVariableDeclaratorTest(unittest.TestCase,CodeMother):
      """LocaleVariableDeclarator tests"""
  
      def setUp( self ):
!         self.function = self.makeQuickFunctionDecl( "void", "f" )
!         self.body = self.function.body
!         self.resolver = self.createMockInstance( LocalVariableResolver, [], FunctionScope( self.function ) )
          self.declarator = LocalVariableDeclarator( self.resolver )
  
      def tearDown( self ):
***************
*** 17,29 ****
          self.resolver = None
  
!     def makeVariableDecl( self, name, init ):
!         declarator = rfta.Declarator( rfta.TypePart(),
!                                       rfta.Identifier(name),
!                                       rfta.TypePart(),
!                                       rfta.AssignInitializerExpression( rfta.GenericExpression( init ) ) )
!         declExpr = rfta.DeclaratorExpression( rfta.TypePart( "int" ) )
!         declExpr.appendDeclarator( declarator )
!         declStatement = rfta.DeclarationStatement( declExpr )
!         return declStatement
  
      def testConstruction( self ):
--- 81,92 ----
          self.resolver = None
  
!     def doResolve( self ):
!         self.declarator.declare( self.body )
! 
!     def checkDeclaredVariable( self, expected_variables ):
!         actual_variables = []
!         for variable_decl in self.resolver.declareVariable.argsPassed:
!             actual_variables.append( variable_decl[0] )
!         self.assertEqual( actual_variables, expected_variables )
  
      def testConstruction( self ):
***************
*** 32,54 ****
      def testEmptyBody( self ):
          self.resolver.declareVariable.setExpectNoCall()
!         self.declarator.visitCompoundStatement( self.body )
          
          self.assertEqual( self.resolver.called, [ "enterScope", "exitScope" ] )
  
      def testDummyBody( self ):
!         self.body.appendStatement( rfta.NullStatement() )
          self.resolver.declareVariable.setExpectNoCall()
!         self.declarator.visitCompoundStatement( self.body )
          
          self.assertEqual( self.resolver.called, [ "enterScope", "exitScope" ] )
  
!     def testDeclareOneVariable( self ):
!         self.body.appendStatement( self.makeVariableDecl( "var1", "3" ) )
!         self.declarator.visitCompoundStatement( self.body )
!         self.assertEqual( self.resolver.called, [ "enterScope", "declareVariable", "exitScope" ] )
!         self.assertEqual( self.resolver.declareVariable.argsPassed, [("var1",)] )
  
  def suite():
!     return unittest.makeSuite(IdentifierResolverTestCase)
  
  if __name__ == '__main__':
--- 95,201 ----
      def testEmptyBody( self ):
          self.resolver.declareVariable.setExpectNoCall()
!         self.declarator.declare( self.body )
          
          self.assertEqual( self.resolver.called, [ "enterScope", "exitScope" ] )
  
      def testDummyBody( self ):
!         self.body.appendStatement( self.makeNullStatement() )
          self.resolver.declareVariable.setExpectNoCall()
!         self.declarator.declare( self.body )
          
          self.assertEqual( self.resolver.called, [ "enterScope", "exitScope" ] )
  
!     def testDeclareTwoVariables( self ):
!         self.body.appendStatement( self.makeVariableDecl( [("var1", "3"), ("var2", "7")] ) )
!         self.declarator.declare( self.body )
!         self.assertEqual( self.resolver.called, [ "enterScope", "declareVariable", "declareVariable", "exitScope" ] )
!         self.checkDeclaredVariable( ["var1", "var2" ] )
! 
!     def testWhileScope( self ):
!         self.body.appendStatement( self.makeWhile( self.makeTrue(),
!                                                    self.makeVariableDecl( [("var1", "453")] ) ) )
!         self.declarator.declare( self.body )
!         self.assertEqual( self.resolver.called,
!                           [ "enterScope", "enterScope", "declareVariable", "exitScope", "exitScope" ] )
!         self.checkDeclaredVariable( ["var1"] )
! 
!     def testIfThenScope( self ):
!         self.body.appendStatement( self.makeIf( self.makeTrue(),
!                                                 self.makeVariableDecl( [("var1", "453")] ) ) )
!         self.declarator.declare( self.body )
!         self.assertEqual( self.resolver.called,
!                           [ "enterScope", "enterScope", "declareVariable", "exitScope", "exitScope" ] )
!         self.checkDeclaredVariable( ["var1"] )
! 
!     def testIfThenElseScope( self ):
!         self.body.appendStatement( self.makeIf( self.makeTrue(),
!                                                 self.makeVariableDecl( [("var1", "453")] ),
!                                                 self.makeVariableDecl( [("var2", "456")] ) ) )
!         self.declarator.declare( self.body )
!         self.assertEqual( self.resolver.called,
!                           [ "enterScope", "enterScope", "declareVariable", "exitScope",
!                                           "enterScope", "declareVariable", "exitScope",
!                             "exitScope" ] )
!         self.checkDeclaredVariable( ["var1","var2"] )
! 
!     def testForScope( self ):
!         self.body.appendStatement( self.makeFor( self.makeVariableDeclExpr( [("var1", "453")] ),
!                                                  self.makeTrue(),
!                                                  self.makeNull(),
!                                                  self.makeVariableDecl( [("var2", "412")] ),
!                                                  ) )
!         self.declarator.declare( self.body )
!         self.assertEqual( self.resolver.called,
!                           [ "enterScope",
!                             "enterForScope", "enterScope", "declareVariable",
!                                 "enterScope", "declareVariable", "exitScope",
!                             "exitForScope", "exitScope", "exitScope" ] )
!         self.checkDeclaredVariable( ["var1","var2"] )
! 
! class LocaleVariableResolverTest(unittest.TestCase,CodeMother):
!     """LocaleVariableResolver tests"""
! 
!     def setUp( self ):
!         self.function = self.makeQuickFunctionDecl( "void", "f" )
!         self.resolver = LocalVariableResolver( FunctionScope( self.function ) )
!         self.declExpr1 = self.makeVariableDeclExpr( [("var1", "1"), ("var2","b"), ("var3","c")] )
!         self.declExpr2 = self.makeVariableDeclExpr( [("x", "1"), ("y","b"), ("z","c")] )
!         self.identifiers = {}
!         for name in [ "var1", "var2", "var3", "x", "y", "z" ]:
!             for count in range(1,5):
!                 variable_name = name + "."  + str(count)
!                 self.identifiers[ variable_name ] = self.makeVariableName( variable_name )
! 
!     def tearDown( self ):
!         pass
! 
!     def declareVariables( self, names, declExpr ):
!         for name in names:
!             self.resolver.declareVariable( name, declExpr )
! 
!     def resolveVariables( self, variables ):
!         for variable in variables:
!             id = variable[0] + "." + str(variable[1])
!             self.resolver.resolveVariable( variable[0], self.identifiers[id] )
! 
!     def checkVariableResolutions( self, names, declExpr ):
!         for name in names:
!             self.assertEqual( self.resolver.findVariable( self.identifiers[name] ),
!                               (IDTYPE_LOCALVARIABLE,declExpr) )
! 
!     def testConstruction( self ):
!         self.assertEqual( self.resolver.current_scope.function, self.function )
! 
!     def testDeclareAndResolve( self ):
!         self.resolver.enterScope()
!         self.declareVariables( ["var1", "var2", "var3"], self.declExpr1 )
!         self.declareVariables( ["x", "y", "z"], self.declExpr1 )
!         self.resolveVariables( [ ("var1",1), ("var2",1) ] )
!         self.resolver.exitScope()
! 
!         self.checkVariableResolutions( ["var1.1", "var2.1"], self.declExpr1 )
  
  def suite():
!     return unittest.makeSuite(IdentifierResolverTestCase, LocaleVariableResolverTest)
  
  if __name__ == '__main__':