Changeset 6b224a52 for src/SynTree

Timestamp:

Aug 25, 2017, 12:11:53 PM (8 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

bf7b9da7

Parents:

135b431 (diff), f676b84 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src/SynTree

Files:

• AddressExpr.cc (modified) (1 diff)
• ApplicationExpr.cc (modified) (1 diff)
• Declaration.h (modified) (3 diffs)
• Expression.cc (modified) (8 diffs)
• Expression.h (modified) (1 diff)
• Mutator.cc (modified) (1 diff)
• Mutator.h (modified) (1 diff)
• ReferenceType.cc (added)
• SynTree.h (modified) (1 diff)
• TupleExpr.cc (modified) (1 diff)
• Type.cc (modified) (2 diffs)
• Type.h (modified) (3 diffs)
• TypeExpr.cc (modified) (1 diff)
• TypeSubstitution.h (modified) (1 diff)
• Visitor.cc (modified) (2 diffs)
• Visitor.h (modified) (1 diff)
• module.mk (modified) (1 diff)

src/SynTree/AddressExpr.cc

@@ -21 +21 @@
 #include "Type.h"            // for PointerType, Type, Type::Qualifiers
 
+// Address expressions are typed based on the following inference rules:
+//    E : lvalue T  &..& (n references)
+//   &E :        T *&..& (n references)
+//
+//    E : T  &..&        (m references)
+//   &E : T *&..&        (m-1 references)
+//
+// That is, lvalues becomes
+
+namespace {
+        Type * addrType( Type * type ) {
+                if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( type ) ) {
+                        return new ReferenceType( refType->get_qualifiers(), addrType( refType->get_base() ) );
+                } else {
+                        return new PointerType( Type::Qualifiers(), type->clone() );
+                }
+        }
+}
+
 AddressExpr::AddressExpr( Expression *arg, Expression *_aname ) : Expression( _aname ), arg( arg ) {
         if ( arg->has_result() ) {
-                set_result( new PointerType( Type::Qualifiers(), arg->get_result()->clone() ) );
+                if ( arg->get_result()->get_lvalue() ) {
+                        // lvalue, retains all layers of reference and gains a pointer inside the references
+                        set_result( addrType( arg->get_result() ) );
+                } else {
+                        // taking address of non-lvalue -- must be a reference, loses one layer of reference
+                        ReferenceType * refType = safe_dynamic_cast< ReferenceType * >( arg->get_result() );
+                        set_result( addrType( refType->get_base() ) );
+                }
+                // result of & is never an lvalue
+                get_result()->set_lvalue( false );
         }
 }

src/SynTree/ApplicationExpr.cc

@@ -49 +49 @@
 }
 
-ApplicationExpr::ApplicationExpr( Expression *funcExpr, const std::list< Expression * > & argList ) : function( funcExpr ), args( argList ) {
+ApplicationExpr::ApplicationExpr( Expression *funcExpr, const std::list<Expression *> & args ) : function( funcExpr ), args( args ) {
         PointerType *pointer = safe_dynamic_cast< PointerType* >( funcExpr->get_result() );
         FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );

src/SynTree/Declaration.h

@@ -109 +109 @@
         virtual DeclarationWithType *acceptMutator( Mutator &m ) = 0;
 
-        virtual Type *get_type() const = 0;
+        virtual Type * get_type() const = 0;
         virtual void set_type(Type *) = 0;
 
@@ -128 +128 @@
         virtual ~ObjectDecl();
 
-        virtual Type *get_type() const { return type; }
+        virtual Type * get_type() const { return type; }
         virtual void set_type(Type *newType) { type = newType; }
 
@@ -155 +155 @@
         virtual ~FunctionDecl();
 
-        Type *get_type() const;
+        Type * get_type() const;
         virtual void set_type(Type *);
 
-        FunctionType *get_functionType() const { return type; }
+        FunctionType * get_functionType() const { return type; }
         void set_functionType( FunctionType *newValue ) { type = newValue; }
         CompoundStmt *get_statements() const { return statements; }

src/SynTree/Expression.cc

@@ -31 +31 @@
 #include "TypeSubstitution.h"        // for TypeSubstitution
 
+#include "GenPoly/Lvalue.h"
 
 Expression::Expression( Expression *_aname ) : result( 0 ), env( 0 ), argName( _aname ) {}
@@ -89 +90 @@
 }
 
+VariableExpr * VariableExpr::functionPointer( FunctionDecl * func ) {
+        VariableExpr * funcExpr = new VariableExpr( func );
+        funcExpr->set_result( new PointerType( Type::Qualifiers(), funcExpr->get_result() ) );
+        return funcExpr;
+}
+
 void VariableExpr::print( std::ostream &os, int indent ) const {
         os << "Variable Expression: ";
@@ -149 +156 @@
 
 void AlignofExpr::print( std::ostream &os, int indent) const {
-        os << std::string( indent, ' ' ) << "Alignof Expression on: ";
+        os << "Alignof Expression on: ";
 
         if (isType)
@@ -258 +265 @@
 
 void AttrExpr::print( std::ostream &os, int indent) const {
-        os << std::string( indent, ' ' ) << "Attr ";
+        os << "Attr ";
         attr->print( os, indent + 2 );
         if ( isType || expr ) {
@@ -357 +364 @@
 namespace {
         TypeSubstitution makeSub( Type * t ) {
-                if ( StructInstType * aggInst = dynamic_cast< StructInstType * >( t ) ) {
+                if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( t ) ) {
+                        return makeSub( refType->get_base() );
+                } else if ( StructInstType * aggInst = dynamic_cast< StructInstType * >( t ) ) {
                         return TypeSubstitution( aggInst->get_baseParameters()->begin(), aggInst->get_baseParameters()->end(), aggInst->get_parameters().begin() );
                 } else if ( UnionInstType * aggInst = dynamic_cast< UnionInstType * >( t ) ) {
@@ -422 +431 @@
         if ( Type * type = expr->get_result() ) {
                 Type * base = InitTweak::getPointerBase( type );
-                if ( ! base ) {
-                        std::cerr << type << std::endl;
+                assertf( base, "expected pointer type in dereference (type was %s)", toString( type ).c_str() );
+                ret->set_result( base->clone() );
+                if ( GenPoly::referencesPermissable() ) {
+                        // if references are still allowed in the AST, dereference returns a reference
+                        ret->set_result( new ReferenceType( Type::Qualifiers(), ret->get_result() ) );
+                } else {
+                        // references have been removed, in which case dereference returns an lvalue of the base type.
+                        ret->get_result()->set_lvalue( true );
                 }
-                assertf( base, "expected pointer type in dereference\n" );
-                ret->set_result( maybeClone( base ) );
         }
         return ret;
@@ -490 +503 @@
 
 void LogicalExpr::print( std::ostream &os, int indent )const {
-        os << std::string( indent, ' ' ) << "Short-circuited operation (" << (isAnd?"and":"or") << ") on: ";
+        os << "Short-circuited operation (" << (isAnd?"and":"or") << ") on: ";
         arg1->print(os);
         os << " and ";
@@ -595 +608 @@
 CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : initializer( initializer ) {
         assert( type && initializer );
+        type->set_lvalue( true );
         set_result( type );
 }

src/SynTree/Expression.h

@@ -284 +284 @@
         void set_var( DeclarationWithType * newValue ) { var = newValue; }
 
+        static VariableExpr * functionPointer( FunctionDecl * decl );
+
         virtual VariableExpr * clone() const { return new VariableExpr( * this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }

src/SynTree/Mutator.cc

@@ -502 +502 @@
 }
 
-Type * Mutator::mutate( FunctionType *functionType ) {
+Type * Mutator::mutate( ReferenceType * refType ) {
+        mutateAll( refType->get_forall(), *this );
+        refType->set_base( maybeMutate( refType->get_base(), *this ) );
+        return refType;
+}
+
+Type * Mutator::mutate( FunctionType * functionType ) {
         mutateAll( functionType->get_forall(), *this );
         mutateAll( functionType->get_returnVals(), *this );

src/SynTree/Mutator.h

@@ -93 +93 @@
         virtual Type* mutate( PointerType *pointerType );
         virtual Type* mutate( ArrayType *arrayType );
+        virtual Type* mutate( ReferenceType *refType );
         virtual Type* mutate( FunctionType *functionType );
         virtual Type* mutate( StructInstType *aggregateUseType );

src/SynTree/SynTree.h

@@ -102 +102 @@
 class PointerType;
 class ArrayType;
+class ReferenceType;
 class FunctionType;
 class ReferenceToType;

src/SynTree/TupleExpr.cc

@@ -67 +67 @@
         assertf( type->size() > index, "TupleIndexExpr index out of bounds: tuple size %d, requested index %d in expr %s", type->size(), index, toString( tuple ).c_str() );
         set_result( (*std::next( type->get_types().begin(), index ))->clone() );
-        get_result()->set_lvalue( type->get_lvalue() );
+        // like MemberExpr, TupleIndexExpr is always an lvalue
+        get_result()->set_lvalue( true );
 }
 

src/SynTree/Type.cc

@@ -64 +64 @@
 const char * Type::QualifiersNames[] = { "const", "restrict", "volatile", "lvalue", "mutex", "_Atomic" };
 
-Type *Type::stripDeclarator() {
+Type * Type::stripDeclarator() {
         Type * type = this;
         while ( Type * at = InitTweak::getPointerBase( type ) ) {
@@ -71 +71 @@
         return type;
 }
+
+Type * Type::stripReferences() {
+        Type * type = this;
+        while ( ReferenceType * ref = dynamic_cast<ReferenceType *>( type ) ) {
+                type = ref->get_base();
+        }
+        return type;
+}
+
+int Type::referenceDepth() const { return 0; }
 
 void Type::print( std::ostream &os, int indent ) const {

src/SynTree/Type.h

@@ -168 +168 @@
 
         /// 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 +268 @@
         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 +304 @@
 };
 
+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:

src/SynTree/TypeExpr.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// TypeExpr.cc -- 
+// TypeExpr.cc --
 //
 // Author           : Richard C. Bilson

src/SynTree/TypeSubstitution.h

@@ -117 +117 @@
                                 } // if
                         } else {
-                                throw SemanticError( "Attempt to provide non-type parameter for type parameter", formal );
+                                throw SemanticError( toString( "Attempt to provide non-type parameter: ", toString( *actualIt ).c_str(), " for type parameter " ), formal );
                         } // if
                 } else {

src/SynTree/Visitor.cc

@@ -389 +389 @@
 void Visitor::visit( PointerType *pointerType ) {
         acceptAll( pointerType->get_forall(), *this );
+        // xxx - should PointerType visit/mutate dimension?
         maybeAccept( pointerType->get_base(), *this );
 }
@@ -396 +397 @@
         maybeAccept( arrayType->get_dimension(), *this );
         maybeAccept( arrayType->get_base(), *this );
+}
+
+void Visitor::visit( ReferenceType *refType ) {
+        acceptAll( refType->get_forall(), *this );
+        maybeAccept( refType->get_base(), *this );
 }
 

src/SynTree/Visitor.h

@@ -95 +95 @@
         virtual void visit( PointerType *pointerType );
         virtual void visit( ArrayType *arrayType );
+        virtual void visit( ReferenceType *refType );
         virtual void visit( FunctionType *functionType );
         virtual void visit( StructInstType *aggregateUseType );

src/SynTree/module.mk

@@ -20 +20 @@
        SynTree/PointerType.cc \
        SynTree/ArrayType.cc \
+       SynTree/ReferenceType.cc \
        SynTree/FunctionType.cc \
        SynTree/ReferenceToType.cc \