Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • libcfa/src/iostream.cfa

    r63e129c r4aae2bd  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Jan 28 11:58:54 2024
    13 // Update Count     : 1917
     12// Last Modified On : Wed Jan  3 10:53:13 2024
     13// Update Count     : 1898
    1414//
    1515
     
    944944        istype & nl( istype & is ) {
    945945                fmt( is, "%*[^\n]" );                                                   // ignore characters to newline
    946                 if ( ! eof( is ) ) fmt( is, "%*c" );                    // read newline
     946                if ( ! eof( is ) && getANL$( is ) ) fmt( is, "%*c" ); // read newline
    947947                return is;
    948948        } // nl
     
    984984        }
    985985
    986         istype & ?|?( istype & is, _Istream_Cquoted f ) with( f.cstr ) {
     986        istype & ?|?( istype & is, _Istream_Cquoted f ) with( f ) {
     987                char fmtstr[32];                                                                // storage scanset and format codes
     988                fmtstr[0] = '%';
     989
     990                int pos = 1;
    987991                int args;
    988           fini: {
     992                bool check = true;
     993
     994                if ( cstr.flags.ignore ) { check = false; fmtstr[1] = '*'; pos += 1; }
     995                int rwd = cstr.wd;
     996                if ( cstr.wd != -1 ) {                                          // => just ignore versus ignore with width
     997                        // wd is buffer bytes available (for input chars + null terminator)
     998                        // rwd is count of input chars
     999                        // no maximum width necessary because text ignored => width is read width
     1000                        if ( cstr.flags.rwd ) check = false;
     1001                        else rwd = cstr.wd - 1;
     1002                        pos += sprintf( &fmtstr[pos], "%d", rwd );
     1003                } // if
     1004
     1005                int len = 0;                                                                    // may not be set in fmt
     1006                char enddelim;
     1007                if ( ! cstr.flags.inex ) {                                              // => quoted getline
    9891008                        args = fmt( is, "%*[ \f\n\r\t\v]" );            // remove leading whitespace
    990                         if ( eof( is ) ) break fini;
    991                         char rfmt[4] = { delimiters[0], '%', 'n', '\0' };
    992                         int len = 0;                                                            // may not be set in fmt
     1009                        if ( eof( is ) ) goto Eof;
     1010                        char rfmt[4] = { cstr.delimiters[0], '%', 'n', '\0' };
    9931011                        args = fmt( is, rfmt, &len );                           // remove leading quote
    994                         if ( len == 0 || eof( is ) ) break fini;
    995 
    996                         // Change the remainder of the read into a getline by reseting the closing delimiter.
    997                         if ( delimiters[1] != '\0' ) {
    998                                 delimiters[0] = delimiters[1];
    999                                 delimiters[1] = '\0';
     1012                        if ( len == 0 || eof( is ) ) goto Eof;
     1013                } // if
     1014                enddelim = cstr.delimiters[1] == '\0' ? cstr.delimiters[0] : cstr.delimiters[1];
     1015                sprintf( &fmtstr[pos], "[^%c]%%n", enddelim );
     1016                if ( cstr.flags.ignore ) args = fmt( is, fmtstr, &len ); // no string argument for '*'
     1017                else args = fmt( is, fmtstr, cstr.s, &len );
     1018                if ( check && len == rwd && ! eof( is ) ) {             // might not fit
     1019                        char peek;
     1020                        fmt( is, "%c", &peek );                                         // check for delimiter
     1021                        if ( ! eof( is ) ) {
     1022                                if ( peek != enddelim ) {
     1023                                        ungetc( is, peek );
     1024                                        throwResume ExceptionInst( cstring_length );
     1025                                } // if
    10001026                        } // if
    1001                         flags.delimiter = true;
    1002                         return is | *(_Istream_Cstr *)&f;
    1003                 } // fini
    1004                 // read failed => no pattern match => set string to null
    1005                 if ( ! flags.ignore && s != 0p && args == 0 ) s[0] = '\0';
     1027                } else fmt( is, "%*c" );                                                // remove delimiter
     1028          Eof: ;
     1029                if ( rwd > 0 && args == 0 ) cstr.s[0] = '\0';   // read failed => no pattern match => set string to null
    10061030                if ( args == 1 && eof( is ) ) {                                 // data but scan ended at EOF
    10071031                        clear( is );                                                            // => reset EOF => detect again on next read
     
    10101034        }
    10111035
    1012         istype & ?|?( istype & is, _Istream_Cstr f ) with( f.cstr ) {
     1036        istype & ?|?( istype & is, _Istream_Cstr f ) with( f ) {
    10131037                const char * scanset;
    10141038                size_t nscanset = 0;
    10151039                if ( flags.delimiter ) scanset = delimiters;    // getline ?
    1016                 else scanset = f.cstr.scanset;
     1040                else scanset = f.scanset;
    10171041                if ( scanset ) nscanset = strlen( scanset );
    10181042
    10191043                char fmtstr[nscanset + 32];                                             // storage for scanset and format codes
    10201044                fmtstr[0] = '%';
     1045
    10211046                int pos = 1;
    10221047                int args;
    10231048                bool check = true;
    10241049
    1025                 if ( flags.ignore ) { check = false; fmtstr[1] = '*'; pos += 1; }
    1026                 int rwd = wd;
    1027                 if ( wd != -1 ) {                                                               // => just ignore versus ignore with width
     1050                if ( f.flags.ignore ) { check = false; fmtstr[1] = '*'; pos += 1; }
     1051                int rwd = f.wd;
     1052                if ( f.wd != -1 ) {                                                             // => just ignore versus ignore with width
    10281053                        // wd is buffer bytes available (for input chars + null terminator)
    10291054                        // rwd is count of input chars
    10301055                        // no maximum width necessary because text ignored => width is read width
    1031                         if ( flags.rwd ) check = false;
    1032                         else rwd = wd - 1;
    1033                         assert( rwd > 0 );
     1056                        if ( f.flags.rwd ) check = false;
     1057                        else rwd = f.wd - 1;
    10341058                        pos += sprintf( &fmtstr[pos], "%d", rwd );
    10351059                } // if
    10361060
    10371061                if ( ! scanset ) {                                                              // %s, %*s, %ws, %*ws
    1038                         // fprintf( stderr, "cstr %s\n", s );
     1062                        // fprintf( stderr, "cstr %s\n", f.s );
    10391063                        strcpy( &fmtstr[pos], "s%n" );
    10401064                        int len = 0;                                                            // may not be set in fmt
    1041                         if ( flags.ignore ) args = fmt( is, fmtstr, &len ); // no string argument for '*'
    1042                         else args = fmt( is, fmtstr, s, &len );
    1043                         // fprintf( stderr, "cstr %s %d %d %d %s\n", fmtstr, args, len, wd, s );
     1065                        if ( f.flags.ignore ) args = fmt( is, fmtstr, &len ); // no string argument for '*'
     1066                        else args = fmt( is, fmtstr, f.s, &len );
     1067                        // fprintf( stderr, "cstr %s %d %d %d %s\n", fmtstr, args, len, f.wd, f.s );
    10441068                        if ( check && len >= rwd && ! eof( is ) ) {     // might not fit
    10451069                                char peek;
     
    10521076                        } // if
    10531077                        // FIX ME: CFA strings need to be modified to NOT change the argument for this case, then this can be removed.
    1054                         if ( ! flags.ignore && args == 0 ) s[0]= '\0'; // read failed => no pattern match => set string to null
     1078                        if ( rwd > 0 && args == 0 ) f.s[0]= '\0';       // read failed => no pattern match => set string to null
    10551079                } else {
    1056                         if ( flags.delimiter ) {                                        // getline
     1080                        if ( f.flags.delimiter ) {                                      // getline
    10571081                                int len = 0;                                                    // may not be set in fmt
    1058                                 if ( delimiters[2] != '\0' ) {                  // read single character ?
    1059                                         sprintf( &fmtstr[pos], "c%%n" );
    1060                                 } else {
    1061                                         sprintf( &fmtstr[pos], "[^%c]%%n", delimiters[0] );
    1062                                 } // if
    1063                                 if ( flags.ignore ) args = fmt( is, fmtstr, &len ); // no string argument for '*'
    1064                                 else args = fmt( is, fmtstr, s, &len );
     1082                                sprintf( &fmtstr[pos], "[^%c]%%n", f.delimiters[0] );
     1083                                if ( f.flags.ignore ) args = fmt( is, fmtstr, &len ); // no string argument for '*'
     1084                                else args = fmt( is, fmtstr, f.s, &len );
    10651085                                if ( check && len == rwd && ! eof( is ) ) {     // might not fit
    1066                                         char peek;
    1067                                         fmt( is, "%c", &peek );                         // check for delimiter
     1086                                        fmtstr[0] = f.delimiters[0]; fmtstr[1] = '%'; fmtstr[2] = 'n'; fmtstr[3] = '\0';
     1087                                        fmt( is, fmtstr, &len );                        // remove delimiter
    10681088                                        if ( ! eof( is ) ) {
    1069                                                 if ( peek != delimiters[0] ) {
    1070                                                         ungetc( is, peek );
     1089//                                              if ( peek != f.delimiter[0] ) {
     1090                                                if ( len != 1 ) {
     1091//                                                      ungetc( is, peek );
    10711092                                                        throwResume ExceptionInst( cstring_length );
    10721093                                                } // if
     
    10761097                                // incl %[xxx],  %*[xxx],  %w[xxx],  %*w[xxx]
    10771098                                // excl %[^xxx], %*[^xxx], %w[^xxx], %*w[^xxx]
    1078                                 sprintf( &fmtstr[pos], "[%s%s]%%n", flags.inex ? "^" : "", scanset );
    1079                                 // fprintf( stderr, "incl/excl %s %d\n", fmtstr, wd );
     1099                                sprintf( &fmtstr[pos], "[%s%s]%%n", f.flags.inex ? "^" : "", scanset );
     1100                                // fprintf( stderr, "incl/excl %s %d\n", fmtstr, f.wd );
    10801101                                int len = 0;                                                    // may not be set in fmt
    1081                                 if ( flags.ignore ) args = fmt( is, fmtstr, &len ); // no string argument for '*'
    1082                                 else args = fmt( is, fmtstr, s, &len );
    1083                                 // fprintf( stderr, "incl/excl %s \"%s\" %d %d %d %d %d %c\n", fmtstr, s, args, wd, len, eof( is ), check, s[wd] );
     1102                                if ( f.flags.ignore ) args = fmt( is, fmtstr, &len ); // no string argument for '*'
     1103                                else args = fmt( is, fmtstr, f.s, &len );
     1104                                // 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] );
    10841105                                if ( check && len == rwd && ! eof( is ) ) {     // might not fit
    10851106                                        // fprintf( stderr, "overflow\n" );
     
    10891110                                        if ( ! eof( is ) ) {
    10901111                                                ungetc( is, peek );
    1091                                                 if ( flags.inex ^ strchr( scanset, peek ) != 0p ) throwResume ExceptionInst( cstring_length );
     1112                                                if ( f.flags.inex ^ strchr( f.scanset, peek ) != 0p ) throwResume ExceptionInst( cstring_length );
    10921113                                        } // if
    10931114                                } // if
    10941115                        } // if
    1095                         if ( ! flags.ignore && args == 0 ) s[0]= '\0'; // read failed => no pattern match => set string to null
     1116                        if ( rwd > 0 && args == 0 ) f.s[0]= '\0';       // read failed => no pattern match => set string to null
    10961117                } // if
    10971118                if ( args == 1 && eof( is ) ) {                                 // data but scan ended at EOF
     
    10991120                        clear( is );                                                            // => reset EOF => detect again on next read
    11001121                } // if
     1122                return is;
     1123        } // ?|?
     1124
     1125        istype & ?|?( istype & is, _Istream_Char f ) {
     1126                fmt( is, "%*c" );                                                               // argument variable unused
    11011127                return is;
    11021128        } // ?|?
     
    11191145} // distribution
    11201146
    1121 INPUT_FMT_IMPL( char, "c" )
    11221147INPUT_FMT_IMPL( signed char, "hhi" )
    11231148INPUT_FMT_IMPL( unsigned char, "hhi" )
Note: See TracChangeset for help on using the changeset viewer.