Changes in src/Parser/ParseNode.h [25bca42:033ff37]

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 : Wed Jun  6 16:17:18 2018
-// Update Count     : 843
+// Last Modified On : Thu Jul 25 22:17:10 2019
+// Update Count     : 876
 //
 
@@ -68 +68 @@
         }
 
-        virtual void print( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const {}
-        virtual void printList( std::ostream &os, int indent = 0 ) const {
+        virtual void print( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const {}
+        virtual void printList( std::ostream & os, int indent = 0 ) const {
                 print( os, indent );
                 if ( next ) next->print( os, indent );
@@ -103 +103 @@
         InitializerNode * next_init() const { return kids; }
 
-        void print( std::ostream &os, int indent = 0 ) const;
+        void print( std::ostream & os, int indent = 0 ) const;
         void printOneLine( std::ostream & ) const;
 
@@ -127 +127 @@
         ExpressionNode * set_extension( bool exten ) { extension = exten; return this; }
 
-        virtual void print( std::ostream &os, __attribute__((unused)) int indent = 0 ) const override {
-                os << expr.get() << std::endl;
-        }
-        void printOneLine( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const {}
+        virtual void print( std::ostream & os, __attribute__((unused)) int indent = 0 ) const override {
+                os << expr.get();
+        }
+        void printOneLine( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const {}
 
         template<typename T>
@@ -136 +136 @@
 
         Expression * build() const { return const_cast<ExpressionNode *>(this)->expr.release(); }
+
+        std::unique_ptr<Expression> expr;                                       // public because of lifetime implications
   private:
         bool extension = false;
-        std::unique_ptr<Expression> expr;
 }; // ExpressionNode
 
@@ -205 +206 @@
 class DeclarationNode : public ParseNode {
   public:
-        // These enumerations must harmonize with their names.
-        enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, Int128, Float80, Float128, NoBasicType };
+        // These enumerations must harmonize with their names in DeclarationNode.cc.
+        enum BasicType { Void, Bool, Char, Int, Int128,
+                                         Float, Double, LongDouble, uuFloat80, uuFloat128,
+                                         uFloat16, uFloat32, uFloat32x, uFloat64, uFloat64x, uFloat128, uFloat128x, NoBasicType };
         static const char * basicTypeNames[];
-        enum ComplexType { Complex, Imaginary, NoComplexType };
+        enum ComplexType { Complex, NoComplexType, Imaginary }; // Imaginary unsupported => parse, but make invisible and print error message
         static const char * complexTypeNames[];
         enum Signedness { Signed, Unsigned, NoSignedness };
@@ -218 +221 @@
         enum TypeClass { Otype, Dtype, Ftype, Ttype, NoTypeClass };
         static const char * typeClassNames[];
-        enum BuiltinType { Valist, Zero, One, NoBuiltinType };
+        enum BuiltinType { Valist, AutoType, Zero, One, NoBuiltinType };
         static const char * builtinTypeNames[];
 
@@ -231 +234 @@
         static DeclarationNode * newForall( DeclarationNode * );
         static DeclarationNode * newFromTypedef( const std::string * );
+        static DeclarationNode * newFromGlobalScope();
+        static DeclarationNode * newQualifiedType( DeclarationNode *, DeclarationNode * );
         static DeclarationNode * newFunction( const std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body );
         static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
@@ -246 +251 @@
         static DeclarationNode * newBitfield( ExpressionNode * size );
         static DeclarationNode * newTuple( DeclarationNode * members );
-        static DeclarationNode * newTypeof( ExpressionNode * expr );
-        static DeclarationNode * newAttr( const std::string *, ExpressionNode * expr ); // @ attributes
-        static DeclarationNode * newAttr( const std::string *, DeclarationNode * type ); // @ attributes
+        static DeclarationNode * newTypeof( ExpressionNode * expr, bool basetypeof = false );
         static DeclarationNode * newAttribute( const std::string *, ExpressionNode * expr = nullptr ); // gcc attributes
         static DeclarationNode * newAsmStmt( StatementNode * stmt ); // gcc external asm statement
@@ -288 +291 @@
         }
 
-        virtual void print( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const override;
-        virtual void printList( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const override;
+        virtual void print( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const override;
+        virtual void printList( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const override;
 
         Declaration * build() const;
@@ -301 +304 @@
         bool get_extension() const { return extension; }
         DeclarationNode * set_extension( bool exten ) { extension = exten; return this; }
+
+        bool get_inLine() const { return inLine; }
+        DeclarationNode * set_inLine( bool inL ) { inLine = inL; return this; }
   public:
         DeclarationNode * get_last() { return (DeclarationNode *)ParseNode::get_last(); }
@@ -325 +331 @@
         StaticAssert_t assert;
 
-        BuiltinType builtin;
-
-        TypeData * type;
-
+        BuiltinType builtin = NoBuiltinType;
+
+        TypeData * type = nullptr;
+
+        bool inLine = false;
         Type::FuncSpecifiers funcSpecs;
         Type::StorageClasses storageClasses;
 
-        ExpressionNode * bitfieldWidth;
+        ExpressionNode * bitfieldWidth = nullptr;
         std::unique_ptr<ExpressionNode> enumeratorValue;
-        bool hasEllipsis;
+        bool hasEllipsis = false;
         LinkageSpec::Spec linkage;
-        Expression * asmName;
+        Expression * asmName = nullptr;
         std::list< Attribute * > attributes;
-        InitializerNode * initializer;
+        InitializerNode * initializer = nullptr;
         bool extension = false;
         std::string error;
-        StatementNode * asmStmt;
+        StatementNode * asmStmt = nullptr;
 
         static UniqueName anonymous;
@@ -375 +382 @@
         virtual StatementNode * append_last_case( StatementNode * );
 
-        virtual void print( std::ostream &os, __attribute__((unused)) int indent = 0 ) const override {
+        virtual void print( std::ostream & os, __attribute__((unused)) int indent = 0 ) const override {
                 os << stmt.get() << std::endl;
         }
@@ -384 +391 @@
 Statement * build_expr( ExpressionNode * ctl );
 
-struct IfCtl {
-        IfCtl( DeclarationNode * decl, ExpressionNode * condition ) :
+struct IfCtrl {
+        IfCtrl( DeclarationNode * decl, ExpressionNode * condition ) :
                 init( decl ? new StatementNode( decl ) : nullptr ), condition( condition ) {}
 
@@ -392 +399 @@
 };
 
-struct ForCtl {
-        ForCtl( ExpressionNode * expr, ExpressionNode * condition, ExpressionNode * change ) :
+struct ForCtrl {
+        ForCtrl( ExpressionNode * expr, ExpressionNode * condition, ExpressionNode * change ) :
                 init( new StatementNode( build_expr( expr ) ) ), condition( condition ), change( change ) {}
-        ForCtl( DeclarationNode * decl, ExpressionNode * condition, ExpressionNode * change ) :
+        ForCtrl( DeclarationNode * decl, ExpressionNode * condition, ExpressionNode * change ) :
                 init( new StatementNode( decl ) ), condition( condition ), change( change ) {}
 
@@ -403 +410 @@
 };
 
-Expression * build_if_control( IfCtl * ctl, std::list< Statement * > & init );
-Statement * build_if( IfCtl * ctl, StatementNode * then_stmt, StatementNode * else_stmt );
+Expression * build_if_control( IfCtrl * ctl, std::list< Statement * > & init );
+Statement * build_if( IfCtrl * ctl, StatementNode * then_stmt, StatementNode * else_stmt );
 Statement * build_switch( bool isSwitch, ExpressionNode * ctl, StatementNode * stmt );
 Statement * build_case( ExpressionNode * ctl );
 Statement * build_default();
-Statement * build_while( IfCtl * ctl, StatementNode * stmt );
+Statement * build_while( IfCtrl * ctl, StatementNode * stmt );
 Statement * build_do_while( ExpressionNode * ctl, StatementNode * stmt );
-Statement * build_for( ForCtl * forctl, StatementNode * stmt );
+Statement * build_for( ForCtrl * forctl, StatementNode * stmt );
 Statement * build_branch( BranchStmt::Type kind );
 Statement * build_branch( std::string * identifier, BranchStmt::Type kind );
@@ -428 +435 @@
 WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when );
 WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when, StatementNode * else_stmt, ExpressionNode * else_when );
-WithStmt * build_with( ExpressionNode * exprs, StatementNode * stmt );
+Statement * build_with( ExpressionNode * exprs, StatementNode * stmt );
 
 //##############################################################################
 
 template< typename SynTreeType, typename NodeType, template< typename, typename...> class Container, typename... Args >
-void buildList( const NodeType * firstNode, Container< SynTreeType *, Args... > &outputList ) {
+void buildList( const NodeType * firstNode, Container< SynTreeType *, Args... > & outputList ) {
         SemanticErrorException errors;
         std::back_insert_iterator< Container< SynTreeType *, Args... > > out( outputList );
@@ -447 +454 @@
                                 assertf(false, "buildList unknown type");
                         } // if
-                } catch( SemanticErrorException &e ) {
+                } catch( SemanticErrorException & e ) {
                         errors.append( e );
                 } // try
@@ -458 +465 @@
 
 // in DeclarationNode.cc
-void buildList( const DeclarationNode * firstNode, std::list< Declaration * > &outputList );
-void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > &outputList );
-void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > &outputList );
+void buildList( const DeclarationNode * firstNode, std::list< Declaration * > & 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 ) {
+void buildMoveList( const NodeType * firstNode, std::list< SynTreeType * > & outputList ) {
         buildList( firstNode, outputList );
         delete firstNode;