![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cmd3.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / Mail|
Return to cmd3.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / Mail |
1.1 ! root 1: /* ! 2: * Copyright (c) 1980 Regents of the University of California. ! 3: * All rights reserved. The Berkeley software License Agreement ! 4: * specifies the terms and conditions for redistribution. ! 5: */ ! 6: ! 7: #ifndef lint ! 8: static char *sccsid = "@(#)cmd3.c 5.3 (Berkeley) 9/15/85"; ! 9: #endif not lint ! 10: ! 11: #include "rcv.h" ! 12: #include <sys/stat.h> ! 13: ! 14: /* ! 15: * Mail -- a mail program ! 16: * ! 17: * Still more user commands. ! 18: */ ! 19: ! 20: /* ! 21: * Process a shell escape by saving signals, ignoring signals, ! 22: * and forking a sh -c ! 23: */ ! 24: ! 25: shell(str) ! 26: char *str; ! 27: { ! 28: int (*sig[2])(), stat[1]; ! 29: register int t; ! 30: char *Shell; ! 31: char cmd[BUFSIZ]; ! 32: ! 33: strcpy(cmd, str); ! 34: if (bangexp(cmd) < 0) ! 35: return(-1); ! 36: if ((Shell = value("SHELL")) == NOSTR) ! 37: Shell = SHELL; ! 38: for (t = 2; t < 4; t++) ! 39: sig[t-2] = sigset(t, SIG_IGN); ! 40: t = vfork(); ! 41: if (t == 0) { ! 42: sigchild(); ! 43: for (t = 2; t < 4; t++) ! 44: if (sig[t-2] != SIG_IGN) ! 45: sigsys(t, SIG_DFL); ! 46: execl(Shell, Shell, "-c", cmd, (char *)0); ! 47: perror(Shell); ! 48: _exit(1); ! 49: } ! 50: while (wait(stat) != t) ! 51: ; ! 52: if (t == -1) ! 53: perror("fork"); ! 54: for (t = 2; t < 4; t++) ! 55: sigset(t, sig[t-2]); ! 56: printf("!\n"); ! 57: return(0); ! 58: } ! 59: ! 60: /* ! 61: * Fork an interactive shell. ! 62: */ ! 63: ! 64: dosh(str) ! 65: char *str; ! 66: { ! 67: int (*sig[2])(), stat[1]; ! 68: register int t; ! 69: char *Shell; ! 70: if ((Shell = value("SHELL")) == NOSTR) ! 71: Shell = SHELL; ! 72: for (t = 2; t < 4; t++) ! 73: sig[t-2] = sigset(t, SIG_IGN); ! 74: t = vfork(); ! 75: if (t == 0) { ! 76: sigchild(); ! 77: for (t = 2; t < 4; t++) ! 78: if (sig[t-2] != SIG_IGN) ! 79: sigsys(t, SIG_DFL); ! 80: execl(Shell, Shell, (char *)0); ! 81: perror(Shell); ! 82: _exit(1); ! 83: } ! 84: while (wait(stat) != t) ! 85: ; ! 86: if (t == -1) ! 87: perror("fork"); ! 88: for (t = 2; t < 4; t++) ! 89: sigsys(t, sig[t-2]); ! 90: putchar('\n'); ! 91: return(0); ! 92: } ! 93: ! 94: /* ! 95: * Expand the shell escape by expanding unescaped !'s into the ! 96: * last issued command where possible. ! 97: */ ! 98: ! 99: char lastbang[128]; ! 100: ! 101: bangexp(str) ! 102: char *str; ! 103: { ! 104: char bangbuf[BUFSIZ]; ! 105: register char *cp, *cp2; ! 106: register int n; ! 107: int changed = 0; ! 108: ! 109: cp = str; ! 110: cp2 = bangbuf; ! 111: n = BUFSIZ; ! 112: while (*cp) { ! 113: if (*cp == '!') { ! 114: if (n < strlen(lastbang)) { ! 115: overf: ! 116: printf("Command buffer overflow\n"); ! 117: return(-1); ! 118: } ! 119: changed++; ! 120: strcpy(cp2, lastbang); ! 121: cp2 += strlen(lastbang); ! 122: n -= strlen(lastbang); ! 123: cp++; ! 124: continue; ! 125: } ! 126: if (*cp == '\\' && cp[1] == '!') { ! 127: if (--n <= 1) ! 128: goto overf; ! 129: *cp2++ = '!'; ! 130: cp += 2; ! 131: changed++; ! 132: } ! 133: if (--n <= 1) ! 134: goto overf; ! 135: *cp2++ = *cp++; ! 136: } ! 137: *cp2 = 0; ! 138: if (changed) { ! 139: printf("!%s\n", bangbuf); ! 140: fflush(stdout); ! 141: } ! 142: strcpy(str, bangbuf); ! 143: strncpy(lastbang, bangbuf, 128); ! 144: lastbang[127] = 0; ! 145: return(0); ! 146: } ! 147: ! 148: /* ! 149: * Print out a nice help message from some file or another. ! 150: */ ! 151: ! 152: help() ! 153: { ! 154: register c; ! 155: register FILE *f; ! 156: ! 157: if ((f = fopen(HELPFILE, "r")) == NULL) { ! 158: perror(HELPFILE); ! 159: return(1); ! 160: } ! 161: while ((c = getc(f)) != EOF) ! 162: putchar(c); ! 163: fclose(f); ! 164: return(0); ! 165: } ! 166: ! 167: /* ! 168: * Change user's working directory. ! 169: */ ! 170: ! 171: schdir(str) ! 172: char *str; ! 173: { ! 174: register char *cp; ! 175: ! 176: for (cp = str; *cp == ' '; cp++) ! 177: ; ! 178: if (*cp == '\0') ! 179: cp = homedir; ! 180: else ! 181: if ((cp = expand(cp)) == NOSTR) ! 182: return(1); ! 183: if (chdir(cp) < 0) { ! 184: perror(cp); ! 185: return(1); ! 186: } ! 187: return(0); ! 188: } ! 189: ! 190: respond(msgvec) ! 191: int *msgvec; ! 192: { ! 193: if (value("Replyall") == NOSTR) ! 194: return (_respond(msgvec)); ! 195: else ! 196: return (_Respond(msgvec)); ! 197: } ! 198: ! 199: /* ! 200: * Reply to a list of messages. Extract each name from the ! 201: * message header and send them off to mail1() ! 202: */ ! 203: ! 204: _respond(msgvec) ! 205: int *msgvec; ! 206: { ! 207: struct message *mp; ! 208: char *cp, *cp2, *cp3, *rcv, *replyto; ! 209: char buf[2 * LINESIZE], **ap; ! 210: struct name *np; ! 211: struct header head; ! 212: ! 213: if (msgvec[1] != 0) { ! 214: printf("Sorry, can't reply to multiple messages at once\n"); ! 215: return(1); ! 216: } ! 217: mp = &message[msgvec[0] - 1]; ! 218: dot = mp; ! 219: rcv = NOSTR; ! 220: cp = skin(nameof(mp, 1)); ! 221: if (cp != NOSTR) ! 222: rcv = cp; ! 223: cp = skin(hfield("from", mp)); ! 224: if (cp != NOSTR) ! 225: rcv = cp; ! 226: replyto = skin(hfield("reply-to", mp)); ! 227: strcpy(buf, ""); ! 228: if (replyto != NOSTR) ! 229: strcpy(buf, replyto); ! 230: else { ! 231: cp = skin(hfield("to", mp)); ! 232: if (cp != NOSTR) ! 233: strcpy(buf, cp); ! 234: } ! 235: np = elide(extract(buf, GTO)); ! 236: /* rcv = rename(rcv); */ ! 237: mapf(np, rcv); ! 238: /* ! 239: * Delete my name from the reply list, ! 240: * and with it, all my alternate names. ! 241: */ ! 242: np = delname(np, myname, icequal); ! 243: if (altnames) ! 244: for (ap = altnames; *ap; ap++) ! 245: np = delname(np, *ap, icequal); ! 246: head.h_seq = 1; ! 247: cp = detract(np, 0); ! 248: if (cp != NOSTR && replyto == NOSTR) { ! 249: strcpy(buf, cp); ! 250: strcat(buf, " "); ! 251: strcat(buf, rcv); ! 252: } ! 253: else { ! 254: if (cp == NOSTR && replyto != NOSTR) ! 255: printf("Empty reply-to field -- replying to author\n"); ! 256: if (cp == NOSTR) ! 257: strcpy(buf, rcv); ! 258: else ! 259: strcpy(buf, cp); ! 260: } ! 261: head.h_to = buf; ! 262: head.h_subject = hfield("subject", mp); ! 263: if (head.h_subject == NOSTR) ! 264: head.h_subject = hfield("subj", mp); ! 265: head.h_subject = reedit(head.h_subject); ! 266: head.h_cc = NOSTR; ! 267: if (replyto == NOSTR) { ! 268: cp = hfield("cc", mp); ! 269: if (cp != NOSTR) { ! 270: np = elide(extract(cp, GCC)); ! 271: mapf(np, rcv); ! 272: np = delname(np, myname, icequal); ! 273: if (altnames != 0) ! 274: for (ap = altnames; *ap; ap++) ! 275: np = delname(np, *ap, icequal); ! 276: head.h_cc = detract(np, 0); ! 277: } ! 278: } ! 279: head.h_bcc = NOSTR; ! 280: mail1(&head); ! 281: return(0); ! 282: } ! 283: ! 284: /* ! 285: * Modify the subject we are replying to to begin with Re: if ! 286: * it does not already. ! 287: */ ! 288: ! 289: char * ! 290: reedit(subj) ! 291: char *subj; ! 292: { ! 293: char sbuf[10]; ! 294: register char *newsubj; ! 295: ! 296: if (subj == NOSTR) ! 297: return(NOSTR); ! 298: strncpy(sbuf, subj, 3); ! 299: sbuf[3] = 0; ! 300: if (icequal(sbuf, "re:")) ! 301: return(subj); ! 302: newsubj = salloc(strlen(subj) + 6); ! 303: sprintf(newsubj, "Re: %s", subj); ! 304: return(newsubj); ! 305: } ! 306: ! 307: /* ! 308: * Preserve the named messages, so that they will be sent ! 309: * back to the system mailbox. ! 310: */ ! 311: ! 312: preserve(msgvec) ! 313: int *msgvec; ! 314: { ! 315: register struct message *mp; ! 316: register int *ip, mesg; ! 317: ! 318: if (edit) { ! 319: printf("Cannot \"preserve\" in edit mode\n"); ! 320: return(1); ! 321: } ! 322: for (ip = msgvec; *ip != NULL; ip++) { ! 323: mesg = *ip; ! 324: mp = &message[mesg-1]; ! 325: mp->m_flag |= MPRESERVE; ! 326: mp->m_flag &= ~MBOX; ! 327: dot = mp; ! 328: } ! 329: return(0); ! 330: } ! 331: ! 332: /* ! 333: * Mark all given messages as unread. ! 334: */ ! 335: unread(msgvec) ! 336: int msgvec[]; ! 337: { ! 338: register int *ip; ! 339: ! 340: for (ip = msgvec; *ip != NULL; ip++) { ! 341: dot = &message[*ip-1]; ! 342: dot->m_flag &= ~(MREAD|MTOUCH); ! 343: dot->m_flag |= MSTATUS; ! 344: } ! 345: return(0); ! 346: } ! 347: ! 348: /* ! 349: * Print the size of each message. ! 350: */ ! 351: ! 352: messize(msgvec) ! 353: int *msgvec; ! 354: { ! 355: register struct message *mp; ! 356: register int *ip, mesg; ! 357: ! 358: for (ip = msgvec; *ip != NULL; ip++) { ! 359: mesg = *ip; ! 360: mp = &message[mesg-1]; ! 361: printf("%d: %d/%ld\n", mesg, mp->m_lines, mp->m_size); ! 362: } ! 363: return(0); ! 364: } ! 365: ! 366: /* ! 367: * Quit quickly. If we are sourcing, just pop the input level ! 368: * by returning an error. ! 369: */ ! 370: ! 371: rexit(e) ! 372: { ! 373: if (sourcing) ! 374: return(1); ! 375: if (Tflag != NOSTR) ! 376: close(creat(Tflag, 0600)); ! 377: exit(e); ! 378: } ! 379: ! 380: /* ! 381: * Set or display a variable value. Syntax is similar to that ! 382: * of csh. ! 383: */ ! 384: ! 385: set(arglist) ! 386: char **arglist; ! 387: { ! 388: register struct var *vp; ! 389: register char *cp, *cp2; ! 390: char varbuf[BUFSIZ], **ap, **p; ! 391: int errs, h, s; ! 392: ! 393: if (argcount(arglist) == 0) { ! 394: for (h = 0, s = 1; h < HSHSIZE; h++) ! 395: for (vp = variables[h]; vp != NOVAR; vp = vp->v_link) ! 396: s++; ! 397: ap = (char **) salloc(s * sizeof *ap); ! 398: for (h = 0, p = ap; h < HSHSIZE; h++) ! 399: for (vp = variables[h]; vp != NOVAR; vp = vp->v_link) ! 400: *p++ = vp->v_name; ! 401: *p = NOSTR; ! 402: sort(ap); ! 403: for (p = ap; *p != NOSTR; p++) ! 404: printf("%s\t%s\n", *p, value(*p)); ! 405: return(0); ! 406: } ! 407: errs = 0; ! 408: for (ap = arglist; *ap != NOSTR; ap++) { ! 409: cp = *ap; ! 410: cp2 = varbuf; ! 411: while (*cp != '=' && *cp != '\0') ! 412: *cp2++ = *cp++; ! 413: *cp2 = '\0'; ! 414: if (*cp == '\0') ! 415: cp = ""; ! 416: else ! 417: cp++; ! 418: if (equal(varbuf, "")) { ! 419: printf("Non-null variable name required\n"); ! 420: errs++; ! 421: continue; ! 422: } ! 423: assign(varbuf, cp); ! 424: } ! 425: return(errs); ! 426: } ! 427: ! 428: /* ! 429: * Unset a bunch of variable values. ! 430: */ ! 431: ! 432: unset(arglist) ! 433: char **arglist; ! 434: { ! 435: register struct var *vp, *vp2; ! 436: register char *cp; ! 437: int errs, h; ! 438: char **ap; ! 439: ! 440: errs = 0; ! 441: for (ap = arglist; *ap != NOSTR; ap++) { ! 442: if ((vp2 = lookup(*ap)) == NOVAR) { ! 443: if (!sourcing) { ! 444: printf("\"%s\": undefined variable\n", *ap); ! 445: errs++; ! 446: } ! 447: continue; ! 448: } ! 449: h = hash(*ap); ! 450: if (vp2 == variables[h]) { ! 451: variables[h] = variables[h]->v_link; ! 452: vfree(vp2->v_name); ! 453: vfree(vp2->v_value); ! 454: cfree(vp2); ! 455: continue; ! 456: } ! 457: for (vp = variables[h]; vp->v_link != vp2; vp = vp->v_link) ! 458: ; ! 459: vp->v_link = vp2->v_link; ! 460: vfree(vp2->v_name); ! 461: vfree(vp2->v_value); ! 462: cfree(vp2); ! 463: } ! 464: return(errs); ! 465: } ! 466: ! 467: /* ! 468: * Put add users to a group. ! 469: */ ! 470: ! 471: group(argv) ! 472: char **argv; ! 473: { ! 474: register struct grouphead *gh; ! 475: register struct group *gp; ! 476: register int h; ! 477: int s; ! 478: char **ap, *gname, **p; ! 479: ! 480: if (argcount(argv) == 0) { ! 481: for (h = 0, s = 1; h < HSHSIZE; h++) ! 482: for (gh = groups[h]; gh != NOGRP; gh = gh->g_link) ! 483: s++; ! 484: ap = (char **) salloc(s * sizeof *ap); ! 485: for (h = 0, p = ap; h < HSHSIZE; h++) ! 486: for (gh = groups[h]; gh != NOGRP; gh = gh->g_link) ! 487: *p++ = gh->g_name; ! 488: *p = NOSTR; ! 489: sort(ap); ! 490: for (p = ap; *p != NOSTR; p++) ! 491: printgroup(*p); ! 492: return(0); ! 493: } ! 494: if (argcount(argv) == 1) { ! 495: printgroup(*argv); ! 496: return(0); ! 497: } ! 498: gname = *argv; ! 499: h = hash(gname); ! 500: if ((gh = findgroup(gname)) == NOGRP) { ! 501: gh = (struct grouphead *) calloc(sizeof *gh, 1); ! 502: gh->g_name = vcopy(gname); ! 503: gh->g_list = NOGE; ! 504: gh->g_link = groups[h]; ! 505: groups[h] = gh; ! 506: } ! 507: ! 508: /* ! 509: * Insert names from the command list into the group. ! 510: * Who cares if there are duplicates? They get tossed ! 511: * later anyway. ! 512: */ ! 513: ! 514: for (ap = argv+1; *ap != NOSTR; ap++) { ! 515: gp = (struct group *) calloc(sizeof *gp, 1); ! 516: gp->ge_name = vcopy(*ap); ! 517: gp->ge_link = gh->g_list; ! 518: gh->g_list = gp; ! 519: } ! 520: return(0); ! 521: } ! 522: ! 523: /* ! 524: * Sort the passed string vecotor into ascending dictionary ! 525: * order. ! 526: */ ! 527: ! 528: sort(list) ! 529: char **list; ! 530: { ! 531: register char **ap; ! 532: int diction(); ! 533: ! 534: for (ap = list; *ap != NOSTR; ap++) ! 535: ; ! 536: if (ap-list < 2) ! 537: return; ! 538: qsort(list, ap-list, sizeof *list, diction); ! 539: } ! 540: ! 541: /* ! 542: * Do a dictionary order comparison of the arguments from ! 543: * qsort. ! 544: */ ! 545: ! 546: diction(a, b) ! 547: register char **a, **b; ! 548: { ! 549: return(strcmp(*a, *b)); ! 550: } ! 551: ! 552: /* ! 553: * The do nothing command for comments. ! 554: */ ! 555: ! 556: null(e) ! 557: { ! 558: return(0); ! 559: } ! 560: ! 561: /* ! 562: * Print out the current edit file, if we are editing. ! 563: * Otherwise, print the name of the person who's mail ! 564: * we are reading. ! 565: */ ! 566: ! 567: file(argv) ! 568: char **argv; ! 569: { ! 570: register char *cp; ! 571: char fname[BUFSIZ]; ! 572: int edit; ! 573: ! 574: if (argv[0] == NOSTR) { ! 575: newfileinfo(); ! 576: return(0); ! 577: } ! 578: ! 579: /* ! 580: * Acker's! Must switch to the new file. ! 581: * We use a funny interpretation -- ! 582: * # -- gets the previous file ! 583: * % -- gets the invoker's post office box ! 584: * %user -- gets someone else's post office box ! 585: * & -- gets invoker's mbox file ! 586: * string -- reads the given file ! 587: */ ! 588: ! 589: cp = getfilename(argv[0], &edit); ! 590: if (cp == NOSTR) ! 591: return(-1); ! 592: if (setfile(cp, edit)) { ! 593: perror(cp); ! 594: return(-1); ! 595: } ! 596: announce(0); ! 597: } ! 598: ! 599: /* ! 600: * Evaluate the string given as a new mailbox name. ! 601: * Ultimately, we want this to support a number of meta characters. ! 602: * Possibly: ! 603: * % -- for my system mail box ! 604: * %user -- for user's system mail box ! 605: * # -- for previous file ! 606: * & -- get's invoker's mbox file ! 607: * file name -- for any other file ! 608: */ ! 609: ! 610: char prevfile[PATHSIZE]; ! 611: ! 612: char * ! 613: getfilename(name, aedit) ! 614: char *name; ! 615: int *aedit; ! 616: { ! 617: register char *cp; ! 618: char savename[BUFSIZ]; ! 619: char oldmailname[BUFSIZ]; ! 620: ! 621: /* ! 622: * Assume we will be in "edit file" mode, until ! 623: * proven wrong. ! 624: */ ! 625: *aedit = 1; ! 626: switch (*name) { ! 627: case '%': ! 628: *aedit = 0; ! 629: strcpy(prevfile, mailname); ! 630: if (name[1] != 0) { ! 631: strcpy(savename, myname); ! 632: strcpy(oldmailname, mailname); ! 633: strncpy(myname, name+1, PATHSIZE-1); ! 634: myname[PATHSIZE-1] = 0; ! 635: findmail(); ! 636: cp = savestr(mailname); ! 637: strcpy(myname, savename); ! 638: strcpy(mailname, oldmailname); ! 639: return(cp); ! 640: } ! 641: strcpy(oldmailname, mailname); ! 642: findmail(); ! 643: cp = savestr(mailname); ! 644: strcpy(mailname, oldmailname); ! 645: return(cp); ! 646: ! 647: case '#': ! 648: if (name[1] != 0) ! 649: goto regular; ! 650: if (prevfile[0] == 0) { ! 651: printf("No previous file\n"); ! 652: return(NOSTR); ! 653: } ! 654: cp = savestr(prevfile); ! 655: strcpy(prevfile, mailname); ! 656: return(cp); ! 657: ! 658: case '&': ! 659: strcpy(prevfile, mailname); ! 660: if (name[1] == 0) ! 661: return(mbox); ! 662: /* Fall into . . . */ ! 663: ! 664: default: ! 665: regular: ! 666: strcpy(prevfile, mailname); ! 667: cp = expand(name); ! 668: return(cp); ! 669: } ! 670: } ! 671: ! 672: /* ! 673: * Expand file names like echo ! 674: */ ! 675: ! 676: echo(argv) ! 677: char **argv; ! 678: { ! 679: register char **ap; ! 680: register char *cp; ! 681: ! 682: for (ap = argv; *ap != NOSTR; ap++) { ! 683: cp = *ap; ! 684: if ((cp = expand(cp)) != NOSTR) ! 685: printf("%s ", cp); ! 686: } ! 687: return(0); ! 688: } ! 689: ! 690: Respond(msgvec) ! 691: int *msgvec; ! 692: { ! 693: if (value("Replyall") == NOSTR) ! 694: return (_Respond(msgvec)); ! 695: else ! 696: return (_respond(msgvec)); ! 697: } ! 698: ! 699: /* ! 700: * Reply to a series of messages by simply mailing to the senders ! 701: * and not messing around with the To: and Cc: lists as in normal ! 702: * reply. ! 703: */ ! 704: ! 705: _Respond(msgvec) ! 706: int msgvec[]; ! 707: { ! 708: struct header head; ! 709: struct message *mp; ! 710: register int i, s, *ap; ! 711: register char *cp, *cp2, *subject; ! 712: ! 713: for (s = 0, ap = msgvec; *ap != 0; ap++) { ! 714: mp = &message[*ap - 1]; ! 715: dot = mp; ! 716: if ((cp = skin(hfield("from", mp))) != NOSTR) ! 717: s+= strlen(cp) + 1; ! 718: else ! 719: s += strlen(skin(nameof(mp, 2))) + 1; ! 720: } ! 721: if (s == 0) ! 722: return(0); ! 723: cp = salloc(s + 2); ! 724: head.h_to = cp; ! 725: for (ap = msgvec; *ap != 0; ap++) { ! 726: mp = &message[*ap - 1]; ! 727: if ((cp2 = skin(hfield("from", mp))) == NOSTR) ! 728: cp2 = skin(nameof(mp, 2)); ! 729: cp = copy(cp2, cp); ! 730: *cp++ = ' '; ! 731: } ! 732: *--cp = 0; ! 733: mp = &message[msgvec[0] - 1]; ! 734: subject = hfield("subject", mp); ! 735: head.h_seq = 0; ! 736: if (subject == NOSTR) ! 737: subject = hfield("subj", mp); ! 738: head.h_subject = reedit(subject); ! 739: if (subject != NOSTR) ! 740: head.h_seq++; ! 741: head.h_cc = NOSTR; ! 742: head.h_bcc = NOSTR; ! 743: mail1(&head); ! 744: return(0); ! 745: } ! 746: ! 747: /* ! 748: * Conditional commands. These allow one to parameterize one's ! 749: * .mailrc and do some things if sending, others if receiving. ! 750: */ ! 751: ! 752: ifcmd(argv) ! 753: char **argv; ! 754: { ! 755: register char *cp; ! 756: ! 757: if (cond != CANY) { ! 758: printf("Illegal nested \"if\"\n"); ! 759: return(1); ! 760: } ! 761: cond = CANY; ! 762: cp = argv[0]; ! 763: switch (*cp) { ! 764: case 'r': case 'R': ! 765: cond = CRCV; ! 766: break; ! 767: ! 768: case 's': case 'S': ! 769: cond = CSEND; ! 770: break; ! 771: ! 772: default: ! 773: printf("Unrecognized if-keyword: \"%s\"\n", cp); ! 774: return(1); ! 775: } ! 776: return(0); ! 777: } ! 778: ! 779: /* ! 780: * Implement 'else'. This is pretty simple -- we just ! 781: * flip over the conditional flag. ! 782: */ ! 783: ! 784: elsecmd() ! 785: { ! 786: ! 787: switch (cond) { ! 788: case CANY: ! 789: printf("\"Else\" without matching \"if\"\n"); ! 790: return(1); ! 791: ! 792: case CSEND: ! 793: cond = CRCV; ! 794: break; ! 795: ! 796: case CRCV: ! 797: cond = CSEND; ! 798: break; ! 799: ! 800: default: ! 801: printf("Mail's idea of conditions is screwed up\n"); ! 802: cond = CANY; ! 803: break; ! 804: } ! 805: return(0); ! 806: } ! 807: ! 808: /* ! 809: * End of if statement. Just set cond back to anything. ! 810: */ ! 811: ! 812: endifcmd() ! 813: { ! 814: ! 815: if (cond == CANY) { ! 816: printf("\"Endif\" without matching \"if\"\n"); ! 817: return(1); ! 818: } ! 819: cond = CANY; ! 820: return(0); ! 821: } ! 822: ! 823: /* ! 824: * Set the list of alternate names. ! 825: */ ! 826: alternates(namelist) ! 827: char **namelist; ! 828: { ! 829: register int c; ! 830: register char **ap, **ap2, *cp; ! 831: ! 832: c = argcount(namelist) + 1; ! 833: if (c == 1) { ! 834: if (altnames == 0) ! 835: return(0); ! 836: for (ap = altnames; *ap; ap++) ! 837: printf("%s ", *ap); ! 838: printf("\n"); ! 839: return(0); ! 840: } ! 841: if (altnames != 0) ! 842: cfree((char *) altnames); ! 843: altnames = (char **) calloc(c, sizeof (char *)); ! 844: for (ap = namelist, ap2 = altnames; *ap; ap++, ap2++) { ! 845: cp = (char *) calloc(strlen(*ap) + 1, sizeof (char)); ! 846: strcpy(cp, *ap); ! 847: *ap2 = cp; ! 848: } ! 849: *ap2 = 0; ! 850: return(0); ! 851: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.