Changes in src/SynTree/Type.h [ea6332d:5ccb10d]

File:

• src/SynTree/Type.h (modified) (4 diffs)

src/SynTree/Type.h

@@ -16 +16 @@
 #pragma once
 
-#include <strings.h>         // for ffs
-#include <cassert>           // for assert, assertf
-#include <list>              // for list, _List_iterator
-#include <ostream>           // for ostream, operator<<, basic_ostream
-#include <string>            // for string
-
-#include "BaseSyntaxNode.h"  // for BaseSyntaxNode
-#include "Common/utility.h"  // for operator+
-#include "Mutator.h"         // for Mutator
-#include "SynTree.h"         // for AST nodes
-#include "Visitor.h"         // for Visitor
+#include "BaseSyntaxNode.h"
+#include "Mutator.h"
+#include "SynTree.h"
+#include "Visitor.h"
+#include <strings.h>                                                                    // ffs
 
 class Type : public BaseSyntaxNode {
@@ -168 +162 @@
 
         /// return type without outer pointers and arrays
-        Type *stripDeclarator();
+        Type * stripDeclarator();
+
+        /// return type without outer references
+        Type * stripReferences();
+
+        /// return the number of references occuring consecutively on the outermost layer of this type (i.e. do not count references nested within other types)
+        virtual int referenceDepth() const;
 
         virtual bool isComplete() const { return true; }
@@ -262 +262 @@
         bool is_array() const { return isStatic || isVarLen || dimension; }
 
+        virtual bool isComplete() const { return ! isVarLen; }
+
         virtual PointerType *clone() const { return new PointerType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
@@ -296 +298 @@
 };
 
+class ReferenceType : public Type {
+public:
+        Type *base;
+
+        ReferenceType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        ReferenceType( const ReferenceType & );
+        virtual ~ReferenceType();
+
+        Type *get_base() { return base; }
+        void set_base( Type *newValue ) { base = newValue; }
+
+        virtual int referenceDepth() const;
+
+        // Since reference types act like value types, their size is the size of the base.
+        // This makes it simple to cast the empty tuple to a reference type, since casts that increase
+        // the number of values are disallowed.
+        virtual unsigned size() const { return base->size(); }
+
+        virtual ReferenceType *clone() const { return new ReferenceType( *this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
+};
+
 class FunctionType : public Type {
   public: