Changes in src/Parser/ParseNode.h [ac71a86:e82aa9df]

File:

• src/Parser/ParseNode.h (modified) (19 diffs)

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug 18 23:48:37 2016
-// Update Count     : 542
+// Last Modified On : Mon Aug 15 14:52:12 2016
+// Update Count     : 512
 //
 
@@ -22 +22 @@
 #include <memory>
 
+#include "Common/utility.h"
 #include "Parser/LinkageSpec.h"
 #include "SynTree/Type.h"
 #include "SynTree/Expression.h"
 #include "SynTree/Statement.h"
+//#include "SynTree/Declaration.h"
+#include "Common/UniqueName.h"
 #include "SynTree/Label.h"
-#include "Common/utility.h"
-#include "Common/UniqueName.h"
 
 class StatementNode;
@@ -36 +37 @@
 class InitializerNode;
 
-//##############################################################################
-
+// Builder
 class ParseNode {
   public:
-        ParseNode() {};
-        ParseNode( const std::string *name ) : name( *name ) { assert( false ); delete name; }
-        ParseNode( const std::string &name ) : name( name ) { assert( false ); }
-        virtual ~ParseNode() { delete next; };
-        virtual ParseNode *clone() const = 0;
+        ParseNode();
+        ParseNode( const std::string * );
+        ParseNode( const std::string & );                                       // for copy constructing subclasses
+        virtual ~ParseNode();
 
         ParseNode *get_next() const { return next; }
         ParseNode *set_next( ParseNode *newlink ) { next = newlink; return this; }
-        ParseNode *get_last() {
-                ParseNode *current;
-                for ( current = this; current->get_next() != 0; current = current->get_next() );
-                return current;
-        }
-        ParseNode *set_last( ParseNode *newlast ) {
-                if ( newlast != 0 ) get_last()->set_next( newlast );
-                return this;
-        }
+        ParseNode *get_last();
+        ParseNode *set_last( ParseNode * );
+
+        virtual ParseNode *clone() const { return 0; };
 
         const std::string &get_name() const { return name; }
         void set_name( const std::string &newValue ) { name = newValue; }
 
-        virtual void print( std::ostream &os, int indent = 0 ) const {}
-        virtual void printList( std::ostream &os, int indent = 0 ) const {}
-  private:
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void printList( std::ostream &os, int indent = 0 ) const;
+
+        ParseNode &operator,( ParseNode & );
+  protected:
+        std::string name;
         static int indent_by;
-
-        ParseNode *next = nullptr;
-        std::string name;
-}; // ParseNode
+        ParseNode *next;
+};
 
 //##############################################################################
@@ -77 +72 @@
         InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode *des = 0 );
         ~InitializerNode();
-        virtual InitializerNode *clone() const { assert( false ); return nullptr; }
 
         ExpressionNode *get_expression() const { return expr; }
@@ -103 +97 @@
 //##############################################################################
 
-class ExpressionNode final : public ParseNode {
+class ExpressionNode : public ParseNode {
   public:
         ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {}
@@ -109 +103 @@
         ExpressionNode( const ExpressionNode &other );
         virtual ~ExpressionNode() {}
-        virtual ExpressionNode *clone() const { assert( false ); return nullptr; }
+
+        virtual ExpressionNode *clone() const { return 0; }
 
         bool get_extension() const { return extension; }
         ExpressionNode *set_extension( bool exten ) { extension = exten; return this; }
 
-        void print( std::ostream &os, int indent = 0 ) const {}
-        void printOneLine( std::ostream &os, int indent = 0 ) const {}
-
-        template<typename T>
-        bool isExpressionType() const {
-                return nullptr != dynamic_cast<T>(expr.get());
-        }
-
-        Expression *build() const { return const_cast<ExpressionNode*>(this)->expr.release(); }
+        virtual void print( std::ostream &os, int indent = 0 ) const {}
+        virtual void printOneLine( std::ostream &os, int indent = 0 ) const {}
+
+        virtual Expression *build() const { return expr; }
   private:
         bool extension = false;
-        std::unique_ptr<Expression> expr;
+        Expression *expr;
 };
 
 template< typename T >
-struct maybeBuild_t< Expression, T > {
+struct maybeBuild_t<Expression, T> {
         static inline Expression * doit( const T *orig ) {
                 if ( orig ) {
@@ -136 +126 @@
                         return p;
                 } else {
-                        return nullptr;
+                        return 0;
                 } // if
         }
@@ -156 +146 @@
 };
 
-Expression *build_constantInteger( const std::string &str );
-Expression *build_constantFloat( const std::string &str );
-Expression *build_constantChar( const std::string &str );
-ConstantExpr *build_constantStr( const std::string &str );
+Expression *build_constantInteger( std::string &str );
+Expression *build_constantFloat( std::string &str );
+Expression *build_constantChar( std::string &str );
+ConstantExpr *build_constantStr( std::string &str );
 
 NameExpr *build_varref( const std::string *name, bool labelp = false );
@@ -238 +228 @@
         static DeclarationNode *newBuiltinType( BuiltinType );
 
-        DeclarationNode();
-        ~DeclarationNode();
-        DeclarationNode *clone() const;
-
         DeclarationNode *addQualifiers( DeclarationNode *);
         DeclarationNode *copyStorageClasses( DeclarationNode *);
@@ -266 +252 @@
         DeclarationNode *cloneBaseType( DeclarationNode *newdecl );
 
-        DeclarationNode *appendList( DeclarationNode *node ) {
-                return (DeclarationNode *)set_last( node );
-        }
-
+        DeclarationNode *appendList( DeclarationNode * );
+
+        DeclarationNode *clone() const;
         void print( std::ostream &os, int indent = 0 ) const;
         void printList( std::ostream &os, int indent = 0 ) const;
@@ -278 +263 @@
         bool get_hasEllipsis() const;
         const std::string &get_name() const { return name; }
-        LinkageSpec::Spec get_linkage() const { return linkage; }
+        LinkageSpec::Type get_linkage() const { return linkage; }
         DeclarationNode *extractAggregate() const;
         ExpressionNode *get_enumeratorValue() const { return enumeratorValue; }
@@ -284 +269 @@
         bool get_extension() const { return extension; }
         DeclarationNode *set_extension( bool exten ) { extension = exten; return this; }
+
+        DeclarationNode();
+        ~DeclarationNode();
   private:
-        // StorageClass buildStorageClass() const;
-        // bool buildFuncSpecifier( StorageClass key ) const;
+        StorageClass buildStorageClass() const;
+        bool buildFuncSpecifier( StorageClass key ) const;
 
         TypeData *type;
         std::string name;
-        // std::list< StorageClass > storageClasses;
-        StorageClass storageClass;
-        bool isInline, isNoreturn;
+        std::list< StorageClass > storageClasses;
         std::list< std::string > attributes;
         ExpressionNode *bitfieldWidth;
@@ -298 +284 @@
         InitializerNode *initializer;
         bool hasEllipsis;
-        LinkageSpec::Spec linkage;
+        LinkageSpec::Type linkage;
         bool extension = false;
-        std::string error;
 
         static UniqueName anonymous;
@@ -309 +294 @@
 //##############################################################################
 
-class StatementNode final : public ParseNode {
+class StatementNode : public ParseNode {
   public:
         StatementNode() { stmt = nullptr; }
@@ -316 +301 @@
         virtual ~StatementNode() {}
 
-        virtual StatementNode *clone() const final { assert( false ); return nullptr; }
-        Statement *build() const { return const_cast<StatementNode*>(this)->stmt.release(); }
+        virtual StatementNode *clone() const { assert( false ); return nullptr; }
+        virtual Statement *build() const { return stmt; }
 
         virtual StatementNode *add_label( const std::string * name ) {
                 stmt->get_labels().emplace_back( *name );
-                delete name;
                 return this;
         }
@@ -330 +314 @@
         virtual void printList( std::ostream &os, int indent = 0 ) {}
   private:
-        std::unique_ptr<Statement> stmt;
+        Statement *stmt;
 }; // StatementNode
 
@@ -367 +351 @@
 void buildList( const NodeType *firstNode, std::list< SynTreeType * > &outputList ) {
         SemanticError errors;
-        std::back_insert_iterator< std::list< SynTreeType * > > out( outputList );
+        std::back_insert_iterator< std::list< SynTreeType *> > out( outputList );
         const NodeType *cur = firstNode;
 
         while ( cur ) {
                 try {
-//                      SynTreeType *result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::result_of< decltype(&NodeType::build)(NodeType)>::type >( cur ) );
-                        SynTreeType *result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
+//                      SynTreeType *result = dynamic_cast< SynTreeType *>( maybeBuild<typename std::result_of<decltype(&NodeType::build)(NodeType)>::type>( cur ) );
+                        SynTreeType *result = dynamic_cast< SynTreeType *>( maybeBuild<typename std::pointer_traits<decltype(cur->build())>::element_type>( cur ) );
                         if ( result ) {
                                 *out++ = result;
@@ -381 +365 @@
                         errors.append( e );
                 } // try
-                cur = dynamic_cast< NodeType * >( cur->get_next() );
+                cur = dynamic_cast< NodeType *>( cur->get_next() );
         } // while
         if ( ! errors.isEmpty() ) {
@@ -390 +374 @@
 // in DeclarationNode.cc
 void buildList( const DeclarationNode *firstNode, std::list< Declaration * > &outputList );
-void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType * > &outputList );
+void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType *> &outputList );
 void buildTypeList( const DeclarationNode *firstNode, std::list< Type * > &outputList );
-
-template< typename SynTreeType, typename NodeType >
-void buildMoveList( const NodeType *firstNode, std::list< SynTreeType * > &outputList ) {
-        buildList(firstNode, outputList);
-        delete firstNode;
-}
-
 
 #endif // PARSENODE_H