![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vmsio.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / bin / vi|
Return to vmsio.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / bin / vi |
1.1 ! root 1: /* ! 2: VMSIO.C -- replacements for lseek(), read() and close() to allow ! 3: arbitrary byte seeks with non-stream-lf files. ! 4: ! 5: (The original version (file routines) were written to port the ! 6: unix ``less'' program. This version helps with the elvis port. ! 7: It may be useful elsewhere to port other utilities.) ! 8: ! 9: Written by John Campbell [email protected]. Use as you ! 10: wish, but leave me some credit for killing myself on this when ! 11: I was sick one weekend, ok? ! 12: ! 13: Also, added vms_rename as a weak replacment for link(). 4/2/91 ! 14: ...and because there was a routine named delete, created a vms_delete. ! 15: ! 16: Sigh, Steve wanted pipe stuff, so vms_rpipe(), vms_pread() and ! 17: vms_pclose() was born. 8/2/91 ! 18: ! 19: Moved the tty i/o routines into this module as well. vms_open_tty() ! 20: and vms_ttyread() (ttread) 8/2/91 ! 21: */ ! 22: ! 23: /* ! 24: Entry points: ! 25: ! 26: FILE I/O ! 27: vms_close (fd) ! 28: long vms_lseek (fd, offset, direction) ! 29: int vms_read (fd, buf, len) ! 30: int vms_rename (from, to) ! 31: vms_delete (file) ! 32: ! 33: PIPE I/O ! 34: int vms_rpipe (cmd, fd, input_file) ! 35: int vms_pread (pfile, buffer, size) ! 36: int vms_rpclose(pfile) ! 37: ! 38: TERMINAL I/O ! 39: vms_open_tty() ! 40: vms_ttyread(buf, len, time) ! 41: */ ! 42: static char *version = "VMSIO, version 1.0"; ! 43: ! 44: #include <stdio.h> ! 45: #include <errno.h> ! 46: #include <perror.h> ! 47: #define BUFSIZE 4096 ! 48: ! 49: /* Data and buffers used to implement vms_lseek() and vms_read() */ ! 50: static struct { ! 51: int type, cur_loc, size, lastbin, maxbin, offset, eob; ! 52: } fdints[_NFILE] = ! 53: {{0,0,0,0,0,0,-1},{0,0,0,0,0,0,-1},{0,0,0,0,0,0,-1},{0,0,0,0,0,0,-1}, ! 54: {0,0,0,0,0,0,-1},{0,0,0,0,0,0,-1},{0,0,0,0,0,0,-1},{0,0,0,0,0,0,-1}, ! 55: {0,0,0,0,0,0,-1},{0,0,0,0,0,0,-1},{0,0,0,0,0,0,-1},{0,0,0,0,0,0,-1}, ! 56: {0,0,0,0,0,0,-1},{0,0,0,0,0,0,-1},{0,0,0,0,0,0,-1},{0,0,0,0,0,0,-1}, ! 57: {0,0,0,0,0,0,-1},{0,0,0,0,0,0,-1},{0,0,0,0,0,0,-1},{0,0,0,0,0,0,-1}}; ! 58: static char **fdbufs[_NFILE] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; ! 59: typedef struct { ! 60: int loc, bstart, bend; ! 61: } seeks; ! 62: static seeks *fdseeks[_NFILE] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; ! 63: ! 64: /* Intended use for fdseeks: fdseeks[fd][i] for i'th triple */ ! 65: ! 66: #define G_cur_loc fdints[fd].cur_loc ! 67: #define G_size fdints[fd].size ! 68: #define G_eof_seen fdints[fd].eof_seen ! 69: #define G_offset fdints[fd].offset ! 70: #define G_eob fdints[fd].eob ! 71: ! 72: ! 73: vms_close (fd) ! 74: int fd; ! 75: { ! 76: if (fd >= 0) { ! 77: /* Reset fdints[fd] and free any buffers we were using. */ ! 78: fdints[fd].type = 0; ! 79: fdints[fd].cur_loc = 0; ! 80: fdints[fd].size = 0; ! 81: fdints[fd].lastbin = 0; ! 82: fdints[fd].maxbin = 0; ! 83: fdints[fd].offset = 0; ! 84: fdints[fd].eob = -1; ! 85: ! 86: if (fdseeks[fd]) ! 87: fdseeks[fd] = free (fdseeks[fd]); ! 88: if (fdbufs[fd]) ! 89: fdbufs[fd] = free (fdbufs[fd]); ! 90: } ! 91: return (close(fd)); ! 92: } ! 93: ! 94: long vms_lseek (fd, offset, direction) ! 95: int fd, offset, direction; ! 96: { ! 97: int tmp; ! 98: ! 99: if (fd > _NFILE) { ! 100: fprintf (stderr,"Too many files for vms_lseek\n"); ! 101: exit(2); ! 102: } ! 103: if (fd < 0) { ! 104: return lseek (fd, offset, direction); ! 105: } ! 106: if (fdints[fd].type == 0) ! 107: _init(fd); ! 108: if (fdints[fd].type == 1) ! 109: return lseek (fd, offset, direction); ! 110: ! 111: /* Convert the possibly relative `offset' to an absolute offset. */ ! 112: if (direction == 1) { ! 113: offset = G_cur_loc + offset + G_offset; ! 114: } ! 115: else if (direction == 2) { ! 116: if (G_eob == -1) ! 117: _refill (fd, -1); /* Figure out the correct eob byte count */ ! 118: offset = G_eob + offset; ! 119: } ! 120: if (offset < 0) ! 121: return -1; ! 122: ! 123: /* Limitation of this implementation--only seeks to end of file. */ ! 124: if (G_eob > -1 && offset > G_eob) ! 125: offset = G_eob; ! 126: ! 127: if (G_offset > offset || offset >= G_offset + G_size) { ! 128: if (_refill (fd, offset) == -1) ! 129: return -1; ! 130: } ! 131: ! 132: /* Byte we want is now in our current buffer. */ ! 133: G_cur_loc = offset - G_offset; ! 134: ! 135: /* Sanity check. */ ! 136: if (G_cur_loc < 0 || G_cur_loc > BUFSIZE) ! 137: _error ("G_cur_loc error in vms_lseek\n", 1); ! 138: ! 139: return G_cur_loc + G_offset; /* Byte location in current buffer */ ! 140: } ! 141: ! 142: ! 143: int vms_read (fd, buf, len) ! 144: int fd, len; ! 145: char *buf; ! 146: { ! 147: /* Buffer the read as the unix system would do. */ ! 148: int fill = 0, n, num = 0,tmp; ! 149: char *buffer; ! 150: ! 151: if (fd > _NFILE) { ! 152: fprintf (stderr,"Too many files for vms_read\n"); ! 153: exit(2); ! 154: } ! 155: ! 156: if (fdints[fd].type == 0) ! 157: _init(fd); ! 158: if (fdints[fd].type == 1) ! 159: return read (fd, buf, len); ! 160: ! 161: buffer = fdbufs[fd]; ! 162: ! 163: if (G_eob != -1 && G_cur_loc + G_offset >= G_eob) ! 164: return 0; /* EOF */ ! 165: ! 166: /* Move any buffered data into place. */ ! 167: while (len && G_cur_loc < G_size) { ! 168: *buf++ = buffer[G_cur_loc++]; ! 169: --len; ! 170: ++num; ! 171: } ! 172: /* Refill as many buffers as necessary to put len bytes into buf. */ ! 173: do { ! 174: /* Don't refill when asked to read beyond the end of the file. */ ! 175: if (G_cur_loc == G_size && (G_eob == -1 || G_offset + G_size < G_eob)) { ! 176: if (_refill (fd, G_offset + G_size) == -1) return -1; ! 177: } ! 178: while (len && G_cur_loc < G_size) { ! 179: *buf++ = buffer[G_cur_loc++]; ! 180: --len; ! 181: ++num; ! 182: } ! 183: } while (len && (G_eob == -1 || G_offset + G_size < G_eob)); ! 184: /* Sanity check. */ ! 185: if (G_cur_loc < 0 || G_cur_loc > BUFSIZE) ! 186: _error ("G_cur_loc bad in vms_read", 1); ! 187: ! 188: return num; ! 189: } ! 190: ! 191: /* ! 192: Fill from the appropriate buffer. Note that offset is a true byte ! 193: offset and needs to be converted to fdseeks[fd][i].loc before seeking. ! 194: This technique may, in fact, generalize to other machines. ! 195: */ ! 196: static int _refill (fd, offset) ! 197: int fd, offset; ! 198: { ! 199: int n, seekbin, tmp; ! 200: char *buffer = fdbufs[fd]; ! 201: ! 202: /* See if the offset is in our current buffer (eob offset is a pain). */ ! 203: if (offset > 0 && G_eob > -1 && offset >= G_eob) ! 204: offset = G_eob - 1; ! 205: ! 206: if (offset > 0 && G_offset <= offset && offset < G_offset + G_size) ! 207: return G_offset; ! 208: ! 209: seekbin = fdints[fd].lastbin; ! 210: ! 211: /* Now see if the offset is known (already been read once). */ ! 212: if (offset >= 0 && offset < fdseeks[fd][seekbin].bstart) { ! 213: /* Yes! We can seek to a known point to pick up this offset. */ ! 214: while (seekbin > 0) { ! 215: if (offset >= fdseeks[fd][seekbin].bstart) ! 216: break; ! 217: --seekbin; ! 218: } ! 219: } ! 220: /* Position ourselves for the read (even if we are already there?) */ ! 221: /* We can avoid this lseek if G_offset == [seekbin-1].bstart */ ! 222: if (lseek (fd, fdseeks[fd][seekbin].loc, 0) == -1) ! 223: _error ("bad seek in _refill"); ! 224: ! 225: /* Ok, fill this buffer. */ ! 226: more: ! 227: G_cur_loc = 0; ! 228: G_size = 0; ! 229: G_offset = fdseeks[fd][seekbin].bstart; ! 230: ! 231: /* ! 232: Don't want to be left with a partial record. Choices are to shrink ! 233: down the read size or to keep seeking so we can backup to just before ! 234: n == read size. Which seems faster? Which puts an arbitrary limit ! 235: on the record size? ! 236: */ ! 237: /* Some lines longer than 512 may be truncated. */ ! 238: while (G_size < BUFSIZE - 512 && ! 239: (n = read (fd, &buffer[G_size], BUFSIZE - G_size)) > 0) { ! 240: #ifdef OTHERMETHOD ! 241: if (n == BUFSIZE - G_size) ! 242: break; /* Don't count last line (it may be a partial line) */ ! 243: #endif ! 244: G_size += n; ! 245: } ! 246: if (n == 0) { ! 247: if (G_size == 0) ! 248: ++G_size; ! 249: G_eob = G_offset + G_size; ! 250: offset = G_eob; ! 251: } ! 252: else if (n == -1) { ! 253: _error ("vms_read (_refill) error", 0); ! 254: return -1; ! 255: } ! 256: ! 257: /* Update the seek array. Finish current bin and start next bin. */ ! 258: if (G_size == 0) ! 259: ++G_size; ! 260: tmp = G_offset + G_size - 1; ! 261: if (seekbin < fdints[fd].lastbin && fdseeks[fd][seekbin].bend != tmp) { ! 262: fprintf (stderr, "Consistency failure in _refill\n"); ! 263: exit(2); ! 264: } ! 265: fdseeks[fd][seekbin].bend = tmp; ! 266: if (G_eob == -1 || G_offset + G_size < G_eob) { ! 267: /* Set up the next seek bin */ ! 268: if (++seekbin > fdints[fd].maxbin) { ! 269: /* Make more room. */ ! 270: fdints[fd].maxbin = 2*fdints[fd].maxbin; ! 271: fdseeks[fd] = (void *)realloc (fdseeks[fd], fdints[fd].maxbin); ! 272: } ! 273: ! 274: /* Make sure that lastbin is up to date. */ ! 275: if (seekbin > fdints[fd].lastbin) fdints[fd].lastbin = seekbin; ! 276: ! 277: if ((tmp = lseek(fd,0,1)) == -1) ! 278: _error ("Seek error in vms_read (refill)"); ! 279: if (seekbin < fdints[fd].lastbin && fdseeks[fd][seekbin].loc != tmp) { ! 280: fprintf (stderr, "Consistency failure in _refill\n"); ! 281: exit(2); ! 282: } ! 283: fdseeks[fd][seekbin].loc = tmp; ! 284: ! 285: if (seekbin >= fdints[fd].lastbin) { ! 286: fdseeks[fd][seekbin].bstart = G_offset + G_size; ! 287: fdseeks[fd][seekbin].bend = 0; ! 288: } ! 289: else { ! 290: /* Consistency check */ ! 291: tmp = G_offset + G_size; ! 292: if (fdseeks[fd][seekbin].bstart != tmp) { ! 293: fprintf (stderr, "Consistency failure in _refill\n"); ! 294: exit(1); ! 295: } ! 296: } ! 297: } ! 298: /* Well, it's either a big do-while loop or this goto... */ ! 299: if (offset == -1 || ! 300: (offset >= G_offset + G_size && (offset < G_eob || G_eob == -1))) ! 301: goto more; ! 302: ! 303: return G_offset; ! 304: } ! 305: ! 306: #include <types.h> ! 307: #include <stat.h> ! 308: /* ! 309: Note: may want to store a pointer to the statbuf in place of type. ! 310: For one thing, this would give you the maximum record size. ! 311: ! 312: Ok, there are some problems when we don't control open and close. ! 313: For instance, switching fd's in midstream can throw us. We could ! 314: store a statbuf pointer to detect this and it may turn out to be ! 315: necessary later. (statbuf has the fid for the file in it.) ! 316: */ ! 317: static _init(fd) ! 318: int fd; ! 319: { ! 320: /* Check the file type; allocate a buffer. */ ! 321: struct stat statbuf; ! 322: int tmp; ! 323: ! 324: if (fstat(fd, &statbuf) < 0) ! 325: _error ("Can't stat\n", 1); ! 326: /* ! 327: Some possible file types (from fab.h): ! 328: ! 329: rat: FTN - 0 rfm: UDF 0 undefined ! 330: CR - 1 FIX 1 ! 331: PRN - 2 VAR 2 default type ! 332: BLK - 3 VFC 3 ! 333: STM 4 ! 334: STMLF 5 ! 335: STMCR 6 ! 336: Also, st_size == 0 seems to indicate a non-file device (mailbox, terminal). ! 337: */ ! 338: if (statbuf.st_fab_rfm == 5 || statbuf.st_fab_rfm == 0 ! 339: || statbuf.st_size == 0) ! 340: fdints[fd].type = 1; /* Use 'C' rtl routines directly */ ! 341: else ! 342: fdints[fd].type = 2; /* Use these routines. */ ! 343: ! 344: /* Get a buffer for our buffered I/O */ ! 345: fdbufs[fd] = malloc (BUFSIZE); ! 346: ! 347: /* Get an array to use for seeking (initial guess). */ ! 348: tmp = (statbuf.st_size + BUFSIZE)/BUFSIZE * sizeof(seeks) + sizeof(seeks); ! 349: fdseeks[fd] = (void *)malloc (tmp); ! 350: fdints[fd].maxbin = tmp/sizeof(seeks); ! 351: ! 352: /* Fill in the 0'th (first) seeks triplet. */ ! 353: fdseeks[fd][0].loc = 0; ! 354: fdseeks[fd][0].bstart = 0; ! 355: fdseeks[fd][0].bend = 0; ! 356: } ! 357: ! 358: #include <descrip.h> ! 359: static _error (string, leave) ! 360: char *string; ! 361: int leave; ! 362: { ! 363: char errstr[81]; ! 364: $DESCRIPTOR(errdesc,errstr); ! 365: short int length; ! 366: ! 367: perror (string); ! 368: if (errno == EVMSERR) { ! 369: if (SYS$GETMSG(vaxc$errno, &length, &errdesc, 1, 0) == 1) { ! 370: errstr[length] = '\0'; ! 371: fprintf (stderr, "%s\n", errstr); ! 372: } ! 373: } ! 374: if (leave) ! 375: exit (44); /* SS_ABORT */ ! 376: } ! 377: #include <ssdef> ! 378: #include <iodef> ! 379: #include <rms> ! 380: #include <fibdef> ! 381: #include <atrdef> ! 382: ! 383: /* Simply need a trick to hide a global called 'delete' elsewhere. */ ! 384: vms_delete (file) ! 385: char *file; ! 386: { ! 387: delete (file); ! 388: } ! 389: ! 390: /* Pipe routines modified from Chris Janton's (chj) VMS Icon port. */ ! 391: /* ! 392: Here we fudge to help the "elvis" program implement rpipe. The ! 393: routine essentially does an popen using fd as stdin--except that ! 394: few VMS utilities use the 'C' library. So we pass in the standard ! 395: input file name and use it if fd is non-zero. ! 396: */ ! 397: #include <dvidef> ! 398: #include <file> ! 399: ! 400: typedef struct _descr { ! 401: int length; ! 402: char *ptr; ! 403: } descriptor; ! 404: ! 405: typedef struct _pipe { ! 406: long pid; /* process id of child */ ! 407: long status; /* exit status of child */ ! 408: long flags; /* LIB$SPAWN flags */ ! 409: int ichan; /* MBX channel number */ ! 410: int ochan; ! 411: int efn; ! 412: unsigned running : 1; /* 1 if child is running */ ! 413: } Pipe; ! 414: ! 415: Pipe _pipes[_NFILE]; /* one for every open file */ ! 416: ! 417: #define NOWAIT 1 ! 418: #define NOCLISYM 2 ! 419: #define NOLOGNAM 4 ! 420: #define NOKEYPAD 8 ! 421: #define NOTIFY 16 ! 422: #define NOCONTROL 32 ! 423: #define SFLAGS (NOWAIT|NOKEYPAD|NOCONTROL) ! 424: ! 425: int vms_rpipe (cmd, fd, input_file) ! 426: char *cmd, *input_file; ! 427: int fd; ! 428: { ! 429: int pfile; /* the Pfile */ ! 430: Pipe *pd; /* _pipe database */ ! 431: descriptor inmbxname; /* name of input mailbox */ ! 432: descriptor outmbxname; /* name of mailbox */ ! 433: char inmname[65]; ! 434: char outmname[65]; /* mailbox name string */ ! 435: int ochan; /* mailbox channel number */ ! 436: int ichan; /* Input mailbox channel number */ ! 437: int status; /* system service status */ ! 438: int efn; ! 439: struct { ! 440: short len; ! 441: short code; ! 442: char *address; ! 443: char *retlen; ! 444: int last; ! 445: } itmlst; ! 446: ! 447: if (!cmd || cmd[0] == '\0') ! 448: return (-1); ! 449: LIB$GET_EF(&efn); ! 450: if (efn == -1) ! 451: return (-1); ! 452: ! 453: /* create and open the input mailbox */ ! 454: status = SYS$CREMBX(0, &ichan, 0, 0, 0, 0, 0); ! 455: if (!(status & 1)) { ! 456: LIB$FREE_EF(&efn); ! 457: return (-1); ! 458: } ! 459: itmlst.last = inmbxname.length = 0; ! 460: itmlst.address = inmbxname.ptr = inmname; ! 461: itmlst.retlen = &inmbxname.length; ! 462: itmlst.code = DVI$_DEVNAM; ! 463: itmlst.len = 64; ! 464: status = SYS$GETDVIW(0, ichan, 0, &itmlst, 0, 0, 0, 0); ! 465: if (!(status & 1)) { ! 466: LIB$FREE_EF(&efn); ! 467: return (-1); ! 468: } ! 469: inmname[inmbxname.length] = '\0'; ! 470: ! 471: /* create and open the output mailbox */ ! 472: status = SYS$CREMBX(0, &ochan, 0, 0, 0, 0, 0); ! 473: if (!(status & 1)) { ! 474: LIB$FREE_EF(&efn); ! 475: return (-1); ! 476: } ! 477: itmlst.last = outmbxname.length = 0; ! 478: itmlst.address = outmbxname.ptr = outmname; ! 479: itmlst.retlen = &outmbxname.length; ! 480: status = SYS$GETDVIW(0, ochan, 0, &itmlst, 0, 0, 0, 0); ! 481: if (!(status & 1)) { ! 482: LIB$FREE_EF(&efn); ! 483: return (-1); ! 484: } ! 485: outmname[outmbxname.length] = '\0'; ! 486: pfile = open(outmname, O_RDONLY); ! 487: if (pfile < 0) { ! 488: LIB$FREE_EF(&efn); ! 489: SYS$DASSGN(ichan); ! 490: SYS$DASSGN(ochan); ! 491: return (-1); ! 492: } ! 493: /* Save file information now */ ! 494: pd = &_pipes[pfile]; /* get Pipe pointer */ ! 495: pd->pid = pd->status = pd->running = 0; ! 496: pd->flags = SFLAGS; ! 497: pd->ichan = ichan; ! 498: pd->ochan = ochan; ! 499: pd->efn = efn; ! 500: ! 501: /* Initiate the command by writing down the input mailbox (SYS$INPUT). */ ! 502: if (fd > 0) { ! 503: char *pre_command[132+12]; ! 504: strcpy (pre_command, "DEFINE/USER SYS$INPUT "); ! 505: strcat (pre_command, input_file); ! 506: status = sys$qiow(0, ichan, IO$_WRITEVBLK | IO$M_NOW, 0, 0, 0, ! 507: pre_command, strlen(pre_command), 0, 0, 0, 0); ! 508: if (!(status & 1)) { ! 509: LIB$FREE_EF(&efn); ! 510: SYS$DASSGN(ichan); ! 511: SYS$DASSGN(ochan); ! 512: return (-1); ! 513: } ! 514: } ! 515: status = sys$qiow(0, ichan, IO$_WRITEVBLK | IO$M_NOW, ! 516: 0, 0, 0, cmd, strlen(cmd), 0, 0, 0, 0); ! 517: if (!(status & 1)) { ! 518: LIB$FREE_EF(&efn); ! 519: SYS$DASSGN(ichan); ! 520: SYS$DASSGN(ochan); ! 521: return (-1); ! 522: } ! 523: status = sys$qiow(0, ichan, IO$_WRITEOF | IO$M_NOW, 0, 0, 0, ! 524: 0, 0, 0, 0, 0, 0); ! 525: if (!(status & 1)) { ! 526: LIB$FREE_EF(&efn); ! 527: SYS$DASSGN(ichan); ! 528: SYS$DASSGN(ochan); ! 529: return (-1); ! 530: } ! 531: ! 532: status = LIB$SPAWN(0, ! 533: &inmbxname, /* input file */ ! 534: &outmbxname, /* output file */ ! 535: &pd->flags, 0, &pd->pid, &pd->status, &pd->efn, 0, 0, 0, 0); ! 536: if (!(status & 1)) { ! 537: LIB$FREE_EF(&efn); ! 538: SYS$DASSGN(ichan); ! 539: SYS$DASSGN(ochan); ! 540: return (-1); ! 541: } else { ! 542: pd->running = 1; ! 543: } ! 544: return (pfile); ! 545: } ! 546: ! 547: int vms_pread (pfile, buffer, size) ! 548: int pfile, size; ! 549: char *buffer; ! 550: /* Be compatible when we read data in (handle newlines). */ ! 551: { ! 552: Pipe *pd; ! 553: int status, request; ! 554: struct { ! 555: short status, ! 556: count; ! 557: int :16; ! 558: } iosb; ! 559: ! 560: pd = pfile >= 0 ? &_pipes[pfile] : 0; ! 561: if (pd == NULL) return -1; ! 562: ! 563: /* ! 564: This is sort of nasty. The default mailbox size is 256 maxmsg ! 565: and 1056 bufquo if your sysgen parameters are standard. Asking ! 566: for more on the CREMBX command (in rpipe) might be a bad idea as ! 567: that could cause an "exceeded quota" error. Since we only return ! 568: -1 on error, there's no hope that the poor user would ever know ! 569: what went wrong. ! 570: */ ! 571: request = size > 256 ? 256 : size - 1; ! 572: status = sys$qiow(0, pd->ochan, IO$_READVBLK, &iosb, 0, 0, ! 573: buffer, request, 0, 0, 0, 0); ! 574: if (!(status & 1)) return -1; ! 575: if (iosb.status == SS$_ENDOFFILE) ! 576: return 0; ! 577: buffer[iosb.count] = '\n'; ! 578: return iosb.count+1; ! 579: } ! 580: ! 581: /* ! 582: * Taken from pclose - close a pipe ! 583: * Last modified 2-Apr-86/chj ! 584: * ! 585: */ ! 586: int vms_rpclose(pfile) ! 587: int pfile; ! 588: { ! 589: Pipe *pd; ! 590: int status; ! 591: int fstatus; ! 592: ! 593: pd = pfile >= 0 ? &_pipes[pfile] : 0; ! 594: if (pd == NULL) ! 595: return (-1); ! 596: fstatus = close(pfile); ! 597: SYS$DASSGN(pd->ichan); ! 598: SYS$DASSGN(pd->ochan); ! 599: LIB$FREE_EF(&pd->efn); ! 600: pd->running = 0; ! 601: return (fstatus); ! 602: } ! 603: ! 604: /* Terminal routines. */ ! 605: ! 606: static int tty; ! 607: static int VMS_term_chan; ! 608: int VMS_read_raw; /* Set by curses.c in elvis. */ ! 609: ! 610: #define VMSCheck(a) {int _s; if (~(_s = (a)) & 1) vms_sys$exit (_s);} ! 611: ! 612: vms_open_tty() ! 613: { ! 614: int c; ! 615: ! 616: $DESCRIPTOR(_terminal,"SYS$INPUT"); ! 617: if (VMS_term_chan == 0) { ! 618: VMSCheck(SYS$ASSIGN (&_terminal, &VMS_term_chan, 0, 0)); ! 619: } ! 620: /* Was 2 -- jdc */ ! 621: tty = 0; ! 622: ! 623: /* Could reset the scrolling region, setup LINES, COLS, etc. */ ! 624: ! 625: read(tty,&c,0); /* Flush the tty buffer. */ ! 626: } ! 627: ! 628: /* ! 629: * Get a character from the keyboard. ! 630: */ ! 631: /*ARGSUSED*/ ! 632: vms_ttyread(buf, len, time) ! 633: char *buf; ! 634: int len; ! 635: int time; ! 636: { ! 637: char c; ! 638: int result, terminat[2] = {0,0}; ! 639: struct { ! 640: short int status; /* I/O completion status */ ! 641: short int bcount; /* byte transfer count */ ! 642: int dev_dep_data; /* device dependant data */ ! 643: } iosb; /* This is a QIO I/O Status Block */ ! 644: ! 645: ! 646: if (VMS_read_raw) { ! 647: /* read(tty,&c,0); */ /* Flush the tty buffer. (needed?) */ ! 648: if (time == 0) { ! 649: VMSCheck(sys$qiow(0, VMS_term_chan, ! 650: IO$_READVBLK | IO$M_NOECHO | IO$M_NOFILTR | IO$M_TRMNOECHO, ! 651: &iosb, 0, 0, buf, 1, 0, terminat, 0, 0)); ! 652: } ! 653: else { ! 654: VMSCheck(sys$qiow(0, VMS_term_chan, ! 655: IO$_READVBLK | IO$M_NOECHO | IO$M_NOFILTR | IO$M_TRMNOECHO | IO$M_TIMED, ! 656: &iosb, 0, 0, buf, 1, time, terminat, 0, 0)); ! 657: } ! 658: if (iosb.status == SS$_ENDOFFILE) ! 659: vms_sys$exit(SS$_ABORT); ! 660: else if (iosb.status == SS$_TIMEOUT) ! 661: return 0; /* Timeout */ ! 662: return 1; /* iosb.bcount; */ ! 663: } ! 664: else { ! 665: /* I don't believe we ever use ttyread to read in non-raw mode... */ ! 666: #undef read ! 667: return read (0, buf, len); ! 668: } ! 669: } ! 670: ! 671: vms_sys$exit(val) ! 672: { ! 673: sys$exit(val); /* Debugger entry point. */ ! 674: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.