Changes in src/Parser/ParseNode.h [413ad05:8cc5cb0]

File:

• src/Parser/ParseNode.h (modified) (22 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 : Sun Aug 28 21:14:51 2016
-// Update Count     : 575
+// Last Modified On : Thu Aug 11 12:24:11 2016
+// Update Count     : 443
 //
 
@@ -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 *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();
+        ParseNode( const std::string * );
+        ParseNode( const std::string & );                                       // for copy constructing subclasses
+        virtual ~ParseNode();
+
+        ParseNode *get_link() const { return next; }
+        ParseNode *get_last();
+        ParseNode *set_link( ParseNode * );
+        void set_next( ParseNode *newlink ) { next = newlink; }
+
+        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;
+};
+
+ParseNode *mkList( ParseNode & );
 
 //##############################################################################
@@ -77 +74 @@
         InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode *des = 0 );
         ~InitializerNode();
-        virtual InitializerNode *clone() const { assert( false ); return nullptr; }
 
         ExpressionNode *get_expression() const { return expr; }
@@ -96 +92 @@
         ExpressionNode *expr;
         bool aggregate;
-        ExpressionNode *designator;                                                     // may be list
+        ExpressionNode *designator; // may be list
         InitializerNode *kids;
         bool maybeConstructed;
-}; // InitializerNode
-
-//##############################################################################
-
-class ExpressionNode final : public ParseNode {
+};
+
+//##############################################################################
+
+class ExpressionNode : public ParseNode {
   public:
         ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {}
@@ -109 +105 @@
         ExpressionNode( const ExpressionNode &other );
         virtual ~ExpressionNode() {}
-        virtual ExpressionNode *clone() const { return expr ? new ExpressionNode( expr->clone() ) : 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;
-}; // ExpressionNode
+        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 +128 @@
                         return p;
                 } else {
-                        return nullptr;
+                        return 0;
                 } // if
         }
 };
+
+//##############################################################################
+
+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 );
+
+//##############################################################################
+
+Expression *build_typevalue( DeclarationNode *decl );
+
+//##############################################################################
 
 enum class OperKinds {
@@ -145 +154 @@
         SizeOf, AlignOf, OffsetOf, Plus, Minus, Mul, Div, Mod, Or, And,
         BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq,
-        Assign, AtAssn, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
+        Assign, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
         Index, Range,
         // monadic
         UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress,
         Ctor, Dtor,
-}; // OperKinds
-
-struct LabelNode {
-        std::list< Label > labels;
-};
-
-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 );
-
-NameExpr *build_varref( const std::string *name, bool labelp = false );
-Expression *build_typevalue( DeclarationNode *decl );
+};
 
 Expression *build_cast( DeclarationNode * decl_node, ExpressionNode *expr_node );
@@ -186 +183 @@
 Expression *build_func( ExpressionNode * function, ExpressionNode * expr_node );
 Expression *build_range( ExpressionNode * low, ExpressionNode *high );
-Expression *build_asmexpr( ExpressionNode *inout, ConstantExpr *constraint, ExpressionNode *operand );
+
+//##############################################################################
+
+Expression *build_asm( ExpressionNode *inout, ConstantExpr *constraint, ExpressionNode *operand );
+
+//##############################################################################
+
+class LabelNode : public ExpressionNode {
+  public:
+        virtual Expression *build() const { return NULL; }
+        virtual LabelNode *clone() const { assert( false ); return new LabelNode( *this ); }
+
+        virtual void print( std::ostream &os, int indent = 0) const;
+        virtual void printOneLine( std::ostream &os, int indent = 0) const;
+
+        const std::list< Label > &get_labels() const { return labels; };
+        void append_label( std::string * label ) { labels.push_back( *label ); delete label; }
+  private:
+        std::list< Label > labels;
+};
+
+//##############################################################################
+
 Expression *build_valexpr( StatementNode *s );
+
+//##############################################################################
+
 Expression *build_compoundLiteral( DeclarationNode *decl_node, InitializerNode *kids );
 
@@ -196 +218 @@
 class DeclarationNode : public ParseNode {
   public:
-        enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic, NoOfQualifier };
+        enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic };
         enum StorageClass { Extern, Static, Auto, Register, Inline, Fortran, Noreturn, Threadlocal, NoStorageClass, };
         enum BasicType { Char, Int, Float, Double, Void, Bool, Complex, Imaginary };
@@ -204 +226 @@
         enum BuiltinType { Valist };
 
+        static const char *storageName[];
         static const char *qualifierName[];
-        static const char *storageName[];
         static const char *basicTypeName[];
         static const char *modifierName[];
@@ -214 +236 @@
         static DeclarationNode *newFunction( std::string *name, DeclarationNode *ret, DeclarationNode *param, StatementNode *body, bool newStyle = false );
         static DeclarationNode *newQualifier( Qualifier );
-        static DeclarationNode *newForall( DeclarationNode *);
         static DeclarationNode *newStorageClass( StorageClass );
         static DeclarationNode *newBasicType( BasicType );
         static DeclarationNode *newModifier( Modifier );
-        static DeclarationNode *newBuiltinType( BuiltinType );
+        static DeclarationNode *newForall( DeclarationNode *);
         static DeclarationNode *newFromTypedef( std::string *);
         static DeclarationNode *newAggregate( Aggregate kind, const std::string *name, ExpressionNode *actuals, DeclarationNode *fields, bool body );
@@ -237 +258 @@
         static DeclarationNode *newAttr( std::string *, ExpressionNode *expr );
         static DeclarationNode *newAttr( std::string *, DeclarationNode *type );
-
-        DeclarationNode();
-        ~DeclarationNode();
-        DeclarationNode *clone() const;
+        static DeclarationNode *newBuiltinType( BuiltinType );
 
         DeclarationNode *addQualifiers( DeclarationNode *);
-        void checkQualifiers( const TypeData *, const TypeData * );
         DeclarationNode *copyStorageClasses( DeclarationNode *);
         DeclarationNode *addType( DeclarationNode *);
@@ -258 +275 @@
         DeclarationNode *addNewArray( DeclarationNode *array );
         DeclarationNode *addParamList( DeclarationNode *list );
-        DeclarationNode *addIdList( DeclarationNode *list ); // old-style functions
+        DeclarationNode *addIdList( DeclarationNode *list );       // old-style functions
         DeclarationNode *addInitializer( InitializerNode *init );
 
@@ -267 +284 @@
         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;
@@ -279 +295 @@
         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;
-        bool has_enumeratorValue() const { return (bool)enumeratorValue; }
-        ExpressionNode *consume_enumeratorValue() const { return const_cast<DeclarationNode*>(this)->enumeratorValue.release(); }
+        ExpressionNode *get_enumeratorValue() const { return enumeratorValue; }
 
         bool get_extension() const { return extension; }
         DeclarationNode *set_extension( bool exten ) { extension = exten; return this; }
-  public:
-        // StorageClass buildStorageClass() const;
-        // bool buildFuncSpecifier( StorageClass key ) const;
+
+        DeclarationNode();
+        ~DeclarationNode();
+  private:
+        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;
-        std::unique_ptr<ExpressionNode> enumeratorValue;
+        ExpressionNode *enumeratorValue;
         InitializerNode *initializer;
         bool hasEllipsis;
-        LinkageSpec::Spec linkage;
+        LinkageSpec::Type linkage;
         bool extension = false;
-        std::string error;
 
         static UniqueName anonymous;
@@ -308 +323 @@
 
 Type *buildType( TypeData *type );
-//Type::Qualifiers buildQualifiers( const TypeData::Qualifiers & qualifiers );
-
-static inline Type * maybeMoveBuildType( const DeclarationNode *orig ) {
-        Type* ret = orig ? orig->buildType() : nullptr;
-        delete orig;
-        return ret;
-}
-
-//##############################################################################
-
-class StatementNode final : public ParseNode {
-  public:
-        StatementNode() { stmt = nullptr; }
-        StatementNode( Statement *stmt ) : stmt( stmt ) {}
+
+//##############################################################################
+
+class StatementNode : public ParseNode {
+  public:
+        enum Type { Exp,   If,        Switch,  Case,    Default,  Choose,   Fallthru,
+                                While, Do,        For,
+                                Goto,  Continue,  Break,   Return,  Throw,
+                                Try,   Catch,     Finally, Asm,
+                                Decl
+        };
+
+        StatementNode();
+        StatementNode( const std::string *name );
+        StatementNode( Type t, ExpressionNode *control = 0, StatementNode *block = 0 );
+        StatementNode( Type t, std::string *target );
         StatementNode( DeclarationNode *decl );
-        virtual ~StatementNode() {}
-
-        virtual StatementNode *clone() const final { assert( false ); return nullptr; }
-        Statement *build() const { return const_cast<StatementNode*>(this)->stmt.release(); }
-
-        virtual StatementNode *add_label( const std::string * name ) {
+
+        ~StatementNode();
+
+        static StatementNode *newCatchStmt( DeclarationNode *d = 0, StatementNode *s = 0, bool catchRestP = false );
+
+        StatementNode *set_block( StatementNode *b ) { block = b; return this; }
+        StatementNode *get_block() const { return block; }
+
+        void set_control( ExpressionNode *c ) { control = c; }
+        ExpressionNode *get_control() const { return control; }
+
+        StatementNode::Type get_type() const { return type; }
+
+        virtual StatementNode *add_label( const std::string * );
+        virtual std::list<std::string> get_labels() const { return labels; }
+
+        void addDeclaration( DeclarationNode *newDecl ) { decl = newDecl; }
+        void setCatchRest( bool newVal ) { isCatchRest = newVal; }
+
+        std::string get_target() const;
+
+        // StatementNode *add_controlexp( ExpressionNode * );
+        StatementNode *append_block( StatementNode * );
+        virtual StatementNode *append_last_case( StatementNode * );
+
+        void print( std::ostream &os, int indent = 0) const;
+        virtual StatementNode *clone() const;
+        virtual Statement *build() const;
+  private:
+        static const char *StType[];
+        Type type;
+        ExpressionNode *control;
+        StatementNode *block;
+        std::list<std::string> labels;
+        std::string *target;                            // target label for jump statements
+        DeclarationNode *decl;
+        bool isCatchRest;
+}; // StatementNode
+
+class StatementNode2 : public StatementNode {
+  public:
+        StatementNode2() {}
+        StatementNode2( Statement *stmt ) : stmt( stmt ) {}
+        virtual ~StatementNode2() {}
+
+        virtual StatementNode2 *clone() const { assert( false ); return nullptr; }
+        virtual Statement *build() const { return stmt; }
+
+        virtual StatementNode2 *add_label( const std::string * name ) {
                 stmt->get_labels().emplace_back( *name );
-                delete name;
                 return this;
         }
-
         virtual StatementNode *append_last_case( StatementNode * );
+        virtual std::list<std::string> get_labels() const { assert( false ); return StatementNode::get_labels(); }
 
         virtual void print( std::ostream &os, int indent = 0 ) {}
         virtual void printList( std::ostream &os, int indent = 0 ) {}
   private:
-        std::unique_ptr<Statement> stmt;
+        Statement *stmt;
 }; // StatementNode
-
-Statement *build_expr( ExpressionNode *ctl );
 
 struct ForCtl {
         ForCtl( ExpressionNode *expr, ExpressionNode *condition, ExpressionNode *change ) :
-                init( new StatementNode( build_expr( expr ) ) ), condition( condition ), change( change ) {}
+                init( new StatementNode( StatementNode::Exp, expr ) ), condition( condition ), change( change ) {}
         ForCtl( DeclarationNode *decl, ExpressionNode *condition, ExpressionNode *change ) :
                 init( new StatementNode( decl ) ), condition( condition ), change( change ) {}
@@ -355 +412 @@
 };
 
+Statement *build_expr( ExpressionNode *ctl );
 Statement *build_if( ExpressionNode *ctl, StatementNode *then_stmt, StatementNode *else_stmt );
 Statement *build_switch( ExpressionNode *ctl, StatementNode *stmt );
@@ -361 +419 @@
 Statement *build_while( ExpressionNode *ctl, StatementNode *stmt, bool kind = false );
 Statement *build_for( ForCtl *forctl, StatementNode *stmt );
-Statement *build_branch( BranchStmt::Type kind );
-Statement *build_branch( std::string *identifier, BranchStmt::Type kind );
+Statement *build_branch( std::string identifier, BranchStmt::Type kind );
 Statement *build_computedgoto( ExpressionNode *ctl );
 Statement *build_return( ExpressionNode *ctl );
 Statement *build_throw( ExpressionNode *ctl );
-Statement *build_try( StatementNode *try_stmt, StatementNode *catch_stmt, StatementNode *finally_stmt );
-Statement *build_catch( DeclarationNode *decl, StatementNode *stmt, bool catchAny = false );
-Statement *build_finally( StatementNode *stmt );
-Statement *build_compound( StatementNode *first );
-Statement *build_asmstmt( bool voltile, ConstantExpr *instruction, ExpressionNode *output = 0, ExpressionNode *input = 0, ExpressionNode *clobber = 0, LabelNode *gotolabels = 0 );
+
+//##############################################################################
+
+class CompoundStmtNode : public StatementNode {
+  public:
+        CompoundStmtNode();
+        CompoundStmtNode( const std::string * );
+        CompoundStmtNode( StatementNode * );
+        ~CompoundStmtNode();
+
+        void add_statement( StatementNode * );
+
+        void print( std::ostream &os, int indent = 0 ) const;
+        virtual Statement *build() const;
+  private:
+        StatementNode *first, *last;
+};
+
+//##############################################################################
+
+class AsmStmtNode : public StatementNode {
+  public:
+        AsmStmtNode( Type, bool voltile, ConstantExpr *instruction, ExpressionNode *output = 0, ExpressionNode *input = 0, ExpressionNode *clobber = 0, LabelNode *gotolabels = 0 );
+        ~AsmStmtNode();
+
+        void print( std::ostream &os, int indent = 0 ) const;
+        Statement *build() const;
+  private:
+        bool voltile;
+        ConstantExpr *instruction;
+        ExpressionNode *output, *input;
+        ExpressionNode *clobber;
+        std::list< Label > gotolabels;
+};
 
 //##############################################################################
@@ -377 +463 @@
 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;
@@ -391 +477 @@
                         errors.append( e );
                 } // try
-                cur = dynamic_cast< NodeType * >( cur->get_next() );
+                cur = dynamic_cast< NodeType *>( cur->get_link() );
         } // while
         if ( ! errors.isEmpty() ) {
@@ -400 +486 @@
 // 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