Changeset be8bd88


Ignore:
Timestamp:
Mar 8, 2017, 3:22:50 PM (5 years ago)
Author:
Aaron Moss <a3moss@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
031a2c95, 0e7ea335
Parents:
87c3bef (diff), 6363ad1 (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

Files:
5 deleted
57 edited

Legend:

Unmodified
Added
Removed
  • .gitignore

    r87c3bef rbe8bd88  
    3030
    3131src/prelude/builtins.cf
     32src/prelude/builtins.c
    3233src/prelude/extras.cf
    3334src/prelude/bootloader.c
     
    3637# generated by bison and lex from cfa.yy and lex.ll, respectively
    3738src/Parser/parser.output
     39src/Parser/lex.cc
     40src/Parser/parser.cc
     41src/Parser/parser.h
    3842
    3943# generated by xfig for user manual
  • Makefile.in

    r87c3bef rbe8bd88  
    135135CFA_INCDIR = @CFA_INCDIR@
    136136CFA_LIBDIR = @CFA_LIBDIR@
     137CFA_NAME = @CFA_NAME@
    137138CFA_PREFIX = @CFA_PREFIX@
    138139CFLAGS = @CFLAGS@
  • configure

    r87c3bef rbe8bd88  
    668668CFA_BACKEND_CC
    669669BACKEND_CC
     670CFA_NAME
    670671MAINT
    671672MAINTAINER_MODE_FALSE
     
    741742enable_silent_rules
    742743enable_maintainer_mode
     744with_cfa_name
    743745with_backend_compiler
    744746enable_target_release
     
    13971399  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
    13981400  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
     1401  --with-cfa-name=NAME     NAME too which cfa will be installed
    13991402  --with-backend-compiler=PROGRAM     PROGRAM that performs the final code compilation (must be gcc-compatible)
    14001403
     
    30013004                        # may require auto* software to be installed
    30023005
     3006# Allow program name tansformation
     3007# will fille program_transform_name with appropriate sed regex
     3008
     3009#autoconf escapes $ and \ since automake wiill un-escape them.
     3010#Since we need to use the sed transform in autoconf we need to manualy un-escape these characters
     3011name_transform=`echo ${program_transform_name} | sed 's/\\$\\$/\\$/g' | sed 's/\\\\\\\/\\\/g'`
     3012cfa_name=`echo cfa | sed ${name_transform}`
     3013cc1_name=`echo cc1 | sed ${name_transform}`
     3014cpp_name=`echo cfa-cpp | sed ${name_transform}`
     3015
     3016#Trasforming cc1 will break compilation
     3017if ! test "${cc1_name}" = "cc1"; then
     3018    as_fn_error $? "Program transform must not modify cc1.
     3019                --program-sufix and --program-prefix not supported.
     3020                Use -program-transform-name='s/cfa$/[Desired name here]/' instead" "$LINENO" 5
     3021fi
     3022#We could support transforming cfa-cpp but since it is located in a unique subfolder we don't need to
     3023if ! test "${cpp_name}" = "cfa-cpp"; then
     3024    as_fn_error $? "Program transform must not modify cfa-cpp.
     3025                --program-sufix and --program-prefix not supported.
     3026                Use -program-transform-name='s/cfa$/[Desired name here]/' instead" "$LINENO" 5
     3027fi
     3028
     3029
     3030# Check whether --with-cfa-name was given.
     3031if test "${with_cfa_name+set}" = set; then :
     3032  withval=$with_cfa_name; cfa_name=$withval
     3033else
     3034  cfa_name="cfa"
     3035fi
     3036
     3037
     3038#Define the new name of the installed command
     3039CFA_NAME=${cfa_name}
     3040
     3041
    30033042rm -f version
    30043043echo ${PACKAGE_VERSION} > version               # file containing version number for other tools
     
    32383277
    32393278if test "$includedir" = '${prefix}/include'; then
    3240         cfa_incdir="${cfa_prefix}/include/cfa"
     3279        cfa_incdir="${cfa_prefix}/include/${cfa_name}"
    32413280else
    32423281        cfa_incdir=${includedir}
     
    32643303
    32653304if test "$libdir" = '${exec_prefix}/lib'; then
    3266         cfa_libdir=${cfa_prefix}/lib
     3305        cfa_libdir="${cfa_prefix}/lib/${cfa_name}"
    32673306else
    32683307        cfa_libdir=${libdir}
  • configure.ac

    r87c3bef rbe8bd88  
    1717AM_INIT_AUTOMAKE
    1818AM_MAINTAINER_MODE(enable)                      # may require auto* software to be installed
     19
     20# Allow program name tansformation
     21# will fill program_transform_name with appropriate sed regex
     22AC_ARG_PROGRAM
     23
     24#Trasforming cc1 will break compilation
     25if ! test "${program_transform_name}" = ""; then
     26    AC_MSG_ERROR([Program transform not supported.
     27                Use --with-cfa-name='[[Desired name here]]' instead])
     28fi
     29
     30AC_ARG_WITH(cfa-name,
     31        [  --with-cfa-name=NAME     NAME too which cfa will be installed],
     32        cfa_name=$withval, cfa_name="cfa")
     33
     34#Define the new name of the installed command
     35AC_SUBST(CFA_NAME, ${cfa_name})
    1936
    2037rm -f version
     
    129146
    130147if test "$includedir" = '${prefix}/include'; then
    131         cfa_incdir="${cfa_prefix}/include/cfa"
     148        cfa_incdir="${cfa_prefix}/include/${cfa_name}"
    132149else
    133150        cfa_incdir=${includedir}
     
    145162
    146163if test "$libdir" = '${exec_prefix}/lib'; then
    147         cfa_libdir=${cfa_prefix}/lib
     164        cfa_libdir="${cfa_prefix}/lib/${cfa_name}"
    148165else
    149166        cfa_libdir=${libdir}
  • src/CodeGen/CodeGenerator.cc

    r87c3bef rbe8bd88  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 16 14:56:29 2017
    13 // Update Count     : 418
     12// Last Modified On : Sun Mar  5 17:13:33 2017
     13// Update Count     : 475
    1414//
    1515
     
    134134
    135135                handleStorageClass( functionDecl );
    136                 if ( functionDecl->get_isInline() ) {
    137                         output << "inline ";
    138                 } // if
    139                 if ( functionDecl->get_isNoreturn() ) {
    140                         output << "_Noreturn ";
    141                 } // if
     136                DeclarationNode::print_FuncSpec( output, functionDecl->get_funcSpec() );
     137
    142138                output << genType( functionDecl->get_functionType(), mangleName( functionDecl ), pretty );
    143139
     
    835831        }
    836832
    837 
    838833        void CodeGenerator::visit( ReturnStmt * returnStmt ) {
    839834                output << "return ";
     
    899894        }
    900895
    901         void CodeGenerator::handleStorageClass( Declaration * decl ) {
    902                 switch ( decl->get_storageClass() ) {
    903                   case DeclarationNode::Extern:
    904                         output << "extern ";
    905                         break;
    906                   case DeclarationNode::Static:
    907                         output << "static ";
    908                         break;
    909                   case DeclarationNode::Auto:
    910                         // silently drop storage class
    911                         break;
    912                   case DeclarationNode::Register:
    913                         output << "register ";
    914                         break;
    915                   case DeclarationNode::Inline:
    916                         output << "inline ";
    917                         break;
    918                   case DeclarationNode::Fortran:
    919                         output << "fortran ";
    920                         break;
    921                   case DeclarationNode::Noreturn:
    922                         output << "_Noreturn ";
    923                         break;
    924                   case DeclarationNode::Threadlocal:
    925                         output << "_Thread_local ";
    926                         break;
    927                   case DeclarationNode::NoStorageClass:
    928                         break;
    929                 } // switch
    930         }
     896        void CodeGenerator::handleStorageClass( DeclarationWithType * decl ) {
     897                if ( decl->get_storageClasses().any() ) {
     898                        DeclarationNode::print_StorageClass( output, decl->get_storageClasses() );
     899                } // if
     900        } // CodeGenerator::handleStorageClass
    931901
    932902        std::string genName( DeclarationWithType * decl ) {
  • src/CodeGen/CodeGenerator.h

    r87c3bef rbe8bd88  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb  9 15:06:21 2017
    13 // Update Count     : 49
     12// Last Modified On : Wed Mar  1 16:20:04 2017
     13// Update Count     : 50
    1414//
    1515
     
    123123
    124124                void printDesignators( std::list< Expression * > & );
    125                 void handleStorageClass( Declaration *decl );
     125                void handleStorageClass( DeclarationWithType *decl );
    126126                void handleAggregate( AggregateDecl *aggDecl );
    127127                void handleTypedef( NamedTypeDecl *namedType );
  • src/CodeGen/FixNames.cc

    r87c3bef rbe8bd88  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Mon Apr 11 15:38:10 2016
    13 // Update Count     : 1
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon Mar  6 23:32:08 2017
     13// Update Count     : 15
    1414//
    1515
     
    3939        std::string mangle_main() {
    4040                FunctionType* main_type;
    41                 std::unique_ptr<FunctionDecl> mainDecl { new FunctionDecl(
    42                         "main",
    43                         DeclarationNode::NoStorageClass,
    44                         LinkageSpec::Cforall,
    45                         main_type = new FunctionType( Type::Qualifiers(), true ),
    46                         nullptr, false, false
    47                 ) };
     41                std::unique_ptr<FunctionDecl> mainDecl { new FunctionDecl( "main", DeclarationNode::StorageClasses(), LinkageSpec::Cforall,
     42                                                                                                                                   main_type = new FunctionType( Type::Qualifiers(), true ), nullptr )
     43                                };
    4844                main_type->get_returnVals().push_back(
    49                         new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
     45                        new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
    5046                );
    5147
    52                 auto&& name = SymTab::Mangler::mangle( mainDecl.get() );
     48                auto && name = SymTab::Mangler::mangle( mainDecl.get() );
    5349                // std::cerr << name << std::endl;
    5450                return name;
     
    5652        std::string mangle_main_args() {
    5753                FunctionType* main_type;
    58                 std::unique_ptr<FunctionDecl> mainDecl { new FunctionDecl(
    59                         "main",
    60                         DeclarationNode::NoStorageClass,
    61                         LinkageSpec::Cforall,
    62                         main_type = new FunctionType( Type::Qualifiers(), false ),
    63                         nullptr, false, false
    64                 ) };
     54                std::unique_ptr<FunctionDecl> mainDecl { new FunctionDecl( "main", DeclarationNode::StorageClasses(), LinkageSpec::Cforall,
     55                                                                                                                                   main_type = new FunctionType( Type::Qualifiers(), false ), nullptr )
     56                                };
    6557                main_type->get_returnVals().push_back(
    66                         new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
     58                        new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
    6759                );
    6860
    6961                mainDecl->get_functionType()->get_parameters().push_back(
    70                         new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
     62                        new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
    7163                );
    7264
    7365                mainDecl->get_functionType()->get_parameters().push_back(
    74                         new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0,
     66                        new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0,
    7567                        new PointerType( Type::Qualifiers(), new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::Char ) ) ),
    7668                        nullptr )
  • src/GenPoly/Box.cc

    r87c3bef rbe8bd88  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 16 14:57:16 2017
    13 // Update Count     : 297
     12// Last Modified On : Mon Mar  6 23:45:59 2017
     13// Update Count     : 330
    1414//
    1515
     
    289289                        TypeInstType paramType( Type::Qualifiers(), (*param)->get_name(), *param );
    290290                        std::string paramName = mangleType( &paramType );
    291                         layoutFnType->get_parameters().push_back( new ObjectDecl( sizeofName( paramName ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
    292                         layoutFnType->get_parameters().push_back( new ObjectDecl( alignofName( paramName ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
     291                        layoutFnType->get_parameters().push_back( new ObjectDecl( sizeofName( paramName ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
     292                        layoutFnType->get_parameters().push_back( new ObjectDecl( alignofName( paramName ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
    293293                }
    294294        }
     
    298298                // Routines at global scope marked "static" to prevent multiple definitions is separate translation units
    299299                // because each unit generates copies of the default routines for each aggregate.
    300                 FunctionDecl *layoutDecl = new FunctionDecl(
    301                         layoutofName( typeDecl ), functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, layoutFnType, new CompoundStmt( noLabels ), true, false );
     300                FunctionDecl *layoutDecl = new FunctionDecl( layoutofName( typeDecl ),
     301                                                                                                         functionNesting > 0 ? DeclarationNode::StorageClasses() : DeclarationNode::StorageClasses( DeclarationNode::StaticClass ),
     302                                                                                                         LinkageSpec::AutoGen, layoutFnType, new CompoundStmt( noLabels ),
     303                                                                                                         std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::InlineSpec ) );
    302304                layoutDecl->fixUniqueId();
    303305                return layoutDecl;
     
    366368                PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType );
    367369
    368                 ObjectDecl *sizeParam = new ObjectDecl( sizeofName( structDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
     370                ObjectDecl *sizeParam = new ObjectDecl( sizeofName( structDecl->get_name() ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
    369371                layoutFnType->get_parameters().push_back( sizeParam );
    370                 ObjectDecl *alignParam = new ObjectDecl( alignofName( structDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
     372                ObjectDecl *alignParam = new ObjectDecl( alignofName( structDecl->get_name() ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
    371373                layoutFnType->get_parameters().push_back( alignParam );
    372                 ObjectDecl *offsetParam = new ObjectDecl( offsetofName( structDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
     374                ObjectDecl *offsetParam = new ObjectDecl( offsetofName( structDecl->get_name() ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
    373375                layoutFnType->get_parameters().push_back( offsetParam );
    374376                addOtypeParams( layoutFnType, otypeParams );
     
    427429                PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType );
    428430
    429                 ObjectDecl *sizeParam = new ObjectDecl( sizeofName( unionDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
     431                ObjectDecl *sizeParam = new ObjectDecl( sizeofName( unionDecl->get_name() ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
    430432                layoutFnType->get_parameters().push_back( sizeParam );
    431                 ObjectDecl *alignParam = new ObjectDecl( alignofName( unionDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
     433                ObjectDecl *alignParam = new ObjectDecl( alignofName( unionDecl->get_name() ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
    432434                layoutFnType->get_parameters().push_back( alignParam );
    433435                addOtypeParams( layoutFnType, otypeParams );
     
    535537                                        if ( adapters.find( mangleName ) == adapters.end() ) {
    536538                                                std::string adapterName = makeAdapterName( mangleName );
    537                                                 adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, new ObjectDecl( adapterName, DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), nullptr ) ) );
     539                                                adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, new ObjectDecl( adapterName, DeclarationNode::StorageClasses(), LinkageSpec::C, nullptr, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), nullptr ) ) );
    538540                                        } // if
    539541                                } // for
     
    654656
    655657                ObjectDecl *Pass1::makeTemporary( Type *type ) {
    656                         ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, type, 0 );
     658                        ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, type, 0 );
    657659                        stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
    658660                        return newObj;
     
    763765                                        Type * newType = param->clone();
    764766                                        if ( env ) env->apply( newType );
    765                                         ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, newType, 0 );
     767                                        ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, newType, 0 );
    766768                                        newObj->get_type()->get_qualifiers() = Type::Qualifiers(); // TODO: is this right???
    767769                                        stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
     
    829831                                makeRetParm( adapter );
    830832                        } // if
    831                         adapter->get_parameters().push_front( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 ) );
     833                        adapter->get_parameters().push_front( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 ) );
    832834                        return adapter;
    833835                }
     
    910912                        adapterBody->get_kids().push_back( bodyStmt );
    911913                        std::string adapterName = makeAdapterName( mangleName );
    912                         return new FunctionDecl( adapterName, DeclarationNode::NoStorageClass, LinkageSpec::C, adapterType, adapterBody, false, false );
     914                        return new FunctionDecl( adapterName, DeclarationNode::StorageClasses(), LinkageSpec::C, adapterType, adapterBody );
    913915                }
    914916
     
    12711273                                if ( adaptersDone.find( mangleName ) == adaptersDone.end() ) {
    12721274                                        std::string adapterName = makeAdapterName( mangleName );
    1273                                         paramList.push_front( new ObjectDecl( adapterName, DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0 ) );
     1275                                        paramList.push_front( new ObjectDecl( adapterName, DeclarationNode::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0 ) );
    12741276                                        adaptersDone.insert( adaptersDone.begin(), mangleName );
    12751277                                }
     
    13771379                        std::list< DeclarationWithType *>::iterator last = funcType->get_parameters().begin();
    13781380                        std::list< DeclarationWithType *> inferredParams;
    1379                         ObjectDecl newObj( "", DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 );
    1380                         ObjectDecl newPtr( "", DeclarationNode::NoStorageClass, LinkageSpec::C, 0,
     1381                        ObjectDecl newObj( "", DeclarationNode::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 );
     1382                        ObjectDecl newPtr( "", DeclarationNode::StorageClasses(), LinkageSpec::C, 0,
    13811383                                           new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) ), 0 );
    13821384                        for ( Type::ForallList::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) {
     
    16321634
    16331635                ObjectDecl *PolyGenericCalculator::makeVar( const std::string &name, Type *type, Initializer *init ) {
    1634                         ObjectDecl *newObj = new ObjectDecl( name, DeclarationNode::NoStorageClass, LinkageSpec::C, 0, type, init );
     1636                        ObjectDecl *newObj = new ObjectDecl( name, DeclarationNode::StorageClasses(), LinkageSpec::C, 0, type, init );
    16351637                        stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
    16361638                        return newObj;
     
    18161818                                                        memberDecl = origMember->clone();
    18171819                                                } else {
    1818                                                         memberDecl = new ObjectDecl( (*member)->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, offsetType->clone(), 0 );
     1820                                                        memberDecl = new ObjectDecl( (*member)->get_name(), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, offsetType->clone(), 0 );
    18191821                                                }
    18201822                                                inits.push_back( new SingleInit( new OffsetofExpr( ty->clone(), memberDecl ) ) );
  • src/GenPoly/Specialize.cc

    r87c3bef rbe8bd88  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Thu Apr 28 15:17:45 2016
    13 // Update Count     : 24
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon Mar  6 23:13:00 2017
     13// Update Count     : 30
    1414//
    1515
     
    155155                } // if
    156156                // create new thunk with same signature as formal type (C linkage, empty body)
    157                 FunctionDecl *thunkFunc = new FunctionDecl( thunkNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, newType, new CompoundStmt( noLabels ), false, false );
     157                FunctionDecl *thunkFunc = new FunctionDecl( thunkNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, newType, new CompoundStmt( noLabels ) );
    158158                thunkFunc->fixUniqueId();
    159159
  • src/InitTweak/FixGlobalInit.cc

    r87c3bef rbe8bd88  
    1010// Created On       : Mon May 04 15:14:56 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jun 29 22:33:15 2016
    13 // Update Count     : 4
     12// Last Modified On : Mon Mar  6 23:14:19 2017
     13// Update Count     : 14
    1414//
    1515
     
    8787                        dtorParameters.push_back( new ConstantExpr( Constant::from_int( 102 ) ) );
    8888                }
    89                 initFunction = new FunctionDecl( "_init_" + fixedName, DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ), false, false );
     89                initFunction = new FunctionDecl( "_init_" + fixedName, DeclarationNode::StorageClasses( DeclarationNode::StaticClass ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
    9090                initFunction->get_attributes().push_back( new Attribute( "constructor", ctorParameters ) );
    91                 destroyFunction = new FunctionDecl( "_destroy_" + fixedName, DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ), false, false );
     91                destroyFunction = new FunctionDecl( "_destroy_" + fixedName, DeclarationNode::StorageClasses( DeclarationNode::StaticClass ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
    9292                destroyFunction->get_attributes().push_back( new Attribute( "destructor", dtorParameters ) );
    9393        }
  • src/InitTweak/FixInit.cc

    r87c3bef rbe8bd88  
    1010// Created On       : Wed Jan 13 16:29:30 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 16 14:58:43 2017
    13 // Update Count     : 35
     12// Last Modified On : Tue Mar  7 07:51:40 2017
     13// Update Count     : 59
    1414//
    1515
     
    437437                        result = result->clone();
    438438                        env->apply( result );
    439                         ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result, 0 );
     439                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, result, 0 );
    440440                        tmp->get_type()->set_isConst( false );
    441441
     
    483483                                result = result->clone();
    484484                                env->apply( result );
    485                                 ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result, 0 );
     485                                ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, result, 0 );
    486486                                ret->get_type()->set_isConst( false );
    487487                                impCpCtorExpr->get_returnDecls().push_back( ret );
     
    506506                                result = result->clone();
    507507                                env->apply( result );
    508                                 ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result, 0 );
     508                                ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, result, 0 );
    509509                                ret->get_type()->set_isConst( false );
    510510                                stmtExpr->get_returnDecls().push_front( ret );
     
    538538                        } else {
    539539                                // expr isn't a call expr, so create a new temporary variable to use to hold the value of the unique expression
    540                                 unqExpr->set_object( new ObjectDecl( toString("_unq_expr_", unqExpr->get_id()), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, unqExpr->get_result()->clone(), nullptr ) );
     540                                unqExpr->set_object( new ObjectDecl( toString("_unq_expr_", unqExpr->get_id()), DeclarationNode::StorageClasses(), LinkageSpec::C, nullptr, unqExpr->get_result()->clone(), nullptr ) );
    541541                                unqExpr->set_var( new VariableExpr( unqExpr->get_object() ) );
    542542                        }
     
    678678                                assert( ! ctorInit->get_ctor() || ! ctorInit->get_init() );
    679679                                if ( Statement * ctor = ctorInit->get_ctor() ) {
    680                                         if ( objDecl->get_storageClass() == DeclarationNode::Static ) {
     680                                        if ( objDecl->get_storageClasses()[ DeclarationNode::Static ] ) {
    681681                                                // originally wanted to take advantage of gcc nested functions, but
    682682                                                // we get memory errors with this approach. To remedy this, the static
     
    704704                                                BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool );
    705705                                                SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant( boolType->clone(), "1" ) ), noDesignators );
    706                                                 ObjectDecl * isUninitializedVar = new ObjectDecl( objDecl->get_mangleName() + "_uninitialized", DeclarationNode::Static, LinkageSpec::Cforall, 0, boolType, boolInitExpr );
     706                                                ObjectDecl * isUninitializedVar = new ObjectDecl( objDecl->get_mangleName() + "_uninitialized", DeclarationNode::StorageClasses( DeclarationNode::StaticClass ), LinkageSpec::Cforall, 0, boolType, boolInitExpr );
    707707                                                isUninitializedVar->fixUniqueId();
    708708
     
    731731
    732732                                                        // void __objName_dtor_atexitN(...) {...}
    733                                                         FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ), false, false );
     733                                                        FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), DeclarationNode::StorageClasses( DeclarationNode::StaticClass ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
    734734                                                        dtorCaller->fixUniqueId();
    735735                                                        dtorCaller->get_statements()->push_back( dtorStmt );
     
    764764                                                        // create a new object which is never used
    765765                                                        static UniqueName dummyNamer( "_dummy" );
    766                                                         ObjectDecl * dummy = new ObjectDecl( dummyNamer.newName(), DeclarationNode::Static, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), 0, std::list< Attribute * >{ new Attribute("unused") } );
     766                                                        ObjectDecl * dummy = new ObjectDecl( dummyNamer.newName(), DeclarationNode::StorageClasses( DeclarationNode::StaticClass ), LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), 0, std::list< Attribute * >{ new Attribute("unused") } );
    767767                                                        return dummy;
    768768                                                }
     
    821821                void InsertDtors::visit( ObjectDecl * objDecl ) {
    822822                        // remember non-static destructed objects so that their destructors can be inserted later
    823                         if ( objDecl->get_storageClass() != DeclarationNode::Static ) {
     823                        if ( ! objDecl->get_storageClasses()[ DeclarationNode::Static ] ) {
    824824                                if ( ConstructorInit * ctorInit = dynamic_cast< ConstructorInit * >( objDecl->get_init() ) ) {
    825825                                        // a decision should have been made by the resolver, so ctor and init are not both non-NULL
     
    11181118
    11191119                        // xxx - ideally we would reuse the temporary generated from the copy constructor passes from within firstArg if it exists and not generate a temporary if it's unnecessary.
    1120                         ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, ctorExpr->get_result()->clone(), nullptr );
     1120                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, nullptr, ctorExpr->get_result()->clone(), nullptr );
    11211121                        addDeclaration( tmp );
    11221122
  • src/InitTweak/GenInit.cc

    r87c3bef rbe8bd88  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 16 14:57:53 2017
    13 // Update Count     : 167
     12// Last Modified On : Tue Mar  7 07:51:38 2017
     13// Update Count     : 179
    1414//
    1515
     
    120120                void hoist( Type * type );
    121121
    122                 DeclarationNode::StorageClass storageclass = DeclarationNode::NoStorageClass;
     122                DeclarationNode::StorageClasses storageClasses;
    123123                bool inFunction = false;
    124124        };
     
    174174
    175175        DeclarationWithType * HoistArrayDimension::mutate( ObjectDecl * objectDecl ) {
    176                 storageclass = objectDecl->get_storageClass();
     176                storageClasses = objectDecl->get_storageClasses();
    177177                DeclarationWithType * temp = Parent::mutate( objectDecl );
    178178                hoist( objectDecl->get_type() );
    179                 storageclass = DeclarationNode::NoStorageClass;
    180179                return temp;
    181180        }
     
    185184                static UniqueName dimensionName( "_array_dim" );
    186185
    187                 // C doesn't allow variable sized arrays at global scope or for static variables,
    188                 // so don't hoist dimension.
     186                // C doesn't allow variable sized arrays at global scope or for static variables, so don't hoist dimension.
    189187                if ( ! inFunction ) return;
    190                 if ( storageclass == DeclarationNode::Static ) return;
     188                if ( storageClasses[ DeclarationNode::StaticClass] ) return;
    191189
    192190                if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
    193191                        if ( ! arrayType->get_dimension() ) return; // xxx - recursive call to hoist?
    194192
    195                         // don't need to hoist dimension if it's a constexpr - only need to if there's potential
    196                         // for side effects.
     193                        // don't need to hoist dimension if it's a constexpr - only need to if there's potential for side effects.
    197194                        if ( isConstExpr( arrayType->get_dimension() ) ) return;
    198195
    199                         ObjectDecl * arrayDimension = new ObjectDecl( dimensionName.newName(), storageclass, LinkageSpec::C, 0, SymTab::SizeType->clone(), new SingleInit( arrayType->get_dimension() ) );
     196                        ObjectDecl * arrayDimension = new ObjectDecl( dimensionName.newName(), storageClasses, LinkageSpec::C, 0, SymTab::SizeType->clone(), new SingleInit( arrayType->get_dimension() ) );
    200197                        arrayDimension->get_type()->set_isConst( true );
    201198
  • src/InitTweak/InitTweak.cc

    r87c3bef rbe8bd88  
    260260                        (objDecl->get_init() == NULL ||
    261261                                ( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() ))
    262                         && objDecl->get_storageClass() != DeclarationNode::Extern;
     262                        && ! objDecl->get_storageClasses()[ DeclarationNode::Extern ];
    263263        }
    264264
  • src/Makefile.am

    r87c3bef rbe8bd88  
    3838
    3939# put into lib for now
    40 cfa_cpplibdir = ${libdir}
     40cfa_cpplibdir = ${CFA_LIBDIR}
    4141cfa_cpplib_PROGRAMS = driver/cfa-cpp
    4242driver_cfa_cpp_SOURCES = ${SRC}
  • src/Makefile.in

    r87c3bef rbe8bd88  
    276276CFA_INCDIR = @CFA_INCDIR@
    277277CFA_LIBDIR = @CFA_LIBDIR@
     278CFA_NAME = @CFA_NAME@
    278279CFA_PREFIX = @CFA_PREFIX@
    279280CFLAGS = @CFLAGS@
     
    436437
    437438# put into lib for now
    438 cfa_cpplibdir = ${libdir}
     439cfa_cpplibdir = ${CFA_LIBDIR}
    439440driver_cfa_cpp_SOURCES = ${SRC}
    440441driver_cfa_cpp_LDADD = ${LEXLIB} -ldl                   # yywrap
  • src/Parser/DeclarationNode.cc

    r87c3bef rbe8bd88  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 23 22:21:06 2017
    13 // Update Count     : 775
     12// Last Modified On : Tue Mar  7 08:02:09 2017
     13// Update Count     : 936
    1414//
    1515
     
    1919#include <algorithm>
    2020#include <cassert>
     21#include <strings.h>                                                                    // ffs
    2122
    2223#include "TypeData.h"
     
    3233
    3334// These must remain in the same order as the corresponding DeclarationNode enumerations.
    34 const char * DeclarationNode::storageName[] = { "extern", "static", "auto", "register", "inline", "fortran", "_Noreturn", "_Thread_local", "NoStorageClass" };
    35 const char * DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic", "NoQualifier" };
    36 const char * DeclarationNode::basicTypeName[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicType" };
    37 const char * DeclarationNode::complexTypeName[] = { "_Complex", "_Imaginary", "NoComplexType" };
    38 const char * DeclarationNode::signednessName[] = { "signed", "unsigned", "NoSignedness" };
    39 const char * DeclarationNode::lengthName[] = { "short", "long", "long long", "NoLength" };
    40 const char * DeclarationNode::aggregateName[] = { "struct", "union", "context" };
    41 const char * DeclarationNode::typeClassName[] = { "otype", "dtype", "ftype" };
    42 const char * DeclarationNode::builtinTypeName[] = { "__builtin_va_list" };
     35const char * DeclarationNode::storageClassNames[] = { "extern", "static", "auto", "register", "_Thread_local", "NoStorageClassNames" };
     36const char * DeclarationNode::funcSpecifierNames[] = { "inline", "fortran", "_Noreturn", "NoFunctionSpecifierNames" };
     37const char * DeclarationNode::typeQualifierNames[] = { "const", "restrict", "volatile", "lvalue", "mutex", "_Atomic", "NoTypeQualifierNames" };
     38const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicTypeNames" };
     39const char * DeclarationNode::complexTypeNames[] = { "_Complex", "_Imaginary", "NoComplexTypeNames" };
     40const char * DeclarationNode::signednessNames[] = { "signed", "unsigned", "NoSignednessNames" };
     41const char * DeclarationNode::lengthNames[] = { "short", "long", "long long", "NoLengthNames" };
     42const char * DeclarationNode::aggregateNames[] = { "struct", "union", "context", "NoAggregateNames" };
     43const char * DeclarationNode::typeClassNames[] = { "otype", "dtype", "ftype", "NoTypeClassNames" };
     44const char * DeclarationNode::builtinTypeNames[] = { "__builtin_va_list", "NoBuiltinTypeNames" };
    4345
    4446UniqueName DeclarationNode::anonymous( "__anonymous" );
     
    4850DeclarationNode::DeclarationNode() :
    4951                type( nullptr ),
    50                 storageClass( NoStorageClass ),
    5152                bitfieldWidth( nullptr ),
    52                 isInline( false ),
    53                 isNoreturn( false ),
    5453                hasEllipsis( false ),
    5554                linkage( ::linkage ),
     
    9089
    9190        newnode->type = maybeClone( type );
    92         newnode->storageClass = storageClass;
     91        newnode->storageClasses = storageClasses;
    9392        newnode->bitfieldWidth = maybeClone( bitfieldWidth );
    94         newnode->isInline = isInline;
    95         newnode->isNoreturn = isNoreturn;
     93        newnode->funcSpecs = funcSpecs;
    9694        newnode->enumeratorValue.reset( maybeClone( enumeratorValue.get() ) );
    9795        newnode->hasEllipsis = hasEllipsis;
     
    118116}
    119117
     118void DeclarationNode::print_StorageClass( std::ostream & output, StorageClasses storageClasses ) {
     119        if ( storageClasses.any() ) {                                                           // function specifiers?
     120                for ( unsigned int i = 0; i < DeclarationNode::NoStorageClass; i += 1 ) {
     121                        if ( storageClasses[i] ) {
     122                                output << DeclarationNode::storageClassNames[i] << ' ';
     123                        } // if
     124                } // for
     125        } // if
     126} // print_StorageClass
     127
     128void DeclarationNode::print_FuncSpec( std::ostream & output, DeclarationNode::FuncSpecifiers funcSpec ) {
     129        if ( funcSpec.any() ) {                                                         // function specifiers?
     130                for ( unsigned int i = 0; i < DeclarationNode::NoFuncSpecifier; i += 1 ) {
     131                        if ( funcSpec[i] ) {
     132                                output << DeclarationNode::funcSpecifierNames[i] << ' ';
     133                        } // if
     134                } // for
     135        } // if
     136} // print_FuncSpec
     137
    120138void DeclarationNode::print( std::ostream &os, int indent ) const {
    121139        os << string( indent, ' ' );
     
    130148        } // if
    131149
    132         if ( storageClass != NoStorageClass ) os << DeclarationNode::storageName[storageClass] << ' ';
    133         if ( isInline ) os << DeclarationNode::storageName[Inline] << ' ';
    134         if ( isNoreturn ) os << DeclarationNode::storageName[Noreturn] << ' ';
     150        print_StorageClass( os, storageClasses );
     151        print_FuncSpec( os, funcSpecs );
     152
    135153        if ( type ) {
    136154                type->print( os, indent );
     
    183201} // DeclarationNode::newFunction
    184202
    185 DeclarationNode * DeclarationNode::newQualifier( Qualifier q ) {
     203
     204DeclarationNode * DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
     205        DeclarationNode * newnode = new DeclarationNode;
     206        newnode->storageClasses[ sc ] = true;
     207        return newnode;
     208} // DeclarationNode::newStorageClass
     209
     210DeclarationNode * DeclarationNode::newFuncSpecifier( DeclarationNode::FuncSpecifier fs ) {
     211        DeclarationNode * newnode = new DeclarationNode;
     212        newnode->funcSpecs[ fs ] = true;
     213        return newnode;
     214} // DeclarationNode::newFuncSpecifier
     215
     216DeclarationNode * DeclarationNode::newTypeQualifier( TypeQualifier tq ) {
    186217        DeclarationNode * newnode = new DeclarationNode;
    187218        newnode->type = new TypeData();
    188         newnode->type->qualifiers[ q ] = 1;
     219        newnode->type->typeQualifiers[ tq ] = true;
    189220        return newnode;
    190221} // DeclarationNode::newQualifier
     222
     223DeclarationNode * DeclarationNode::newBasicType( BasicType bt ) {
     224        DeclarationNode * newnode = new DeclarationNode;
     225        newnode->type = new TypeData( TypeData::Basic );
     226        newnode->type->basictype = bt;
     227        return newnode;
     228} // DeclarationNode::newBasicType
     229
     230DeclarationNode * DeclarationNode::newComplexType( ComplexType ct ) {
     231        DeclarationNode * newnode = new DeclarationNode;
     232        newnode->type = new TypeData( TypeData::Basic );
     233        newnode->type->complextype = ct;
     234        return newnode;
     235} // DeclarationNode::newComplexType
     236
     237DeclarationNode * DeclarationNode::newSignedNess( Signedness sn ) {
     238        DeclarationNode * newnode = new DeclarationNode;
     239        newnode->type = new TypeData( TypeData::Basic );
     240        newnode->type->signedness = sn;
     241        return newnode;
     242} // DeclarationNode::newSignedNess
     243
     244DeclarationNode * DeclarationNode::newLength( Length lnth ) {
     245        DeclarationNode * newnode = new DeclarationNode;
     246        newnode->type = new TypeData( TypeData::Basic );
     247        newnode->type->length = lnth;
     248        return newnode;
     249} // DeclarationNode::newLength
    191250
    192251DeclarationNode * DeclarationNode::newForall( DeclarationNode * forall ) {
     
    196255        return newnode;
    197256} // DeclarationNode::newForall
    198 
    199 DeclarationNode * DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
    200         DeclarationNode * newnode = new DeclarationNode;
    201         newnode->storageClass = sc;
    202         return newnode;
    203 } // DeclarationNode::newStorageClass
    204 
    205 DeclarationNode * DeclarationNode::newBasicType( BasicType bt ) {
    206         DeclarationNode * newnode = new DeclarationNode;
    207         newnode->type = new TypeData( TypeData::Basic );
    208         newnode->type->basictype = bt;
    209         return newnode;
    210 } // DeclarationNode::newBasicType
    211 
    212 DeclarationNode * DeclarationNode::newComplexType( ComplexType ct ) {
    213         DeclarationNode * newnode = new DeclarationNode;
    214         newnode->type = new TypeData( TypeData::Basic );
    215         newnode->type->complextype = ct;
    216         return newnode;
    217 } // DeclarationNode::newComplexType
    218 
    219 DeclarationNode * DeclarationNode::newSignedNess( Signedness sn ) {
    220         DeclarationNode * newnode = new DeclarationNode;
    221         newnode->type = new TypeData( TypeData::Basic );
    222         newnode->type->signedness = sn;
    223         return newnode;
    224 } // DeclarationNode::newSignedNess
    225 
    226 DeclarationNode * DeclarationNode::newLength( Length lnth ) {
    227         DeclarationNode * newnode = new DeclarationNode;
    228         newnode->type = new TypeData( TypeData::Basic );
    229         newnode->type->length = lnth;
    230         return newnode;
    231 } // DeclarationNode::newLength
    232257
    233258DeclarationNode * DeclarationNode::newFromTypedef( string * name ) {
     
    428453
    429454void DeclarationNode::checkQualifiers( const TypeData * src, const TypeData * dst ) {
    430         TypeData::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers; // optimization
     455        const TypeData::TypeQualifiers qsrc = src->typeQualifiers, qdst = dst->typeQualifiers; // optimization
    431456
    432457        if ( (qsrc & qdst).any() ) {                                            // common qualifier ?
    433                 for ( int i = 0; i < NoQualifier; i += 1 ) {    // find common qualifiers
     458                for ( unsigned int i = 0; i < NoTypeQualifier; i += 1 ) { // find common qualifiers
    434459                        if ( qsrc[i] && qdst[i] ) {
    435                                 appendError( error, string( "duplicate " ) + DeclarationNode::qualifierName[i] );
     460                                appendError( error, string( "duplicate " ) + DeclarationNode::typeQualifierNames[i] );
    436461                        } // if
    437462                } // for
    438         } // if
     463        } // for
    439464} // DeclarationNode::checkQualifiers
    440465
    441 void DeclarationNode::checkStorageClasses( DeclarationNode * q ) {
    442         if ( storageClass != NoStorageClass && q->storageClass != NoStorageClass ) {
    443                 if ( storageClass == q->storageClass ) {                // duplicate qualifier
    444                         appendError( error, string( "duplicate " ) + storageName[ storageClass ] );
    445                 } else {                                                                                // only one storage class
    446                         appendError( error, string( "conflicting " ) + storageName[ storageClass ] + " & " + storageName[ q->storageClass ] );
    447                         q->storageClass = storageClass;                         // FIX ERROR, prevent assertions from triggering
    448                 } // if
    449         } // if
    450         appendError( error, q->error );
    451 } // DeclarationNode::checkStorageClasses
    452 
    453 DeclarationNode * DeclarationNode::copyStorageClasses( DeclarationNode * q ) {
    454         isInline = isInline || q->isInline;
    455         isNoreturn = isNoreturn || q->isNoreturn;
    456         // do not overwrite an existing value with NoStorageClass
    457         if ( q->storageClass != NoStorageClass ) {
    458                 assert( storageClass == NoStorageClass || storageClass == q->storageClass );
    459                 storageClass = q->storageClass;
    460         } // if
     466void DeclarationNode::checkSpecifiers( DeclarationNode * src ) {
     467        if ( (funcSpecs & src->funcSpecs).any() ) {                     // common specifier ?
     468                for ( unsigned int i = 0; i < NoFuncSpecifier; i += 1 ) { // find common specifier
     469                        if ( funcSpecs[i] && src->funcSpecs[i] ) {
     470                                appendError( error, string( "duplicate " ) + DeclarationNode::funcSpecifierNames[i] );
     471                        } // if
     472                } // for
     473        } // if
     474
     475        if ( storageClasses != 0 && src->storageClasses != 0 ) { // any reason to check ?
     476                if ( (storageClasses & src->storageClasses).any() ) { // duplicates ?
     477                        for ( unsigned int i = 0; i < NoStorageClass; i += 1 ) { // find duplicates
     478                                if ( storageClasses[i] && src->storageClasses[i] ) {
     479                                        appendError( error, string( "duplicate " ) + storageClassNames[i] );
     480                                } // if
     481                        } // for
     482                        // src is the new item being added and has a single bit
     483                } else if ( ! src->storageClasses[ Threadlocal ] ) { // conflict ?
     484                        appendError( error, string( "conflicting " ) + storageClassNames[ffs( storageClasses.to_ulong() ) - 1] +
     485                                                 " & " + storageClassNames[ffs( src->storageClasses.to_ulong() ) - 1] );
     486                        src->storageClasses.reset();                            // FIX to preserve invariant of one basic storage specifier
     487                } // if
     488        } // if
     489
     490        appendError( error, src->error );
     491} // DeclarationNode::checkSpecifiers
     492
     493DeclarationNode * DeclarationNode::copySpecifiers( DeclarationNode * q ) {
     494        funcSpecs = funcSpecs | q->funcSpecs;
     495        storageClasses = storageClasses | q->storageClasses;
    461496
    462497        for ( Attribute *attr: reverseIterate( q->attributes ) ) {
     
    464499        } // for
    465500        return this;
    466 } // DeclarationNode::copyStorageClasses
     501} // DeclarationNode::copySpecifiers
    467502
    468503static void addQualifiersToType( TypeData *&src, TypeData * dst ) {
     
    481516                src = nullptr;
    482517        } else {
    483                 dst->qualifiers |= src->qualifiers;
     518                dst->typeQualifiers |= src->typeQualifiers;
    484519        } // if
    485520} // addQualifiersToType
     
    488523        if ( ! q ) { delete q; return this; }
    489524
    490         checkStorageClasses( q );
    491         copyStorageClasses( q );
     525        checkSpecifiers( q );
     526        copySpecifiers( q );
    492527
    493528        if ( ! q->type ) {
     
    518553        } // if
    519554
    520         checkQualifiers( q->type, type );
     555        checkQualifiers( type, q->type );
    521556        addQualifiersToType( q->type, type );
    522557
     
    539574                switch ( dst->kind ) {
    540575                  case TypeData::Unknown:
    541                         src->qualifiers |= dst->qualifiers;
     576                        src->typeQualifiers |= dst->typeQualifiers;
    542577                        dst = src;
    543578                        src = nullptr;
    544579                        break;
    545580                  case TypeData::Basic:
    546                         dst->qualifiers |= src->qualifiers;
     581                        dst->typeQualifiers |= src->typeQualifiers;
    547582                        if ( src->kind != TypeData::Unknown ) {
    548583                                assert( src->kind == TypeData::Basic );
     
    551586                                        dst->basictype = src->basictype;
    552587                                } else if ( src->basictype != DeclarationNode::NoBasicType )
    553                                         throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::basicTypeName[ src->basictype ] + " in type: ", src );
     588                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::basicTypeNames[ src->basictype ] + " in type: ", src );
    554589
    555590                                if ( dst->complextype == DeclarationNode::NoComplexType ) {
    556591                                        dst->complextype = src->complextype;
    557592                                } else if ( src->complextype != DeclarationNode::NoComplexType )
    558                                         throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::complexTypeName[ src->complextype ] + " in type: ", src );
     593                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::complexTypeNames[ src->complextype ] + " in type: ", src );
    559594
    560595                                if ( dst->signedness == DeclarationNode::NoSignedness ) {
    561596                                        dst->signedness = src->signedness;
    562597                                } else if ( src->signedness != DeclarationNode::NoSignedness )
    563                                         throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::signednessName[ src->signedness ] + " in type: ", src );
     598                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::signednessNames[ src->signedness ] + " in type: ", src );
    564599
    565600                                if ( dst->length == DeclarationNode::NoLength ) {
     
    568603                                        dst->length = DeclarationNode::LongLong;
    569604                                } else if ( src->length != DeclarationNode::NoLength )
    570                                         throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::lengthName[ src->length ] + " in type: ", src );
     605                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::lengthNames[ src->length ] + " in type: ", src );
    571606                        } // if
    572607                        break;
     
    580615                                        dst->base->aggInst.params = maybeClone( src->aggregate.actuals );
    581616                                } // if
    582                                 dst->base->qualifiers |= src->qualifiers;
     617                                dst->base->typeQualifiers |= src->typeQualifiers;
    583618                                src = nullptr;
    584619                                break;
     
    599634DeclarationNode * DeclarationNode::addType( DeclarationNode * o ) {
    600635        if ( o ) {
    601                 checkStorageClasses( o );
    602                 copyStorageClasses( o );
     636                checkSpecifiers( o );
     637                copySpecifiers( o );
    603638                if ( o->type ) {
    604639                        if ( ! type ) {
     
    612647                                                type->aggInst.hoistType = o->type->enumeration.body;
    613648                                        } // if
    614                                         type->qualifiers |= o->type->qualifiers;
     649                                        type->typeQualifiers |= o->type->typeQualifiers;
    615650                                } else {
    616651                                        type = o->type;
     
    768803                                        p->type->base->aggInst.params = maybeClone( type->aggregate.actuals );
    769804                                } // if
    770                                 p->type->base->qualifiers |= type->qualifiers;
     805                                p->type->base->typeQualifiers |= type->typeQualifiers;
    771806                                break;
    772807
     
    805840                                        lastArray->base->aggInst.params = maybeClone( type->aggregate.actuals );
    806841                                } // if
    807                                 lastArray->base->qualifiers |= type->qualifiers;
     842                                lastArray->base->typeQualifiers |= type->typeQualifiers;
    808843                                break;
    809844                          default:
     
    854889        DeclarationNode * newnode = new DeclarationNode;
    855890        newnode->type = maybeClone( type );
    856         assert( storageClass == NoStorageClass );
    857         newnode->copyStorageClasses( this );
     891        newnode->copySpecifiers( this );
    858892        assert( newName );
    859893        newnode->name = newName;
     
    864898        if ( ! o ) return nullptr;
    865899
    866         o->copyStorageClasses( this );
     900        o->copySpecifiers( this );
    867901        if ( type ) {
    868902                TypeData * srcType = type;
     
    956990                                } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) {
    957991                                        StructInstType * inst = new StructInstType( Type::Qualifiers(), agg->get_name() );
    958                                         auto obj = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr );
     992                                        auto obj = new ObjectDecl( "", DeclarationNode::StorageClasses(), linkage, nullptr, inst, nullptr );
    959993                                        obj->location = cur->location;
    960994                                        * out++ = obj;
     
    962996                                } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {
    963997                                        UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->get_name() );
    964                                         auto obj = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr );
     998                                        auto obj = new ObjectDecl( "", DeclarationNode::StorageClasses(), linkage, nullptr, inst, nullptr );
    965999                                        obj->location = cur->location;
    9661000                                        * out++ = obj;
     
    10051039        } // if
    10061040
    1007 //      if ( variable.name ) {
    10081041        if ( variable.tyClass != NoTypeClass ) {
    10091042                static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Dtype, TypeDecl::Ftype, TypeDecl::Ttype };
    10101043                assertf( sizeof(kindMap)/sizeof(kindMap[0] == NoTypeClass-1), "DeclarationNode::build: kindMap is out of sync." );
    10111044                assertf( variable.tyClass < sizeof(kindMap)/sizeof(kindMap[0]), "Variable's tyClass is out of bounds." );
    1012 //              TypeDecl * ret = new TypeDecl( *variable.name, DeclarationNode::NoStorageClass, nullptr, kindMap[ variable.tyClass ] );
    1013                 TypeDecl * ret = new TypeDecl( *name, DeclarationNode::NoStorageClass, nullptr, kindMap[ variable.tyClass ] );
     1045                TypeDecl * ret = new TypeDecl( *name, DeclarationNode::StorageClasses(), nullptr, kindMap[ variable.tyClass ] );
    10141046                buildList( variable.assertions, ret->get_assertions() );
    10151047                return ret;
     
    10171049
    10181050        if ( type ) {
    1019                 return buildDecl( type, name ? *name : string( "" ), storageClass, maybeBuild< Expression >( bitfieldWidth ), isInline, isNoreturn, linkage, asmName, maybeBuild< Initializer >(initializer), attributes )->set_extension( extension );
    1020         } // if
    1021 
    1022         if ( ! isInline && ! isNoreturn ) {
    1023                 assertf( name, "ObjectDecl are assumed to have names\n" );
    1024                 return (new ObjectDecl( *name, storageClass, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_asmName( asmName )->set_extension( extension );
    1025         } // if
    1026 
    1027         throw SemanticError( "invalid function specifier ", this );
     1051                // Function specifiers can only appear on a function definition/declaration.
     1052                //
     1053                //    inline _Noreturn int f();                 // allowed
     1054                //    inline _Noreturn int g( int i );  // allowed
     1055                //    inline _Noreturn int i;                   // disallowed
     1056                if ( type->kind != TypeData::Function && funcSpecs.any() ) {
     1057                        throw SemanticError( "invalid function specifier for ", this );
     1058                } // if
     1059                return buildDecl( type, name ? *name : string( "" ), storageClasses, maybeBuild< Expression >( bitfieldWidth ), funcSpecs, linkage, asmName, maybeBuild< Initializer >(initializer), attributes )->set_extension( extension );
     1060        } // if
     1061
     1062        // SUE's cannot have function specifiers, either
     1063        //
     1064        //    inlne _Noreturn struct S { ... };         // disallowed
     1065        //    inlne _Noreturn enum   E { ... };         // disallowed
     1066        if ( funcSpecs.any() ) {
     1067                throw SemanticError( "invalid function specifier for ", this );
     1068        } // if
     1069        assertf( name, "ObjectDecl must a have name\n" );
     1070        return (new ObjectDecl( *name, storageClasses, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_asmName( asmName )->set_extension( extension );
    10281071}
    10291072
     
    10321075
    10331076        if ( attr.expr ) {
    1034 //              return new AttrType( buildQualifiers( type ), *attr.name, attr.expr->build() );
    10351077                return new AttrType( buildQualifiers( type ), *name, attr.expr->build(), attributes );
    10361078        } else if ( attr.type ) {
    1037 //              return new AttrType( buildQualifiers( type ), *attr.name, attr.type->buildType() );
    10381079                return new AttrType( buildQualifiers( type ), *name, attr.type->buildType(), attributes );
    10391080        } // if
  • src/Parser/ExpressionNode.cc

    r87c3bef rbe8bd88  
    1010// Created On       : Sat May 16 13:17:07 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Sep 16 16:27:44 2016
    13 // Update Count     : 508
     12// Last Modified On : Sat Mar  4 06:58:47 2017
     13// Update Count     : 509
    1414//
    1515
     
    173173
    174174Expression *build_constantZeroOne( const std::string & str ) {
    175         Expression * ret = new ConstantExpr( Constant( str == "0" ? (Type*)new ZeroType( emptyQualifiers ) : (Type*)new OneType( emptyQualifiers ), str ) );
     175        Expression * ret = new ConstantExpr( Constant( str == "0" ? (Type *)new ZeroType( emptyQualifiers ) : (Type*)new OneType( emptyQualifiers ), str ) );
    176176        delete &str;                                                                            // created by lex
    177177        return ret;
     
    275275}
    276276Expression *build_offsetOf( DeclarationNode *decl_node, NameExpr *member ) {
    277         Expression* ret = new UntypedOffsetofExpr( maybeMoveBuildType( decl_node ), member->get_name() );
     277        Expression * ret = new UntypedOffsetofExpr( maybeMoveBuildType( decl_node ), member->get_name() );
    278278        delete member;
    279279        return ret;
  • src/Parser/ParseNode.h

    r87c3bef rbe8bd88  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 23 15:22:10 2017
    13 // Update Count     : 662
     12// Last Modified On : Tue Mar  7 08:10:53 2017
     13// Update Count     : 726
    1414//
    1515
     
    1919#include <string>
    2020#include <list>
     21#include <bitset>
    2122#include <iterator>
    2223#include <memory>
     
    3940//##############################################################################
    4041
    41 extern char* yyfilename;
     42extern char * yyfilename;
    4243extern int yylineno;
    4344
     
    122123        }
    123124
    124         Expression * build() const { return const_cast<ExpressionNode*>(this)->expr.release(); }
     125        Expression * build() const { return const_cast<ExpressionNode *>(this)->expr.release(); }
    125126  private:
    126127        bool extension = false;
     
    203204        // These must remain in the same order as the corresponding DeclarationNode names.
    204205
    205         // enum StorageClass { Extern, Static, Auto, Register, NoStorageClass };
    206         // enum FunctionSpec { Inline, Fortran, Noreturn, NoFunctionSpec };
    207         // enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic, Threadlocal, Mutex, NoQualifier };
    208 
    209         enum StorageClass { Extern, Static, Auto, Register, Inline, Fortran, Noreturn, Threadlocal, NoStorageClass, };
    210         enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic, NoQualifier };
     206        enum StorageClass { Extern, Static, Auto, Register, Threadlocal, NoStorageClass,
     207                                                ExternClass = 1 << Extern, StaticClass = 1 << Static, AutoClass = 1 << Auto, RegisterClass = 1 << Register, ThreadlocalClass = 1 << Threadlocal };
     208        enum FuncSpecifier { Inline, Noreturn, Fortran, NoFuncSpecifier,
     209                                                 InlineSpec = 1 << Inline, NoreturnSpec = 1 << Noreturn, FortranSpec = 1 << Fortran };
     210        enum TypeQualifier { Const, Restrict, Volatile, Lvalue, Mutex, Atomic, NoTypeQualifier };
    211211        enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, NoBasicType };
    212212        enum ComplexType { Complex, Imaginary, NoComplexType };
     
    217217        enum BuiltinType { Valist, Zero, One, NoBuiltinType };
    218218
    219         static const char * storageName[];
    220         static const char * qualifierName[];
    221         static const char * basicTypeName[];
    222         static const char * complexTypeName[];
    223         static const char * signednessName[];
    224         static const char * lengthName[];
    225         static const char * aggregateName[];
    226         static const char * typeClassName[];
    227         static const char * builtinTypeName[];
    228 
    229         static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
    230         static DeclarationNode * newQualifier( Qualifier );
    231         static DeclarationNode * newForall( DeclarationNode * );
     219        static const char * storageClassNames[];
     220        static const char * funcSpecifierNames[];
     221        static const char * typeQualifierNames[];
     222        static const char * basicTypeNames[];
     223        static const char * complexTypeNames[];
     224        static const char * signednessNames[];
     225        static const char * lengthNames[];
     226        static const char * aggregateNames[];
     227        static const char * typeClassNames[];
     228        static const char * builtinTypeNames[];
     229
    232230        static DeclarationNode * newStorageClass( StorageClass );
     231        static DeclarationNode * newFuncSpecifier( FuncSpecifier );
     232        static DeclarationNode * newTypeQualifier( TypeQualifier );
    233233        static DeclarationNode * newBasicType( BasicType );
    234234        static DeclarationNode * newComplexType( ComplexType );
    235         static DeclarationNode * newSignedNess( Signedness sn );
    236         static DeclarationNode * newLength( Length lnth );
     235        static DeclarationNode * newSignedNess( Signedness );
     236        static DeclarationNode * newLength( Length );
    237237        static DeclarationNode * newBuiltinType( BuiltinType );
     238        static DeclarationNode * newForall( DeclarationNode * );
    238239        static DeclarationNode * newFromTypedef( std::string * );
     240        static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
    239241        static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
    240242        static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants, bool body );
     
    263265        DeclarationNode * addQualifiers( DeclarationNode * );
    264266        void checkQualifiers( const TypeData *, const TypeData * );
    265         void checkStorageClasses( DeclarationNode * );
    266         DeclarationNode * copyStorageClasses( DeclarationNode * );
     267        void checkSpecifiers( DeclarationNode * );
     268        DeclarationNode * copySpecifiers( DeclarationNode * );
    267269        DeclarationNode * addType( DeclarationNode * );
    268270        DeclarationNode * addTypedef();
     
    295297
    296298        Declaration * build() const;
    297         ::Type * buildType() const;
     299        Type * buildType() const;
    298300
    299301        bool get_hasEllipsis() const;
     
    301303        DeclarationNode * extractAggregate() const;
    302304        bool has_enumeratorValue() const { return (bool)enumeratorValue; }
    303         ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode*>(this)->enumeratorValue.release(); }
     305        ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode *>(this)->enumeratorValue.release(); }
    304306
    305307        bool get_extension() const { return extension; }
     
    323325
    324326        TypeData * type;
    325         StorageClass storageClass;
     327
     328        typedef std::bitset< DeclarationNode::NoStorageClass > StorageClasses;
     329        StorageClasses storageClasses;
     330        static void print_StorageClass( std::ostream & output, StorageClasses storageClasses );
     331
     332        typedef std::bitset< DeclarationNode::NoFuncSpecifier > FuncSpecifiers;
     333        FuncSpecifiers funcSpecs;
     334        static void print_FuncSpec( std::ostream & output, FuncSpecifiers funcSpecs );
     335
    326336        ExpressionNode * bitfieldWidth;
    327         bool isInline, isNoreturn;
    328337        std::unique_ptr<ExpressionNode> enumeratorValue;
    329338        bool hasEllipsis;
     
    342351
    343352static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) {
    344         Type* ret = orig ? orig->buildType() : nullptr;
     353        Type * ret = orig ? orig->buildType() : nullptr;
    345354        delete orig;
    346355        return ret;
     
    357366
    358367        virtual StatementNode * clone() const final { assert( false ); return nullptr; }
    359         Statement * build() const { return const_cast<StatementNode*>(this)->stmt.release(); }
     368        Statement * build() const { return const_cast<StatementNode *>(this)->stmt.release(); }
    360369
    361370        virtual StatementNode * add_label( const std::string * name, DeclarationNode * attr = nullptr ) {
  • src/Parser/TypeData.cc

    r87c3bef rbe8bd88  
    1010// Created On       : Sat May 16 15:12:51 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 23 21:48:55 2017
    13 // Update Count     : 485
     12// Last Modified On : Tue Mar  7 08:08:21 2017
     13// Update Count     : 538
    1414//
    1515
     
    157157TypeData * TypeData::clone() const {
    158158        TypeData * newtype = new TypeData( kind );
    159         newtype->qualifiers = qualifiers;
     159        newtype->typeQualifiers = typeQualifiers;
    160160        newtype->base = maybeClone( base );
    161161        newtype->forall = maybeClone( forall );
     
    226226
    227227void TypeData::print( ostream &os, int indent ) const {
    228         for ( int i = 0; i < DeclarationNode::NoQualifier; i += 1 ) {
    229                 if ( qualifiers[i] ) os << DeclarationNode::qualifierName[ i ] << ' ';
     228        for ( int i = 0; i < DeclarationNode::NoTypeQualifier; i += 1 ) {
     229                if ( typeQualifiers[i] ) os << DeclarationNode::typeQualifierNames[ i ] << ' ';
    230230        } // for
    231231
     
    250250                break;
    251251          case Basic:
    252                 if ( signedness != DeclarationNode::NoSignedness ) os << DeclarationNode::signednessName[ signedness ] << " ";
    253                 if ( length != DeclarationNode::NoLength ) os << DeclarationNode::lengthName[ length ] << " ";
     252                if ( signedness != DeclarationNode::NoSignedness ) os << DeclarationNode::signednessNames[ signedness ] << " ";
     253                if ( length != DeclarationNode::NoLength ) os << DeclarationNode::lengthNames[ length ] << " ";
    254254                assert( basictype != DeclarationNode::NoBasicType );
    255                 os << DeclarationNode::basicTypeName[ basictype ] << " ";
    256                 if ( complextype != DeclarationNode::NoComplexType ) os << DeclarationNode::complexTypeName[ complextype ] << " ";
     255                os << DeclarationNode::basicTypeNames[ basictype ] << " ";
     256                if ( complextype != DeclarationNode::NoComplexType ) os << DeclarationNode::complexTypeNames[ complextype ] << " ";
    257257                break;
    258258          case Array:
     
    301301                break;
    302302          case Aggregate:
    303                 os << DeclarationNode::aggregateName[ aggregate.kind ] << ' ' << *aggregate.name << endl;
     303                os << DeclarationNode::aggregateNames[ aggregate.kind ] << ' ' << *aggregate.name << endl;
    304304                if ( aggregate.params ) {
    305305                        os << string( indent + 2, ' ' ) << "with type parameters " << endl;
     
    393393        buildList( firstNode, outputList );
    394394        for ( typename ForallList::iterator i = outputList.begin(); i != outputList.end(); ++i ) {
    395                 TypeDecl * td = static_cast<TypeDecl*>(*i);
     395                TypeDecl * td = static_cast<TypeDecl *>(*i);
    396396                if ( td->get_kind() == TypeDecl::Any ) {
    397397                        // add assertion parameters to `type' tyvars in reverse order
    398398                        // add dtor:  void ^?{}(T *)
    399399                        FunctionType * dtorType = new FunctionType( Type::Qualifiers(), false );
    400                         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 ) );
    401                         td->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, nullptr, false, false ) );
     400                        dtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
     401                        td->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, dtorType, nullptr ) );
    402402
    403403                        // add copy ctor:  void ?{}(T *, T)
    404404                        FunctionType * copyCtorType = new FunctionType( Type::Qualifiers(), false );
    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 ) );
    406                         copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
    407                         td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, nullptr, false, false ) );
     405                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
     406                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
     407                        td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, copyCtorType, nullptr ) );
    408408
    409409                        // add default ctor:  void ?{}(T *)
    410410                        FunctionType * ctorType = new FunctionType( Type::Qualifiers(), false );
    411                         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 ) );
    412                         td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, nullptr, false, false ) );
     411                        ctorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
     412                        td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, ctorType, nullptr ) );
    413413
    414414                        // add assignment operator:  T * ?=?(T *, T)
    415415                        FunctionType * assignType = new FunctionType( Type::Qualifiers(), false );
    416                         assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
    417                         assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
    418                         assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
    419                         td->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, nullptr, false, false ) );
     416                        assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
     417                        assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
     418                        assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
     419                        td->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, assignType, nullptr ) );
    420420                } // if
    421421        } // for
     
    494494Type::Qualifiers buildQualifiers( const TypeData * td ) {
    495495        Type::Qualifiers q;
    496         q.isConst = td->qualifiers[ DeclarationNode::Const ];
    497         q.isVolatile = td->qualifiers[ DeclarationNode::Volatile ];
    498         q.isRestrict = td->qualifiers[ DeclarationNode::Restrict ];
    499         q.isLvalue = td->qualifiers[ DeclarationNode::Lvalue ];
    500         q.isAtomic = td->qualifiers[ DeclarationNode::Atomic ];;
     496        q.isConst = td->typeQualifiers[ DeclarationNode::Const ];
     497        q.isVolatile = td->typeQualifiers[ DeclarationNode::Volatile ];
     498        q.isRestrict = td->typeQualifiers[ DeclarationNode::Restrict ];
     499        q.isLvalue = td->typeQualifiers[ DeclarationNode::Lvalue ];
     500        q.isAtomic = td->typeQualifiers[ DeclarationNode::Atomic ];;
    501501        return q;
    502502} // buildQualifiers
     
    516516          case DeclarationNode::Bool:
    517517                if ( td->signedness != DeclarationNode::NoSignedness ) {
    518                         throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td );
     518                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessNames[ td->signedness ] + " in type: ", td );
    519519                } // if
    520520                if ( td->length != DeclarationNode::NoLength ) {
    521                         throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
     521                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td );
    522522                } // if
    523523
     
    532532
    533533                if ( td->length != DeclarationNode::NoLength ) {
    534                         throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
     534                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td );
    535535                } // if
    536536
     
    562562          FloatingPoint: ;
    563563                if ( td->signedness != DeclarationNode::NoSignedness ) {
    564                         throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td );
     564                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessNames[ td->signedness ] + " in type: ", td );
    565565                } // if
    566566                if ( td->length == DeclarationNode::Short || td->length == DeclarationNode::LongLong ) {
    567                         throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
     567                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td );
    568568                } // if
    569569                if ( td->basictype == DeclarationNode::Float && td->length == DeclarationNode::Long ) {
     
    732732} // buildAggInst
    733733
    734 NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, DeclarationNode::StorageClass sc ) {
     734NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, DeclarationNode::StorageClasses scs ) {
    735735        assert( td->kind == TypeData::Symbolic );
    736736        NamedTypeDecl * ret;
    737737        assert( td->base );
    738738        if ( td->symbolic.isTypedef ) {
    739                 ret = new TypedefDecl( name, sc, typebuild( td->base ) );
     739                ret = new TypedefDecl( name, scs, typebuild( td->base ) );
    740740        } else {
    741                 ret = new TypeDecl( name, sc, typebuild( td->base ), TypeDecl::Any );
     741                ret = new TypeDecl( name, scs, typebuild( td->base ), TypeDecl::Any );
    742742        } // if
    743743        buildList( td->symbolic.params, ret->get_parameters() );
     
    784784} // buildTypeof
    785785
    786 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 ) {
     786Declaration * buildDecl( const TypeData * td, const string &name, DeclarationNode::StorageClasses scs, Expression * bitfieldWidth, DeclarationNode::FuncSpecifiers funcSpec, LinkageSpec::Spec linkage, ConstantExpr *asmName, Initializer * init, std::list< Attribute * > attributes ) {
    787787        if ( td->kind == TypeData::Function ) {
    788788                if ( td->function.idList ) {                                    // KR function ?
     
    792792                FunctionDecl * decl;
    793793                Statement * stmt = maybeBuild<Statement>( td->function.body );
    794                 CompoundStmt * body = dynamic_cast< CompoundStmt* >( stmt );
    795                 decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), body, isInline, isNoreturn, attributes );
     794                CompoundStmt * body = dynamic_cast< CompoundStmt * >( stmt );
     795                decl = new FunctionDecl( name, scs, linkage, buildFunction( td ), body, attributes, funcSpec );
    796796                return decl->set_asmName( asmName );
    797797        } else if ( td->kind == TypeData::Aggregate ) {
     
    800800                return buildEnum( td, attributes );
    801801        } else if ( td->kind == TypeData::Symbolic ) {
    802                 return buildSymbolic( td, name, sc );
     802                return buildSymbolic( td, name, scs );
    803803        } else {
    804                 return (new ObjectDecl( name, sc, linkage, bitfieldWidth, typebuild( td ), init, attributes, isInline, isNoreturn ))->set_asmName( asmName );
     804                return (new ObjectDecl( name, scs, linkage, bitfieldWidth, typebuild( td ), init, attributes ))->set_asmName( asmName );
    805805        } // if
    806806        return nullptr;
     
    820820                        break;
    821821                  default:
    822                         ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( buildDecl( td->base,  "", DeclarationNode::NoStorageClass, nullptr, false, false, LinkageSpec::Cforall, nullptr ) ) );
     822                        ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType * >( buildDecl( td->base, "", DeclarationNode::StorageClasses(), nullptr, DeclarationNode::FuncSpecifiers(), LinkageSpec::Cforall, nullptr ) ) );
    823823                } // switch
    824824        } else {
    825                 ft->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) );
     825                ft->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) );
    826826        } // if
    827827        return ft;
     
    846846        for ( DeclarationNode * decl = function.oldDeclList; decl != nullptr; decl = dynamic_cast< DeclarationNode * >( decl->get_next() ) ) {
    847847                // scan ALL parameter names for each declaration name to check for duplicates
    848                 for ( DeclarationNode * param = function.idList; param != nullptr; param = dynamic_cast< DeclarationNode* >( param->get_next() ) ) {
     848                for ( DeclarationNode * param = function.idList; param != nullptr; param = dynamic_cast< DeclarationNode * >( param->get_next() ) ) {
    849849                        if ( *decl->name == *param->name ) {
    850850                                // type set => parameter name already transformed by a declaration names so there is a duplicate
     
    867867        //    rtb( a, b, c ) const char * b; {} => int rtn( int a, const char * b, int c ) {}
    868868
    869         for ( DeclarationNode * param = function.idList; param != nullptr; param = dynamic_cast< DeclarationNode* >( param->get_next() ) ) {
     869        for ( DeclarationNode * param = function.idList; param != nullptr; param = dynamic_cast< DeclarationNode * >( param->get_next() ) ) {
    870870                if ( ! param->type ) {                                                  // generate type int for empty parameter type
    871871                        param->type = new TypeData( TypeData::Basic );
  • src/Parser/TypeData.h

    r87c3bef rbe8bd88  
    1010// Created On       : Sat May 16 15:18:36 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 23 17:14:46 2017
    13 // Update Count     : 158
     12// Last Modified On : Tue Mar  7 08:03:53 2017
     13// Update Count     : 173
    1414//
    1515
     
    7676        DeclarationNode::Length length = DeclarationNode::NoLength;
    7777        DeclarationNode::BuiltinType builtintype = DeclarationNode::NoBuiltinType;
    78         typedef std::bitset< DeclarationNode::NoQualifier > Qualifiers;
    79         Qualifiers qualifiers;
     78        typedef std::bitset< DeclarationNode::NoTypeQualifier > TypeQualifiers;
     79        TypeQualifiers typeQualifiers;
    8080        DeclarationNode * forall;
    8181
     
    107107ReferenceToType * buildComAggInst( const TypeData *, std::list< Attribute * > attributes );
    108108ReferenceToType * buildAggInst( const TypeData * );
    109 NamedTypeDecl * buildSymbolic( const TypeData *, const std::string &name, DeclarationNode::StorageClass sc );
    110109TypeDecl * buildVariable( const TypeData * );
    111110EnumDecl * buildEnum( const TypeData *, std::list< Attribute * > );
     
    113112TupleType * buildTuple( const TypeData * );
    114113TypeofType * buildTypeof( const TypeData * );
    115 Declaration * buildDecl( const TypeData *, const std::string &, DeclarationNode::StorageClass, Expression *, bool isInline, bool isNoreturn, LinkageSpec::Spec, ConstantExpr *asmName, Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() );
     114Declaration * buildDecl( const TypeData *, const std::string &, DeclarationNode::StorageClasses, Expression *, DeclarationNode::FuncSpecifiers funcSpec, LinkageSpec::Spec, ConstantExpr *asmName, Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() );
    116115FunctionType * buildFunction( const TypeData * );
    117116void buildKRFunction( const TypeData::Function_t & function );
  • src/Parser/lex.ll

    r87c3bef rbe8bd88  
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Tue Nov 29 11:32:00 2016
    13  * Update Count     : 501
     12 * Last Modified On : Fri Mar  3 22:18:00 2017
     13 * Update Count     : 502
    1414 */
    1515
     
    235235long                    { KEYWORD_RETURN(LONG); }
    236236lvalue                  { KEYWORD_RETURN(LVALUE); }                             // CFA
     237mutex                   { KEYWORD_RETURN(MUTEX); }                              // CFA
    237238_Noreturn               { KEYWORD_RETURN(NORETURN); }                   // C11
    238239__builtin_offsetof { KEYWORD_RETURN(OFFSETOF); }                // GCC
  • src/Parser/parser.yy

    r87c3bef rbe8bd88  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb 28 09:58:10 2017
    13 // Update Count     : 2208
     12// Last Modified On : Sun Mar  5 15:48:24 2017
     13// Update Count     : 2227
    1414//
    1515
     
    9191// keywords
    9292%token TYPEDEF
    93 %token AUTO EXTERN REGISTER STATIC
    94 %token INLINE                                                                                   // C99
    95 %token FORTRAN                                                                                  // C99, extension ISO/IEC 9899:1999 Section J.5.9(1)
     93%token EXTERN STATIC AUTO REGISTER
     94%token THREADLOCAL                                                                              // C11
     95%token INLINE FORTRAN                                                                   // C99, extension ISO/IEC 9899:1999 Section J.5.9(1)
     96%token NORETURN                                                                                 // C11
    9697%token CONST VOLATILE
    9798%token RESTRICT                                                                                 // C99
    98 %token FORALL LVALUE                                                                    // CFA
     99%token ATOMIC                                                                                   // C11
     100%token FORALL LVALUE MUTEX                                                              // CFA
    99101%token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED ZERO_T ONE_T
    100102%token VALIST                                                                                   // GCC
     
    102104%token TYPEOF LABEL                                                                             // GCC
    103105%token ENUM STRUCT UNION
    104 %token OTYPE FTYPE DTYPE TTYPE TRAIT                                                    // CFA
     106%token OTYPE FTYPE DTYPE TTYPE TRAIT                                    // CFA
    105107%token SIZEOF OFFSETOF
    106108%token ATTRIBUTE EXTENSION                                                              // GCC
     
    108110%token CHOOSE DISABLE ENABLE FALLTHRU TRY CATCH CATCHRESUME FINALLY THROW THROWRESUME AT        // CFA
    109111%token ASM                                                                                              // C99, extension ISO/IEC 9899:1999 Section J.5.10(1)
    110 %token ALIGNAS ALIGNOF ATOMIC GENERIC NORETURN STATICASSERT THREADLOCAL // C11
     112%token ALIGNAS ALIGNOF GENERIC STATICASSERT                             // C11
    111113
    112114// names and constants: lexer differentiates between identifier and typedef names
     
    14001402type_qualifier_name:
    14011403        CONST
    1402                 { $$ = DeclarationNode::newQualifier( DeclarationNode::Const ); }
     1404                { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Const ); }
    14031405        | RESTRICT
    1404                 { $$ = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
     1406                { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Restrict ); }
    14051407        | VOLATILE
    1406                 { $$ = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
     1408                { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Volatile ); }
    14071409        | LVALUE                                                                                        // CFA
    1408                 { $$ = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
     1410                { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Lvalue ); }
     1411        | MUTEX
     1412                { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Mutex ); }
    14091413        | ATOMIC
    1410                 { $$ = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
     1414                { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Atomic ); }
    14111415        | FORALL '('
    14121416                {
     
    14481452        | REGISTER
    14491453                { $$ = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
    1450         | INLINE                                                                                        // C99
    1451                 //{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Inline ); }
    1452                 { $$ = new DeclarationNode; $$->isInline = true; }
    1453         | FORTRAN                                                                                       // C99
    1454                 { $$ = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
    1455         | NORETURN                                                                                      // C11
    1456                 //{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Noreturn ); }
    1457                 { $$ = new DeclarationNode; $$->isNoreturn = true; }
    14581454        | THREADLOCAL                                                                           // C11
    14591455                { $$ = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
     1456                // Put function specifiers here to simplify parsing rules, but separate them semantically.
     1457        | INLINE                                                                                        // C99
     1458                { $$ = DeclarationNode::newFuncSpecifier( DeclarationNode::Inline ); }
     1459        | FORTRAN                                                                                       // C99
     1460                { $$ = DeclarationNode::newFuncSpecifier( DeclarationNode::Fortran ); }
     1461        | NORETURN                                                                                      // C11
     1462                { $$ = DeclarationNode::newFuncSpecifier( DeclarationNode::Noreturn ); }
    14601463        ;
    14611464
     
    20332036                { $$ = $3->addQualifiers( $1 ); }
    20342037        | type_declaring_list ',' type_declarator
    2035                 { $$ = $1->appendList( $3->copyStorageClasses( $1 ) ); }
     2038                { $$ = $1->appendList( $3->copySpecifiers( $1 ) ); }
    20362039        ;
    20372040
  • src/ResolvExpr/Unify.cc

    r87c3bef rbe8bd88  
    1010// Created On       : Sun May 17 12:27:10 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Mar  2 17:37:05 2016
    13 // Update Count     : 37
     12// Last Modified On : Mon Mar  6 23:37:38 2017
     13// Update Count     : 39
    1414//
    1515
     
    541541                        flatten( dcl->get_type(), back_inserter( types ) );
    542542                        for ( Type * t : types ) {
    543                                 dst.push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, t, nullptr ) );
     543                                dst.push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::C, nullptr, t, nullptr ) );
    544544                        }
    545545                        delete dcl;
  • src/SymTab/Autogen.cc

    r87c3bef rbe8bd88  
    1010// Created On       : Thu Mar 03 15:45:56 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 16 15:02:50 2017
    13 // Update Count     : 13
     12// Last Modified On : Tue Mar  7 07:42:44 2017
     13// Update Count     : 51
    1414//
    1515
     
    125125        FunctionType * genDefaultType( Type * paramType ) {
    126126                FunctionType *ftype = new FunctionType( Type::Qualifiers(), false );
    127                 ObjectDecl *dstParam = new ObjectDecl( "_dst", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), paramType->clone() ), nullptr );
     127                ObjectDecl *dstParam = new ObjectDecl( "_dst", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), paramType->clone() ), nullptr );
    128128                ftype->get_parameters().push_back( dstParam );
    129129
     
    134134        FunctionType * genCopyType( Type * paramType ) {
    135135                FunctionType *ftype = genDefaultType( paramType );
    136                 ObjectDecl *srcParam = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr );
     136                ObjectDecl *srcParam = new ObjectDecl( "_src", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr );
    137137                ftype->get_parameters().push_back( srcParam );
    138138                return ftype;
     
    142142        FunctionType * genAssignType( Type * paramType ) {
    143143                FunctionType *ftype = genCopyType( paramType );
    144                 ObjectDecl *returnVal = new ObjectDecl( "_ret", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr );
     144                ObjectDecl *returnVal = new ObjectDecl( "_ret", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr );
    145145                ftype->get_returnVals().push_back( returnVal );
    146146                return ftype;
     
    161161                // Routines at global scope marked "static" to prevent multiple definitions in separate translation units
    162162                // because each unit generates copies of the default routines for each aggregate.
    163                 DeclarationNode::StorageClass sc = functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static;
     163//              DeclarationNode::StorageClass sc = functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static;
     164                DeclarationNode::StorageClasses scs = functionNesting > 0 ? DeclarationNode::StorageClasses() : DeclarationNode::StorageClasses( DeclarationNode::StaticClass );
    164165                LinkageSpec::Spec spec = isIntrinsic ? LinkageSpec::Intrinsic : LinkageSpec::AutoGen;
    165                 FunctionDecl * decl = new FunctionDecl( fname, sc, spec, ftype, new CompoundStmt( noLabels ), true, false );
     166                FunctionDecl * decl = new FunctionDecl( fname, scs, spec, ftype, new CompoundStmt( noLabels ),
     167                                                                                                std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::InlineSpec ) );
    166168                decl->fixUniqueId();
    167169                return decl;
     
    458460                                        continue;
    459461                                }
    460                                 memCtorType->get_parameters().push_back( new ObjectDecl( member->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, member->get_type()->clone(), 0 ) );
     462                                memCtorType->get_parameters().push_back( new ObjectDecl( member->get_name(), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, member->get_type()->clone(), 0 ) );
    461463                                FunctionDecl * ctor = genFunc( "?{}", memCtorType->clone(), functionNesting );
    462464                                makeStructFieldCtorBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), ctor, isDynamicLayout );
     
    538540                for ( Declaration * member : aggregateDecl->get_members() ) {
    539541                        if ( DeclarationWithType * field = dynamic_cast< DeclarationWithType * >( member ) ) {
    540                                 ObjectDecl * srcParam = new ObjectDecl( "src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, field->get_type()->clone(), 0 );
     542                                ObjectDecl * srcParam = new ObjectDecl( "src", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, field->get_type()->clone(), 0 );
    541543
    542544                                FunctionType * memCtorType = ctorType->clone();
     
    603605                TypeInstType *typeInst = new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), false );
    604606                typeInst->set_baseType( typeDecl );
    605                 ObjectDecl *src = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, typeInst->clone(), nullptr );
    606                 ObjectDecl *dst = new ObjectDecl( "_dst", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), typeInst->clone() ), nullptr );
     607                ObjectDecl *src = new ObjectDecl( "_src", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, typeInst->clone(), nullptr );
     608                ObjectDecl *dst = new ObjectDecl( "_dst", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), typeInst->clone() ), nullptr );
    607609
    608610                std::list< Statement * > stmts;
     
    616618                } // if
    617619                FunctionType *type = new FunctionType( Type::Qualifiers(), false );
    618                 type->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, typeInst, 0 ) );
     620                type->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, typeInst, 0 ) );
    619621                type->get_parameters().push_back( dst );
    620622                type->get_parameters().push_back( src );
     
    715717                        if ( TypeInstType * ty = dynamic_cast< TypeInstType * >( t ) ) {
    716718                                if ( ! done.count( ty->get_baseType() ) ) {
    717                                         TypeDecl * newDecl = new TypeDecl( ty->get_baseType()->get_name(), DeclarationNode::NoStorageClass, nullptr, TypeDecl::Any );
     719                                        TypeDecl * newDecl = new TypeDecl( ty->get_baseType()->get_name(), DeclarationNode::StorageClasses(), nullptr, TypeDecl::Any );
    718720                                        TypeInstType * inst = new TypeInstType( Type::Qualifiers(), newDecl->get_name(), newDecl );
    719                                         newDecl->get_assertions().push_back( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, genAssignType( inst ), nullptr, true, false ) );
    720                                         newDecl->get_assertions().push_back( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, genDefaultType( inst ), nullptr, true, false ) );
    721                                         newDecl->get_assertions().push_back( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, genCopyType( inst ), nullptr, true, false ) );
    722                                         newDecl->get_assertions().push_back( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, genDefaultType( inst ), nullptr, true, false ) );
     721                                        newDecl->get_assertions().push_back( new FunctionDecl( "?=?", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, genAssignType( inst ), nullptr,
     722                                                                                                                                                   std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::InlineSpec ) ) );
     723                                        newDecl->get_assertions().push_back( new FunctionDecl( "?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, genDefaultType( inst ), nullptr,
     724                                                                                                                                                   std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::InlineSpec ) ) );
     725                                        newDecl->get_assertions().push_back( new FunctionDecl( "?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, genCopyType( inst ), nullptr,
     726                                                                                                                                                   std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::InlineSpec ) ) );
     727                                        newDecl->get_assertions().push_back( new FunctionDecl( "^?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, genDefaultType( inst ), nullptr,
     728                                                                                                                                                   std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::InlineSpec ) ) );
    723729                                        typeParams.push_back( newDecl );
    724730                                        done.insert( ty->get_baseType() );
  • src/SymTab/Autogen.h

    r87c3bef rbe8bd88  
    1010// Created On       : Sun May 17 21:53:34 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb  1 16:31:00 2017
    13 // Update Count     : 2
     12// Last Modified On : Mon Mar  6 23:33:01 2017
     13// Update Count     : 4
    1414//
    1515
     
    102102                }
    103103
    104                 ObjectDecl *index = new ObjectDecl( indexName.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin, std::list<Expression*>() ) );
     104                ObjectDecl *index = new ObjectDecl( indexName.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin, std::list<Expression*>() ) );
    105105
    106106                UntypedExpr *cond = new UntypedExpr( cmp );
  • src/SymTab/FixFunction.cc

    r87c3bef rbe8bd88  
    1010// Created On       : Sun May 17 16:19:49 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Mar  2 17:31:10 2016
    13 // Update Count     : 3
     12// Last Modified On : Mon Mar  6 23:36:59 2017
     13// Update Count     : 6
    1414//
    1515
     
    2121
    2222namespace SymTab {
    23         FixFunction::FixFunction() : isVoid( false ) {
    24         }
     23        FixFunction::FixFunction() : isVoid( false ) {}
    2524
    2625        DeclarationWithType * FixFunction::mutate(FunctionDecl *functionDecl) {
    27                 ObjectDecl *pointer = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClass(), functionDecl->get_linkage(), 0, new PointerType( Type::Qualifiers(), functionDecl->get_type()->clone() ), 0, functionDecl->get_attributes() );
     26                ObjectDecl *pointer = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClasses(), functionDecl->get_linkage(), 0, new PointerType( Type::Qualifiers(), functionDecl->get_type()->clone() ), 0, functionDecl->get_attributes() );
    2827                functionDecl->get_attributes().clear();
    2928                delete functionDecl;
  • src/SymTab/Indexer.cc

    r87c3bef rbe8bd88  
    1010// Created On       : Sun May 17 21:37:33 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 16 14:59:19 2017
    13 // Update Count     : 13
     12// Last Modified On : Tue Mar  7 07:45:32 2017
     13// Update Count     : 16
    1414//
    1515
     
    738738                                ObjectDecl *newobj = dynamic_cast< ObjectDecl* >( added );
    739739                                ObjectDecl *oldobj = dynamic_cast< ObjectDecl* >( existing );
    740                                 if ( newobj->get_storageClass() != DeclarationNode::Extern && oldobj->get_storageClass() != DeclarationNode::Extern ) {
     740                                if ( ! newobj->get_storageClasses()[ DeclarationNode::Extern ] && ! oldobj->get_storageClasses()[ DeclarationNode::Extern ] ) {
    741741                                        throw SemanticError( "duplicate object definition for ", added );
    742742                                } // if
  • src/SymTab/Validate.cc

    r87c3bef rbe8bd88  
    1010// Created On       : Sun May 17 21:50:04 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 23 21:33:55 2017
    13 // Update Count     : 318
     12// Last Modified On : Tue Mar  7 07:51:36 2017
     13// Update Count     : 349
    1414//
    1515
     
    9797        class ReturnTypeFixer final : public Visitor {
    9898          public:
    99 
    10099                typedef Visitor Parent;
    101100                using Parent::visit;
     
    104103
    105104                virtual void visit( FunctionDecl * functionDecl );
    106 
    107105                virtual void visit( FunctionType * ftype );
    108106        };
     
    161159          private:
    162160                virtual void visit( FunctionDecl * functionDecl );
    163 
    164161                virtual void visit( ReturnStmt * returnStmt );
    165162
     
    211208
    212209        class CompoundLiteral final : public GenPoly::DeclMutator {
    213                 DeclarationNode::StorageClass storageclass = DeclarationNode::NoStorageClass;
     210                DeclarationNode::StorageClasses storageClasses;
    214211
    215212                using GenPoly::DeclMutator::mutate;
     
    660657                // Note, qualifiers on the typedef are superfluous for the forward declaration.
    661658                if ( StructInstType *aggDecl = dynamic_cast< StructInstType * >( tyDecl->get_base() ) ) {
    662                         return aggDecl->get_baseStruct() ? Mutator::mutate( aggDecl->get_baseStruct() ) : new StructDecl( aggDecl->get_name() );
     659                        return new StructDecl( aggDecl->get_name() );
    663660                } else if ( UnionInstType *aggDecl = dynamic_cast< UnionInstType * >( tyDecl->get_base() ) ) {
    664                         return aggDecl->get_baseUnion() ? Mutator::mutate( aggDecl->get_baseUnion() ) : new UnionDecl( aggDecl->get_name() );
     661                        return new UnionDecl( aggDecl->get_name() );
    665662                } else if ( EnumInstType *enumDecl = dynamic_cast< EnumInstType * >( tyDecl->get_base() ) ) {
    666663                        return new EnumDecl( enumDecl->get_name() );
     
    691688                DeclarationWithType *ret = Mutator::mutate( objDecl );
    692689                typedefNames.endScope();
    693                 // is the type a function?
    694                 if ( FunctionType *funtype = dynamic_cast<FunctionType *>( ret->get_type() ) ) {
     690
     691                if ( FunctionType *funtype = dynamic_cast<FunctionType *>( ret->get_type() ) ) { // function type?
    695692                        // replace the current object declaration with a function declaration
    696                         FunctionDecl * newDecl = new FunctionDecl( ret->get_name(), ret->get_storageClass(), ret->get_linkage(), funtype, 0, ret->get_isInline(), ret->get_isNoreturn(), objDecl->get_attributes() );
     693                        FunctionDecl * newDecl = new FunctionDecl( ret->get_name(), ret->get_storageClasses(), ret->get_linkage(), funtype, 0, objDecl->get_attributes(), ret->get_funcSpec() );
    697694                        objDecl->get_attributes().clear();
    698695                        objDecl->set_type( nullptr );
    699696                        delete objDecl;
    700697                        return newDecl;
    701                 } else if ( objDecl->get_isInline() || objDecl->get_isNoreturn() ) {
    702                         throw SemanticError( "invalid inline or _Noreturn specification in declaration of ", objDecl );
    703698                } // if
    704699                return ret;
     
    759754                                type = new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() );
    760755                        } // if
    761                         TypedefDeclPtr tyDecl( new TypedefDecl( aggDecl->get_name(), DeclarationNode::NoStorageClass, type ) );
     756                        TypedefDeclPtr tyDecl( new TypedefDecl( aggDecl->get_name(), DeclarationNode::StorageClasses(), type ) );
    762757                        typedefNames[ aggDecl->get_name() ] = std::make_pair( std::move( tyDecl ), scopeLevel );
    763758                } // if
     
    813808
    814809        DeclarationWithType * CompoundLiteral::mutate( ObjectDecl *objectDecl ) {
    815                 storageclass = objectDecl->get_storageClass();
     810                storageClasses = objectDecl->get_storageClasses();
    816811                DeclarationWithType * temp = Mutator::mutate( objectDecl );
    817                 storageclass = DeclarationNode::NoStorageClass;
    818812                return temp;
    819813        }
     
    824818                static UniqueName indexName( "_compLit" );
    825819
    826                 ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageclass, LinkageSpec::C, 0, compLitExpr->get_type(), compLitExpr->get_initializer() );
     820                ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageClasses, LinkageSpec::C, 0, compLitExpr->get_type(), compLitExpr->get_initializer() );
    827821                compLitExpr->set_type( 0 );
    828822                compLitExpr->set_initializer( 0 );
     
    863857                        TupleType * tupleType = safe_dynamic_cast< TupleType * >( ResolvExpr::extractResultType( ftype ) );
    864858                        // ensure return value is not destructed by explicitly creating an empty ListInit node wherein maybeConstruct is false.
    865                         ObjectDecl * newRet = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, tupleType, new ListInit( std::list<Initializer*>(), noDesignators, false ) );
     859                        ObjectDecl * newRet = new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, tupleType, new ListInit( std::list<Initializer*>(), noDesignators, false ) );
    866860                        deleteAll( retVals );
    867861                        retVals.clear();
  • src/SynTree/AggregateDecl.cc

    r87c3bef rbe8bd88  
    1010// Created On       : Sun May 17 23:56:39 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Feb  6 15:31:23 2017
    13 // Update Count     : 17
     12// Last Modified On : Tue Mar  7 07:31:47 2017
     13// Update Count     : 19
    1414//
    1515
     
    2020
    2121
    22 AggregateDecl::AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes ) : Parent( name, DeclarationNode::NoStorageClass, LinkageSpec::Cforall ), body( false ), attributes( attributes ) {
     22AggregateDecl::AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes ) : Parent( name, DeclarationNode::StorageClasses(), LinkageSpec::Cforall ), body( false ), attributes( attributes ) {
    2323}
    2424
  • src/SynTree/Declaration.cc

    r87c3bef rbe8bd88  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb  9 14:28:05 2017
    13 // Update Count     : 16
     12// Last Modified On : Tue Mar  7 07:31:11 2017
     13// Update Count     : 23
    1414//
    1515
     
    2727static IdMapType idMap;
    2828
    29 Declaration::Declaration( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage )
    30                 : name( name ), storageClass( sc ), linkage( linkage ), isInline( false ), isNoreturn( false ), uniqueId( 0 ) {
     29Declaration::Declaration( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage )
     30                : name( name ), storageClasses( scs ), linkage( linkage ), uniqueId( 0 ) {
    3131}
    3232
    3333Declaration::Declaration( const Declaration &other )
    34         : name( other.name ), storageClass( other.storageClass ), linkage( other.linkage ), isInline( other.isInline ), isNoreturn( other.isNoreturn ), uniqueId( other.uniqueId ) {
     34        : name( other.name ), storageClasses( other.storageClasses ), linkage( other.linkage ), uniqueId( other.uniqueId ) {
    3535}
    3636
     
    6666
    6767
    68 AsmDecl::AsmDecl( AsmStmt *stmt ) : Declaration( "", DeclarationNode::NoStorageClass, LinkageSpec::C ), stmt( stmt ) {
     68AsmDecl::AsmDecl( AsmStmt *stmt ) : Declaration( "", DeclarationNode::StorageClasses(), LinkageSpec::C ), stmt( stmt ) {
    6969}
    7070
  • src/SynTree/Declaration.h

    r87c3bef rbe8bd88  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 16 14:53:35 2017
    13 // Update Count     : 57
     12// Last Modified On : Tue Mar  7 07:40:42 2017
     13// Update Count     : 113
    1414//
    1515
     
    2828class Declaration : public BaseSyntaxNode {
    2929  public:
    30         Declaration( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage );
     30        Declaration( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage );
    3131        Declaration( const Declaration &other );
    3232        virtual ~Declaration();
     
    3434        const std::string &get_name() const { return name; }
    3535        void set_name( std::string newValue ) { name = newValue; }
    36         DeclarationNode::StorageClass get_storageClass() const { return storageClass; }
    37         void set_storageClass( DeclarationNode::StorageClass newValue ) { storageClass = newValue; }
     36
     37        DeclarationNode::StorageClasses get_storageClasses() const { return storageClasses; }
     38
    3839        LinkageSpec::Spec get_linkage() const { return linkage; }
    3940        void set_linkage( LinkageSpec::Spec newValue ) { linkage = newValue; }
    40         bool get_isInline() const { return isInline; }
    41         void set_isInline( bool newValue ) { isInline = newValue; }
    42         bool get_isNoreturn() const { return isNoreturn; }
    43         void set_isNoreturn( bool newValue ) { isNoreturn = newValue; }
     41
    4442        UniqueId get_uniqueId() const { return uniqueId; }
     43
    4544        bool get_extension() const { return extension; }
    4645        Declaration *set_extension( bool exten ) { extension = exten; return this; }
     
    5756  private:
    5857        std::string name;
    59         DeclarationNode::StorageClass storageClass;
     58        DeclarationNode::StorageClasses storageClasses;
    6059        LinkageSpec::Spec linkage;
    61         bool isInline, isNoreturn;
    6260        UniqueId uniqueId;
    6361        bool extension = false;
     
    6664class DeclarationWithType : public Declaration {
    6765  public:
    68         DeclarationWithType( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes );
     66        DeclarationWithType( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, DeclarationNode::FuncSpecifiers fs );
    6967        DeclarationWithType( const DeclarationWithType &other );
    7068        virtual ~DeclarationWithType();
     
    8381        std::list< Attribute * >& get_attributes() { return attributes; }
    8482        const std::list< Attribute * >& get_attributes() const { return attributes; }
     83
     84        DeclarationNode::FuncSpecifiers get_funcSpec() const { return fs; }
     85        //void set_functionSpecifiers( DeclarationNode::FuncSpecifiers newValue ) { fs = newValue; }
    8586
    8687        virtual DeclarationWithType *clone() const = 0;
     
    9798        ConstantExpr *asmName;
    9899        std::list< Attribute * > attributes;
     100        DeclarationNode::FuncSpecifiers fs;
    99101};
    100102
     
    102104        typedef DeclarationWithType Parent;
    103105  public:
    104         ObjectDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init, const std::list< Attribute * > attributes = std::list< Attribute * >(), bool isInline = false, bool isNoreturn = false );
     106        ObjectDecl( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init,
     107                                const std::list< Attribute * > attributes = std::list< Attribute * >(), DeclarationNode::FuncSpecifiers fs = DeclarationNode::FuncSpecifiers() );
    105108        ObjectDecl( const ObjectDecl &other );
    106109        virtual ~ObjectDecl();
     
    129132        typedef DeclarationWithType Parent;
    130133  public:
    131         FunctionDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements, bool isInline, bool isNoreturn, const std::list< Attribute * > attributes = std::list< Attribute * >() );
     134        FunctionDecl( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements,
     135                                  const std::list< Attribute * > attributes = std::list< Attribute * >(), DeclarationNode::FuncSpecifiers fs = DeclarationNode::FuncSpecifiers() );
    132136        FunctionDecl( const FunctionDecl &other );
    133137        virtual ~FunctionDecl();
     
    154158        typedef Declaration Parent;
    155159  public:
    156         NamedTypeDecl( const std::string &name, DeclarationNode::StorageClass sc, Type *type );
     160        NamedTypeDecl( const std::string &name, DeclarationNode::StorageClasses scs, Type *type );
    157161        NamedTypeDecl( const NamedTypeDecl &other );
    158162        virtual ~NamedTypeDecl();
     
    189193        };
    190194
    191         TypeDecl( const std::string &name, DeclarationNode::StorageClass sc, Type *type, Kind kind );
     195        TypeDecl( const std::string &name, DeclarationNode::StorageClasses scs, Type *type, Kind kind );
    192196        TypeDecl( const TypeDecl &other );
    193197
     
    210214        typedef NamedTypeDecl Parent;
    211215  public:
    212         TypedefDecl( const std::string &name, DeclarationNode::StorageClass sc, Type *type ) : Parent( name, sc, type ) {}
     216        TypedefDecl( const std::string &name, DeclarationNode::StorageClasses scs, Type *type ) : Parent( name, scs, type ) {}
    213217        TypedefDecl( const TypedefDecl &other ) : Parent( other ) {}
    214218
  • src/SynTree/DeclarationWithType.cc

    r87c3bef rbe8bd88  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Dec 13 14:49:43 2016
    13 // Update Count     : 7
     12// Last Modified On : Tue Mar  7 07:32:14 2017
     13// Update Count     : 23
    1414//
    1515
     
    1919#include "Common/utility.h"
    2020
    21 DeclarationWithType::DeclarationWithType( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes )
    22         : Declaration( name, sc, linkage ), asmName( nullptr ), attributes( attributes ) {
     21DeclarationWithType::DeclarationWithType( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, DeclarationNode::FuncSpecifiers fs )
     22        : Declaration( name, scs, linkage ), asmName( nullptr ), attributes( attributes ), fs( fs ) {
    2323}
    2424
    2525DeclarationWithType::DeclarationWithType( const DeclarationWithType &other )
    26                 : Declaration( other ), mangleName( other.mangleName ), scopeLevel( other.scopeLevel ) {
     26                : Declaration( other ), mangleName( other.mangleName ), scopeLevel( other.scopeLevel ), fs( other.fs ) {
    2727        cloneAll( other.attributes, attributes );
    2828        asmName = maybeClone( other.asmName );
  • src/SynTree/FunctionDecl.cc

    r87c3bef rbe8bd88  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 16 15:01:52 2017
    13 // Update Count     : 23
     12// Last Modified On : Tue Mar  7 07:54:58 2017
     13// Update Count     : 68
    1414//
    1515
     
    2626extern bool translation_unit_nomain;
    2727
    28 FunctionDecl::FunctionDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements, bool isInline, bool isNoreturn, std::list< Attribute * > attributes )
    29                 : Parent( name, sc, linkage, attributes ), type( type ), statements( statements ) {
    30         set_isInline( isInline );
    31         set_isNoreturn( isNoreturn );
    32         // this is a brazen hack to force the function "main" to have Cforall linkage
    33         // because we want to replace the main even if it is inside an extern
     28FunctionDecl::FunctionDecl( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements, std::list< Attribute * > attributes, DeclarationNode::FuncSpecifiers fs )
     29        : Parent( name, scs, linkage, attributes, fs ), type( type ), statements( statements ) {
     30        // hack forcing the function "main" to have Cforall linkage to replace main even if it is inside an extern
    3431        if ( name == "main" ) {
    3532                set_linkage( CodeGen::FixMain::mainLinkage() );
     
    3835
    3936FunctionDecl::FunctionDecl( const FunctionDecl &other )
    40         : Parent( other ), type( maybeClone( other.type ) ), statements( maybeClone( other.statements ) ) {
     37                : Parent( other ), type( maybeClone( other.type ) ), statements( maybeClone( other.statements ) ) {
    4138}
    4239
     
    6562                os << LinkageSpec::linkageName( get_linkage() ) << " ";
    6663        } // if
    67         if ( get_isInline() ) {
    68                 os << "inline ";
    69         } // if
    70         if ( get_isNoreturn() ) {
    71                 os << "_Noreturn ";
    72         } // if
    7364
    7465        printAll( get_attributes(), os, indent );
    7566
    76         if ( get_storageClass() != DeclarationNode::NoStorageClass ) {
    77                 os << DeclarationNode::storageName[ get_storageClass() ] << ' ';
    78         } // if
     67        DeclarationNode::print_StorageClass( os, get_storageClasses() );
     68        DeclarationNode::print_FuncSpec( os, get_funcSpec() );
     69
    7970        if ( get_type() ) {
    8071                get_type()->print( os, indent );
     
    9788                os << get_name() << ": ";
    9889        } // if
    99         if ( get_isInline() ) {
    100                 os << "inline ";
    101         } // if
    102         if ( get_isNoreturn() ) {
    103                 os << "_Noreturn ";
    104         } // if
    10590
    10691        // xxx - should printShort print attributes?
    10792
    108         if ( get_storageClass() != DeclarationNode::NoStorageClass ) {
    109                 os << DeclarationNode::storageName[ get_storageClass() ] << ' ';
    110         } // if
     93        DeclarationNode::print_StorageClass( os, get_storageClasses() );
     94        DeclarationNode::print_FuncSpec( os, get_funcSpec() );
     95
    11196        if ( get_type() ) {
    11297                get_type()->print( os, indent );
  • src/SynTree/NamedTypeDecl.cc

    r87c3bef rbe8bd88  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jun 13 08:13:55 2015
    13 // Update Count     : 3
     12// Last Modified On : Tue Mar  7 07:39:41 2017
     13// Update Count     : 10
    1414//
    1515
     
    1818#include "Common/utility.h"
    1919
    20 NamedTypeDecl::NamedTypeDecl( const std::string &name, DeclarationNode::StorageClass sc, Type *base )
    21         : Parent( name, sc, LinkageSpec::Cforall ), base( base ) {}
     20NamedTypeDecl::NamedTypeDecl( const std::string &name, DeclarationNode::StorageClasses scs, Type *base )
     21        : Parent( name, scs, LinkageSpec::Cforall ), base( base ) {}
    2222
    2323NamedTypeDecl::NamedTypeDecl( const NamedTypeDecl &other )
     
    3939                os << get_name() << ": ";
    4040        } // if
    41         if ( get_storageClass() != DeclarationNode::NoStorageClass ) {
    42                 os << DeclarationNode::storageName[ get_storageClass() ] << ' ';
    43         } // if
     41        DeclarationNode::print_StorageClass( os, get_storageClasses() );
    4442        os << typeString();
    4543        if ( base ) {
     
    6361                os << get_name() << ": ";
    6462        } // if
    65         if ( get_storageClass() != DeclarationNode::NoStorageClass ) {
    66                 os << DeclarationNode::storageName[ get_storageClass() ] << ' ';
    67         } // if
     63        DeclarationNode::print_StorageClass( os, get_storageClasses() );
    6864        os << typeString();
    6965        if ( base ) {
  • src/SynTree/ObjectDecl.cc

    r87c3bef rbe8bd88  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Oct  1 23:05:56 2016
    13 // Update Count     : 32
     12// Last Modified On : Tue Mar  7 07:55:24 2017
     13// Update Count     : 54
    1414//
    1515
     
    2222#include "Statement.h"
    2323
    24 ObjectDecl::ObjectDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init, const std::list< Attribute * > attributes, bool isInline, bool isNoreturn )
    25         : Parent( name, sc, linkage, attributes ), type( type ), init( init ), bitfieldWidth( bitfieldWidth ) {
    26         set_isInline( isInline );
    27         set_isNoreturn( isNoreturn );
     24ObjectDecl::ObjectDecl( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init, const std::list< Attribute * > attributes, DeclarationNode::FuncSpecifiers fs )
     25        : Parent( name, scs, linkage, attributes, fs ), type( type ), init( init ), bitfieldWidth( bitfieldWidth ) {
    2826}
    2927
     
    4947        printAll( get_attributes(), os, indent );
    5048
    51         if ( get_storageClass() != DeclarationNode::NoStorageClass ) {
    52                 os << DeclarationNode::storageName[ get_storageClass() ] << ' ';
    53         } // if
     49        DeclarationNode::print_StorageClass( os, get_storageClasses() );
    5450
    5551        if ( get_type() ) {
     
    8581        // xxx - should printShort print attributes?
    8682
    87         if ( get_storageClass() != DeclarationNode::NoStorageClass ) {
    88                 os << DeclarationNode::storageName[ get_storageClass() ] << ' ';
    89         } // if
     83        DeclarationNode::print_StorageClass( os, get_storageClasses() );
    9084
    9185        if ( get_type() ) {
  • src/SynTree/Type.h

    r87c3bef rbe8bd88  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 23 16:38:53 2017
    13 // Update Count     : 34
     12// Last Modified On : Wed Mar  1 09:11:45 2017
     13// Update Count     : 41
    1414//
    1515
     
    2121#include "SynTree.h"
    2222#include "Visitor.h"
    23 #include "Common/utility.h"
    2423
    2524class Type : public BaseSyntaxNode {
     
    213212        bool get_isVarArgs() const { return isVarArgs; }
    214213        void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }
    215 
    216214        bool isTtype() const;
    217215
  • src/SynTree/TypeDecl.cc

    r87c3bef rbe8bd88  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jun 13 08:14:35 2015
    13 // Update Count     : 2
     12// Last Modified On : Tue Mar  7 07:39:09 2017
     13// Update Count     : 4
    1414//
    1515
     
    1818#include "Common/utility.h"
    1919
    20 TypeDecl::TypeDecl( const std::string &name, DeclarationNode::StorageClass sc, Type *type, Kind kind ) : Parent( name, sc, type ), kind( kind ), sized( kind == Any || kind == Ttype ) {
     20TypeDecl::TypeDecl( const std::string &name, DeclarationNode::StorageClasses scs, Type *type, Kind kind ) : Parent( name, scs, type ), kind( kind ), sized( kind == Any || kind == Ttype ) {
    2121}
    2222
  • src/Tuples/TupleAssignment.cc

    r87c3bef rbe8bd88  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb  1 16:40:16 2017
    13 // Update Count     : 3
     12// Last Modified On : Mon Mar  6 23:40:14 2017
     13// Update Count     : 5
    1414//
    1515
     
    240240        ObjectDecl * TupleAssignSpotter::Matcher::newObject( UniqueName & namer, Expression * expr ) {
    241241                assert( expr->has_result() && ! expr->get_result()->isVoid() );
    242                 ObjectDecl * ret = new ObjectDecl( namer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, expr->get_result()->clone(), new SingleInit( expr->clone() ) );
     242                ObjectDecl * ret = new ObjectDecl( namer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, expr->get_result()->clone(), new SingleInit( expr->clone() ) );
    243243                ConstructorInit * ctorInit = InitTweak::genCtorInit( ret );
    244244                ret->set_init( ctorInit );
  • src/Tuples/TupleExpansion.cc

    r87c3bef rbe8bd88  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb  1 16:40:40 2017
    13 // Update Count     : 3
     12// Last Modified On : Tue Mar  7 07:43:56 2017
     13// Update Count     : 12
    1414//
    1515
     
    187187                        }
    188188                        BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool );
    189                         ObjectDecl * finished = new ObjectDecl( toString( "_unq_expr_finished_", id ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::Bool ), new SingleInit( new ConstantExpr( Constant( boolType->clone(), "0" ) ), noDesignators ) );
     189                        ObjectDecl * finished = new ObjectDecl( toString( "_unq_expr_finished_", id ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::Bool ), new SingleInit( new ConstantExpr( Constant( boolType->clone(), "0" ) ), noDesignators ) );
    190190                        addDeclaration( finished );
    191191                        // (finished ? _unq_expr_N : (_unq_expr_N = <unqExpr->get_expr()>, finished = 1, _unq_expr_N))
     
    221221                        decl->set_body( true );
    222222                        for ( size_t i = 0; i < tupleSize; ++i ) {
    223                                 TypeDecl * tyParam = new TypeDecl( toString("tuple_param_", i), DeclarationNode::NoStorageClass, nullptr, TypeDecl::Any );
    224                                 decl->get_members().push_back( new ObjectDecl( toString("field_", i), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, new TypeInstType( Type::Qualifiers(), tyParam->get_name(), tyParam ), nullptr ) );
     223                                TypeDecl * tyParam = new TypeDecl( toString( "tuple_param_", i ), DeclarationNode::StorageClasses(), nullptr, TypeDecl::Any );
     224                                decl->get_members().push_back( new ObjectDecl( toString("field_", i ), DeclarationNode::StorageClasses(), LinkageSpec::C, nullptr, new TypeInstType( Type::Qualifiers(), tyParam->get_name(), tyParam ), nullptr ) );
    225225                                decl->get_parameters().push_back( tyParam );
    226226                        }
    227227                        if ( tupleSize == 0 ) {
    228228                                // empty structs are not standard C. Add a dummy field to empty tuples to silence warnings when a compound literal Tuple0 is created.
    229                                 decl->get_members().push_back( new ObjectDecl( "dummy", DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) );
     229                                decl->get_members().push_back( new ObjectDecl( "dummy", DeclarationNode::StorageClasses(), LinkageSpec::C, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) );
    230230                        }
    231231                        typeMap[tupleSize] = decl;
  • src/benchmark/Makefile.am

    r87c3bef rbe8bd88  
    1818CFLAGS =
    1919AM_CFLAGS = -g -Wall -Wno-unused-function -O2
    20 CC = @CFA_BINDIR@/cfa
     20CC = @CFA_BINDIR@/@CFA_NAME@
    2121
    2222noinst_PROGRAMS = bench ctxswitch-coroutine ctxswitch-thread
  • src/benchmark/Makefile.in

    r87c3bef rbe8bd88  
    9494AWK = @AWK@
    9595BACKEND_CC = @BACKEND_CC@
    96 CC = @CFA_BINDIR@/cfa
     96CC = @CFA_BINDIR@/@CFA_NAME@
    9797CCAS = @CCAS@
    9898CCASDEPMODE = @CCASDEPMODE@
     
    104104CFA_INCDIR = @CFA_INCDIR@
    105105CFA_LIBDIR = @CFA_LIBDIR@
     106CFA_NAME = @CFA_NAME@
    106107CFA_PREFIX = @CFA_PREFIX@
    107108
  • src/driver/Makefile.am

    r87c3bef rbe8bd88  
    2828endif
    2929
    30 bin_PROGRAMS = cfa
     30noinst_PROGRAMS = cfa
    3131cfa_SOURCES = cfa.cc
    3232
     33install-exec-hook:
     34        @echo " $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) cfa '$(CFA_BINDIR)/$(CFA_NAME)'"; \
     35        $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) cfa $(CFA_BINDIR)/$(CFA_NAME) || exit $$?
     36
     37uninstall-hook:
     38        @echo " ( cd '$(CFA_BINDIR)' && rm -f $(CFA_NAME) )"; \
     39        cd "$(CFA_BINDIR)" && rm -f $(CFA_NAME)
     40
    3341# put into lib for now
    34 cc1libdir = ${libdir}
     42cc1libdir = ${CFA_LIBDIR}
    3543cc1lib_PROGRAMS = cc1
    3644cc1_SOURCES = cc1.cc
    3745
    38 MAINTAINERCLEANFILES = @CFA_PREFIX@/bin/${bin_PROGRAMS} @CFA_PREFIX@/lib/${cc1lib_PROGRAMS}
     46MAINTAINERCLEANFILES = $(CFA_BINDIR)/$(CFA_NAME) @CFA_PREFIX@/lib/${cc1lib_PROGRAMS}
  • src/driver/Makefile.in

    r87c3bef rbe8bd88  
    4141@BUILD_DEBUG_TRUE@am__append_2 = -DHAVE_LIBCFA_DEBUG
    4242@BUILD_RELEASE_TRUE@am__append_3 = -DHAVE_LIBCFA_RELEASE
    43 bin_PROGRAMS = cfa$(EXEEXT)
     43noinst_PROGRAMS = cfa$(EXEEXT)
    4444cc1lib_PROGRAMS = cc1$(EXEEXT)
    4545subdir = src/driver
     
    5353CONFIG_CLEAN_FILES =
    5454CONFIG_CLEAN_VPATH_FILES =
    55 am__installdirs = "$(DESTDIR)$(bindir)" "$(DESTDIR)$(cc1libdir)"
    56 PROGRAMS = $(bin_PROGRAMS) $(cc1lib_PROGRAMS)
     55am__installdirs = "$(DESTDIR)$(cc1libdir)"
     56PROGRAMS = $(cc1lib_PROGRAMS) $(noinst_PROGRAMS)
    5757am_cc1_OBJECTS = cc1.$(OBJEXT)
    5858cc1_OBJECTS = $(am_cc1_OBJECTS)
     
    106106CFA_INCDIR = @CFA_INCDIR@
    107107CFA_LIBDIR = @CFA_LIBDIR@
     108CFA_NAME = @CFA_NAME@
    108109CFA_PREFIX = @CFA_PREFIX@
    109110CFLAGS = @CFLAGS@
     
    212213
    213214# put into lib for now
    214 cc1libdir = ${libdir}
     215cc1libdir = ${CFA_LIBDIR}
    215216cc1_SOURCES = cc1.cc
    216 MAINTAINERCLEANFILES = @CFA_PREFIX@/bin/${bin_PROGRAMS} @CFA_PREFIX@/lib/${cc1lib_PROGRAMS}
     217MAINTAINERCLEANFILES = $(CFA_BINDIR)/$(CFA_NAME) @CFA_PREFIX@/lib/${cc1lib_PROGRAMS}
    217218all: all-am
    218219
     
    249250        cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
    250251$(am__aclocal_m4_deps):
    251 install-binPROGRAMS: $(bin_PROGRAMS)
    252         @$(NORMAL_INSTALL)
    253         test -z "$(bindir)" || $(MKDIR_P) "$(DESTDIR)$(bindir)"
    254         @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
    255         for p in $$list; do echo "$$p $$p"; done | \
    256         sed 's/$(EXEEXT)$$//' | \
    257         while read p p1; do if test -f $$p; \
    258           then echo "$$p"; echo "$$p"; else :; fi; \
    259         done | \
    260         sed -e 'p;s,.*/,,;n;h' -e 's|.*|.|' \
    261             -e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \
    262         sed 'N;N;N;s,\n, ,g' | \
    263         $(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \
    264           { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \
    265             if ($$2 == $$4) files[d] = files[d] " " $$1; \
    266             else { print "f", $$3 "/" $$4, $$1; } } \
    267           END { for (d in files) print "f", d, files[d] }' | \
    268         while read type dir files; do \
    269             if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \
    270             test -z "$$files" || { \
    271               echo " $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \
    272               $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \
    273             } \
    274         ; done
    275 
    276 uninstall-binPROGRAMS:
    277         @$(NORMAL_UNINSTALL)
    278         @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
    279         files=`for p in $$list; do echo "$$p"; done | \
    280           sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \
    281               -e 's/$$/$(EXEEXT)/' `; \
    282         test -n "$$list" || exit 0; \
    283         echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \
    284         cd "$(DESTDIR)$(bindir)" && rm -f $$files
    285 
    286 clean-binPROGRAMS:
    287         -test -z "$(bin_PROGRAMS)" || rm -f $(bin_PROGRAMS)
    288252install-cc1libPROGRAMS: $(cc1lib_PROGRAMS)
    289253        @$(NORMAL_INSTALL)
     
    323287clean-cc1libPROGRAMS:
    324288        -test -z "$(cc1lib_PROGRAMS)" || rm -f $(cc1lib_PROGRAMS)
     289
     290clean-noinstPROGRAMS:
     291        -test -z "$(noinst_PROGRAMS)" || rm -f $(noinst_PROGRAMS)
    325292cc1$(EXEEXT): $(cc1_OBJECTS) $(cc1_DEPENDENCIES) $(EXTRA_cc1_DEPENDENCIES)
    326293        @rm -f cc1$(EXEEXT)
     
    439406all-am: Makefile $(PROGRAMS)
    440407installdirs:
    441         for dir in "$(DESTDIR)$(bindir)" "$(DESTDIR)$(cc1libdir)"; do \
     408        for dir in "$(DESTDIR)$(cc1libdir)"; do \
    442409          test -z "$$dir" || $(MKDIR_P) "$$dir"; \
    443410        done
     
    475442clean: clean-am
    476443
    477 clean-am: clean-binPROGRAMS clean-cc1libPROGRAMS clean-generic \
     444clean-am: clean-cc1libPROGRAMS clean-generic clean-noinstPROGRAMS \
    478445        mostlyclean-am
    479446
     
    502469install-dvi-am:
    503470
    504 install-exec-am: install-binPROGRAMS
    505 
     471install-exec-am:
     472        @$(NORMAL_INSTALL)
     473        $(MAKE) $(AM_MAKEFLAGS) install-exec-hook
    506474install-html: install-html-am
    507475
     
    541509ps-am:
    542510
    543 uninstall-am: uninstall-binPROGRAMS uninstall-cc1libPROGRAMS
    544 
    545 .MAKE: install-am install-strip
    546 
    547 .PHONY: CTAGS GTAGS all all-am check check-am clean clean-binPROGRAMS \
    548         clean-cc1libPROGRAMS clean-generic ctags distclean \
    549         distclean-compile distclean-generic distclean-tags distdir dvi \
    550         dvi-am html html-am info info-am install install-am \
    551         install-binPROGRAMS install-cc1libPROGRAMS install-data \
    552         install-data-am install-dvi install-dvi-am install-exec \
    553         install-exec-am install-html install-html-am install-info \
     511uninstall-am: uninstall-cc1libPROGRAMS
     512        @$(NORMAL_INSTALL)
     513        $(MAKE) $(AM_MAKEFLAGS) uninstall-hook
     514.MAKE: install-am install-exec-am install-strip uninstall-am
     515
     516.PHONY: CTAGS GTAGS all all-am check check-am clean \
     517        clean-cc1libPROGRAMS clean-generic clean-noinstPROGRAMS ctags \
     518        distclean distclean-compile distclean-generic distclean-tags \
     519        distdir dvi dvi-am html html-am info info-am install \
     520        install-am install-cc1libPROGRAMS install-data install-data-am \
     521        install-dvi install-dvi-am install-exec install-exec-am \
     522        install-exec-hook install-html install-html-am install-info \
    554523        install-info-am install-man install-pdf install-pdf-am \
    555524        install-ps install-ps-am install-strip installcheck \
     
    557526        maintainer-clean-generic mostlyclean mostlyclean-compile \
    558527        mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \
    559         uninstall-am uninstall-binPROGRAMS uninstall-cc1libPROGRAMS
    560 
     528        uninstall-am uninstall-cc1libPROGRAMS uninstall-hook
     529
     530
     531install-exec-hook:
     532        @echo " $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) cfa '$(CFA_BINDIR)/$(CFA_NAME)'"; \
     533        $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) cfa $(CFA_BINDIR)/$(CFA_NAME) || exit $$?
     534
     535uninstall-hook:
     536        @echo " ( cd '$(CFA_BINDIR)' && rm -f $(CFA_NAME) )"; \
     537        cd "$(CFA_BINDIR)" && rm -f $(CFA_NAME)
    561538
    562539# Tell versions [3.59,3.63) of GNU make to not export all variables.
  • src/examples/Makefile.am

    r87c3bef rbe8bd88  
    1818CFLAGS =
    1919AM_CFLAGS = -g -Wall -Wno-unused-function -O2
    20 CC = @CFA_BINDIR@/cfa
     20CC = @CFA_BINDIR@/@CFA_NAME@
    2121
    2222noinst_PROGRAMS = fstream_test vector_test avl_test Bench # build but do not install
  • src/examples/Makefile.in

    r87c3bef rbe8bd88  
    105105AWK = @AWK@
    106106BACKEND_CC = @BACKEND_CC@
    107 CC = @CFA_BINDIR@/cfa
     107CC = @CFA_BINDIR@/@CFA_NAME@
    108108CCAS = @CCAS@
    109109CCASDEPMODE = @CCASDEPMODE@
     
    115115CFA_INCDIR = @CFA_INCDIR@
    116116CFA_LIBDIR = @CFA_LIBDIR@
     117CFA_NAME = @CFA_NAME@
    117118CFA_PREFIX = @CFA_PREFIX@
    118119
  • src/libcfa/Makefile.am

    r87c3bef rbe8bd88  
    1818AUTOMAKE_OPTIONS = subdir-objects
    1919
     20libdir = ${CFA_LIBDIR}
    2021lib_LIBRARIES =
    2122
     
    6768${libobjs} : ${abs_top_srcdir}/src/driver/cfa-cpp ${cfalib_DATA} # add dependency to cfa-cpp so all libraries are rebuilt with new translator
    6869
    69 
    7070libcfa_a_SOURCES = ${libsrc}
    7171libcfa_a_CFLAGS = -nodebug -O2
     
    7575stdhdr = ${shell echo stdhdr/*}
    7676
    77 cfa_includedir = $(includedir)/cfa
     77cfa_includedir = $(CFA_INCDIR)
    7878nobase_cfa_include_HEADERS = ${headers} ${stdhdr} concurrency/invoke.h
    7979
     
    8181
    8282maintainer-clean-local:
    83         -rm -rf ${includedir}/*
     83        -rm -rf ${CFA_INCDIR} ${CFA_LIBDIR}
  • src/libcfa/Makefile.in

    r87c3bef rbe8bd88  
    201201CFA_INCDIR = @CFA_INCDIR@
    202202CFA_LIBDIR = @CFA_LIBDIR@
     203CFA_NAME = @CFA_NAME@
    203204CFA_PREFIX = @CFA_PREFIX@
    204205CFLAGS = -quiet -no-include-stdhdr -XCFA -t -B${abs_top_srcdir}/src/driver ${EXTRA_FLAGS}
     
    281282infodir = @infodir@
    282283install_sh = @install_sh@
    283 libdir = @libdir@
     284libdir = ${CFA_LIBDIR}
    284285libexecdir = @libexecdir@
    285286localedir = @localedir@
     
    315316libcfa_d_a_CFLAGS = -debug -O0
    316317stdhdr = ${shell echo stdhdr/*}
    317 cfa_includedir = $(includedir)/cfa
     318cfa_includedir = $(CFA_INCDIR)
    318319nobase_cfa_include_HEADERS = ${headers} ${stdhdr} concurrency/invoke.h
    319320CLEANFILES = libcfa-prelude.c
     
    11601161
    11611162maintainer-clean-local:
    1162         -rm -rf ${includedir}/*
     1163        -rm -rf ${CFA_INCDIR} ${CFA_LIBDIR}
    11631164
    11641165# Tell versions [3.59,3.63) of GNU make to not export all variables.
  • src/libcfa/iostream

    r87c3bef rbe8bd88  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Feb 24 21:09:09 2017
    13 // Update Count     : 94
     12// Last Modified On : Mon Mar  6 20:51:35 2017
     13// Update Count     : 98
    1414//
    1515
     
    6868forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const void * );
    6969
     70// tuples
     71forall( dtype ostype, otype T, ttype Params | ostream( ostype ) | writeable( T ) | { ostype * ?|?( ostype *, Params ); } ) ostype * ?|?( ostype * os, T arg, Params rest );
     72
     73// manipulators
    7074forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, ostype * (*)( ostype * ) );
    71 // manipulators
    7275forall( dtype ostype | ostream( ostype ) ) ostype * endl( ostype * );
    7376forall( dtype ostype | ostream( ostype ) ) ostype * sepOn( ostype * );
  • src/libcfa/iostream.c

    r87c3bef rbe8bd88  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Feb 24 21:09:59 2017
    13 // Update Count     : 307
     12// Last Modified On : Mon Mar  6 20:52:02 2017
     13// Update Count     : 313
    1414//
    1515
     
    155155        enum { Open = 1, Close, OpenClose };
    156156        static const unsigned char mask[256] = {
    157                 // opening delimiters
     157                // opening delimiters, no space after
    158158                ['('] : Open, ['['] : Open, ['{'] : Open,
    159                 ['$'] : Open, [(unsigned char)'£'] : Open, [(unsigned char)'¥'] : Open,
     159                ['$'] : Open, ['='] : Open, [(unsigned char)'£'] : Open, [(unsigned char)'¥'] : Open,
    160160                [(unsigned char)'¡'] : Open, [(unsigned char)'¿'] : Open, [(unsigned char)'«'] : Open,
    161                 // closing delimiters
     161                // closing delimiters, no space before
    162162                [','] : Close, ['.'] : Close, [':'] : Close, [';'] : Close, ['!'] : Close, ['?'] : Close,
    163163                [')'] : Close, [']'] : Close, ['}'] : Close,
    164164                ['%'] : Close, [(unsigned char)'¢'] : Close, [(unsigned char)'»'] : Close,
    165                 // opening-closing delimiters
     165                // opening-closing delimiters, no space before or after
    166166                ['\''] : OpenClose, ['`'] : OpenClose, ['"'] : OpenClose,
    167167                [' '] : OpenClose, ['\f'] : OpenClose, ['\n'] : OpenClose, ['\r'] : OpenClose, ['\t'] : OpenClose, ['\v'] : OpenClose, // isspace
     
    198198
    199199
     200// tuples
     201forall( dtype ostype, otype T, ttype Params | ostream( ostype ) | writeable( T ) | { ostype * ?|?( ostype *, Params ); } )
     202ostype * ?|?( ostype * os, T arg, Params rest ) {
     203        os | arg | ", ";
     204        os | rest;
     205} // ?|?
     206
     207
     208// manipulators
    200209forall( dtype ostype | ostream( ostype ) )
    201210ostype * ?|?( ostype * os, ostype * (* manip)( ostype * ) ) {
  • src/libcfa/stdlib

    r87c3bef rbe8bd88  
    1010// Created On       : Thu Jan 28 17:12:35 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Feb 24 21:07:16 2017
    13 // Update Count     : 101
     12// Last Modified On : Sat Mar  4 22:03:54 2017
     13// Update Count     : 102
    1414//
    1515
  • src/libcfa/stdlib.c

    r87c3bef rbe8bd88  
    1010// Created On       : Thu Jan 28 17:10:29 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Feb 24 21:08:11 2017
    13 // Update Count     : 171
     12// Last Modified On : Sat Mar  4 22:02:22 2017
     13// Update Count     : 172
    1414//
    1515
  • src/prelude/Makefile.am

    r87c3bef rbe8bd88  
    1919
    2020# put into lib for now
    21 cfalibdir = ${libdir}
     21cfalibdir = ${CFA_LIBDIR}
    2222cfalib_DATA = builtins.cf extras.cf prelude.cf bootloader.c
    2323noinst_DATA = ../libcfa/libcfa-prelude.c
  • src/prelude/Makefile.in

    r87c3bef rbe8bd88  
    105105CFA_INCDIR = @CFA_INCDIR@
    106106CFA_LIBDIR = @CFA_LIBDIR@
     107CFA_NAME = @CFA_NAME@
    107108CFA_PREFIX = @CFA_PREFIX@
    108109CFLAGS = @CFLAGS@
     
    209210
    210211# put into lib for now
    211 cfalibdir = ${libdir}
     212cfalibdir = ${CFA_LIBDIR}
    212213cfalib_DATA = builtins.cf extras.cf prelude.cf bootloader.c
    213214noinst_DATA = ../libcfa/libcfa-prelude.c
  • src/tests/.expect/tupleAssign.txt

    r87c3bef rbe8bd88  
     1u=5 v=6 x=10 y=11 z=[100, 200]
    12u=5 v=6 x=10 y=11 z=[100, 200]
    23u=11 v=10 x=11 y=10 z=[11, 10]
     4u=11 v=10 x=11 y=10 z=[11, 10]
     5u=10 v=11 z=[10, 11]
    36u=10 v=11 z=[10, 11]
    47u=123 v=456 z=[111, 222]
    5 d=-2153.12 i=-2153 c=-105 t=[-2153, -2153.12, -2153]
    6 d=-2153.12 i=-2153 c=-105 t=[-2153, -2153.12, -2153]
     8u=123 v=456 z=[111, 222]
     9d=94.12 i=94 c=^ t=[94, 94.12, 94]
     10d=94.12 i=94 c=^ t=[94, 94.12, 94]
     11d=-94.12 i=-94 c=¢ t=[-94, -94.12, -94]
     12d=-94.12 i=-94 c=¢ t=[-94, -94.12, -94]
  • src/tests/Makefile.am

    r87c3bef rbe8bd88  
    3030EXTRA_FLAGS =
    3131CFLAGS = -g -Wall -Wno-unused-function @CFA_FLAGS@ ${EXTRA_FLAGS}
    32 CC = @CFA_BINDIR@/cfa
     32CC = @CFA_BINDIR@/@CFA_NAME@
    3333
    3434.PHONY : list
  • src/tests/Makefile.in

    r87c3bef rbe8bd88  
    113113AWK = @AWK@
    114114BACKEND_CC = @BACKEND_CC@
    115 CC = @CFA_BINDIR@/cfa
     115CC = @CFA_BINDIR@/@CFA_NAME@
    116116CCAS = @CCAS@
    117117CCASDEPMODE = @CCASDEPMODE@
     
    123123CFA_INCDIR = @CFA_INCDIR@
    124124CFA_LIBDIR = @CFA_LIBDIR@
     125CFA_NAME = @CFA_NAME@
    125126CFA_PREFIX = @CFA_PREFIX@
    126127CFLAGS = -g -Wall -Wno-unused-function @CFA_FLAGS@ ${EXTRA_FLAGS}
  • src/tests/tupleAssign.c

    r87c3bef rbe8bd88  
    99// Author           : Rob Schluntz
    1010// Created On       : Tue Nov 15 17:24:32 2016
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Tue Nov 15 17:27:28 2016
    13 // Update Count     : 3
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon Mar  6 21:23:58 2017
     13// Update Count     : 34
    1414//
     15
     16#include <fstream>
    1517
    1618int main() {
     
    2123
    2224                // swap x, y and store the new [x, y] in [u, v] and in z;
    23                 printf("u=%d v=%d x=%d y=%d z=[%d, %d]\n", u, v, x, y, z);
     25                printf( "u=%d v=%d x=%d y=%d z=[%d, %d]\n", u, v, x, y, z );
     26                sout | "u=" | u | "v=" | v | "x=" | x | "y=" | y | "z=[" | z | "]" | endl;
    2427                z = [u, v] = [x, y] = [y, x];
    25                 printf("u=%d v=%d x=%d y=%d z=[%d, %d]\n", u, v, x, y, z);
     28                printf( "u=%d v=%d x=%d y=%d z=[%d, %d]\n", u, v, x, y, z );
     29                sout | "u=" | u | "v=" | v | "x=" | x | "y=" | y | "z=[" | z | "]" | endl;
    2630
    2731                // shuffle elements -- v = z.0, z.0 = z.1, z.1 = u, u = v
    2832                [v, z, u] = [z, u, v];
    29                 printf("u=%d v=%d z=[%d, %d]\n", u, v, z);
     33                printf( "u=%d v=%d z=[%d, %d]\n", u, v, z );
     34                sout | "u=" | u | "v=" | v | "z=[" | z | "]" | endl;
    3035
    3136                // multiple assignment with tuple expression on right
    3237                z = [111, 222];
    3338                [u, v] = [123, 456];
    34                 printf("u=%d v=%d z=[%d, %d]\n", u, v, z);
     39                printf( "u=%d v=%d z=[%d, %d]\n", u, v, z );
     40                sout | "u=" | u | "v=" | v | "z=[" | z | "]" | endl;
    3541        }
    36 
    3742        {
    3843                // test mass assignment
     
    4853                // no conversion from X to integral types, so this serves as a santiy
    4954                // check that as long as this compiles, ?=?(_, x) is not generated.
    50                 [t, x, d, i, c, x] = (double)-2153.12;
    51                 printf("d=%lg i=%d c=%d t=[%d, %lg, %d]\n", d, i, (int)c, t);
    52                 [x, c, i, d, x, t] = (double)-2153.12;
    53                 printf("d=%lg i=%d c=%d t=[%d, %lg, %d]\n", d, i, (int)c, t);
     55                [t, x, d, i, c, x] = (double)94.12;
     56                printf( "d=%lg i=%d c=%c t=[%d, %lg, %d]\n", d, i, (int)c, t );
     57                sout | "d=" | d | "i=" | i | "c=" | c | ' ' | "t=[" | t | "]" | endl;
     58                [x, c, i, d, x, t] = (double)-94.12;
     59                printf( "d=%lg i=%d c=%c t=[%d, %lg, %d]\n", d, i, c, t );
     60                sout | "d=" | d | "i=" | i | "c=" | c | ' ' | "t=[" | t | "]" | endl;
    5461        }
    5562}
Note: See TracChangeset for help on using the changeset viewer.