![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to emacs_io.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / cmd / emacs|
Return to emacs_io.c CVS log | Up to [Research Unix] / researchv9 / cmd / emacs |
1.1 ! root 1: /* EMACS_MODES: c !fill */ ! 2: #ifdef v8 ! 3: #include <sys/types.h> ! 4: #endif ! 5: #include "emacs_gb.h" ! 6: #include "emacs_io.h" ! 7: #ifndef PC ! 8: #include <signal.h> ! 9: #endif ! 10: #ifdef bsd ! 11: #include <sys/time.h> ! 12: #else ! 13: #include <time.h> ! 14: #endif ! 15: #include <errno.h> ! 16: #ifdef ux3 ! 17: #include <termio.h> ! 18: #else ! 19: #include <sgtty.h> ! 20: #endif ! 21: ! 22: #ifdef bsd ! 23: ! 24: /* The following defines turn on the use of the select system call ! 25: * and Cbreak mode for berkeley unix. If you are running a version ! 26: * of berkeley unix without these features, taken them out */ ! 27: ! 28: #define SELECT ! 29: #define CBRAKE ! 30: #define FLIM ! 31: #endif ! 32: #ifdef ux3 ! 33: #define FLIM ! 34: #endif ! 35: ! 36: ! 37: #ifdef COMPRESS ! 38: long coutc = 0; ! 39: int DOCOMP=0; ! 40: char *trtab[128] = { ! 41: ! 42: #include "compress.h" ! 43: }; ! 44: ! 45: #endif ! 46: ! 47: #ifdef NDLAY ! 48: #include <sys/types.h> ! 49: #ifdef ux3 ! 50: #include <fcntl.h> ! 51: #endif ux3 ! 52: ! 53: int ndfrn; /* file for ndelay I/O */ ! 54: #endif ! 55: ! 56: extern int SAVEMD; ! 57: extern int curbf; ! 58: extern char *getenv(); ! 59: ! 60: #ifdef PC ! 61: #define READM (0) ! 62: #define APPEM (1) ! 63: #define WRITEM (1) ! 64: #else ! 65: #define READM 0 ! 66: #define APPEM 1 ! 67: #define WRITEM 0666 ! 68: ! 69: int READ_WAIT = 255; ! 70: int read_miss; ! 71: #endif ! 72: /* TTY buffer */ ! 73: ! 74: /* if unix3.0 (or later) system with no wait raw-mode I/O, use a big tty */ ! 75: /* buffer to allow type ahead and avoid excessive re-display */ ! 76: ! 77: #if (defined(ux3) || defined(bsd) || defined(v8)) ! 78: #define TTLOOK 16 ! 79: #else ! 80: #define TTLOOK 1 ! 81: #endif ! 82: int ttcnt ; ! 83: char ttbuf[18]; /* Make large */ ! 84: char *ttptr; ! 85: int ungc = 0; ! 86: extern int ttywarp; ! 87: ! 88: /* Interrupted system command flag */ ! 89: int irupt = 0; ! 90: #define MAXIRUPT 100 ! 91: ! 92: /* controlification stuff */ ! 93: ! 94: int ctlify; ! 95: int CONCHAR = 036; /* ^^ */ ! 96: ioinit() ! 97: { ! 98: /* Keywords: internal-initialization standard-I/O files:20 */ ! 99: register char *ttname; ! 100: ! 101: xclose(3); /* close all files */ ! 102: _stdout._frn = 1; ! 103: _stdout._cnt = 0; ! 104: _stdout._flags = _OUTPUT; ! 105: incnt = inlev = infrn = 0; ! 106: infrn = NULL; ! 107: brkflg = 0; ! 108: inbuf = _inbuf[0]; ! 109: #ifdef NDLAY ! 110: #ifdef ux3 ! 111: ! 112: #ifdef pdp11 ! 113: #define PDPTEST (ttywarp<2) ! 114: #else ! 115: #define PDPTEST 0 ! 116: #endif ! 117: ! 118: /* IF we have NDELAY I/O, close standard error and open it with ndelay */ ! 119: ! 120: close(2); /* close standard error */ ! 121: ! 122: ! 123: if ((ttname=getenv("LOGTTY"))==NULL) ttname="/dev/tty"; ! 124: if (PDPTEST || (open(ttname,O_RDWR+O_NDELAY)<0)) { ! 125: dup(1); ! 126: ndfrn = 0; ! 127: } else ndfrn = 2; ! 128: ! 129: /* if we can't get tty, restore frn2 */ ! 130: #endif ux3 ! 131: #ifdef (defined(bsd) || defined(v8)) ! 132: /* ! 133: * we can see how many chars await us in bsd4.1, ! 134: * so set ndfrn if the tty is fast enough for us. - CRC ! 135: */ ! 136: ndfrn = 2; /* CRC */ ! 137: ! 138: #endif (bsd || v8) /* CRC */ ! 139: ! 140: #endif /* CRC */ ! 141: } ! 142: int FLOWMIN=0; /* Mode variable must be present */ ! 143: ! 144: #ifdef PC ! 145: ! 146: cook() ! 147: { ! 148: } ! 149: uncook() ! 150: { ! 151: } ! 152: #else ! 153: /* into raw mode */ ! 154: ! 155: ! 156: /* Terminal I/O modes, sgttyb for before unix 3.0, termio for later */ ! 157: ! 158: ! 159: int xon; ! 160: ! 161: #ifdef ux3 ! 162: struct termio ttyjunk; ! 163: struct termio nttyjunk; ! 164: #else ! 165: struct sgttyb ttyjunk; ! 166: struct sgttyb nttyjunk; ! 167: #endif ! 168: ! 169: #ifdef CBRAKE ! 170: /* Additional goodies for 4.2BSD */ ! 171: ! 172: int ldisc; /* Line discipline */ ! 173: struct tchars tchars; /* Basic characters */ ! 174: int locmode; /* Local mode */ ! 175: struct ltchars ltchars; /* And at last, local modes */ ! 176: struct ltchars zchars = { ! 177: -1,-1,-1,-1,-1,-1 }; /* Zero characters for ioctl */ ! 178: struct tchars fcoff = {0,-1,-1,-1,-1,-1}; ! 179: struct tchars fcon = {0,-1,021,023,-1,-1}; ! 180: int mylmode = LLITOUT|LDECCTQ; /* Literal output, ^Q starts ^S */ ! 181: #endif ! 182: ! 183: ! 184: #define NBAUD 16 /* number of baud rates */ ! 185: char charms[NBAUD] = { /* ms per char in various rates */ ! 186: 100, ! 187: 100, /* 50 */ ! 188: 100, /* 75 */ ! 189: 100, /* 110 */ ! 190: 70, /* 134 */ ! 191: 66, /* 150 */ ! 192: 50, /* 200 */ ! 193: 33, /* 300 */ ! 194: 16, /* 600 */ ! 195: 8, /* 1200 */ ! 196: 5, /* 1800 */ ! 197: 4, /* 2400 */ ! 198: 2, /* 4800 */ ! 199: 1, /* 9600 */ ! 200: 1, /* EXTA */ ! 201: 1, /* EXTB */ ! 202: }; ! 203: ! 204: uncook() ! 205: { ! 206: ! 207: /* UNIX 3 code thanks to J. Langer and M. Plotnick */ ! 208: ! 209: /* Keywords: the-terminal internal-initialization:40 terminal-initialization terminal-modes unix-interface:50 */ ! 210: #ifdef ux3 ! 211: ! 212: ! 213: ioctl(1, TCGETA, &ttyjunk); ! 214: nttyjunk=ttyjunk; ! 215: ! 216: #ifdef u370 ! 217: ! 218: nttyjunk.c_iflag |= (BRKINT|ISTRIP|IGNPAR); ! 219: nttyjunk.c_iflag &= ! 220: ~(IGNBRK|IGNPAR|PARMRK|IXON|INLCR|IGNCR|ICRNL|INPCK); ! 221: /* accept break, no crnl mapping, no ^S^Q */ ! 222: nttyjunk.c_oflag = 0; /* no delays, no crlf mapping */ ! 223: /* nttyjunk.c_cflag |= CS8 ;*/ ! 224: nttyjunk.c_lflag &= ~(ISIG|ECHO|ICANON); /* no echo, signals, ! 225: or erase/kill processing */ ! 226: #else ! 227: nttyjunk.c_iflag |= (BRKINT|ISTRIP); ! 228: nttyjunk.c_iflag &= ~(IGNBRK|PARMRK|INLCR|ICRNL|IGNCR|IXON|IXOFF); ! 229: /* accept break, no crnl mapping, no ^S^Q */ ! 230: nttyjunk.c_oflag = 0; /* no delays, no crlf mapping */ ! 231: nttyjunk.c_lflag &= ~(ISIG|ECHO|ICANON); /* no echo, signals, ! 232: or erase/kill processing */ ! 233: #endif ! 234: nttyjunk.c_cc[VMIN] = 0; /* return after every character read */ ! 235: ! 236: /* Setting VMIN to 0 causes emacs to time out input every 25.5 seconds, ! 237: * updating the display of time (if time mode is on) and received ! 238: * mail. Setting it to 1 will cause emacs to wait indefinetely for ! 239: * input. */ ! 240: ! 241: nttyjunk.c_cc[VTIME] = READ_WAIT; /* Or after 25.5 seconds */ ! 242: ttywarp = charms[ttyjunk.c_cflag&CBAUD]; /* milliseconds for character */ ! 243: ! 244: ioctl(1, TCSETAW, &nttyjunk); ! 245: ioctl(1, TCXONC,1); /* Force tty back on */ ! 246: xon = 0; /* Xon/XOff is now off */ ! 247: ! 248: #else ! 249: ! 250: ! 251: ioctl(1,TIOCGETP,&ttyjunk); ! 252: nttyjunk=ttyjunk; ! 253: #ifdef CBRAKE ! 254: nttyjunk.sg_flags = CBREAK; ! 255: ioctl(1,TIOCSETN,&nttyjunk); ! 256: ! 257: /* Now for the real fun, get all of the other 4.2BSD goodies */ ! 258: ! 259: ioctl(1,TIOCGETC,&tchars); ! 260: ioctl(1,TIOCSETC,&fcoff); ! 261: ioctl(1,TIOCLGET,&locmode); ! 262: ioctl(1,TIOCLBIS,&mylmode); ! 263: ioctl(1,TIOCGLTC,<chars); ! 264: ioctl(1,TIOCSLTC,&zchars); ! 265: xon = 0; ! 266: #else ! 267: nttyjunk.sg_flags &= (~ECHO); /* it was so SIMPLE in the old days */ ! 268: nttyjunk.sg_flags |= (RAW); ! 269: ioctl(1,TIOCSETP,&nttyjunk); ! 270: #endif ! 271: ttywarp = charms[ttyjunk.sg_ospeed]; /* milliseconds for char */ ! 272: #endif ! 273: ! 274: vinit(); ! 275: ! 276: /* Anything above 2500 baud may cause problems */ ! 277: /* If the user has not selected a limit we'll set one */ ! 278: /* Commented out, remove this line to enable it ! 279: if ((ttywarp < 4)&&(FLOWMIN==0)) FLOWMIN = 64; /* */ ! 280: ! 281: } ! 282: ! 283: cook() ! 284: { ! 285: /* Keywords: the-terminal terminal-modes exit-processing:50 unix-interface:50 */ ! 286: extern int osert,umode; ! 287: ! 288: /* First, return the terminal to a sane state */ ! 289: ! 290: if (no_io) return; ! 291: if (umode) unline(); ! 292: if (osert) unsert(); ! 293: vexit(); ! 294: mflush(stdout); /* force output */ ! 295: #ifdef ux3 ! 296: ioctl(1,TCSETAW, &ttyjunk); ! 297: ioctl(1, TCXONC,1); /* Force tty back on */ ! 298: xon = 1; /* XON/XOFF is now ON */ ! 299: #else ! 300: #ifdef CBRAKE ! 301: ioctl(1,TIOCSETN,&ttyjunk); ! 302: ioctl(1,TIOCSETC,&tchars); ! 303: ioctl(1,TIOCLSET,&locmode); ! 304: ioctl(1,TIOCLBIC,&mylmode); ! 305: ioctl(1,TIOCSLTC,<chars); ! 306: xon = 1; ! 307: #else ! 308: ioctl(1,TIOCSETP,&ttyjunk); ! 309: #endif ! 310: #endif ! 311: } ! 312: #endif ! 313: ! 314: /*VARARGS2*/ ! 315: ! 316: char * ! 317: nscan(stptr,ret) ! 318: ! 319: register char *stptr; ! 320: register int *ret; ! 321: ! 322: /* Keywords: standard-I/O:20 conversions parsing:20 reading:20 */ ! 323: { ! 324: register int c; ! 325: ! 326: *ret = 0; ! 327: while (((c = *stptr)>='0') && (c <= '9')) { ! 328: stptr++; ! 329: *ret = *ret*10+(c-'0'); ! 330: } ! 331: return(stptr); ! 332: } ! 333: ! 334: ! 335: seprintf(string,fmt,x) ! 336: char *string; ! 337: char *fmt; ! 338: unsigned x; ! 339: { ! 340: sxprintf(string,fmt,&x); /* Depends on arg list format */ ! 341: } ! 342: ! 343: /* Internal printf formatter */ ! 344: ! 345: sxprintf(string,fmt, adx) ! 346: register char *string; ! 347: register char *fmt; ! 348: register unsigned int *adx; ! 349: { ! 350: /* Keywords: standard-I/O:50 formatting writing:20 terminal-parameters:20 */ ! 351: int c; ! 352: int width; ! 353: ! 354: extern char *mstrcpy(); ! 355: ! 356: if (fmt == NULL) fmt = ""; ! 357: ! 358: loop: ! 359: while((c = *fmt++) != '%') { ! 360: *string++ = c; ! 361: if(c == '\0') { ! 362: return; ! 363: } ! 364: } ! 365: width = 0; ! 366: c = *fmt++; ! 367: if ((c >= '0') && (c <= '9')) { ! 368: fmt = nscan(fmt-1,&width); ! 369: c = *fmt++; ! 370: } ! 371: ! 372: switch(c) { ! 373: case 'd': ! 374: case 'D': ! 375: case 'o': ! 376: case 'O': ! 377: { ! 378: register int b; ! 379: long n; ! 380: long n1; ! 381: register int i; ! 382: char dstack[20]; ! 383: ! 384: b = (((c=='o') || (c == 'O'))? 8: 10); /* number base */ ! 385: if ((c == 'o') || (c == 'd')) { ! 386: n = (long) (*adx); ! 387: if (sizeof(n) != sizeof(i)) { ! 388: if (n > 32768L) n = n-65536L; /* sign correction */ ! 389: } ! 390: } else { ! 391: n = *((long *) adx); ! 392: adx += ((sizeof(n)-sizeof(i))/sizeof(i)); ! 393: } ! 394: i = 0; ! 395: if (n < 0) { ! 396: n = -n; ! 397: *string++ = '-'; ! 398: } ! 399: ! 400: do { ! 401: n1 = n/b; ! 402: dstack[i++] = (short) (n-(n1*b)); ! 403: n = n1; ! 404: } while (n != 0); /* figure number */ ! 405: if ((b == 8) && ((i !=1 ) || (dstack[0] != 0))) dstack[i++]=0; ! 406: while (i<width) dstack[i++] = 0; ! 407: while (i > 0) { ! 408: #ifdef PC ! 409: char cq; ! 410: cq = dstack[--i]; ! 411: cq += '0'; ! 412: *string++ = cq; ! 413: #else ! 414: *string++ = (dstack[--i] + '0'); /* print number */ ! 415: #endif ! 416: } ! 417: } ! 418: break; ! 419: case 'P': ! 420: width *= SREGION; ! 421: /* Fall through */ ! 422: case 'p': ! 423: while (width > 0) { ! 424: *string++ = *NOP; ! 425: width -= ttywarp; ! 426: } ! 427: adx--; ! 428: break; ! 429: case 's': ! 430: string = mstrcpy(string,(char *)*adx); ! 431: break; ! 432: case 'm': ! 433: case 'M': ! 434: { ! 435: char *cp; ! 436: if (c=='m') { ! 437: cp = &TMAP[width * (*adx)]; ! 438: } else { ! 439: cp = &SMAP[width * (*adx)]; ! 440: } ! 441: for (c = 0; c < width; c++) { ! 442: if (*cp) *string++ = *cp++; ! 443: } ! 444: } ! 445: break; ! 446: case 'c': ! 447: c = *adx + width; ! 448: if (c) { ! 449: *string++ = c; ! 450: } else { ! 451: *string++ = '^'; ! 452: *string++ = '@'; /* punt */ ! 453: } ! 454: break; ! 455: case '%': ! 456: *string++ ='%'; ! 457: adx--; ! 458: break; ! 459: default: ! 460: error(WARN,70); /* Bad character in printf */ ! 461: } ! 462: adx++; ! 463: goto loop; ! 464: } ! 465: char *inget() ! 466: { ! 467: /* Keywords: command-files:10 */ ! 468: if (infrn < 0)return(inptr); ! 469: else return(NULL); ! 470: } ! 471: inset(newptr) ! 472: char *newptr; ! 473: /* Keywords: command-files:10 */ ! 474: { ! 475: if (infrn < 0) inptr = newptr; ! 476: } ! 477: ! 478: #ifdef SELECT ! 479: int sreadfd = 1; ! 480: struct timeval stimeout = {30,0}; /* timeout interval */ ! 481: #endif ! 482: #ifdef v8 ! 483: fd_set sreadfd; ! 484: #endif ! 485: int ! 486: getchar() ! 487: { ! 488: /* Keywords: the-terminal standard-I/O terminal-modes:10 reading mail-processing:20 time-processing:20 prompting:30 conversions:10 PC-only:10 keyboard-macros:20 unix-interface:10 */ ! 489: ! 490: extern int timemd; ! 491: extern int newmail; ! 492: extern int mailcnt; ! 493: extern int kbdfile; ! 494: extern char ctype[]; ! 495: extern char cbuf[]; ! 496: register int c; ! 497: ! 498: ! 499: if (no_io) return(CTRLZ); /* Flush I/O */ ! 500: if (brkflg) brkit(); /* handle break interrupt */ ! 501: if (incnt == 0) { ! 502: while (1) { ! 503: errno = 0; ! 504: if (infrn) { ! 505: inptr = inbuf; ! 506: incnt = read(infrn,inbuf,INLOOK); ! 507: } else { ! 508: ! 509: /* The following code expects read from a raw mode tty port to ! 510: * return whenever at least one character has been received or a ! 511: * timeout expires. It assumes that if it gets 0 characters, the ! 512: * timer expired, unless it happens too many times in a row. */ ! 513: ! 514: reread: ttptr = ttbuf+2; ! 515: #ifdef PC ! 516: ttcnt = incnt = rawread(ttbuf+2); ! 517: #else ! 518: ! 519: read_miss = 0; ! 520: if (donttime) goto notime; /* Avoid time and mail */ ! 521: ! 522: /* First, update time and mail */ ! 523: ! 524: if (timemd) dtime(0); ! 525: if ((mailcnt>=0) && (--mailcnt<=0)) { ! 526: ckmail(); ! 527: } ! 528: ! 529: /* Display them if necessary */ ! 530: if (newmail) { ! 531: int x,y; ! 532: x = mline; ! 533: y = mcol; ! 534: prompt(ECHOL-1,"%s You have mail",cbuf); ! 535: if (newmail < 0) beep(); ! 536: mgo(x,y); ! 537: newmail = 1; ! 538: } else if (disptime) { ! 539: ! 540: int x,y; ! 541: x = mline; ! 542: y = mcol; ! 543: prompt(ECHOL-1,cbuf); ! 544: disptime=0; ! 545: mgo(x,y); ! 546: } ! 547: notime: ! 548: /* Now try to read some standard input */ ! 549: ! 550: mflush(stdout); ! 551: #ifdef FLIM ! 552: if (xon && (FLOWMIN>=0)) { /* If xon/xoff is on, turn it off */ ! 553: #ifdef CBRAKE ! 554: ! 555: quietout(); ! 556: ioctl(1,TIOCSETC,&fcoff); ! 557: #else ! 558: nttyjunk.c_iflag &= ~(IXON|IXANY); ! 559: ioctl(1,TCSETAW,&nttyjunk); ! 560: #endif ! 561: xon = 0; ! 562: } ! 563: #endif ! 564: #ifdef SELECT ! 565: if (inproc){ ! 566: sreadfd = 1+(1<<inproc); ! 567: ttcnt = select(inproc+1,&sreadfd,NULL,NULL,&stimeout); ! 568: if (sreadfd > 1) readproc(); ! 569: } else { ! 570: sreadfd = 1; /* must set up each time since select clobbers it */ ! 571: ttcnt = select(1,&sreadfd,NULL,NULL,&stimeout); ! 572: } ! 573: if ((sreadfd & 1) && (brkflg == 0)) ttcnt = incnt = read(0,ttbuf+2,TTLOOK); ! 574: else { ! 575: incnt = 0; ! 576: errno = EINTR; /* Make it look like the read timed out! */ ! 577: ! 578: } ! 579: #else ! 580: #ifdef v8 ! 581: if (inproc){ ! 582: FD_ZERO(sreadfd); ! 583: FD_SET(0, sreadfd); ! 584: FD_SET(inproc, sreadfd); ! 585: ttcnt = select(inproc+1,&sreadfd,NULL,30000); ! 586: if (FD_ISSET(inproc,sreadfd)) ! 587: readproc(); ! 588: } else { ! 589: FD_ZERO(sreadfd); ! 590: FD_SET(0, sreadfd); ! 591: ttcnt = select(1,&sreadfd,NULL,30000); ! 592: } ! 593: if (FD_ISSET(0,sreadfd) && (brkflg == 0)) ! 594: ttcnt = incnt = read(0,ttbuf+2,TTLOOK); ! 595: else { ! 596: incnt = 0; ! 597: errno = EINTR; /* Make it look like the read timed out! */ ! 598: ! 599: } ! 600: #else ! 601: ttcnt = incnt = read(0,ttbuf+2,TTLOOK); ! 602: if (inproc) readproc(); /* Process any input */ ! 603: #ifdef ux3 ! 604: if (ttcnt) ioset(10); ! 605: else ioset(READ_WAIT<<1); /* Back off read timeout next time */ ! 606: #endif ux3 ! 607: #endif v8 ! 608: #endif SELECT ! 609: if (brkflg) { ! 610: incnt=ttcnt=0; ! 611: brkit(); ! 612: disup(); ! 613: goto reread; /* Try again for a charactger */ ! 614: ! 615: } ! 616: ! 617: if (incnt == 0) { ! 618: mailcnt = 0; /* Expire mail timer */ ! 619: if (++read_miss < 1000) goto reread; ! 620: } ! 621: #endif PC ! 622: } ! 623: ninch+= incnt; /* count for stats */ ! 624: if (incnt >= 0) break; ! 625: if ((errno != EINTR)|| (++irupt > MAXIRUPT)) break; ! 626: } ! 627: ! 628: } ! 629: ! 630: if (infrn < 0) { /* if in macro */ ! 631: incnt++; ! 632: } ! 633: if (infrn) { ! 634: if (incnt-- >0) return(*inptr++ & 0377); ! 635: } else { ! 636: if ((incnt= --ttcnt) >= 0) { ! 637: if (ungc) { ! 638: ungc--; ! 639: return(*ttptr++ & 0377); ! 640: } ! 641: c = (*ttptr++ & 0177); ! 642: if (ctlify && (c == CONCHAR)) { ! 643: ctlify = 0; /* don't controlify again */ ! 644: ! 645: c = getchar(); ! 646: if ((c>= 'a') && (c <= 'z')) c -= 040; ! 647: if ((ctype[c] == PLAIN) ||(ctype[c] == UL)) c ^= 0100; ! 648: ctlify++; ! 649: } ! 650: if (kbdfile) { ! 651: char x; ! 652: x=c; ! 653: write(kbdfile,&x,1); ! 654: } ! 655: return(c); ! 656: } ! 657: } ! 658: return(CTRLZ); ! 659: } ! 660: #ifndef PC ! 661: #ifdef ux3 ! 662: ! 663: /* Set non-blocking terminal timeout appropriately */ ! 664: ! 665: /* Note -- this is a very imperfect simulation of the select system ! 666: * call in 4.2bsd for system V unix. What is done is that if no ! 667: * process is running, the timeout is set to 25.5 seconds. If a ! 668: * process is running, the timeout is decreased after every piece of ! 669: * input is sent, and rises as reads time out, returning eventually ! 670: * to 25.5 seconds. Thus quick processes get good results, but slow ! 671: * ones can get dismal response. Emacs polls the sub-process(s) ! 672: * each time it reads from the tty, so the timeout just dictates ! 673: * how often this happens if there is no tty input. */ ! 674: ! 675: ! 676: ioset(limit) ! 677: int limit; ! 678: { ! 679: /* Keywords: unix-interface reading shell-escape sub-processes look-ahead: 10*/ ! 680: ! 681: if (READ_WAIT == 0) return; /* No non-blocking I/O available */ ! 682: if (limit > 255) limit = 255; /* Clamp it */ ! 683: ! 684: if (READ_WAIT == limit) return; ! 685: READ_WAIT = limit; ! 686: nttyjunk.c_cc[VTIME] = READ_WAIT; ! 687: ioctl(1, TCSETA, &nttyjunk); ! 688: ! 689: } ! 690: #endif ! 691: ! 692: /* Process input from process in the window */ ! 693: ! 694: readproc () ! 695: { ! 696: /* Keywords: unix-interface reading shell-escape sub-processes buffers:50 */ ! 697: ! 698: ! 699: char buf[128]; ! 700: int nc,obuf; ! 701: int cnt; ! 702: ! 703: #ifdef v8 ! 704: ioctl(inproc, FIONREAD, &cnt); ! 705: if(cnt <= 0) ! 706: return; ! 707: #endif ! 708: nc = read(inproc,buf,127); ! 709: buf[nc]=0; ! 710: if (nc) { ! 711: if (curbf != procbuf) { ! 712: if (procbuf == windbuf()) { ! 713: owind(); ! 714: stuffproc(buf); ! 715: disup(); ! 716: owind(); ! 717: disup(); ! 718: } else { ! 719: obuf=curbf; ! 720: chbuf(procbuf); ! 721: stuffproc(buf); ! 722: chbuf(obuf); ! 723: } ! 724: } else { ! 725: stuffproc(buf); ! 726: disup(); /* Update display for user */ ! 727: } ! 728: } else { ! 729: } ! 730: } ! 731: ! 732: /* stuffproc -- stuff process input into the current buffer */ ! 733: ! 734: stuffproc(string) ! 735: char *string; ! 736: { ! 737: /* Keywords: unix-interface reading shell-escape sub-processes buffers:50 */ ! 738: ! 739: bot(); ! 740: putin(string); ! 741: mark(curbf); ! 742: } ! 743: ! 744: /* sendproc -- send current line to the process */ ! 745: ! 746: sendproc (ptr,count) ! 747: char * ptr; ! 748: int count; ! 749: { ! 750: /* Keywords: unix-interface shell-escape buffer-representation:10 buffers:50 writing sub-processes */ ! 751: if (write(outproc,ptr,count)<0) flushproc(); ! 752: #ifdef ux3 ! 753: ioset(1); /* Set back timeout appropriately */ ! 754: ! 755: #endif ! 756: } ! 757: ! 758: /* brkproc -- send an interrupt to the current sub-process */ ! 759: ! 760: brkproc(arg) ! 761: ! 762: /* Keywords: unix-interface shell-escape break-handling sub-processes */ ! 763: ! 764: ! 765: { ! 766: if (curbf == procbuf) { ! 767: if (arg== 1) arg = SIGINT; ! 768: kill(procpid,arg); ! 769: } ! 770: } ! 771: ! 772: /* flushproc -- rid ourselves of the current sub-process */ ! 773: ! 774: flushproc() ! 775: { ! 776: /* Keywords: unix-interface shell-escape closing sub-processes */ ! 777: ! 778: int status; ! 779: ! 780: if (procpid) { ! 781: kill (procpid,9); ! 782: status=wait(&status); ! 783: close(inproc); ! 784: close(outproc); ! 785: procpid=inproc=outproc=0; ! 786: procbuf= -1; ! 787: } ! 788: } ! 789: #else ! 790: /* Define some tombstones for this code. It's easier than ifdeffing out all the calls */ ! 791: brkproc() ! 792: { ! 793: } ! 794: #endif ! 795: /* Fill tty buffer if we have ndelay I/O */ ! 796: ! 797: ttfill() ! 798: /* Keywords: the-terminal terminal-modes lookahead reading unix-interface:50 */ ! 799: ! 800: { ! 801: #ifdef NDLAY ! 802: long i; ! 803: register char *addr; ! 804: ! 805: if (no_io || (ndfrn == 0)) return; ! 806: mflush(stdout); /* flush tty */ ! 807: ! 808: #if (defined(bsd) || defined(v8)) /* CRC */ ! 809: i = 0; /* CRC */ ! 810: ioctl(2,FIONREAD,&i); /* CRC */ ! 811: if( i <= 0) /* CRC */ ! 812: /* no input awaits us. - CRC */ ! 813: return; /* CRC */ ! 814: #endif (bsd || v8) ! 815: if (ttcnt) { ! 816: /* more input, append to it */ ! 817: addr = ttptr+ttcnt; ! 818: i = read(2,addr,ttbuf+2+TTLOOK-addr); ! 819: } else { ! 820: i = read(2,ttbuf+2,TTLOOK); ! 821: ttptr = ttbuf+2; ! 822: } ! 823: if (i < 0) i = 0; ! 824: ttcnt += i; /* more characters */ ! 825: if (infrn == 0) { /* reading from tty */ ! 826: incnt = ttcnt; ! 827: inptr = ttptr; ! 828: } ! 829: #endif ! 830: return; ! 831: } ! 832: pushin(fp) ! 833: /* Keywords: command-files:50 keyboard-macros:20 opening unix-interface:10 */ ! 834: register char *fp; ! 835: { ! 836: register int frn; ! 837: ! 838: if (fp != NULL) { ! 839: while((frn = open(fp,READM)) <= 0) { ! 840: if ((errno != EINTR) && (errno != 23))break; ! 841: } ! 842: } else frn = 0; ! 843: if (frn >= 0) { ! 844: _incnt[inlev] = incnt; ! 845: _infrn[inlev] = infrn; ! 846: _inptr[inlev++] = inptr; ! 847: infrn = frn; ! 848: if (frn) incnt = 0; ! 849: else incnt = ttcnt; ! 850: return(1); ! 851: } else return(0); ! 852: } ! 853: ! 854: pshmac(pos) ! 855: /* Keywords: macro-invocation */ ! 856: ! 857: short pos; ! 858: { ! 859: ! 860: if (inlev>= NINP) error(FATAL,64); ! 861: _incnt[inlev] = incnt; ! 862: _infrn[inlev] = infrn; ! 863: _inptr[inlev++] = inptr; ! 864: infrn = -1; ! 865: incnt = 100; /* will never decrease */ ! 866: inptr = &bbuf[0][pos]; /* macro buffer position */ ! 867: return(1); ! 868: } ! 869: ! 870: ! 871: ! 872: inpop() ! 873: /* Keywords: exit-processing:10 macro-invoction:20 command-files:20 */ ! 874: { ! 875: if (inlev > 0) { ! 876: --inlev; ! 877: if (infrn>0) close(infrn); ! 878: infrn = _infrn[inlev]; ! 879: inptr = _inptr[inlev]; ! 880: inbuf = _inbuf[inlev]; ! 881: if (infrn) incnt = _incnt[inlev]; ! 882: else incnt = ttcnt; ! 883: return(1); ! 884: } else return(0); ! 885: } ! 886: ! 887: #ifdef COMPRESS ! 888: ! 889: #define CRELOAD 0376 ! 890: ! 891: translate(buf,count) ! 892: /* Keywords: standard-I/O:10 compressed-output conversions writing */ ! 893: char *buf; ! 894: int count; ! 895: { ! 896: register char *bp; ! 897: char *be; ! 898: register char *bo; ! 899: register char *mp; ! 900: register char *tp; ! 901: bp=bo=buf; ! 902: be=buf+count; ! 903: ! 904: while (bp<be-1) { ! 905: if (*bp&0200) { ! 906: *bp = 0; /* PUNT all meta characters to 0 */ ! 907: goto stop; ! 908: } ! 909: mp=trtab[*bp]; ! 910: while (*mp) { ! 911: tp=bp+1; ! 912: while (*tp++ == *mp++); ! 913: if ((mp[-1]&0200)){ ! 914: if (tp > be+1) { ! 915: goto stop; ! 916: } ! 917: /* Matched a substring */ ! 918: *bo++ = mp[-1]; ! 919: bp = tp-1; ! 920: goto out; ! 921: } ! 922: while ((*mp++ & 0200) == 0); /* Skip rest of string */ ! 923: } ! 924: stop: *bo++ = *bp++; ! 925: out: continue; ! 926: } ! 927: if (bp < be) *bo++ = *bp++; ! 928: return(bo-buf); ! 929: } ! 930: ! 931: loadtbl() ! 932: /* Load compression table here and remote */ ! 933: /* Keywords: commands the-terminal:90 conversions compressed-output */ ! 934: { ! 935: extern int macptr; ! 936: char *nullp; ! 937: char c; ! 938: int nc; ! 939: FILE fbuf; ! 940: FILE *fp; ! 941: int i; ! 942: ! 943: if (DOCOMP==0) return; /* Can't do compression */ ! 944: nullp = &bbuf[0][macptr]; ! 945: pshchr(0); /* Store a null string for common cases */ ! 946: fp = xopen(&fbuf,expenv(getname("Compression file: ")),"r"); ! 947: if (fp == NULL) return; ! 948: DOCOMP=0; ! 949: mflush(stdout); /* Past the point of no return */ ! 950: i = 0; ! 951: while (getc(fp) != EOF) { ! 952: nc = 0; ! 953: while (getc(fp) == '\\') { ! 954: if (nc == 0) trtab[i] = &bbuf[0][macptr]; ! 955: nc++; ! 956: c = ((getc(fp)&07)<<6); ! 957: c += ((getc(fp)&07)<<3); ! 958: c += (getc(fp)&07); ! 959: pshchr(c); ! 960: } ! 961: c = getc(fp); /* Eat comma */ ! 962: c = getc(fp); /* Eat newline */ ! 963: if (nc) pshchr(0); /* Put in null */ ! 964: else trtab[i]=nullp; /* Null string */ ! 965: i++; ! 966: } ! 967: /* OK, host table loaded, now load the blit */ ! 968: mclose(fp); ! 969: fp = xopen(&fbuf,expenv(getname("Decompression file: ")),"r"); ! 970: if (fp == NULL) return; ! 971: putchar(CRELOAD); /* Tell blit it's time to reload */ ! 972: while ((c = getc(fp)) != EOF) putchar(c); ! 973: putchar(CRELOAD); /* Reload done (let's hope!) */ ! 974: mflush(stdout); /* Force output out before we turn on compression */ ! 975: DOCOMP=1; /* Here goes nothing */ ! 976: clear(); /* refresh screen */ ! 977: mclose(fp); ! 978: } ! 979: #endif ! 980: ungetch(c) ! 981: /* Keywords: the-terminal:90 standard-I/O parsing:10 reading:10 */ ! 982: { ! 983: if (incnt < 0) return; /* Can't unget an eof */ ! 984: ++incnt; ! 985: if (infrn==0) { ! 986: ++ungc; ! 987: *(--ttptr) = c; ! 988: ++ttcnt; ! 989: } else { ! 990: *(--inptr) = c; ! 991: } ! 992: } ! 993: ! 994: mflush(p) ! 995: ! 996: register FILE *p; ! 997: /* Keywords: writing the-terminal:10 standard-I/O PC-only:40 unix-interface:20 */ ! 998: { ! 999: register int bc; ! 1000: register int bo; ! 1001: ! 1002: if (p->_flags & _OUTPUT) { ! 1003: if (p->_flags & _ERROR) { ! 1004: p->_cnt = 0; ! 1005: return; ! 1006: } ! 1007: if (p == stdout) { ! 1008: if (no_io) { ! 1009: p->_cnt = 0; ! 1010: return; ! 1011: } ! 1012: ntwrite++; /* count for stats */ ! 1013: noutc += p->_cnt; ! 1014: #ifdef PC ! 1015: return; /* No output to stdout */ ! 1016: #endif PC ! 1017: #ifdef COMPRESS ! 1018: if (DOCOMP&& (p->_cnt > 10)) p->_cnt = translate(p->_buf,p->_cnt); ! 1019: coutc += p->_cnt; ! 1020: #endif ! 1021: #ifdef FLIM ! 1022: if (FLOWMIN && (p->_cnt > FLOWMIN) && (xon == 0)) { ! 1023: #ifdef CBRAKE ! 1024: quietout(); ! 1025: ioctl(1,TIOCSETC,&fcon); ! 1026: #else ! 1027: nttyjunk.c_iflag |= IXON+IXANY; ! 1028: ioctl(1,TCSETA,&nttyjunk); ! 1029: #endif ! 1030: xon = 1; ! 1031: } ! 1032: #endif ! 1033: } ! 1034: #ifdef PC ! 1035: if (p->_cnt) { ! 1036: if ((bc = write(p->_frn, p->_buf, p->_cnt)) < p->_cnt) { ! 1037: error (NORM,errno,"writing"); ! 1038: } ! 1039: } ! 1040: #else ! 1041: bo = 0; ! 1042: while((bc = write(p->_frn, p->_buf+bo, p->_cnt)) != p->_cnt) { ! 1043: if (bc >0) { ! 1044: p->_cnt -= bc; ! 1045: bo += bc; ! 1046: } ! 1047: if ((errno != EINTR)|| (++irupt > MAXIRUPT)) { ! 1048: if ((p == stdout) || (errno == EPIPE)) break; /* PUNT ! 1049: * errors on standard output */ ! 1050: p->_flags |= _ERROR; ! 1051: SAVEMD = 0; /* Give up on autosaving */ ! 1052: error (NORM,errno,"writing"); ! 1053: break; ! 1054: } ! 1055: } ! 1056: #endif PC ! 1057: p->_cnt = 0; ! 1058: } ! 1059: } ! 1060: ! 1061: #ifdef CBRAKE ! 1062: /* Wait for quiet output on berkely systems. This is very imperfect */ ! 1063: /* but it's all we can do. */ ! 1064: ! 1065: quietout() ! 1066: { ! 1067: int outqs; ! 1068: struct timeval outime; ! 1069: long timeout; ! 1070: ! 1071: ioctl(1,TIOCOUTQ,&outqs); ! 1072: while (outqs > 0) { ! 1073: ! 1074: timeout = outqs*1000 /ttywarp - 3000; /* Microseconds of timeout */ ! 1075: if (timeout > 0) { ! 1076: ! 1077: outime.tv_sec = timeout/1000000; ! 1078: outime.tv_usec = timeout%1000000; ! 1079: select(0,NULL,NULL,NULL,&outime); /* Wait for something to happen! */ ! 1080: } ! 1081: ioctl(1,TIOCOUTQ,&outqs); ! 1082: } ! 1083: } ! 1084: #endif ! 1085: filbuf(p) ! 1086: ! 1087: FILE *p; ! 1088: { ! 1089: /* Keywords: reading standard-I/O PC-only:40 unix-interface:10 */ ! 1090: #ifdef PC ! 1091: p->_cnt = read(p->_frn, p->_buf, BUFSIZ); ! 1092: #else ! 1093: mflush(stdout); /* Make output come out */ ! 1094: while ((p->_cnt = read(p->_frn, p->_buf, BUFSIZ)) < 0) { ! 1095: if ((errno != EINTR)|| (++irupt > MAXIRUPT)) break; ! 1096: } ! 1097: #endif PC ! 1098: p->_ptr = &(p->_buf[1]); ! 1099: if (p->_cnt > 0) { ! 1100: p->_cnt--; ! 1101: return(p->_buf[0]&0377); ! 1102: } ! 1103: else p->_cnt = 0; ! 1104: return(EOF); ! 1105: } ! 1106: ! 1107: /*VARARGS1*/ ! 1108: ! 1109: eprintf(string,a1) ! 1110: ! 1111: char *string; ! 1112: /* Keywords: formatting standard-I/O:50 terminal-parameters:50 */ ! 1113: { ! 1114: char pbuf[1024]; ! 1115: sxprintf(pbuf,string,&a1); ! 1116: puts(pbuf,stdout); ! 1117: } ! 1118: ! 1119: puts(cp,p) ! 1120: ! 1121: FILE *p; ! 1122: register char *cp; ! 1123: /* Keywords standard-I/O writing */ ! 1124: { ! 1125: while (*cp) { ! 1126: putc(*cp++,p); ! 1127: } ! 1128: } ! 1129: ! 1130: mclose(p) ! 1131: ! 1132: FILE *p; ! 1133: /* Keywords: standard-I/O closing files unix-interface */ ! 1134: { ! 1135: mflush(p); ! 1136: close(p->_frn); ! 1137: return(p->_flags & _ERROR); ! 1138: } ! 1139: ! 1140: FILE * ! 1141: ! 1142: xopen(p,np,mode) ! 1143: ! 1144: FILE *p; ! 1145: char *np; ! 1146: char *mode; ! 1147: /* Keywords: files opening standard-I/O unix-interface */ ! 1148: { ! 1149: int omode; ! 1150: ! 1151: omode = 0; ! 1152: if (*mode == 'b') { ! 1153: #ifdef PC ! 1154: omode = 4; ! 1155: #endif ! 1156: mode++; ! 1157: } ! 1158: switch(*mode) { ! 1159: case 'r': /* read file mode */ ! 1160: ! 1161: while ((p->_frn = open(np,omode+READM)) <0) { ! 1162: if ((errno != EINTR) && (errno != 23))return(NULL); ! 1163: } ! 1164: p->_flags = _INPUT; ! 1165: break; ! 1166: ! 1167: case 'a': ! 1168: while((p->_frn = open(np,omode+APPEM)) <0) { ! 1169: if ((errno != EINTR) && (errno != 23))return(NULL); ! 1170: } ! 1171: lseek (p->_frn,0L,2); /* at end */ ! 1172: p->_flags = _OUTPUT; ! 1173: break; ! 1174: case 'w': ! 1175: ! 1176: while((p->_frn = creat(np,omode+WRITEM)) <=0) { ! 1177: if ((errno != EINTR)&& (errno != 23)) return(NULL); ! 1178: } ! 1179: p->_flags = _OUTPUT; ! 1180: break; ! 1181: } ! 1182: p->_cnt = 0; ! 1183: p->_ptr = 0; ! 1184: return(p); ! 1185: } ! 1186: ! 1187: FILE * ! 1188: ! 1189: fdopen(p,frn,mode) ! 1190: ! 1191: FILE *p; ! 1192: int frn; ! 1193: char *mode; ! 1194: /* Keywords: standard-I/O opening unix-interface */ ! 1195: ! 1196: { ! 1197: p->_frn = frn; ! 1198: p->_cnt = 0; ! 1199: p->_ptr = &(p->_buf[0]); ! 1200: p->_flags = _DEAD; ! 1201: switch(*mode) { ! 1202: ! 1203: case 'r': ! 1204: p->_flags = _INPUT; ! 1205: break; ! 1206: case 'w': ! 1207: p->_flags = _OUTPUT; ! 1208: break; ! 1209: } ! 1210: return(p); ! 1211: } ! 1212: ! 1213: /* ascii to integer */ ! 1214: ! 1215: aint(string) ! 1216: ! 1217: register char *string; ! 1218: /* Keywords: standard-I/O:10 conversions string-handling:10 */ ! 1219: { ! 1220: register int result; ! 1221: register int base; ! 1222: ! 1223: base = ((*string == '0') ? 8 : 10); ! 1224: result = 0; ! 1225: while ((*string >= '0') && (*string <= '9')) { ! 1226: result = (result * base) + (*string++ - '0'); ! 1227: } ! 1228: if (*string == 0) return(result); ! 1229: else return(-1); ! 1230: } ! 1231: ! 1232: xclose(lowfile) ! 1233: ! 1234: register int lowfile; ! 1235: /* Keywords: unix-interface files closing */ ! 1236: { ! 1237: register int fileno; ! 1238: #ifndef PC ! 1239: for (fileno = lowfile; fileno < 20; fileno++) { ! 1240: close(fileno); ! 1241: } ! 1242: #endif PC ! 1243: } ! 1244: #ifdef PC ! 1245: /* All the nice? C routines you don't really need! */ ! 1246: signal() ! 1247: { ! 1248: return(0); ! 1249: } ! 1250: char * ! 1251: getenv() ! 1252: { ! 1253: return(0); ! 1254: } ! 1255: char cbuf[2]; /* Fake character buffer */ ! 1256: #else ! 1257: ! 1258: /* ctime stuff */ ! 1259: ! 1260: ! 1261: ! 1262: char cbuf[26]; ! 1263: char dmsize[12] = ! 1264: { ! 1265: 31, ! 1266: 28, ! 1267: 31, ! 1268: 30, ! 1269: 31, ! 1270: 30, ! 1271: 31, ! 1272: 31, ! 1273: 30, ! 1274: 31, ! 1275: 30, ! 1276: 31 ! 1277: }; ! 1278: ! 1279: long timez = 0; ! 1280: int daylite = 1; ! 1281: ! 1282: #define dysize(xyear) ((xyear&03) ? 365 : 366) ! 1283: ! 1284: ! 1285: struct tm *gmtime(); ! 1286: struct tm *localtime(); ! 1287: char *ctime(); ! 1288: char *asctime(); ! 1289: ! 1290: char * ! 1291: ctime(t) ! 1292: long *t; ! 1293: { ! 1294: /* Keywords: time-processing */ ! 1295: return(asctime(localtime(t))); ! 1296: } ! 1297: ! 1298: #ifdef ux3 ! 1299: void ! 1300: #endif ! 1301: tzset() ! 1302: { ! 1303: register char *p; ! 1304: register int n; ! 1305: int sign; ! 1306: /* Keywords: time-processing internal-initialization */ ! 1307: if ((p = getenv ("TZ")) && *p) { ! 1308: ! 1309: p += 3; ! 1310: if (sign = *p == '-') ! 1311: p++; ! 1312: n = 0; ! 1313: while (*p >= '0' && *p <= '9') ! 1314: n = (n * 10) + *p++ - '0'; ! 1315: if (sign) ! 1316: n = -n; ! 1317: timez = ((long) (n * 60)) * 60; ! 1318: if (*p) daylite = 1; ! 1319: else daylite = 0; ! 1320: } ! 1321: } ! 1322: ! 1323: struct tm * ! 1324: localtime(tim) ! 1325: long *tim; ! 1326: { ! 1327: /* Keywords: time-processing */ ! 1328: register int dayno; ! 1329: register struct tm *ct; ! 1330: register daylbegin, daylend; ! 1331: long copyt; ! 1332: ! 1333: if (timez == 0) tzset(); ! 1334: ! 1335: copyt = *tim - timez; ! 1336: ct = gmtime(©t); ! 1337: if (!daylite) return(ct); ! 1338: dayno = ct->tm_yday; ! 1339: daylbegin = 119; /* last Sun in Apr */ ! 1340: daylend = 303; /* Last Sun in Oct */ ! 1341: daylbegin = sunday(ct, daylbegin); ! 1342: daylend = sunday(ct, daylend); ! 1343: if ((dayno>daylbegin || (dayno==daylbegin && ct->tm_hour>=2)) && ! 1344: (dayno<daylend || (dayno==daylend && ct->tm_hour<1))) { ! 1345: copyt += 1*60*60; ! 1346: ct = gmtime(©t); ! 1347: } ! 1348: return(ct); ! 1349: } ! 1350: ! 1351: /* ! 1352: * The argument is a 0-origin day number. ! 1353: * The value is the day number of the first ! 1354: * Sunday on or after the day. ! 1355: */ ! 1356: sunday(t, d) ! 1357: register struct tm *t; ! 1358: register int d; ! 1359: { ! 1360: /* Keywords: time-processing */ ! 1361: if ((d >= 58) && ((t->tm_year & 03) == 0)) d+=1; /* leap year */ ! 1362: return(d - (d - t->tm_yday + t->tm_wday + 700) % 7); ! 1363: } ! 1364: ! 1365: struct tm * ! 1366: gmtime(tim) ! 1367: long *tim; ! 1368: { ! 1369: /* Keywords: time-processing */ ! 1370: register int d0, d1; ! 1371: int day; ! 1372: long hms; ! 1373: static struct tm xtime; ! 1374: ! 1375: /* ! 1376: * break initial number into days ! 1377: */ ! 1378: day = *tim / 86400; ! 1379: hms = *tim - (day*86400); ! 1380: ! 1381: /* ! 1382: * generate hours:minutes:seconds ! 1383: */ ! 1384: d1 = hms/60; ! 1385: xtime.tm_sec = hms - (((long)d1)*60L); ! 1386: xtime.tm_min = d1%60; ! 1387: d1 /= 60; ! 1388: xtime.tm_hour = d1; ! 1389: ! 1390: /* ! 1391: * day is the day number. ! 1392: * generate day of the week. ! 1393: * The addend is 4 mod 7 (1/1/1970 was Thursday) ! 1394: */ ! 1395: ! 1396: xtime.tm_wday = (day+4)%7; ! 1397: ! 1398: /* ! 1399: * year number ! 1400: */ ! 1401: for(d1=70; day >= dysize(d1); d1++) ! 1402: day -= dysize(d1); ! 1403: xtime.tm_year = d1; ! 1404: xtime.tm_yday = d0 = day; ! 1405: ! 1406: /* ! 1407: * generate month ! 1408: */ ! 1409: ! 1410: if ((d1&03) == 0)dmsize[1] = 29; ! 1411: else dmsize[1] = 28; ! 1412: for(d1=0; d0 >= dmsize[d1]; d1++) ! 1413: d0 -= dmsize[d1]; ! 1414: xtime.tm_mday= d0+1; ! 1415: xtime.tm_mon = d1; ! 1416: return(&xtime); ! 1417: } ! 1418: ! 1419: char * ! 1420: asctime(t) ! 1421: register struct tm *t; ! 1422: { ! 1423: /* Keywords: time-processing */ ! 1424: ! 1425: seprintf(cbuf,"%s %s %d %2d:%2d", ! 1426: &"Sun\0Mon\0Tue\0Wed\0Thu\0Fri\0Sat"[4*t->tm_wday], ! 1427: &"Jan\0Feb\0Mar\0Apr\0May\0Jun\0Jul\0Aug\0Sep\0Oct\0Nov\0Dec"[(t->tm_mon)*4], ! 1428: t->tm_mday, ! 1429: t->tm_hour, ! 1430: t->tm_min); ! 1431: return(cbuf); ! 1432: } ! 1433: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.