[Cpptool-cvs] rfta/src/rftaparser NamespaceParser.cpp,1.3,1.4 NamespaceParser.h,1.1,1.2

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

Update of /cvsroot/cpptool/rfta/src/rftaparser
In directory sc8-pr-cvs1:/tmp/cvs-serv2847/src/rftaparser

Modified Files:
	NamespaceParser.cpp NamespaceParser.h 
Log Message:
* added handling for anonymous namespace
* refactored a bit

Index: NamespaceParser.cpp
===================================================================
RCS file: /cvsroot/cpptool/rfta/src/rftaparser/NamespaceParser.cpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** NamespaceParser.cpp	15 Apr 2003 19:05:19 -0000	1.3
--- NamespaceParser.cpp	30 Apr 2003 19:20:12 -0000	1.4
***************
*** 46,110 ****
     // named namespace or unnamed namespace:
     // "namespace x" or "namespace { ... }"
!    int name_startIdx = getCurrentIndex();
!    std::string namespace_name;
!    if (tryReadNextIdentifier(namespace_name))
     {
        // namespace has an identifier which will be stored as child-node.      
!       ASTNodePtr namespace_identifier = 
            createASTNode( ASTNodeTypes::localScopeIdentifier,
                           namespaceNode,
!                          name_startIdx, getCurrentIndex() - name_startIdx + 1 );
!       namespaceNode->addChild( namespace_identifier );
     }
  
!    if (!namespace_name.empty())
!    {
!       // check for definition of a namespace alias
!       skipSpaces();
!       if (tryNextIs('='))
!       {
!          // namespace alias: "namespace x = y;"
!          skipSpaces();
!          int alias_startIdx = getCurrentIndex();
!          std::string alias_name = namespace_name;
!          if (!tryReadNextIdentifier(namespace_name))
!          {
!             throwFailure( std::string("expected identifier for namespace alias." ));
!          }
!          namespaceNode->mutateType(ASTNodeTypes::namespaceAlias);
!          // store alias name in property
!          context_.bindNextNodeToProperty(namespaceNode,ASTNodeProperties::namespaceAliasProperty );
!          
!          ASTNodePtr namespace_identifier = 
!           createASTNode( ASTNodeTypes::localScopeIdentifier,
!                          namespaceNode,
!                          alias_startIdx, getCurrentIndex() - alias_startIdx );
!          
!          context_.addNode(namespace_identifier);
! 
!          skipSpaces();
!          expect(';');         
!       } else
!       {
!          // this is a usual namespace definition:
!          // "namespace x { }"
!          int body_startIdx = getCurrentIndex();
!          expect('{');
!          findNextBalanced('{','}');
!          // store body in namespace-body-property
!          context_.bindNextNodeToProperty(namespaceNode,ASTNodeProperties::namespaceBodyProperty );
!          
!          ASTNodePtr namespace_body = 
!             createASTNode( ASTNodeTypes::unparsedDeclarationList,
!                            namespaceNode,
!                            body_startIdx, getCurrentIndex() - body_startIdx );
  
!          context_.addNode(namespace_body);
!       }
!    }
  
     namespaceNode->setLength( getCurrentLength() );
     
  }
  
  } // namespace Refactoring
--- 46,122 ----
     // named namespace or unnamed namespace:
     // "namespace x" or "namespace { ... }"
!    int nameStartIndex = getCurrentIndex();
!    std::string namespaceName;
!    if (tryReadNextIdentifier(namespaceName))
     {
        // namespace has an identifier which will be stored as child-node.      
!       ASTNodePtr namespaceIdentifier = 
            createASTNode( ASTNodeTypes::localScopeIdentifier,
                           namespaceNode,
!                          nameStartIndex, getCurrentIndex() - nameStartIndex + 1 );
!       namespaceNode->addChild( namespaceIdentifier );
     }
  
!    skipSpaces();
  
!    // check for definition of a namespace alias
!    if ( tryNextIs('=') )
!       parseNamespaceAlias( namespaceName, namespaceNode );
!    else
!       parseNamespaceBody( namespaceNode );
  
     namespaceNode->setLength( getCurrentLength() );
     
  }
+ 
+ 
+ void 
+ NamespaceParser::parseNamespaceAlias( const std::string &namespace_name,
+                                       const ASTNodePtr &namespaceNode )
+ {
+    // namespace alias: "namespace x = y;"
+    skipSpaces();
+ 
+    int aliasStartIndex = getCurrentIndex();
+    std::string originalNamespaceName;
+    if ( !tryReadNextIdentifier(originalNamespaceName) )
+       throwFailure( "expected identifier for namespace alias." );
+ 
+    namespaceNode->mutateType(ASTNodeTypes::namespaceAlias);
+    // store alias name in property
+    context_.bindNextNodeToProperty(namespaceNode,ASTNodeProperties::namespaceAliasProperty );
+    
+    ASTNodePtr namespace_identifier = 
+     createASTNode( ASTNodeTypes::localScopeIdentifier,
+                    namespaceNode,
+                    aliasStartIndex, getCurrentIndex() - aliasStartIndex );
+    
+    context_.addNode(namespace_identifier);
+ 
+    skipSpaces();
+    expect(';');         
+ }
+ 
+ 
+ void 
+ NamespaceParser::parseNamespaceBody( const ASTNodePtr &namespaceNode )
+ {
+    // this is a usual namespace definition:
+    // "namespace x { }"
+    int bodyStartIndex = getCurrentIndex();
+    expect('{');
+    findNextBalanced('{','}');
+ 
+    // store body in namespace-body-property
+    context_.bindNextNodeToProperty(namespaceNode,ASTNodeProperties::namespaceBodyProperty );
+    
+    ASTNodePtr namespaceBody = 
+       createASTNode( ASTNodeTypes::unparsedDeclarationList,
+                      namespaceNode,
+                      bodyStartIndex, getCurrentIndex() - bodyStartIndex );
+ 
+    context_.addNode(namespaceBody);
+ }
+ 
  
  } // namespace Refactoring

Index: NamespaceParser.h
===================================================================
RCS file: /cvsroot/cpptool/rfta/src/rftaparser/NamespaceParser.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** NamespaceParser.h	12 Apr 2003 19:08:40 -0000	1.1
--- NamespaceParser.h	30 Apr 2003 19:20:13 -0000	1.2
***************
*** 30,33 ****
--- 30,37 ----
        
     private:
+       void parseNamespaceAlias( const std::string &namespace_name,
+                                 const ASTNodePtr &namespaceNode );
+ 
+       void parseNamespaceBody( const ASTNodePtr &namespaceNode );
     };