source: libcfa/src/iostream.cfa @ 3c573e9

arm-ehjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-expr
Last change on this file since 3c573e9 was 3c573e9, checked in by Peter A. Buhr <pabuhr@…>, 3 years ago

first draft of output manipulators and start input manipulators

  • Property mode set to 100644
File size: 27.6 KB
Line 
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.c --
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 : Tue Jun  4 17:32:34 2019
13// Update Count     : 761
14//
15
16#include "iostream.hfa"
17
18extern "C" {
19#include <stdio.h>
20#include <stdbool.h>                                                                    // true/false
21//#include <string.h>                                                                   // strlen, strcmp
22extern size_t strlen (const char *__s) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
23extern int strcmp (const char *__s1, const char *__s2) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
24extern char *strcpy (char *__restrict __dest, const char *__restrict __src) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
25extern 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_DIG
27#include <math.h>                                                                               // isfinite
28#include <complex.h>                                                                    // creal, cimag
29} // extern "C"
30
31forall( dtype ostype | ostream( ostype ) ) {
32        ostype & ?|?( ostype & os, zero_t ) {
33                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
34                fmt( os, "%d", 0n );
35                return os;
36        } // ?|?
37        void ?|?( ostype & os, zero_t z ) {
38                (ostype &)(os | z); nl( os );
39        } // ?|?
40
41        ostype & ?|?( ostype & os, one_t ) {
42                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
43                fmt( os, "%d", 1n );
44                return os;
45        } // ?|?
46        void ?|?( ostype & os, one_t o ) {
47                (ostype &)(os | o); nl( os );
48        } // ?|?
49
50        ostype & ?|?( ostype & os, bool b ) {
51                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
52                fmt( os, "%s", b ? "true" : "false" );
53                return os;
54        } // ?|?
55        void ?|?( ostype & os, bool b ) {
56                (ostype &)(os | b); nl( os );
57        } // ?|?
58
59        ostype & ?|?( ostype & os, char c ) {
60                fmt( os, "%c", c );
61                if ( c == '\n' ) setNL( os, true );
62                return sepOff( os );
63        } // ?|?
64        void ?|?( ostype & os, char c ) {
65                (ostype &)(os | c); nl( os );
66        } // ?|?
67
68        ostype & ?|?( ostype & os, signed char sc ) {
69                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
70                fmt( os, "%hhd", sc );
71                return os;
72        } // ?|?
73        void ?|?( ostype & os, signed char sc ) {
74                (ostype &)(os | sc); nl( os );
75        } // ?|?
76
77        ostype & ?|?( ostype & os, unsigned char usc ) {
78                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
79                fmt( os, "%hhu", usc );
80                return os;
81        } // ?|?
82        void ?|?( ostype & os, unsigned char usc ) {
83                (ostype &)(os | usc); nl( os );
84        } // ?|?
85
86        ostype & ?|?( ostype & os, short int si ) {
87                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
88                fmt( os, "%hd", si );
89                return os;
90        } // ?|?
91        void & ?|?( ostype & os, short int si ) {
92                (ostype &)(os | si); nl( os );
93        } // ?|?
94
95        ostype & ?|?( ostype & os, unsigned short int usi ) {
96                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
97                fmt( os, "%hu", usi );
98                return os;
99        } // ?|?
100        void & ?|?( ostype & os, unsigned short int usi ) {
101                (ostype &)(os | usi); nl( os );
102        } // ?|?
103
104        ostype & ?|?( ostype & os, int i ) {
105                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
106                fmt( os, "%d", i );
107                return os;
108        } // ?|?
109        void & ?|?( ostype & os, int i ) {
110                (ostype &)(os | i); nl( os );
111        } // ?|?
112
113        ostype & ?|?( ostype & os, unsigned int ui ) {
114                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
115                fmt( os, "%u", ui );
116                return os;
117        } // ?|?
118        void & ?|?( ostype & os, unsigned int ui ) {
119                (ostype &)(os | ui); nl( os );
120        } // ?|?
121
122        ostype & ?|?( ostype & os, long int li ) {
123                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
124                fmt( os, "%ld", li );
125                return os;
126        } // ?|?
127        void & ?|?( ostype & os, long int li ) {
128                (ostype &)(os | li); nl( os );
129        } // ?|?
130
131        ostype & ?|?( ostype & os, unsigned long int uli ) {
132                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
133                fmt( os, "%lu", uli );
134                return os;
135        } // ?|?
136        void & ?|?( ostype & os, unsigned long int uli ) {
137                (ostype &)(os | uli); nl( os );
138        } // ?|?
139
140        ostype & ?|?( ostype & os, long long int lli ) {
141                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
142                fmt( os, "%lld", lli );
143                return os;
144        } // ?|?
145        void & ?|?( ostype & os, long long int lli ) {
146                (ostype &)(os | lli); nl( os );
147        } // ?|?
148
149        ostype & ?|?( ostype & os, unsigned long long int ulli ) {
150                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
151                fmt( os, "%llu", ulli );
152                return os;
153        } // ?|?
154        void & ?|?( ostype & os, unsigned long long int ulli ) {
155                (ostype &)(os | ulli); nl( os );
156        } // ?|?
157
158        #define PrintWithDP( os, format, val, ... ) \
159                { \
160                        enum { size = 48 }; \
161                        char buf[size]; \
162                        int len = snprintf( buf, size, format, ##__VA_ARGS__, val ); \
163                        fmt( os, "%s", buf ); \
164                        if ( isfinite( val ) ) {                                        /* if number, always print decimal point */ \
165                                for ( int i = 0;; i += 1 ) { \
166                                        if ( i == len ) { fmt( os, "." ); break; } \
167                                        if ( buf[i] == '.' ) break; \
168                                } /* for */ \
169                        } /* if */ \
170                }
171
172        ostype & ?|?( ostype & os, float f ) {
173                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
174                PrintWithDP( os, "%g", f );
175                return os;
176        } // ?|?
177        void & ?|?( ostype & os, float f ) {
178                (ostype &)(os | f); nl( os );
179        } // ?|?
180
181        ostype & ?|?( ostype & os, double d ) {
182                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
183                PrintWithDP( os, "%.*lg", d, DBL_DIG );
184                return os;
185        } // ?|?
186        void & ?|?( ostype & os, double d ) {
187                (ostype &)(os | d); nl( os );
188        } // ?|?
189
190        ostype & ?|?( ostype & os, long double ld ) {
191                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
192                PrintWithDP( os, "%.*Lg", ld, LDBL_DIG );
193                return os;
194        } // ?|?
195        void & ?|?( ostype & os, long double ld ) {
196                (ostype &)(os | ld); nl( os );
197        } // ?|?
198
199        ostype & ?|?( ostype & os, float _Complex fc ) {
200                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
201//              os | crealf( fc ) | nonl;
202                PrintWithDP( os, "%g", crealf( fc ) );
203                PrintWithDP( os, "%+g", cimagf( fc ) );
204                fmt( os, "i" );
205                return os;
206        } // ?|?
207        void & ?|?( ostype & os, float _Complex fc ) {
208                (ostype &)(os | fc); nl( os );
209        } // ?|?
210
211        ostype & ?|?( ostype & os, double _Complex dc ) {
212                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
213//              os | creal( dc ) | nonl;
214                PrintWithDP( os, "%.*lg", creal( dc ), DBL_DIG );
215                PrintWithDP( os, "%+.*lg", cimag( dc ), DBL_DIG );
216                fmt( os, "i" );
217                return os;
218        } // ?|?
219        void & ?|?( ostype & os, double _Complex dc ) {
220                (ostype &)(os | dc); nl( os );
221        } // ?|?
222
223        ostype & ?|?( ostype & os, long double _Complex ldc ) {
224                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
225//              os | creall( ldc ) || nonl;
226                PrintWithDP( os, "%.*Lg", creall( ldc ), LDBL_DIG );
227                PrintWithDP( os, "%+.*Lg", cimagl( ldc ), LDBL_DIG );
228                fmt( os, "i" );
229                return os;
230        } // ?|?
231        void & ?|?( ostype & os, long double _Complex ldc ) {
232                (ostype &)(os | ldc); nl( os );
233        } // ?|?
234
235        ostype & ?|?( ostype & os, const char * str ) {
236                enum { Open = 1, Close, OpenClose };
237                static const unsigned char mask[256] @= {
238                        // opening delimiters, no space after
239                        ['('] : Open, ['['] : Open, ['{'] : Open,
240                        ['='] : Open, ['$'] : Open, [(unsigned char)'£'] : Open, [(unsigned char)'¥'] : Open,
241                        [(unsigned char)'¡'] : Open, [(unsigned char)'¿'] : Open, [(unsigned char)'«'] : Open,
242                        // closing delimiters, no space before
243                        [','] : Close, ['.'] : Close, [';'] : Close, ['!'] : Close, ['?'] : Close,
244                        ['%'] : Close, [(unsigned char)'¢'] : Close, [(unsigned char)'»'] : Close,
245                        [')'] : Close, [']'] : Close, ['}'] : Close,
246                        // opening-closing delimiters, no space before or after
247                        ['\''] : OpenClose, ['`'] : OpenClose, ['"'] : OpenClose, [':'] : OpenClose,
248                        [' '] : OpenClose, ['\f'] : OpenClose, ['\n'] : OpenClose, ['\r'] : OpenClose, ['\t'] : OpenClose, ['\v'] : OpenClose, // isspace
249                }; // mask
250
251          if ( str[0] == '\0' ) { sepOff( os ); return os; } // null string => no separator
252
253                // first character IS NOT spacing or closing punctuation => add left separator
254                unsigned char ch = str[0];                                              // must make unsigned
255                if ( sepPrt( os ) && mask[ ch ] != Close && mask[ ch ] != OpenClose ) {
256                        fmt( os, "%s", sepGetCur( os ) );
257                } // if
258
259                // if string starts line, must reset to determine open state because separator is off
260                sepReset( os );                                                                 // reset separator
261
262                // last character IS spacing or opening punctuation => turn off separator for next item
263                size_t len = strlen( str );
264                ch = str[len - 1];                                                              // must make unsigned
265                if ( sepPrt( os ) && mask[ ch ] != Open && mask[ ch ] != OpenClose ) {
266                        sepOn( os );
267                } else {
268                        sepOff( os );
269                } // if
270                if ( ch == '\n' ) setNL( os, true );                    // check *AFTER* sepPrt call above as it resets NL flag
271                return write( os, str, len );
272        } // ?|?
273        void ?|?( ostype & os, const char * str ) {
274                (ostype &)(os | str); nl( os );
275        } // ?|?
276
277//      ostype & ?|?( ostype & os, const char16_t * str ) {
278//              if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
279//              fmt( os, "%ls", str );
280//              return os;
281//      } // ?|?
282
283// #if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous
284//      ostype & ?|?( ostype & os, const char32_t * str ) {
285//              if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
286//              fmt( os, "%ls", str );
287//              return os;
288//      } // ?|?
289// #endif // ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 )
290
291//      ostype & ?|?( ostype & os, const wchar_t * str ) {
292//              if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
293//              fmt( os, "%ls", str );
294//              return os;
295//      } // ?|?
296
297        ostype & ?|?( ostype & os, const void * p ) {
298                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
299                fmt( os, "%p", p );
300                return os;
301        } // ?|?
302        void ?|?( ostype & os, const void * p ) {
303                (ostype &)(os | p); nl( os );
304        } // ?|?
305
306        // manipulators
307        ostype & ?|?( ostype & os, ostype & (* manip)( ostype & ) ) {
308                (ostype &)(manip( os ));
309                return os;
310        } // ?|?
311        void ?|?( ostype & os, ostype & (* manip)( ostype & ) ) {
312                (ostype &)(manip( os ));
313                if ( getPrt( os ) ) nl( os );                                   // something printed ?
314                setPrt( os, false );                                                    // turn off
315        } // ?|?
316
317        ostype & sep( ostype & os ) {
318                return (ostype &)(os | sepGet( os ));
319        } // sep
320
321        ostype & sepTuple( ostype & os ) {
322                return os | sepGetTuple( os );
323        } // sepTuple
324
325        ostype & nl( ostype & os ) {
326                (ostype &)(os | '\n');
327                setPrt( os, false );                                                    // turn off
328                setNL( os, true );
329                flush( os );
330                return sepOff( os );                                                    // prepare for next line
331        } // nl
332
333        void nl( ostype & os ) {
334                if ( getANL( os ) ) (ostype &)(nl( os ));               // implementation only
335                else setPrt( os, false );                                               // turn off
336        } // nl
337
338        ostype & nonl( ostype & os ) {
339                setPrt( os, false );                                                    // turn off
340                return os;
341        } // nonl
342
343        ostype & sepOn( ostype & os ) {
344                sepOn( os );                                                                    // call void returning
345                return os;
346        } // sepOn
347
348        ostype & sepOff( ostype & os ) {
349                sepOff( os );                                                                   // call void returning
350                return os;
351        } // sepOff
352
353        ostype & sepEnable( ostype & os ) {
354                sepEnable( os );                                                                // call void returning
355                return os;
356        } // sepEnable
357
358        ostype & sepDisable( ostype & os ) {
359                sepDisable( os );                                                               // call void returning
360                return os;
361        } // sepDisable
362
363        ostype & nlOn( ostype & os ) {
364                nlOn( os );                                                                             // call void returning
365                return os;
366        } // nlOn
367
368        ostype & nlOff( ostype & os ) {
369                nlOff( os );                                                                    // call void returning
370                return os;
371        } // nlOff
372} // distribution
373
374// tuples
375forall( dtype ostype, otype T, ttype Params | writeable( T, ostype ) | { ostype & ?|?( ostype &, Params ); } ) {
376        ostype & ?|?( ostype & os, T arg, Params rest ) {
377                (ostype &)(os | arg);                                                   // print first argument
378                sepSetCur( os, sepGetTuple( os ) );                             // switch to tuple separator
379                (ostype &)(os | rest);                                                  // print remaining arguments
380                sepSetCur( os, sepGet( os ) );                                  // switch to regular separator
381                return os;
382        } // ?|?
383        void ?|?( ostype & os, T arg, Params rest ) {
384                // (ostype &)(?|?( os, arg, rest )); nl( os );
385                (ostype &)(os | arg);                                                   // print first argument
386                sepSetCur( os, sepGetTuple( os ) );                             // switch to tuple separator
387                (ostype &)(os | rest);                                                  // print remaining arguments
388                sepSetCur( os, sepGet( os ) );                                  // switch to regular separator
389                nl( os );
390        } // ?|?
391} // distribution
392
393
394//*********************************** Integral ***********************************
395
396static const char * shortbin[] = { "0", "1", "10", "11", "100", "101", "110", "111", "1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111" };
397static const char * longbin[]  = { "0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111", "1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111" };
398
399// Default prefix for non-decimal prints is 0b, 0, 0x.
400#define IntegralFMTImpl( T, CODE, IFMTNP, IFMTP ) \
401forall( dtype ostype | ostream( ostype ) ) { \
402        ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \
403                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); \
404\
405                if ( f.base == 'b' || f.base == 'B' ) {                 /* bespoke binary format */ \
406                        int bits;                                                                                                       \
407                        if ( f.val == (T){0} ) bits = 1;                        /* force at least one bit to print */ \
408                        else bits = sizeof(long long int) * 8 - __builtin_clzll( f.val ); /* position of most significant bit */ \
409                        bits = bits > sizeof(f.val) * 8 ? sizeof(f.val) * 8 : bits; \
410                        int spaces = f.wd - bits;                                       /* can be negative */ \
411                        if ( ! f.flags.nobsdp ) { spaces -= 2; }        /* base prefix takes space */ \
412                        /* printf( "%d %d\n", bits, spaces ); */ \
413                        if ( ! f.flags.left ) {                                         /* right justified ? */ \
414                                /* Note, base prefix then zero padding or spacing then prefix. */ \
415                                if ( f.flags.pad0 || f.flags.pc ) { \
416                                        if ( ! f.flags.nobsdp ) { fmt( os, "0%c", f.base ); } \
417                                        if ( f.flags.pc ) spaces = f.pc - bits; \
418                                        if ( spaces > 0 ) fmt( os, "%0*d", spaces, 0 ); /* zero pad */ \
419                                } else { \
420                                        if ( spaces > 0 ) fmt( os, "%*s", spaces, " " ); /* space pad */ \
421                                        if ( ! f.flags.nobsdp ) { fmt( os, "0%c", f.base ); } \
422                                } /* if */ \
423                        } else if ( ! f.flags.nobsdp ) { \
424                                fmt( os, "0%c", f.base ); \
425                        } /* if */ \
426                        int shift = (bits - 1) / 4 * 4; /* floor( bits - 1, 4 ) */ \
427                        typeof( f.val ) temp = f.val; \
428                        fmt( os, "%s", shortbin[(temp >> shift) & 0xf] ); \
429                        for () { \
430                                shift -= 4; \
431                          if ( shift < 0 ) break; \
432                                temp = f.val; \
433                                fmt( os, "%s", longbin[(temp >> shift) & 0xf] ); \
434                        } /* for */ \
435                        if ( f.flags.left && spaces > 0 ) fmt( os, "%*s", spaces, " " ); \
436                        return os; \
437                } /* if  */ \
438\
439                char fmtstr[sizeof(IFMTP)];                                             /* sizeof includes '\0' */ \
440                if ( ! f.flags.pc ) memcpy( &fmtstr, IFMTNP, sizeof(IFMTNP) ); \
441                else memcpy( &fmtstr, IFMTP, sizeof(IFMTP) ); \
442                int star = 4;                                                                   /* position before first '*' */ \
443\
444                /* Insert flags into spaces before '*', from right to left. */ \
445                if ( ! f.flags.nobsdp ) { fmtstr[star] = '#'; star -= 1; } \
446                if ( f.flags.left ) { fmtstr[star] = '-'; star -= 1; } \
447                if ( f.flags.sign && f.base == CODE ) { fmtstr[star] = '+'; star -= 1; } \
448                if ( f.flags.pad0 && ! f.flags.pc ) { fmtstr[star] = '0'; star -= 1; } \
449                fmtstr[star] = '%'; \
450\
451                if ( ! f.flags.pc ) {                                                   /* no precision */ \
452                        /* printf( "%s\n", &fmtstr[star] ); */ \
453                        fmtstr[sizeof(IFMTNP)-2] = f.base;                      /* sizeof includes '\0' */ \
454                        fmt( os, &fmtstr[star], f.wd, f.val ); \
455                } else {                                                                                /* precision */ \
456                        fmtstr[sizeof(IFMTP)-2] = f.base;                       /* sizeof includes '\0' */ \
457                        /* printf( "%s\n", &fmtstr[star] ); */ \
458                        fmt( os, &fmtstr[star], f.wd, f.pc, f.val ); \
459                } /* if */ \
460                return os; \
461        } /* ?|? */ \
462        void ?|?( ostype & os, _Ostream_Manip(T) f ) { (ostype &)(os | f); nl( os ); } \
463} // distribution
464
465IntegralFMTImpl( signed char, 'd', "%    *hh ", "%    *.*hh " )
466IntegralFMTImpl( unsigned char, 'u', "%    *hh ", "%    *.*hh " )
467IntegralFMTImpl( signed short int, 'd', "%    *h ", "%    *.*h " )
468IntegralFMTImpl( unsigned short int, 'u', "%    *h ", "%    *.*h " )
469IntegralFMTImpl( signed int, 'd', "%    * ", "%    *.* " )
470IntegralFMTImpl( unsigned int, 'u', "%    * ", "%    *.* " )
471IntegralFMTImpl( signed long int, 'd', "%    *l ", "%    *.*l " )
472IntegralFMTImpl( unsigned long int, 'u', "%    *l ", "%    *.*l " )
473IntegralFMTImpl( signed long long int, 'd', "%    *ll ", "%    *.*ll " )
474IntegralFMTImpl( unsigned long long int, 'u', "%    *ll ", "%    *.*ll " )
475
476//*********************************** Floating Point ***********************************
477
478#define PrintWithDP2( os, format, val, ... ) \
479        { \
480                enum { size = 48 }; \
481                char buf[size]; \
482                int bufbeg = 0, i, len = snprintf( buf, size, format, ##__VA_ARGS__, val ); \
483                if ( isfinite( val ) && (f.base != 'g' || f.pc != 0) ) { /* if number, print decimal point */ \
484                        for ( i = 0; i < len && buf[i] != '.' && buf[i] != 'e' && buf[i] != 'E'; i += 1 ); /* decimal point or scientific ? */ \
485                        if ( i == len && ! f.flags.nobsdp ) { \
486                                if ( ! f.flags.left ) { \
487                                        buf[i] = '.'; buf[i + 1] = '\0'; \
488                                        if ( buf[0] == ' ' ) bufbeg = 1; /* decimal point within width */ \
489                                } else { \
490                                        for ( i = 0; i < len && buf[i] != ' '; i += 1 ); /* trailing blank ? */ \
491                                        buf[i] = '.'; \
492                                        if ( i == len ) buf[i + 1] = '\0'; \
493                                } /* if */ \
494                        } /* if */ \
495                } /* if */ \
496                fmt( os, "%s", &buf[bufbeg] ); \
497        }
498
499#define FloatingPointFMTImpl( T, DFMTNP, DFMTP ) \
500forall( dtype ostype | ostream( ostype ) ) { \
501        ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \
502                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); \
503                char fmtstr[sizeof(DFMTP)];                                             /* sizeof includes '\0' */ \
504                if ( ! f.flags.pc ) memcpy( &fmtstr, DFMTNP, sizeof(DFMTNP) ); \
505                else memcpy( &fmtstr, DFMTP, sizeof(DFMTP) ); \
506                int star = 4;                                                                   /* position before first '*' */ \
507\
508                /* Insert flags into spaces before '*', from right to left. */ \
509                if ( f.flags.left ) { fmtstr[star] = '-'; star -= 1; } \
510                if ( f.flags.sign ) { fmtstr[star] = '+'; star -= 1; } \
511                if ( f.flags.pad0 ) { fmtstr[star] = '0'; star -= 1; } \
512                fmtstr[star] = '%'; \
513\
514                if ( ! f.flags.pc ) {                                                   /* no precision */ \
515                        fmtstr[sizeof(DFMTNP)-2] = f.base;                      /* sizeof includes '\0' */ \
516                        /* printf( "%g %d %s\n", f.val, f.wd, &fmtstr[star]); */ \
517                        PrintWithDP2( os, &fmtstr[star], f.val, f.wd ) \
518                } else {                                                                                /* precision */ \
519                        fmtstr[sizeof(DFMTP)-2] = f.base;                       /* sizeof includes '\0' */ \
520                        /* printf( "%g %d %d %s\n", f.val, f.wd, f.pc, &fmtstr[star] ); */ \
521                        PrintWithDP2( os, &fmtstr[star], f.val, f.wd, f.pc ) \
522                } /* if */ \
523                return os; \
524        } /* ?|? */ \
525        void ?|?( ostype & os, _Ostream_Manip(T) f ) { (ostype &)(os | f); nl( os ); } \
526} // distribution
527
528FloatingPointFMTImpl( double, "%    * ", "%    *.* " )
529FloatingPointFMTImpl( long double, "%    *L ", "%    *.*L " )
530
531//*********************************** Character ***********************************
532
533forall( dtype ostype | ostream( ostype ) ) {
534        ostype & ?|?( ostype & os, _Ostream_Manip(char) f ) {
535                if ( f.base != 'c' ) {                                                          // bespoke binary/octal/hex format
536                        _Ostream_Manip(unsigned char) fmtuc @= { f.val, f.wd, f.pc, f.base, {'\0'} };
537                        fmtuc.flags.pc = f.flags.pc;
538                        fmtuc.flags.nobsdp = f.flags.nobsdp;
539//                      os | fmtuc | nonl;
540                        (ostype &)(os | fmtuc);
541                        return os;
542                } // if
543
544                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
545
546                #define CFMTNP "% * "
547                char fmtstr[sizeof(CFMTNP)];                                            // sizeof includes '\0'
548                memcpy( &fmtstr, CFMTNP, sizeof(CFMTNP) );
549                int star = 1;                                                                           // position before first '*'
550
551                // Insert flags into spaces before '*', from right to left.
552                if ( f.flags.left ) { fmtstr[star] = '-'; star -= 1; }
553                fmtstr[star] = '%';
554
555                fmtstr[sizeof(CFMTNP)-2] = f.base;                                      // sizeof includes '\0'
556                // printf( "%d %s\n", f.wd, &fmtstr[star] );
557                fmt( os, &fmtstr[star], f.wd, f.val );
558                return os;
559        } // ?|?
560        void ?|?( ostype & os, _Ostream_Manip(char) f ) { (ostype &)(os | f); nl( os ); }
561} // distribution
562
563//*********************************** C String ***********************************
564
565forall( dtype ostype | ostream( ostype ) ) {
566        ostype & ?|?( ostype & os, _Ostream_Manip(const char *) f ) {
567                if ( ! f.val ) return os;                                               // null pointer ?
568
569                if ( f.base != 's' ) {                                                  // bespoke binary/octal/hex format
570                        _Ostream_Manip(unsigned char) fmtuc @= { 0, f.wd, f.pc, f.base, {'\0'} };
571                        fmtuc.flags.pc = f.flags.pc;
572                        fmtuc.flags.nobsdp = f.flags.nobsdp;
573                        for ( unsigned int i = 0; f.val[i] != '\0'; i += 1 ) {
574                                fmtuc.val = f.val[i];
575//                              os | fmtuc | nonl;
576                                (ostype &)(os | fmtuc);
577                        } // for
578                        return os;
579                } // if
580
581                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
582
583                #define SFMTNP "% * "
584                #define SFMTP "% *.* "
585                char fmtstr[sizeof(SFMTP)];                                             // sizeof includes '\0'
586                if ( ! f.flags.pc ) memcpy( &fmtstr, SFMTNP, sizeof(SFMTNP) );
587                else memcpy( &fmtstr, SFMTP, sizeof(SFMTP) );
588                int star = 1;                                                                   // position before first '*'
589
590                // Insert flags into spaces before '*', from right to left.
591                if ( f.flags.left ) { fmtstr[star] = '-'; star -= 1; }
592                fmtstr[star] = '%';
593
594                if ( ! f.flags.pc ) {                                                   // no precision
595                        // printf( "%d %s\n", f.wd, &fmtstr[star] );
596                        fmtstr[sizeof(SFMTNP)-2] = f.base;                      // sizeof includes '\0'
597                        fmt( os, &fmtstr[star], f.wd, f.val );
598                } else {                                                                                // precision
599                        fmtstr[sizeof(SFMTP)-2] = f.base;                       // sizeof includes '\0'
600                        // printf( "%d %d %s\n", f.wd, f.pc, &fmtstr[star] );
601                        fmt( os, &fmtstr[star], f.wd, f.pc, f.val );
602                } // if
603                return os;
604        } // ?|?
605        void ?|?( ostype & os, _Ostream_Manip(const char *) f ) { (ostype &)(os | f); nl( os ); }
606} // distribution
607
608//---------------------------------------
609
610// writes the range [begin, end) to the given stream
611forall( dtype ostype, otype elt_type | writeable( elt_type, ostype ), otype iterator_type | iterator( iterator_type, elt_type ) ) {
612        void write( iterator_type begin, iterator_type end, ostype & os ) {
613                void print( elt_type i ) { os | i; }
614                for_each( begin, end, print );
615        } // ?|?
616
617        void write_reverse( iterator_type begin, iterator_type end, ostype & os ) {
618                void print( elt_type i ) { os | i; }
619                for_each_reverse( begin, end, print );
620        } // ?|?
621} // distribution
622
623
624//*********************************** Istream ***********************************
625
626
627forall( dtype istype | istream( istype ) ) {
628        istype & ?|?( istype & is, bool & b ) {
629                char val[6];
630                fmt( is, "%5s", val );
631                if ( strcmp( val, "true" ) == 0 ) b = true;
632                else if ( strcmp( val, "false" ) == 0 ) b = false;
633                else {
634                        fprintf( stderr, "invalid Boolean constant\n" );
635                        abort();
636                } // if
637                return is;
638        } // ?|?
639
640        istype & ?|?( istype & is, char & c ) {
641                char temp;
642                for () {
643                        fmt( is, "%c", &temp );                                                 // must pass pointer through varg to fmt
644                        // do not overwrite parameter with newline unless appropriate
645                        if ( temp != '\n' || getANL( is ) ) { c = temp; break; }
646                        if ( eof( is ) ) break;
647                } // for
648                return is;
649        } // ?|?
650
651        istype & ?|?( istype & is, signed char & sc ) {
652                fmt( is, "%hhi", &sc );
653                return is;
654        } // ?|?
655
656        istype & ?|?( istype & is, unsigned char & usc ) {
657                fmt( is, "%hhi", &usc );
658                return is;
659        } // ?|?
660
661        istype & ?|?( istype & is, short int & si ) {
662                fmt( is, "%hi", &si );
663                return is;
664        } // ?|?
665
666        istype & ?|?( istype & is, unsigned short int & usi ) {
667                fmt( is, "%hi", &usi );
668                return is;
669        } // ?|?
670
671        istype & ?|?( istype & is, int & i ) {
672                fmt( is, "%i", &i );
673                return is;
674        } // ?|?
675
676        istype & ?|?( istype & is, unsigned int & ui ) {
677                fmt( is, "%i", &ui );
678                return is;
679        } // ?|?
680
681        istype & ?|?( istype & is, long int & li ) {
682                fmt( is, "%li", &li );
683                return is;
684        } // ?|?
685
686        istype & ?|?( istype & is, unsigned long int & ulli ) {
687                fmt( is, "%li", &ulli );
688                return is;
689        } // ?|?
690
691        istype & ?|?( istype & is, long long int & lli ) {
692                fmt( is, "%lli", &lli );
693                return is;
694        } // ?|?
695
696        istype & ?|?( istype & is, unsigned long long int & ulli ) {
697                fmt( is, "%lli", &ulli );
698                return is;
699        } // ?|?
700
701
702        istype & ?|?( istype & is, float & f ) {
703                fmt( is, "%f", &f );
704                return is;
705        } // ?|?
706
707        istype & ?|?( istype & is, double & d ) {
708                fmt( is, "%lf", &d );
709                return is;
710        } // ?|?
711
712        istype & ?|?( istype & is, long double & ld ) {
713                fmt( is, "%Lf", &ld );
714                return is;
715        } // ?|?
716
717
718        istype & ?|?( istype & is, float _Complex & fc ) {
719                float re, im;
720                fmt( is, "%f%fi", &re, &im );
721                fc = re + im * _Complex_I;
722                return is;
723        } // ?|?
724
725        istype & ?|?( istype & is, double _Complex & dc ) {
726                double re, im;
727                fmt( is, "%lf%lfi", &re, &im );
728                dc = re + im * _Complex_I;
729                return is;
730        } // ?|?
731
732        istype & ?|?( istype & is, long double _Complex & ldc ) {
733                long double re, im;
734                fmt( is, "%Lf%Lfi", &re, &im );
735                ldc = re + im * _Complex_I;
736                return is;
737        } // ?|?
738
739        // manipulators
740        istype & ?|?( istype & is, istype & (* manip)( istype & ) ) {
741                return manip( is );
742        } // ?|?
743
744        istype & nl( istype & is ) {
745                fmt( is, "%*[^\n]" );                                                   // ignore characters to newline
746                return is;
747        } // nl
748
749        istype & nlOn( istype & is ) {
750                nlOn( is );                                                                             // call void returning
751                return is;
752        } // nlOn
753
754        istype & nlOff( istype & is ) {
755                nlOff( is );                                                                    // call void returning
756                return is;
757        } // nlOff
758} // distribution
759
760_Istream_cstrUC cstr( char * str ) { return (_Istream_cstrUC){ str }; }
761forall( dtype istype | istream( istype ) )
762istype & ?|?( istype & is, _Istream_cstrUC cstr ) {
763        fmt( is, "%s", cstr.s );
764        return is;
765} // cstr
766
767_Istream_cstrC cstr( char * str, int size ) { return (_Istream_cstrC){ str, size }; }
768forall( dtype istype | istream( istype ) )
769istype & ?|?( istype & is, _Istream_cstrC cstr ) {
770        char buf[16];
771        sprintf( buf, "%%%ds", cstr.size );
772        fmt( is, buf, cstr.s );
773        return is;
774} // cstr
775
776#if 0
777forall( dtype istype | istream( istype ) )
778istype & ?|?( istype & is, _Istream_skip skip ) {
779        fmt( is, skip.s, "" );                                                          // no input arguments
780        return is;
781} // skip
782
783forall( dtype istype | istream( istype ) )
784istype & ?|?( istype & is, _Istream_incl incl ) {
785        size_t len = strlen( incl.scanset ) + 4;                        // extras: "%[]\0"
786        char fmtstr[len];
787        fmtstr[0] = '%'; fmtstr[1] = '[';
788        strcpy( &fmtstr[2], incl.scanset );                                     // after '[', copy includes '\0'
789        fmtstr[len - 2] = ']'; fmtstr[len - 1] = '\0';
790        fmt( is, fmtstr, incl.s );
791        return is;
792} // incl
793
794forall( dtype istype | istream( istype ) )
795istype & ?|?( istype & is, _Istream_excl excl ) {
796        size_t len = strlen( excl.scanset );
797        char fmtstr[len+5];
798        fmtstr[0] = '%'; fmtstr[1] = '['; fmtstr[2] = '^';
799        strcpy( &fmtstr[3], excl.scanset );                                     // after '^', copy includes '\0'
800        fmtstr[len - 2] = ']'; fmtstr[len - 1] = '\0';
801        fmt( is, fmtstr, excl.s );
802        return is;
803} // excl
804
805forall( dtype istype | istream( istype ) )
806istype & ?|?( istype & is, _Istream_cstr cstr ) {
807        fmt( is, "%s", cstr.s );
808        return is;
809} // cstr
810
811_Istream_cstrW cstr( char * s, int size ) { return (_Istream_cstrW){ s, size }; }
812forall( dtype istype | istream( istype ) )
813istype & ?|?( istype & is, _Istream_cstrW cstr ) {
814        enum { size = 16 };
815        char fmtstr[size];
816        sprintf( fmtstr, "%%%ds", cstr.size );
817        fmt( is, fmtstr, cstr.s );
818        return is;
819} // cstr
820
821forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, _Istream_Cstr ) {
822       
823}
824
825//*********************************** Manipulators ***********************************
826
827#define InputFMTImpl( T, CODE ) \
828forall( dtype istype | istream( istype ) ) \
829istype & ?|?( istype & is, _Istream_Manip(T) f ) { \
830        enum { size = 16 }; \
831        char fmtstr[size]; \
832        if ( f.wd == -1 ) { \
833                snprintf( fmtstr, size, "%%%s%s", f.ignore ? "*" : "", CODE ); \
834        } else { \
835                snprintf( fmtstr, size, "%%%s%d%s", f.ignore ? "*" : "", f.wd, CODE ); \
836        } /* if */ \
837        /* printf( "%d %s %p\n", f.wd, fmtstr, &f.val ); */ \
838        fmt( is, fmtstr, &f.val ); \
839        return is; \
840} /* ?|? */
841
842InputFMTImpl( char, "c" )
843InputFMTImpl( signed char, "hhi" )
844InputFMTImpl( unsigned char, "hhi" )
845InputFMTImpl( signed short int, "hi" )
846InputFMTImpl( unsigned short int, "hi" )
847InputFMTImpl( signed int, "i" )
848InputFMTImpl( unsigned int, "i" )
849InputFMTImpl( signed long int, "li" )
850InputFMTImpl( unsigned long int, "li" )
851InputFMTImpl( signed long long int, "lli" )
852InputFMTImpl( unsigned long long int, "lli" )
853
854InputFMTImpl( float, "f" )
855InputFMTImpl( double, "lf" )
856InputFMTImpl( long double, "Lf" )
857
858InputFMTImpl( float _Complex, "ff" )
859InputFMTImpl( double _Complex, "lf" )
860InputFMTImpl( long double _Complex, "Lf" )
861#endif // 0
862
863// Local Variables: //
864// tab-width: 4 //
865// compile-command: "cfa iostream.cfa" //
866// End: //
Note: See TracBrowser for help on using the repository browser.