![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to filebuf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / libC / iostream|
Return to filebuf.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / libC / iostream |
1.1 ! root 1: /*ident "@(#)ctrans:lib/stream/filebuf.c 1.1.2.2" */ ! 2: /************************************************************************** ! 3: Copyright (c) 1984 AT&T ! 4: All Rights Reserved ! 5: ! 6: THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T ! 7: ! 8: The copyright notice above does not evidence any ! 9: actual or intended publication of such source code. ! 10: ! 11: filebuf.c: ! 12: ! 13: *****************************************************************************/ ! 14: ! 15: #include <iostream.h> ! 16: #include <fstream.h> ! 17: ! 18: #include "streamdefs.h" ! 19: ! 20: #ifdef STDIO_ONLY ! 21: #include <stdio.h> ! 22: ! 23: static int open(const char* name,int flags, int prot = 0) ; ! 24: static int creat(const char* name, int prot ) ; ! 25: static streampos lseek(int fd, long, ios::seek_dir) ; ! 26: static int read(int fd, char* b, int len) ; ! 27: static int write(int fd, char* b, int len) ; ! 28: static int close(int fd) ; ! 29: #else ! 30: ! 31: #include <osfcn.h> ! 32: ! 33: #ifndef O_RDONLY ! 34: #include <fcntl.h> ! 35: #endif ! 36: ! 37: #endif /* STDIO_ONLY */ ! 38: ! 39: #ifndef O_RDONLY ! 40: # define O_RDONLY 0 ! 41: #endif ! 42: ! 43: #ifndef O_WRONLY ! 44: # define O_WRONLY 1 ! 45: #endif ! 46: ! 47: #ifndef O_RDWR ! 48: # define O_RDWR 2 ! 49: #endif ! 50: ! 51: #ifndef O_CREAT ! 52: # define O_CREAT 00400 ! 53: #endif ! 54: ! 55: #ifndef O_TRUNC ! 56: # define O_TRUNC 01000 ! 57: #endif ! 58: ! 59: #ifndef O_EXCL ! 60: # define O_EXCL 02000 ! 61: #endif ! 62: ! 63: #ifndef O_APPEND ! 64: static const int NOSYSAPPEND = 1 ; ! 65: # define O_APPEND 010 ! 66: #else ! 67: static const int NOSYSAPPEND = 0 ; ! 68: #endif ! 69: ! 70: #include <errno.h> ! 71: extern int errno ; ! 72: ! 73: const int filebuf::openprot = 0644 ; ! 74: ! 75: static const int input=ios::in ; ! 76: static const int output=ios::out ; ! 77: static const int append=ios::app ; ! 78: static const int atend=ios::ate ; ! 79: static const int tcate=ios::trunc ; ! 80: static const int nocr=ios::nocreate ; ! 81: static const int norep=ios::noreplace ; ! 82: ! 83: static const int seek_beg=ios::beg ; ! 84: static const int seek_end=ios::end ; ! 85: static const int seek_cur=ios::cur ; ! 86: ! 87: int filebuf::last_op() ! 88: { ! 89: return (pptr()?output:(gptr()?input:0)) ; ! 90: } ! 91: ! 92: inline void save_errno(int& orig) ! 93: { ! 94: orig = ::errno ; ! 95: ::errno = 0 ; ! 96: } ! 97: ! 98: inline int restore_errno(int& orig) ! 99: { ! 100: if ( ::errno == 0 ) ::errno = orig ; ! 101: return EOF ; ! 102: } ! 103: ! 104: /* ! 105: * Open a file with the given mode. ! 106: * Return: NULL if failure ! 107: * this if success ! 108: */ ! 109: filebuf* filebuf::open (const char *name, int om, int prot) ! 110: { ! 111: int errno_orig ; ! 112: save_errno(errno_orig) ; ! 113: if ( om&append ) om |= output ; ! 114: ! 115: if ( opened ) { ! 116: restore_errno(errno_orig) ; ! 117: return 0 ; ! 118: } ! 119: ! 120: int flags = 0 ; ! 121: if ( om&append ) flags |= O_APPEND ; ! 122: ! 123: switch (om&(input|output)) { ! 124: case input : ! 125: flags |= O_RDONLY ; ! 126: xfd = ::open(name,flags) ; ! 127: break ; ! 128: ! 129: case output : ! 130: flags |= O_WRONLY|O_CREAT|O_TRUNC ; ! 131: if ( om&nocr ) flags &= ~O_CREAT ; ! 132: if ( om&norep ) flags |= O_CREAT|O_EXCL ; ! 133: if ( om&append ) flags |= O_APPEND ; ! 134: if ( om&(append|atend) ) flags &= ~O_TRUNC ; ! 135: if ( flags == (O_WRONLY|O_CREAT|O_TRUNC) ) { ! 136: xfd = ::creat(name,prot) ; ! 137: } ! 138: else { ! 139: xfd = ::open(name,flags,prot) ; ! 140: } ! 141: ! 142: if ( xfd >= 0 && (om&(atend|append))) lseek(xfd,0,2) ; ! 143: break ; ! 144: ! 145: case input|output: ! 146: flags |= O_RDWR|O_CREAT ; ! 147: if ( om&tcate ) flags |= O_TRUNC ; ! 148: if ( om&append ) flags |= O_APPEND ; ! 149: if ( om&nocr ) flags &= ~O_CREAT ; ! 150: xfd = ::open(name,flags,prot) ; ! 151: if ( xfd >= 0 && (om&(atend|append))) lseek(xfd,0,2) ; ! 152: break; ! 153: } ! 154: ! 155: if (xfd < 0) return 0; ! 156: ! 157: opened = 1; ! 158: setp(0,0) ; ! 159: setg(0,0,0) ; ! 160: mode = om ; ! 161: last_seek = EOF ; ! 162: restore_errno(errno_orig) ; ! 163: return this; ! 164: } ! 165: ! 166: filebuf* filebuf::attach (int f) ! 167: { ! 168: if ( opened ) return 0 ; ! 169: xfd = f; ! 170: opened = 1; ! 171: setp(0,0) ; ! 172: setg(0,0,0) ; ! 173: mode=0 ; ! 174: last_seek= EOF; ! 175: return this; ! 176: } ! 177: ! 178: /* ! 179: * Empty an output buffer. ! 180: * Returns: EOF on error ! 181: * 0 on success ! 182: */ ! 183: int filebuf::overflow(int c) ! 184: { ! 185: int errno_orig ; ! 186: save_errno(errno_orig) ; ! 187: if ( !opened ) return restore_errno(errno_orig) ; ! 188: if ( allocate() == EOF ) return restore_errno(errno_orig) ; ! 189: if ( last_op() == input ) { ! 190: if ( sync()==EOF ) return restore_errno(errno_orig) ; ! 191: } ! 192: ! 193: register char* p = base() ; ! 194: // pptr()==NULL does not imply p < pptr(), so we need separate ! 195: // test. ! 196: while ( pptr() && p < pptr() ) { ! 197: if ( NOSYSAPPEND && (mode&append) ) { ! 198: // System doesn't have an append mode, so approximate ! 199: // as best we can. ! 200: lseek(xfd,0,2) ; ! 201: } ! 202: /* Partial writes are sometimes possible in peculiar ! 203: * circumstances */ ! 204: register int count = write(xfd,p,pptr()-p) ; ! 205: if ( count < 0 ) { ! 206: last_seek = EOF ; ! 207: return restore_errno(errno_orig) ; ! 208: } ! 209: p += count ; ! 210: ! 211: if ( SEEK_ARITH_OK ! 212: && last_seek != EOF ! 213: && mode && !(mode&append) ! 214: && count >= 0 ) { ! 215: last_seek += count ; ! 216: } else { ! 217: last_seek = EOF ; ! 218: } ! 219: ! 220: if ( count < 0 ) return restore_errno(errno_orig) ; ! 221: } ! 222: ! 223: setp(base(),ebuf()) ; ! 224: setg(0,0,0); ! 225: ! 226: if ( c == EOF ) /* don't do anything */ ; ! 227: else if ( unbuffered() ) { ! 228: char ch = c; ! 229: last_seek = EOF ; ! 230: while ( write(xfd,&ch,1)!=1 && ::errno==0 ) ; ! 231: if ( ::errno != 0 ) return restore_errno(errno_orig) ; ! 232: } ! 233: else { ! 234: sputc(c) ; ! 235: } ! 236: ! 237: restore_errno(errno_orig) ; ! 238: return zapeof(c) ; ! 239: } ! 240: ! 241: ! 242: /* ! 243: * Fill an input buffer. ! 244: * Returns: EOF on error or end of input ! 245: * next character on success ! 246: */ ! 247: int filebuf::underflow() ! 248: { ! 249: int count; ! 250: ! 251: if ( !opened ) return EOF ; ! 252: if ( allocate() == EOF ) return EOF ; ! 253: if ( last_op() == output ) { ! 254: if ( sync()==EOF ) return EOF ; ! 255: } ! 256: int orig_errno ; ! 257: save_errno(orig_errno) ; ! 258: setp(0,0) ; ! 259: if ( unbuffered() ) { ! 260: last_seek=EOF ; ! 261: count = read(xfd,&lahead[0],1) ; ! 262: setg(&lahead[0],&lahead[0],&lahead[count]) ; ! 263: if ( count <= 0 ) return EOF ; ! 264: } ! 265: else { ! 266: register int rdsize ; ! 267: if ( blen() > 2*sizeof(long) ) { ! 268: /* gptr must be set greater than base to ! 269: * guarantee at least 1 char of pushback. ! 270: * putting it farther will tend in many common ! 271: * cases to keep things aligned. ! 272: */ ! 273: in_start = base()+sizeof(long) ; ! 274: rdsize = blen()-sizeof(long) ; ! 275: } else { ! 276: in_start = base()+1 ; ! 277: rdsize = blen()-1 ; ! 278: } ! 279: count = read(xfd,in_start,rdsize) ; ! 280: while ( count<=0 && ::errno==EINTR ) { ! 281: /* ! 282: * Signal caught and returned before any data ! 283: * transfered. ! 284: */ ! 285: ::errno = 0 ; ! 286: count = read(xfd,in_start,rdsize) ; ! 287: } ! 288: ! 289: if ( SEEK_ARITH_OK ! 290: && last_seek != EOF ! 291: && mode && !(mode&append) ! 292: && count >= 0 ) { ! 293: last_seek += count ; ! 294: } else { ! 295: last_seek = EOF ; ! 296: } ! 297: ! 298: if ( count <= 0 ) { ! 299: setg(0,0,0) ; ! 300: return restore_errno(orig_errno) ; ! 301: } ! 302: setg(base(),in_start,in_start+count) ; ! 303: } ! 304: ! 305: restore_errno(orig_errno) ; ! 306: return zapeof(*gptr()); ! 307: } ! 308: ! 309: filebuf* filebuf::close() ! 310: { ! 311: int f = xfd ; ! 312: if ( !opened ) { ! 313: return 0 ; ! 314: } ! 315: if (last_op()==output) overflow(); ! 316: setg(0,0,0) ; ! 317: setp(0,0) ; ! 318: opened = 0 ; ! 319: xfd = -1 ; ! 320: last_seek = EOF ; ! 321: if ( mode != 0 ) { ! 322: mode = 0 ; ! 323: int orig_errno ; ! 324: save_errno(orig_errno) ; ! 325: int ok = ::close(f); ! 326: restore_errno(orig_errno) ; ! 327: return ( ok==EOF ? 0 : this ) ; ! 328: } else { ! 329: return this ; ! 330: } ! 331: } ! 332: ! 333: int filebuf::sync() ! 334: { ! 335: int ok = 0 ; ! 336: int orig_errno ; ! 337: save_errno(orig_errno) ; ! 338: switch(last_op()) { ! 339: case input: ! 340: last_seek = lseek(xfd,gptr()-egptr(),seek_cur) ; ! 341: if ( last_seek < 0 ) { ! 342: ok = EOF ; ! 343: last_seek = EOF ; ! 344: } ! 345: break ; ! 346: case output: ! 347: ok = overflow() ; ! 348: /* This does not result in infinite recursion even though ! 349: * under some circumstances overflow might call sync. ! 350: * it explicitly does not when last_op==output ! 351: */ ! 352: break; ! 353: } ! 354: setp(0,0) ; ! 355: setg(0,0,0) ; ! 356: last_seek = EOF ; ! 357: restore_errno(orig_errno) ; ! 358: return (ok==EOF ? EOF : 0 ) ; ! 359: } ! 360: ! 361: streampos filebuf::seekoff(streamoff p, ios::seek_dir d, int m) ! 362: { ! 363: int orig_errno ; ! 364: save_errno(orig_errno) ; ! 365: ! 366: if ( last_seek == EOF ) { ! 367: last_seek = lseek(xfd,0,seek_cur) ; ! 368: } ! 369: if ( last_seek == EOF ) return EOF ; ! 370: if( SEEK_ARITH_OK && !unbuffered() ) { ! 371: char* refptr = 0 ; ! 372: streampos sneed ; ! 373: streampos sref, minavail, maxavail ; ! 374: ! 375: switch ( last_op() ) { ! 376: case input : { ! 377: refptr = gptr() ; ! 378: sref = last_seek-(egptr()-gptr()) ; ! 379: minavail = last_seek-(egptr()-in_start) ; ! 380: maxavail = last_seek-1 ; ! 381: } break ; ! 382: case output : { ! 383: // only allowable seek during output is ! 384: // to present position. ! 385: refptr = pptr() ; ! 386: sref = last_seek+pptr()-pbase() ; ! 387: minavail = maxavail = sref ; ! 388: } break ; ! 389: } ! 390: switch( d ) { ! 391: case seek_beg : sneed = p ; break ; ! 392: case seek_cur : sneed = sref+p ;break ; ! 393: case seek_end : refptr = 0 ; break ; ! 394: /* Can't do seek_end */ ! 395: } ! 396: if ( refptr && sneed >= minavail && sneed <= maxavail ) { ! 397: switch( last_op() ) { ! 398: case input : { ! 399: setg(eback(),refptr+(sneed-sref),egptr()); ! 400: } break ; ! 401: case output : { ! 402: // Seeking to current position. Nothing to ! 403: // do. ! 404: } break ; ! 405: default : { ! 406: // shouldn't get here. Try to recover somehow ! 407: sync() ; ! 408: seekoff(p,d,m); ! 409: } break ; ! 410: } ! 411: return sneed ; ! 412: } ! 413: if ( refptr && sneed < sref && sneed+blen()/2 > sref ! 414: && last_op() == input ) { ! 415: // looks like we are stepping backward through ! 416: // a file. Performance may be improved by ! 417: // backing up a little extra. ! 418: ! 419: streampos toofar = sneed-blen()/2 ; ! 420: if ( toofar < 0 ) toofar = 0 ; ! 421: sync() ; ! 422: last_seek=lseek(xfd,toofar,seek_beg) ; ! 423: overflow(); ! 424: seekoff(p,d,m); ! 425: } ! 426: } ! 427: ! 428: restore_errno(orig_errno) ; ! 429: if ( sync()==EOF ) return EOF ; ! 430: else { ! 431: last_seek=lseek(xfd,p,d) ; ! 432: return last_seek ; ! 433: } ! 434: } ! 435: ! 436: filebuf::filebuf() ! 437: : xfd(-1), opened(0), mode(0), last_seek(EOF) ! 438: { ! 439: ! 440: } ! 441: ! 442: filebuf::filebuf(int f) ! 443: : xfd(f), opened(1), mode(0), last_seek(EOF) ! 444: { ! 445: ! 446: } ! 447: ! 448: filebuf::filebuf(int f, char* p, int l) ! 449: : streambuf(p,l), xfd(f), opened(1), mode(0), last_seek(EOF) ! 450: { ! 451: ! 452: } ! 453: ! 454: filebuf::~filebuf() { ! 455: close() ; ! 456: } ! 457: ! 458: streambuf* filebuf::setbuf(char* p , int len) ! 459: { ! 460: if ( is_open() && base() ) return 0 ; ! 461: // Note the special case of allowing buffering to be turned ! 462: // on even for an already opened filebuf. ! 463: setb(0,0) ; ! 464: return streambuf::setbuf(p,len) ; ! 465: } ! 466: ! 467: #ifdef STDIO_ONLY ! 468: ! 469: /**** ! 470: The following functions will simulate the UNIX function ! 471: calls using stdio operations. They are intended for ! 472: non-unix environments. Simulation is not perfect and ! 473: there may be problems porting code to such environments. ! 474: In particular issues of binary files are not dealt with ! 475: here ! 476: *****/ ! 477: #ifndef SEEK_SET ! 478: # define SEEK_SET 0 ! 479: #endif ! 480: ! 481: #ifndef SEEK_CUR ! 482: # define SEEK_CUR 1 ! 483: #endif ! 484: ! 485: #ifndef SEEK_END ! 486: # define SEEK_END 2 ! 487: #endif ! 488: ! 489: typedef FILE* Filep ; ! 490: ! 491: static Filep* files = 0 ; ! 492: static int nfiles = 0 ; ! 493: ! 494: static Filep zfp ; ! 495: ! 496: static Filep& file(int fd) ! 497: { ! 498: if ( fd < nfiles ) return files[fd] ; ! 499: if ( !files ) { ! 500: files = new Filep [3] ; ! 501: if ( !files ) { ! 502: // Malloc failed. We're in deep trouble ! 503: return zfp ; ! 504: } ! 505: files[0] = stdin ; ! 506: files[1] = stdout ; ! 507: files[2] = stderr ; ! 508: nfiles = 3 ; ! 509: } ! 510: if ( fd < nfiles ) return files[fd] ; ! 511: ! 512: Filep* newfiles = new Filep [2*nfiles] ; ! 513: if ( !newfiles ) { ! 514: // Oh dear malloc failed. There isn't really any ! 515: // reasonable recovery, so I just kind of boot. ! 516: return zfp ; ! 517: } ! 518: int x ; ! 519: for ( x = 0 ; x < nfiles ; ++x) newfiles[x] = files[x] ; ! 520: nfiles = 2*nfiles ; ! 521: for ( ; x < nfiles ; ++x ) newfiles[x] = 0 ; ! 522: delete files ; ! 523: files = newfiles ; ! 524: return files[fd] ; ! 525: } ! 526: ! 527: static int xfile() ! 528: { ! 529: if ( !files ) file(0) ; ! 530: for ( int x = 0 ; x < nfiles ; ++x ) { ! 531: if ( !files[x] ) return x ; ! 532: } ! 533: return nfiles ; ! 534: } ! 535: ! 536: static int open(const char* name, int flags, int ) ! 537: { ! 538: /* not all modes can be simulated using stdio, sorry */ ! 539: char* type = "" ; ! 540: switch ( flags & 03 ) { ! 541: case 0 : /* RD_ONLY */ { ! 542: type = "r" ; ! 543: } break ; ! 544: case 1 : /* WR_ONLY */ { ! 545: if ( flags & O_TRUNC ) type = "w" ; ! 546: else type = "a" ; ! 547: } break ; ! 548: case 2 : /* RDWR */ { ! 549: if ( flags & O_TRUNC) type = "w+" ; ! 550: else if ( flags & O_APPEND ) type = "a+" ; ! 551: else type = "r+" ; ! 552: } break ; ! 553: } ! 554: ! 555: int x = xfile() ; ! 556: if ( x < 0 ) return -1 ; ! 557: Filep* xfile = &file(x) ; ! 558: *xfile = fopen(name, type) ; ! 559: return ( *xfile ? x : -1 ) ; ! 560: } ! 561: ! 562: static int creat(const char* name, int) ! 563: { ! 564: return open(name,O_WRONLY|O_CREAT|O_TRUNC,0) ; ! 565: } ! 566: ! 567: static streampos lseek(int fd, long n, ios::seek_dir d ) ! 568: { ! 569: int whence ; ! 570: switch ( d ) { ! 571: case seek_beg : whence = SEEK_SET ; break ; ! 572: case seek_cur : whence = SEEK_CUR ; break ; ! 573: case seek_end : whence = SEEK_END ; break ; ! 574: } ! 575: Filep f = file(fd) ; ! 576: if ( !f ) return EOF ; ! 577: int fail = fseek(f, n, whence ) ; ! 578: if ( fail ) return EOF ; ! 579: return ftell(f) ; ! 580: } ! 581: ! 582: ! 583: static int read(int fd, char* b, int len) ! 584: { ! 585: Filep f = file(fd) ; ! 586: if ( !f ) return 0 ; ! 587: return fread(b,1,len,file(fd)) ; ! 588: } ! 589: ! 590: static int write(int fd, char* b, int len) ! 591: { ! 592: Filep f = file(fd) ; ! 593: if ( !f ) return 0 ; ! 594: int n = fwrite(b,1,len,f) ; ! 595: fflush(f) ; ! 596: return n ; ! 597: } ! 598: ! 599: static int close(int fd) ! 600: { ! 601: Filep f = file(fd) ; ! 602: if (!f ) return 0 ; ! 603: return fclose(f) ; ! 604: } ! 605: ! 606: #endif /* STDIO_ONLY */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.