Changeset 7e1dbd7

Timestamp:

Aug 28, 2023, 7:05:05 PM (8 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

38de914, 4269d1b

Parents:

0926487

Message:

first attempt at input manipulators for strings

Location:

libcfa/src/containers

Files:

• string.cfa (modified) (2 diffs)
• string.hfa (modified) (2 diffs)

libcfa/src/containers/string.cfa

@@ -10 +10 @@
 // Created On       : Fri Sep 03 11:00:00 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug 24 11:27:57 2023
-// Update Count     : 89
+// Last Modified On : Mon Aug 28 19:00:45 2023
+// Update Count     : 146
 //
 
@@ -118 +118 @@
 }
 
-void getline( ifstream & in, string & str, const char delimit = '\n' ) {
-        // .---------------,
-        // | | | | |...|0|0| check and guard
-        // `---------------'
-        enum { gwd = 256 + 2, wd = gwd - 1 };                           // guarded and unguarded width
+static void readstr( ifstream & is, _Istream_str f, char fmtstr[], char cstr[] ) {
+        int check = f.rwd - 1;
+
+        if ( ! f.flags.rwd ) cstr[check] = '\0';                        // insert sentinel
+        int len = fmt( is, fmtstr, cstr );
+        // fprintf( stderr, "KK %s %zd %d %c %s\n", fmtstr, len, check, cstr[check], cstr );
+
+        if ( ! f.flags.rwd && cstr[check] != '\0' )                     // sentinel overwritten ?
+                throw (cstring_length){ &cstring_length_vt };
+
+        if ( f.flags.delimit ) {                                                        // getline ?
+                if ( len == 0 ) cstr[0] = '\0';                                 // empty read => argument unchanged => set empty
+                if ( ! eof( is ) ) fmt( is, "%*c" );                    // ignore delimiter
+        } //if
+} // readstr
+
+ifstream & ?|?( ifstream & is, _Istream_str f ) {
+        // skip, same as for char *
+        if ( ! &f.s ) {
+                // fprintf( stderr,  "skip %s %d\n", f.scanset, f.wd );
+                if ( f.rwd == -1 ) fmt( is, f.scanset, "" ); // no input arguments
+                else for ( f.rwd ) fmt( is, "%*c" );
+                return is;
+        } // if
+
+        enum { gwd = 16 + 2, wd = gwd - 1 };                            // guarded and unguarded width
         char cstr[gwd];                                                                         // read in chunks
         bool cont = false;;
 
+        if ( f.rwd == -1 ) f.rwd = wd;
+        const char * scanset = f.scanset;;
+        if ( f.flags.delimit ) scanset = f.delimit;                     // getline ?
+
+        size_t len = 0;
+        if ( scanset ) len = strlen( scanset );
+        char fmtstr[len + 16];
+        int start = 1;
+        fmtstr[0] = '%';
+        if ( f.flags.ignore ) { fmtstr[1] = '*'; start += 1; }
+        if ( f.rwd != -1 ) { start += sprintf( &fmtstr[start], "%d", f.rwd ); }
+
+        if ( ! scanset ) {
+                // %s, %*s, %ws, %*ws
+                fmtstr[start] = 's'; fmtstr[start + 1] = '\0';
+                // printf( "cstr %s\n", fmtstr );
+        } else {
+                // incl %[xxx],  %*[xxx],  %w[xxx],  %*w[xxx]
+                // excl %[^xxx], %*[^xxx], %w[^xxx], %*w[^xxx]
+                fmtstr[start] = '['; start += 1;
+                if ( f.flags.inex ) { fmtstr[start] = '^'; start += 1; }
+                strcpy( &fmtstr[start], scanset );                              // copy includes '\0'
+                len += start;
+                fmtstr[len] = ']'; fmtstr[len + 1] = '\0';
+                // printf( "incl/excl %s\n", fmtstr );
+        } // if
+
         cstr[wd] = '\0';                                                                        // guard null terminate string
         try {
-                in | getline( wdi( wd, cstr ), delimit );               // must have room for string terminator
-                if ( eof( in  ) ) return;                                               // do not change argument
+                readstr( is, f, fmtstr, cstr );
         } catch( cstring_length * ) {
-                cont = true;                                                                    // continue not allowed
+                cont = true;
         } finally {
-                str = cstr;                                                                             // ok to initialize string
+                f.s = cstr;                                                                             // ok to initialize string
         } // try
         for ( ; cont; )  {                                                                      // overflow read ?
                 cont = false;
                 try {
-                        in | getline( wdi( wd, cstr ), delimit );       // must have room for string terminator
-                        if ( eof( in  ) ) return;
+                        readstr( is, f, fmtstr, cstr );
                 } catch( cstring_length * ) {
                         cont = true;                                                            // continue not allowed
                 } finally {
-                        str += cstr;                                                            // build string chunk at a time
+                        f.s += cstr;                                                            // build string chunk at a time
                 } // try
         } // for
-}
+        return is;
+} // ?|?
+
+void ?|?( ifstream & in, _Istream_str f ) {
+    (ifstream &)(in | f); ends( in );
+}
+
+// void getline( ifstream & in, string & str, const char delimit = '\n' ) {
+//      // .---------------,
+//      // | | | | |...|0|0| check and guard
+//      // `---------------'
+//      enum { gwd = 128 + 2, wd = gwd - 1 };                           // guarded and unguarded width
+//      char cstr[gwd];                                                                         // read in chunks
+//      bool cont = false;;
+
+//      cstr[wd] = '\0';                                                                        // guard null terminate string
+//      try {
+//              in | getline( wdi( wd, cstr ), delimit );               // must have room for string terminator
+//              if ( eof( in  ) ) return;                                               // do not change argument
+//      } catch( cstring_length * ) {
+//              cont = true;
+//      } finally {
+//              str = cstr;                                                                             // ok to initialize string
+//      } // try
+//      for ( ; cont; )  {                                                                      // overflow read ?
+//              cont = false;
+//              try {
+//                      in | getline( wdi( wd, cstr ), delimit );       // must have room for string terminator
+//                      if ( eof( in  ) ) return;
+//              } catch( cstring_length * ) {
+//                      cont = true;                                                            // continue not allowed
+//              } finally {
+//                      str += cstr;                                                            // build string chunk at a time
+//              } // try
+//      } // for
+// }
 
 ////////////////////////////////////////////////////////

libcfa/src/containers/string.hfa

@@ -10 +10 @@
 // Created On       : Fri Sep 03 11:00:00 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Aug 23 11:16:14 2023
-// Update Count     : 6
+// Last Modified On : Mon Aug 28 18:32:59 2023
+// Update Count     : 40
 //
 
@@ -57 +57 @@
 ifstream & ?|?(ifstream & in, string & s);
 void ?|?( ifstream & in, string & this );
+
+
+struct _Istream_str {
+        string & s;
+        union {
+                const char * scanset;
+                char delimit[2];
+        };
+        int rwd;                                                                                        // read width
+        union {
+                unsigned char all;
+                struct {
+                        unsigned char ignore:1;                                         // do not change input argument
+                        unsigned char inex:1;                                           // include/exclude characters in scanset
+                        unsigned char delimit:1;                                        // delimit character
+                        unsigned char rwd:1;                                            // read width
+                } flags;
+        };
+}; // _Istream_str
+
+static inline {
+        // read width does not include null terminator
+        _Istream_str wdi( unsigned int rwd, string & s ) { return (_Istream_str)@{ s, {0p}, rwd, {.flags.rwd : true} }; }
+        _Istream_str skip( const char scanset[] ) { return (_Istream_str)@{ *0p, {scanset}, -1, {.all : 0} }; }
+        _Istream_str skip( unsigned int wd ) { return (_Istream_str)@{ *0p, {0p}, wd, {.all : 0} }; }
+        _Istream_str getline( string & s, const char delimit = '\n' ) {
+                return (_Istream_str)@{ s, {.delimit : { delimit, '\0' } }, -1, {.flags.delimit : true, .flags.inex : true} };
+        }
+        _Istream_str & getline( _Istream_str & fmt, const char delimit = '\n' ) {
+                fmt.delimit[0] = delimit; fmt.delimit[1] = '\0'; fmt.flags.delimit = true; fmt.flags.inex = true; return fmt;
+        }
+        _Istream_str incl( const char scanset[], string & s ) { return (_Istream_str)@{ s, {scanset}, -1, {.flags.inex : false} }; }
+        _Istream_str & incl( const char scanset[], _Istream_str & fmt ) { fmt.scanset = scanset; fmt.flags.inex = false; return fmt; }
+        _Istream_str excl( const char scanset[], string & s ) { return (_Istream_str)@{ s, {scanset}, -1, {.flags.inex : true} }; }
+        _Istream_str & excl( const char scanset[], _Istream_str & fmt ) { fmt.scanset = scanset; fmt.flags.inex = true; return fmt; }
+        _Istream_str ignore( string & s ) { return (_Istream_str)@{ s, {0p}, -1, {.flags.ignore : true} }; }
+        _Istream_str & ignore( _Istream_str & fmt ) { fmt.flags.ignore = true; return fmt; }
+} // distribution
+ifstream & ?|?( ifstream & is, _Istream_str f );
+void ?|?( ifstream & is, _Istream_str t );
 void getline( ifstream & in, string & this, const char delimit = '\n' );