| 1 | //
|
|---|
| 2 | // Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
|
|---|
| 3 | //
|
|---|
| 4 | // The contents of this file are covered under the licence agreement in the
|
|---|
| 5 | // file "LICENCE" distributed with Cforall.
|
|---|
| 6 | //
|
|---|
| 7 | // iostream.hfa --
|
|---|
| 8 | //
|
|---|
| 9 | // Author : Peter A. Buhr
|
|---|
| 10 | // Created On : Wed May 27 17:56:53 2015
|
|---|
| 11 | // Last Modified By : Peter A. Buhr
|
|---|
| 12 | // Last Modified On : Sat May 2 18:48:56 2026
|
|---|
| 13 | // Update Count : 780
|
|---|
| 14 | //
|
|---|
| 15 |
|
|---|
| 16 | #pragma once
|
|---|
| 17 |
|
|---|
| 18 | #include "iterator.hfa"
|
|---|
| 19 | #include "Exception.hfa"
|
|---|
| 20 |
|
|---|
| 21 | // *********************************** ostream ***********************************
|
|---|
| 22 |
|
|---|
| 23 | forall( ostype & )
|
|---|
| 24 | struct basic_ostream_data {
|
|---|
| 25 | // private
|
|---|
| 26 | bool (*sepPrt$)( ostype & ); // get separator state (on/off)
|
|---|
| 27 | void (*sepReset$)( ostype & ); // set separator state to default state
|
|---|
| 28 | void (*sepReset$)( ostype &, bool ); // set separator and default state
|
|---|
| 29 | const char * (*sepGetCur$)( ostype & ); // get current separator string
|
|---|
| 30 | void (*sepSetCur$)( ostype &, const char [] ); // set current separator string
|
|---|
| 31 | bool (*getNL$)( ostype & ); // get newline
|
|---|
| 32 | bool (*setNL$)( ostype &, bool ); // set newline
|
|---|
| 33 | bool (*getANL$)( ostype & ); // get auto newline (on/off)
|
|---|
| 34 | bool (*setANL$)( ostype &, bool ); // set auto newline (on/off), and return previous state
|
|---|
| 35 | bool (*getPrt$)( ostype & ); // get fmt called in output cascade
|
|---|
| 36 | bool (*setPrt$)( ostype &, bool ); // set fmt called in output cascade
|
|---|
| 37 | // public
|
|---|
| 38 | void (*nlOn)( ostype & ); // turn auto-newline state on
|
|---|
| 39 | void (*nlOff)( ostype & ); // turn auto-newline state off
|
|---|
| 40 |
|
|---|
| 41 | void (*sep)( ostype & ); // turn separator state on
|
|---|
| 42 | void (*nosep)( ostype & ); // turn separator state off
|
|---|
| 43 | bool (*sepOn)( ostype & ); // set default state to on, and return previous state
|
|---|
| 44 | bool (*sepOff)( ostype & ); // set default state to off, and return previous state
|
|---|
| 45 | const char * (*sepGet)( ostype & ); // get separator string
|
|---|
| 46 | void (*sepSet)( ostype &, const char [] ); // set separator to string (15 character maximum)
|
|---|
| 47 | const char * (*sepGetTuple)( ostype & ); // get tuple separator string
|
|---|
| 48 | void (*sepSetTuple)( ostype &, const char [] ); // set tuple separator to string (15 character maximum)
|
|---|
| 49 |
|
|---|
| 50 | void (*ends)( ostype & ); // end of output statement
|
|---|
| 51 | int (*fmt)( ostype &, const char format[], ... ) __attribute__(( format(printf, 2, 3) ));
|
|---|
| 52 | }; // basic_ostream
|
|---|
| 53 |
|
|---|
| 54 | forall( ostype & )
|
|---|
| 55 | struct ostream_data {
|
|---|
| 56 | inline basic_ostream_data( ostype );
|
|---|
| 57 | bool (*fail)( ostype & ); // operation failed?
|
|---|
| 58 | void (*clearerr)( ostype & );
|
|---|
| 59 | int (*flush)( ostype & );
|
|---|
| 60 | void (*open)( ostype &, const char name[], const char mode[] );
|
|---|
| 61 | void (*close)( ostype & );
|
|---|
| 62 | ostype & (*write)( ostype &, const char [], size_t );
|
|---|
| 63 | }; // ostream
|
|---|
| 64 |
|
|---|
| 65 | forall( ostype & )
|
|---|
| 66 | trait basic_ostream {
|
|---|
| 67 | basic_ostream_data(ostype) const & basic_ostream_table;
|
|---|
| 68 | };
|
|---|
| 69 |
|
|---|
| 70 | forall( ostype & | basic_ostream( ostype ) )
|
|---|
| 71 | trait ostream {
|
|---|
| 72 | ostream_data(ostype) const & ostream_table;
|
|---|
| 73 | };
|
|---|
| 74 |
|
|---|
| 75 | // forall( T )
|
|---|
| 76 | // trait writeable {
|
|---|
| 77 | // forall( ostype & | ostream( ostype ) ) ostype & ?|?( ostype &, T );
|
|---|
| 78 | // }; // writeable
|
|---|
| 79 |
|
|---|
| 80 | forall( T, ostype & | ostream( ostype ) )
|
|---|
| 81 | trait writeable {
|
|---|
| 82 | ostype & ?|?( ostype &, T );
|
|---|
| 83 | }; // writeable
|
|---|
| 84 |
|
|---|
| 85 | // implement writable for intrinsic types
|
|---|
| 86 |
|
|---|
| 87 | #define OSTYPE_VOID( T ) void ?|?( ostype &, T )
|
|---|
| 88 | #define OSTYPE_VOID_IMPL( os, T ) \
|
|---|
| 89 | void ?|?( ostype & os, T t ) { \
|
|---|
| 90 | (ostype &)(os | t); \
|
|---|
| 91 | basic_ostream_table.ends( os ); \
|
|---|
| 92 | } // ?|?
|
|---|
| 93 |
|
|---|
| 94 | forall( ostype & | basic_ostream( ostype ) ) {
|
|---|
| 95 | ostype & ?|?( ostype &, bool );
|
|---|
| 96 | OSTYPE_VOID( bool );
|
|---|
| 97 |
|
|---|
| 98 | ostype & ?|?( ostype &, char );
|
|---|
| 99 | OSTYPE_VOID( char );
|
|---|
| 100 | ostype & ?|?( ostype &, signed char );
|
|---|
| 101 | OSTYPE_VOID( signed char );
|
|---|
| 102 | ostype & ?|?( ostype &, unsigned char );
|
|---|
| 103 | OSTYPE_VOID( unsigned char );
|
|---|
| 104 |
|
|---|
| 105 | ostype & ?|?( ostype &, short int );
|
|---|
| 106 | OSTYPE_VOID( short int );
|
|---|
| 107 | ostype & ?|?( ostype &, unsigned short int );
|
|---|
| 108 | OSTYPE_VOID( unsigned short int );
|
|---|
| 109 | ostype & ?|?( ostype &, int );
|
|---|
| 110 | OSTYPE_VOID( int );
|
|---|
| 111 | ostype & ?|?( ostype &, unsigned int );
|
|---|
| 112 | OSTYPE_VOID( unsigned int );
|
|---|
| 113 | ostype & ?|?( ostype &, long int );
|
|---|
| 114 | OSTYPE_VOID( long int );
|
|---|
| 115 | ostype & ?|?( ostype &, long long int );
|
|---|
| 116 | OSTYPE_VOID( long long int );
|
|---|
| 117 | ostype & ?|?( ostype &, unsigned long int );
|
|---|
| 118 | OSTYPE_VOID( unsigned long int );
|
|---|
| 119 | ostype & ?|?( ostype &, unsigned long long int );
|
|---|
| 120 | OSTYPE_VOID( unsigned long long int );
|
|---|
| 121 | #if defined( __SIZEOF_INT128__ )
|
|---|
| 122 | ostype & ?|?( ostype &, int128 );
|
|---|
| 123 | OSTYPE_VOID( int128 );
|
|---|
| 124 | ostype & ?|?( ostype &, unsigned int128 );
|
|---|
| 125 | OSTYPE_VOID( unsigned int128 );
|
|---|
| 126 | #endif // __SIZEOF_INT128__
|
|---|
| 127 |
|
|---|
| 128 | ostype & ?|?( ostype &, float );
|
|---|
| 129 | OSTYPE_VOID( float );
|
|---|
| 130 | ostype & ?|?( ostype &, double );
|
|---|
| 131 | OSTYPE_VOID( double );
|
|---|
| 132 | ostype & ?|?( ostype &, long double );
|
|---|
| 133 | OSTYPE_VOID( long double );
|
|---|
| 134 |
|
|---|
| 135 | ostype & ?|?( ostype &, float _Complex );
|
|---|
| 136 | OSTYPE_VOID( float _Complex );
|
|---|
| 137 | ostype & ?|?( ostype &, double _Complex );
|
|---|
| 138 | OSTYPE_VOID( double _Complex );
|
|---|
| 139 | ostype & ?|?( ostype &, long double _Complex );
|
|---|
| 140 | OSTYPE_VOID( long double _Complex );
|
|---|
| 141 |
|
|---|
| 142 | ostype & ?|?( ostype &, const char [] );
|
|---|
| 143 | OSTYPE_VOID( const char [] );
|
|---|
| 144 | // ostype & ?|?( ostype &, const char16_t [] );
|
|---|
| 145 | #if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous
|
|---|
| 146 | // ostype & ?|?( ostype &, const char32_t [] );
|
|---|
| 147 | #endif // ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 )
|
|---|
| 148 | // ostype & ?|?( ostype &, const wchar_t [] );
|
|---|
| 149 | ostype & ?|?( ostype &, const void * );
|
|---|
| 150 | OSTYPE_VOID( const void * );
|
|---|
| 151 |
|
|---|
| 152 | // FIX-ME: does not work so using macros
|
|---|
| 153 | // forall( T | { ostype & ?|?( ostype &, T ); } )
|
|---|
| 154 | // void ?|?( ostype & os, T );
|
|---|
| 155 |
|
|---|
| 156 | // manipulators
|
|---|
| 157 | ostype & ?|?( ostype &, ostype & (*)( ostype & ) );
|
|---|
| 158 | OSTYPE_VOID( ostype & (*)( ostype & ) );
|
|---|
| 159 |
|
|---|
| 160 | ostype & nl( ostype & );
|
|---|
| 161 | ostype & nonl( ostype & );
|
|---|
| 162 | ostype & nlOn( ostype & );
|
|---|
| 163 | ostype & nlOff( ostype & );
|
|---|
| 164 |
|
|---|
| 165 | ostype & sepVal( ostype & );
|
|---|
| 166 | ostype & sepTupleVal( ostype & );
|
|---|
| 167 | ostype & sep( ostype & );
|
|---|
| 168 | ostype & nosep( ostype & );
|
|---|
| 169 | ostype & sepOn( ostype & );
|
|---|
| 170 | ostype & sepOff( ostype & );
|
|---|
| 171 | } // distribution
|
|---|
| 172 |
|
|---|
| 173 | // tuples
|
|---|
| 174 | forall( ostype &, T, List ... | writeable( T, ostype ) | { ostype & ?|?( ostype &, List ); } ) {
|
|---|
| 175 | ostype & ?|?( ostype & os, T arg, List rest );
|
|---|
| 176 | void ?|?( ostype & os, T arg, List rest );
|
|---|
| 177 | } // distribution
|
|---|
| 178 |
|
|---|
| 179 | // writes the range [begin, end) to the given stream
|
|---|
| 180 | forall( ostype &, elt_type | writeable( elt_type, ostype ), iterator_type | iterator( iterator_type, elt_type ) ) {
|
|---|
| 181 | void write( iterator_type begin, iterator_type end, ostype & os );
|
|---|
| 182 | void write_reverse( iterator_type begin, iterator_type end, ostype & os );
|
|---|
| 183 | } // distribution
|
|---|
| 184 |
|
|---|
| 185 | // *********************************** manipulators ***********************************
|
|---|
| 186 |
|
|---|
| 187 | struct _Ostream_Flags {
|
|---|
| 188 | unsigned char eng:1; // engineering notation
|
|---|
| 189 | unsigned char neg:1; // val is negative
|
|---|
| 190 | unsigned char pc:1; // precision specified
|
|---|
| 191 | unsigned char left:1; // left justify
|
|---|
| 192 | unsigned char nobsdp:1; // base prefix / decimal point
|
|---|
| 193 | unsigned char sign:1; // plus / minus sign
|
|---|
| 194 | unsigned char pad0:1; // zero pad
|
|---|
| 195 | unsigned char quote:1; // print quotes
|
|---|
| 196 | };
|
|---|
| 197 |
|
|---|
| 198 | // FIXME: Should be an anonymous inner union of _Ostream_Manip.
|
|---|
| 199 | // Hoisting manually to work around warning of #294.
|
|---|
| 200 | union _Ostream_Manip_Mode {
|
|---|
| 201 | unsigned char all;
|
|---|
| 202 | _Ostream_Flags flags;
|
|---|
| 203 | };
|
|---|
| 204 |
|
|---|
| 205 | forall( T )
|
|---|
| 206 | struct _Ostream_Manip {
|
|---|
| 207 | T val; // polymorphic base-type
|
|---|
| 208 | int wd, pc; // width, precision: signed for computations
|
|---|
| 209 | char base; // numeric base / floating-point style
|
|---|
| 210 | inline _Ostream_Manip_Mode;
|
|---|
| 211 | }; // _Ostream_Manip
|
|---|
| 212 |
|
|---|
| 213 | // *********************************** integral ***********************************
|
|---|
| 214 |
|
|---|
| 215 | #define INTEGRAL_FMT_DECL( T, CODE ) \
|
|---|
| 216 | static inline { \
|
|---|
| 217 | _Ostream_Manip(T) bin( T val ) { return (_Ostream_Manip(T))@{ .val = val, .wd = 1, .pc = 0, .base = 'b', { .all = 0 } }; } \
|
|---|
| 218 | _Ostream_Manip(T) oct( T val ) { return (_Ostream_Manip(T))@{ .val = val, .wd = 1, .pc = 0, .base = 'o', { .all = 0 } }; } \
|
|---|
| 219 | _Ostream_Manip(T) hex( T val ) { return (_Ostream_Manip(T))@{ .val = val, .wd = 1, .pc = 0, .base = 'x', { .all = 0 } }; } \
|
|---|
| 220 | _Ostream_Manip(T) wd( unsigned int wd, T val ) { return (_Ostream_Manip(T))@{ .val = val, .wd = wd, .pc = 0, .base = CODE, { .all = 0 } }; } \
|
|---|
| 221 | _Ostream_Manip(T) wd( unsigned int wd, unsigned int pc, T val ) { return (_Ostream_Manip(T))@{ .val = val, .wd = wd, .pc = pc, .base = CODE, { .flags.pc = true } }; } \
|
|---|
| 222 | _Ostream_Manip(T) & wd( unsigned int wd, _Ostream_Manip(T) & fmt ) { fmt.wd = wd; return fmt; } \
|
|---|
| 223 | _Ostream_Manip(T) & wd( unsigned int wd, unsigned int pc, _Ostream_Manip(T) & fmt ) { fmt.wd = wd; fmt.pc = pc; fmt.flags.pc = true; return fmt; } \
|
|---|
| 224 | _Ostream_Manip(T) & left( _Ostream_Manip(T) & fmt ) { fmt.flags.left = true; return fmt; } \
|
|---|
| 225 | _Ostream_Manip(T) & upcase( _Ostream_Manip(T) & fmt ) { if ( fmt.base == 'x' || fmt.base == 'b' ) fmt.base -= 32; /* upper case */ return fmt; } \
|
|---|
| 226 | _Ostream_Manip(T) & nobase( _Ostream_Manip(T) & fmt ) { fmt.flags.nobsdp = true; return fmt; } \
|
|---|
| 227 | _Ostream_Manip(T) sign( T val ) { return (_Ostream_Manip(T))@{ .val = val, .wd = 1, .pc = 0, .base = CODE, { .flags.sign = true } }; } \
|
|---|
| 228 | _Ostream_Manip(T) & sign( _Ostream_Manip(T) & fmt ) { fmt.flags.sign = true; return fmt; } \
|
|---|
| 229 | _Ostream_Manip(T) & pad0( _Ostream_Manip(T) & fmt ) { fmt.flags.pad0 = true; return fmt; } \
|
|---|
| 230 | } /* distribution */ \
|
|---|
| 231 | forall( ostype & | basic_ostream( ostype ) ) { \
|
|---|
| 232 | ostype & ?|?( ostype & os, _Ostream_Manip(T) f ); \
|
|---|
| 233 | OSTYPE_VOID( _Ostream_Manip(T) ); \
|
|---|
| 234 | } // ?|?
|
|---|
| 235 |
|
|---|
| 236 | INTEGRAL_FMT_DECL( signed char, 'd' )
|
|---|
| 237 | INTEGRAL_FMT_DECL( unsigned char, 'u' )
|
|---|
| 238 | INTEGRAL_FMT_DECL( signed short int, 'd' )
|
|---|
| 239 | INTEGRAL_FMT_DECL( unsigned short int, 'u' )
|
|---|
| 240 | INTEGRAL_FMT_DECL( signed int, 'd' )
|
|---|
| 241 | INTEGRAL_FMT_DECL( unsigned int, 'u' )
|
|---|
| 242 | INTEGRAL_FMT_DECL( signed long int, 'd' )
|
|---|
| 243 | INTEGRAL_FMT_DECL( unsigned long int, 'u' )
|
|---|
| 244 | INTEGRAL_FMT_DECL( signed long long int, 'd' )
|
|---|
| 245 | INTEGRAL_FMT_DECL( unsigned long long int, 'u' )
|
|---|
| 246 | #if defined( __SIZEOF_INT128__ )
|
|---|
| 247 | INTEGRAL_FMT_DECL( int128, 'd' )
|
|---|
| 248 | INTEGRAL_FMT_DECL( unsigned int128, 'u' )
|
|---|
| 249 | #endif // __SIZEOF_INT128__
|
|---|
| 250 |
|
|---|
| 251 | // *********************************** floating point ***********************************
|
|---|
| 252 |
|
|---|
| 253 | // Default suffix for values with no fraction is "."
|
|---|
| 254 | #define FLOATING_POINT_FMT_DECL( T ) \
|
|---|
| 255 | static inline { \
|
|---|
| 256 | _Ostream_Manip(T) hex( T val ) { return (_Ostream_Manip(T))@{ .val = val, .wd = 1, .pc = 0, .base = 'a', { .all = 0 } }; } \
|
|---|
| 257 | _Ostream_Manip(T) sci( T val ) { return (_Ostream_Manip(T))@{ .val = val, .wd = 1, .pc = 0, .base = 'e', { .all = 0 } }; } \
|
|---|
| 258 | _Ostream_Manip(T) eng( T val ) { return (_Ostream_Manip(T))@{ .val = val, 1, -1, .base = 'g', { .flags.eng = true } }; } \
|
|---|
| 259 | _Ostream_Manip(T) wd( unsigned int wd, T val ) { return (_Ostream_Manip(T))@{ .val = val, .wd = wd, .pc = 0, .base = 'g', { .all = 0 } }; } \
|
|---|
| 260 | _Ostream_Manip(T) wd( unsigned int wd, unsigned int pc, T val ) { return (_Ostream_Manip(T))@{ .val = val, .wd = wd, .pc = pc, .base = 'f', { .flags.pc = true } }; } \
|
|---|
| 261 | _Ostream_Manip(T) ws( unsigned int wd, unsigned int pc, T val ) { return (_Ostream_Manip(T))@{ .val = val, .wd = wd, .pc = pc, .base = 'g', { .flags.pc = true } }; } \
|
|---|
| 262 | _Ostream_Manip(T) & wd( unsigned int wd, _Ostream_Manip(T) & fmt ) { if ( fmt.flags.eng ) fmt.base = 'f'; fmt.wd = wd; return fmt; } \
|
|---|
| 263 | _Ostream_Manip(T) & wd( unsigned int wd, unsigned int pc, _Ostream_Manip(T) & fmt ) { \
|
|---|
| 264 | if ( fmt.flags.eng ) fmt.base = 'f'; fmt.wd = wd; fmt.pc = pc; fmt.flags.pc = true; return fmt; } \
|
|---|
| 265 | _Ostream_Manip(T) & ws( unsigned int wd, unsigned int pc, _Ostream_Manip(T) & fmt ) { fmt.wd = wd; fmt.pc = pc; fmt.flags.pc = true; return fmt; } \
|
|---|
| 266 | _Ostream_Manip(T) & left( _Ostream_Manip(T) & fmt ) { fmt.flags.left = true; return fmt; } \
|
|---|
| 267 | _Ostream_Manip(T) upcase( T val ) { return (_Ostream_Manip(T))@{ .val = val, .wd = 1, .pc = 0, .base = 'G', { .all = 0 } }; } \
|
|---|
| 268 | _Ostream_Manip(T) & upcase( _Ostream_Manip(T) & fmt ) { fmt.base -= 32; /* upper case */ return fmt; } \
|
|---|
| 269 | _Ostream_Manip(T) & pad0( _Ostream_Manip(T) & fmt ) { fmt.flags.pad0 = true; return fmt; } \
|
|---|
| 270 | _Ostream_Manip(T) sign( T val ) { return (_Ostream_Manip(T))@{ .val = val, .wd = 1, .pc = 0, .base = 'g', { .flags.sign = true } }; } \
|
|---|
| 271 | _Ostream_Manip(T) & sign( _Ostream_Manip(T) & fmt ) { fmt.flags.sign = true; return fmt; } \
|
|---|
| 272 | _Ostream_Manip(T) nodp( T val ) { return (_Ostream_Manip(T))@{ .val = val, .wd = 1, .pc = 0, .base = 'g', { .flags.nobsdp = true } }; } \
|
|---|
| 273 | _Ostream_Manip(T) & nodp( _Ostream_Manip(T) & fmt ) { fmt.flags.nobsdp = true; return fmt; } \
|
|---|
| 274 | _Ostream_Manip(T) unit( T val ) { return (_Ostream_Manip(T))@{ .val = val, .wd = 1, .pc = 0, .base = 'g', { .flags.nobsdp = true } }; } \
|
|---|
| 275 | _Ostream_Manip(T) & unit( _Ostream_Manip(T) & fmt ) { fmt.flags.nobsdp = true; return fmt; } \
|
|---|
| 276 | } /* distribution */ \
|
|---|
| 277 | forall( ostype & | basic_ostream( ostype ) ) { \
|
|---|
| 278 | ostype & ?|?( ostype & os, _Ostream_Manip(T) f ); \
|
|---|
| 279 | OSTYPE_VOID( _Ostream_Manip(T) ); \
|
|---|
| 280 | } // ?|?
|
|---|
| 281 |
|
|---|
| 282 | FLOATING_POINT_FMT_DECL( double )
|
|---|
| 283 | FLOATING_POINT_FMT_DECL( long double )
|
|---|
| 284 |
|
|---|
| 285 | // *********************************** character ***********************************
|
|---|
| 286 |
|
|---|
| 287 | static inline {
|
|---|
| 288 | _Ostream_Manip(char) bin( char c ) { return (_Ostream_Manip(char))@{ .val = c, .wd = 1, .pc = 0, .base = 'b', { .all = 0 } }; }
|
|---|
| 289 | _Ostream_Manip(char) oct( char c ) { return (_Ostream_Manip(char))@{ .val = c, .wd = 1, .pc = 0, .base = 'o', { .all = 0 } }; }
|
|---|
| 290 | _Ostream_Manip(char) hex( char c ) { return (_Ostream_Manip(char))@{ .val = c, .wd = 1, .pc = 0, .base = 'x', { .all = 0 } }; }
|
|---|
| 291 | _Ostream_Manip(char) quote( char c ) { return (_Ostream_Manip(char))@{ .val = c, .wd = 1, .pc = 0, .base = 'c', { .flags.quote = true } }; }
|
|---|
| 292 | _Ostream_Manip(char) wd( unsigned int wd, char c ) { return (_Ostream_Manip(char))@{ .val = c, .wd = wd, .pc = 0, .base = 'c', { .all = 0 } }; }
|
|---|
| 293 | _Ostream_Manip(char) & wd( unsigned int wd, _Ostream_Manip(char) & fmt ) { fmt.wd = wd; return fmt; }
|
|---|
| 294 | _Ostream_Manip(char) & left( _Ostream_Manip(char) & fmt ) { fmt.flags.left = true; return fmt; }
|
|---|
| 295 | _Ostream_Manip(char) & upcase( _Ostream_Manip(char) & fmt ) { if ( fmt.base == 'x' || fmt.base == 'b' ) fmt.base -= 32; /* upper case */ return fmt; }
|
|---|
| 296 | _Ostream_Manip(char) & nobase( _Ostream_Manip(char) & fmt ) { fmt.flags.nobsdp = true; return fmt; }
|
|---|
| 297 | _Ostream_Manip(char) & quote( _Ostream_Manip(char) & fmt ) { fmt.flags.quote = true; return fmt; }
|
|---|
| 298 | } // distribution
|
|---|
| 299 | forall( ostype & | basic_ostream( ostype ) ) {
|
|---|
| 300 | ostype & ?|?( ostype & os, _Ostream_Manip(char) f );
|
|---|
| 301 | OSTYPE_VOID( _Ostream_Manip(char) ); \
|
|---|
| 302 | } // ?|?
|
|---|
| 303 |
|
|---|
| 304 | // *********************************** C string ***********************************
|
|---|
| 305 |
|
|---|
| 306 | static inline {
|
|---|
| 307 | _Ostream_Manip(const char *) bin( const char s[] ) { return (_Ostream_Manip(const char *))@{ .val = s, .wd = 1, .pc = 0, .base = 'b', { .all = 0 } }; }
|
|---|
| 308 | _Ostream_Manip(const char *) oct( const char s[] ) { return (_Ostream_Manip(const char *))@{ .val = s, .wd = 1, .pc = 0, .base = 'o', { .all = 0 } }; }
|
|---|
| 309 | _Ostream_Manip(const char *) hex( const char s[] ) { return (_Ostream_Manip(const char *))@{ .val = s, .wd = 1, .pc = 0, .base = 'x', { .all = 0 } }; }
|
|---|
| 310 | _Ostream_Manip(const char *) quote( const char s[] ) { return (_Ostream_Manip(const char *))@{ .val = s, .wd = 1, .pc = 0, .base = 's', { .flags.quote = true } }; }
|
|---|
| 311 | _Ostream_Manip(const char *) wd( unsigned int wd, const char s[] ) { return (_Ostream_Manip(const char *))@{ .val = s, .wd = wd, .pc = 0, .base = 's', { .all = 0 } }; }
|
|---|
| 312 | _Ostream_Manip(const char *) wd( unsigned int wd, unsigned int pc, const char s[] ) { return (_Ostream_Manip(const char *))@{ .val = s, .wd = wd, .pc = pc, .base = 's', { .flags.pc = true } }; }
|
|---|
| 313 | _Ostream_Manip(const char *) & wd( unsigned int wd, _Ostream_Manip(const char *) & fmt ) { fmt.wd = wd; return fmt; }
|
|---|
| 314 | _Ostream_Manip(const char *) & wd( unsigned int wd, unsigned int pc, _Ostream_Manip(const char *) & fmt ) { fmt.wd = wd; fmt.pc = pc; fmt.flags.pc = true; return fmt; }
|
|---|
| 315 | _Ostream_Manip(const char *) & left( _Ostream_Manip(const char *) & fmt ) { fmt.flags.left = true; return fmt; }
|
|---|
| 316 | _Ostream_Manip(const char *) & upcase( _Ostream_Manip(const char *) & fmt ) { if ( fmt.base == 'x' || fmt.base == 'b' ) fmt.base -= 32; /* upper case */ return fmt; }
|
|---|
| 317 | _Ostream_Manip(const char *) & nobase( _Ostream_Manip(const char *) & fmt ) { fmt.flags.nobsdp = true; return fmt; }
|
|---|
| 318 | _Ostream_Manip(const char *) & quote( _Ostream_Manip(const char *) & fmt ) { fmt.flags.quote = true; return fmt; } \
|
|---|
| 319 | } // distribution
|
|---|
| 320 | forall( ostype & | basic_ostream( ostype ) ) {
|
|---|
| 321 | ostype & ?|?( ostype & os, _Ostream_Manip(const char *) f );
|
|---|
| 322 | OSTYPE_VOID( _Ostream_Manip(const char *) ); \
|
|---|
| 323 | } // ?|?
|
|---|
| 324 |
|
|---|
| 325 |
|
|---|
| 326 | // *********************************** istream ***********************************
|
|---|
| 327 |
|
|---|
| 328 |
|
|---|
| 329 | forall( istype & )
|
|---|
| 330 | struct basic_istream_data {
|
|---|
| 331 | // private
|
|---|
| 332 | bool (*getANL$)( istype & ); // get scan newline (on/off)
|
|---|
| 333 | bool (*setANL$)( istype &, bool ); // set scan newline (on/off)
|
|---|
| 334 | // public
|
|---|
| 335 | void (*nlOn)( istype & ); // read newline
|
|---|
| 336 | void (*nlOff)( istype & ); // scan newline
|
|---|
| 337 | int (*fmt)( istype &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
|
|---|
| 338 | istype & (*ungetc)( char, istype & );
|
|---|
| 339 | bool (*eof)( istype & );
|
|---|
| 340 | void (*clearerr)( istype & );
|
|---|
| 341 | }; // basic_istream
|
|---|
| 342 |
|
|---|
| 343 | forall( istype & )
|
|---|
| 344 | struct istream_data {
|
|---|
| 345 | inline basic_istream_data( istype );
|
|---|
| 346 | bool (*fail)( istype & );
|
|---|
| 347 | void (*open)( istype & is, const char name[], const char mode[] );
|
|---|
| 348 | void (*open)( istype & is, const char name[] );
|
|---|
| 349 | void (*close)( istype & is );
|
|---|
| 350 | istype & (*read)( istype &, char [], size_t );
|
|---|
| 351 | }; // istream
|
|---|
| 352 |
|
|---|
| 353 | forall( istype & )
|
|---|
| 354 | trait basic_istream {
|
|---|
| 355 | basic_istream_data(istype) const & basic_istream_table;
|
|---|
| 356 | };
|
|---|
| 357 |
|
|---|
| 358 | forall( istype & | basic_istream( istype ) )
|
|---|
| 359 | trait istream {
|
|---|
| 360 | istream_data(istype) const & istream_table;
|
|---|
| 361 | };
|
|---|
| 362 |
|
|---|
| 363 | forall( T )
|
|---|
| 364 | trait readable {
|
|---|
| 365 | forall( istype & | istream( istype ) ) istype & ?|?( istype &, T );
|
|---|
| 366 | }; // readable
|
|---|
| 367 |
|
|---|
| 368 | forall( istype & | basic_istream( istype ) ) {
|
|---|
| 369 | istype & ?|?( istype &, bool & );
|
|---|
| 370 |
|
|---|
| 371 | istype & ?|?( istype &, char & );
|
|---|
| 372 | istype & ?|?( istype &, signed char & );
|
|---|
| 373 | istype & ?|?( istype &, unsigned char & );
|
|---|
| 374 |
|
|---|
| 375 | istype & ?|?( istype &, short int & );
|
|---|
| 376 | istype & ?|?( istype &, unsigned short int & );
|
|---|
| 377 | istype & ?|?( istype &, int & );
|
|---|
| 378 | istype & ?|?( istype &, unsigned int & );
|
|---|
| 379 | istype & ?|?( istype &, long int & );
|
|---|
| 380 | istype & ?|?( istype &, unsigned long int & );
|
|---|
| 381 | istype & ?|?( istype &, long long int & );
|
|---|
| 382 | istype & ?|?( istype &, unsigned long long int & );
|
|---|
| 383 | #if defined( __SIZEOF_INT128__ )
|
|---|
| 384 | istype & ?|?( istype &, int128 & );
|
|---|
| 385 | istype & ?|?( istype &, unsigned int128 & );
|
|---|
| 386 | #endif // __SIZEOF_INT128__
|
|---|
| 387 |
|
|---|
| 388 | istype & ?|?( istype &, float & );
|
|---|
| 389 | istype & ?|?( istype &, double & );
|
|---|
| 390 | istype & ?|?( istype &, long double & );
|
|---|
| 391 |
|
|---|
| 392 | istype & ?|?( istype &, float _Complex & );
|
|---|
| 393 | istype & ?|?( istype &, double _Complex & );
|
|---|
| 394 | istype & ?|?( istype &, long double _Complex & );
|
|---|
| 395 |
|
|---|
| 396 | // This is too restrictive as it prevents building a format in a string and using that format.
|
|---|
| 397 | // inline istype & ?|?( istype &, char [] ) { // possible error, too restrictive to change
|
|---|
| 398 | // _Static_assert( false, "reading a character array without a maximum length is unsafe. Use input manipulator \"wdi( N, s )\", where \"char s[N]\" or fmt( s )." );
|
|---|
| 399 | // }
|
|---|
| 400 | istype & ?|?( istype &, const char [] ); // match text
|
|---|
| 401 |
|
|---|
| 402 | // manipulators
|
|---|
| 403 | istype & ?|?( istype &, istype & (*)( istype & ) );
|
|---|
| 404 | istype & nl( istype & is );
|
|---|
| 405 | istype & nlOn( istype & );
|
|---|
| 406 | istype & nlOff( istype & );
|
|---|
| 407 | } // distribution
|
|---|
| 408 |
|
|---|
| 409 | // *********************************** exceptions ***********************************
|
|---|
| 410 |
|
|---|
| 411 | ExceptionDecl( end_of_file ); // read encounters end of file
|
|---|
| 412 | ExceptionDecl( missing_data ); // read finds no appropriate data
|
|---|
| 413 | ExceptionDecl( cstring_length ); // character string size exceeded
|
|---|
| 414 | ExceptionDecl( data_range ); // value too large for numerical type
|
|---|
| 415 |
|
|---|
| 416 | // *********************************** manipulators ***********************************
|
|---|
| 417 |
|
|---|
| 418 | // skip does not compose with other C string manipulators.
|
|---|
| 419 | struct _Istream_Cskip {
|
|---|
| 420 | const char * scanset;
|
|---|
| 421 | unsigned wd; // scan width
|
|---|
| 422 | }; // _Istream_Cskip
|
|---|
| 423 |
|
|---|
| 424 | static inline {
|
|---|
| 425 | _Istream_Cskip skip( const char scanset[] ) { return (_Istream_Cskip)@{ .scanset = scanset, .wd = 0 }; }
|
|---|
| 426 | _Istream_Cskip skip( unsigned int wd ) { return (_Istream_Cskip)@{ .scanset = 0p, .wd = wd }; }
|
|---|
| 427 | } // distribution
|
|---|
| 428 |
|
|---|
| 429 | struct _Istream_str_base {
|
|---|
| 430 | union {
|
|---|
| 431 | const char * scanset;
|
|---|
| 432 | char delimiters[3]; // [0] => left, [1] => right
|
|---|
| 433 | };
|
|---|
| 434 | int wd; // width
|
|---|
| 435 | union {
|
|---|
| 436 | unsigned char all;
|
|---|
| 437 | struct {
|
|---|
| 438 | unsigned char ignore:1; // do not change input argument
|
|---|
| 439 | unsigned char inex:1; // include/exclude characters in scanset
|
|---|
| 440 | unsigned char delimiter:1; // delimit character(s)
|
|---|
| 441 | unsigned char rwd:1; // read width
|
|---|
| 442 | } flags;
|
|---|
| 443 | };
|
|---|
| 444 | }; // _Istream_str_base
|
|---|
| 445 |
|
|---|
| 446 | struct _Istream_Cwidth {
|
|---|
| 447 | char * s;
|
|---|
| 448 | inline _Istream_str_base;
|
|---|
| 449 | }; // _Istream_Cwidth
|
|---|
| 450 |
|
|---|
| 451 | // Restrict nesting of input manipulators to those combinations that make sense.
|
|---|
| 452 |
|
|---|
| 453 | struct _Istream_Cquote {
|
|---|
| 454 | _Istream_Cwidth cstr;
|
|---|
| 455 | }; // _Istream_Cquote
|
|---|
| 456 |
|
|---|
| 457 | struct _Istream_Cstr {
|
|---|
| 458 | _Istream_Cwidth cstr;
|
|---|
| 459 | }; // _Istream_Cstr
|
|---|
| 460 |
|
|---|
| 461 | static inline {
|
|---|
| 462 | // width must include room for null terminator, (gcc) scanf does not allow a 0 width => wd > 1 (1 char and null) and rd > 0 (1 char);
|
|---|
| 463 | _Istream_Cwidth wdi( unsigned int wd, char s[] ) {
|
|---|
| 464 | if ( wd <= 1 ) throwResume ExceptionInst( cstring_length ); // minimum 1 character and null terminator
|
|---|
| 465 | return (_Istream_Cwidth)@{ .s = s, { {.scanset = 0p}, .wd = wd, {.all = 0} } };
|
|---|
| 466 | }
|
|---|
| 467 | _Istream_Cwidth wdi( unsigned int wd, unsigned int rwd, char s[] ) {
|
|---|
| 468 | if ( wd <= 1 || wd <= rwd ) throwResume ExceptionInst( cstring_length ); // minimum 1 character, null terminator, plus subset
|
|---|
| 469 | return (_Istream_Cwidth)@{ .s = s, { {.scanset = 0p}, .wd = rwd, {.flags.rwd = true} } };
|
|---|
| 470 | }
|
|---|
| 471 | _Istream_Cstr & getline( _Istream_Cwidth & f, const char delimiter = '\n' ) {
|
|---|
| 472 | f.delimiters[0] = delimiter; f.delimiters[1] = '\0'; f.flags.delimiter = true; return (_Istream_Cstr &)f;
|
|---|
| 473 | }
|
|---|
| 474 | _Istream_Cquote quote( char & ch, const char Ldelimiter = '\'', const char Rdelimiter = '\0' ) {
|
|---|
| 475 | return (_Istream_Cquote)@{ { .s = &ch, { {.delimiters = { Ldelimiter, Rdelimiter, '\1' }}, .wd = 1, {.flags.rwd = true} } } };
|
|---|
| 476 | }
|
|---|
| 477 | _Istream_Cquote & quote( _Istream_Cwidth & f, const char Ldelimiter = '"', const char Rdelimiter = '\0' ) {
|
|---|
| 478 | f.delimiters[0] = Ldelimiter; f.delimiters[1] = Rdelimiter; f.delimiters[2] = '\0';
|
|---|
| 479 | return (_Istream_Cquote &)f;
|
|---|
| 480 | }
|
|---|
| 481 | _Istream_Cstr & incl( const char scanset[], _Istream_Cwidth & f ) { f.scanset = scanset; f.flags.inex = false; return (_Istream_Cstr &)f; }
|
|---|
| 482 | _Istream_Cstr & excl( const char scanset[], _Istream_Cwidth & f ) { f.scanset = scanset; f.flags.inex = true; return (_Istream_Cstr &)f; }
|
|---|
| 483 | _Istream_Cstr ignore( const char s[] ) { return (_Istream_Cstr)@{ { .s = (char *)s, { {.scanset = 0p}, .wd = -1, {.flags.ignore = true} } } }; }
|
|---|
| 484 | _Istream_Cstr & ignore( _Istream_Cwidth & f ) { f.flags.ignore = true; return (_Istream_Cstr &)f; }
|
|---|
| 485 | _Istream_Cquote & ignore( _Istream_Cquote & f ) { f.cstr.flags.ignore = true; return (_Istream_Cquote &)f; }
|
|---|
| 486 | _Istream_Cstr & ignore( _Istream_Cstr & f ) { f.cstr.flags.ignore = true; return (_Istream_Cstr &)f; }
|
|---|
| 487 | } // distribution
|
|---|
| 488 |
|
|---|
| 489 | forall( istype & | basic_istream( istype ) ) {
|
|---|
| 490 | istype & ?|?( istype & is, _Istream_Cskip f );
|
|---|
| 491 | istype & ?|?( istype & is, _Istream_Cquote f );
|
|---|
| 492 | istype & ?|?( istype & is, _Istream_Cstr f );
|
|---|
| 493 | static inline istype & ?|?( istype & is, _Istream_Cwidth f ) { return is | *(_Istream_Cstr *)&f; }
|
|---|
| 494 | } // distribution
|
|---|
| 495 |
|
|---|
| 496 | // FIXME: `| sized(T)` seems to be working around a bug, but it is logically unnecessary.
|
|---|
| 497 | // Including sized(T) causes a warning that is telling us to get rid of it.
|
|---|
| 498 | #pragma GCC diagnostic push
|
|---|
| 499 | #pragma GCC diagnostic ignored "-Wunused-parameter"
|
|---|
| 500 | forall( T & | sized(T) )
|
|---|
| 501 | struct _Istream_Manip {
|
|---|
| 502 | T & val; // polymorphic base-type
|
|---|
| 503 | int wd; // width
|
|---|
| 504 | bool ignore; // do not change input argument
|
|---|
| 505 | }; // _Istream_Manip
|
|---|
| 506 | #pragma GCC diagnostic pop
|
|---|
| 507 |
|
|---|
| 508 | #define INPUT_FMT_DECL( T ) \
|
|---|
| 509 | static inline { \
|
|---|
| 510 | _Istream_Manip(T) wdi( unsigned int wd, T & val ) { return (_Istream_Manip(T))@{ .val = val, .wd = wd, .ignore = false }; } \
|
|---|
| 511 | _Istream_Manip(T) ignore( const T & val ) { return (_Istream_Manip(T))@{ .val = (T &)val, .wd = -1, .ignore = true }; } \
|
|---|
| 512 | _Istream_Manip(T) & ignore( _Istream_Manip(T) & fmt ) { fmt.ignore = true; return fmt; } \
|
|---|
| 513 | } /* distribution */ \
|
|---|
| 514 | forall( istype & | basic_istream( istype ) ) { \
|
|---|
| 515 | istype & ?|?( istype & is, _Istream_Manip(T) f ); \
|
|---|
| 516 | } // ?|?
|
|---|
| 517 |
|
|---|
| 518 | INPUT_FMT_DECL( char )
|
|---|
| 519 | INPUT_FMT_DECL( signed char )
|
|---|
| 520 | INPUT_FMT_DECL( unsigned char )
|
|---|
| 521 | INPUT_FMT_DECL( signed short int )
|
|---|
| 522 | INPUT_FMT_DECL( unsigned short int )
|
|---|
| 523 | INPUT_FMT_DECL( signed int )
|
|---|
| 524 | INPUT_FMT_DECL( unsigned int )
|
|---|
| 525 | INPUT_FMT_DECL( signed long int )
|
|---|
| 526 | INPUT_FMT_DECL( unsigned long int )
|
|---|
| 527 | INPUT_FMT_DECL( signed long long int )
|
|---|
| 528 | INPUT_FMT_DECL( unsigned long long int )
|
|---|
| 529 |
|
|---|
| 530 | INPUT_FMT_DECL( float )
|
|---|
| 531 | INPUT_FMT_DECL( double )
|
|---|
| 532 | INPUT_FMT_DECL( long double )
|
|---|
| 533 |
|
|---|
| 534 | INPUT_FMT_DECL( float _Complex )
|
|---|
| 535 | INPUT_FMT_DECL( double _Complex )
|
|---|
| 536 | INPUT_FMT_DECL( long double _Complex )
|
|---|
| 537 |
|
|---|
| 538 | // *********************************** enumerations ***********************************
|
|---|
| 539 |
|
|---|
| 540 | forall( istype & | istream( istype ), E | CfaEnum( E ) | Serial(E) )
|
|---|
| 541 | istype & ?|?( istype &, E & );
|
|---|
| 542 |
|
|---|
| 543 | forall( ostype & | ostream( ostype ), E | CfaEnum( E ) ) {
|
|---|
| 544 | ostype & ?|?( ostype &, E );
|
|---|
| 545 | OSTYPE_VOID( E );
|
|---|
| 546 | }
|
|---|
| 547 |
|
|---|
| 548 | // *********************************** time ***********************************
|
|---|
| 549 |
|
|---|
| 550 | #include <time_t.hfa> // Duration (constructors) / Time (constructors)
|
|---|
| 551 |
|
|---|
| 552 | forall( ostype & | ostream( ostype ) ) {
|
|---|
| 553 | ostype & ?|?( ostype & os, Duration dur );
|
|---|
| 554 | OSTYPE_VOID( Duration );
|
|---|
| 555 | ostype & ?|?( ostype & os, Time time );
|
|---|
| 556 | OSTYPE_VOID( Time );
|
|---|
| 557 | } // distribution
|
|---|
| 558 |
|
|---|
| 559 | // Local Variables: //
|
|---|
| 560 | // tab-width: 4 //
|
|---|
| 561 | // End: //
|
|---|
