Changeset 638ac26 for src


Ignore:
Timestamp:
Jul 6, 2018, 2:18:34 PM (6 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, no_list, persistent-indexer, pthread-emulation, qualifiedEnum
Children:
46e480a5
Parents:
e3b2474 (diff), 1d386a7 (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:/u/cforall/software/cfa/cfa-cc

Location:
src
Files:
1 added
5 edited
1 moved

Legend:

Unmodified
Added
Removed

  • src/Parser/DeclarationNode.cc

    re3b2474 r638ac26  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jun  7 12:08:55 2018
    13 // Update Count     : 1079
     12// Last Modified On : Fri Jul  6 06:56:08 2018
     13// Update Count     : 1088
    1414//
    1515
    … …  
    522522
    523523static void addQualifiersToType( TypeData *&src, TypeData * dst ) {
    524         if ( src->forall && dst->kind == TypeData::Function ) {
    525                 if ( dst->forall ) {
    526                         dst->forall->appendList( src->forall );
    527                 } else {
    528                         dst->forall = src->forall;
    529                 } // if
    530                 src->forall = nullptr;
    531         } // if
    532524        if ( dst->base ) {
    533525                addQualifiersToType( src, dst->base );
    … …  
    10831075                        SemanticError( this, "invalid function specifier for " );
    10841076                } // if
     1077                // Forall qualifier can only appear on a function/aggregate definition/declaration.
     1078                //
     1079                //    forall int f();                                   // allowed
     1080                //    forall int g( int i );                    // allowed
     1081                //    forall int i;                                             // disallowed
     1082                if ( type->kind != TypeData::Function && type->forall ) {
     1083                        SemanticError( this, "invalid type qualifier for " );
     1084                } // if
    10851085                bool isDelete = initializer && initializer->get_isDelete();
    10861086                Declaration * decl = buildDecl( type, name ? *name : string( "" ), storageClasses, maybeBuild< Expression >( bitfieldWidth ), funcSpecs, linkage, asmName, isDelete ? nullptr : maybeBuild< Initializer >(initializer), attributes )->set_extension( extension );

  • src/Parser/parser.yy

    re3b2474 r638ac26  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Jul  2 20:23:14 2018
    13 // Update Count     : 3607
     12// Last Modified On : Fri Jul  6 08:02:38 2018
     13// Update Count     : 3716
    1414//
    1515
    … …  
    116116
    117117void distQual( DeclarationNode * declaration, DeclarationNode * qualifiers ) {
    118         // distribute qualifiers across all declarations in a distribution statemement
     118        // distribute qualifiers across all non-variable declarations in a distribution statemement
    119119        for ( DeclarationNode * iter = declaration; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
    120                 if ( isMangled( iter->linkage ) ) {             // ignore extern "C"
    121                         iter->addQualifiers( qualifiers->clone() );
     120                // SKULLDUGGERY: Distributions are parsed inside out, so qualifiers are added to declarations inside out. Since
     121                // addQualifiers appends to the back of the list, the forall clauses are in the wrong order (right to left). To
     122                // get the qualifiers in the correct order and still use addQualifiers (otherwise, 90% of addQualifiers has to
     123                // be copied to add to front), the appropriate forall pointers are interchanged before calling addQualifiers.
     124                DeclarationNode * clone = qualifiers->clone();
     125                if ( qualifiers->type ) {                                               // forall clause ? (handles SC)
     126                        if ( iter->type->kind == TypeData::Aggregate ) { // struct/union ?
     127                                swap( clone->type->forall, iter->type->aggregate.params );
     128                                iter->addQualifiers( clone );
     129                        } else if ( iter->type->kind == TypeData::AggregateInst && iter->type->aggInst.aggregate->aggregate.body ) { // struct/union ?
     130                                // Create temporary node to hold aggregate, call addQualifiers as above, then put nodes back together.
     131                                DeclarationNode newnode;
     132                                swap( newnode.type, iter->type->aggInst.aggregate );
     133                                swap( clone->type->forall, newnode.type->aggregate.params );
     134                                newnode.addQualifiers( clone );
     135                                swap( newnode.type, iter->type->aggInst.aggregate );
     136                        } else if ( iter->type->kind == TypeData::Function ) { // routines ?
     137                                swap( clone->type->forall, iter->type->forall );
     138                                iter->addQualifiers( clone );
     139                        } // if
     140                } else {                                                                                // just SC qualifiers
     141                        iter->addQualifiers( clone );
    122142                } // if
    123143        } // for
    124 } // distExt
     144        delete qualifiers;
     145} // distQual
    125146
    126147// There is an ambiguity for inline generic-routine return-types and generic routines.
    … …  
    366387%type<decl> type_parameter type_parameter_list type_initializer_opt
    367388
    368 %type<en> type_list
     389%type<en> type_parameters_opt type_list
    369390
    370391%type<decl> type_qualifier type_qualifier_name forall type_qualifier_list_opt type_qualifier_list
    … …  
    406427// Order of these lines matters (low-to-high precedence).
    407428%precedence TYPEGENname
     429%precedence '}'
    408430%precedence '('
    409431
    … …  
    17531775                { $$ = $3->addQualifiers( $1 ); }
    17541776        | sue_type_specifier type_qualifier
    1755                 { $$ = $1->addQualifiers( $2 ); }
     1777                {
     1778                        if ( $2->type != nullptr && $2->type->forall ) forall = true; // remember generic type
     1779                        $$ = $1->addQualifiers( $2 );
     1780                }
    17561781        ;
    17571782
    … …  
    18311856
    18321857aggregate_type:                                                                                 // struct, union
    1833         aggregate_key attribute_list_opt '{' field_declaration_list_opt '}'
    1834                 { $$ = DeclarationNode::newAggregate( $1, new string( DeclarationNode::anonymous.newName() ), nullptr, $4, true )->addQualifiers( $2 ); }
     1858        aggregate_key attribute_list_opt '{' field_declaration_list_opt '}' type_parameters_opt
     1859                { $$ = DeclarationNode::newAggregate( $1, new string( DeclarationNode::anonymous.newName() ), $6, $4, true )->addQualifiers( $2 ); }
    18351860        | aggregate_key attribute_list_opt no_attr_identifier fred
    18361861                {
    … …  
    18381863                        forall = false;                                                         // reset
    18391864                }
    1840           '{' field_declaration_list_opt '}'
    1841                 { $$ = DeclarationNode::newAggregate( $1, $3, nullptr, $7, true )->addQualifiers( $2 ); }
     1865          '{' field_declaration_list_opt '}' type_parameters_opt
     1866                { $$ = DeclarationNode::newAggregate( $1, $3, $9, $7, true )->addQualifiers( $2 ); }
    18421867        | aggregate_key attribute_list_opt type_name fred
    18431868                {
    … …  
    18451870                        forall = false;                                                         // reset
    18461871                }
    1847           '{' field_declaration_list_opt '}'
    1848                 { $$ = DeclarationNode::newAggregate( $1, $3->type->symbolic.name, nullptr, $7, true )->addQualifiers( $2 ); }
    1849         | aggregate_key attribute_list_opt '(' type_list ')' '{' field_declaration_list_opt '}' // CFA
    1850                 { $$ = DeclarationNode::newAggregate( $1, new string( DeclarationNode::anonymous.newName() ), $4, $7, false )->addQualifiers( $2 ); }
     1872          '{' field_declaration_list_opt '}' type_parameters_opt
     1873                { $$ = DeclarationNode::newAggregate( $1, $3->type->symbolic.name, $9, $7, true )->addQualifiers( $2 ); }
    18511874        | aggregate_type_nobody
     1875        ;
     1876
     1877type_parameters_opt:
     1878        // empty
     1879                { $$ = nullptr; }                                                               %prec '}'
     1880        | '(' type_list ')'
     1881                { $$ = $2; }
    18521882        ;
    18531883
    … …  
    23862416                        distQual( $5, $1 );
    23872417                        xxx = false;
    2388                         delete $1;
    23892418                        $$ = $5;
    23902419                }
    … …  
    23982427                        distQual( $5, $1 );
    23992428                        xxx = false;
    2400                         delete $1;
    24012429                        $$ = $5;
    24022430                }
    … …  
    24082436          '{' up external_definition_list_opt down '}'          // CFA, namespace
    24092437                {
    2410                         distQual( $6, $2 );
    2411                         distQual( $6, $1 );
     2438                        distQual( $6, $1->addQualifiers( $2 ) );
    24122439                        xxx = false;
    2413                         delete $1;
    2414                         delete $2;
    24152440                        $$ = $6;
    24162441                }

  • src/libcfa/stdlib

    re3b2474 r638ac26  
    1010// Created On       : Thu Jan 28 17:12:35 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jul  3 08:17:28 2018
    13 // Update Count     : 324
     12// Last Modified On : Thu Jul  5 07:41:03 2018
     13// Update Count     : 332
    1414//
    1515
    … …  
    1818#include <stdlib.h>                                                                             // allocation, strto*, *abs
    1919extern "C" {
    20         void * memalign( size_t align, size_t size );
    21         void * aligned_alloc( size_t align, size_t size );
    22         void * memset( void * dest, int c, size_t size );
     20        void * memalign( size_t align, size_t size );           // malloc.h
     21        void * memset( void * dest, int c, size_t size );       // string.h
     22        void * memcpy( void * dest, const void * src, size_t size ); // string.h
    2323} // extern "C"
    2424
    … …  
    140140        } // memset
    141141
    142         extern "C" { void * memcpy( void * dest, const void * src, size_t size ); } // use default C routine for void *
    143 
    144142        T * memcpy( T * dest, const T * src ) {
    145143                //printf( "X18\n" );
    … …  
    174172//---------------------------------------
    175173
    176 static inline int strto( const char * sptr, char ** eptr, int base ) { return (int)strtol( sptr, eptr, base ); }
    177 static inline unsigned int strto( const char * sptr, char ** eptr, int base ) { return (unsigned int)strtoul( sptr, eptr, base ); }
    178 static inline long int strto( const char * sptr, char ** eptr, int base ) { return strtol( sptr, eptr, base ); }
    179 static inline unsigned long int strto( const char * sptr, char ** eptr, int base ) { return strtoul( sptr, eptr, base ); }
    180 static inline long long int strto( const char * sptr, char ** eptr, int base ) { return strtoll( sptr, eptr, base ); }
    181 static inline unsigned long long int strto( const char * sptr, char ** eptr, int base ) { return strtoull( sptr, eptr, base ); }
    182 
    183 static inline float strto( const char * sptr, char ** eptr ) { return strtof( sptr, eptr ); }
    184 static inline double strto( const char * sptr, char ** eptr ) { return strtod( sptr, eptr ); }
    185 static inline long double strto( const char * sptr, char ** eptr ) { return strtold( sptr, eptr ); }
     174static inline {
     175        int strto( const char * sptr, char ** eptr, int base ) { return (int)strtol( sptr, eptr, base ); }
     176        unsigned int strto( const char * sptr, char ** eptr, int base ) { return (unsigned int)strtoul( sptr, eptr, base ); }
     177        long int strto( const char * sptr, char ** eptr, int base ) { return strtol( sptr, eptr, base ); }
     178        unsigned long int strto( const char * sptr, char ** eptr, int base ) { return strtoul( sptr, eptr, base ); }
     179        long long int strto( const char * sptr, char ** eptr, int base ) { return strtoll( sptr, eptr, base ); }
     180        unsigned long long int strto( const char * sptr, char ** eptr, int base ) { return strtoull( sptr, eptr, base ); }
     181
     182        float strto( const char * sptr, char ** eptr ) { return strtof( sptr, eptr ); }
     183        double strto( const char * sptr, char ** eptr ) { return strtod( sptr, eptr ); }
     184        long double strto( const char * sptr, char ** eptr ) { return strtold( sptr, eptr ); }
     185} // distribution
    186186
    187187float _Complex strto( const char * sptr, char ** eptr );
    … …  
    189189long double _Complex strto( const char * sptr, char ** eptr );
    190190
    191 static inline int ato( const char * sptr ) {return (int)strtol( sptr, 0, 10 ); }
    192 static inline unsigned int ato( const char * sptr ) { return (unsigned int)strtoul( sptr, 0, 10 ); }
    193 static inline long int ato( const char * sptr ) { return strtol( sptr, 0, 10 ); }
    194 static inline unsigned long int ato( const char * sptr ) { return strtoul( sptr, 0, 10 ); }
    195 static inline long long int ato( const char * sptr ) { return strtoll( sptr, 0, 10 ); }
    196 static inline unsigned long long int ato( const char * sptr ) { return strtoull( sptr, 0, 10 ); }
    197 
    198 static inline float ato( const char * sptr ) { return strtof( sptr, 0 ); }
    199 static inline double ato( const char * sptr ) { return strtod( sptr, 0 ); }
    200 static inline long double ato( const char * sptr ) { return strtold( sptr, 0 ); }
    201 
    202 static inline float _Complex ato( const char * sptr ) { return strto( sptr, NULL ); }
    203 static inline double _Complex ato( const char * sptr ) { return strto( sptr, NULL ); }
    204 static inline long double _Complex ato( const char * sptr ) { return strto( sptr, NULL ); }
     191static inline {
     192        int ato( const char * sptr ) {return (int)strtol( sptr, 0, 10 ); }
     193        unsigned int ato( const char * sptr ) { return (unsigned int)strtoul( sptr, 0, 10 ); }
     194        long int ato( const char * sptr ) { return strtol( sptr, 0, 10 ); }
     195        unsigned long int ato( const char * sptr ) { return strtoul( sptr, 0, 10 ); }
     196        long long int ato( const char * sptr ) { return strtoll( sptr, 0, 10 ); }
     197        unsigned long long int ato( const char * sptr ) { return strtoull( sptr, 0, 10 ); }
     198
     199        float ato( const char * sptr ) { return strtof( sptr, 0 ); }
     200        double ato( const char * sptr ) { return strtod( sptr, 0 ); }
     201        long double ato( const char * sptr ) { return strtold( sptr, 0 ); }
     202
     203        float _Complex ato( const char * sptr ) { return strto( sptr, NULL ); }
     204        double _Complex ato( const char * sptr ) { return strto( sptr, NULL ); }
     205        long double _Complex ato( const char * sptr ) { return strto( sptr, NULL ); }
     206} // distribution
    205207
    206208//---------------------------------------
    … …  
    236238//---------------------------------------
    237239
    238 static inline unsigned char abs( signed char v ) { return abs( (int)v ); }
    239240extern "C" { int abs( int ); }                                                  // use default C routine for int
    240 static inline unsigned long int abs( long int v ) { return labs( v ); }
    241 static inline unsigned long long int abs( long long int v ) { return llabs( v ); }
    242 
    243 extern "C" {
    244 double fabs( double );
    245 float fabsf( float );
    246 long double fabsl( long double );
     241static inline {
     242        unsigned char abs( signed char v ) { return abs( (int)v ); }
     243        unsigned long int abs( long int v ) { return labs( v ); }
     244        unsigned long long int abs( long long int v ) { return llabs( v ); }
     245} // distribution
     246
     247extern "C" {                                                                                    // use default C routine for int
     248        double fabs( double );
     249        float fabsf( float );
     250        long double fabsl( long double );
    247251} // extern "C"
    248 static inline float abs( float x ) { return fabsf( x ); }
    249 static inline double abs( double x ) { return fabs( x ); }
    250 static inline long double abs( long double x ) { return fabsl( x ); }
    251 
    252 extern "C" {
    253 double cabs( double _Complex );
    254 float cabsf( float _Complex );
    255 long double cabsl( long double _Complex );
     252static inline {
     253        float abs( float x ) { return fabsf( x ); }
     254        double abs( double x ) { return fabs( x ); }
     255        long double abs( long double x ) { return fabsl( x ); }
     256} // distribution
     257
     258extern "C" {                                                                                    // use default C routine for int
     259        double cabs( double _Complex );
     260        float cabsf( float _Complex );
     261        long double cabsl( long double _Complex );
    256262} // extern "C"
    257 static inline float abs( float _Complex x ) { return cabsf( x ); }
    258 static inline double abs( double _Complex x ) { return cabs( x ); }
    259 static inline long double abs( long double _Complex x ) { return cabsl( x ); }
     263static inline {
     264        float abs( float _Complex x ) { return cabsf( x ); }
     265        double abs( double _Complex x ) { return cabs( x ); }
     266        long double abs( long double _Complex x ) { return cabsl( x ); }
     267} // distribution
    260268
    261269forall( otype T | { void ?{}( T &, zero_t ); int ?<?( T, T ); T -?( T ); } )
    … …  
    295303//---------------------------------------
    296304
    297 forall( otype T | { int ?<?( T, T ); } )
    298 static inline T min( T t1, T t2 ) { return t1 < t2 ? t1 : t2; }
    299 
    300 forall( otype T | { int ?>?( T, T ); } )
    301 static inline T max( T t1, T t2 ) { return t1 > t2 ? t1 : t2; }
    302 
    303 forall( otype T | { T min( T, T ); T max( T, T ); } )
    304 static inline T clamp( T value, T min_val, T max_val ) { return max( min_val, min( value, max_val ) ); }
    305 
    306 forall( otype T )
    307 static inline void swap( T & v1, T & v2 ) { T temp = v1; v1 = v2; v2 = temp; }
     305static inline {
     306        forall( otype T | { int ?<?( T, T ); } )
     307        T min( T t1, T t2 ) { return t1 < t2 ? t1 : t2; }
     308
     309        forall( otype T | { int ?>?( T, T ); } )
     310        T max( T t1, T t2 ) { return t1 > t2 ? t1 : t2; }
     311
     312        forall( otype T | { T min( T, T ); T max( T, T ); } )
     313        T clamp( T value, T min_val, T max_val ) { return max( min_val, min( value, max_val ) ); }
     314
     315        forall( otype T )
     316        void swap( T & v1, T & v2 ) { T temp = v1; v1 = v2; v2 = temp; }
     317} // distribution
    308318
    309319// Local Variables: //

  • src/prelude/Makefile.am

    re3b2474 r638ac26  
    4242        ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -E prototypes.c | awk -f prototypes.awk > $@
    4343
     44prelude.cf : prelude-gen.cc
     45        ${AM_V_GEN}${CXX} ${AM_CXXFLAGS} ${CXXFLAGS} ${<} -o prelude-gen
     46        @./prelude-gen > $@
     47        @rm ./prelude-gen
     48
    4449builtins.def :
    4550

  • src/prelude/Makefile.in

    re3b2474 r638ac26  
    511511        ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -E prototypes.c | awk -f prototypes.awk > $@
    512512
     513prelude.cf : prelude-gen.cc
     514        ${AM_V_GEN}${CXX} ${AM_CXXFLAGS} ${CXXFLAGS} ${<} -o prelude-gen
     515        @./prelude-gen > $@
     516        @rm ./prelude-gen
     517
    513518builtins.def :
    514519
Note: See TracChangeset for help on using the changeset viewer.