Changeset 3f7e12cb for src/Parser/TypeData.cc

Timestamp:

Nov 8, 2017, 5:43:33 PM (8 years ago)

Author:

Aaron Moss <a3moss@…>

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:

954908d

Parents:

78315272 (diff), e35f30a (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

File:

• src/Parser/TypeData.cc (modified) (29 diffs)

src/Parser/TypeData.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Sep  1 23:13:38 2017
-// Update Count     : 569
+// Last Modified On : Mon Sep 25 18:33:41 2017
+// Update Count     : 587
 //
 
@@ -98 +98 @@
 } // TypeData::TypeData
 
+
 TypeData::~TypeData() {
         delete base;
@@ -161 +162 @@
         } // switch
 } // TypeData::~TypeData
+
 
 TypeData * TypeData::clone() const {
@@ -235 +237 @@
 } // TypeData::clone
 
+
 void TypeData::print( ostream &os, int indent ) const {
         for ( int i = 0; i < Type::NumTypeQualifier; i += 1 ) {
@@ -399 +402 @@
 } // TypeData::print
 
+
 template< typename ForallList >
 void buildForall( const DeclarationNode * firstNode, ForallList &outputList ) {
         buildList( firstNode, outputList );
-        for ( typename ForallList::iterator i = outputList.begin(); i != outputList.end(); ++i ) {
+        auto n = firstNode;
+        for ( typename ForallList::iterator i = outputList.begin(); i != outputList.end(); ++i, n = (DeclarationNode*)n->get_next() ) {
                 TypeDecl * td = static_cast<TypeDecl *>(*i);
-                if ( td->get_kind() == TypeDecl::Any ) {
+                if ( n->variable.tyClass == DeclarationNode::Otype ) {
                         // add assertion parameters to `type' tyvars in reverse order
                         // add dtor:  void ^?{}(T *)
@@ -430 +435 @@
                 } // if
         } // for
-}
+} // buildForall
+
 
 Type * typebuild( const TypeData * td ) {
@@ -477 +483 @@
 } // typebuild
 
+
 TypeData * typeextractAggregate( const TypeData * td, bool toplevel ) {
         TypeData * ret = nullptr;
@@ -504 +511 @@
 } // typeextractAggregate
 
+
 Type::Qualifiers buildQualifiers( const TypeData * td ) {
         return td->qualifiers;
 } // buildQualifiers
 
+
+static string genTSError( string msg, DeclarationNode::BasicType basictype ) {
+        throw SemanticError( string( "invalid type specifier \"" ) + msg + "\" for type \"" + DeclarationNode::basicTypeNames[basictype] + "\"." );
+} // genTSError
+
 Type * buildBasicType( const TypeData * td ) {
         BasicType::Kind ret;
@@ -513 +526 @@
         switch ( td->basictype ) {
           case DeclarationNode::Void:
-                if ( td->signedness != DeclarationNode::NoSignedness && td->length != DeclarationNode::NoLength ) {
-                        throw SemanticError( "invalid type specifier \"void\" in type: ", td );
-                } // if
-
+                if ( td->signedness != DeclarationNode::NoSignedness ) {
+                        genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype );
+                } // if
+                if ( td->length != DeclarationNode::NoLength ) {
+                        genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
+                } // if
                 return new VoidType( buildQualifiers( td ) );
                 break;
@@ -522 +537 @@
           case DeclarationNode::Bool:
                 if ( td->signedness != DeclarationNode::NoSignedness ) {
-                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessNames[ td->signedness ] + " in type: ", td );
+                        genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype );
                 } // if
                 if ( td->length != DeclarationNode::NoLength ) {
-                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td );
+                        genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
                 } // if
 
@@ -538 +553 @@
 
                 if ( td->length != DeclarationNode::NoLength ) {
-                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td );
+                        genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
                 } // if
 
@@ -557 +572 @@
                 break;
 
+          case DeclarationNode::Int128:
+                ret = td->signedness == 1 ? BasicType::UnsignedInt128 : BasicType::SignedInt128;
+                if ( td->length != DeclarationNode::NoLength ) {
+                        genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
+                } // if
+                break;
+
           case DeclarationNode::Float:
+          case DeclarationNode::Float80:
+          case DeclarationNode::Float128:
           case DeclarationNode::Double:
           case DeclarationNode::LongDouble:                                     // not set until below
@@ -568 +592 @@
           FloatingPoint: ;
                 if ( td->signedness != DeclarationNode::NoSignedness ) {
-                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessNames[ td->signedness ] + " in type: ", td );
+                        genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype );
                 } // if
                 if ( td->length == DeclarationNode::Short || td->length == DeclarationNode::LongLong ) {
-                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td );
+                        genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
                 } // if
                 if ( td->basictype == DeclarationNode::Float && td->length == DeclarationNode::Long ) {
-                        throw SemanticError( "invalid type specifier \"long\" in type: ", td );
+                        genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
                 } // if
                 if ( td->length == DeclarationNode::Long ) {
@@ -593 +617 @@
                 goto Integral;
           default:
-                assert(false);
+                assertf( false, "unknown basic type" );
                 return nullptr;
         } // switch
@@ -601 +625 @@
         return bt;
 } // buildBasicType
+
 
 PointerType * buildPointer( const TypeData * td ) {
@@ -612 +637 @@
         return pt;
 } // buildPointer
+
 
 ArrayType * buildArray( const TypeData * td ) {
@@ -626 +652 @@
 } // buildArray
 
+
 ReferenceType * buildReference( const TypeData * td ) {
         ReferenceType * rt;
@@ -637 +664 @@
 } // buildReference
 
+
 AggregateDecl * buildAggregate( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
         assert( td->kind == TypeData::Aggregate );
@@ -665 +693 @@
         return at;
 } // buildAggregate
+
 
 ReferenceToType * buildComAggInst( const TypeData * type, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
@@ -722 +751 @@
 } // buildAggInst
 
+
 ReferenceToType * buildAggInst( const TypeData * td ) {
         assert( td->kind == TypeData::AggregateInst );
@@ -761 +791 @@
 } // buildAggInst
 
+
 NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage ) {
         assert( td->kind == TypeData::Symbolic );
@@ -768 +799 @@
                 ret = new TypedefDecl( name, scs, typebuild( td->base ), linkage );
         } else {
-                ret = new TypeDecl( name, scs, typebuild( td->base ), TypeDecl::Any );
+                ret = new TypeDecl( name, scs, typebuild( td->base ), TypeDecl::Dtype, true );
         } // if
         buildList( td->symbolic.params, ret->get_parameters() );
@@ -774 +805 @@
         return ret;
 } // buildSymbolic
+
 
 EnumDecl * buildEnum( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
@@ -790 +822 @@
 } // buildEnum
 
+
 TypeInstType * buildSymbolicInst( const TypeData * td ) {
         assert( td->kind == TypeData::SymbolicInst );
@@ -797 +830 @@
         return ret;
 } // buildSymbolicInst
+
 
 TupleType * buildTuple( const TypeData * td ) {
@@ -807 +841 @@
 } // buildTuple
 
+
 TypeofType * buildTypeof( const TypeData * td ) {
         assert( td->kind == TypeData::Typeof );
@@ -813 +848 @@
         return new TypeofType( buildQualifiers( td ), td->typeexpr->build() );
 } // buildTypeof
+
 
 Declaration * buildDecl( const TypeData * td, const string &name, Type::StorageClasses scs, Expression * bitfieldWidth, Type::FuncSpecifiers funcSpec, LinkageSpec::Spec linkage, Expression *asmName, Initializer * init, std::list< Attribute * > attributes ) {
@@ -836 +872 @@
         return nullptr;
 } // buildDecl
+
 
 FunctionType * buildFunction( const TypeData * td ) {
@@ -857 +894 @@
         return ft;
 } // buildFunction
+
 
 // Transform KR routine declarations into C99 routine declarations: