Changeset f441c88

Timestamp:

Nov 2, 2018, 4:14:33 PM (6 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

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

Children:

5753b33, 8e04794

Parents:

c45b304

Message:

Implement basetypeof

Location:

src

Files:

• Parser/TypeData.cc (modified) (2 diffs)
• ResolvExpr/ResolveTypeof.cc (modified) (1 diff)
• SynTree/Type.h (modified) (1 diff)
• SynTree/TypeofType.cc (modified) (2 diffs)

src/Parser/TypeData.cc

@@ -522 +522 @@
         switch ( td->kind ) {
           case TypeData::Unknown:
-                // fill in implicit int
-                return new BasicType( buildQualifiers( td ), BasicType::SignedInt );
+                        // fill in implicit int
+                        return new BasicType( buildQualifiers( td ), BasicType::SignedInt );
           case TypeData::Basic:
-                return buildBasicType( td );
+                        return buildBasicType( td );
           case TypeData::Pointer:
-                return buildPointer( td );
+                        return buildPointer( td );
           case TypeData::Array:
-                return buildArray( td );
+                        return buildArray( td );
           case TypeData::Reference:
-                return buildReference( td );
+                        return buildReference( td );
           case TypeData::Function:
-                return buildFunction( td );
+                        return buildFunction( td );
           case TypeData::AggregateInst:
-                return buildAggInst( td );
+                        return buildAggInst( td );
           case TypeData::EnumConstant:
-                // the name gets filled in later -- by SymTab::Validate
-                return new EnumInstType( buildQualifiers( td ), "" );
+                        // the name gets filled in later -- by SymTab::Validate
+                        return new EnumInstType( buildQualifiers( td ), "" );
           case TypeData::SymbolicInst:
-                return buildSymbolicInst( td );
+                        return buildSymbolicInst( td );
           case TypeData::Tuple:
-                return buildTuple( td );
+                        return buildTuple( td );
           case TypeData::Typeof:
           case TypeData::Basetypeof:
-                return buildTypeof( td );
+                        return buildTypeof( td );
           case TypeData::Builtin:
-                if(td->builtintype == DeclarationNode::Zero) {
-                        return new ZeroType( noQualifiers );
-                }
-                else if(td->builtintype == DeclarationNode::One) {
-                        return new OneType( noQualifiers );
-                }
-                else {
-                        return new VarArgsType( buildQualifiers( td ) );
-                }
+                        if (td->builtintype == DeclarationNode::Zero) {
+                                return new ZeroType( noQualifiers );
+                        }
+                        else if (td->builtintype == DeclarationNode::One) {
+                                return new OneType( noQualifiers );
+                        }
+                        else {
+                                return new VarArgsType( buildQualifiers( td ) );
+                        }
           case TypeData::GlobalScope:
-                return new GlobalScopeType();
+                        return new GlobalScopeType();
                 case TypeData::Qualified:
-                return new QualifiedType( buildQualifiers( td ), typebuild( td->qualified.parent ), typebuild( td->qualified.child ) );
+                        return new QualifiedType( buildQualifiers( td ), typebuild( td->qualified.parent ), typebuild( td->qualified.child ) );
           case TypeData::Symbolic:
           case TypeData::Enum:
           case TypeData::Aggregate:
-                assert( false );
+                        assert( false );
         } // switch
 
@@ -942 +942 @@
         assert( td->typeexpr );
         // assert( td->typeexpr->expr );
-        return new TypeofType( td->kind == TypeData::Basetypeof ? Type::Qualifiers{} : buildQualifiers( td ), td->typeexpr->build() );
+        return new TypeofType{ 
+                buildQualifiers( td ), td->typeexpr->build(), td->kind == TypeData::Basetypeof };
 } // buildTypeof
 

src/ResolvExpr/ResolveTypeof.cc

@@ -67 +67 @@
                 std::cerr << std::endl;
 #endif
-                if ( typeofType->expr ) {
+                // pass on null expression
+                if ( ! typeofType->expr ) return typeofType;
+
+                bool isBasetypeof = typeofType->is_basetypeof;
+                auto oldQuals = typeofType->get_qualifiers().val;
+
+                Type* newType;
+                if ( TypeExpr* tyExpr = dynamic_cast<TypeExpr*>(typeofType->expr) ) {
+                        // typeof wrapping type
+                        newType = tyExpr->type;
+                        tyExpr->type = nullptr;
+                        delete tyExpr;
+                } else {
+                        // typeof wrapping expression
                         Expression * newExpr = resolveInVoidContext( typeofType->expr, indexer );
                         assert( newExpr->result && ! newExpr->result->isVoid() );
-                        Type * newType = newExpr->result;
+                        newType = newExpr->result;
                         newExpr->result = nullptr;
                         delete typeofType;
                         delete newExpr;
-                        return newType;
-                } // if
-                return typeofType;
+                }
+
+                // clear qualifiers for base, combine with typeoftype quals in any case
+                if ( isBasetypeof ) {
+                        newType->get_qualifiers().val 
+                                = ( newType->get_qualifiers().val & ~Type::Qualifiers::Mask ) | oldQuals;
+                } else {
+                        newType->get_qualifiers().val |= oldQuals;
+                }
+                
+                return newType;
         }
 } // namespace ResolvExpr

src/SynTree/Type.h

@@ -598 +598 @@
 class TypeofType : public Type {
   public:
-        Expression *expr;
-
-        TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        Expression *expr;    ///< expression to take the type of
+        bool is_basetypeof;  ///< true iff is basetypeof type
+
+        TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        TypeofType( const Type::Qualifiers & tq, Expression *expr, bool is_basetypeof, 
+                const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         TypeofType( const TypeofType& );
         virtual ~TypeofType();

src/SynTree/TypeofType.cc

@@ -23 +23 @@
 class Attribute;
 
-TypeofType::TypeofType( const Type::Qualifiers &tq, Expression *expr, const std::list< Attribute * > & attributes ) : Type( tq, attributes ), expr( expr ) {
-}
+TypeofType::TypeofType( const Type::Qualifiers &tq, Expression *expr, 
+        const std::list< Attribute * > & attributes ) 
+: Type( tq, attributes ), expr( expr ), is_basetypeof(false) {}
 
-TypeofType::TypeofType( const TypeofType &other ) : Type( other ), expr( maybeClone( other.expr ) ) {
-}
+TypeofType::TypeofType( const Type::Qualifiers &tq, Expression *expr, bool is_basetypeof, 
+        const std::list< Attribute * > & attributes ) 
+: Type( tq, attributes ), expr( expr ), is_basetypeof( is_basetypeof ) {}
+
+TypeofType::TypeofType( const TypeofType &other )
+: Type( other ), expr( maybeClone( other.expr ) ), is_basetypeof( other.is_basetypeof ) {}
 
 TypeofType::~TypeofType() {
@@ -35 +40 @@
 void TypeofType::print( std::ostream &os, Indenter indent ) const {
         Type::print( os, indent );
+        if ( is_basetypeof ) { os << "base-"; }
         os << "type-of expression ";
         if ( expr ) {