Changeset eef8dfb for libcfa/src/iostream.cfa
- Timestamp:
- Jan 7, 2021, 2:55:57 PM (5 years ago)
- Branches:
- ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum
- Children:
- 58fe85a
- Parents:
- bdfc032 (diff), 44e37ef (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the(diff)links above to see all the changes relative to each parent. - File:
-
- 1 edited
-
libcfa/src/iostream.cfa (modified) (44 diffs)
Legend:
- Unmodified
- Added
- Removed
-
libcfa/src/iostream.cfa
rbdfc032 reef8dfb 10 10 // Created On : Wed May 27 17:56:53 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Sat Jul 13 08:07:59 201913 // Update Count : 82112 // Last Modified On : Mon Aug 24 08:31:35 2020 13 // Update Count : 1130 14 14 // 15 15 16 16 #include "iostream.hfa" 17 17 18 extern "C" {19 18 #include <stdio.h> 20 19 #include <stdbool.h> // true/false 21 //#include <string.h> // strlen, strcmp 20 #include <stdint.h> // UINT64_MAX 21 #include <float.h> // DBL_DIG, LDBL_DIG 22 #include <complex.h> // creal, cimag 23 //#include <string.h> // strlen, strcmp, memcpy 24 extern "C" { 22 25 extern size_t strlen (const char *__s) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); 23 26 extern int strcmp (const char *__s1, const char *__s2) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); 24 27 extern char *strcpy (char *__restrict __dest, const char *__restrict __src) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); 25 28 extern void *memcpy (void *__restrict __dest, const void *__restrict __src, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); 26 #include <float.h> // DBL_DIG, LDBL_DIG27 #include <math.h> // isfinite28 #include <complex.h> // creal, cimag29 29 } // extern "C" 30 30 31 32 //*********************************** ostream *********************************** 31 #include "math.hfa" // isfinite, floor, ceiling_div 32 #include "bitmanip.hfa" // high1 33 34 35 // *********************************** ostream *********************************** 33 36 34 37 35 38 forall( dtype ostype | ostream( ostype ) ) { 36 ostype & ?|?( ostype & os, zero_t ) {37 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );38 fmt( os, "%d", 0n );39 return os;40 } // ?|?41 void ?|?( ostype & os, zero_t z ) {42 (ostype &)(os | z); ends( os );43 } // ?|?44 45 ostype & ?|?( ostype & os, one_t ) {46 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );47 fmt( os, "%d", 1n );48 return os;49 } // ?|?50 void ?|?( ostype & os, one_t o ) {51 (ostype &)(os | o); ends( os );52 } // ?|?53 54 39 ostype & ?|?( ostype & os, bool b ) { 55 if ( sepPrt( os ) ) fmt( os, "%s",sepGetCur( os ) );40 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); 56 41 fmt( os, "%s", b ? "true" : "false" ); 57 42 return os; … … 63 48 ostype & ?|?( ostype & os, char c ) { 64 49 fmt( os, "%c", c ); 65 if ( c == '\n' ) setNL( os, true );50 if ( c == '\n' ) $setNL( os, true ); 66 51 return sepOff( os ); 67 52 } // ?|? … … 71 56 72 57 ostype & ?|?( ostype & os, signed char sc ) { 73 if ( sepPrt( os ) ) fmt( os, "%s",sepGetCur( os ) );58 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); 74 59 fmt( os, "%hhd", sc ); 75 60 return os; … … 80 65 81 66 ostype & ?|?( ostype & os, unsigned char usc ) { 82 if ( sepPrt( os ) ) fmt( os, "%s",sepGetCur( os ) );67 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); 83 68 fmt( os, "%hhu", usc ); 84 69 return os; … … 89 74 90 75 ostype & ?|?( ostype & os, short int si ) { 91 if ( sepPrt( os ) ) fmt( os, "%s",sepGetCur( os ) );76 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); 92 77 fmt( os, "%hd", si ); 93 78 return os; … … 98 83 99 84 ostype & ?|?( ostype & os, unsigned short int usi ) { 100 if ( sepPrt( os ) ) fmt( os, "%s",sepGetCur( os ) );85 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); 101 86 fmt( os, "%hu", usi ); 102 87 return os; … … 107 92 108 93 ostype & ?|?( ostype & os, int i ) { 109 if ( sepPrt( os ) ) fmt( os, "%s",sepGetCur( os ) );94 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); 110 95 fmt( os, "%d", i ); 111 96 return os; … … 116 101 117 102 ostype & ?|?( ostype & os, unsigned int ui ) { 118 if ( sepPrt( os ) ) fmt( os, "%s",sepGetCur( os ) );103 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); 119 104 fmt( os, "%u", ui ); 120 105 return os; … … 125 110 126 111 ostype & ?|?( ostype & os, long int li ) { 127 if ( sepPrt( os ) ) fmt( os, "%s",sepGetCur( os ) );112 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); 128 113 fmt( os, "%ld", li ); 129 114 return os; … … 134 119 135 120 ostype & ?|?( ostype & os, unsigned long int uli ) { 136 if ( sepPrt( os ) ) fmt( os, "%s",sepGetCur( os ) );121 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); 137 122 fmt( os, "%lu", uli ); 138 123 return os; … … 143 128 144 129 ostype & ?|?( ostype & os, long long int lli ) { 145 if ( sepPrt( os ) ) fmt( os, "%s",sepGetCur( os ) );130 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); 146 131 fmt( os, "%lld", lli ); 147 132 return os; … … 152 137 153 138 ostype & ?|?( ostype & os, unsigned long long int ulli ) { 154 if ( sepPrt( os ) ) fmt( os, "%s",sepGetCur( os ) );139 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); 155 140 fmt( os, "%llu", ulli ); 156 141 return os; … … 159 144 (ostype &)(os | ulli); ends( os ); 160 145 } // ?|? 146 147 #if defined( __SIZEOF_INT128__ ) 148 // UINT64_MAX 18_446_744_073_709_551_615_ULL 149 #define P10_UINT64 10_000_000_000_000_000_000_ULL // 19 zeroes 150 151 static inline void base10_128( ostype & os, unsigned int128 val ) { 152 #if defined(__GNUC__) && __GNUC_PREREQ(7,0) // gcc version >= 7 153 if ( val > P10_UINT64 ) { 154 #else 155 if ( (uint64_t)(val >> 64) != 0 || (uint64_t)val > P10_UINT64 ) { // patch gcc 5 & 6 -O3 bug 156 #endif // __GNUC_PREREQ(7,0) 157 base10_128( os, val / P10_UINT64 ); // recursive 158 fmt( os, "%.19lu", (uint64_t)(val % P10_UINT64) ); 159 } else { 160 fmt( os, "%lu", (uint64_t)val ); 161 } // if 162 } // base10_128 163 164 static inline void base10_128( ostype & os, int128 val ) { 165 if ( val < 0 ) { 166 fmt( os, "-" ); // leading negative sign 167 val = -val; 168 } // if 169 base10_128( os, (unsigned int128)val ); // print zero/positive value 170 } // base10_128 171 172 ostype & ?|?( ostype & os, int128 llli ) { 173 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); 174 base10_128( os, llli ); 175 return os; 176 } // ?|? 177 void & ?|?( ostype & os, int128 llli ) { 178 (ostype &)(os | llli); ends( os ); 179 } // ?|? 180 181 ostype & ?|?( ostype & os, unsigned int128 ullli ) { 182 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); 183 base10_128( os, ullli ); 184 return os; 185 } // ?|? 186 void & ?|?( ostype & os, unsigned int128 ullli ) { 187 (ostype &)(os | ullli); ends( os ); 188 } // ?|? 189 #endif // __SIZEOF_INT128__ 161 190 162 191 #define PrintWithDP( os, format, val, ... ) \ … … 175 204 176 205 ostype & ?|?( ostype & os, float f ) { 177 if ( sepPrt( os ) ) fmt( os, "%s",sepGetCur( os ) );206 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); 178 207 PrintWithDP( os, "%g", f ); 179 208 return os; … … 184 213 185 214 ostype & ?|?( ostype & os, double d ) { 186 if ( sepPrt( os ) ) fmt( os, "%s",sepGetCur( os ) );215 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); 187 216 PrintWithDP( os, "%.*lg", d, DBL_DIG ); 188 217 return os; … … 193 222 194 223 ostype & ?|?( ostype & os, long double ld ) { 195 if ( sepPrt( os ) ) fmt( os, "%s",sepGetCur( os ) );224 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); 196 225 PrintWithDP( os, "%.*Lg", ld, LDBL_DIG ); 197 226 return os; … … 202 231 203 232 ostype & ?|?( ostype & os, float _Complex fc ) { 204 if ( sepPrt( os ) ) fmt( os, "%s",sepGetCur( os ) );233 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); 205 234 // os | crealf( fc ) | nonl; 206 235 PrintWithDP( os, "%g", crealf( fc ) ); … … 214 243 215 244 ostype & ?|?( ostype & os, double _Complex dc ) { 216 if ( sepPrt( os ) ) fmt( os, "%s",sepGetCur( os ) );245 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); 217 246 // os | creal( dc ) | nonl; 218 247 PrintWithDP( os, "%.*lg", creal( dc ), DBL_DIG ); … … 226 255 227 256 ostype & ?|?( ostype & os, long double _Complex ldc ) { 228 if ( sepPrt( os ) ) fmt( os, "%s",sepGetCur( os ) );257 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); 229 258 // os | creall( ldc ) || nonl; 230 259 PrintWithDP( os, "%.*Lg", creall( ldc ), LDBL_DIG ); … … 237 266 } // ?|? 238 267 239 ostype & ?|?( ostype & os, const char * str) {268 ostype & ?|?( ostype & os, const char str[] ) { 240 269 enum { Open = 1, Close, OpenClose }; 241 270 static const unsigned char mask[256] @= { … … 257 286 // first character IS NOT spacing or closing punctuation => add left separator 258 287 unsigned char ch = str[0]; // must make unsigned 259 if ( sepPrt( os ) && mask[ ch ] != Close && mask[ ch ] != OpenClose ) {260 fmt( os, "%s", sepGetCur( os ) );288 if ( $sepPrt( os ) && mask[ ch ] != Close && mask[ ch ] != OpenClose ) { 289 fmt( os, "%s", $sepGetCur( os ) ); 261 290 } // if 262 291 263 292 // if string starts line, must reset to determine open state because separator is off 264 sepReset( os );// reset separator293 $sepReset( os ); // reset separator 265 294 266 295 // last character IS spacing or opening punctuation => turn off separator for next item 267 296 size_t len = strlen( str ); 268 297 ch = str[len - 1]; // must make unsigned 269 if ( sepPrt( os ) && mask[ ch ] != Open && mask[ ch ] != OpenClose ) {298 if ( $sepPrt( os ) && mask[ ch ] != Open && mask[ ch ] != OpenClose ) { 270 299 sepOn( os ); 271 300 } else { 272 301 sepOff( os ); 273 302 } // if 274 if ( ch == '\n' ) setNL( os, true ); // check *AFTER*sepPrt call above as it resets NL flag303 if ( ch == '\n' ) $setNL( os, true ); // check *AFTER* $sepPrt call above as it resets NL flag 275 304 return write( os, str, len ); 276 305 } // ?|? 277 void ?|?( ostype & os, const char * str ) { 306 307 void ?|?( ostype & os, const char str[] ) { 278 308 (ostype &)(os | str); ends( os ); 279 309 } // ?|? 280 310 281 311 // ostype & ?|?( ostype & os, const char16_t * str ) { 282 // if ( sepPrt( os ) ) fmt( os, "%s",sepGetCur( os ) );312 // if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); 283 313 // fmt( os, "%ls", str ); 284 314 // return os; … … 287 317 // #if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous 288 318 // ostype & ?|?( ostype & os, const char32_t * str ) { 289 // if ( sepPrt( os ) ) fmt( os, "%s",sepGetCur( os ) );319 // if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); 290 320 // fmt( os, "%ls", str ); 291 321 // return os; … … 294 324 295 325 // ostype & ?|?( ostype & os, const wchar_t * str ) { 296 // if ( sepPrt( os ) ) fmt( os, "%s",sepGetCur( os ) );326 // if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); 297 327 // fmt( os, "%ls", str ); 298 328 // return os; … … 300 330 301 331 ostype & ?|?( ostype & os, const void * p ) { 302 if ( sepPrt( os ) ) fmt( os, "%s",sepGetCur( os ) );332 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); 303 333 fmt( os, "%p", p ); 304 334 return os; … … 315 345 void ?|?( ostype & os, ostype & (* manip)( ostype & ) ) { 316 346 (ostype &)(manip( os )); 317 if ( getPrt( os ) ) ends( os );// something printed ?318 setPrt( os, false ); // turn off347 if ( $getPrt( os ) ) ends( os ); // something printed ? 348 $setPrt( os, false ); // turn off 319 349 } // ?|? 320 350 … … 329 359 ostype & nl( ostype & os ) { 330 360 (ostype &)(os | '\n'); 331 setPrt( os, false ); // turn off332 setNL( os, true );361 $setPrt( os, false ); // turn off 362 $setNL( os, true ); 333 363 flush( os ); 334 364 return sepOff( os ); // prepare for next line … … 336 366 337 367 ostype & nonl( ostype & os ) { 338 setPrt( os, false ); // turn off368 $setPrt( os, false ); // turn off 339 369 return os; 340 370 } // nonl … … 375 405 ostype & ?|?( ostype & os, T arg, Params rest ) { 376 406 (ostype &)(os | arg); // print first argument 377 sepSetCur( os, sepGetTuple( os ) );// switch to tuple separator407 $sepSetCur( os, sepGetTuple( os ) ); // switch to tuple separator 378 408 (ostype &)(os | rest); // print remaining arguments 379 sepSetCur( os, sepGet( os ) ); // switch to regular separator409 $sepSetCur( os, sepGet( os ) ); // switch to regular separator 380 410 return os; 381 411 } // ?|? … … 383 413 // (ostype &)(?|?( os, arg, rest )); ends( os ); 384 414 (ostype &)(os | arg); // print first argument 385 sepSetCur( os, sepGetTuple( os ) );// switch to tuple separator415 $sepSetCur( os, sepGetTuple( os ) ); // switch to tuple separator 386 416 (ostype &)(os | rest); // print remaining arguments 387 sepSetCur( os, sepGet( os ) ); // switch to regular separator417 $sepSetCur( os, sepGet( os ) ); // switch to regular separator 388 418 ends( os ); 389 419 } // ?|? … … 403 433 } // distribution 404 434 405 // *********************************** manipulators ***********************************406 407 // *********************************** integral ***********************************435 // *********************************** manipulators *********************************** 436 437 // *********************************** integral *********************************** 408 438 409 439 static const char * shortbin[] = { "0", "1", "10", "11", "100", "101", "110", "111", "1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111" }; … … 411 441 412 442 // Default prefix for non-decimal prints is 0b, 0, 0x. 413 #define IntegralFMTImpl( T, CODE,IFMTNP, IFMTP ) \443 #define IntegralFMTImpl( T, IFMTNP, IFMTP ) \ 414 444 forall( dtype ostype | ostream( ostype ) ) { \ 415 445 ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \ 416 if ( sepPrt( os ) ) fmt( os, "%s",sepGetCur( os ) ); \446 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); \ 417 447 \ 418 448 if ( f.base == 'b' || f.base == 'B' ) { /* bespoke binary format */ \ 419 int bits; \ 420 if ( f.val == (T){0} ) bits = 1; /* force at least one bit to print */ \ 421 else bits = sizeof(long long int) * 8 - __builtin_clzll( f.val ); /* position of most significant bit */ \ 422 bits = bits > sizeof(f.val) * 8 ? sizeof(f.val) * 8 : bits; \ 423 int spaces = f.wd - bits; /* can be negative */ \ 424 if ( ! f.flags.nobsdp ) { spaces -= 2; } /* base prefix takes space */ \ 425 /* printf( "%d %d\n", bits, spaces ); */ \ 449 int bits = high1( f.val ); /* position of most significant bit */ \ 450 if ( bits == 0 ) bits = 1; /* 0 value => force one bit to print */ \ 451 int spaces; \ 426 452 if ( ! f.flags.left ) { /* right justified ? */ \ 427 453 /* Note, base prefix then zero padding or spacing then prefix. */ \ 428 if ( f.flags.pad0 || f.flags.pc ) { \ 454 if ( f.flags.pc ) { \ 455 spaces = f.wd - f.pc; \ 456 if ( ! f.flags.nobsdp ) { spaces -= 2; } /* base prefix takes space */ \ 457 if ( spaces > 0 ) fmt( os, "%*s", spaces, " " ); /* space pad */ \ 429 458 if ( ! f.flags.nobsdp ) { fmt( os, "0%c", f.base ); } \ 430 if ( f.flags.pc )spaces = f.pc - bits; \459 spaces = f.pc - bits; \ 431 460 if ( spaces > 0 ) fmt( os, "%0*d", spaces, 0 ); /* zero pad */ \ 432 461 } else { \ 433 if ( spaces > 0 ) fmt( os, "%*s", spaces, " " ); /* space pad */ \ 434 if ( ! f.flags.nobsdp ) { fmt( os, "0%c", f.base ); } \ 462 spaces = f.wd - bits; \ 463 if ( ! f.flags.nobsdp ) { spaces -= 2; } /* base prefix takes space */ \ 464 if ( f.flags.pad0 ) { \ 465 if ( ! f.flags.nobsdp ) { fmt( os, "0%c", f.base ); } \ 466 if ( spaces > 0 ) fmt( os, "%0*d", spaces, 0 ); /* zero pad */ \ 467 } else { \ 468 if ( spaces > 0 ) fmt( os, "%*s", spaces, " " ); /* space pad */ \ 469 if ( ! f.flags.nobsdp ) { fmt( os, "0%c", f.base ); } \ 470 } /* if */ \ 435 471 } /* if */ \ 436 } else if ( ! f.flags.nobsdp ) { \ 437 fmt( os, "0%c", f.base ); \ 472 } else { \ 473 if ( ! f.flags.nobsdp ) fmt( os, "0%c", f.base ); \ 474 if ( f.flags.pc ) { \ 475 spaces = f.pc - bits; \ 476 if ( spaces > 0 ) fmt( os, "%0*d", spaces, 0 ); /* zero pad */ \ 477 spaces = f.wd - f.pc; \ 478 } else { /* pad0 flag ignored with left flag */ \ 479 spaces = f.wd - bits; \ 480 } /* if */ \ 481 if ( ! f.flags.nobsdp ) { spaces -= 2; } /* base prefix takes space */ \ 438 482 } /* if */ \ 439 int shift = (bits - 1) / 4 * 4; /* floor( bits - 1, 4 ) */\483 int shift = floor( bits - 1, 4 ); \ 440 484 typeof( f.val ) temp = f.val; \ 441 485 fmt( os, "%s", shortbin[(temp >> shift) & 0xf] ); \ … … 448 492 if ( f.flags.left && spaces > 0 ) fmt( os, "%*s", spaces, " " ); \ 449 493 return os; \ 450 } /* if 494 } /* if */ \ 451 495 \ 452 496 char fmtstr[sizeof(IFMTP)]; /* sizeof includes '\0' */ \ … … 458 502 if ( ! f.flags.nobsdp ) { fmtstr[star] = '#'; star -= 1; } \ 459 503 if ( f.flags.left ) { fmtstr[star] = '-'; star -= 1; } \ 460 if ( f.flags.sign && f.base == CODE) { fmtstr[star] = '+'; star -= 1; } \504 if ( f.flags.sign ) { fmtstr[star] = '+'; star -= 1; } \ 461 505 if ( f.flags.pad0 && ! f.flags.pc ) { fmtstr[star] = '0'; star -= 1; } \ 462 506 fmtstr[star] = '%'; \ 463 507 \ 464 508 if ( ! f.flags.pc ) { /* no precision */ \ 465 /* printf( "%s\n", &fmtstr[star] ); */ \466 509 fmtstr[sizeof(IFMTNP)-2] = f.base; /* sizeof includes '\0' */ \ 510 /* printf( "%s %c\n", &fmtstr[star], f.base ); */ \ 467 511 fmt( os, &fmtstr[star], f.wd, f.val ); \ 468 512 } else { /* precision */ \ 469 513 fmtstr[sizeof(IFMTP)-2] = f.base; /* sizeof includes '\0' */ \ 470 /* printf( "%s \n", &fmtstr[star]); */ \514 /* printf( "%s %c\n", &fmtstr[star], f.base ); */ \ 471 515 fmt( os, &fmtstr[star], f.wd, f.pc, f.val ); \ 472 516 } /* if */ \ … … 476 520 } // distribution 477 521 478 IntegralFMTImpl( signed char, 'd', "% *hh ", "% *.*hh " ) 479 IntegralFMTImpl( unsigned char, 'u', "% *hh ", "% *.*hh " ) 480 IntegralFMTImpl( signed short int, 'd', "% *h ", "% *.*h " ) 481 IntegralFMTImpl( unsigned short int, 'u', "% *h ", "% *.*h " ) 482 IntegralFMTImpl( signed int, 'd', "% * ", "% *.* " ) 483 IntegralFMTImpl( unsigned int, 'u', "% * ", "% *.* " ) 484 IntegralFMTImpl( signed long int, 'd', "% *l ", "% *.*l " ) 485 IntegralFMTImpl( unsigned long int, 'u', "% *l ", "% *.*l " ) 486 IntegralFMTImpl( signed long long int, 'd', "% *ll ", "% *.*ll " ) 487 IntegralFMTImpl( unsigned long long int, 'u', "% *ll ", "% *.*ll " ) 488 489 //*********************************** floating point *********************************** 522 IntegralFMTImpl( signed char, "% *hh ", "% *.*hh " ) 523 IntegralFMTImpl( unsigned char, "% *hh ", "% *.*hh " ) 524 IntegralFMTImpl( signed short int, "% *h ", "% *.*h " ) 525 IntegralFMTImpl( unsigned short int, "% *h ", "% *.*h " ) 526 IntegralFMTImpl( signed int, "% * ", "% *.* " ) 527 IntegralFMTImpl( unsigned int, "% * ", "% *.* " ) 528 IntegralFMTImpl( signed long int, "% *l ", "% *.*l " ) 529 IntegralFMTImpl( unsigned long int, "% *l ", "% *.*l " ) 530 IntegralFMTImpl( signed long long int, "% *ll ", "% *.*ll " ) 531 IntegralFMTImpl( unsigned long long int, "% *ll ", "% *.*ll " ) 532 533 #if 0 534 #if defined( __SIZEOF_INT128__ ) 535 // Default prefix for non-decimal prints is 0b, 0, 0x. 536 #define IntegralFMTImpl128( T, SIGNED, CODE, IFMTNP, IFMTP ) \ 537 forall( dtype ostype | ostream( ostype ) ) \ 538 static void base10_128( ostype & os, _Ostream_Manip(T) f ) { \ 539 if ( f.val > UINT64_MAX ) { \ 540 unsigned long long int lsig = f.val % P10_UINT64; \ 541 f.val /= P10_UINT64; /* msig */ \ 542 base10_128( os, f ); /* recursion */ \ 543 _Ostream_Manip(unsigned long long int) fmt @= { lsig, 0, 19, 'u', { .all : 0 } }; \ 544 fmt.flags.nobsdp = true; \ 545 /* printf( "fmt1 %c %lld %d\n", fmt.base, fmt.val, fmt.all ); */ \ 546 sepOff( os ); \ 547 (ostype &)(os | fmt); \ 548 } else { \ 549 /* printf( "fmt2 %c %lld %d\n", f.base, (unsigned long long int)f.val, f.all ); */ \ 550 _Ostream_Manip(SIGNED long long int) fmt @= { (SIGNED long long int)f.val, f.wd, f.pc, f.base, { .all : f.all } }; \ 551 (ostype &)(os | fmt); \ 552 } /* if */ \ 553 } /* base10_128 */ \ 554 forall( dtype ostype | ostream( ostype ) ) { \ 555 ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \ 556 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); \ 557 \ 558 if ( f.base == 'b' | f.base == 'B' | f.base == 'o' | f.base == 'x' | f.base == 'X' ) { \ 559 unsigned long long int msig = (unsigned long long int)(f.val >> 64); \ 560 unsigned long long int lsig = (unsigned long long int)(f.val); \ 561 _Ostream_Manip(SIGNED long long int) fmt @= { msig, f.wd, f.pc, f.base, { .all : f.all } }; \ 562 _Ostream_Manip(unsigned long long int) fmt2 @= { lsig, 0, 0, f.base, { .all : 0 } }; \ 563 if ( msig == 0 ) { \ 564 fmt.val = lsig; \ 565 (ostype &)(os | fmt); \ 566 } else { \ 567 fmt2.flags.pad0 = fmt2.flags.nobsdp = true; \ 568 if ( f.base == 'b' | f.base == 'B' ) { \ 569 if ( fmt.flags.pc && fmt.pc > 64 ) fmt.pc -= 64; else { fmt.flags.pc = false; fmt.pc = 0; } \ 570 if ( fmt.flags.left ) { \ 571 fmt.flags.left = false; \ 572 fmt.wd = 0; \ 573 /* printf( "L %llo %llo %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all ); */ \ 574 fmt2.flags.left = true; \ 575 int msigd = high1( msig ); \ 576 fmt2.wd = f.wd - (fmt.pc > msigd ? fmt.pc : msigd); \ 577 if ( ! fmt.flags.nobsdp ) fmt2.wd -= 2; /* compensate for 0b base specifier */ \ 578 if ( (int)fmt2.wd < 64 ) fmt2.wd = 64; /* cast deals with negative value */ \ 579 fmt2.flags.pc = true; fmt2.pc = 64; \ 580 } else { \ 581 if ( fmt.wd > 64 ) fmt.wd -= 64; \ 582 else fmt.wd = 1; \ 583 /* printf( "R %llo %llo %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all ); */ \ 584 fmt2.wd = 64; \ 585 } /* if */ \ 586 /* printf( "C %llo %d %d '%c' %x\n", fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \ 587 (ostype &)(os | fmt | "" | fmt2); \ 588 } else if ( f.base == 'o' ) { \ 589 if ( fmt.flags.pc && fmt.pc > 22 ) fmt.pc -= 22; else { fmt.flags.pc = false; fmt.pc = 0; } \ 590 fmt.val = (unsigned long long int)fmt.val >> 2; \ 591 fmt2.val = ((msig & 0x3) << 1) + ((lsig & 0x8000000000000000U) != 0); \ 592 if ( fmt.flags.left ) { \ 593 fmt.flags.left = false; \ 594 fmt.wd = 0; \ 595 /* printf( "L %llo %llo %llo %d %d '%c' %x %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all, fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \ 596 (ostype &)(os | fmt | "" | fmt2); \ 597 sepOff( os ); \ 598 fmt2.flags.left = true; \ 599 int msigd = ceiling_div( high1( fmt.val ), 3 ); \ 600 fmt2.wd = f.wd - (fmt.pc > msigd ? fmt.pc : msigd); \ 601 if ( ! fmt.flags.nobsdp ) fmt2.wd -= 1; /* compensate for 0 base specifier */ \ 602 if ( (int)fmt2.wd < 21 ) fmt2.wd = 21; /* cast deals with negative value */ \ 603 fmt2.flags.pc = true; fmt2.pc = 21; \ 604 } else { \ 605 if ( fmt.wd > 22 ) fmt.wd -= 22; \ 606 else fmt.wd = 1; \ 607 /* printf( "R %llo %llo %llo %d %d '%c' %x %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all, fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \ 608 (ostype &)(os | fmt | "" | fmt2); \ 609 sepOff( os ); \ 610 fmt2.wd = 21; \ 611 } /* if */ \ 612 fmt2.val = lsig & 0x7fffffffffffffffU; \ 613 /* printf( "\nC %llo %d %d '%c' %x\n", fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \ 614 (ostype &)(os | fmt2); \ 615 } else { /* f.base == 'x' | f.base == 'X' */ \ 616 if ( fmt.flags.pc && fmt.pc > 16 ) fmt.pc -= 16; else { fmt.flags.pc = false; fmt.pc = 0; } \ 617 if ( fmt.flags.left ) { \ 618 fmt.flags.left = false; \ 619 fmt.wd = 0; \ 620 /* printf( "L %llo %llo %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all ); */ \ 621 fmt2.flags.left = true; \ 622 int msigd = high1( msig ); \ 623 fmt2.wd = f.wd - (fmt.pc > msigd ? fmt.pc : msigd); \ 624 if ( ! fmt.flags.nobsdp ) fmt2.wd -= 2; /* compensate for 0x base specifier */ \ 625 if ( (int)fmt2.wd < 16 ) fmt2.wd = 16; /* cast deals with negative value */ \ 626 fmt2.flags.pc = true; fmt2.pc = 16; \ 627 } else { \ 628 if ( fmt.wd > 16 ) fmt.wd -= 16; \ 629 else fmt.wd = 1; \ 630 /* printf( "R %llo %llo %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all ); */ \ 631 fmt2.wd = 16; \ 632 } /* if */ \ 633 /* printf( "C %llo %d %d '%c' %x\n", fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \ 634 (ostype &)(os | fmt | "" | fmt2); \ 635 } /* if */ \ 636 } /* if */ \ 637 } else { \ 638 if ( CODE == 'd' ) { \ 639 if ( f.val < 0 ) { fmt( os, "-" ); sepOff( os ); f.val = -f.val; f.flags.sign = false; } \ 640 } /* if */ \ 641 base10_128( os, f ); \ 642 } /* if */ \ 643 return os; \ 644 } /* ?|? */ \ 645 void ?|?( ostype & os, _Ostream_Manip(T) f ) { (ostype &)(os | f); ends( os ); } \ 646 } // distribution 647 648 IntegralFMTImpl128( int128, signed, 'd', "% *ll ", "% *.*ll " ) 649 IntegralFMTImpl128( unsigned int128, unsigned, 'u', "% *ll ", "% *.*ll " ) 650 #endif // __SIZEOF_INT128__ 651 #endif // 0 652 653 #if 1 654 #if defined( __SIZEOF_INT128__ ) 655 // Default prefix for non-decimal prints is 0b, 0, 0x. 656 forall( dtype ostype | ostream( ostype ) ) 657 static inline void base_128( ostype & os, unsigned int128 val, unsigned int128 power, _Ostream_Manip(uint64_t) & f, unsigned int maxdig, unsigned int bits, unsigned int cnt = 0 ) { 658 int wd = 1; // f.wd is never 0 because 0 implies left-pad 659 if ( val > power ) { // subdivide value into printable 64-bit values 660 base_128( os, val / power, power, f, maxdig, bits, cnt + 1 ); // recursive 661 f.val = val % power; 662 if ( cnt == 1 && f.flags.left ) { wd = f.wd; f.wd = maxdig; } // copy f.wd and reset for printing middle chunk 663 // printf( "R val:%#lx(%lu) wd:%u pc:%u base:%c neg:%d pc:%d left:%d nobsdp:%d sign:%d pad0:%d\n", 664 // f.val, f.val, f.wd, f.pc, f.base, f.flags.neg, f.flags.pc, f.flags.left, f.flags.nobsdp, f.flags.sign, f.flags.pad0 ); 665 (ostype &)(os | f); 666 if ( cnt == 1 ) { 667 if ( f.flags.left ) { wd -= maxdig; f.wd = wd < 0 ? 1 : wd; } // update and restore f.wd for printing end chunk 668 sepOff( os ); // no seperator between chunks 669 } // if 670 } else { // print start chunk 671 f.val = val; 672 // f.pc is unsigned => use wd 673 if ( f.flags.pc && f.pc > maxdig * cnt ) { wd = f.pc - maxdig * cnt; f.pc = wd < 0 ? 0 : wd; } 674 else { f.flags.pc = false; f.pc = 0; } 675 676 if ( ! f.flags.left ) { // right justify 677 wd = f.wd - maxdig * cnt; 678 f.wd = wd < 0 ? 1 : wd; 679 wd = maxdig; 680 } else { // left justify 681 if ( cnt != 0 ) { // value >= 2^64 ? 682 unsigned int dig, bs = 0; 683 // compute size of prefix digits and base 684 if ( f.base == 'd' || f.base == 'u' ) { // no base prefix 685 dig = ceil( log10( f.val ) ); // use floating-point 686 if ( f.base == 'd' && (f.flags.neg || f.flags.sign) ) bs = 1; // sign ? 687 } else { 688 dig = ceiling_div( high1( f.val ), bits ); 689 if ( ! f.flags.nobsdp ) { // base prefix ? 690 if ( f.base == 'o' ) { 691 // 0 prefix for octal is not added for precision with leading zero 692 if ( f.pc <= dig ) bs = 1; // 1 character prefix 693 } else bs = 2; // 2 character prefix 694 } // if 695 } // if 696 wd = f.wd - (f.pc > dig ? f.pc : dig) - bs; // precision > leading digits ? 697 if ( wd < 0 ) wd = 1; 698 f.wd = 1; 699 } // if 700 // all manipulators handled implicitly for value < 2^64 701 } // if 702 // prior checks ensure wd not negative 703 704 if ( f.flags.neg ) f.val = -f.val; 705 // printf( "L val:%#lx(%lu) wd:%u pc:%u base:%c neg:%d pc:%d left:%d nobsdp:%d sign:%d pad0:%d\n", 706 // f.val, f.val, f.wd, f.pc, f.base, f.flags.neg, f.flags.pc, f.flags.left, f.flags.nobsdp, f.flags.sign, f.flags.pad0 ); 707 (ostype &)(os | f); 708 709 // remaining middle and end chunks are padded with 0s on the left 710 if ( ! f.flags.left ) { f.flags.pad0 = true; f.flags.pc = false; } // left pad with 0s 711 else { f.pc = maxdig; f.flags.pc = true; } // left pad with precision 712 713 if ( cnt != 0 ) sepOff( os ); // no seperator between chunks 714 f.wd = wd; // reset f.wd for next chunk 715 f.flags.sign = false; // no leading +/- sign 716 f.flags.nobsdp = true; // no leading base prefix 717 } // if 718 } // base_128 719 720 #define IntegralFMTImpl128( T ) \ 721 forall( dtype ostype | ostream( ostype ) ) { \ 722 ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \ 723 _Ostream_Manip(uint64_t) fmt; \ 724 fmt.[wd, pc, base, all] = f.[wd, pc, base, all]; \ 725 if ( f.base == 'b' | f.base == 'B' ) { \ 726 base_128( os, f.val, (unsigned int128)1 << 64, fmt, 64, 1 ); \ 727 } else if ( f.base == 'o' ) { \ 728 base_128( os, f.val, (unsigned int128)1 << 63, fmt, 21, 3 ); \ 729 } else if ( f.base == 'd' || f.base == 'u' ) { \ 730 if ( f.base == 'd' && f.val < 0 ) { f.val = -f.val; fmt.flags.neg = true; } \ 731 base_128( os, f.val, (unsigned int128)10_000_000_000_000_000_000UL, fmt, 19, 0 ); \ 732 } else { \ 733 base_128( os, f.val, (unsigned int128)1 << 64, fmt, 16, 4 ); \ 734 } /* if */ \ 735 return os; \ 736 } /* ?|? */ \ 737 void ?|?( ostype & os, _Ostream_Manip(T) f ) { (ostype &)(os | f); ends( os ); } \ 738 } // distribution 739 740 IntegralFMTImpl128( int128 ) 741 IntegralFMTImpl128( unsigned int128 ) 742 #endif // __SIZEOF_INT128__ 743 #endif // 0 744 745 // *********************************** floating point *********************************** 490 746 491 747 #define PrintWithDP2( os, format, val, ... ) \ … … 513 769 forall( dtype ostype | ostream( ostype ) ) { \ 514 770 ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \ 515 if ( sepPrt( os ) ) fmt( os, "%s",sepGetCur( os ) ); \771 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); \ 516 772 char fmtstr[sizeof(DFMTP)]; /* sizeof includes '\0' */ \ 517 773 if ( ! f.flags.pc ) memcpy( &fmtstr, DFMTNP, sizeof(DFMTNP) ); \ … … 536 792 return os; \ 537 793 } /* ?|? */ \ 794 \ 538 795 void ?|?( ostype & os, _Ostream_Manip(T) f ) { (ostype &)(os | f); ends( os ); } \ 539 796 } // distribution … … 542 799 FloatingPointFMTImpl( long double, "% *L ", "% *.*L " ) 543 800 544 // *********************************** character ***********************************801 // *********************************** character *********************************** 545 802 546 803 forall( dtype ostype | ostream( ostype ) ) { … … 555 812 } // if 556 813 557 if ( sepPrt( os ) ) fmt( os, "%s",sepGetCur( os ) );814 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); 558 815 559 816 #define CFMTNP "% * " … … 571 828 return os; 572 829 } // ?|? 830 573 831 void ?|?( ostype & os, _Ostream_Manip(char) f ) { (ostype &)(os | f); ends( os ); } 574 832 } // distribution 575 833 576 // *********************************** C string ***********************************834 // *********************************** C string *********************************** 577 835 578 836 forall( dtype ostype | ostream( ostype ) ) { … … 592 850 } // if 593 851 594 if ( sepPrt( os ) ) fmt( os, "%s",sepGetCur( os ) );852 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); 595 853 596 854 #define SFMTNP "% * " … … 616 874 return os; 617 875 } // ?|? 876 618 877 void ?|?( ostype & os, _Ostream_Manip(const char *) f ) { (ostype &)(os | f); ends( os ); } 619 878 } // distribution 620 879 621 880 622 // *********************************** istream ***********************************881 // *********************************** istream *********************************** 623 882 624 883 … … 697 956 } // ?|? 698 957 958 #if defined( __SIZEOF_INT128__ ) 959 istype & ?|?( istype & is, int128 & i128 ) { 960 return (istype &)(is | (unsigned int128 &)i128); 961 } // ?|? 962 963 istype & ?|?( istype & is, unsigned int128 & ui128 ) { 964 char s[40]; 965 bool sign = false; 966 967 if ( fmt( is, " %[-]", s ) == 1 ) sign = true; // skip whitespace, negative sign ? 968 // If the input is too large, the value returned is undefined. If there is no input, no value is returned 969 if ( fmt( is, "%39[0-9]%*[0-9]", s ) == 1 ) { // take first 39 characters, ignore remaining 970 ui128 = 0; 971 for ( unsigned int i = 0; s[i] != '\0'; i += 1 ) { 972 ui128 = ui128 * 10 + s[i] - '0'; 973 } // for 974 if ( sign ) ui128 = -ui128; 975 } else if ( sign ) ungetc( is, '-' ); // return minus when no digits 976 return is; 977 } // ?|? 978 #endif // __SIZEOF_INT128__ 699 979 700 980 istype & ?|?( istype & is, float & f ) { … … 735 1015 } // ?|? 736 1016 737 // istype & ?|?( istype & is, const char * fmt) {1017 // istype & ?|?( istype & is, const char fmt[] ) { 738 1018 // fmt( is, fmt, "" ); 739 1019 // return is; … … 766 1046 } // distribution 767 1047 768 // *********************************** manipulators ***********************************1048 // *********************************** manipulators *********************************** 769 1049 770 1050 forall( dtype istype | istream( istype ) )
Note:
See TracChangeset
for help on using the changeset viewer.
