Changes in / [278e162:4d2d7e27]


Ignore:
Files:
21 edited

Legend:

Unmodified
Added
Removed

  • libcfa/src/collections/string.cfa

    r278e162 r4d2d7e27  
    1010// Created On       : Fri Sep 03 11:00:00 2021
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Oct 18 21:52:09 2023
    13 // Update Count     : 208
     12// Last Modified On : Sat Sep  2 12:05:57 2023
     13// Update Count     : 206
    1414//
    1515
    … …  
    138138
    139139void ?|?( ifstream & in, _Istream_Sstr f ) {
    140     (ifstream &)(in | f);
     140    (ifstream &)(in | f); ends( in );
    141141}
    142142

  • libcfa/src/collections/string_res.cfa

    r278e162 r4d2d7e27  
    1010// Created On       : Fri Sep 03 11:00:00 2021
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Oct 18 21:54:54 2023
    13 // Update Count     : 15
     12// Last Modified On : Mon Aug 14 18:06:01 2023
     13// Update Count     : 12
    1414//
    1515
    … …  
    236236        // get bytes
    237237        try {
    238                         *(temp.Handle.ulink->EndVbyte) = '\0';   // pre-assign empty cstring
    239238            in | wdi( lenReadable, temp.Handle.ulink->EndVbyte );
    240239        } catch (cstring_length*) {
    … …  
    248247    }
    249248
    250         if ( temp.Handle.lnth > 0 ) s = temp;
     249    s = temp;
    251250    return in;
    252251}
    253252
    254253void ?|?( ifstream & in, string_res & this ) {
    255     (ifstream &)(in | this);
     254    (ifstream &)(in | this); ends( in );
    256255}
    257256
    … …  
    269268        cstr[wd] = '\0';                                                                        // guard null terminate string
    270269        try {
    271                 cstr[0] = '\0';                                                                 // pre-assign as empty cstring
    272270                is | cf;
    273271        } catch( cstring_length * ) {
    274272                cont = true;
    275273        } finally {
    276                 if ( ! cf.flags.ignore &&                                               // ok to initialize string
    277                                 cstr[0] != '\0' ) {                                             // something was read
    278                         *(f.s) = cstr;
    279                 }
     274        if ( ! cf.flags.ignore ) *(f.s) = cstr;                 // ok to initialize string
    280275        } // try
    281276        for ( ; cont; )  {                                                                      // overflow read ?
    282277                cont = false;
    283278                try {
    284                         cstr[0] = '\0';                                                         // pre-assign as empty cstring
    285279                        is | cf;
    286280                } catch( cstring_length * ) {
    287281                        cont = true;                                                            // continue not allowed
    288282                } finally {
    289                         if ( ! cf.flags.ignore &&
    290                                         cstr[0] != '\0' ) {                                     // something was read
    291                                 *(f.s) += cstr;                                                 // build string chunk at a time
    292                         }
     283                        if ( ! cf.flags.ignore ) *(f.s) += cstr;        // build string chunk at a time
    293284                } // try
    294285        } // for
    … …  
    297288
    298289void ?|?( ifstream & in, _Istream_Rstr f ) {
    299     (ifstream &)(in | f);
     290    (ifstream &)(in | f); ends( in );
    300291}
    301292

  • libcfa/src/concurrency/channel.hfa

    r278e162 r4d2d7e27  
    2828    unlock( lock );
    2929    park();
    30     __atomic_thread_fence( __ATOMIC_SEQ_CST );
    3130    return sn.extra == 0p;
    3231}

  • libcfa/src/fstream.cfa

    r278e162 r4d2d7e27  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Oct 18 22:05:54 2023
    13 // Update Count     : 549
     12// Last Modified On : Fri Aug 18 10:41:17 2023
     13// Update Count     : 541
    1414//
    1515
    … …  
    230230void nlOff( ifstream & os ) { os.nlOnOff$ = false; }
    231231
     232void ends( ifstream & is ) {}
     233
    232234bool eof( ifstream & is ) { return feof( (FILE *)(is.file$) ) != 0; }
    233235
    … …  
    309311        } // if
    310312        va_end( args );
    311 //      if ( len == 0 ) throw ExceptionInst( missing_data );
    312313        return len;
    313314} // fmt

  • libcfa/src/fstream.hfa

    r278e162 r4d2d7e27  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Oct 18 20:30:12 2023
    13 // Update Count     : 261
     12// Last Modified On : Fri Aug 18 10:41:15 2023
     13// Update Count     : 258
    1414//
    1515
    … …  
    117117void nlOn( ifstream & );
    118118void nlOff( ifstream & );
     119void ends( ifstream & );
    119120int fmt( ifstream &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
    120 ifstream & ungetc( ifstream & is, char c );
    121 bool eof( ifstream & is );
    122121
    123122bool fail( ifstream & is );
    124123void clear( ifstream & );
     124bool eof( ifstream & is );
    125125void open( ifstream & is, const char name[], const char mode[] ); // FIX ME: use default = "r"
    126126void open( ifstream & is, const char name[] );
    127127void close( ifstream & is );
     128
    128129ifstream & read( ifstream & is, char data[], size_t size );
     130ifstream & ungetc( ifstream & is, char c );
    129131
    130132void ?{}( ifstream & is );

  • libcfa/src/iostream.cfa

    r278e162 r4d2d7e27  
     1
    12//
    23// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
    … …  
    1011// Created On       : Wed May 27 17:56:53 2015
    1112// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Oct 19 21:10:10 2023
    13 // Update Count     : 1801
     13// Last Modified On : Sun Oct  8 12:10:21 2023
     14// Update Count     : 1564
    1415//
    1516
    … …  
    784785                return is;
    785786        } // ?|?
     787        ISTYPE_VOID_IMPL( bool & )
    786788
    787789        istype & ?|?( istype & is, char & c ) {
    … …  
    795797                return is;
    796798        } // ?|?
     799        ISTYPE_VOID_IMPL( char & )
    797800
    798801        istype & ?|?( istype & is, signed char & sc ) {
    … …  
    800803                return is;
    801804        } // ?|?
     805        ISTYPE_VOID_IMPL( signed char & )
    802806
    803807        istype & ?|?( istype & is, unsigned char & usc ) {
    … …  
    805809                return is;
    806810        } // ?|?
     811        ISTYPE_VOID_IMPL( unsigned char & )
    807812
    808813        istype & ?|?( istype & is, short int & si ) {
    … …  
    810815                return is;
    811816        } // ?|?
     817        ISTYPE_VOID_IMPL( short int & )
    812818
    813819        istype & ?|?( istype & is, unsigned short int & usi ) {
    … …  
    815821                return is;
    816822        } // ?|?
     823        ISTYPE_VOID_IMPL( unsigned short int & )
    817824
    818825        istype & ?|?( istype & is, int & i ) {
    … …  
    820827                return is;
    821828        } // ?|?
     829        ISTYPE_VOID_IMPL( int & )
    822830
    823831        istype & ?|?( istype & is, unsigned int & ui ) {
    … …  
    825833                return is;
    826834        } // ?|?
     835        ISTYPE_VOID_IMPL( unsigned int & )
    827836
    828837        istype & ?|?( istype & is, long int & li ) {
    … …  
    830839                return is;
    831840        } // ?|?
     841        ISTYPE_VOID_IMPL( long int & )
    832842
    833843        istype & ?|?( istype & is, unsigned long int & ulli ) {
    … …  
    835845                return is;
    836846        } // ?|?
     847        ISTYPE_VOID_IMPL( unsigned long int & )
    837848
    838849        istype & ?|?( istype & is, long long int & lli ) {
    … …  
    840851                return is;
    841852        } // ?|?
     853        ISTYPE_VOID_IMPL( long long int & )
    842854
    843855        istype & ?|?( istype & is, unsigned long long int & ulli ) {
    … …  
    845857                return is;
    846858        } // ?|?
     859        ISTYPE_VOID_IMPL( unsigned long long int & )
    847860
    848861        #if defined( __SIZEOF_INT128__ )
    … …  
    850863                return (istype &)(is | (unsigned int128 &)llli);
    851864        } // ?|?
     865        ISTYPE_VOID_IMPL( int128 & )
    852866
    853867        istype & ?|?( istype & is, unsigned int128 & ullli ) {
    … …  
    866880                return is;
    867881        } // ?|?
     882        ISTYPE_VOID_IMPL( unsigned int128 & )
    868883        #endif // __SIZEOF_INT128__
    869884
    … …  
    872887                return is;
    873888        } // ?|?
     889        ISTYPE_VOID_IMPL( float & )
    874890
    875891        istype & ?|?( istype & is, double & d ) {
    … …  
    877893                return is;
    878894        } // ?|?
     895        ISTYPE_VOID_IMPL( double & )
    879896
    880897        istype & ?|?( istype & is, long double & ld ) {
    … …  
    882899                return is;
    883900        } // ?|?
     901        ISTYPE_VOID_IMPL( long double & )
    884902
    885903        istype & ?|?( istype & is, float _Complex & fc ) {
    … …  
    889907                return is;
    890908        } // ?|?
     909        ISTYPE_VOID_IMPL( float _Complex & )
    891910
    892911        istype & ?|?( istype & is, double _Complex & dc ) {
    … …  
    896915                return is;
    897916        } // ?|?
     917        ISTYPE_VOID_IMPL( double _Complex & )
    898918
    899919        istype & ?|?( istype & is, long double _Complex & ldc ) {
    … …  
    903923                return is;
    904924        } // ?|?
     925        ISTYPE_VOID_IMPL( long double _Complex & )
    905926
    906927        istype & ?|?( istype & is, const char fmt[] ) {
    … …  
    908929                return is;
    909930        } // ?|?
     931        ISTYPE_VOID_IMPL( const char * )
    910932
    911933        // manipulators
    … …  
    915937
    916938        void ?|?( istype & is, istype & (* manip)( istype & ) ) {
    917                 manip( is );
     939                manip( is ); ends( is );
    918940        } // ?|?
    919941
    … …  
    944966                        char fmtstr[ sizeof("%*[]") + nscanset ];
    945967                        int pos = 0;
    946                         strcpy( &fmtstr[pos], "%*[" );  pos += 3;
     968                        fmtstr[pos] = '%';                  pos += 1;
     969                        fmtstr[pos] = '*';                  pos += 1;
     970                        fmtstr[pos] = '[';                  pos += 1;
    947971                        strcpy( &fmtstr[pos], f.scanset );  pos += nscanset;
    948                         strcpy( &fmtstr[pos], "]" );
    949                         fmt( is, fmtstr, "" );                                          // skip scanset
    950                 } else {
    951                         char ch;
    952 //                      fprintf( stderr, "skip " );
    953                         for ( f.wd ) {                                                          // skip N characters
    954                           if ( eof( is ) ) break;
    955                                 fmt( is, "%c", &ch );
    956 //                              fprintf( stderr, "`%c' ", ch );
    957                         } // for
    958                 } // if
     972                        fmtstr[pos] = ']';                  pos += 1;
     973                        fmtstr[pos] = '\0';
     974                        fmt( is, fmtstr, (void*)0 );  // last arg is dummy: suppress gcc warning
     975                }
     976                else for ( f.wd ) fmt( is, "%*c" );
    959977                return is;
    960978        }
     979        ISTYPE_VOID_IMPL( _Istream_Cskip )
    961980
    962981        istype & ?|?( istype & is, _Istream_Cstr f ) {
    963                 const char * scanset;
    964                 size_t nscanset = 0;
     982                const char * scanset = f.scanset;
    965983                if ( f.flags.delimiter ) scanset = f.delimiter; // getline ?
    966                 else scanset = f.scanset;
    967                 if ( scanset ) nscanset = strlen( scanset );
    968 
    969                 char fmtstr[nscanset + 32];                                             // storage for scanset and format codes
     984
     985                size_t len = 0;
     986                if ( scanset ) len = strlen( scanset );
     987                char fmtstr[len + 16];
     988                int start = 1;
    970989                fmtstr[0] = '%';
    971 
    972                 int pos = 1;
    973                 int args;
    974                 bool check = true;
    975 
    976                 if ( f.flags.ignore ) { check = false; fmtstr[1] = '*'; pos += 1; }
    977                 int rwd = f.wd;
    978                 if ( f.wd != -1 ) {                                                             // => just ignore versus ignore with width
     990                if ( f.flags.ignore ) { fmtstr[1] = '*'; start += 1; }
     991                // no maximum width necessary because text ignored => width is read width
     992                if ( f.wd != -1 ) {
    979993                        // wd is buffer bytes available (for input chars + null terminator)
    980994                        // rwd is count of input chars
    981                         // no maximum width necessary because text ignored => width is read width
    982                         if ( f.flags.rwd ) check = false;
    983                         else rwd = f.wd - 1;
    984                         pos += sprintf( &fmtstr[pos], "%d", rwd );
     995                        int rwd;
     996                        if (f.flags.rwd) {
     997                                verify (f.wd >= 0);
     998                                rwd = f.wd;
     999                        } else {
     1000                                verify (f.wd >= 1);
     1001                                rwd = f.wd - 1;
     1002                        } // if
     1003                        start += sprintf( &fmtstr[start], "%d", rwd );
     1004                }
     1005
     1006                if ( ! scanset ) {
     1007                        // %s, %*s, %ws, %*ws
     1008                        fmtstr[start] = 's'; fmtstr[start + 1] = '\0';
     1009                        // printf( "cstr %s\n", fmtstr );
     1010                } else {
     1011                        // incl %[xxx],  %*[xxx],  %w[xxx],  %*w[xxx]
     1012                        // excl %[^xxx], %*[^xxx], %w[^xxx], %*w[^xxx]
     1013                        fmtstr[start] = '['; start += 1;
     1014                        if ( f.flags.inex ) { fmtstr[start] = '^'; start += 1; }
     1015                        strcpy( &fmtstr[start], scanset );                      // copy includes '\0'
     1016                        len += start;
     1017                        fmtstr[len] = ']'; fmtstr[len + 1] = '\0';
     1018                        // printf( "incl/excl %s\n", fmtstr );
    9851019                } // if
    9861020
    987                 if ( ! scanset ) {                                                              // %s, %*s, %ws, %*ws
    988 //                      fprintf( stderr, "cstr %s\n", f.s );
    989                         strcpy( &fmtstr[pos], "s%n" );
    990                         int len = 0;                                                            // may not be set in fmt
    991                         if ( f.flags.ignore ) args = fmt( is, fmtstr, &len ); // no string argument for '*'
    992                         else args = fmt( is, fmtstr, f.s, &len );
    993 //                      fprintf( stderr, "cstr %s %d %d %d %s\n", fmtstr, args, len, f.wd, f.s );
    994                         if ( check && len >= rwd && ! eof( is ) ) {     // might not fit
     1021                int check = f.wd - 2;
     1022                if (! f.flags.ignore ) {
     1023                        f.s[0] = '\0';
     1024                        if ( ! f.flags.rwd ) f.s[check] = '\0';         // insert sentinel
     1025                }
     1026                len = fmt( is, fmtstr, f.s );
     1027                //fprintf( stderr, "KK %s %zd %d %c %s\n", fmtstr, len, check, f.s[check], f.s );
     1028
     1029                if ( ! f.flags.ignore && ! f.flags.rwd && f.s[check] != '\0' ) { // sentinel overwritten ?
     1030                        // buffer filled, but would we have kept going?
     1031                        if ( ! eof( is ) ) {
    9951032                                char peek;
    996                                 fmt( is, "%c", &peek );                                 // check for whitespace terminator
    997 //                              fprintf( stderr, "peek %d '%c'\n", args, peek );
    998                                 if ( ! eof( is ) ) {
    999                                         ungetc( is, peek );
    1000                                         if ( ! isspace( peek ) ) throw ExceptionInst( cstring_length );
    1001                                 } // if
    1002                         } // if
    1003                 } else {
    1004                         if ( f.flags.delimiter ) {                                      // getline
    1005 //                              fprintf( stderr, "getline\n" );
    1006                                 sprintf( &fmtstr[pos], "[%s%s]%%n", f.flags.inex ? "^" : "", scanset );
    1007 //                              fprintf( stderr, "getline %s %d\n", fmtstr, f.wd );
    1008                                 int len = 0;                                                    // may not be set in fmt
    1009                                 if ( f.flags.ignore ) args = fmt( is, fmtstr, &len ); // no string argument for '*'
    1010                                 else args = fmt( is, fmtstr, f.s, &len );
    1011 //                              fprintf( stderr, "getline %s %d %d %d\n", fmtstr, args, f.wd, eof( is ) );
    1012                                 if ( check && len == rwd && ! eof( is ) ) {     // might not fit
    1013                                         char peek;
    1014                                         fmt( is, "%c", &peek );                         // check for delimiter
    1015 //                                      fprintf( stderr, "peek %d '%c'\n", args, peek );
    1016                                         if ( ! eof( is ) ) {
    1017                                                 if ( peek != f.delimiter[0] ) {
    1018                                                         ungetc( is, peek );
    1019                                                         throw ExceptionInst( cstring_length );
    1020                                                 } // if
    1021                                         } // if
    1022                                 } else fmt( is, "%*c" );                                //  remove delimiter
    1023                         } else {
    1024                                 // incl %[xxx],  %*[xxx],  %w[xxx],  %*w[xxx]
    1025                                 // excl %[^xxx], %*[^xxx], %w[^xxx], %*w[^xxx]
    1026                                 sprintf( &fmtstr[pos], "[%s%s]%%n", f.flags.inex ? "^" : "", scanset );
    1027 //                              fprintf( stderr, "incl/excl %s %d\n", fmtstr, f.wd );
    1028                                 int len = 0;                                                    // may not be set in fmt
    1029                                 if ( f.flags.ignore ) args = fmt( is, fmtstr, &len ); // no string argument for '*'
    1030                                 else args = fmt( is, fmtstr, f.s, &len );
    1031 //                              fprintf( stderr, "incl/excl %s \"%s\" %d %d %d %d %d %c\n", fmtstr, f.s, args, f.wd, len, eof( is ), check, f.s[f.wd] );
    1032                                 if ( check && len == rwd && ! eof( is ) ) {     // might not fit
    1033 //                                      fprintf( stderr, "overflow\n" );
    1034                                         char peek;
    1035                                         fmt( is, "%c", &peek );                         // check for whitespace terminator
    1036 //                                      fprintf( stderr, "peek %d '%c'\n", args, peek );
    1037                                         if ( ! eof( is ) ) {
    1038                                                 ungetc( is, peek );
    1039                                                 if ( f.flags.inex ^ strchr( f.scanset, peek ) != 0p ) throw ExceptionInst( cstring_length );
    1040                                         } // if
    1041                                 } // if
     1033                                fmt( is, "%c", &peek );
     1034                                ungetc( is, peek );
     1035                                bool hasMore;
     1036                                if (f.flags.delimiter) { // getline
     1037                                        hasMore = (peek != f.delimiter[0]);
     1038                                } else if (f.scanset) { // incl/excl
     1039                                        bool peekMatch = strchr(f.scanset, peek) != 0p;
     1040                                        hasMore = f.flags.inex ? (!peekMatch) : (peekMatch);
     1041                                } else { // %s
     1042                                        hasMore = !isspace(peek);
     1043                                }
     1044                                if (hasMore) throw (cstring_length){ &cstring_length_vt };
    10421045                        } // if
    10431046                } // if
    1044                 if ( args == 1 && eof( is ) ) {                                 // data but scan ended at EOF
    1045 //                      fprintf( stderr, "clear\n" );
    1046                         clear( is );                                                            // => reset EOF => detect again on next read
    1047                 } // if
    1048                 return is;
    1049         } // ?|?
     1047
     1048                if ( f.flags.delimiter ) {                                              // getline ?
     1049                        if ( len == 0 ) f.s[0] = '\0';                          // empty read => argument unchanged => set empty
     1050                        if ( ! eof( is ) ) {                                            // ignore delimiter, may not be present because of width
     1051                                char delimiter;
     1052                                fmt( is, "%c", &delimiter );
     1053                                if ( delimiter != f.delimiter[0] ) ungetc( is, delimiter );
     1054                        } // if
     1055                } //if
     1056                return is;
     1057        } // ?|?
     1058        ISTYPE_VOID_IMPL( _Istream_Cstr )
    10501059
    10511060        istype & ?|?( istype & is, _Istream_Char f ) {
    … …  
    10531062                return is;
    10541063        } // ?|?
     1064        ISTYPE_VOID_IMPL( _Istream_Char )
    10551065} // distribution
    10561066
    … …  
    10691079                return is; \
    10701080        } /* ?|? */ \
     1081        ISTYPE_VOID_IMPL( _Istream_Manip(T) ) \
    10711082} // distribution
    10721083
    … …  
    10961107                return is;
    10971108        } // ?|?
     1109        ISTYPE_VOID_IMPL( _Istream_Manip(float _Complex) )
    10981110
    10991111        istype & ?|?( istype & is, _Istream_Manip(double _Complex) dc ) {
    … …  
    11061118                return is;
    11071119        } // ?|?
     1120        ISTYPE_VOID_IMPL( _Istream_Manip(double _Complex) )
    11081121
    11091122        istype & ?|?( istype & is, _Istream_Manip(long double _Complex) ldc ) {
    … …  
    11161129                return is;
    11171130        } // ?|?
     1131        ISTYPE_VOID_IMPL( _Istream_Manip(long double _Complex) )
    11181132} // distribution
    11191133

  • libcfa/src/iostream.hfa

    r278e162 r4d2d7e27  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Oct 18 21:21:20 2023
    13 // Update Count     : 583
     12// Last Modified On : Sun Oct  8 12:02:55 2023
     13// Update Count     : 568
    1414//
    1515
    … …  
    306306// *********************************** istream ***********************************
    307307
     308#define ISTYPE_VOID( T ) void ?|?( istype &, T )
     309#define ISTYPE_VOID_IMPL( T ) \
     310        void ?|?( istype & is, T t ) { \
     311                (istype &)(is | t); ends( is ); \
     312        } // ?|?
     313
    308314forall( istype & )
    309315trait basic_istream {
    … …  
    314320        void nlOn( istype & );                                                          // read newline
    315321        void nlOff( istype & );                                                         // scan newline
     322        void ends( istype & os );                                                       // end of output statement
    316323        int fmt( istype &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
    317324        istype & ungetc( istype &, char );
    318325        bool eof( istype & );
    319         void clear( istype & );
    320326}; // basic_istream
    321327
    … …  
    323329trait istream {
    324330        bool fail( istype & );
    325         void open( istype & is, const char name[], const char mode[] );
     331        void clear( istype & );
    326332        void open( istype & is, const char name[] );
    327333        void close( istype & is );
    … …  
    336342forall( istype & | basic_istream( istype ) ) {
    337343        istype & ?|?( istype &, bool & );
     344        ISTYPE_VOID( bool & );
    338345
    339346        istype & ?|?( istype &, char & );
     347        ISTYPE_VOID( char & );
    340348        istype & ?|?( istype &, signed char & );
     349        ISTYPE_VOID( signed char & );
    341350        istype & ?|?( istype &, unsigned char & );
     351        ISTYPE_VOID( unsigned char & );
    342352
    343353        istype & ?|?( istype &, short int & );
     354        ISTYPE_VOID( short int & );
    344355        istype & ?|?( istype &, unsigned short int & );
     356        ISTYPE_VOID( unsigned short int & );
    345357        istype & ?|?( istype &, int & );
     358        ISTYPE_VOID( int & );
    346359        istype & ?|?( istype &, unsigned int & );
     360        ISTYPE_VOID( unsigned int & );
    347361        istype & ?|?( istype &, long int & );
     362        ISTYPE_VOID( long int & );
    348363        istype & ?|?( istype &, unsigned long int & );
     364        ISTYPE_VOID( unsigned long int & );
    349365        istype & ?|?( istype &, long long int & );
     366        ISTYPE_VOID( long long int & );
    350367        istype & ?|?( istype &, unsigned long long int & );
     368        ISTYPE_VOID( unsigned long long int & );
    351369        #if defined( __SIZEOF_INT128__ )
    352370        istype & ?|?( istype &, int128 & );
     371        ISTYPE_VOID( int128 & );
    353372        istype & ?|?( istype &, unsigned int128 & );
     373        ISTYPE_VOID( unsigned int128 & );
    354374        #endif // __SIZEOF_INT128__
    355375
    356376        istype & ?|?( istype &, float & );
     377        ISTYPE_VOID( float & );
    357378        istype & ?|?( istype &, double & );
     379        ISTYPE_VOID( double & );
    358380        istype & ?|?( istype &, long double & );
     381        ISTYPE_VOID( long double & );
    359382
    360383        istype & ?|?( istype &, float _Complex & );
     384        ISTYPE_VOID( float _Complex & );
    361385        istype & ?|?( istype &, double _Complex & );
     386        ISTYPE_VOID( double _Complex & );
    362387        istype & ?|?( istype &, long double _Complex & );
     388        ISTYPE_VOID( long double _Complex & );
    363389
    364390        istype & ?|?( istype &, const char [] );
     391        ISTYPE_VOID( const char [] );
    365392
    366393        // manipulators
    367394        istype & ?|?( istype &, istype & (*)( istype & ) );
     395        ISTYPE_VOID( istype & (*)( istype & ) );
    368396        istype & nl( istype & is );
    369397        istype & nlOn( istype & );
    … …  
    374402
    375403ExceptionDecl( cstring_length );
    376 ExceptionDecl( missing_data );
    377404
    378405// *********************************** manipulators ***********************************
    379406
    380 // skip does not compose with other C string manipulators.
    381407struct _Istream_Cskip {
    382408        const char * scanset;
    … …  
    390416forall( istype & | basic_istream( istype ) ) {
    391417        istype & ?|?( istype & is, _Istream_Cskip f );
     418        ISTYPE_VOID( _Istream_Cskip );
    392419}
    393420
    … …  
    431458forall( istype & | basic_istream( istype ) ) {
    432459        istype & ?|?( istype & is, _Istream_Cstr f );
     460        ISTYPE_VOID( _Istream_Cstr );
    433461}
    434462
    … …  
    443471forall( istype & | basic_istream( istype ) ) {
    444472        istype & ?|?( istype & is, _Istream_Char f );
     473        ISTYPE_VOID( _Istream_Char );
    445474}
    446475
    … …  
    461490forall( istype & | basic_istream( istype ) ) { \
    462491        istype & ?|?( istype & is, _Istream_Manip(T) f ); \
     492        ISTYPE_VOID( _Istream_Manip(T) ); \
    463493} // ?|?
    464494

  • src/CodeTools/DeclStats.cc

    r278e162 r4d2d7e27  
    2525#include "Common/PassVisitor.h"
    2626#include "Common/VectorMap.h"      // for VectorMap
     27#include "GenPoly/GenPoly.h"       // for hasPolyBase
    2728#include "SynTree/LinkageSpec.h"   // for ::NoOfSpecs, Spec
    2829#include "SynTree/Declaration.h"   // for FunctionDecl, TypeDecl, Declaration

  • src/GenPoly/BoxNew.cpp

    r278e162 r4d2d7e27  
    3939
    4040namespace {
     41
     42/// Common field of several sub-passes of box.
     43struct BoxPass {
     44        TypeVarMap scopeTypeVars;
     45        BoxPass() : scopeTypeVars( ast::TypeData() ) {}
     46};
     47
     48// TODO: Could this be a common helper somewhere?
     49ast::FunctionType * makeFunctionType( ast::FunctionDecl const * decl ) {
     50        ast::FunctionType * type = new ast::FunctionType(
     51                decl->type->isVarArgs, decl->type->qualifiers
     52        );
     53        for ( auto type_param : decl->type_params ) {
     54                type->forall.emplace_back( new ast::TypeInstType( type_param ) );
     55        }
     56        for ( auto assertion : decl->assertions ) {
     57                type->assertions.emplace_back( new ast::VariableExpr(
     58                        assertion->location, assertion ) );
     59        }
     60        for ( auto param : decl->params ) {
     61                type->params.emplace_back( param->get_type() );
     62        }
     63        for ( auto retval : decl->returns ) {
     64                type->returns.emplace_back( retval->get_type() );
     65        }
     66        return type;
     67}
    4168
    4269// --------------------------------------------------------------------------
    … …  
    332359/// * Adds appropriate type variables to the function calls.
    333360struct CallAdapter final :
     361                public BoxPass,
    334362                public ast::WithConstTypeSubstitution,
    335363                public ast::WithGuards,
    … …  
    410438                CodeLocation const & location, ast::Type const * type );
    411439
    412         TypeVarMap scopeTypeVars;
     440        /// Set of adapter functions in the current scope.
    413441        ScopedMap< std::string, ast::DeclWithType const * > adapters;
    414442        std::map< ast::ApplicationExpr const *, ast::Expr const * > retVals;
    … …  
    631659        ptrdiff_t initArgCount = mutExpr->args.size();
    632660
    633         TypeVarMap exprTypeVars;
     661        TypeVarMap exprTypeVars = { ast::TypeData() };
    634662        // TODO: Should this take into account the variables already bound in
    635663        // scopeTypeVars ([ex] remove them from exprTypeVars)?
    … …  
    13821410
    13831411ast::FunctionDecl const * DeclAdapter::previsit( ast::FunctionDecl const * decl ) {
    1384         TypeVarMap localTypeVars;
     1412        TypeVarMap localTypeVars = { ast::TypeData() };
    13851413        makeTypeVarMap( decl, localTypeVars );
    13861414
    … …  
    14131441                        layoutParams.emplace_back( alignParam );
    14141442                }
    1415                 // Assertions should be stored in the main list.
    1416                 assert( mutParam->assertions.empty() );
     1443                // TODO: These should possibly all be gone.
     1444                // More all assertions into parameter list.
     1445                for ( ast::ptr<ast::DeclWithType> & assert : mutParam->assertions ) {
     1446                        // Assertion parameters may not be used in body,
     1447                        // pass along with unused attribute.
     1448                        assert.get_and_mutate()->attributes.push_back(
     1449                                new ast::Attribute( "unused" ) );
     1450                        inferredParams.push_back( assert );
     1451                }
     1452                mutParam->assertions.clear();
    14171453                typeParam = mutParam;
    14181454        }
     1455        // TODO: New version of inner loop.
    14191456        for ( ast::ptr<ast::DeclWithType> & assert : mutDecl->assertions ) {
    14201457                // Assertion parameters may not be used in body,
    … …  
    14311468        spliceBegin( mutDecl->params, layoutParams );
    14321469        addAdapters( mutDecl, localTypeVars );
    1433 
    1434         // Now have to update the type to match the declaration.
    1435         ast::FunctionType * type = new ast::FunctionType(
    1436                 mutDecl->type->isVarArgs, mutDecl->type->qualifiers );
    1437         for ( auto type_param : mutDecl->type_params ) {
    1438                 type->forall.emplace_back( new ast::TypeInstType( type_param ) );
    1439         }
    1440         for ( auto param : mutDecl->params ) {
    1441                 type->params.emplace_back( param->get_type() );
    1442         }
    1443         for ( auto retval : mutDecl->returns ) {
    1444                 type->returns.emplace_back( retval->get_type() );
    1445         }
    1446         mutDecl->type = type;
    14471470
    14481471        return mutDecl;
    … …  
    14781501                }
    14791502        }
     1503        // TODO: Can this be updated as we go along?
     1504        mutDecl->type = makeFunctionType( mutDecl );
    14801505        return mutDecl;
    14811506}
    … …  
    15331558        assertf( it != adapters.end(), "Could not correct floating node." );
    15341559        return ast::mutate_field( expr, &ast::VariableExpr::var, it->second );
     1560
    15351561}
    15361562
    … …  
    15441570/// * Inserts dynamic calculation of polymorphic type layouts where needed.
    15451571struct PolyGenericCalculator final :
     1572                public BoxPass,
    15461573                public ast::WithConstTypeSubstitution,
    15471574                public ast::WithDeclsToAdd<>,
    … …  
    15881615        /// C sizeof().
    15891616        ast::Expr const * genSizeof( CodeLocation const &, ast::Type const * );
     1617
    15901618        /// Enters a new scope for type-variables,
    15911619        /// adding the type variables from the provided type.
    15921620        void beginTypeScope( ast::Type const * );
    15931621
    1594         /// The type variables and polymorphic parameters currently in scope.
    1595         TypeVarMap scopeTypeVars;
    15961622        /// Set of generic type layouts known in the current scope,
    15971623        /// indexed by sizeofName.
    … …  
    16421668                ast::TypeDecl const * decl ) {
    16431669        ast::Type const * base = decl->base;
    1644         if ( nullptr == base ) return decl;
     1670        if ( nullptr == base) return decl;
    16451671
    16461672        // Add size/align variables for opaque type declarations.
    … …  
    16671693        alignDecl->accept( *visitor );
    16681694
    1669         // A little trick to replace this with two declarations.
    1670         // Adding after makes sure that there is no conflict with adding stmts.
     1695        // Can't use [makeVar], because it inserts into stmtsToAdd and TypeDecls
     1696        // can occur at global scope.
    16711697        declsToAddAfter.push_back( alignDecl );
     1698        // replace with sizeDecl.
    16721699        return sizeDecl;
    16731700}
    … …  
    16941721
    16951722        // Change initialization of a polymorphic value object to allocate via a
    1696         // variable-length-array (alloca cannot be safely used in loops).
     1723        // variable-length-array (alloca was previouly used, but it cannot be
     1724        // safely used in loops).
    16971725        ast::ObjectDecl * newBuf = new ast::ObjectDecl( decl->location,
    16981726                bufNamer.newName(),
    … …  
    21822210/// * Strips fields from generic structure declarations.
    21832211struct Eraser final :
     2212                public BoxPass,
    21842213                public ast::WithGuards {
    21852214        void guardTypeVarMap( ast::Type const * type ) {
    … …  
    21962225        void previsit( ast::PointerType const * type );
    21972226        void previsit( ast::FunctionType const * type );
    2198 public:
    2199         TypeVarMap scopeTypeVars;
    22002227};
    22012228

  • src/GenPoly/GenPoly.cc

    r278e162 r4d2d7e27  
    273273        if ( func->returns.empty() ) return nullptr;
    274274
    275         TypeVarMap forallTypes;
     275        TypeVarMap forallTypes = { ast::TypeData() };
    276276        makeTypeVarMap( func, forallTypes );
    277277        return isDynType( func->returns.front(), forallTypes );
    … …  
    801801        const ast::FunctionType * function = getFunctionType( expr->func->result );
    802802        assertf( function, "ApplicationExpr has non-function type: %s", toString( expr->func->result ).c_str() );
    803         TypeVarMap exprTyVars;
     803        TypeVarMap exprTyVars = { ast::TypeData() };
    804804        makeTypeVarMap( function, exprTyVars );
    805805        return needsBoxing( param, arg, exprTyVars, subst );

  • src/GenPoly/GenPoly.h

    r278e162 r4d2d7e27  
    3333
    3434        typedef ErasableScopedMap< std::string, TypeDecl::Data > TyVarMap;
    35         struct TypeVarMap : public ErasableScopedMap<ast::TypeEnvKey, ast::TypeData> {
    36                 TypeVarMap() : ErasableScopedMap( ast::TypeData() ) {}
    37         };
     35        using TypeVarMap = ErasableScopedMap< ast::TypeEnvKey, ast::TypeData >;
    3836
    3937        /// Replaces a TypeInstType by its referrent in the environment, if applicable

  • src/GenPoly/SpecializeNew.cpp

    r278e162 r4d2d7e27  
    8181}
    8282
    83 // The number of elements in a list, if all tuples had been flattened.
    84 size_t flatTypeListSize( const std::vector<ast::ptr<ast::Type>> & types ) {
    85         size_t sum = 0;
    86         for ( const ast::ptr<ast::Type> & type : types ) {
    87                 if ( const ast::TupleType * tuple = type.as<ast::TupleType>() ) {
    88                         sum += flatTypeListSize( tuple->types );
    89                 } else {
    90                         sum += 1;
    91                 }
    92         }
    93         return sum;
     83// The number of elements in a type if it is a flattened tuple.
     84size_t flatTupleSize( const ast::Type * type ) {
     85        if ( auto tuple = dynamic_cast<const ast::TupleType *>( type ) ) {
     86                size_t sum = 0;
     87                for ( auto t : *tuple ) {
     88                        sum += flatTupleSize( t );
     89                }
     90                return sum;
     91        } else {
     92                return 1;
     93        }
    9494}
    9595
    9696// Find the total number of components in a parameter list.
    9797size_t functionParameterSize( const ast::FunctionType * type ) {
    98         return flatTypeListSize( type->params );
     98        size_t sum = 0;
     99        for ( auto param : type->params ) {
     100                sum += flatTupleSize( param );
     101        }
     102        return sum;
    99103}
    100104

  • tests/collections/.expect/string-istream-manip.txt

    r278e162 r4d2d7e27  
    696913 wwwwwwww
    707014 cccc
    71 15 q
     7115
    72721 yyyyyyyyyyyyyyyyyyyy
    73732 abcxxx
    … …  
    848413 wwwwwwww
    858514 cccc
    86 15 q
     8615

  • tests/collections/string-istream-manip.cfa

    r278e162 r4d2d7e27  
    3838        void echoTillX(const char * casename) {
    3939            string s;
    40             // loop assumes behaviour not tested until main-case #15:
    41             // on reading nothing, the prior string value is left alone
    4240            do {
    43                 s = "";
    4441                forceStringHeapFreeSpaceTo(9);
    4542                sin | s;
    … …  
    5754            string s;
    5855            do {
    59                 s = "";
    6056                sin | plainjane( s );
    6157                sout | casename | s;
    … …  
    7268            string_res s;
    7369            do {
    74                 s = "";
    7570                sin | plainjane( s );
    7671                sout | casename | s;
    … …  
    8782            string s;
    8883            do {
    89                 s = "";
    9084                sin | skip("-\n");
    9185                sin | incl( ".:|# x", s );
    … …  
    10397            string s;
    10498            do {
    105                 s = "";
    10699                sin | skip("-\n");
    107100                sin | excl( "-\n", s );
    … …  
    120113            string s;
    121114            do {
    122                 s = "";
    123115                sin | getline( s );
    124116                sout | casename | s;
    … …  
    135127            string s;
    136128            do {
    137                 s = "";
    138129                sin | getline( s, '@' );
    139130                sout | casename | s;

  • tests/concurrency/waituntil/channel_close.cfa

    r278e162 r4d2d7e27  
    2626        for( ;; ) {
    2727            if ( useAnd ) {
    28                 waituntil( (in << A) ) { __atomic_thread_fence( __ATOMIC_SEQ_CST ); assert( A_removes == in ); A_removes++; removes++; }
    29                 and waituntil( (in2 << B) ) { __atomic_thread_fence( __ATOMIC_SEQ_CST ); assert( B_removes == in2 ); B_removes++; removes++; }
     28                waituntil( (in << A) ) { assert( A_removes == in ); A_removes++; removes++; }
     29                and waituntil( (in2 << B) ) { assert( B_removes == in2 ); B_removes++; removes++; }
    3030                continue;
    3131            }
    32             waituntil( (in << A) ) { __atomic_thread_fence( __ATOMIC_SEQ_CST ); assert( A_removes == in ); A_removes++; removes++; }
    33             or waituntil( (in << B) ) { __atomic_thread_fence( __ATOMIC_SEQ_CST ); ( B_removes == in ); B_removes++; removes++; }
     32            waituntil( (in << A) ) { assert( A_removes == in ); A_removes++; removes++; }
     33            or waituntil( (in << B) ) { assert( B_removes == in ); B_removes++; removes++; }
    3434        }
    3535    } catchResume ( channel_closed * e ) {} // continue to remove until would block
    … …  
    3737    try {
    3838        for( ;; )
    39             waituntil( (in << A) ) { __atomic_thread_fence( __ATOMIC_SEQ_CST ); assert( A_removes == in ); A_removes++; removes++; }
     39            waituntil( (in << A) ) { assert( A_removes == in ); A_removes++; removes++; }
    4040    } catchResume ( channel_closed * e ) {} // continue to remove until would block
    4141    catch ( channel_closed * e ) {}
    4242    try {
    4343        for( ;; )
    44             waituntil( (in << B) ) { __atomic_thread_fence( __ATOMIC_SEQ_CST ); assert( B_removes == in ); B_removes++; removes++; }
     44            waituntil( (in << B) ) { assert( B_removes == in ); B_removes++; removes++; }
    4545    } catchResume ( channel_closed * e ) {} // continue to remove until would block
    4646    catch ( channel_closed * e ) {}

  • tests/genericUnion.cfa

    r278e162 r4d2d7e27  
    1010// Created On       : Tue Dec 25 14:42:46 2018
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Oct 20 09:13:26 2023
    13 // Update Count     : 15
     12// Last Modified On : Tue Dec 25 14:46:33 2018
     13// Update Count     : 2
    1414//
    1515
    16 #include <fstream.hfa>
    1716#include <limits.hfa>
    1817
    19 forall( T )
     18forall(T)
    2019union ByteView {
    2120        T val;
    … …  
    2423
    2524forall(T)
    26 void print( ByteView(T) x ) {
    27         for ( i; sizeof(int) ) {                                                        // want to change to sizeof(T)
    28                 sout | nobase( pad0( wd( 2, hex( x.bytes[i] & 0xff ) ) ) ) | nosep;
     25void print(ByteView(T) x) {
     26        for (int i = 0; i < sizeof(int); i++) {                         // want to change to sizeof(T)
     27                printf("%02x", x.bytes[i] & 0xff);
    2928        }
    3029}
    3130
    3231forall(T)
    33 void f( ByteView(T) x, T val ) {
    34         print( x );
    35         sout | " ";
     32void f(ByteView(T) x, T val) {
     33        print(x);
     34        printf(" ");
    3635        x.val = val;
    37         print( x );
    38         sout | nl;
     36        print(x);
     37        printf("\n");
    3938}
    4039
    4140int main() {
    42         sout | nlOff;
    4341        ByteView(unsigned) u = { 0 };
    4442        ByteView(int) i = { 0 };
    45         f( u, MAX );
    46         f( i, -1 );
     43        f(u, MAX);
     44        f(i, -1);
    4745}
    4846

  • tests/io/.expect/manipulatorsInput.arm64.txt

    r278e162 r4d2d7e27  
    343413 wwwwwwww
    353514 cccc
    36 15 q
     3615
    3737a
    3838a

  • tests/io/.expect/manipulatorsInput.x64.txt

    r278e162 r4d2d7e27  
    343413 wwwwwwww
    353514 cccc
    36 15 q
     3615
    3737a
    3838a

  • tests/io/.expect/manipulatorsInput.x86.txt

    r278e162 r4d2d7e27  
    343413 wwwwwwww
    353514 cccc
    36 15 q
     3615
    3737a
    3838a

  • tests/io/.expect/manipulatorsOutput4.txt

    r278e162 r4d2d7e27  
    225225-1.55051464826854e+28 -15.5051e27 -15.5051e27   -15.505e27   -15.505e27 -15.50515e27 -15.50515e27 -0015.505e27 -0015.505e27 -15.50515e27 -15.50515e27 -15.505e27   -15.505e27   -15.50515e27 -15.50515e27 -15.505e27   -15.505e27   -15.50515e27 -15.50515e27
    226226-6.51216152272788e+29 -651.216e27 -651.216e27   -651.22e27   -651.22e27 -651.21615e27 -651.21615e27 -00651.22e27 -00651.22e27 -651.21615e27 -651.21615e27 -651.22e27   -651.22e27   -651.21615e27 -651.21615e27 -651.22e27   -651.22e27   -651.21615e27 -651.21615e27
    227 0 1 1 1.0 1
    228 1 2 2 2.0 2
    229 2 4 4 4.0 4
    230 3 8 8 8.0 8
    231 4 16 16 16.0 16
    232 5 32 32 32.0 32
    233 6 64 64 64.0 64
    234 7 128 128 128.0 128
    235 8 256 256 256.0 256
    236 9 512 512 512.0 512
    237 10 1024 1.024K 1.0K 1K
    238 11 2048 2.048K 2.0K 2K
    239 12 4096 4.096K 4.1K 4K
    240 13 8192 8.192K 8.2K 8K
    241 14 16384 16.384K 16.4K 16K
    242 15 32768 32.768K 32.8K 33K
    243 16 65536 65.536K 65.5K 66K
    244 17 131072 131.072K 131.1K 131K
    245 18 262144 262.144K 262.1K 262K
    246 19 524288 524.288K 524.3K 524K
    247 20 1048576 1.04858M 1.0M 1M
    248 21 2097152 2.09715M 2.1M 2M
    249 22 4194304 4.1943M 4.2M 4M
    250 23 8388608 8.38861M 8.4M 8M
    251 24 16777216 16.7772M 16.8M 17M
    252 25 33554432 33.5544M 33.6M 34M
    253 26 67108864 67.1089M 67.1M 67M
    254 27 134217728 134.218M 134.2M 134M
    255 28 268435456 268.435M 268.4M 268M
    256 29 536870912 536.871M 536.9M 537M
    257 30 1073741824 1.07374G 1.1G 1G
    258 31 2147483648 2.14748G 2.1G 2G

  • tests/io/manipulatorsOutput4.cfa

    r278e162 r4d2d7e27  
    77// Created On       : Tue Apr 13 17:55:02 2021
    88// Last Modified By : Peter A. Buhr
    9 // Last Modified On : Tue Oct 17 08:37:42 2023
    10 // Update Count     : 5
     9// Last Modified On : Tue Apr 13 18:00:33 2021
     10// Update Count     : 4
    1111//
    1212
    … …  
    4242                         | left(ws(12,5, eng(w) )) | left(sign(ws(12,5, eng(w) ))) | left(wd(12,5, eng(w) )) | left(sign(wd(12,5, eng(w) ))) | left(pad0(ws(12,5, eng(w) ))) | left(pad0(sign(ws(12,5, eng(w) )))) | left(pad0(wd(12,5, eng(w) ))) | left(pad0(sign(wd(12,5, eng(w) ))));
    4343        } // for
    44 
    45         for ( exp; sizeof(int) * 8 ) {
    46                 size_t pow2 = 1z << exp;
    47                 sout | exp | pow2 | unit(eng(pow2)) | wd(0,1, unit(eng( pow2 ))) | wd(0,0, unit(eng(pow2)));
    48         } // for
    4944} // main
    5045
Note: See TracChangeset for help on using the changeset viewer.