![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dired.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / cmd / dired|
Return to dired.c CVS log | Up to [Research Unix] / researchv8dc / cmd / dired |
1.1 ! root 1: /* ! 2: ********************************************************************** ! 3: * * ! 4: * dired [][dir][files] Stuart Cracraft (mclure@sri-unix) Sept 1980 * ! 5: * * ! 6: * Directory editor. * ! 7: * edit/delete files in a directory or a file list * ! 8: * compile with the berkeley termlib archive * ! 9: * and don't forget to change the 'helpfile' and * ! 10: * 'dirednam' strings to reflect your own setup. * ! 11: * * ! 12: * Note: if you make improvements, I'd like to get them too. * ! 13: * Stuart Cracraft mclure@sri-unix, * ! 14: * ucbvax!menlo70!sri-unix!mclure * ! 15: * so would I: Jay Lepreau lepreau@utah-20, * ! 16: * decvax!randvax!utah-cs!lepreau * ! 17: ********************************************************************** ! 18: */ ! 19: ! 20: /* ! 21: * Enhanced by J.Lepreau, Univ of Utah, 8-10/81: ! 22: * --bunch of stuff, including more cmds, 2 window mode, ! 23: * bufering output, pathname substition in !escapes, ! 24: * initial sort options, ^G escape from sorts, ^U escape ! 25: * from !escapes, empty dir check. ! 26: */ ! 27: ! 28: #ifdef COMMENT ! 29: ! 30: Modified 12/81 by Lepreau: ! 31: 1. Fix up aborting of command escapes, with mildy tricky re-display. ! 32: 2. Make default window size be half-screen (2 window mode). ! 33: Added option -wf to get full screen. ! 34: 3. Add check for too many files to avoid core-dump. ! 35: 4. Fix bug in cmd escapes: must reset caught signals before invocation. ! 36: ! 37: #endif COMMENT ! 38: ! 39: /* ! 40: things to consider ! 41: - perhaps should be able to edit protection field and ! 42: be able to change protection instantly at the ! 43: touch of a key (or queue the change for later exit) ! 44: ! 45: -- Would be nice if there were cmds (e.g. 'c') which would update ! 46: 1) the file-info & re-display it, & 2) update whole ! 47: display's info. ! 48: */ ! 49: ! 50: #ifdef vax /* this does for now */ ! 51: # define VFORK ! 52: #endif ! 53: ! 54: #ifndef VFORK ! 55: # define vfork fork ! 56: #endif ! 57: ! 58: #define FALSE 0 ! 59: #define TRUE 1 ! 60: #define NOTDELETED 0 ! 61: #define DELETED 1 ! 62: ! 63: /* Sort Orders */ ! 64: #define NAME 0 ! 65: #define SIZE 1 ! 66: #define WRITE 2 ! 67: #define READ 3 ! 68: char sortstr[] = "nswr"; /* must be in order by above */ ! 69: ! 70: #define ESC '\033' ! 71: #define CURSOR 48 /* X-coord of cursor, just b4 file */ ! 72: #define CTRL(c) ('c' & 037) ! 73: ! 74: #include <stdio.h> ! 75: #include <sys/types.h> ! 76: #include <signal.h> ! 77: #include <sgtty.h> ! 78: #include <sys/stat.h> ! 79: #include <sys/dir.h> ! 80: ! 81: #ifdef UTAH ! 82: char *dirednam = "/usr/local/dired "; /* Where dired lives - need blnk */ ! 83: char *helpfile = "/usr/help/dired.hlp"; /* Where helpfile lives */ ! 84: #else ! 85: char *dirednam = "dired "; /* Where dired lives - need blnk */ ! 86: char *helpfile = "/usr/lib/dired"; /* Where helpfile lives */ ! 87: #endif ! 88: ! 89: char divider[132]; /* divides the windows */ ! 90: #define DIVCHAR '-' /* makes up the divider */ ! 91: ! 92: #define MOREPGM "p " /* program to page thru a file */ ! 93: ! 94: #define MAXFILES 2000 /* Max number of files we can handle */ ! 95: ! 96: struct lbuf ! 97: { ! 98: union ! 99: { ! 100: char lname[30]; ! 101: char *namep; ! 102: } ln; ! 103: short deleted; ! 104: char ltype; ! 105: short lnum; ! 106: short lflags; ! 107: short lnl; ! 108: short luid; ! 109: short lgid; ! 110: long lsize; ! 111: long latime; ! 112: long lctime; ! 113: long lmtime; ! 114: }; ! 115: ! 116: struct lbuf file[MAXFILES]; ! 117: ! 118: struct stat statbuf; ! 119: struct sgttyb ioctlb; ! 120: ! 121: #define ISARG 0100000 ! 122: ! 123: int gflg, ! 124: iflg, ! 125: lflg, ! 126: sflg; /* Random flags */ ! 127: int splitflg; /* Split screen? */ ! 128: int sortyp; /* Key to sort on */ ! 129: int errcode; /* Error variable used by rm */ ! 130: int rflg = 1; /* Reverse sort flag */ ! 131: int totfiles = 0; /* Total files */ ! 132: int flags; /* Gets flags */ ! 133: int blurb; /* 1=>thing in echo area,0 otherwise */ ! 134: int numdeleted; /* Number of files marked deleted */ ! 135: long ttime; /* Temp time variable */ ! 136: long year; /* Six months ago */ ! 137: long totblocks = 0; /* Total blocks */ ! 138: int lastuid = -1; /* Last uid/gid we handled */ ! 139: char tempbuf[128]; /* Random temporary buffer */ ! 140: char userbuf[35]; /* Temporary buffer for user name */ ! 141: FILE *pwdf, *dirf; /* Password/group file and directory files */ ! 142: ! 143: int curfile = 0; /* Current file */ ! 144: int topfile = 0; /* File at top of screen */ ! 145: int curline = 0; /* Line that we're on */ ! 146: int scrlen = 999; /* Length of screen - dired part: half size */ ! 147: int Worklen = 0; /* Length of 'working window', the other part*/ ! 148: int Worktop = 0; /* Top of " " */ ! 149: int Tscrlen; /*Total length of screen,minus 1 for cmd line*/ ! 150: int scrwid = 79; /* Width of screen */ ! 151: char *CL, ! 152: *UP, /* Termcap strings we'll use */ ! 153: *HO, ! 154: *CM, ! 155: *CD, /* clear to end of display */ ! 156: *CE, ! 157: *AL; /* insert line */ ! 158: char PC; ! 159: char tbuf[1024], ! 160: tcapbuf[128]; ! 161: char *tgetstr (), *tgoto (); ! 162: char *getenv (); ! 163: int compar (); ! 164: char *ctime (); ! 165: char *index(); ! 166: char *makename (); ! 167: char *catargs(); ! 168: char *bldnam(); ! 169: long nblock (); ! 170: int catchint(); ! 171: int sigint; ! 172: ! 173: char bufout[BUFSIZ]; ! 174: ! 175: main (argc, argv) ! 176: int argc; ! 177: char *argv[]; ! 178: { ! 179: register int i, ! 180: cc; ! 181: int numarg, ! 182: special, /* flag says had % or # in cmd */ ! 183: status; ! 184: char nambuf[128]; ! 185: char command; /* Holds last command */ ! 186: char **oldargv; ! 187: register char *t, ! 188: *tt; ! 189: ! 190: /* Get terminal type */ ! 191: ! 192: getcap (); ! 193: ! 194: /* Process arg flags. They must be first! */ ! 195: for (i=1; i<argc; i++) { ! 196: if (argv[i][0] != '-') ! 197: break; ! 198: switch (cc = argv[i][1]) { ! 199: case 'w': /* Window size */ ! 200: if (argv[i][2] == 'h') ! 201: scrlen = 999; /* Half */ ! 202: else if (argv[i][2] == 'f') ! 203: scrlen = 0; /* Full */ ! 204: else ! 205: scrlen = atoi(&argv[i][2]); ! 206: break; ! 207: case 's': /* Initial sort order */ ! 208: case 'r': ! 209: sortyp = index(sortstr, argv[i][2]) - sortstr; ! 210: rflg = (cc == 's') ? 1 : -1; ! 211: break; ! 212: default: ! 213: printf("Unknown option %s, ignored.\n", argv[i]); ! 214: break; ! 215: } ! 216: } ! 217: argc -= (i - 1); ! 218: oldargv = argv; ! 219: argv += (i - 1); ! 220: ! 221: if (scrlen == 0) /* full screen */ ! 222: scrlen = Tscrlen; ! 223: else if (scrlen == 999) /* means split in half */ ! 224: scrlen = (Tscrlen - 1) >> 1; ! 225: if (scrlen < 2) ! 226: scrlen = 2; ! 227: if (Tscrlen < scrlen) ! 228: scrlen = Tscrlen; ! 229: splitflg = (Tscrlen > scrlen+1); /* 1 extra line for separator */ ! 230: if (splitflg) { ! 231: Worklen = Tscrlen - (scrlen+1); /* size of 'working' window */ ! 232: Worktop = scrlen + 1; /* bottom half for now */ ! 233: } ! 234: else ! 235: Worklen = 0; ! 236: ! 237: tt = divider + scrwid - 14; ! 238: for (t = divider; t < tt;) /* arbitrary length */ ! 239: *t++ = DIVCHAR; ! 240: *t = '\0'; ! 241: ! 242: signal (SIGINT, SIG_IGN); ! 243: signal (SIGQUIT, SIG_IGN); ! 244: ! 245: setdpy (); ! 246: printf ("Reading"); ! 247: ! 248: time (&ttime); ! 249: year = ttime - 6L * 30L * 24L * 60L * 60L;/* 6 months ago */ ! 250: ! 251: lflg = 1; ! 252: gflg = iflg = sflg = 0; ! 253: if (lflg) ! 254: { ! 255: t = "/etc/passwd"; ! 256: if (gflg) ! 257: t = "/etc/group"; ! 258: pwdf = fopen (t, "r"); ! 259: } ! 260: ! 261: ! 262: numarg = argc; ! 263: if (argc == 1) ! 264: readdir ("."); ! 265: else ! 266: if (argc == 2) ! 267: readdir (argv[1]); ! 268: else ! 269: { ! 270: while (--argc > 0) ! 271: { ! 272: if (totfiles == MAXFILES) { ! 273: overflow(); ! 274: break; ! 275: } ! 276: if ((totfiles % 10) == 0) ! 277: putchar ('.'); ! 278: if (gstat(*++argv) == 0) { ! 279: file[totfiles].ln.namep = *argv; ! 280: file[totfiles].lflags |= ISARG; ! 281: totfiles++; ! 282: } ! 283: } ! 284: } ! 285: if (totfiles == 0) { ! 286: printf("\n?Empty directory\n"); ! 287: unsetdpy(); ! 288: sleep(1); /* So user can see it - don't worry if less */ ! 289: exit(0); ! 290: } ! 291: qsort (file, totfiles, sizeof (struct lbuf), compar); ! 292: blank (); ! 293: showscreen (); ! 294: curxy (0, Tscrlen); ! 295: ceol (); ! 296: curxy (CURSOR, 0); ! 297: startup: ! 298: while ((command = readchar()) != 'q') ! 299: { ! 300: if (blurb) ! 301: { ! 302: telluser (""); ! 303: blurb = 0; ! 304: } ! 305: switch (command) ! 306: { ! 307: case 'a': /* Abort completely */ ! 308: blank (); ! 309: unsetdpy (); ! 310: exit (1); ! 311: break; ! 312: case 'P': /* Print a file */ ! 313: case 'p': /* do a pr2 */ ! 314: if (file[curfile].ltype == 'd') ! 315: { ! 316: telluser ("?Can only print files"); ! 317: break; ! 318: } ! 319: tempbuf[0] = '\0'; ! 320: bldnam(tempbuf, numarg, curfile, argv); ! 321: telluser ("Printing..."); ! 322: while ((i = vfork ()) == -1) ! 323: sleep (3); ! 324: if (i == 0) { ! 325: #ifdef UTAH ! 326: if (command == 'p') /* little print */ ! 327: execlp("pr2", "pr2", tempbuf, 0); ! 328: else /* big print */ ! 329: #endif ! 330: execlp ("print", "print", tempbuf, 0); ! 331: telluser ("?Can't find program to list file.\n"); ! 332: _exit(1); ! 333: } ! 334: wait (&status); ! 335: break; ! 336: ! 337: case '!': /* Execute a system command */ ! 338: telluser (""); ! 339: curxy (0, Tscrlen); ! 340: unsetdpy (); ! 341: printf ("Command: "); ! 342: tempbuf[0] = 'x'; /* dummy kludge */ ! 343: if (gets(tempbuf) != NULL && tempbuf[0] != '\0') { ! 344: extern char *skipto(); ! 345: register char *op, /* old ptr */ ! 346: *np; /* new ptr */ ! 347: char bldbuf[70]; ! 348: ! 349: bldbuf[0] = '\0'; ! 350: op = tempbuf; ! 351: special = 0; ! 352: while (cc = *(np = skipto(op, "%#"))) { ! 353: special++; /* set flag */ ! 354: *np++ = '\0'; /* zap the %/# and bump past it */ ! 355: strcat(bldbuf, op); /* 1st part */ ! 356: if (cc == '%') /* complete file name */ ! 357: bldnam(bldbuf, numarg, curfile, argv); ! 358: else { /* Had # sign, trailing comp only */ ! 359: if (numarg <= 2) ! 360: strcat (bldbuf, file[curfile].ln.lname); ! 361: else ! 362: strcat (bldbuf, file[curfile].ln.namep); ! 363: } ! 364: ! 365: op = np; ! 366: } ! 367: strcat(bldbuf, op); ! 368: ! 369: blank (); ! 370: if (special) { /* display expanded command */ ! 371: printf( "%s\n", bldbuf); ! 372: } /* "system" takes long enuf for him to see it */ ! 373: signal(SIGINT, SIG_DFL); /* temp kludge here... */ ! 374: signal(SIGQUIT, SIG_DFL); /* should not use 'system' */ ! 375: system (bldbuf); ! 376: signal (SIGINT, SIG_IGN); ! 377: signal (SIGQUIT, SIG_IGN); ! 378: printf ("\nCR to return..."); ! 379: setdpy (); ! 380: readchar(); ! 381: blank (); ! 382: showscreen (); ! 383: telluser (""); ! 384: } ! 385: else { /* CR only, or EOF, or error */ ! 386: /* ! 387: * He changed his mind, skip it. Since we were in ! 388: * cooked mode, the CR ending the gets is echoed and ! 389: * we lost the first line of the display. So we ! 390: * re-insert it. ! 391: */ ! 392: setdpy(); ! 393: if (tempbuf[0] == 'x') /* means EOF */ ! 394: telluser(""); ! 395: /* null entry, normal case */ ! 396: else if (AL == 0) { /* no insert line capability */ ! 397: blank(); ! 398: showscreen(); ! 399: } ! 400: else { /* be a little sneakier */ ! 401: curxy(0, Tscrlen-1); /* go back to where prompt */ ! 402: ceol(); /* is now, and blank it */ ! 403: home(); ! 404: insline(); /* make some room */ ! 405: pentry(topfile); ! 406: putchar('\n'); ! 407: } ! 408: curxy(CURSOR, curline); ! 409: } ! 410: break; ! 411: ! 412: case 'r': /* Reverse sort */ ! 413: curxy (0, Tscrlen); ! 414: printf ("reverse "); ! 415: rflg = -1; ! 416: case 's': /* Normal sort */ ! 417: if (command == 's') ! 418: { ! 419: curxy (0, Tscrlen); ! 420: rflg = 1; ! 421: } ! 422: printf ("sort by [s,n,r,w]: "); ! 423: command = readchar(); ! 424: while ((command == '?') || !((command == 'n') || ! 425: (command == 'r') || (command == 'w') || (command == 's') || ! 426: (command == CTRL(g)))) ! 427: { ! 428: curxy (0, Tscrlen); ! 429: ceol (); ! 430: if (rflg == -1) ! 431: printf ("reverse "); ! 432: printf ("sort by size, name, read or write date: "); ! 433: command = readchar(); ! 434: } ! 435: ! 436: if (command == CTRL(g)) { /* abort */ ! 437: putchar(CTRL(g)); /* echo it */ ! 438: telluser(""); ! 439: curxy(CURSOR, curline); ! 440: break; ! 441: } ! 442: ! 443: if (command == 's') ! 444: sortyp = SIZE; ! 445: else ! 446: if (command == 'w') ! 447: sortyp = WRITE; ! 448: else ! 449: if (command == 'r') ! 450: sortyp = READ; ! 451: else ! 452: sortyp = 0; ! 453: printf ("%c", command); ! 454: qsort (file, totfiles, sizeof (struct lbuf), compar); ! 455: topfile = 0; ! 456: curfile = 0; ! 457: curline = 0; ! 458: blank (); ! 459: showscreen (); ! 460: curxy (CURSOR, 0); ! 461: break; ! 462: ! 463: case 'e': /* Edit a file or directory */ ! 464: if (file[curfile].ltype == 'd') { ! 465: strcpy (tempbuf, dirednam); ! 466: catargs(tempbuf, oldargv); ! 467: } ! 468: else { ! 469: if ((t = getenv("EDITOR")) != NULL) ! 470: strcat(strcpy(tempbuf, t), " "); ! 471: else ! 472: strcpy (tempbuf, "ed "); ! 473: } ! 474: bldnam(tempbuf, numarg, curfile, argv); ! 475: blank (); ! 476: unsetdpy (); ! 477: system (tempbuf); ! 478: setdpy (); ! 479: blank (); ! 480: showscreen (); ! 481: telluser (""); ! 482: break; ! 483: ! 484: case 'm': /* 'more' a file */ ! 485: if (file[curfile].ltype == 'd') ! 486: { ! 487: telluser ("?Can only page thru files"); ! 488: break; ! 489: } ! 490: strcpy (tempbuf, MOREPGM); ! 491: bldnam(tempbuf, numarg, curfile, argv); ! 492: blank (); ! 493: unsetdpy (); ! 494: system (tempbuf); ! 495: /* if (!sigint) { */ ! 496: printf ("\nCR to return..."); ! 497: /* } */ ! 498: setdpy (); ! 499: readchar(); ! 500: blank (); ! 501: showscreen (); ! 502: telluser (""); ! 503: break; ! 504: ! 505: case 'T': /* don't wait at page end */ ! 506: case 't': /* quickly type the file -- added 5/81, J.Lepreau */ ! 507: if (file[curfile].ltype == 'd') ! 508: { ! 509: telluser ("?Can only type files"); ! 510: break; ! 511: } ! 512: tempbuf[0] = '\0'; ! 513: bldnam(tempbuf, numarg, curfile, argv); ! 514: if (type(tempbuf, command == 't')) /* little t means wait */ ! 515: showscreen (); ! 516: curxy (CURSOR, curline); ! 517: break; ! 518: ! 519: case 'l': /* Refresh screen */ ! 520: case CTRL(l): /* added for editor compatibility -fjl */ ! 521: blank (); ! 522: showscreen (); ! 523: telluser (""); ! 524: break; ! 525: case 'c': /* Refresh current line */ ! 526: curxy (0, curline); ! 527: pentry (curfile); ! 528: curxy (CURSOR, curline); ! 529: break; ! 530: case CTRL(v): ! 531: case 'f': /* forward window */ ! 532: fscreen (); ! 533: break; ! 534: /* wish we could do meta-v */ ! 535: case 'b': /* backward window */ ! 536: bscreen (); ! 537: break; ! 538: case CTRL(n): ! 539: case '\r': ! 540: case '\n': /* next file */ ! 541: if (curfile == totfiles - 1) ! 542: telluser ("?At end of files"); ! 543: else ! 544: if (curline == scrlen - 1) ! 545: { ! 546: topfile = curfile; ! 547: curline = 0; ! 548: blank (); ! 549: showscreen (); ! 550: curxy (CURSOR, 0); ! 551: downline (); ! 552: } ! 553: else ! 554: downline (); ! 555: break; ! 556: case '^': /* previous file */ ! 557: case CTRL(h): /* backspace */ ! 558: case '-': ! 559: case CTRL(p): ! 560: if (curfile == 0) ! 561: telluser ("?At start of files"); ! 562: else ! 563: if (curline == 0) ! 564: { ! 565: topfile = curfile - scrlen + 1; ! 566: curline = scrlen - 1; ! 567: blank (); ! 568: showscreen (); ! 569: curxy (CURSOR, curline); ! 570: upline (); ! 571: } ! 572: else ! 573: upline (); ! 574: break; ! 575: case 'h': /* Help */ ! 576: case '?': ! 577: if (type(helpfile, 1)) /* wait */ ! 578: showscreen (); ! 579: curxy (CURSOR, curline); ! 580: break; ! 581: case 'd': /* delete file */ ! 582: if (file[curfile].deleted == DELETED) ! 583: telluser ("?Already marked deleted"); ! 584: else ! 585: { ! 586: numdeleted++; ! 587: file[curfile].deleted = DELETED; ! 588: printf ("D%c", 010); ! 589: if (curline + 1 == scrlen) ! 590: { ! 591: fscreen (); ! 592: downline (); ! 593: } ! 594: else ! 595: if (curfile != totfiles - 1) ! 596: downline (); ! 597: } ! 598: break; ! 599: case 'u': /* undelete file */ ! 600: if (file[curfile].deleted == NOTDELETED) ! 601: telluser ("?Not marked deleted"); ! 602: else ! 603: { ! 604: numdeleted--; ! 605: file[curfile].deleted = NOTDELETED; ! 606: printf (" %c", 010); ! 607: } ! 608: break; ! 609: default: ! 610: telluser ("Unknown command. Type ? or h for help"); ! 611: break; ! 612: } ! 613: } ! 614: if (numdeleted) ! 615: { ! 616: blank (); ! 617: printf ("The following %s marked for deletion:\n", ! 618: (numdeleted == 1) ? "is" : "are"); ! 619: typefiles (); ! 620: printf ("\nShall I delete %s? ", ! 621: (numdeleted == 1) ? "this" : "these"); ! 622: if ((command = readchar()) != 'y') ! 623: { ! 624: blank (); ! 625: showscreen (); ! 626: curxy (0, Tscrlen); ! 627: ceol (); ! 628: curxy (CURSOR, curline); ! 629: goto startup; ! 630: } ! 631: else ! 632: { ! 633: printf ("y\n"); ! 634: for (i = 0; i < totfiles; i++) ! 635: if (file[i].deleted == DELETED) { ! 636: nambuf[0] = '\0'; ! 637: bldnam(nambuf, numarg, i, argv); ! 638: if (file[i].ltype == 'd') ! 639: rm (nambuf, 0); ! 640: else ! 641: if (unlink (nambuf) < 0) ! 642: printf ("Delete of %s failed.\n", nambuf); ! 643: } ! 644: } ! 645: } ! 646: else ! 647: blank (); ! 648: ! 649: unsetdpy (); ! 650: exit(0); ! 651: } ! 652: ! 653: typefiles () ! 654: { ! 655: int longsiz, ! 656: i, ! 657: j, ! 658: maxperln, ! 659: numout, ! 660: longthis; ! 661: longsiz = numout = 0; ! 662: for (i = 0; i < totfiles; i++) ! 663: if (file[i].deleted == DELETED) ! 664: if (file[i].lflags & ISARG) ! 665: { ! 666: if (strlen (file[i].ln.namep) > longsiz) ! 667: { ! 668: longsiz = strlen (file[i].ln.namep); ! 669: } ! 670: } ! 671: else ! 672: { ! 673: if (strlen (file[i].ln.lname) > longsiz) ! 674: { ! 675: longsiz = strlen (file[i].ln.lname); ! 676: } ! 677: } ! 678: maxperln = scrwid / (longsiz + 3); ! 679: for (i = 0; i < totfiles; i++) ! 680: if (file[i].deleted == DELETED) ! 681: { ! 682: if (file[i].lflags & ISARG) ! 683: { ! 684: printf ("%s", file[i].ln.namep); ! 685: longthis = strlen (file[i].ln.namep); ! 686: } ! 687: else ! 688: { ! 689: printf ("%.14s", file[i].ln.lname); ! 690: longthis = strlen (file[i].ln.lname); ! 691: } ! 692: numout++; ! 693: if ((numout % maxperln) == 0) ! 694: putchar ('\n'); ! 695: else if (numout != numdeleted) ! 696: for (j = 0; j < (longsiz + 3 - longthis); j++) ! 697: putchar (' '); ! 698: } ! 699: } ! 700: ! 701: rm (arg, level) ! 702: char arg[]; ! 703: { ! 704: struct stat buf; ! 705: struct direct direct; ! 706: char name[100]; ! 707: int d; ! 708: ! 709: if (stat (arg, &buf)) ! 710: { ! 711: return; ! 712: } ! 713: if ((buf.st_mode & S_IFMT) == S_IFDIR) ! 714: { ! 715: if (access (arg, 02) < 0) ! 716: { ! 717: printf ("%s not deleted.\n", arg); ! 718: return; ! 719: } ! 720: if ((d = open (arg, 0)) < 0) ! 721: { ! 722: printf ("rm: %s: cannot read\n", arg); ! 723: return; ! 724: } ! 725: while (read (d, (char *) & direct, sizeof (direct)) == sizeof (direct)) ! 726: { ! 727: if (direct.d_ino != 0 && !dotname (direct.d_name)) ! 728: { ! 729: sprintf (name, "%s/%.14s", arg, direct.d_name); ! 730: rm (name, level + 1); ! 731: } ! 732: } ! 733: close (d); ! 734: errcode += rmdir (arg); ! 735: return; ! 736: } ! 737: ! 738: if (unlink (arg)) ! 739: { ! 740: ++errcode; ! 741: printf ("%s not deleted.\n", arg); ! 742: } ! 743: } ! 744: ! 745: dotname (s) ! 746: char *s; ! 747: { ! 748: if (s[0] == '.') ! 749: if (s[1] == '.') ! 750: if (s[2] == '\0') ! 751: return (1); ! 752: else ! 753: return (0); ! 754: else ! 755: if (s[1] == '\0') ! 756: return (1); ! 757: return (0); ! 758: } ! 759: ! 760: rmdir (f) ! 761: char *f; ! 762: { ! 763: int status, ! 764: i; ! 765: ! 766: if (dotname (f)) ! 767: return (0); ! 768: while ((i = vfork ()) == -1) ! 769: sleep (3); ! 770: if (i == 0) { ! 771: execl ("/bin/rmdir", "rmdir", f, 0); ! 772: execl ("/usr/bin/rmdir", "rmdir", f, 0); ! 773: printf ("rm: can't find rmdir\n"); ! 774: _exit(1); ! 775: } ! 776: wait (&status); ! 777: return (status); ! 778: } ! 779: ! 780: fscreen () ! 781: { ! 782: if (topfile + scrlen - 1 > totfiles - 1) ! 783: telluser ("?No remaining windows"); ! 784: else ! 785: { ! 786: topfile = topfile + scrlen - 1; ! 787: curfile = topfile; ! 788: curline = 0; ! 789: blank (); ! 790: showscreen (); ! 791: curxy (CURSOR, 0); ! 792: } ! 793: } ! 794: ! 795: bscreen () ! 796: { ! 797: if (topfile - scrlen + 1 < 0) ! 798: telluser ("?No previous windows"); ! 799: else ! 800: { ! 801: topfile = topfile - scrlen + 1; ! 802: curfile = topfile; ! 803: curline = 0; ! 804: blank (); ! 805: showscreen (); ! 806: curxy (CURSOR, 0); ! 807: } ! 808: } ! 809: ! 810: showscreen () ! 811: { ! 812: int i, ! 813: numprint; ! 814: home (); ! 815: numprint = 0; ! 816: for (i = topfile; (numprint < scrlen) && (i < totfiles); i++) ! 817: { ! 818: numprint++; ! 819: pentry (i); ! 820: putchar ('\n'); ! 821: } ! 822: if (splitflg) ! 823: printf ("%s\n", divider); ! 824: } ! 825: ! 826: readdir (dir) /* Reads directory dir */ ! 827: char *dir; ! 828: { ! 829: static struct direct dentry; ! 830: register int j; ! 831: ! 832: if ((dirf = fopen (dir, "r")) == NULL) ! 833: { ! 834: printf ("\nSorry, %s unreadable.\n", dir); ! 835: unsetdpy (); ! 836: exit(1); ! 837: } ! 838: for (;;) ! 839: { ! 840: if (fread ((char *) & dentry, sizeof (dentry), 1, dirf) != 1) ! 841: break; ! 842: if (dentry.d_ino == 0 ! 843: || dentry.d_name[0] == '.' && (dentry.d_name[1] == '\0' ! 844: || dentry.d_name[1] == '.' && dentry.d_name[2] == '\0')) ! 845: continue; ! 846: ! 847: if (totfiles == MAXFILES) ! 848: overflow(); /* abort, too may files */ ! 849: /* Just ignore if can't find the file, dir may be changing */ ! 850: if (gstat (makename (dir, dentry.d_name)) == 0) { /* 0 == Ok */ ! 851: file[totfiles].lnum = dentry.d_ino; ! 852: for (j = 0; j < DIRSIZ; j++) ! 853: file[totfiles].ln.lname[j] = dentry.d_name[j]; ! 854: totfiles++; ! 855: if (totfiles % 10 == 0) ! 856: putchar ('.'); ! 857: } ! 858: } ! 859: fclose (dirf); ! 860: } ! 861: ! 862: gstat (name) /* Stats the file with name */ ! 863: char *name; ! 864: { ! 865: ! 866: file[totfiles].lflags = 0; ! 867: file[totfiles].lnum = 0; ! 868: file[totfiles].ltype = '-'; ! 869: ! 870: if (stat (name, &statbuf) < 0) ! 871: { ! 872: return(-1); ! 873: } ! 874: file[totfiles].lnum = statbuf.st_ino; ! 875: file[totfiles].lsize = statbuf.st_size; ! 876: switch (statbuf.st_mode & S_IFMT) ! 877: { ! 878: case S_IFLNK: ! 879: file[totfiles].ltype = 'l'; ! 880: break; ! 881: case S_IFDIR: ! 882: file[totfiles].ltype = 'd'; ! 883: break; ! 884: case S_IFBLK: ! 885: file[totfiles] .ltype = 'b'; ! 886: file[totfiles].lsize = statbuf.st_rdev; ! 887: break; ! 888: case S_IFCHR: ! 889: file[totfiles].ltype = 'c'; ! 890: file[totfiles].lsize = statbuf.st_rdev; ! 891: break; ! 892: } ! 893: file[totfiles].lflags = statbuf.st_mode & ~S_IFMT; ! 894: file[totfiles].luid = statbuf.st_uid; ! 895: file[totfiles].lgid = statbuf.st_gid; ! 896: file[totfiles].lnl = statbuf.st_nlink; ! 897: file[totfiles].latime = statbuf.st_atime; ! 898: file[totfiles].lctime = statbuf.st_ctime; ! 899: file[totfiles].lmtime = statbuf.st_mtime; ! 900: totblocks += nblock (statbuf.st_size); ! 901: return(0); ! 902: } ! 903: ! 904: char * ! 905: makename (dir, filen) ! 906: char *dir, ! 907: *filen; ! 908: { ! 909: static char dfile[100]; ! 910: register char *dp, ! 911: *fp; ! 912: register int i; ! 913: ! 914: dp = dfile; ! 915: fp = dir; ! 916: while (*fp) ! 917: *dp++ = *fp++; ! 918: *dp++ = '/'; ! 919: fp = filen; ! 920: for (i = 0; i < DIRSIZ; i++) ! 921: *dp++ = *fp++; ! 922: *dp = 0; ! 923: return (dfile); ! 924: } ! 925: ! 926: long ! 927: nblock (size) ! 928: long size; ! 929: { ! 930: return ((size + 511) >> 9); ! 931: } ! 932: ! 933: pentry (whichone) ! 934: int whichone; ! 935: { ! 936: struct ! 937: { ! 938: char dminor, ! 939: dmajor; ! 940: }; ! 941: register t; ! 942: register char *cp; ! 943: ! 944: if (file[whichone].lnum == -1) ! 945: return; ! 946: if (iflg) ! 947: printf ("%5u ", file[whichone].lnum); ! 948: if (sflg) ! 949: printf ("%4D ", nblock (file[whichone].lsize)); ! 950: if (lflg) ! 951: { ! 952: putchar (file[whichone].ltype); ! 953: pmode (file[whichone].lflags); ! 954: printf ("%2d ", file[whichone].lnl); ! 955: t = file[whichone].luid; ! 956: if (gflg) ! 957: t = file[whichone].lgid; ! 958: if (getname (t, userbuf) == 0) ! 959: printf ("%-14.14s", userbuf); ! 960: else ! 961: printf ("%-14d", t); ! 962: if (file[whichone].ltype == 'b' || file[whichone].ltype == 'c') ! 963: printf ("%3d,%3d", major ((int) file[whichone].lsize), ! 964: minor ((int) file[whichone].lsize)); ! 965: else ! 966: printf ("%7ld", file[whichone].lsize); ! 967: if ((sortyp == WRITE) || (sortyp == 0) || (sortyp == SIZE)) ! 968: { ! 969: cp = ctime (&file[whichone].lmtime); ! 970: if (file[whichone].lmtime < year) ! 971: printf (" %-7.7s %-4.4s ", cp + 4, cp + 20); ! 972: else ! 973: printf (" %-12.12s ", cp + 4); ! 974: } ! 975: else ! 976: if (sortyp == READ) ! 977: { ! 978: cp = ctime (&file[whichone].latime); ! 979: if (file[whichone].latime < year) ! 980: printf (" %-7.7s %-4.4s ", cp + 4, cp + 20); ! 981: else ! 982: printf (" %-12.12s ", cp + 4); ! 983: } ! 984: } ! 985: printf ("%c", file[whichone].deleted ? 'D' : ' '); ! 986: if (file[whichone].lflags & ISARG) ! 987: printf (" %s", file[whichone].ln.namep); ! 988: else { ! 989: putchar(' '); ! 990: for (t=0; t<14; t++) { ! 991: register c = file[whichone].ln.lname[t] & 0377;; ! 992: if (c == '\0') ! 993: break; ! 994: if (c<' ' || c>=0200) { ! 995: c &= 0177; ! 996: c |= 0100; ! 997: putchar('^'); ! 998: } ! 999: putchar(c); ! 1000: } ! 1001: } ! 1002: } ! 1003: ! 1004: getname (uid, buf) ! 1005: int uid; ! 1006: char buf[]; ! 1007: { ! 1008: int j, ! 1009: c, ! 1010: n, ! 1011: i; ! 1012: ! 1013: if (uid == lastuid) ! 1014: return (0); ! 1015: if (pwdf == NULL) ! 1016: return (-1); ! 1017: rewind (pwdf); ! 1018: lastuid = -1; ! 1019: do ! 1020: { ! 1021: i = 0; ! 1022: j = 0; ! 1023: n = 0; ! 1024: while ((c = fgetc (pwdf)) != '\n') ! 1025: { ! 1026: if (c == EOF) ! 1027: return (-1); ! 1028: if (c == ':') ! 1029: { ! 1030: j++; ! 1031: c = '0'; ! 1032: } ! 1033: if (j == 0) ! 1034: buf[i++] = c; ! 1035: if (j == 2) ! 1036: n = n * 10 + c - '0'; ! 1037: } ! 1038: } while (n != uid); ! 1039: buf[i++] = '\0'; ! 1040: lastuid = uid; ! 1041: return (0); ! 1042: } ! 1043: ! 1044: int m1[] = ! 1045: { ! 1046: 1, S_IREAD >> 0, 'r', '-' ! 1047: }; ! 1048: int m2[] = ! 1049: { ! 1050: 1, S_IWRITE >> 0, 'w', '-' ! 1051: }; ! 1052: int m3[] = ! 1053: { ! 1054: 2, S_ISUID, 's', S_IEXEC >> 0, 'x', '-' ! 1055: }; ! 1056: int m4[] = ! 1057: { ! 1058: 1, S_IREAD >> 3, 'r', '-' ! 1059: }; ! 1060: int m5[] = ! 1061: { ! 1062: 1, S_IWRITE >> 3, 'w', '-' ! 1063: }; ! 1064: int m6[] = ! 1065: { ! 1066: 2, S_ISGID, 's', S_IEXEC >> 3, 'x', '-' ! 1067: }; ! 1068: int m7[] = ! 1069: { ! 1070: 1, S_IREAD >> 6, 'r', '-' ! 1071: }; ! 1072: int m8[] = ! 1073: { ! 1074: 1, S_IWRITE >> 6, 'w', '-' ! 1075: }; ! 1076: int m9[] = ! 1077: { ! 1078: 2, S_ISVTX, 't', S_IEXEC >> 6, 'x', '-' ! 1079: }; ! 1080: ! 1081: int *m[] = ! 1082: { ! 1083: m1, m2, m3, m4, m5, m6, m7, m8, m9 ! 1084: }; ! 1085: ! 1086: pmode (aflag) ! 1087: { ! 1088: register int **mp; ! 1089: ! 1090: flags = aflag; ! 1091: for (mp = &m[0]; mp < &m[sizeof (m) / sizeof (m[0])];) ! 1092: select (*mp++); ! 1093: } ! 1094: ! 1095: select (pairp) ! 1096: register int *pairp; ! 1097: { ! 1098: register int n; ! 1099: ! 1100: n = *pairp++; ! 1101: while (--n >= 0 && (flags & *pairp++) == 0) ! 1102: pairp++; ! 1103: putchar (*pairp); ! 1104: } ! 1105: ! 1106: compar (pp1, pp2) ! 1107: struct lbuf *pp1, ! 1108: *pp2; ! 1109: { ! 1110: register struct lbuf *p1, ! 1111: *p2; ! 1112: ! 1113: p1 = pp1; ! 1114: p2 = pp2; ! 1115: if (p1 -> lflags & ISARG && p1 -> ltype == 'd') ! 1116: { ! 1117: if (!(p2 -> lflags & ISARG && p2 -> ltype == 'd')) ! 1118: return (1); ! 1119: } ! 1120: else ! 1121: { ! 1122: if (p2 -> lflags & ISARG && p2 -> ltype == 'd') ! 1123: return (-1); ! 1124: } ! 1125: if (sortyp == SIZE) ! 1126: { ! 1127: if (p2 -> lsize == p1 -> lsize) ! 1128: return (0); ! 1129: if (p2 -> lsize > p1 -> lsize) ! 1130: return (rflg); ! 1131: return (-rflg); ! 1132: } ! 1133: else ! 1134: if (sortyp == WRITE) ! 1135: { ! 1136: if (p2 -> lmtime == p1 -> lmtime) ! 1137: return (0); ! 1138: if (p2 -> lmtime > p1 -> lmtime) ! 1139: return (rflg); ! 1140: return (-rflg); ! 1141: } ! 1142: else ! 1143: if (sortyp == READ) ! 1144: { ! 1145: if (p2 -> latime == p1 -> latime) ! 1146: return (0); ! 1147: if (p2 -> latime > p1 -> latime) ! 1148: return (rflg); ! 1149: return (-rflg); ! 1150: } ! 1151: return (rflg * strcmp (p1 -> lflags & ISARG ? p1 -> ln.namep : p1 -> ln.lname, ! 1152: p2 -> lflags & ISARG ? p2 -> ln.namep : p2 -> ln.lname)); ! 1153: } ! 1154: ! 1155: ceod() ! 1156: { ! 1157: putpad(CD); ! 1158: } ! 1159: ! 1160: ceol () ! 1161: { ! 1162: putpad (CE); ! 1163: } ! 1164: blank () ! 1165: { ! 1166: putpad (CL); ! 1167: } ! 1168: home () ! 1169: { ! 1170: if (HO) ! 1171: putpad (HO); ! 1172: else ! 1173: curxy(0,0); ! 1174: } ! 1175: insline () ! 1176: { ! 1177: putpad (AL); ! 1178: } ! 1179: ! 1180: /* Yes, folks, we use direct cursor addressing to get to next line! ! 1181: Before you mumble "What sort of cretin would do this?" here's ! 1182: the reason. We don't use \n since that obviously won't work. ! 1183: We don't use \012 since virgin version 7 makes that into a crlf. ! 1184: We don't use raw mode since we type out help files efficently, ! 1185: and we don't want to switch modes all the time. So enjoy. -- SMC */ ! 1186: ! 1187: downline () ! 1188: { ! 1189: curxy (CURSOR, ++curline); ! 1190: curfile++; ! 1191: } ! 1192: upline () ! 1193: { ! 1194: putpad (UP); ! 1195: curline--; ! 1196: curfile--; ! 1197: } ! 1198: ! 1199: /*VARARGS1*/ ! 1200: telluser (msg, args) ! 1201: char *msg; ! 1202: { ! 1203: curxy (0, Tscrlen); ! 1204: ceol (); ! 1205: printf (msg, args); ! 1206: curxy (CURSOR, curline); ! 1207: blurb++; ! 1208: } ! 1209: curxy (col, lin) ! 1210: { ! 1211: char *cmstr = tgoto (CM, col, lin); ! 1212: putpad (cmstr); ! 1213: } ! 1214: ! 1215: char *fgets(); ! 1216: ! 1217: type (filestr, waitflg) /* Modified to type help file & others. fjl 5/81 */ ! 1218: char *filestr; /* Kludgy now with split screen stuff! */ ! 1219: { ! 1220: int helpfd = 5; ! 1221: FILE *fd = stdin; ! 1222: char *eof; ! 1223: register int i, n; ! 1224: register int cc = 0; ! 1225: int cur_scrl; /* current screen length */ ! 1226: char helpbuf[512]; ! 1227: ! 1228: if (!splitflg) ! 1229: helpfd = open(filestr, 0); ! 1230: else ! 1231: fd = fopen(filestr, "r"); ! 1232: if (helpfd < 0 || fd == NULL) { ! 1233: telluser("?Unable to open %sfile",strcmp(filestr,helpfile)?"":"help "); ! 1234: return (FALSE); ! 1235: } ! 1236: ! 1237: signal(SIGINT, catchint); ! 1238: sigint = 0; ! 1239: ! 1240: if (!splitflg) { ! 1241: blank(); ! 1242: fflush(stdout); ! 1243: while ((i = read (helpfd, helpbuf, 512)) > 0 && !sigint) ! 1244: write (1, helpbuf, i); ! 1245: close(helpfd); ! 1246: } ! 1247: else { ! 1248: cur_scrl = totfiles - topfile + 1; /* topfile starts at 0 */ ! 1249: Worktop = ((cur_scrl < scrlen) ? cur_scrl : scrlen) + 1; ! 1250: do { ! 1251: curxy(0, Worktop); ! 1252: ceod(); ! 1253: for (i = Worktop; (i < Tscrlen) && !sigint && (cc != EOF); i++) { ! 1254: n = 0; ! 1255: while ((cc = getc(fd)) != EOF) { ! 1256: if (cc == '\t') ! 1257: n |= 07; ! 1258: chklen: if (n++ == scrwid-1) { /* Use most of screen */ ! 1259: if (cc != '\n') { ! 1260: ungetc(cc, fd); ! 1261: cc = '\n'; ! 1262: } ! 1263: } ! 1264: if (cc < ' ' && cc!='\n' && cc!='\t' || cc>=0200) { ! 1265: putchar('^'); ! 1266: cc &= 0177; ! 1267: cc |= 0100; ! 1268: goto chklen; ! 1269: } ! 1270: putchar(cc); ! 1271: if (cc == '\n') ! 1272: break; ! 1273: } ! 1274: } ! 1275: } while (!sigint && (cc != EOF) && waitchk(waitflg)); ! 1276: ! 1277: if (feof(fd)) ! 1278: printf("===== End-of-File =====\n"); ! 1279: fflush(stdout); ! 1280: fclose(fd); ! 1281: return(FALSE); /* means needs no re-display */ ! 1282: } ! 1283: ! 1284: if (!splitflg) { /* redundant now... */ ! 1285: if (!sigint) { ! 1286: curxy(0, Tscrlen); ! 1287: printf ("CR to return..."); ! 1288: readchar(); ! 1289: } ! 1290: blank (); ! 1291: return (TRUE); ! 1292: } ! 1293: } ! 1294: ! 1295: waitchk(waitflg) ! 1296: { ! 1297: if (!waitflg) ! 1298: return(1); ! 1299: fflush(stdout); ! 1300: curxy(0, Tscrlen); ! 1301: printf ("---Continue---"); ! 1302: ceol(); ! 1303: curxy(0, Tscrlen); ! 1304: readchar(); ! 1305: ceol(); ! 1306: if (sigint) ! 1307: return(0); /* avoids clear of screen */ ! 1308: return(1); ! 1309: } ! 1310: ! 1311: setdpy () ! 1312: { ! 1313: ioctl (0, TIOCGETP, &ioctlb); ! 1314: ioctlb.sg_flags |= CBREAK; ! 1315: ioctlb.sg_flags &= ~ECHO; ! 1316: ioctl (0, TIOCSETP, &ioctlb); ! 1317: } ! 1318: ! 1319: unsetdpy () ! 1320: { ! 1321: ioctlb.sg_flags &= ~CBREAK; ! 1322: ioctlb.sg_flags |= ECHO; ! 1323: ioctl (0, TIOCSETP, &ioctlb); ! 1324: } ! 1325: ! 1326: getcap () ! 1327: { ! 1328: char *ap; ! 1329: char *term; ! 1330: char *xPC; ! 1331: ! 1332: term = getenv ("TERM"); ! 1333: if (term == 0) ! 1334: { ! 1335: printf("No TERM in environment\n"); ! 1336: exit(1); ! 1337: } ! 1338: ! 1339: switch (tgetent (tbuf, term)) ! 1340: { ! 1341: case -1: ! 1342: printf("Cannot open termcap file\n"); ! 1343: exit (2); ! 1344: case 0: ! 1345: printf("%s: unknown terminal", term); ! 1346: exit (3); ! 1347: } ! 1348: ! 1349: ap = tcapbuf; ! 1350: ! 1351: Tscrlen = tgetnum ("li") - 1; ! 1352: scrwid = tgetnum ("co") - 1;/* lose 1 so won't scroll in last line */ ! 1353: ! 1354: UP = tgetstr ("up", &ap); ! 1355: CD = tgetstr ("cd", &ap); ! 1356: CE = tgetstr ("ce", &ap); ! 1357: HO = tgetstr ("ho", &ap); ! 1358: CL = tgetstr ("cl", &ap); ! 1359: CM = tgetstr ("cm", &ap); ! 1360: AL = tgetstr ("al", &ap); /* insert line, optional */ ! 1361: ! 1362: xPC = tgetstr ("pc", &ap); ! 1363: if (xPC) ! 1364: PC = *xPC; ! 1365: ! 1366: if ((CM == 0) || (CL == 0) || (UP == 0)) ! 1367: { ! 1368: printf("Tty must have cursor addr, clear, and 4 cursor motions.\n"); ! 1369: exit (1); ! 1370: } ! 1371: if (Tscrlen <= 0 || scrwid <= 0) ! 1372: { ! 1373: printf("Must know the screen size\n"); ! 1374: exit (1); ! 1375: } ! 1376: } ! 1377: ! 1378: outch (c) ! 1379: { ! 1380: putchar (c); ! 1381: } ! 1382: ! 1383: putpad (str) ! 1384: char *str; ! 1385: { ! 1386: if (str) ! 1387: tputs (str, 0, outch); ! 1388: } ! 1389: ! 1390: catchint(sig) ! 1391: { ! 1392: signal(SIGINT, SIG_IGN); /* reset it */ ! 1393: sigint = 1; ! 1394: } ! 1395: ! 1396: char * ! 1397: bldnam(str, numarg, filidx, argv) ! 1398: char *str; ! 1399: char *argv[]; ! 1400: { ! 1401: ! 1402: if (numarg == 1) ! 1403: strcat (str, file[filidx].ln.lname); ! 1404: else ! 1405: if (numarg == 2) { ! 1406: strcat (str, argv[1]); ! 1407: strcat (str, "/"); ! 1408: strcat (str, file[filidx].ln.lname); ! 1409: } ! 1410: else ! 1411: strcat (str, file[filidx].ln.namep); ! 1412: return(str); ! 1413: } ! 1414: ! 1415: char * ! 1416: catargs(str, argv) ! 1417: char *str; ! 1418: char *argv[]; ! 1419: { ! 1420: register int i; ! 1421: ! 1422: for (++argv; *argv; argv++) { ! 1423: if (**argv == '-') { ! 1424: strcat(str, *argv); ! 1425: strcat(str, " "); ! 1426: } ! 1427: } ! 1428: return(str); ! 1429: } ! 1430: ! 1431: overflow() ! 1432: { ! 1433: printf("\n?Too many files\007\n"); ! 1434: fflush(stdout); ! 1435: sleep(1); /* So user can see it - don't worry if less */ ! 1436: } ! 1437: ! 1438: char *skipto (string,charset) ! 1439: char *charset,*string; ! 1440: { ! 1441: register char *setp,*strp; ! 1442: register int found; ! 1443: ! 1444: found = 0; /* not found yet */ ! 1445: strp = string; /* start at first char */ ! 1446: ! 1447: while (*strp && !found) { /* until null or found */ ! 1448: /* find first char in charset matching *strp */ ! 1449: for (setp=charset; (*setp) && (*setp != *strp); setp++) ; ! 1450: if (*setp) found = 1; /* matches a char */ ! 1451: else strp++; /* else keep looking */ ! 1452: } ! 1453: ! 1454: return (strp); ! 1455: } ! 1456: ! 1457: readchar() ! 1458: { ! 1459: static neofs; ! 1460: register c; ! 1461: ! 1462: fflush(stdout); ! 1463: c = getchar(); ! 1464: if (c == EOF) ! 1465: if (++neofs > 100) ! 1466: exit(1); ! 1467: return(c); ! 1468: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.