[86bd7c1f] | 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 | // |
---|
[356189a] | 7 | // fstream.c -- |
---|
[86bd7c1f] | 8 | // |
---|
[90c3b1c] | 9 | // Author : Peter A. Buhr |
---|
[86bd7c1f] | 10 | // Created On : Wed May 27 17:56:53 2015 |
---|
[5d125e4] | 11 | // Last Modified By : Peter A. Buhr |
---|
[7baff35] | 12 | // Last Modified On : Mon Aug 14 18:24:21 2023 |
---|
| 13 | // Update Count : 534 |
---|
[86bd7c1f] | 14 | // |
---|
| 15 | |
---|
[f451177] | 16 | #include "fstream.hfa" // also includes iostream.hfa |
---|
[51b7345] | 17 | |
---|
[90c3b1c] | 18 | #include <stdio.h> // vfprintf, vfscanf |
---|
| 19 | #include <stdlib.h> // exit |
---|
| 20 | #include <stdarg.h> // varargs |
---|
[b431515] | 21 | #include <string.h> // strncpy, strerror |
---|
[91c389a] | 22 | #include <assert.h> |
---|
[8a25be9] | 23 | #include <errno.h> // errno |
---|
[51b7345] | 24 | |
---|
[cce4648] | 25 | #pragma GCC visibility push(default) |
---|
| 26 | |
---|
[7baff35] | 27 | |
---|
[8d321f9] | 28 | // *********************************** ofstream *********************************** |
---|
[65240bb] | 29 | |
---|
| 30 | |
---|
[53ba273] | 31 | #define IO_MSG "I/O error: " |
---|
[6ba0659] | 32 | |
---|
[7ce2483] | 33 | // private |
---|
| 34 | void ?{}( ofstream & os, void * file ) with( os ) { |
---|
[3bf3b6b] | 35 | file$ = file; |
---|
| 36 | sepDefault$ = true; |
---|
| 37 | sepOnOff$ = false; |
---|
| 38 | nlOnOff$ = true; |
---|
| 39 | prt$ = false; |
---|
| 40 | sawNL$ = false; |
---|
[6c5d92f] | 41 | sepSetCur$( os, sepGet( os ) ); |
---|
[5cb2b8c] | 42 | sepSet( os, " " ); |
---|
| 43 | sepSetTuple( os, ", " ); |
---|
[65240bb] | 44 | } // ?{} |
---|
[0583064b] | 45 | |
---|
[f5d9c37] | 46 | inline bool getNL$( ofstream & os ) { return os.sawNL$; } |
---|
| 47 | inline void setNL$( ofstream & os, bool state ) { os.sawNL$ = state; } |
---|
| 48 | inline bool getANL$( ofstream & os ) { return os.nlOnOff$; } |
---|
| 49 | |
---|
[7ce2483] | 50 | inline bool sepPrt$( ofstream & os ) { setNL$( os, false ); return os.sepOnOff$; } |
---|
| 51 | inline void sepReset$( ofstream & os ) { os.sepOnOff$ = os.sepDefault$; } |
---|
| 52 | inline void sepReset$( ofstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; } |
---|
| 53 | inline const char * sepGetCur$( ofstream & os ) { return os.sepCur$; } |
---|
| 54 | inline void sepSetCur$( ofstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; } |
---|
[f5d9c37] | 55 | |
---|
[7ce2483] | 56 | inline bool getPrt$( ofstream & os ) { return os.prt$; } |
---|
| 57 | inline void setPrt$( ofstream & os, bool state ) { os.prt$ = state; } |
---|
| 58 | |
---|
[c52f033] | 59 | inline void lock( ofstream & os ) with( os ) { lock( os.lock$ ); } |
---|
[7ce2483] | 60 | inline void unlock( ofstream & os ) { unlock( os.lock$ ); } |
---|
[829c907] | 61 | |
---|
[9ebd778] | 62 | // public |
---|
[6c5d92f] | 63 | void ?{}( ofstream & os ) { os.file$ = 0p; } |
---|
[7ce2483] | 64 | void ?{}( ofstream & os, const char name[], const char mode[] ) { open( os, name, mode ); } |
---|
| 65 | void ?{}( ofstream & os, const char name[] ) { open( os, name, "w" ); } |
---|
| 66 | void ^?{}( ofstream & os ) { close( os ); } |
---|
[4cae032] | 67 | |
---|
[f5d9c37] | 68 | void nlOn( ofstream & os ) { os.nlOnOff$ = true; } |
---|
| 69 | void nlOff( ofstream & os ) { os.nlOnOff$ = false; } |
---|
[09687aa] | 70 | |
---|
[f5d9c37] | 71 | void sep( ofstream & os ) { os.sepOnOff$ = ! getNL$( os ); } |
---|
| 72 | void nosep( ofstream & os ) { os.sepOnOff$ = false; } |
---|
[6152c81] | 73 | |
---|
[f5d9c37] | 74 | bool sepOn( ofstream & os ) { |
---|
[6c5d92f] | 75 | bool temp = os.sepDefault$; |
---|
| 76 | os.sepDefault$ = true; |
---|
| 77 | if ( os.sepOnOff$ ) sepReset$( os ); // start of line ? |
---|
[53ba273] | 78 | return temp; |
---|
[f5d9c37] | 79 | } // sepOn |
---|
[90c3b1c] | 80 | |
---|
[f5d9c37] | 81 | bool sepOff( ofstream & os ) { |
---|
| 82 | bool temp = os.sepDefault$; |
---|
| 83 | os.sepDefault$ = false; |
---|
| 84 | sepReset$( os ); |
---|
| 85 | return temp; |
---|
| 86 | } // sepOff |
---|
[200fcb3] | 87 | |
---|
[6c5d92f] | 88 | const char * sepGet( ofstream & os ) { return os.separator$; } |
---|
[e3fea42] | 89 | void sepSet( ofstream & os, const char s[] ) { |
---|
[9ebd778] | 90 | assert( s ); |
---|
[b431515] | 91 | strncpy( os.separator$, s, ofstream_sepSize - 1 ); |
---|
| 92 | os.separator$[ofstream_sepSize - 1] = '\0'; |
---|
[9ebd778] | 93 | } // sepSet |
---|
| 94 | |
---|
[6c5d92f] | 95 | const char * sepGetTuple( ofstream & os ) { return os.tupleSeparator$; } |
---|
[e3fea42] | 96 | void sepSetTuple( ofstream & os, const char s[] ) { |
---|
[9ebd778] | 97 | assert( s ); |
---|
[b431515] | 98 | strncpy( os.tupleSeparator$, s, ofstream_sepSize - 1 ); |
---|
| 99 | os.tupleSeparator$[ofstream_sepSize - 1] = '\0'; |
---|
[9ebd778] | 100 | } // sepSet |
---|
| 101 | |
---|
[65240bb] | 102 | void ends( ofstream & os ) { |
---|
[6c5d92f] | 103 | if ( getANL$( os ) ) nl( os ); |
---|
| 104 | else setPrt$( os, false ); // turn off |
---|
[65240bb] | 105 | if ( &os == &exit ) exit( EXIT_FAILURE ); |
---|
| 106 | if ( &os == &abort ) abort(); |
---|
| 107 | } // ends |
---|
| 108 | |
---|
[7ce2483] | 109 | bool fail( ofstream & os ) { return os.file$ == 0 || ferror( (FILE *)(os.file$) ); } |
---|
| 110 | void clear( ofstream & os ) { clearerr( (FILE *)(os.file$) ); } |
---|
| 111 | int flush( ofstream & os ) { return fflush( (FILE *)(os.file$) ); } |
---|
[6ba0659] | 112 | |
---|
[e3fea42] | 113 | void open( ofstream & os, const char name[], const char mode[] ) { |
---|
[8dcb832] | 114 | FILE * file; |
---|
| 115 | for ( cnt; 10 ) { |
---|
| 116 | errno = 0; |
---|
| 117 | file = fopen( name, mode ); |
---|
| 118 | if ( file != 0p || errno != EINTR ) break; // timer interrupt ? |
---|
| 119 | if ( cnt == 9 ) abort( "ofstream open EINTR spinning exceeded" ); |
---|
| 120 | } // for |
---|
[d1a9ff5] | 121 | if ( file == 0p ) { |
---|
[874b16e] | 122 | throw (open_failure){ os }; |
---|
[8d321f9] | 123 | // abort | IO_MSG "open output file \"" | name | "\"" | nl | strerror( errno ); |
---|
[93c2e0a] | 124 | } // if |
---|
[cce4648] | 125 | (os){ file }; // initialize |
---|
[6ba0659] | 126 | } // open |
---|
| 127 | |
---|
[7ce2483] | 128 | void open( ofstream & os, const char name[] ) { open( os, name, "w" ); } |
---|
[8da74119] | 129 | |
---|
[7ce2483] | 130 | void close( ofstream & os ) with( os ) { |
---|
[3bf3b6b] | 131 | if ( (FILE *)(file$) == 0p ) return; |
---|
| 132 | if ( (FILE *)(file$) == (FILE *)stdout || (FILE *)(file$) == (FILE *)stderr ) return; |
---|
[6ba0659] | 133 | |
---|
[8dcb832] | 134 | int ret; |
---|
| 135 | for ( cnt; 10 ) { |
---|
| 136 | errno = 0; |
---|
| 137 | ret = fclose( (FILE *)(file$) ); |
---|
| 138 | if ( ret != EOF || errno != EINTR ) break; // timer interrupt ? |
---|
| 139 | if ( cnt == 9 ) abort( "ofstream open EINTR spinning exceeded" ); |
---|
| 140 | } // for |
---|
| 141 | if ( ret == EOF ) { |
---|
[874b16e] | 142 | throw (close_failure){ os }; |
---|
[ba0d2ea] | 143 | // abort | IO_MSG "close output" | nl | strerror( errno ); |
---|
[356189a] | 144 | } // if |
---|
[7ce2483] | 145 | file$ = 0p; // safety after close |
---|
[6ba0659] | 146 | } // close |
---|
| 147 | |
---|
[e3fea42] | 148 | ofstream & write( ofstream & os, const char data[], size_t size ) { |
---|
[6ba0659] | 149 | if ( fail( os ) ) { |
---|
[874b16e] | 150 | throw (write_failure){ os }; |
---|
[ba0d2ea] | 151 | // abort | IO_MSG "attempt write I/O on failed stream"; |
---|
[6ba0659] | 152 | } // if |
---|
| 153 | |
---|
[6c5d92f] | 154 | if ( fwrite( data, 1, size, (FILE *)(os.file$) ) != size ) { |
---|
[874b16e] | 155 | throw (write_failure){ os }; |
---|
[ba0d2ea] | 156 | // abort | IO_MSG "write" | nl | strerror( errno ); |
---|
[839ccbb] | 157 | } // if |
---|
[86bd7c1f] | 158 | return os; |
---|
[839ccbb] | 159 | } // write |
---|
[51b7345] | 160 | |
---|
[09687aa] | 161 | int fmt( ofstream & os, const char format[], ... ) { |
---|
[5d125e4] | 162 | va_list args; |
---|
[829c907] | 163 | va_start( args, format ); |
---|
[cce4648] | 164 | |
---|
[8dcb832] | 165 | int len; |
---|
| 166 | for ( cnt; 10 ) { |
---|
| 167 | errno = 0; |
---|
[7a1b7e6] | 168 | disable_interrupts(); |
---|
[8dcb832] | 169 | len = vfprintf( (FILE *)(os.file$), format, args ); |
---|
[7a1b7e6] | 170 | enable_interrupts(); |
---|
[8dcb832] | 171 | if ( len != EOF || errno != EINTR ) break; // timer interrupt ? |
---|
| 172 | if ( cnt == 9 ) abort( "ofstream fmt EINTR spinning exceeded" ); |
---|
| 173 | } // for |
---|
[bbdf954] | 174 | if ( len == EOF ) { // error writing ? |
---|
| 175 | abort | IO_MSG "invalid write"; |
---|
[90c3b1c] | 176 | } // if |
---|
[5d125e4] | 177 | va_end( args ); |
---|
[b72bad4f] | 178 | |
---|
[6c5d92f] | 179 | setPrt$( os, true ); // called in output cascade |
---|
| 180 | sepReset$( os ); // reset separator |
---|
[90c3b1c] | 181 | return len; |
---|
[829c907] | 182 | } // fmt |
---|
| 183 | |
---|
[fd8f88f] | 184 | static ofstream soutFile = { (FILE *)stdout }; |
---|
[a87d40b] | 185 | ofstream & sout = soutFile, & stdout = soutFile; |
---|
[fd8f88f] | 186 | static ofstream serrFile = { (FILE *)stderr }; |
---|
[a87d40b] | 187 | ofstream & serr = serrFile, & stderr = serrFile; |
---|
[51b7345] | 188 | |
---|
[e474cf09] | 189 | static ofstream lsoutFile = { (FILE *)stdout }; |
---|
| 190 | ofstream & lsout = lsoutFile; |
---|
| 191 | |
---|
[fd8f88f] | 192 | static ofstream exitFile = { (FILE *)stdout }; |
---|
[65240bb] | 193 | ofstream & exit = exitFile; |
---|
[fd8f88f] | 194 | static ofstream abortFile = { (FILE *)stderr }; |
---|
[65240bb] | 195 | ofstream & abort = abortFile; |
---|
[5cb2b8c] | 196 | |
---|
[f451177] | 197 | ofstream & nl( ofstream & os ) { |
---|
| 198 | nl$( os ); // call basic_ostream nl |
---|
| 199 | flush( os ); |
---|
| 200 | return os; |
---|
| 201 | } // nl |
---|
[90c3b1c] | 202 | |
---|
[00e9be9] | 203 | |
---|
[8d321f9] | 204 | // *********************************** ifstream *********************************** |
---|
[65240bb] | 205 | |
---|
[51b7345] | 206 | |
---|
[09687aa] | 207 | // private |
---|
[7ce2483] | 208 | void ?{}( ifstream & is, void * file ) with( is ) { |
---|
[3bf3b6b] | 209 | file$ = file; |
---|
| 210 | nlOnOff$ = false; |
---|
[65240bb] | 211 | } // ?{} |
---|
[09687aa] | 212 | |
---|
[c8371b5] | 213 | bool getANL$( ifstream & os ) { return os.nlOnOff$; } |
---|
| 214 | |
---|
[7ce2483] | 215 | inline void lock( ifstream & os ) with( os ) { lock( os.lock$ ); } |
---|
| 216 | inline void unlock( ifstream & os ) { unlock( os.lock$ ); } |
---|
| 217 | |
---|
[09687aa] | 218 | // public |
---|
[6c5d92f] | 219 | void ?{}( ifstream & is ) { is.file$ = 0p; } |
---|
[7ce2483] | 220 | void ?{}( ifstream & is, const char name[], const char mode[] ) { open( is, name, mode ); } |
---|
| 221 | void ?{}( ifstream & is, const char name[] ) { open( is, name, "r" ); } |
---|
| 222 | void ^?{}( ifstream & is ) { close( is ); } |
---|
[4cae032] | 223 | |
---|
[7ce2483] | 224 | bool fail( ifstream & is ) { return is.file$ == 0p || ferror( (FILE *)(is.file$) ); } |
---|
| 225 | void clear( ifstream & is ) { clearerr( (FILE *)(is.file$) ); } |
---|
[00e9be9] | 226 | |
---|
[c8371b5] | 227 | void nlOn( ifstream & os ) { os.nlOnOff$ = true; } |
---|
| 228 | void nlOff( ifstream & os ) { os.nlOnOff$ = false; } |
---|
| 229 | |
---|
| 230 | void ends( ifstream & is ) {} |
---|
[e474cf09] | 231 | |
---|
[c8371b5] | 232 | bool eof( ifstream & is ) { return feof( (FILE *)(is.file$) ) != 0; } |
---|
[6ba0659] | 233 | |
---|
[e3fea42] | 234 | void open( ifstream & is, const char name[], const char mode[] ) { |
---|
[8dcb832] | 235 | FILE * file; |
---|
| 236 | for ( cnt; 10 ) { |
---|
| 237 | errno = 0; |
---|
| 238 | file = fopen( name, mode ); |
---|
| 239 | if ( file != 0p || errno != EINTR ) break; // timer interrupt ? |
---|
| 240 | if ( cnt == 9 ) abort( "ifstream open EINTR spinning exceeded" ); |
---|
| 241 | } // for |
---|
[d1a9ff5] | 242 | if ( file == 0p ) { |
---|
[874b16e] | 243 | throw (open_failure){ is }; |
---|
[8d321f9] | 244 | // abort | IO_MSG "open input file \"" | name | "\"" | nl | strerror( errno ); |
---|
[93c2e0a] | 245 | } // if |
---|
[cce4648] | 246 | (is){ file }; // initialize |
---|
[90c3b1c] | 247 | } // open |
---|
[6ba0659] | 248 | |
---|
[7ce2483] | 249 | void open( ifstream & is, const char name[] ) { open( is, name, "r" ); } |
---|
[8da74119] | 250 | |
---|
[7ce2483] | 251 | void close( ifstream & is ) with( is ) { |
---|
[3bf3b6b] | 252 | if ( (FILE *)(file$) == 0p ) return; |
---|
| 253 | if ( (FILE *)(file$) == (FILE *)stdin ) return; |
---|
[90c3b1c] | 254 | |
---|
[8dcb832] | 255 | int ret; |
---|
| 256 | for ( cnt; 10 ) { |
---|
| 257 | errno = 0; |
---|
| 258 | ret = fclose( (FILE *)(file$) ); |
---|
| 259 | if ( ret != EOF || errno != EINTR ) break; // timer interrupt ? |
---|
| 260 | if ( cnt == 9 ) abort( "ifstream close EINTR spinning exceeded" ); |
---|
| 261 | } // for |
---|
| 262 | if ( ret == EOF ) { |
---|
[874b16e] | 263 | throw (close_failure){ is }; |
---|
[ba0d2ea] | 264 | // abort | IO_MSG "close input" | nl | strerror( errno ); |
---|
[356189a] | 265 | } // if |
---|
[8dcb832] | 266 | file$ = 0p; // safety after close |
---|
[90c3b1c] | 267 | } // close |
---|
| 268 | |
---|
[00e9be9] | 269 | ifstream & read( ifstream & is, char data[], size_t size ) { |
---|
[6ba0659] | 270 | if ( fail( is ) ) { |
---|
[874b16e] | 271 | throw (read_failure){ is }; |
---|
[ba0d2ea] | 272 | // abort | IO_MSG "attempt read I/O on failed stream"; |
---|
[6ba0659] | 273 | } // if |
---|
| 274 | |
---|
[6c5d92f] | 275 | if ( fread( data, size, 1, (FILE *)(is.file$) ) == 0 ) { |
---|
[874b16e] | 276 | throw (read_failure){ is }; |
---|
[ba0d2ea] | 277 | // abort | IO_MSG "read" | nl | strerror( errno ); |
---|
[6ba0659] | 278 | } // if |
---|
[86bd7c1f] | 279 | return is; |
---|
[6ba0659] | 280 | } // read |
---|
[356189a] | 281 | |
---|
[09687aa] | 282 | ifstream &ungetc( ifstream & is, char c ) { |
---|
[6ba0659] | 283 | if ( fail( is ) ) { |
---|
[ff2a33e] | 284 | abort | IO_MSG "attempt ungetc I/O on failed stream"; |
---|
[6ba0659] | 285 | } // if |
---|
[51b7345] | 286 | |
---|
[6c5d92f] | 287 | if ( ungetc( c, (FILE *)(is.file$) ) == EOF ) { |
---|
[ff2a33e] | 288 | abort | IO_MSG "ungetc" | nl | strerror( errno ); |
---|
[6ba0659] | 289 | } // if |
---|
| 290 | return is; |
---|
| 291 | } // ungetc |
---|
[51b7345] | 292 | |
---|
[09687aa] | 293 | int fmt( ifstream & is, const char format[], ... ) { |
---|
[5d125e4] | 294 | va_list args; |
---|
[829c907] | 295 | va_start( args, format ); |
---|
[8dcb832] | 296 | |
---|
| 297 | int len; |
---|
| 298 | for () { // no check for EINTR limit waiting for keyboard input |
---|
| 299 | errno = 0; |
---|
[7a1b7e6] | 300 | disable_interrupts(); |
---|
[8dcb832] | 301 | len = vfscanf( (FILE *)(is.file$), format, args ); |
---|
[7a1b7e6] | 302 | enable_interrupts(); |
---|
[8dcb832] | 303 | if ( len != EOF || errno != EINTR ) break; // timer interrupt ? |
---|
| 304 | } // for |
---|
[bbdf954] | 305 | if ( len == EOF ) { // EOF or matching failure ? |
---|
| 306 | if ( ! feof( (FILE *)(is.file$) ) && ferror( (FILE *)(is.file$) ) ) { |
---|
[ff2a33e] | 307 | abort | IO_MSG "invalid read"; |
---|
[90c3b1c] | 308 | } // if |
---|
| 309 | } // if |
---|
[5d125e4] | 310 | va_end( args ); |
---|
[90c3b1c] | 311 | return len; |
---|
[829c907] | 312 | } // fmt |
---|
[51b7345] | 313 | |
---|
[fd8f88f] | 314 | static ifstream sinFile = { (FILE *)stdin }; |
---|
[a87d40b] | 315 | ifstream & sin = sinFile, & stdin = sinFile; |
---|
[86bd7c1f] | 316 | |
---|
[91e52be] | 317 | |
---|
[8d321f9] | 318 | // *********************************** exceptions *********************************** |
---|
[91e52be] | 319 | |
---|
| 320 | |
---|
[874b16e] | 321 | static vtable(open_failure) open_failure_vt; |
---|
[a5a6a1a8] | 322 | |
---|
| 323 | // exception I/O constructors |
---|
[874b16e] | 324 | void ?{}( open_failure & ex, ofstream & ostream ) with(ex) { |
---|
| 325 | virtual_table = &open_failure_vt; |
---|
[3bf3b6b] | 326 | ostream = &ostream; |
---|
| 327 | tag = 1; |
---|
[a5a6a1a8] | 328 | } // ?{} |
---|
| 329 | |
---|
[874b16e] | 330 | void ?{}( open_failure & ex, ifstream & istream ) with(ex) { |
---|
| 331 | virtual_table = &open_failure_vt; |
---|
[3bf3b6b] | 332 | istream = &istream; |
---|
| 333 | tag = 0; |
---|
[a5a6a1a8] | 334 | } // ?{} |
---|
| 335 | |
---|
| 336 | |
---|
[874b16e] | 337 | static vtable(close_failure) close_failure_vt; |
---|
[ba0d2ea] | 338 | |
---|
| 339 | // exception I/O constructors |
---|
[874b16e] | 340 | void ?{}( close_failure & ex, ofstream & ostream ) with(ex) { |
---|
| 341 | virtual_table = &close_failure_vt; |
---|
[3bf3b6b] | 342 | ostream = &ostream; |
---|
| 343 | tag = 1; |
---|
[ba0d2ea] | 344 | } // ?{} |
---|
| 345 | |
---|
[874b16e] | 346 | void ?{}( close_failure & ex, ifstream & istream ) with(ex) { |
---|
| 347 | virtual_table = &close_failure_vt; |
---|
[3bf3b6b] | 348 | istream = &istream; |
---|
| 349 | tag = 0; |
---|
[ba0d2ea] | 350 | } // ?{} |
---|
| 351 | |
---|
| 352 | |
---|
[874b16e] | 353 | static vtable(write_failure) write_failure_vt; |
---|
[ba0d2ea] | 354 | |
---|
| 355 | // exception I/O constructors |
---|
[874b16e] | 356 | void ?{}( write_failure & ex, ofstream & ostream ) with(ex) { |
---|
| 357 | virtual_table = &write_failure_vt; |
---|
[3bf3b6b] | 358 | ostream = &ostream; |
---|
| 359 | tag = 1; |
---|
[ba0d2ea] | 360 | } // ?{} |
---|
| 361 | |
---|
[874b16e] | 362 | void ?{}( write_failure & ex, ifstream & istream ) with(ex) { |
---|
| 363 | virtual_table = &write_failure_vt; |
---|
[3bf3b6b] | 364 | istream = &istream; |
---|
| 365 | tag = 0; |
---|
[ba0d2ea] | 366 | } // ?{} |
---|
| 367 | |
---|
| 368 | |
---|
[874b16e] | 369 | static vtable(read_failure) read_failure_vt; |
---|
[ba0d2ea] | 370 | |
---|
| 371 | // exception I/O constructors |
---|
[874b16e] | 372 | void ?{}( read_failure & ex, ofstream & ostream ) with(ex) { |
---|
| 373 | virtual_table = &read_failure_vt; |
---|
[3bf3b6b] | 374 | ostream = &ostream; |
---|
| 375 | tag = 1; |
---|
[ba0d2ea] | 376 | } // ?{} |
---|
| 377 | |
---|
[874b16e] | 378 | void ?{}( read_failure & ex, ifstream & istream ) with(ex) { |
---|
| 379 | virtual_table = &read_failure_vt; |
---|
[3bf3b6b] | 380 | istream = &istream; |
---|
| 381 | tag = 0; |
---|
[ba0d2ea] | 382 | } // ?{} |
---|
| 383 | |
---|
[874b16e] | 384 | // void throwopen_failure( ofstream & ostream ) { |
---|
| 385 | // open_failure exc = { ostream }; |
---|
[ba0d2ea] | 386 | // } |
---|
| 387 | |
---|
[874b16e] | 388 | // void throwopen_failure( ifstream & istream ) { |
---|
| 389 | // open_failure exc = { istream }; |
---|
[ba0d2ea] | 390 | // } |
---|
[91e52be] | 391 | |
---|
[86bd7c1f] | 392 | // Local Variables: // |
---|
| 393 | // tab-width: 4 // |
---|
| 394 | // End: // |
---|