Changes in src/Parser/ParseNode.h [658fafe4:e869d663]

File:

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

src/Parser/ParseNode.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// ParseNode.h --
+// ParseNode.h -- 
 //
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 13:28:16 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Jul 24 02:17:00 2016
-// Update Count     : 269
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Aug 12 13:27:11 2015
+// Update Count     : 172
 //
 
@@ -20 +20 @@
 #include <list>
 #include <iterator>
-#include <memory>
-
-#include "Common/utility.h"
+
+#include "utility.h"
 #include "Parser/LinkageSpec.h"
 #include "SynTree/Type.h"
-#include "SynTree/Expression.h"
 //#include "SynTree/Declaration.h"
-#include "Common/UniqueName.h"
-#include "SynTree/Label.h"
+#include "UniqueName.h"
 
 class ExpressionNode;
@@ -43 +40 @@
         ParseNode();
         ParseNode( const std::string * );
-        ParseNode( const std::string & );                                       // for copy constructing subclasses
+        ParseNode( const std::string & );  // for copy constructing subclasses
         virtual ~ParseNode();
 
-        ParseNode *get_link() const { return next; }
+        ParseNode *get_link() const;
         ParseNode *get_last();
         ParseNode *set_link( ParseNode * );
@@ -62 +59 @@
   protected:
         std::string name;
+        ParseNode *next;
         static int indent_by;
-        ParseNode *next;
 };
 
@@ -77 +74 @@
         virtual ExpressionNode *clone() const = 0;
 
-        // virtual CommaExprNode *add_to_list( ExpressionNode * );
+        virtual CommaExprNode *add_to_list( ExpressionNode * );
 
         ExpressionNode *get_argName() const { return argName; }
         ExpressionNode *set_argName( const std::string *aName );
         ExpressionNode *set_argName( ExpressionNode *aDesignator );
-        bool get_extension() const { return extension; }
-        ExpressionNode *set_extension( bool exten ) { extension = exten; return this; }
 
         virtual void print( std::ostream &, int indent = 0) const = 0;
@@ -92 +87 @@
         void printDesignation ( std::ostream &, int indent = 0) const;
   private:
-        ExpressionNode *argName = 0;
-        bool extension = false;
-};
-
-template< typename T >
-struct maybeBuild_t<Expression, T> {
-        static inline Expression * doit( const T *orig ) {
-                if ( orig ) {
-                        Expression *p = orig->build();
-                        p->set_extension( orig->get_extension() );
-                        return p;
-                } else {
-                        return 0;
-                } // if
-        }
+        ExpressionNode *argName;
 };
 
@@ -126 +107 @@
         enum Type { Integer, Float, Character, String };
 
-        ConstantNode( ConstantExpr * );
-        ConstantNode( const ConstantNode &other ) : expr( other.expr->clone() ) {};
-        ~ConstantNode() { delete expr; }
+        ConstantNode( Type, std::string * );
+        ~ConstantNode() { delete &value; }
 
         virtual ConstantNode *clone() const { return new ConstantNode( *this ); }
-        virtual void print( std::ostream &, int indent = 0) const;
-        virtual void printOneLine( std::ostream &, int indent = 0) const;
-
+        Type get_type( void ) const { return type; }
+        virtual void print( std::ostream &, int indent = 0) const;
+        virtual void printOneLine( std::ostream &, int indent = 0) const;
+
+        const std::string &get_value() const { return value; }
         ConstantNode *appendstr( const std::string *newValue );
 
         Expression *build() const;
   private:
-        ConstantExpr *expr;
-};
-
-ConstantNode *makeConstantInteger( std::string & );
-ConstantNode *makeConstantFloat( std::string & );
-ConstantNode *makeConstantChar( std::string & );
-ConstantNode *makeConstantStr( std::string & );
+        Type type;
+        BasicType::Kind btype;
+        std::string &value;
+};
 
 class VarRefNode : public ExpressionNode {
@@ -195 +174 @@
 class OperatorNode : public ExpressionNode {
   public:
-        enum Type { TupleC, Comma, TupleFieldSel, // n-adic
-                                // triadic
-                                Cond, NCond,
-                                // diadic
-                                SizeOf, AlignOf, OffsetOf, Attr, Plus, Minus, Mul, Div, Mod, Or, And,
-                                BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq,
-                                Assign, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
-                                Index, FieldSel, PFieldSel, Range,
-                                // monadic
-                                UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress,
-                                Ctor, Dtor,
+        enum Type { TupleC, Comma, TupleFieldSel,
+                                Cond, NCond, 
+                                SizeOf, AlignOf, Attr, CompLit, Plus, Minus, Mul, Div, Mod, Or, And, 
+                                BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq, 
+                                Assign, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, 
+                                ERAssn, OrAssn, Index, FieldSel, PFieldSel, Range,
+                                UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress
         };
 
@@ -223 +198 @@
   private:
         Type type;
+        static const char *OpName[];
 };
 
@@ -286 +262 @@
         virtual void printOneLine( std::ostream &, int indent = 0) const;
 
-        const std::list< Label > &get_labels() const { return labels; };
+        const std::list< std::string > &get_labels() const { return labels; };
         void append_label( std::string *label ) { labels.push_back( *label ); delete label; }
   private:
-        std::list< Label > labels;
+        std::list< std::string > labels;
+};
+
+class CommaExprNode : public CompositeExprNode {
+  public:
+        CommaExprNode();
+        CommaExprNode( ExpressionNode * );
+        CommaExprNode( ExpressionNode *, ExpressionNode * );
+        CommaExprNode( const CommaExprNode &other );
+
+        virtual CommaExprNode *add_to_list( ExpressionNode * );
+        virtual CommaExprNode *clone() const { return new CommaExprNode( *this ); }
 };
 
@@ -319 +306 @@
         ValofExprNode( const ValofExprNode &other );
         ~ValofExprNode();
-
+  
         virtual ValofExprNode *clone() const { return new ValofExprNode( *this ); }
 
@@ -339 +326 @@
         enum BasicType { Char, Int, Float, Double, Void, Bool, Complex, Imaginary };
         enum Modifier  { Signed, Unsigned, Short, Long };
-        enum Aggregate { Struct, Union, Trait };
+        enum Aggregate { Struct, Union, Context };
         enum TypeClass { Type, Dtype, Ftype };
-        enum BuiltinType { Valist };
-
-        static const char *storageName[];
+
+        static const char *storageName[];  
         static const char *qualifierName[];
         static const char *basicTypeName[];
@@ -349 +335 @@
         static const char *aggregateName[];
         static const char *typeClassName[];
-        static const char *builtinTypeName[];
 
         static DeclarationNode *newFunction( std::string *name, DeclarationNode *ret, DeclarationNode *param, StatementNode *body, bool newStyle = false );
@@ -358 +343 @@
         static DeclarationNode *newForall( DeclarationNode *);
         static DeclarationNode *newFromTypedef( std::string *);
-        static DeclarationNode *newAggregate( Aggregate kind, const std::string *name, ExpressionNode *actuals, DeclarationNode *fields, bool body );
+        static DeclarationNode *newAggregate( Aggregate kind, const std::string *name, ExpressionNode *actuals, DeclarationNode *fields );
         static DeclarationNode *newEnum( std::string *name, DeclarationNode *constants );
         static DeclarationNode *newEnumConstant( std::string *name, ExpressionNode *constant );
@@ -364 +349 @@
         static DeclarationNode *newFromTypeGen( std::string *, ExpressionNode *params );
         static DeclarationNode *newTypeParam( TypeClass, std::string *);
-        static DeclarationNode *newTrait( std::string *name, DeclarationNode *params, DeclarationNode *asserts );
-        static DeclarationNode *newTraitUse( std::string *name, ExpressionNode *params );
+        static DeclarationNode *newContext( std::string *name, DeclarationNode *params, DeclarationNode *asserts );
+        static DeclarationNode *newContextUse( std::string *name, ExpressionNode *params );
         static DeclarationNode *newTypeDecl( std::string *name, DeclarationNode *typeParams );
         static DeclarationNode *newPointer( DeclarationNode *qualifiers );
@@ -375 +360 @@
         static DeclarationNode *newAttr( std::string *, ExpressionNode *expr );
         static DeclarationNode *newAttr( std::string *, DeclarationNode *type );
-        static DeclarationNode *newBuiltinType( BuiltinType );
 
         DeclarationNode *addQualifiers( DeclarationNode *);
@@ -414 +398 @@
         LinkageSpec::Type get_linkage() const { return linkage; }
         DeclarationNode *extractAggregate() const;
-        ExpressionNode *get_enumeratorValue() const { return enumeratorValue; }
-
-        bool get_extension() const { return extension; }
-        DeclarationNode *set_extension( bool exten ) { extension = exten; return this; }
 
         DeclarationNode();
@@ -430 +410 @@
         std::list< std::string > attributes;
         ExpressionNode *bitfieldWidth;
-        ExpressionNode *enumeratorValue;
         InitializerNode *initializer;
         bool hasEllipsis;
         LinkageSpec::Type linkage;
-        bool extension = false;
 
         static UniqueName anonymous;
@@ -441 +419 @@
 class StatementNode : public ParseNode {
   public:
-        enum Type { Exp,   If,        Switch,  Case,    Default,  Choose,   Fallthru,
+        enum Type { Exp,   If,        Switch,  Case,    Default,  Choose,   Fallthru, 
                                 While, Do,        For,
                                 Goto,  Continue,  Break,   Return,  Throw,
@@ -474 +452 @@
         std::string get_target() const;
 
-        // StatementNode *add_controlexp( ExpressionNode * );
+        StatementNode *add_controlexp( ExpressionNode * );
         StatementNode *append_block( StatementNode * );
         StatementNode *append_last_case( StatementNode * );
@@ -519 +497 @@
         ExpressionNode *output, *input;
         ConstantNode *clobber;
-        std::list< Label > gotolabels;
+        std::list<std::string> gotolabels;
+};
+
+class NullStmtNode : public CompoundStmtNode {
+  public:
+        Statement *build() const;
+        void print( std::ostream &, int indent = 0 ) const;
 };
 
@@ -533 +517 @@
         ExpressionNode *get_designators() const { return designator; }
 
-        InitializerNode *set_maybeConstructed( bool value ) { maybeConstructed = value; return this; }
-        bool get_maybeConstructed() const { return maybeConstructed; }
-
         InitializerNode *next_init() const { return kids; }
 
@@ -546 +527 @@
         bool aggregate;
         ExpressionNode *designator; // may be list
-        InitializerNode *kids;
-        bool maybeConstructed;
-};
-
-class CompoundLiteralNode : public ExpressionNode {
-  public:
-        CompoundLiteralNode( DeclarationNode *type, InitializerNode *kids );
-        CompoundLiteralNode( const CompoundLiteralNode &type );
-        ~CompoundLiteralNode();
-
-        virtual CompoundLiteralNode *clone() const;
-
-        DeclarationNode *get_type() const { return type; }
-        CompoundLiteralNode *set_type( DeclarationNode *t ) { type = t; return this; }
-
-        InitializerNode *get_initializer() const { return kids; }
-        CompoundLiteralNode *set_initializer( InitializerNode *k ) { kids = k; return this; }
-
-        void print( std::ostream &, int indent = 0 ) const;
-        void printOneLine( std::ostream &, int indent = 0 ) const;
-
-        virtual Expression *build() const;
-  private:
-        DeclarationNode *type;
         InitializerNode *kids;
 };
@@ -581 +538 @@
         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 *>( cur->build() );
                         if ( result ) {
                                 *out++ = result;