Changeset dd020c0 for src/Parser/TypeData.cc

Timestamp:

Mar 3, 2017, 10:12:02 PM (7 years ago)

Author:

Peter A. Buhr <pabuhr@…>

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:

8191203

Parents:

f37147b

Message:

first attempt to create function specifiers

File:

• src/Parser/TypeData.cc (modified) (16 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 : Thu Feb 23 21:48:55 2017
-// Update Count     : 485
+// Last Modified On : Fri Mar  3 21:59:10 2017
+// Update Count     : 516
 //
 
@@ -157 +157 @@
 TypeData * TypeData::clone() const {
         TypeData * newtype = new TypeData( kind );
-        newtype->qualifiers = qualifiers;
+        newtype->typeQualifiers = typeQualifiers;
         newtype->base = maybeClone( base );
         newtype->forall = maybeClone( forall );
@@ -226 +226 @@
 
 void TypeData::print( ostream &os, int indent ) const {
-        for ( int i = 0; i < DeclarationNode::NoQualifier; i += 1 ) {
-                if ( qualifiers[i] ) os << DeclarationNode::qualifierName[ i ] << ' ';
+        for ( int i = 0; i < DeclarationNode::NoTypeQualifier; i += 1 ) {
+                if ( typeQualifiers[i] ) os << DeclarationNode::typeQualifierNames[ i ] << ' ';
         } // for
 
@@ -250 +250 @@
                 break;
           case Basic:
-                if ( signedness != DeclarationNode::NoSignedness ) os << DeclarationNode::signednessName[ signedness ] << " ";
-                if ( length != DeclarationNode::NoLength ) os << DeclarationNode::lengthName[ length ] << " ";
+                if ( signedness != DeclarationNode::NoSignedness ) os << DeclarationNode::signednessNames[ signedness ] << " ";
+                if ( length != DeclarationNode::NoLength ) os << DeclarationNode::lengthNames[ length ] << " ";
                 assert( basictype != DeclarationNode::NoBasicType );
-                os << DeclarationNode::basicTypeName[ basictype ] << " ";
-                if ( complextype != DeclarationNode::NoComplexType ) os << DeclarationNode::complexTypeName[ complextype ] << " ";
+                os << DeclarationNode::basicTypeNames[ basictype ] << " ";
+                if ( complextype != DeclarationNode::NoComplexType ) os << DeclarationNode::complexTypeNames[ complextype ] << " ";
                 break;
           case Array:
@@ -301 +301 @@
                 break;
           case Aggregate:
-                os << DeclarationNode::aggregateName[ aggregate.kind ] << ' ' << *aggregate.name << endl;
+                os << DeclarationNode::aggregateNames[ aggregate.kind ] << ' ' << *aggregate.name << endl;
                 if ( aggregate.params ) {
                         os << string( indent + 2, ' ' ) << "with type parameters " << endl;
@@ -399 +399 @@
                         FunctionType * dtorType = new FunctionType( Type::Qualifiers(), false );
                         dtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
-                        td->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, nullptr, false, false ) );
+                        td->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, nullptr ) );
 
                         // add copy ctor:  void ?{}(T *, T)
@@ -405 +405 @@
                         copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
                         copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
-                        td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, nullptr, false, false ) );
+                        td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, nullptr ) );
 
                         // add default ctor:  void ?{}(T *)
                         FunctionType * ctorType = new FunctionType( Type::Qualifiers(), false );
                         ctorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
-                        td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, nullptr, false, false ) );
+                        td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, nullptr ) );
 
                         // add assignment operator:  T * ?=?(T *, T)
@@ -417 +417 @@
                         assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
                         assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
-                        td->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, nullptr, false, false ) );
+                        td->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, nullptr ) );
                 } // if
         } // for
@@ -494 +494 @@
 Type::Qualifiers buildQualifiers( const TypeData * td ) {
         Type::Qualifiers q;
-        q.isConst = td->qualifiers[ DeclarationNode::Const ];
-        q.isVolatile = td->qualifiers[ DeclarationNode::Volatile ];
-        q.isRestrict = td->qualifiers[ DeclarationNode::Restrict ];
-        q.isLvalue = td->qualifiers[ DeclarationNode::Lvalue ];
-        q.isAtomic = td->qualifiers[ DeclarationNode::Atomic ];;
+        q.isConst = td->typeQualifiers[ DeclarationNode::Const ];
+        q.isVolatile = td->typeQualifiers[ DeclarationNode::Volatile ];
+        q.isRestrict = td->typeQualifiers[ DeclarationNode::Restrict ];
+        q.isLvalue = td->typeQualifiers[ DeclarationNode::Lvalue ];
+        q.isAtomic = td->typeQualifiers[ DeclarationNode::Atomic ];;
         return q;
 } // buildQualifiers
@@ -516 +516 @@
           case DeclarationNode::Bool:
                 if ( td->signedness != DeclarationNode::NoSignedness ) {
-                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td );
+                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessNames[ td->signedness ] + " in type: ", td );
                 } // if
                 if ( td->length != DeclarationNode::NoLength ) {
-                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
+                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td );
                 } // if
 
@@ -532 +532 @@
 
                 if ( td->length != DeclarationNode::NoLength ) {
-                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
+                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td );
                 } // if
 
@@ -562 +562 @@
           FloatingPoint: ;
                 if ( td->signedness != DeclarationNode::NoSignedness ) {
-                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td );
+                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessNames[ td->signedness ] + " in type: ", td );
                 } // if
                 if ( td->length == DeclarationNode::Short || td->length == DeclarationNode::LongLong ) {
-                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
+                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td );
                 } // if
                 if ( td->basictype == DeclarationNode::Float && td->length == DeclarationNode::Long ) {
@@ -784 +784 @@
 } // buildTypeof
 
-Declaration * buildDecl( const TypeData * td, const string &name, DeclarationNode::StorageClass sc, Expression * bitfieldWidth, bool isInline, bool isNoreturn, LinkageSpec::Spec linkage, ConstantExpr *asmName, Initializer * init, std::list< Attribute * > attributes ) {
+Declaration * buildDecl( const TypeData * td, const string &name, DeclarationNode::StorageClass sc, Expression * bitfieldWidth, DeclarationNode::FuncSpec funcSpec, LinkageSpec::Spec linkage, ConstantExpr *asmName, Initializer * init, std::list< Attribute * > attributes ) {
         if ( td->kind == TypeData::Function ) {
                 if ( td->function.idList ) {                                    // KR function ?
@@ -793 +793 @@
                 Statement * stmt = maybeBuild<Statement>( td->function.body );
                 CompoundStmt * body = dynamic_cast< CompoundStmt* >( stmt );
-                decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), body, isInline, isNoreturn, attributes );
+                decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), body, attributes, funcSpec );
                 return decl->set_asmName( asmName );
         } else if ( td->kind == TypeData::Aggregate ) {
@@ -802 +802 @@
                 return buildSymbolic( td, name, sc );
         } else {
-                return (new ObjectDecl( name, sc, linkage, bitfieldWidth, typebuild( td ), init, attributes, isInline, isNoreturn ))->set_asmName( asmName );
+                return (new ObjectDecl( name, sc, linkage, bitfieldWidth, typebuild( td ), init, attributes ))->set_asmName( asmName );
         } // if
         return nullptr;
@@ -820 +820 @@
                         break;
                   default:
-                        ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( buildDecl( td->base,  "", DeclarationNode::NoStorageClass, nullptr, false, false, LinkageSpec::Cforall, nullptr ) ) );
+                        ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( buildDecl( td->base, "", DeclarationNode::NoStorageClass, nullptr, DeclarationNode::FuncSpecifier(), LinkageSpec::Cforall, nullptr ) ) );
                 } // switch
         } else {