Changeset 0f6a7752

Timestamp:

Jun 24, 2019, 2:28:10 PM (5 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

093a5d7

Parents:

08c0780

Message:

Put in temporary patch to finish new resolver port

Location:

src

Files:

• AST/Type.hpp (modified) (1 diff)
• ResolvExpr/ResolveTypeof.cc (modified) (4 diffs)
• ResolvExpr/Resolver.cc (modified) (2 diffs)

src/AST/Type.hpp

@@ -164 +164 @@
         static const char *typeNames[];
 
-        BasicType( Kind k, CV::Qualifiers q = {} ) : Type(q), kind(k) {}
+        BasicType( Kind k, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} ) 
+        : Type(q, std::move(as)), kind(k) {}
 
         /// Check if this type represents an integer type

src/ResolvExpr/ResolveTypeof.cc

@@ -18 +18 @@
 #include <cassert>               // for assert
 
+#include "AST/CVQualifiers.hpp"
+#include "AST/Node.hpp"
+#include "AST/Pass.hpp"
+#include "AST/Type.hpp"
+#include "AST/TypeEnvironment.hpp"
 #include "Common/PassVisitor.h"  // for PassVisitor
+#include "Common/utility.h"      // for copy
 #include "Resolver.h"            // for resolveInVoidContext
 #include "SynTree/Expression.h"  // for Expression
@@ -42 +48 @@
         }
 
-        class ResolveTypeof : public WithShortCircuiting {
+        class ResolveTypeof_old : public WithShortCircuiting {
           public:
-                ResolveTypeof( const SymTab::Indexer &indexer ) : indexer( indexer ) {}
+                ResolveTypeof_old( const SymTab::Indexer &indexer ) : indexer( indexer ) {}
                 void premutate( TypeofType *typeofType );
                 Type * postmutate( TypeofType *typeofType );
@@ -53 +59 @@
 
         Type * resolveTypeof( Type *type, const SymTab::Indexer &indexer ) {
-                PassVisitor<ResolveTypeof> mutator( indexer );
+                PassVisitor<ResolveTypeof_old> mutator( indexer );
                 return type->acceptMutator( mutator );
         }
 
-        void ResolveTypeof::premutate( TypeofType * ) {
+        void ResolveTypeof_old::premutate( TypeofType * ) {
                 visit_children = false;
         }
 
-        Type * ResolveTypeof::postmutate( TypeofType *typeofType ) {
+        Type * ResolveTypeof_old::postmutate( TypeofType *typeofType ) {
 #if 0
                 std::cerr << "resolving typeof: ";
@@ -108 +114 @@
         }
 
-        const ast::Type * resolveTypeof( const ast::Type * type , const ast::SymbolTable & symtab ) {
-                #warning unimplemented
-                (void)type; (void)symtab;
-                assert(false);
-                return nullptr;
-        }
+namespace {
+        struct ResolveTypeof_new : public ast::WithShortCircuiting {
+                const ast::SymbolTable & localSymtab;
+
+                ResolveTypeof_new( const ast::SymbolTable & syms ) : localSymtab( syms ) {}
+
+                void premutate( const ast::TypeofType * ) { visit_children = false; }
+
+                const ast::Type * postmutate( const ast::TypeofType * typeofType ) {
+                        // pass on null expression
+                        if ( ! typeofType->expr ) return typeofType;
+
+                        ast::ptr< ast::Type > newType;
+                        if ( auto tyExpr = typeofType->expr.as< ast::TypeExpr >() ) {
+                                // typeof wrapping type
+                                newType = tyExpr->type;
+                        } else {
+                                // typeof wrapping expression
+                                ast::TypeEnvironment dummy;
+                                ast::ptr< ast::Expr > newExpr = 
+                                        resolveInVoidContext( typeofType->expr, localSymtab, dummy );
+                                assert( newExpr->result && ! newExpr->result->isVoid() );
+                                newType = newExpr->result;
+                        }
+
+                        // clear qualifiers for base, combine with typeoftype quals regardless
+                        if ( typeofType->kind == ast::TypeofType::Basetypeof ) {
+                                // replace basetypeof(<enum>) by int
+                                if ( newType.as< ast::EnumInstType >() ) {
+                                        newType = new ast::BasicType{ 
+                                                ast::BasicType::SignedInt, newType->qualifiers, copy(newType->attributes) };
+                                }
+                                reset_qualifiers( 
+                                        newType, 
+                                        ( newType->qualifiers & ~ast::CV::EquivQualifiers ) | typeofType->qualifiers );
+                        } else {
+                                add_qualifiers( newType, typeofType->qualifiers );
+                        }
+
+                        return newType;
+                }
+        };
+} // anonymous namespace
+
+const ast::Type * resolveTypeof( const ast::Type * type , const ast::SymbolTable & symtab ) {
+        ast::Pass< ResolveTypeof_new > mutator{ symtab };
+        return type->accept( mutator );
+}
+
 } // namespace ResolvExpr
 

src/ResolvExpr/Resolver.cc

@@ -1226 +1226 @@
                 const ast::StaticAssertDecl * previsit( const ast::StaticAssertDecl * );
 
-                void previsit( const ast::ArrayType * );
-                void previsit( const ast::PointerType * );
+                const ast::ArrayType * previsit( const ast::ArrayType * );
+                const ast::PointerType * previsit( const ast::PointerType * );
 
                 const ast::ExprStmt *        previsit( const ast::ExprStmt * );
@@ -1334 +1334 @@
 
         template< typename PtrType >
-        void handlePtrType( const PtrType * type, const ast::SymbolTable & symtab ) {
-                #warning unimplemented; needs support for new Validate::SizeType global
-                (void)type; (void)symtab;
-                assert( false );
-        }
-
-        void Resolver_new::previsit( const ast::ArrayType * at ) {
-                handlePtrType( at, symtab );
-        }
-
-        void Resolver_new::previsit( const ast::PointerType * pt ) {
-                handlePtrType( pt, symtab );
+        const PtrType * handlePtrType( const PtrType * type, const ast::SymbolTable & symtab ) {
+                if ( type->dimension ) {
+                        #warning should use new equivalent to Validate::SizeType rather than sizeType here
+                        ast::ptr< ast::Type > sizeType = 
+                                new ast::BasicType{ ast::BasicType::LongLongUnsignedInt };
+                        ast::mutate_field( 
+                                type, &PtrType::dimension, 
+                                findSingleExpression( type->dimension, sizeType, symtab ) );
+                }
+                return type;
+        }
+
+        const ast::ArrayType * Resolver_new::previsit( const ast::ArrayType * at ) {
+                return handlePtrType( at, symtab );
+        }
+
+        const ast::PointerType * Resolver_new::previsit( const ast::PointerType * pt ) {
+                return handlePtrType( pt, symtab );
         }