Changes in libcfa/src/iostream.hfa [3c5dee4:61c7239]

File:

• libcfa/src/iostream.hfa (modified) (5 diffs)

libcfa/src/iostream.hfa

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// iostream --
+// iostream.hfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat May 11 10:31:27 2019
-// Update Count     : 232
+// Last Modified On : Sat Jun  8 17:28:44 2019
+// Update Count     : 312
 //
 
@@ -17 +17 @@
 
 #include "iterator.hfa"
+
+
+//*********************************** Ostream ***********************************
+
 
 trait ostream( dtype ostype ) {
@@ -146 +150 @@
 } // distribution
 
-//---------------------------------------
+//*********************************** Manipulators ***********************************
+
+forall( otype T )
+struct _Ostream_Manip {
+        T val;                                                                                          // polymorphic base-type
+        unsigned char wd, pc;                                                           // width, precision
+        char base;                                                                                      // numeric base / floating-point style
+        union {
+                unsigned char all;
+                struct {
+                        unsigned char pc:1;                                                     // precision specified
+                        unsigned char left:1;                                           // left justify
+                        unsigned char nobsdp:1;                                         // base prefix / decimal point
+                        unsigned char sign:1;                                           // plus / minus sign
+                        unsigned char pad0:1;                                           // zero pad
+                } flags;
+        };
+}; // _Ostream_Manip
+
+//*********************************** Integral ***********************************
+
+// See 6.7.9. 19) The initialization shall occur in initializer list order, each initializer provided for a particular
+// subobject overriding any previously listed initializer for the same subobject; ***all subobjects that are not
+// initialized explicitly shall be initialized implicitly the same as objects that have static storage duration.***
+
+#define IntegralFMTDecl( T, CODE ) \
+static inline { \
+        _Ostream_Manip(T) bin( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'b', { .all : 0 } }; } \
+        _Ostream_Manip(T) oct( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'o', { .all : 0 } }; } \
+        _Ostream_Manip(T) hex( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'x', { .all : 0 } }; } \
+        _Ostream_Manip(T) wd( unsigned char w, T val ) { return (_Ostream_Manip(T))@{ val, w, 0, CODE, { .all : 0 } }; } \
+        _Ostream_Manip(T) wd( unsigned char w, unsigned char pc, T val ) { return (_Ostream_Manip(T))@{ val, w, pc, CODE, { .flags.pc : true } }; } \
+        _Ostream_Manip(T) & wd( unsigned char w, _Ostream_Manip(T) & fmt ) { fmt.wd = w; return fmt; } \
+        _Ostream_Manip(T) & wd( unsigned char w, unsigned char pc, _Ostream_Manip(T) & fmt ) { fmt.wd = w; fmt.pc = pc; fmt.flags.pc = true; return fmt; } \
+        _Ostream_Manip(T) & left( _Ostream_Manip(T) & fmt ) { fmt.flags.left = true; return fmt; } \
+        _Ostream_Manip(T) & upcase( _Ostream_Manip(T) & fmt ) { if ( fmt.base == 'x' || fmt.base == 'b' ) fmt.base -= 32; /* upper case */ return fmt; } \
+        _Ostream_Manip(T) & nobase( _Ostream_Manip(T) & fmt ) { fmt.flags.nobsdp = true; return fmt; } \
+        _Ostream_Manip(T) & pad0( _Ostream_Manip(T) & fmt ) { fmt.flags.pad0 = true; return fmt; } \
+        _Ostream_Manip(T) sign( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, CODE, { .flags.sign : true } }; } \
+        _Ostream_Manip(T) & sign( _Ostream_Manip(T) & fmt ) { fmt.flags.sign = true; return fmt; } \
+} \
+forall( dtype ostype | ostream( ostype ) ) { \
+        ostype & ?|?( ostype & os, _Ostream_Manip(T) f ); \
+        void ?|?( ostype & os, _Ostream_Manip(T) f ); \
+} // ?|?
+
+IntegralFMTDecl( signed char, 'd' )
+IntegralFMTDecl( unsigned char, 'u' )
+IntegralFMTDecl( signed short int, 'd' )
+IntegralFMTDecl( unsigned short int, 'u' )
+IntegralFMTDecl( signed int, 'd' )
+IntegralFMTDecl( unsigned int, 'u' )
+IntegralFMTDecl( signed long int, 'd' )
+IntegralFMTDecl( unsigned long int, 'u' )
+IntegralFMTDecl( signed long long int, 'd' )
+IntegralFMTDecl( unsigned long long int, 'u' )
+
+//*********************************** Floating Point ***********************************
+
+// Default suffix for values with no fraction is "."
+#define FloatingPointFMTDecl( T ) \
+static inline { \
+        _Ostream_Manip(T) hex( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'a', { .all : 0 } }; } \
+        _Ostream_Manip(T) sci( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'e', { .all : 0 } }; } \
+        _Ostream_Manip(T) wd( unsigned char w, T val ) { return (_Ostream_Manip(T))@{ val, w, 0, 'f', { .all : 0 } }; } \
+        _Ostream_Manip(T) wd( unsigned char w, unsigned char pc, T val ) { return (_Ostream_Manip(T))@{ val, w, pc, 'f', { .flags.pc : true } }; } \
+        _Ostream_Manip(T) ws( unsigned char w, unsigned char pc, T val ) { return (_Ostream_Manip(T))@{ val, w, pc, 'g', { .flags.pc : true } }; } \
+        _Ostream_Manip(T) & wd( unsigned char w, _Ostream_Manip(T) & fmt ) { fmt.wd = w; return fmt; } \
+        _Ostream_Manip(T) & wd( unsigned char w, unsigned char pc, _Ostream_Manip(T) & fmt ) { fmt.wd = w; fmt.pc = pc; fmt.flags.pc = true; return fmt; } \
+        _Ostream_Manip(T) & left( _Ostream_Manip(T) & fmt ) { fmt.flags.left = true; return fmt; } \
+        _Ostream_Manip(T) upcase( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'G', { .all : 0 } }; } \
+        _Ostream_Manip(T) & upcase( _Ostream_Manip(T) & fmt ) { fmt.base -= 32; /* upper case */ return fmt; } \
+        _Ostream_Manip(T) & pad0( _Ostream_Manip(T) & fmt ) { fmt.flags.pad0 = true; return fmt; } \
+        _Ostream_Manip(T) sign( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'g', { .flags.sign : true } }; } \
+        _Ostream_Manip(T) & sign( _Ostream_Manip(T) & fmt ) { fmt.flags.sign = true; return fmt; } \
+        _Ostream_Manip(T) nodp( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'g', { .flags.nobsdp : true } }; } \
+        _Ostream_Manip(T) & nodp( _Ostream_Manip(T) & fmt ) { fmt.flags.nobsdp = true; return fmt; } \
+} \
+forall( dtype ostype | ostream( ostype ) ) { \
+        ostype & ?|?( ostype & os, _Ostream_Manip(T) f ); \
+        void ?|?( ostype & os, _Ostream_Manip(T) f ); \
+} // ?|?
+
+FloatingPointFMTDecl( double )
+FloatingPointFMTDecl( long double )
+
+//*********************************** Character ***********************************
+
+static inline {
+        _Ostream_Manip(char) bin( char val ) { return (_Ostream_Manip(char))@{ val, 1, 0, 'b', { .all : 0 } }; }
+        _Ostream_Manip(char) oct( char val ) { return (_Ostream_Manip(char))@{ val, 1, 0, 'o', { .all : 0 } }; }
+        _Ostream_Manip(char) hex( char val ) { return (_Ostream_Manip(char))@{ val, 1, 0, 'x', { .all : 0 } }; }
+        _Ostream_Manip(char) wd( unsigned char w, char val ) { return (_Ostream_Manip(char))@{ val, w, 0, 'c', { .all : 0 } }; }
+        _Ostream_Manip(char) & wd( unsigned char w, _Ostream_Manip(char) & fmt ) { fmt.wd = w; return fmt; }
+        _Ostream_Manip(char) & left( _Ostream_Manip(char) & fmt ) { fmt.flags.left = true; return fmt; }
+        _Ostream_Manip(char) & upcase( _Ostream_Manip(char) & fmt ) { if ( fmt.base == 'x' || fmt.base == 'b' ) fmt.base -= 32; /* upper case */ return fmt; }
+        _Ostream_Manip(char) & nobase( _Ostream_Manip(char) & fmt ) { fmt.flags.nobsdp = true; return fmt; }
+} // distribution
+forall( dtype ostype | ostream( ostype ) ) {
+        ostype & ?|?( ostype & os, _Ostream_Manip(char) f );
+        void ?|?( ostype & os, _Ostream_Manip(char) f );
+} // ?|?
+
+//*********************************** C String ***********************************
+
+static inline {
+        _Ostream_Manip(const char *) bin( const char * val ) { return (_Ostream_Manip(const char *))@{ val, 1, 0, 'b', { .all : 0 } }; }
+        _Ostream_Manip(const char *) oct( const char * val ) { return (_Ostream_Manip(const char *))@{ val, 1, 0, 'o', { .all : 0 } }; }
+        _Ostream_Manip(const char *) hex( const char * val ) { return (_Ostream_Manip(const char *))@{ val, 1, 0, 'x', { .all : 0 } }; }
+        _Ostream_Manip(const char *) wd( unsigned char w, const char * val ) { return (_Ostream_Manip(const char *))@{ val, w, 0, 's', { .all : 0 } }; }
+        _Ostream_Manip(const char *) wd( unsigned char w, unsigned char pc, const char * val ) { return (_Ostream_Manip(const char *))@{ val, w, pc, 's', { .flags.pc : true } }; }
+        _Ostream_Manip(const char *) & wd( unsigned char w, _Ostream_Manip(const char *) & fmt ) { fmt.wd = w; return fmt; }
+        _Ostream_Manip(const char *) & wd( unsigned char w, unsigned char pc, _Ostream_Manip(const char *) & fmt ) { fmt.wd = w; fmt.pc = pc; fmt.flags.pc = true; return fmt; }
+        _Ostream_Manip(const char *) & left( _Ostream_Manip(const char *) & fmt ) { fmt.flags.left = true; return fmt; }
+        _Ostream_Manip(const char *) & nobase( _Ostream_Manip(const char *) & fmt ) { fmt.flags.nobsdp = true; return fmt; }
+} // distribution
+forall( dtype ostype | ostream( ostype ) ) {
+        ostype & ?|?( ostype & os, _Ostream_Manip(const char *) f );
+        void ?|?( ostype & os, _Ostream_Manip(const char *) f );
+} // ?|?
+
+
+//*********************************** Istream ***********************************
+
 
 trait istream( dtype istype ) {
@@ -189 +316 @@
         istype & ?|?( istype &, long double _Complex & );
 
+        // Cannot have char & and char * => cstr manipulator
+        // istype & ?|?( istype &, char * );
+
         // manipulators
         istype & ?|?( istype &, istype & (*)( istype & ) );
@@ -196 +326 @@
 } // distribution
 
-struct _Istream_cstrUC { char * s; };
-_Istream_cstrUC cstr( char * );
-forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, _Istream_cstrUC );
-
-struct _Istream_cstrC { char * s; int size; };
-_Istream_cstrC cstr( char *, int size );
-forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, _Istream_cstrC );
+//*********************************** Manipulators ***********************************
+
+struct _Istream_Cstr {
+        char * s;
+        const char * scanset;
+        int wd;                                                                                         // width
+        union {
+                unsigned char all;
+                struct {
+                        unsigned char ignore:1;                                         // do not change input argument
+                        unsigned char inex:1;                                           // include/exclude characters in scanset
+                } flags;
+        };
+}; // _Istream_Cstr
+
+static inline _Istream_Cstr skip( const char * scanset ) { return (_Istream_Cstr){ 0p, scanset, -1, { .all : 0 } }; }
+static inline _Istream_Cstr incl( const char * scanset, char * s ) { return (_Istream_Cstr){ s, scanset, -1, { .flags.inex : false } }; }
+static inline _Istream_Cstr incl( const char * scanset, _Istream_Cstr & fmt ) { fmt.flags.inex = false; return fmt; }
+static inline _Istream_Cstr excl( const char * scanset, char * s ) { return (_Istream_Cstr){ s, scanset, -1, { .flags.inex : true } }; }
+static inline _Istream_Cstr excl( const char * scanset, _Istream_Cstr & fmt ) { fmt.flags.inex = true; return fmt; }
+static inline _Istream_Cstr cstr( char * s ) { return (_Istream_Cstr){ s, 0p, -1, { .all : 0 } }; }
+static inline _Istream_Cstr ignore( const char * s ) { return (_Istream_Cstr)@{ s, 0p, -1, { .flags.ignore : true } }; }
+static inline _Istream_Cstr ignore( _Istream_Cstr & fmt ) { fmt.flags.ignore = true; return fmt; }
+static inline _Istream_Cstr wd( unsigned int w, char * s ) { return (_Istream_Cstr)@{ s, 0p, w, { .all : 0 } }; }
+static inline _Istream_Cstr wd( unsigned int w, _Istream_Cstr & fmt ) { fmt.wd = w; return fmt; }
+forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, _Istream_Cstr );
+
+forall( otype T )
+struct _Istream_Manip {
+        T & val;                                                                                        // polymorphic base-type
+        int wd;                                                                                         // width
+        bool ignore;                                                                            // do not change input argument
+}; // _Istream_Manip
+
+#define InputFMTDecl( T ) \
+static inline _Istream_Manip(T) ignore( const T & val ) { return (_Istream_Manip(T))@{ (T &)val, -1, true }; } \
+static inline _Istream_Manip(T) ignore( _Istream_Manip(T) & fmt ) { fmt.ignore = true; return fmt; } \
+static inline _Istream_Manip(T) wd( unsigned int w, T & val ) { return (_Istream_Manip(T))@{ val, w, false }; } \
+forall( dtype istype | istream( istype ) ) { \
+        istype & ?|?( istype & is, _Istream_Manip(T) f ); \
+} // ?|?
+
+InputFMTDecl( char )
+InputFMTDecl( signed char )
+InputFMTDecl( unsigned char )
+InputFMTDecl( signed short int )
+InputFMTDecl( unsigned short int )
+InputFMTDecl( signed int )
+InputFMTDecl( unsigned int )
+InputFMTDecl( signed long int )
+InputFMTDecl( unsigned long int )
+InputFMTDecl( signed long long int )
+InputFMTDecl( unsigned long long int )
+
+InputFMTDecl( float )
+InputFMTDecl( double )
+InputFMTDecl( long double )
+
+InputFMTDecl( float _Complex )
+InputFMTDecl( double _Complex )
+InputFMTDecl( long double _Complex )
+
+
+//*********************************** Time ***********************************