home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 1 / 1461 < prev    next >
Encoding:
Internet Message Format  |  1990-12-28  |  61.7 KB
  1. From: sob@lib.tmc.edu (Stan Barber)
  2. Newsgroups: alt.sources
  3. Subject: rrn/rn combo kite part 4 of 9
  4. Message-ID: <430@lib.tmc.edu>
  5. Date: 14 Jun 90 03:27:35 GMT
  6.  
  7. #! /bin/sh
  8.  
  9. # Make a new directory for the rn sources, cd to it, and run kits 1 thru 9 
  10. # through sh.  When all 9 kits have been run, read README.
  11.  
  12. echo "This is rn kit 4 (of 9).  If kit 4 is complete, the line"
  13. echo '"'"End of kit 4 (of 9)"'" will echo at the end.'
  14. echo ""
  15. export PATH || (echo "You didn't use sh, you clunch." ; kill $$)
  16. echo Extracting intrp.c
  17. cat >intrp.c <<'!STUFFY!FUNK!'
  18. /* $Header: intrp.c,v 4.3.2.4 90/04/23 00:31:20 sob Exp $
  19.  *
  20.  * $Log:    intrp.c,v $
  21.  * Revision 4.3.2.4  90/04/23  00:31:20  sob
  22.  * Removed unneeded atoi call.
  23.  * 
  24.  * Revision 4.3.2.3  90/03/22  23:04:35  sob
  25.  * Fixes provided by Wayne Davison <drivax!davison>
  26.  * 
  27.  * Revision 4.3.2.2  90/03/17  17:03:12  sob
  28.  * Fixed determination of the news superuser's id. Fix provided by Chip
  29.  * Rosenthal <chip@chinacat.lonestar.org>.
  30.  * 
  31.  * Revision 4.3.2.1  89/12/17  02:54:55  sob
  32.  * Removed redundant include directive.
  33.  * 
  34.  * Revision 4.3.1.5  85/05/23  17:21:24  lwall
  35.  * Now allows 'r' and 'f' on null articles.
  36.  * 
  37.  * Revision 4.3.1.4  85/05/21  13:35:21  lwall
  38.  * Sped up "rn -c" by not doing unnecessary initialization.
  39.  * 
  40.  * Revision 4.3.1.3  85/05/17  10:37:11  lwall
  41.  * Fixed & substitution to capitalize last name too.
  42.  * 
  43.  * Revision 4.3.1.2  85/05/15  14:39:45  lwall
  44.  * Spelled gecos right.
  45.  * 
  46.  * Revision 4.3.1.1  85/05/10  11:33:51  lwall
  47.  * Branch for patches.
  48.  * 
  49.  * Revision 4.3  85/05/01  11:40:54  lwall
  50.  * Baseline for release with 4.3bsd.
  51.  * 
  52.  */
  53.  
  54. #include "EXTERN.h"
  55. #include "common.h"
  56. #include "util.h"
  57. #include "search.h"
  58. #include "head.h"
  59. #include "rn.h"
  60. #include "artsrch.h"
  61. #include "ng.h"
  62. #include "respond.h"
  63. #include "rcstuff.h"
  64. #include "bits.h"
  65. #include "artio.h"
  66. #include "term.h"
  67. #include "final.h"
  68. #include "INTERN.h"
  69. #include "intrp.h"
  70.  
  71. char orgname[] = ORGNAME;
  72.  
  73. /* name of this site */
  74. #ifdef GETHOSTNAME
  75.     char *hostname;
  76. #   undef SITENAME
  77. #   define SITENAME hostname
  78. #else !GETHOSTNAME
  79. #   ifdef DOUNAME
  80. #    include <sys/utsname.h>
  81.     struct utsname uts;
  82. #    undef SITENAME
  83. #    define SITENAME uts.nodename
  84. #   else !DOUNAME
  85. #    ifdef PHOSTNAME
  86.         char *hostname;
  87. #        undef SITENAME
  88. #        define SITENAME hostname
  89. #    else !PHOSTNAME
  90. #        ifdef WHOAMI
  91. #        undef SITENAME
  92. #        define SITENAME sysname
  93. #        endif WHOAMI
  94. #    endif PHOSTNAME
  95. #   endif DOUNAME
  96. #endif GETHOSTNAME
  97.  
  98. #ifdef TILDENAME
  99. static char *tildename = Nullch;
  100. static char *tildedir = Nullch;
  101. #endif
  102.  
  103. char *realname INIT(Nullch);    /* real name of sender from /etc/passwd */
  104.  
  105. char *dointerp();
  106. char *getrealname();
  107. #ifdef CONDSUB
  108. char *skipinterp();
  109. #endif
  110.  
  111. static void abort_interp();
  112.  
  113. void
  114. intrp_init(tcbuf)
  115. char *tcbuf;
  116. {
  117.     char *getlogin();
  118.  
  119.     spool = savestr(filexp(SPOOL));    /* usually /usr/spool/news */
  120.     
  121.     /* get environmental stuff */
  122.  
  123.     /* get home directory */
  124.  
  125.     homedir = getenv("HOME");
  126.     if (homedir == Nullch)
  127.     homedir = getenv("LOGDIR");
  128.  
  129.     dotdir = getval("DOTDIR",homedir);
  130.  
  131.     /* get login name */
  132.  
  133.     logname = getenv("USER");
  134.     if (logname == Nullch)
  135.     logname = getenv("LOGNAME");
  136. #ifdef GETLOGIN
  137.     if (logname == Nullch)
  138.     logname = savestr(getlogin());
  139. #endif
  140.     
  141.     if (checkflag)            /* that getwd below takes ~1/3 sec. */
  142.     return;                /* and we do not need it for -c */
  143.     getwd(tcbuf);            /* find working directory name */
  144.     origdir = savestr(tcbuf);        /* and remember it */
  145.  
  146.     /* get the real name of the person (%N) */
  147.     /* Must be done after logname is read in because BERKNAMES uses that */
  148.  
  149.     strcpy(tcbuf,getrealname(getuid()));
  150.     realname = savestr(tcbuf);
  151.  
  152.     /* name of header file (%h) */
  153.  
  154.     headname = savestr(filexp(HEADNAME));
  155.  
  156.     /* name of this site (%H) */
  157.  
  158. #ifdef GETHOSTNAME
  159.     gethostname(buf,sizeof buf);
  160.     hostname = savestr(buf);
  161. #else
  162. #ifdef DOUNAME
  163.     /* get sysname */
  164.     uname(&uts);
  165. #else
  166. #ifdef PHOSTNAME
  167.     {
  168.     FILE *popen();
  169.     FILE *pipefp = popen(PHOSTNAME,"r");
  170.     
  171.     if (pipefp == Nullfp) {
  172.         printf("Can't find hostname\n");
  173.         sig_catcher(0);
  174.     }
  175.     fgets(buf,sizeof buf,pipefp);
  176.     buf[strlen(buf)-1] = '\0';    /* wipe out newline */
  177.     hostname = savestr(buf);
  178.     pclose(pipefp);
  179.     }
  180. #endif
  181. #endif
  182. #endif
  183.     sitename = savestr(SITENAME);
  184. }
  185.  
  186. /* expand filename via %, ~, and $ interpretation */
  187. /* returns pointer to static area */
  188. /* Note that there is a 1-deep cache of ~name interpretation */
  189.  
  190. char *
  191. filexp(s)
  192. register char *s;
  193. {
  194.     static char filename[CBUFLEN];
  195.     char scrbuf[CBUFLEN];
  196.     register char *d;
  197.  
  198. #ifdef DEBUGGING
  199.     if (debug & DEB_FILEXP)
  200.     printf("< %s\n",s) FLUSH;
  201. #endif
  202.     interp(filename, (sizeof filename), s);            /* interpret any % escapes */
  203. #ifdef DEBUGGING
  204.     if (debug & DEB_FILEXP)
  205.     printf("%% %s\n",filename) FLUSH;
  206. #endif
  207.     s = filename;
  208.     if (*s == '~') {    /* does destination start with ~? */
  209.     if (!*(++s) || *s == '/') {
  210.         sprintf(scrbuf,"%s%s",homedir,s);
  211.                 /* swap $HOME for it */
  212. #ifdef DEBUGGING
  213.     if (debug & DEB_FILEXP)
  214.     printf("~ %s\n",scrbuf) FLUSH;
  215. #endif
  216.         strcpy(filename,scrbuf);
  217.     }
  218.     else {
  219. #ifdef TILDENAME
  220.         for (d=scrbuf; isalnum(*s); s++,d++)
  221.         *d = *s;
  222.         *d = '\0';
  223.         if (tildedir && strEQ(tildename,scrbuf)) {
  224.         strcpy(scrbuf,tildedir);
  225.         strcat(scrbuf, s);
  226.         strcpy(filename, scrbuf);
  227. #ifdef DEBUGGING
  228.         if (debug & DEB_FILEXP)
  229.             printf("r %s %s\n",tildename,tildedir) FLUSH;
  230. #endif
  231.         }
  232.         else {
  233.         if (tildename) {
  234.             free(tildename);
  235.             free(tildedir);
  236.         }
  237.         tildedir = Nullch;
  238.         tildename = savestr(scrbuf);
  239. #ifdef GETPWENT        /* getpwnam() is not the paragon of efficiency */
  240.         {
  241.             struct passwd *getpwnam();
  242.             struct passwd *pwd = getpwnam(tildename);
  243.  
  244.             sprintf(scrbuf,"%s%s",pwd->pw_dir,s);
  245.             tildedir = savestr(pwd->pw_dir);
  246. #ifdef NEWSADMIN
  247.             if ((pwd != NULL) && strEQ(newsadmin,tildename))
  248.             newsuid = pwd->pw_uid;
  249. #endif
  250.             strcpy(filename,scrbuf);
  251. #ifdef GETPWENT
  252.             endpwent();
  253. #endif
  254.         }
  255. #else            /* this will run faster, and is less D space */
  256.         {    /* just be sure LOGDIRFIELD is correct */
  257.             FILE *pfp = fopen("/etc/passwd","r");
  258.             char tmpbuf[512];
  259.             int i;
  260.             
  261.             if (pfp == Nullfp) {
  262.             printf(cantopen,"passwd") FLUSH;
  263.             sig_catcher(0);
  264.             }
  265.             while (fgets(tmpbuf,512,pfp) != Nullch) {
  266.             d = cpytill(scrbuf,tmpbuf,':');
  267. #ifdef DEBUGGING
  268.             if (debug & DEB_FILEXP)
  269.                 printf("p %s\n",tmpbuf) FLUSH;
  270. #endif
  271.             if (strEQ(scrbuf,tildename)) {
  272. #ifdef NEWSADMIN
  273.                 if (strEQ(newsadmin,tildename))
  274.                 newsuid = atoi(index(d+1,':')+1);
  275. #endif
  276.                 for (i=LOGDIRFIELD-2; i; i--) {
  277.                 if (d)
  278.                     d = index(d+1,':');
  279.                 }
  280.                 if (d) {
  281.                 cpytill(scrbuf,d+1,':');
  282.                 tildedir = savestr(scrbuf);
  283.                 strcat(scrbuf,s);
  284.                 strcpy(filename,scrbuf);
  285.                 }
  286.                 break;
  287.             }
  288.             }
  289.             fclose(pfp);
  290.         }
  291. #endif
  292.         }
  293. #else !TILDENAME
  294. #ifdef VERBOSE
  295.         IF(verbose)
  296.         fputs("~loginname not implemented.\n",stdout) FLUSH;
  297.         ELSE
  298. #endif
  299. #ifdef TERSE
  300.         fputs("~login not impl.\n",stdout) FLUSH;
  301. #endif
  302. #endif
  303.     }
  304.     }
  305.     else if (*s == '$') {    /* starts with some env variable? */
  306.     d = scrbuf;
  307.     *d++ = '%';
  308.     if (s[1] == '{')
  309.         strcpy(d,s+2);
  310.     else {
  311.         *d++ = '{';
  312.         for (s++; isalnum(*s); s++) *d++ = *s;
  313.                 /* skip over token */
  314.         *d++ = '}';
  315.         strcpy(d,s);
  316.     }
  317. #ifdef DEBUGGING
  318.     if (debug & DEB_FILEXP)
  319.         printf("$ %s\n",scrbuf) FLUSH;
  320. #endif
  321.     interp(filename, (sizeof filename), scrbuf);
  322.                     /* this might do some extra '%'s but */
  323.                     /* that is how the Mercedes Benz */
  324.     }
  325. #ifdef DEBUGGING
  326.     if (debug & DEB_FILEXP)
  327.     printf("> %s\n",filename) FLUSH;
  328. #endif
  329.     return filename;
  330. }
  331.  
  332. #ifdef CONDSUB
  333. /* skip interpolations */
  334.  
  335. char *
  336. skipinterp(pattern,stoppers)
  337. register char *pattern;
  338. char *stoppers;
  339. {
  340.  
  341.     while (*pattern && (!stoppers || !index(stoppers,*pattern))) {
  342. #ifdef DEBUGGING
  343.     if (debug & 8)
  344.         printf("skipinterp till %s at %s\n",stoppers?stoppers:"",pattern);
  345. #endif
  346.     if (*pattern == '%' && pattern[1]) {
  347.         switch (*++pattern) {
  348.         case '{':
  349.         for (pattern++; *pattern && *pattern != '}'; pattern++)
  350.             if (*pattern == '\\')
  351.             pattern++;
  352.         break;
  353.         case '[':
  354.         for (pattern++; *pattern && *pattern != ']'; pattern++)
  355.             if (*pattern == '\\')
  356.             pattern++;
  357.         break;
  358. #ifdef CONDSUB
  359.         case '(': {
  360.         pattern = skipinterp(pattern+1,"!=");
  361.         if (!*pattern)
  362.             goto getout;
  363.         for (pattern++; *pattern && *pattern != '?'; pattern++)
  364.             if (*pattern == '\\')
  365.             pattern++;
  366.         if (!*pattern)
  367.             goto getout;
  368.         pattern = skipinterp(pattern+1,":)");
  369.         if (*pattern == ':')
  370.             pattern = skipinterp(pattern+1,")");
  371.         break;
  372.         }
  373. #endif
  374. #ifdef BACKTICK
  375.         case '`': {
  376.         pattern = skipinterp(pattern+1,"`");
  377.         break;
  378.         }
  379. #endif
  380. #ifdef PROMPTTTY
  381.         case '"':
  382.         pattern = skipinterp(pattern+1,"\"");
  383.         break;
  384. #endif
  385.         default:
  386.         break;
  387.         }
  388.         pattern++;
  389.     }
  390.     else {
  391.         if (*pattern == '^' && pattern[1])
  392.         pattern += 2;
  393.         else if (*pattern == '\\' && pattern[1])
  394.         pattern += 2;
  395.         else
  396.         pattern++;
  397.     }
  398.     }
  399. getout:
  400.     return pattern;            /* where we left off */
  401. }
  402. #endif
  403.  
  404. /* interpret interpolations */
  405.  
  406. char *
  407. dointerp(dest,destsize,pattern,stoppers)
  408. register char *dest;
  409. register int destsize;
  410. register char *pattern;
  411. char *stoppers;
  412. {
  413.     char *subj_buf = Nullch;
  414.     char *ngs_buf = Nullch;
  415.     char *refs_buf = Nullch;
  416.     char *artid_buf = Nullch;
  417.     char *reply_buf = Nullch;
  418.     char *from_buf = Nullch;
  419.     char *path_buf = Nullch;
  420.     char *follow_buf = Nullch;
  421.     char *dist_buf = Nullch;
  422.     char *line_buf = Nullch;
  423.     register char *s, *h;
  424.     register int i;
  425.     char scrbuf[512];
  426.     bool upper = FALSE;
  427.     bool lastcomp = FALSE;
  428.     int metabit = 0;
  429.  
  430.     while (*pattern && (!stoppers || !index(stoppers,*pattern))) {
  431. #ifdef DEBUGGING
  432.     if (debug & 8)
  433.         printf("dointerp till %s at %s\n",stoppers?stoppers:"",pattern);
  434. #endif
  435.     if (*pattern == '%' && pattern[1]) {
  436.         upper = FALSE;
  437.         lastcomp = FALSE;
  438.         for (s=Nullch; !s; ) {
  439.         switch (*++pattern) {
  440.         case '^':
  441.             upper = TRUE;
  442.             break;
  443.         case '_':
  444.             lastcomp = TRUE;
  445.             break;
  446.         case '/':
  447. #ifdef ARTSRCH
  448.             s = scrbuf;
  449.             if (!index("/?g",pattern[-2]))
  450.             *s++ = '/';
  451.             strcpy(s,lastpat);
  452.             s += strlen(s);
  453.             if (pattern[-2] != 'g') {
  454.             if (index("/?",pattern[-2]))
  455.                 *s++ = pattern[-2];
  456.             else
  457.                 *s++ = '/';
  458.             if (art_howmuch == 1)
  459.                 *s++ = 'h';
  460.             else if (art_howmuch == 2)
  461.                 *s++ = 'a';
  462.             if (art_doread)
  463.                 *s++ = 'r';
  464.             }
  465.             *s = '\0';
  466.             s = scrbuf;
  467. #else
  468.             s = nullstr;
  469. #endif
  470.             break;
  471.         case '{':
  472.             pattern = cpytill(scrbuf,pattern+1,'}');
  473.             if (s = index(scrbuf,'-'))
  474.             *s++ = '\0';
  475.             else
  476.             s = nullstr;
  477.             s = getval(scrbuf,s);
  478.             break;
  479.         case '[':
  480.             pattern = cpytill(scrbuf,pattern+1,']');
  481.             i = set_line_type(scrbuf,scrbuf+strlen(scrbuf));
  482.             if (line_buf)
  483.             free(line_buf);
  484.             s = line_buf = fetchlines(art,i);
  485.             break;
  486. #ifdef CONDSUB
  487.         case '(': {
  488.             COMPEX *oldbra_compex = bra_compex;
  489.             COMPEX cond_compex;
  490.             char rch;
  491.             bool matched;
  492.             
  493.             init_compex(&cond_compex);
  494.             pattern = dointerp(dest,destsize,pattern+1,"!=");
  495.             rch = *pattern;
  496.             if (rch == '!')
  497.             pattern++;
  498.             if (*pattern != '=')
  499.             goto getout;
  500.             pattern = cpytill(scrbuf,pattern+1,'?');
  501.             if (!*pattern)
  502.             goto getout;
  503.             if (s = compile(&cond_compex,scrbuf,TRUE,TRUE)) {
  504.             printf("%s: %s\n",scrbuf,s) FLUSH;
  505.             pattern += strlen(pattern);
  506.             goto getout;
  507.             }
  508.             matched = (execute(&cond_compex,dest) != Nullch);
  509.             if (cond_compex.nbra)    /* were there brackets? */
  510.             bra_compex = &cond_compex;
  511.             if (matched==(rch == '=')) {
  512.             pattern = dointerp(dest,destsize,pattern+1,":)");
  513.             if (*pattern == ':')
  514.                 pattern = skipinterp(pattern+1,")");
  515.             }
  516.             else {
  517.             pattern = skipinterp(pattern+1,":)");
  518.             if (*pattern == ':')
  519.                 pattern++;
  520.             pattern = dointerp(dest,destsize,pattern,")");
  521.             }
  522.             s = dest;
  523.             bra_compex = oldbra_compex;
  524.             free_compex(&cond_compex);
  525.             break;
  526.         }
  527. #endif
  528. #ifdef BACKTICK
  529.         case '`': {
  530.             FILE *pipefp, *popen();
  531.  
  532.             pattern = dointerp(scrbuf,(sizeof scrbuf),pattern+1,"`");
  533.             pipefp = popen(scrbuf,"r");
  534.             if (pipefp != Nullfp) {
  535.             int len;
  536.  
  537.             len = fread(scrbuf,sizeof(char),(sizeof scrbuf)-1,
  538.                 pipefp);
  539.             scrbuf[len] = '\0';
  540.             pclose(pipefp);
  541.             }
  542.             else {
  543.             printf("\nCan't run %s\n",scrbuf);
  544.             *scrbuf = '\0';
  545.             }
  546.             for (s=scrbuf; *s; s++) {
  547.             if (*s == '\n') {
  548.                 if (s[1])
  549.                 *s = ' ';
  550.                 else
  551.                 *s = '\0';
  552.             }
  553.             }
  554.             s = scrbuf;
  555.             break;
  556.         }
  557. #endif
  558. #ifdef PROMPTTTY
  559.         case '"':
  560.             pattern = dointerp(scrbuf,(sizeof scrbuf),pattern+1,"\"");
  561.             fputs(scrbuf,stdout) FLUSH;
  562.             resetty();
  563.             gets(scrbuf);
  564.             noecho();
  565.             crmode();
  566.             s = scrbuf;
  567.             break;
  568. #endif
  569.         case '~':
  570.             s = homedir;
  571.             break;
  572.         case '.':
  573.             s = dotdir;
  574.             break;
  575.         case '$':
  576.             s = scrbuf;
  577.             sprintf(s,"%d",getpid());
  578.             break;
  579.         case '0': case '1': case '2': case '3': case '4':
  580.         case '5': case '6': case '7': case '8': case '9':
  581. #ifdef CONDSUB
  582.             s = getbracket(bra_compex,*pattern - '0');
  583. #else
  584.             s = nullstr;
  585. #endif
  586.             break;
  587.         case 'a':
  588.             s = scrbuf;
  589.             sprintf(s,"%ld",(long)art);
  590.             break;
  591.         case 'A':
  592. #ifdef LINKART
  593.             s = linkartname;    /* so Eunice people get right file */
  594. #else
  595.             s = scrbuf;
  596.             sprintf(s,"%s/%s/%ld",spool,ngdir,(long)art);
  597. #endif
  598.             break;
  599.         case 'b':
  600.             s = savedest;
  601.             break;
  602.         case 'B':
  603.             s = scrbuf;
  604.             sprintf(s,"%ld",(long)savefrom);
  605.             break;
  606.         case 'c':
  607.             s = ngdir;
  608.             break;
  609.         case 'C':
  610.             s = ngname;
  611.             break;
  612.         case 'd':
  613.             s = scrbuf;
  614.             sprintf(s,"%s/%s",spool,ngdir);
  615.             break;
  616.         case 'D':
  617.             s = dist_buf = fetchlines(art,DIST_LINE);
  618.             break;
  619.         case 'f':            /* from line */
  620. #ifdef ASYNC_PARSE
  621.             parse_maybe(art);
  622. #endif
  623.             if (htype[REPLY_LINE].ht_minpos >= 0) {
  624.                         /* was there a reply line? */
  625.             if (!(s=reply_buf))
  626.                 s = reply_buf = fetchlines(art,REPLY_LINE);
  627.             }
  628.             else if (!(s = from_buf))
  629.             s = from_buf = fetchlines(art,FROM_LINE);
  630.             break;
  631.         case 'F':
  632. #ifdef ASYNC_PARSE
  633.             parse_maybe(art);
  634. #endif
  635.             if (htype[FOLLOW_LINE].ht_minpos >= 0)
  636.                     /* is there a Followup-To line? */
  637.             s = follow_buf = fetchlines(art,FOLLOW_LINE);
  638.             else {
  639.             int off;
  640.         
  641.             s = ngs_buf = fetchlines(art,NGS_LINE);
  642.             if (h = instr(s,"net.general")) {
  643.                 off = h-s;
  644.                 strncpy(scrbuf,s,off+4);
  645.                 strcpy(scrbuf+off+4,"followup");
  646.                 safecpy(scrbuf+off+12,h+11,sizeof(scrbuf));
  647.                 s = scrbuf;
  648.             }
  649.             }
  650.             break;
  651.         case 'h':            /* header file name */
  652.             s = headname;
  653.             break;
  654.         case 'H':            /* host name */
  655.             s = sitename;
  656.             break;
  657.         case 'i':
  658.             if (!(s=artid_buf))
  659.             s = artid_buf = fetchlines(art,MESSID_LINE);
  660.             if (*s && *s != '<') {
  661.             sprintf(scrbuf,"<%s>",artid_buf);
  662.             s = scrbuf;
  663.             }
  664.             break;
  665.         case 'I':            /* ref article indicator */
  666.             s = scrbuf;
  667.             sprintf(scrbuf,"'%s'",indstr);
  668.             break;
  669.         case 'l':            /* rn library */
  670. #ifdef NEWSADMIN
  671.             s = newsadmin;
  672. #else
  673.             s = "???";
  674. #endif
  675.             break;
  676.         case 'L':            /* login id */
  677.             s = logname;
  678.             break;
  679.         case 'm':        /* current mode */
  680.             s = scrbuf;
  681.             *s = mode;
  682.             s[1] = '\0';
  683.             break;
  684.         case 'M':
  685. #ifdef DELAYMARK
  686.             sprintf(scrbuf,"%ld",(long)dmcount);
  687.             s = scrbuf;
  688. #else
  689.             s = nullstr;
  690. #endif
  691.             break;
  692.         case 'n':            /* newsgroups */
  693.             s = ngs_buf = fetchlines(art,NGS_LINE);
  694.             break;
  695.         case 'N':            /* full name */
  696.             s = getval("NAME",realname);
  697.             break;
  698.         case 'o':            /* organization */
  699.             s = getval("ORGANIZATION",orgname);
  700. #ifdef ORGFILE
  701.             if (*s == '/') {
  702.             FILE *ofp = fopen(s,"r");
  703.  
  704.             if (ofp) {
  705.                 fgets(scrbuf,sizeof scrbuf,ofp);
  706.                 fclose(ofp);
  707.                 s = scrbuf;
  708.                 s[strlen(s)-1] = '\0';
  709.             }
  710.             }
  711. #endif
  712.             break;
  713.         case 'O':
  714.             s = origdir;
  715.             break;
  716.         case 'p':
  717.             s = cwd;
  718.             break;
  719.         case 'P':
  720.             s = spool;
  721.             break;
  722.         case 'r':
  723. #ifdef ASYNC_PARSE
  724.             parse_maybe(art);
  725. #endif
  726.             if (htype[REFS_LINE].ht_minpos >= 0) {
  727.             refs_buf = fetchlines(art,REFS_LINE);
  728.             refscpy(scrbuf,(sizeof scrbuf),refs_buf);
  729.             }
  730.             else
  731.             *scrbuf = '\0';
  732.             s = rindex(scrbuf,'<');
  733.             break;
  734.         case 'R':
  735. #ifdef ASYNC_PARSE
  736.             parse_maybe(art);
  737. #endif
  738.             if (htype[REFS_LINE].ht_minpos >= 0) {
  739.             refs_buf = fetchlines(art,REFS_LINE);
  740.             refscpy(scrbuf,(sizeof scrbuf),refs_buf);
  741.             /* no more than 3 prior references allowed,
  742.             ** including the one concatenated below */
  743.             if ((s = rindex(scrbuf,'<')) > scrbuf) {
  744.                 *s = '\0';
  745.                 h = rindex(scrbuf,'<');
  746.                 *s = '<';
  747.                 if (h > scrbuf)
  748.                 strcpy(scrbuf,h);
  749.             }
  750.             }
  751.             else
  752.             *scrbuf = '\0';
  753.             if (!artid_buf)
  754.             artid_buf = fetchlines(art,MESSID_LINE);
  755.             if (artid_buf[0] == '<')
  756.             safecat(scrbuf,artid_buf,sizeof(scrbuf));
  757.             else if (artid_buf[0]) {
  758.             char tmpbuf[64];
  759.     
  760.             sprintf(tmpbuf,"<%s>",artid_buf);
  761.             safecat(scrbuf,tmpbuf,sizeof(scrbuf));
  762.             }
  763.             s = scrbuf;
  764.             break;
  765.         case 's':
  766.             if (!(s=subj_buf))
  767.             s = subj_buf = fetchsubj(art,TRUE,TRUE);
  768.                         /* get subject handy */
  769.             while ((*s=='R'||*s=='r')&&(s[1]=='E'||s[1]=='e')&&s[2]==':') {
  770.                         /* skip extra Re: */
  771.             s += 3;
  772.             if (*s == ' ')
  773.                 s++;
  774.             }
  775.             if (h = instr(s,"- (nf"))
  776.             *h = '\0';
  777.             break;
  778.         case 'S':
  779.             if (!(s=subj_buf))
  780.             s = subj_buf = fetchsubj(art,TRUE,TRUE);
  781.                         /* get subject handy */
  782.             if ((*s=='R'||*s=='r')&&(s[1]=='E'||s[1]=='e')&&s[2]==':') {
  783.                         /* skip extra Re: */
  784.             s += 3;
  785.             if (*s == ' ')
  786.                 s++;
  787.             }
  788.             break;
  789.         case 't':
  790.         case 'T':
  791. #ifdef ASYNC_PARSE
  792.             parse_maybe(art);
  793. #endif
  794.             if (htype[REPLY_LINE].ht_minpos >= 0) {
  795.                     /* was there a reply line? */
  796.             if (!(s=reply_buf))
  797.                 s = reply_buf = fetchlines(art,REPLY_LINE);
  798.             }
  799.             else if (!(s = from_buf))
  800.             s = from_buf = fetchlines(art,FROM_LINE);
  801.             if (*pattern == 'T') {
  802.             if (htype[PATH_LINE].ht_minpos >= 0) {
  803.                     /* should we substitute path? */
  804.                 s = path_buf = fetchlines(art,PATH_LINE);
  805.             }
  806.             i = strlen(sitename);
  807.             if (strnEQ(sitename,s,i) && s[i] == '!')
  808.                 s += i + 1;
  809.             }
  810.             if ((h=index(s,'(')) != Nullch)
  811.                         /* strip garbage from end */
  812.             *(h-1) = '\0';
  813.             else if ((h=index(s,'<')) != Nullch) {
  814.                         /* or perhaps from beginning */
  815.             s = h+1;
  816.             if ((h=index(s,'>')) != Nullch)
  817.                 *h = '\0';
  818.             }
  819.             break;
  820.         case 'u':
  821.             sprintf(scrbuf,"%ld",(long)toread[ng]);
  822.             s = scrbuf;
  823.             break;
  824.         case 'U':
  825.             sprintf(scrbuf,"%ld",
  826.             (long)(((ART_NUM)toread[ng]) - 1 + was_read(art)));
  827.             s = scrbuf;
  828.             break;
  829.         case 'x':            /* news library */
  830.             s = lib;
  831.             break;
  832.         case 'X':            /* rn library */
  833.             s = rnlib;
  834.             break;
  835.         case 'z':
  836. #ifdef LINKART
  837.             s = linkartname;    /* so Eunice people get right file */
  838. #else
  839.             s = scrbuf;
  840.             sprintf(s,"%ld",(long)art);
  841. #endif
  842.             if (stat(s,&filestat) < 0)
  843.             filestat.st_size = 0L;
  844.             sprintf(scrbuf,"%5ld",(long)filestat.st_size);
  845.             s = scrbuf;
  846.             break;
  847.         default:
  848.             if (--destsize <= 0)
  849.             abort_interp();
  850.             *dest++ = *pattern | metabit;
  851.             s = nullstr;
  852.             break;
  853.         }
  854.         }
  855.         if (!s)
  856.         s = nullstr;
  857.         pattern++;
  858.         if (upper || lastcomp) {
  859.         char *t;
  860.  
  861.         if (s != scrbuf) {
  862.             safecpy(scrbuf,s,(sizeof scrbuf));
  863.             s = scrbuf;
  864.         }
  865.         if (upper || !(t=rindex(s,'/')))
  866.             t = s;
  867.         while (*t && !isalpha(*t))
  868.             t++;
  869.         if (islower(*t))
  870.             *t = toupper(*t);
  871.         }
  872.         i = metabit;        /* maybe get into register */
  873.         if (s == dest) {
  874.         while (*dest) {
  875.             if (--destsize <= 0)
  876.             abort_interp();
  877.             *dest++ |= i;
  878.         }
  879.         }
  880.         else {
  881.         while (*s) {
  882.             if (--destsize <= 0)
  883.             abort_interp();
  884.             *dest++ = *s++ | i;
  885.         }
  886.         }
  887.     }
  888.     else {
  889.         if (--destsize <= 0)
  890.         abort_interp();
  891.         if (*pattern == '^' && pattern[1]) {
  892.         ++pattern;            /* skip uparrow */
  893.         i = *pattern;        /* get char into a register */
  894.         if (i == '?')
  895.             *dest++ = '\177' | metabit;
  896.         else if (i == '(') {
  897.             metabit = 0200;
  898.             destsize++;
  899.         }
  900.         else if (i == ')') {
  901.             metabit = 0;
  902.             destsize++;
  903.         }
  904.         else
  905.             *dest++ = i & 037 | metabit;
  906.         pattern++;
  907.         }
  908.         else if (*pattern == '\\' && pattern[1]) {
  909.         ++pattern;            /* skip backslash */
  910.         i = *pattern;        /* get char into a register */
  911.     
  912.         /* this used to be a switch but the if may save space */
  913.         
  914.         if (i >= '0' && i <= '7') {
  915.             i = 1;
  916.             while (i < 01000 && *pattern >= '0' && *pattern <= '7') {
  917.             i <<= 3;
  918.             i += *pattern++ - '0';
  919.             }
  920.             *dest++ = i & 0377 | metabit;
  921.             --pattern;
  922.         }
  923.         else if (i == 'b')
  924.             *dest++ = '\b' | metabit;
  925.         else if (i == 'f')
  926.             *dest++ = '\f' | metabit;
  927.         else if (i == 'n')
  928.             *dest++ = '\n' | metabit;
  929.         else if (i == 'r')
  930.             *dest++ = '\r' | metabit;
  931.         else if (i == 't')
  932.             *dest++ = '\t' | metabit;
  933.         else
  934.             *dest++ = i | metabit;
  935.         pattern++;
  936.         }
  937.         else
  938.         *dest++ = *pattern++ | metabit;
  939.     }
  940.     }
  941.     *dest = '\0';
  942. getout:
  943.     if (subj_buf != Nullch)    /* return any checked out storage */
  944.     free(subj_buf);
  945.     if (ngs_buf != Nullch)
  946.     free(ngs_buf);
  947.     if (refs_buf != Nullch)
  948.     free(refs_buf);
  949.     if (artid_buf != Nullch)
  950.     free(artid_buf);
  951.     if (reply_buf != Nullch)
  952.     free(reply_buf);
  953.     if (from_buf != Nullch)
  954.     free(from_buf);
  955.     if (path_buf != Nullch)
  956.     free(path_buf);
  957.     if (follow_buf != Nullch)
  958.     free(follow_buf);
  959.     if (dist_buf != Nullch)
  960.     free(dist_buf);
  961.     if (line_buf != Nullch)
  962.     free(line_buf);
  963.     return pattern;            /* where we left off */
  964. }
  965.  
  966. void
  967. interp(dest,destsize,pattern)
  968. char *dest;
  969. int destsize;
  970. char *pattern;
  971. {
  972.     dointerp(dest,destsize,pattern,Nullch);
  973. #ifdef DEBUGGING
  974.     if (debug & DEB_FILEXP)
  975.     fputs(dest,stdout);
  976. #endif
  977. }
  978.  
  979. /* copy a references line, normalizing as we go */
  980.  
  981. void
  982. refscpy(dest,destsize,src)
  983. register char *dest, *src;
  984. register int destsize;
  985. {
  986.     register char *dot, *at, *beg;
  987.     char tmpbuf[64];
  988.     
  989.     while (*src) {
  990.     if (*src != '<') {
  991.         if (--destsize <= 0)
  992.         break;
  993.         *dest++ = '<';
  994.         at = dot = Nullch;
  995.         beg = src;
  996.         while (*src && *src != ' ' && *src != ',') {
  997.         if (*src == '.')
  998.             dot = src;
  999.         else if (*src == '@')
  1000.             at = src;
  1001.         if (--destsize <= 0)
  1002.             break;
  1003.         *dest++ = *src++;
  1004.         }
  1005.         if (destsize <= 0)
  1006.         break;
  1007.         if (dot && !at) {
  1008.         int len;
  1009.  
  1010.         *dest = *dot++ = '\0';
  1011.         sprintf(tmpbuf,"%s@%s.UUCP",dot,beg);
  1012.         len = strlen(tmpbuf);
  1013.         if (destsize > len) {
  1014.             strcpy(dest,tmpbuf);
  1015.             dest = dest + len;
  1016.             destsize -= len;
  1017.         }
  1018.         }
  1019.         if (--destsize <= 0)
  1020.         break;
  1021.         *dest++ = '>';
  1022.     }
  1023.     else {
  1024.         while (*src && --destsize > 0 && (*dest++ = *src++) != '>') ;
  1025.         if (destsize <= 0)
  1026.         break;
  1027.     }
  1028.     while (*src == ' ' || *src == ',') src++;
  1029.     if (*src && --destsize > 0)
  1030.         *dest++ = ' ';
  1031.     }
  1032.     *dest = '\0';
  1033. } 
  1034.  
  1035. /* get the person's real name from /etc/passwd */
  1036. /* (string is overwritten, so it must be copied) */
  1037.  
  1038. char *
  1039. getrealname(uid)
  1040. int uid;
  1041. {
  1042.     char *s, *c;
  1043.  
  1044. #ifdef PASSNAMES
  1045. #ifdef GETPWENT
  1046.     struct passwd *pwd = getpwuid(uid);
  1047.     
  1048.     s = pwd->pw_gecos;
  1049. #else
  1050.     char tmpbuf[512];
  1051.     int i;
  1052.  
  1053.     getpw(uid, tmpbuf);
  1054.     for (s=tmpbuf, i=GCOSFIELD-1; i; i--) {
  1055.     if (s)
  1056.         s = index(s,':')+1;
  1057.     }
  1058.     if (!s)
  1059.     return nullstr;
  1060.     cpytill(tmpbuf,s,':');
  1061.     s = tmpbuf;
  1062. #endif
  1063. #ifdef BERKNAMES
  1064. #ifdef BERKJUNK
  1065.     while (*s && !isalnum(*s) && *s != '&') s++;
  1066. #endif
  1067.     if ((c = index(s, ',')) != Nullch)
  1068.     *c = '\0';
  1069.     if ((c = index(s, ';')) != Nullch)
  1070.     *c = '\0';
  1071.     s = cpytill(buf,s,'&');
  1072.     if (*s == '&') {            /* whoever thought this one up was */
  1073.     c = buf + strlen(buf);        /* in the middle of the night */
  1074.     strcat(c,logname);        /* before the morning after */
  1075.     strcat(c,s+1);
  1076.     if (islower(*c))
  1077.         *c = toupper(*c);        /* gack and double gack */
  1078.     }
  1079. #else
  1080.     if ((c = index(s, '(')) != Nullch)
  1081.     *c = '\0';
  1082.     if ((c = index(s, '-')) != Nullch)
  1083.     s = c;
  1084.     strcpy(buf,tmpbuf);
  1085. #endif
  1086. #ifdef GETPWENT
  1087.     endpwent();
  1088. #endif
  1089.     return buf;                /* return something static */
  1090. #else
  1091.     if ((tmpfp=fopen(filexp(FULLNAMEFILE),"r")) != Nullfp) {
  1092.     fgets(buf,sizeof buf,tmpfp);
  1093.     fclose(tmpfp);
  1094.     buf[strlen(buf)-1] = '\0';
  1095.     return buf;
  1096.     }
  1097.     return "PUT YOUR NAME HERE";
  1098. #endif
  1099. }
  1100.  
  1101. static void
  1102. abort_interp()
  1103. {
  1104.     fputs("\n% interp buffer overflow!\n",stdout) FLUSH;
  1105.     sig_catcher(0);
  1106. }
  1107. !STUFFY!FUNK!
  1108. echo Extracting term.c
  1109. cat >term.c <<'!STUFFY!FUNK!'
  1110. /* $Header: term.c,v 4.3.2.7 90/04/21 16:54:29 sob Exp $
  1111.  *
  1112.  * $Log:    term.c,v $
  1113.  * Revision 4.3.2.7  90/04/21  16:54:29  sob
  1114.  * Installed patches provided by SCO for SCO Xenix
  1115.  * 
  1116.  * Revision 4.3.2.6  90/04/13  23:48:17  sob
  1117.  * Modifications provided by Gene Hackney for 3b2.
  1118.  * 
  1119.  * Revision 4.3.2.5  90/04/06  20:35:08  sob
  1120.  * Added fixes for SCO Xenix sent by ronald@robobar.co.uk.
  1121.  * 
  1122.  * Revision 4.3.2.4  90/03/22  23:05:38  sob
  1123.  * Fixes provided by Wayne Davison <drivax!davison>
  1124.  * 
  1125.  * Revision 4.3.2.3  89/11/28  01:51:58  sob
  1126.  * Now handles SIGWINCH correctly.
  1127.  * 
  1128.  * Revision 4.3.2.2  89/11/27  01:31:34  sob
  1129.  * Altered NNTP code per ideas suggested by Bela Lubkin
  1130.  * <filbo@gorn.santa-cruz.ca.us>
  1131.  * 
  1132.  * Revision 4.3.2.1  89/11/06  01:02:12  sob
  1133.  * Added RRN support from NNTP 1.5
  1134.  * 
  1135.  * Revision 4.3.1.3  85/09/10  11:05:23  lwall
  1136.  * Improved %m in in_char().
  1137.  * 
  1138.  * Revision 4.3.1.2  85/05/16  16:45:35  lwall
  1139.  * Forced \r to \n on input.
  1140.  * Fix for terminfo braindamage regarding bc emulation.
  1141.  * 
  1142.  * Revision 4.3.1.1  85/05/10  11:41:03  lwall
  1143.  * Branch for patches.
  1144.  * 
  1145.  * Revision 4.3  85/05/01  11:51:10  lwall
  1146.  * Baseline for release with 4.3bsd.
  1147.  * 
  1148.  */
  1149.  
  1150. #include "EXTERN.h"
  1151. #include "common.h"
  1152. #include "util.h"
  1153. #include "final.h"
  1154. #include "help.h"
  1155. #include "cheat.h"
  1156. #include "intrp.h"
  1157. #include "INTERN.h"
  1158. #include "term.h"
  1159.  
  1160. char ERASECH;        /* rubout character */
  1161. char KILLCH;        /* line delete character */
  1162. char tcarea[TCSIZE];    /* area for "compiled" termcap strings */
  1163.  
  1164. /* guarantee capability pointer != Nullch */
  1165. /* (I believe terminfo will ignore the &tmpaddr argument.) */
  1166.  
  1167. #define Tgetstr(key) ((tmpstr = tgetstr(key,&tmpaddr)) ? tmpstr : nullstr)
  1168.  
  1169. #ifdef PUSHBACK
  1170. struct keymap {
  1171.     char km_type[128];
  1172.     union km_union {
  1173.     struct keymap *km_km;
  1174.     char *km_str;
  1175.     } km_ptr[128];
  1176. };
  1177.  
  1178. #define KM_NOTHIN 0
  1179. #define KM_STRING 1
  1180. #define KM_KEYMAP 2
  1181. #define KM_BOGUS 3
  1182.  
  1183. #define KM_TMASK 3
  1184. #define KM_GSHIFT 4
  1185. #define KM_GMASK 7
  1186.  
  1187. typedef struct keymap KEYMAP;
  1188.  
  1189. KEYMAP *topmap INIT(Null(KEYMAP*));
  1190.  
  1191. void mac_init();
  1192. KEYMAP *newkeymap();
  1193. void show_keymap();
  1194. void pushstring();
  1195. #endif
  1196.  
  1197. void line_col_calcs();
  1198.  
  1199. /* terminal initialization */
  1200.  
  1201. void
  1202. term_init()
  1203. {
  1204.     savetty();                /* remember current tty state */
  1205.  
  1206. #ifdef TERMIO
  1207.     ospeed = _tty.c_cflag & CBAUD;    /* for tputs() */
  1208.     ERASECH = _tty.c_cc[VERASE];    /* for finish_command() */
  1209.     KILLCH = _tty.c_cc[VKILL];        /* for finish_command() */
  1210. #else
  1211.     ospeed = _tty.sg_ospeed;        /* for tputs() */
  1212.     ERASECH = _tty.sg_erase;        /* for finish_command() */
  1213.     KILLCH = _tty.sg_kill;        /* for finish_command() */
  1214. #endif
  1215.  
  1216.     /* The following could be a table but I can't be sure that there isn't */
  1217.     /* some degree of sparsity out there in the world. */
  1218.  
  1219.     switch (ospeed) {            /* 1 second of padding */
  1220. #ifdef BEXTA
  1221.         case BEXTA:  just_a_sec = 1920; break;
  1222. #else
  1223. #ifdef B19200
  1224.         case B19200: just_a_sec = 1920; break;
  1225. #endif
  1226. #endif
  1227.         case B9600:  just_a_sec =  960; break;
  1228.         case B4800:  just_a_sec =  480; break;
  1229.         case B2400:  just_a_sec =  240; break;
  1230.         case B1800:  just_a_sec =  180; break;
  1231.         case B1200:  just_a_sec =  120; break;
  1232.         case B600:   just_a_sec =   60; break;
  1233.     case B300:   just_a_sec =   30; break;
  1234.     /* do I really have to type the rest of this??? */
  1235.         case B200:   just_a_sec =   20; break;
  1236.         case B150:   just_a_sec =   15; break;
  1237.         case B134:   just_a_sec =   13; break;
  1238.         case B110:   just_a_sec =   11; break;
  1239.         case B75:    just_a_sec =    8; break;
  1240.         case B50:    just_a_sec =    5; break;
  1241.         default:     just_a_sec =  960; break;
  1242.                     /* if we are running detached I */
  1243.     }                    /*  don't want to know about it! */
  1244. }
  1245.  
  1246. /* set terminal characteristics */
  1247.  
  1248. void
  1249. term_set(tcbuf)
  1250. char *tcbuf;        /* temp area for "uncompiled" termcap entry */
  1251. {
  1252.     char *tmpaddr;            /* must not be register */
  1253.     register char *tmpstr;
  1254.     char *tgetstr();
  1255.     char *s;
  1256.     int status;
  1257. #ifdef TIOCGWINSZ
  1258. #ifdef u3b2
  1259. struct winsize {
  1260.     unsigned short ws_row;       /* rows, in characters*/
  1261.     unsigned short ws_col;       /* columns, in character */
  1262.     unsigned short ws_xpixel;    /* horizontal size, pixels */
  1263.     unsigned short ws_ypixel;    /* vertical size, pixels */
  1264. };
  1265. #endif
  1266.     struct winsize winsize;
  1267. #endif
  1268.  
  1269. #ifdef PENDING
  1270. #if ! defined (FIONREAD) && ! defined (RDCHK)
  1271.     /* do no delay reads on something that always gets closed on exit */
  1272.  
  1273.     devtty = open("/dev/tty",0);
  1274.     if (devtty < 0) {
  1275.     printf(cantopen,"/dev/tty") FLUSH;
  1276.     finalize(1);
  1277.     }
  1278.     fcntl(devtty,F_SETFL,O_NDELAY);
  1279. #endif
  1280. #endif
  1281.     
  1282.     /* get all that good termcap stuff */
  1283.  
  1284. #ifdef HAVETERMLIB
  1285.     status = tgetent(tcbuf,getenv("TERM"));    /* get termcap entry */
  1286.     if (status < 1) {
  1287. #ifdef VERBOSE
  1288.     printf("No termcap %s found.\n", status ? "file" : "entry") FLUSH;
  1289. #else
  1290.     fputs("Termcap botch\n",stdout) FLUSH
  1291. #endif
  1292.     finalize(1);
  1293.     }
  1294.     tmpaddr = tcarea;            /* set up strange tgetstr pointer */
  1295.     s = Tgetstr("pc");            /* get pad character */
  1296.     PC = *s;                /* get it where tputs wants it */
  1297.     if (!tgetflag("bs")) {        /* is backspace not used? */
  1298.     BC = Tgetstr("bc");        /* find out what is */
  1299.     if (BC == nullstr)         /* terminfo grok's 'bs' but not 'bc' */
  1300.         BC = Tgetstr("le");
  1301.     } else
  1302.     BC = "\b";            /* make a backspace handy */
  1303.     UP = Tgetstr("up");            /* move up a line */
  1304.     if (!*UP)                /* no UP string? */
  1305.     marking = 0;            /* disable any marking */
  1306.     if (muck_up_clear)            /* this is for weird HPs */
  1307.     CL = "\n\n\n\n";
  1308.     else
  1309.     CL = Tgetstr("cl");        /* get clear string */
  1310.     CE = Tgetstr("ce");            /* clear to end of line string */
  1311. #ifdef CLEAREOL
  1312.     CM = Tgetstr("cm");            /* cursor motion */
  1313.     HO = Tgetstr("ho");            /* home cursor if no CM */
  1314.     CD = Tgetstr("cd");            /* clear to end of display */
  1315.     if (!*CE || !*CD || (!*CM && !*HO))    /* can we CE, CD, and home? */
  1316.     can_home_clear = FALSE;        /*  no, so disable use of clear eol */
  1317. #endif CLEAREOL
  1318.     SO = Tgetstr("so");            /* begin standout */
  1319.     SE = Tgetstr("se");            /* end standout */
  1320.     if ((SG = tgetnum("sg"))<0)
  1321.     SG = 0;                /* blanks left by SG, SE */
  1322.     US = Tgetstr("us");            /* start underline */
  1323.     UE = Tgetstr("ue");            /* end underline */
  1324.     if ((UG = tgetnum("ug"))<0)
  1325.     UG = 0;                /* blanks left by US, UE */
  1326.     if (*US)
  1327.     UC = nullstr;            /* UC must not be NULL */
  1328.     else
  1329.     UC = Tgetstr("uc");        /* underline a character */
  1330.     if (!*US && !*UC) {            /* no underline mode? */
  1331.     US = SO;            /* substitute standout mode */
  1332.     UE = SE;
  1333.     UG = SG;
  1334.     }
  1335.     LINES = tgetnum("li");        /* lines per page */
  1336.     COLS = tgetnum("co");        /* columns on page */
  1337.  
  1338. #ifdef TIOCGWINSZ
  1339.     { struct winsize ws;
  1340.     if (ioctl(0, TIOCGWINSZ, &ws) >= 0 && ws.ws_row > 0 && ws.ws_col > 0) {
  1341.         LINES = ws.ws_row;
  1342.         COLS = ws.ws_col;
  1343.     }
  1344.     }
  1345. #endif
  1346.     
  1347.     AM = tgetflag("am");        /* terminal wraps automatically? */
  1348.     XN = tgetflag("xn");        /* then eats next newline? */
  1349.     VB = Tgetstr("vb");
  1350.     if (!*VB)
  1351.     VB = "\007";
  1352.     CR = Tgetstr("cr");
  1353.     if (!*CR) {
  1354.     if (tgetflag("nc") && *UP) {
  1355.         CR = safemalloc((MEM_SIZE)strlen(UP)+2);
  1356.         sprintf(CR,"%s\r",UP);
  1357.     }
  1358.     else
  1359.         CR = "\r";
  1360.     }
  1361. #ifdef TIOCGWINSZ
  1362.     if (ioctl(1, TIOCGWINSZ, &winsize)>=0) {
  1363.         if (winsize.ws_row>0) LINES=winsize.ws_row;
  1364.         if (winsize.ws_col>0) COLS=winsize.ws_col;
  1365.     }
  1366. #endif
  1367. #else
  1368.     ??????                /* Roll your own... */
  1369. #endif
  1370.     line_col_calcs();
  1371.     noecho();                /* turn off echo */
  1372.     crmode();                /* enter cbreak mode */
  1373.  
  1374. #ifdef PUSHBACK
  1375.     mac_init(tcbuf);
  1376. #endif
  1377. }
  1378.  
  1379. #ifdef PUSHBACK
  1380. void
  1381. mac_init(tcbuf)
  1382. char *tcbuf;
  1383. {
  1384.     char tmpbuf[1024];
  1385.  
  1386.     tmpfp = fopen(filexp(getval("RNMACRO",RNMACRO)),"r");
  1387.     if (tmpfp != Nullfp) {
  1388.     while (fgets(tcbuf,1024,tmpfp) != Nullch) {
  1389.         mac_line(tcbuf,tmpbuf,(sizeof tmpbuf));
  1390.     }
  1391.     fclose(tmpfp);
  1392.     }
  1393. }
  1394.  
  1395. void
  1396. mac_line(line,tmpbuf,tbsize)
  1397. char *line;
  1398. char *tmpbuf;
  1399. int tbsize;
  1400. {
  1401.     register char *s, *m;
  1402.     register KEYMAP *curmap;
  1403.     register int ch;
  1404.     register int garbage = 0;
  1405.     static char override[] = "\nkeymap overrides string\n";
  1406.  
  1407.     if (topmap == Null(KEYMAP*))
  1408.     topmap = newkeymap();
  1409.     if (*line == '#' || *line == '\n')
  1410.     return;
  1411.     if (line[ch = strlen(line)-1] == '\n')
  1412.     line[ch] = '\0';
  1413.     m = dointerp(tmpbuf,tbsize,line," \t");
  1414.     if (!*m)
  1415.     return;
  1416.     while (*m == ' ' || *m == '\t') m++;
  1417.     for (s=tmpbuf,curmap=topmap; *s; s++) {
  1418.     ch = *s & 0177;
  1419.     if (s[1] == '+' && isdigit(s[2])) {
  1420.         s += 2;
  1421.         garbage = (*s & KM_GMASK) << KM_GSHIFT;
  1422.     }
  1423.     else
  1424.         garbage = 0;
  1425.     if (s[1]) {
  1426.         if ((curmap->km_type[ch] & KM_TMASK) == KM_STRING) {
  1427.         fputs(override,stdout) FLUSH;
  1428.         free(curmap->km_ptr[ch].km_str);
  1429.         curmap->km_ptr[ch].km_str = Nullch;
  1430.         }
  1431.         curmap->km_type[ch] = KM_KEYMAP + garbage;
  1432.         if (curmap->km_ptr[ch].km_km == Null(KEYMAP*))
  1433.         curmap->km_ptr[ch].km_km = newkeymap();
  1434.         curmap = curmap->km_ptr[ch].km_km;
  1435.     }
  1436.     else {
  1437.         if ((curmap->km_type[ch] & KM_TMASK) == KM_KEYMAP)
  1438.         fputs(override,stdout) FLUSH;
  1439.         else {
  1440.         curmap->km_type[ch] = KM_STRING + garbage;
  1441.         curmap->km_ptr[ch].km_str = savestr(m);
  1442.         }
  1443.     }
  1444.     }
  1445. }
  1446.  
  1447. KEYMAP*
  1448. newkeymap()
  1449. {
  1450.     register int i;
  1451.     register KEYMAP *map;
  1452.  
  1453. #ifndef lint
  1454.     map = (KEYMAP*)safemalloc(sizeof(KEYMAP));
  1455. #else
  1456.     map = Null(KEYMAP*);
  1457. #endif lint
  1458.     for (i=127; i>=0; --i) {
  1459.     map->km_ptr[i].km_km = Null(KEYMAP*);
  1460.     map->km_type[i] = KM_NOTHIN;
  1461.     }
  1462.     return map;
  1463. }
  1464.  
  1465. void
  1466. show_macros()
  1467. {
  1468.     char prebuf[64];
  1469.  
  1470.     if (topmap != Null(KEYMAP*)) {
  1471.     print_lines("Macros:\n",STANDOUT);
  1472.     *prebuf = '\0';
  1473.     show_keymap(topmap,prebuf);
  1474.     }
  1475. }
  1476.  
  1477. void
  1478. show_keymap(curmap,prefix)
  1479. register KEYMAP *curmap;
  1480. char *prefix;
  1481. {
  1482.     register int i;
  1483.     register char *next = prefix + strlen(prefix);
  1484.     register int kt;
  1485.  
  1486.     for (i=0; i<128; i++) {
  1487.     if (kt = curmap->km_type[i]) {
  1488.         if (i < ' ')
  1489.         sprintf(next,"^%c",i+64);
  1490.         else if (i == ' ')
  1491.         strcpy(next,"\\040");
  1492.         else if (i == 127)
  1493.         strcpy(next,"^?");
  1494.         else
  1495.         sprintf(next,"%c",i);
  1496.         if ((kt >> KM_GSHIFT) & KM_GMASK) {
  1497.         sprintf(cmd_buf,"+%d", (kt >> KM_GSHIFT) & KM_GMASK);
  1498.         strcat(next,cmd_buf);
  1499.         }
  1500.         switch (kt & KM_TMASK) {
  1501.         case KM_NOTHIN:
  1502.         sprintf(cmd_buf,"%s    %c\n",prefix,i);
  1503.         print_lines(cmd_buf,NOMARKING);
  1504.         break;
  1505.         case KM_KEYMAP:
  1506.         show_keymap(curmap->km_ptr[(char)i].km_km, prefix);
  1507.         break;
  1508.         case KM_STRING:
  1509.         sprintf(cmd_buf,"%s    %s\n",prefix,curmap->km_ptr[i].km_str);
  1510.         print_lines(cmd_buf,NOMARKING);
  1511.         break;
  1512.         case KM_BOGUS:
  1513.         sprintf(cmd_buf,"%s    BOGUS\n",prefix);
  1514.         print_lines(cmd_buf,STANDOUT);
  1515.         break;
  1516.         }
  1517.     }
  1518.     }
  1519. }
  1520.  
  1521. #endif
  1522.  
  1523. /* routine to pass to tputs */
  1524.  
  1525. char
  1526. putchr(ch)
  1527. register char ch;
  1528. {
  1529.     putchar(ch);
  1530. #ifdef lint
  1531.     ch = Null(char);
  1532.     ch = ch;
  1533. #endif
  1534.     return((char) 0);
  1535. }
  1536.  
  1537. /* input the 2nd and succeeding characters of a multi-character command */
  1538. /* returns TRUE if command finished, FALSE if they rubbed out first character */
  1539.  
  1540. bool
  1541. finish_command(donewline)
  1542. int donewline;
  1543. {
  1544.     register char *s;
  1545.     register bool quoteone = FALSE;
  1546.  
  1547.     s = buf;
  1548.     if (s[1] != FINISHCMD)        /* someone faking up a command? */
  1549.     return TRUE;
  1550.     do {
  1551.       top:
  1552.     if (*s < ' ') {
  1553.         putchar('^');
  1554.         putchar(*s | 64);
  1555.     }
  1556.     else if (*s == '\177') {
  1557.         putchar('^');
  1558.         putchar('?');
  1559.     }
  1560.     else
  1561.         putchar(*s);        /* echo previous character */
  1562.     s++;
  1563. re_read:
  1564.     fflush(stdout);
  1565.     getcmd(s);
  1566.     if (quoteone) {
  1567.         quoteone = FALSE;
  1568.         continue;
  1569.     }
  1570.     if (errno || *s == Ctl('l')) {
  1571.         *s = Ctl('r');        /* force rewrite on CONT */
  1572.     }
  1573.     if (*s == '\033') {        /* substitution desired? */
  1574. #ifdef ESCSUBS
  1575.         char tmpbuf[4], *cpybuf;
  1576.  
  1577.         tmpbuf[0] = '%';
  1578.         read_tty(&tmpbuf[1],1);
  1579. #ifdef RAWONLY
  1580.         tmpbuf[1] &= 0177;
  1581. #endif
  1582.         tmpbuf[2] = '\0';
  1583.         if (tmpbuf[1] == 'h') {
  1584.         (void) help_subs();
  1585.         *s = '\0';
  1586.         reprint();
  1587.         goto re_read;
  1588.         }
  1589.         else if (tmpbuf[1] == '\033') {
  1590.         *s = '\0';
  1591.         cpybuf = savestr(buf);
  1592.         interp(buf, (sizeof buf), cpybuf);
  1593.         free(cpybuf);
  1594.         s = buf + strlen(buf);
  1595.         reprint();
  1596.         goto re_read;
  1597.         }
  1598.         else {
  1599.         interp(s,(sizeof buf) - (s-buf),tmpbuf);
  1600.         fputs(s,stdout);
  1601.         s += strlen(s);
  1602.         }
  1603.         goto re_read;
  1604. #else
  1605.         notincl("^[");
  1606.         *s = '\0';
  1607.         reprint();
  1608.         goto re_read;
  1609. #endif
  1610.     }
  1611.     else if (*s == ERASECH) {    /* they want to rubout a char? */
  1612.         rubout();
  1613.         s--;            /* discount the char rubbed out */
  1614.         if (*s < ' ' || *s == '\177')
  1615.         rubout();
  1616.         if (s == buf) {        /* entire string gone? */
  1617.         fflush(stdout);        /* return to single char command mode */
  1618.         return FALSE;
  1619.         }
  1620.         else
  1621.         goto re_read;
  1622.     }
  1623.     else if (*s == KILLCH) {    /* wipe out the whole line? */
  1624.         while (s-- != buf) {    /* emulate that many ERASEs */
  1625.         rubout();
  1626.         if (*s < ' ' || *s == '\177')
  1627.             rubout();
  1628.         }
  1629.         fflush(stdout);
  1630.         return FALSE;        /* return to single char mode */
  1631.     }
  1632. #ifdef WORDERASE
  1633.     else if (*s == Ctl('w')) {    /* wipe out one word? */
  1634.         *s-- = ' ';
  1635.         while (!isspace(*s) || isspace(s[1])) {
  1636.         rubout();
  1637.         if (s-- == buf) {
  1638.             fflush(stdout);
  1639.             return FALSE;    /* return to single char mode */
  1640.         }
  1641.         if (*s < ' ' || *s == '\177')
  1642.             rubout();
  1643.         }
  1644.         s++;
  1645.         goto re_read;
  1646.     }
  1647. #endif
  1648.     else if (*s == Ctl('r')) {
  1649.         *s = '\0';
  1650.         reprint();
  1651.         goto re_read;
  1652.     }
  1653.     else if (*s == Ctl('v')) {
  1654.         putchar('^');
  1655.         backspace();
  1656.         fflush(stdout);
  1657.         getcmd(s);
  1658.         goto top;
  1659.     }
  1660.     else if (*s == '\\') {
  1661.         quoteone = TRUE;
  1662.     }
  1663.     } while (*s != '\n');        /* till a newline (not echoed) */
  1664.     *s = '\0';                /* terminate the string nicely */
  1665.     if (donewline)
  1666.     putchar('\n') FLUSH;
  1667.     return TRUE;            /* say we succeeded */
  1668. }
  1669.  
  1670. /* discard any characters typed ahead */
  1671.  
  1672. void
  1673. eat_typeahead()
  1674. {
  1675. #ifdef PUSHBACK
  1676.     if (!typeahead && nextin==nextout)    /* cancel only keyboard stuff */
  1677. #else
  1678.     if (!typeahead)
  1679. #endif
  1680.     {
  1681. #ifdef PENDING
  1682.     while (input_pending())
  1683.         read_tty(buf,sizeof(buf));
  1684. #else /* this is probably v7 */
  1685.     ioctl(_tty_ch,TIOCSETP,&_tty);
  1686. #endif
  1687.     }
  1688. }
  1689.  
  1690. void
  1691. settle_down()
  1692. {
  1693.     dingaling();
  1694.     fflush(stdout);
  1695.     sleep(1);
  1696. #ifdef PUSHBACK
  1697.     nextout = nextin;            /* empty circlebuf */
  1698. #endif
  1699.     eat_typeahead();
  1700. }
  1701.  
  1702. #ifdef PUSHBACK
  1703. /* read a character from the terminal, with multi-character pushback */
  1704.  
  1705. int
  1706. read_tty(addr,size)
  1707. char *addr;
  1708. int size;
  1709. {
  1710.     if (nextout != nextin) {
  1711.     *addr = circlebuf[nextout++];
  1712.     nextout %= PUSHSIZE;
  1713.     return 1;
  1714.     }
  1715.     else {
  1716.     size = read(0,addr,size);
  1717. #ifdef RAWONLY
  1718.     *addr &= 0177;
  1719. #endif
  1720.     return size;
  1721.     }
  1722. }
  1723.  
  1724. #ifdef PENDING
  1725. #if ! defined (FIONREAD) && ! defined (RDCHK)
  1726. int
  1727. circfill()
  1728. {
  1729.     register int Howmany = read(devtty,circlebuf+nextin,1);
  1730.  
  1731.     if (Howmany) {
  1732.     nextin += Howmany;
  1733.     nextin %= PUSHSIZE;
  1734.     }
  1735.     return Howmany;
  1736. }
  1737. #endif PENDING
  1738. #endif FIONREAD
  1739.  
  1740. void
  1741. pushchar(c)
  1742. char c;
  1743. {
  1744.     nextout--;
  1745.     if (nextout < 0)
  1746.     nextout = PUSHSIZE - 1;
  1747.     if (nextout == nextin) {
  1748.     fputs("\npushback buffer overflow\n",stdout) FLUSH;
  1749.     sig_catcher(0);
  1750.     }
  1751.     circlebuf[nextout] = c;
  1752. }
  1753.  
  1754. #else PUSHBACK
  1755. #ifndef read_tty
  1756. /* read a character from the terminal, with hacks for O_NDELAY reads */
  1757.  
  1758. int
  1759. read_tty(addr,size)
  1760. char *addr;
  1761. int size;
  1762. {
  1763.     if (is_input) {
  1764.     *addr = pending_ch;
  1765.     is_input = FALSE;
  1766.     return 1;
  1767.     }
  1768.     else {
  1769.     size = read(0,addr,size);
  1770. #ifdef RAWONLY
  1771.     *addr &= 0177;
  1772. #endif
  1773.     return size;
  1774.     }
  1775. }
  1776. #endif read_tty
  1777. #endif PUSHBACK
  1778.  
  1779. /* print an underlined string, one way or another */
  1780.  
  1781. void
  1782. underprint(s)
  1783. register char *s;
  1784. {
  1785.     assert(UC);
  1786.     if (*UC) {        /* char by char underline? */
  1787.     while (*s) {
  1788.         if (*s < ' ') {
  1789.         putchar('^');
  1790.         backspace();/* back up over it */
  1791.         underchar();/* and do the underline */
  1792.         putchar(*s+64);
  1793.         backspace();/* back up over it */
  1794.         underchar();/* and do the underline */
  1795.         }
  1796.         else {
  1797.         putchar(*s);
  1798.         backspace();/* back up over it */
  1799.         underchar();/* and do the underline */
  1800.         }
  1801.         s++;
  1802.     }
  1803.     }
  1804.     else {        /* start and stop underline */
  1805.     underline();    /* start underlining */
  1806.     while (*s) {
  1807.         if (*s < ' ') {
  1808.         putchar('^');
  1809.         putchar(*s+64);
  1810.         }
  1811.         else
  1812.         putchar(*s);
  1813.         s++;
  1814.     }
  1815.     un_underline();    /* stop underlining */
  1816.     }
  1817. }
  1818.  
  1819. /* keep screen from flashing strangely on magic cookie terminals */
  1820.  
  1821. #ifdef NOFIREWORKS
  1822. void
  1823. no_sofire()
  1824. {
  1825.     if (*UP && *SE) {        /* should we disable fireworks? */
  1826.     putchar('\n');
  1827.     un_standout();
  1828.     up_line();
  1829.     carriage_return();
  1830.     }
  1831. }
  1832.  
  1833. void
  1834. no_ulfire()
  1835. {
  1836.     if (*UP && *US) {        /* should we disable fireworks? */
  1837.     putchar('\n');
  1838.     un_underline();
  1839.     up_line();
  1840.     carriage_return();
  1841.     }
  1842. }
  1843. #endif
  1844.  
  1845. /* get a character into a buffer */
  1846.  
  1847. void
  1848. getcmd(whatbuf)
  1849. register char *whatbuf;
  1850. {
  1851. #ifdef PUSHBACK
  1852.     register KEYMAP *curmap;
  1853.     register int i;
  1854.     bool no_macros; 
  1855.     int times = 0;            /* loop detector */
  1856.     char scrchar;
  1857.  
  1858. tryagain:
  1859.     curmap = topmap;
  1860.     no_macros = (whatbuf != buf && nextin == nextout); 
  1861. #endif
  1862.     for (;;) {
  1863.     int_count = 0;
  1864.     errno = 0;
  1865.     if (read_tty(whatbuf,1) < 0)
  1866.         if (!errno)
  1867.             errno = EINTR;
  1868.         else {
  1869.         perror(readerr);
  1870.         sig_catcher(0);
  1871.     }
  1872. #ifdef PUSHBACK
  1873.     if (*whatbuf & 0200 || no_macros) {
  1874.         *whatbuf &= 0177;
  1875.         goto got_canonical;
  1876.     }
  1877.     if (curmap == Null(KEYMAP*))
  1878.         goto got_canonical;
  1879.     for (i = (curmap->km_type[*whatbuf] >> KM_GSHIFT) & KM_GMASK; i; --i){
  1880.         read_tty(&scrchar,1);
  1881.     }
  1882.     switch (curmap->km_type[*whatbuf] & KM_TMASK) {
  1883.     case KM_NOTHIN:            /* no entry? */
  1884.         if (curmap == topmap)    /* unmapped canonical */
  1885.         goto got_canonical;
  1886.         settle_down();
  1887.         goto tryagain;
  1888.     case KM_KEYMAP:            /* another keymap? */
  1889.         curmap = curmap->km_ptr[*whatbuf].km_km;
  1890.         assert(curmap != Null(KEYMAP*));
  1891.         break;
  1892.     case KM_STRING:            /* a string? */
  1893.         pushstring(curmap->km_ptr[*whatbuf].km_str);
  1894.         if (++times > 20) {        /* loop? */
  1895.         fputs("\nmacro loop?\n",stdout);
  1896.         settle_down();
  1897.         }
  1898.         no_macros = FALSE;
  1899.         goto tryagain;
  1900.     }
  1901. #else
  1902. #ifdef RAWONLY
  1903.     *whatbuf &= 0177;
  1904. #endif
  1905.     break;
  1906. #endif
  1907.     }
  1908.  
  1909. got_canonical:
  1910. #ifndef TERMIO
  1911.     if (*whatbuf == '\r')
  1912.     *whatbuf = '\n';
  1913. #endif
  1914.     if (whatbuf == buf)
  1915.     whatbuf[1] = FINISHCMD;        /* tell finish_command to work */
  1916. }
  1917.  
  1918. #ifdef PUSHBACK
  1919. void
  1920. pushstring(str)
  1921. char *str;
  1922. {
  1923.     register int i;
  1924.     char tmpbuf[PUSHSIZE];
  1925.     register char *s = tmpbuf;
  1926.  
  1927.     assert(str != Nullch);
  1928.     interp(s,PUSHSIZE,str);
  1929.     for (i = strlen(s)-1; i >= 0; --i) {
  1930.     s[i] ^= 0200; 
  1931.     pushchar(s[i]);
  1932.     }
  1933. }
  1934. #endif
  1935.  
  1936. int
  1937. get_anything()
  1938. {
  1939.     char tmpbuf[2];
  1940.  
  1941. reask_anything:
  1942.     unflush_output();            /* disable any ^O in effect */
  1943.     standout();
  1944. #ifdef VERBOSE
  1945.     IF(verbose)
  1946.     fputs("[Type space to continue] ",stdout);
  1947.     ELSE
  1948. #endif
  1949. #ifdef TERSE
  1950.     fputs("[MORE] ",stdout);
  1951. #endif
  1952.     un_standout();
  1953.     fflush(stdout);
  1954.     eat_typeahead();
  1955.     if (int_count) {
  1956.     return -1;
  1957.     }
  1958.     collect_subjects();            /* loads subject cache until */
  1959.                     /* input is pending */
  1960.     getcmd(tmpbuf);
  1961.     if (errno || *tmpbuf == '\f') {
  1962.     putchar('\n') FLUSH;        /* if return from stop signal */
  1963.     goto reask_anything;        /* give them a prompt again */
  1964.     }
  1965.     if (*tmpbuf == 'h') {
  1966. #ifdef VERBOSE
  1967.     IF(verbose)
  1968.         fputs("\nType q to quit or space to continue.\n",stdout) FLUSH;
  1969.     ELSE
  1970. #endif
  1971. #ifdef TERSE
  1972.         fputs("\nq to quit, space to continue.\n",stdout) FLUSH;
  1973. #endif
  1974.     goto reask_anything;
  1975.     }
  1976.     else if (*tmpbuf != ' ' && *tmpbuf != '\n') {
  1977.     carriage_return();
  1978.     erase_eol();    /* erase the prompt */
  1979.     carriage_return();
  1980.     return *tmpbuf == 'q' ? -1 : *tmpbuf;
  1981.     }
  1982.     if (*tmpbuf == '\n') {
  1983.     page_line = LINES - 1;
  1984.     carriage_return();
  1985.     erase_eol();
  1986.     carriage_return();
  1987.     }
  1988.     else {
  1989.     page_line = 1;
  1990.     if (erase_screen)        /* -e? */
  1991.         clear();            /* clear screen */
  1992.     else {
  1993.         carriage_return();
  1994.         erase_eol();        /* erase the prompt */
  1995.         carriage_return();
  1996.     }
  1997.     }
  1998.     return 0;
  1999. }
  2000.  
  2001. void
  2002. in_char(prompt, newmode)
  2003. char *prompt;
  2004. char newmode;
  2005. {
  2006.     char oldmode = mode;
  2007.  
  2008. reask_in_char:
  2009.     unflush_output();            /* disable any ^O in effect */
  2010.     fputs(prompt,stdout);
  2011.     fflush(stdout);
  2012.     eat_typeahead();
  2013.     mode = newmode;
  2014.     getcmd(buf);
  2015.     if (errno || *buf == '\f') {
  2016.     putchar('\n') FLUSH;        /* if return from stop signal */
  2017.     goto reask_in_char;        /* give them a prompt again */
  2018.     }
  2019.     mode = oldmode;
  2020. }
  2021.  
  2022. int
  2023. print_lines(what_to_print,hilite)
  2024. char *what_to_print;
  2025. int hilite;
  2026. {
  2027.     register char *s;
  2028.     register int i;
  2029.  
  2030.     if (page_line < 0)            /* they do not want to see this? */
  2031.     return -1;
  2032.     for (s=what_to_print; *s; ) {
  2033.     if (page_line >= LINES || int_count) {
  2034.         if (i = -1, int_count || (i = get_anything())) {
  2035.         page_line = -1;        /* disable further print_lines */
  2036.         return i;
  2037.         }
  2038.     }
  2039.     page_line++;
  2040.     if (hilite == STANDOUT) {
  2041. #ifdef NOFIREWORKS
  2042.         if (erase_screen)
  2043.         no_sofire();
  2044. #endif
  2045.         standout();
  2046.     }
  2047.     else if (hilite == UNDERLINE) {
  2048. #ifdef NOFIREWORKS
  2049.         if (erase_screen)
  2050.         no_ulfire();
  2051. #endif
  2052.         underline();
  2053.     }
  2054.     for (i=0; i<COLS; i++) {
  2055.         if (!*s)
  2056.         break;
  2057.         if (*s >= ' ')
  2058.         putchar(*s);
  2059.         else if (*s == '\t') {
  2060.         putchar(*s);
  2061.         i = ((i+8) & ~7) - 1; 
  2062.         }
  2063.         else if (*s == '\n') {
  2064.         i = 32000;
  2065.         }
  2066.         else {
  2067.         i++;
  2068.         putchar('^');
  2069.         putchar(*s + 64);
  2070.         }
  2071.         s++;
  2072.     }
  2073.     if (i) {
  2074.         if (hilite == STANDOUT)
  2075.         un_standout();
  2076.         else if (hilite == UNDERLINE)
  2077.         un_underline();
  2078.         if (AM && i == COLS)
  2079.         fflush(stdout);
  2080.         else
  2081.         putchar('\n') FLUSH;
  2082.     }
  2083.     }
  2084.     return 0;
  2085. }
  2086.  
  2087. void
  2088. page_init()
  2089. {
  2090.     page_line = 1;
  2091.     if (erase_screen)
  2092.     clear();
  2093.     else
  2094.     putchar('\n') FLUSH;
  2095. }
  2096.  
  2097. void
  2098. pad(num)
  2099. int num;
  2100. {
  2101.     register int i;
  2102.  
  2103.     for (i = num; i; --i)
  2104.     putchar(PC);
  2105.     fflush(stdout);
  2106. }
  2107.  
  2108. /* echo the command just typed */
  2109.  
  2110. #ifdef VERIFY
  2111. void
  2112. printcmd()
  2113. {
  2114.     if (verify && buf[1] == FINISHCMD) {
  2115.     if (*buf < ' ') {
  2116.         putchar('^');
  2117.         putchar(*buf | 64);
  2118.         backspace();
  2119.         backspace();
  2120.     }
  2121.     else {
  2122.         putchar(*buf);
  2123.         backspace();
  2124.     }
  2125.     fflush(stdout);
  2126.     }
  2127. }
  2128. #endif
  2129.  
  2130. void
  2131. rubout()
  2132. {
  2133.     backspace();            /* do the old backspace, */
  2134.     putchar(' ');            /*   space, */
  2135.     backspace();            /*     backspace trick */
  2136. }
  2137.  
  2138. void
  2139. reprint()
  2140. {
  2141.     register char *s;
  2142.  
  2143.     fputs("^R\n",stdout) FLUSH;
  2144.     for (s = buf; *s; s++) {
  2145.     if (*s < ' ') {
  2146.         putchar('^');
  2147.         putchar(*s | 64);
  2148.     }
  2149.     else
  2150.         putchar(*s);
  2151.     }
  2152. }
  2153.  
  2154. #ifdef CLEAREOL
  2155. void
  2156. home_cursor()
  2157. {
  2158.     char *tgoto();
  2159.  
  2160.     if (!*HO) {            /* no home sequence? */
  2161.     if (!*CM) {        /* no cursor motion either? */
  2162.         fputs ("\n\n\n", stdout);
  2163.         return;        /* forget it. */
  2164.     }
  2165.     tputs (tgoto (CM, 0, 0), 1, putchr);    /* go to home via CM */
  2166.     return;
  2167.     }
  2168.     else {            /* we have home sequence */
  2169.     tputs (HO, 1, putchr);    /* home via HO */
  2170.     }
  2171. }
  2172. #endif CLEAREOL
  2173.  
  2174.  
  2175. void
  2176. line_col_calcs()
  2177. {
  2178.      if (LINES > 0) {            /* is this a crt? */
  2179.       if ((!initlines) || (!initlines_specified))
  2180.            /* no -i or unreasonable value for initlines */
  2181.            if (ospeed >= B9600)     /* whole page at >= 9600 baud */
  2182.             initlines = LINES;
  2183.            else if (ospeed >= B4800)/* 16 lines at 4800 */
  2184.             initlines = 16;
  2185.            else            /* otherwise just header */
  2186.             initlines = 8;
  2187.      }
  2188.      else {                /* not a crt */
  2189.       LINES = 30000;        /* so don't page */
  2190.       CL = "\n\n";            /* put a couple of lines between */
  2191.       if ((!initlines) || (!initlines_specified))
  2192.            /* make initlines reasonable */
  2193.            initlines = 8;
  2194.      }
  2195.      if (COLS <= 0)
  2196.       COLS = 80;
  2197. }
  2198.  
  2199.  
  2200. #ifdef SIGWINCH
  2201. int
  2202. winch_catcher()
  2203. {
  2204.      /* Come here if window size change signal received */
  2205. #ifdef TIOCGWINSZ
  2206.      struct winsize ws;
  2207.  
  2208.      if (ioctl(0, TIOCGWINSZ, &ws) >= 0 && ws.ws_row > 0 && ws.ws_col > 0) {
  2209.           LINES = ws.ws_row;
  2210.           COLS = ws.ws_col;
  2211.           line_col_calcs();
  2212.      }
  2213. #else
  2214.      ???????
  2215.      /* Well, if SIGWINCH is defined, but TIOCGWINSZ isn't, there's    */
  2216.      /* almost certainly something wrong.  Figure it out for yourself, */
  2217.      /* because I don't know now to deal :-)                           */
  2218. #endif
  2219. }
  2220. #endif
  2221. !STUFFY!FUNK!
  2222. echo Extracting search.c
  2223. cat >search.c <<'!STUFFY!FUNK!'
  2224. /* $Header: search.c,v 4.3.2.2 90/03/22 23:05:31 sob Exp $
  2225.  *
  2226.  * $Log:    search.c,v $
  2227.  * Revision 4.3.2.2  90/03/22  23:05:31  sob
  2228.  * Fixes provided by Wayne Davison <drivax!davison>
  2229.  * 
  2230.  * Revision 4.3.2.1  90/03/17  17:46:29  sob
  2231.  * Added changes to insure that null search strings won't result in core dumps
  2232.  * on non-VAX computers.
  2233.  * 
  2234.  * Revision 4.3  85/05/01  11:50:16  lwall
  2235.  * Baseline for release with 4.3bsd.
  2236.  * 
  2237.  */
  2238.  
  2239. /* string search routines */
  2240.  
  2241. /*        Copyright (c) 1981,1980 James Gosling        */
  2242.  
  2243. /* Modified Aug. 12, 1981 by Tom London to include regular expressions
  2244.    as in ed.  RE stuff hacked over by jag to correct a few major problems,
  2245.    mainly dealing with searching within the buffer rather than copying
  2246.    each line to a separate array.  Newlines can now appear in RE's */
  2247.  
  2248. /* Ripped to shreds and glued back together to make a search package,
  2249.  * July 6, 1984, by Larry Wall. (If it doesn't work, it's probably my fault.)
  2250.  * Changes include:
  2251.  *    Buffer, window, and mlisp stuff gone.
  2252.  *    Translation tables reduced to 1 table.
  2253.  *    Expression buffer is now dynamically allocated.
  2254.  *    Character classes now implemented with a bitmap.
  2255.  */
  2256.  
  2257. #include "EXTERN.h"
  2258. #include "common.h"
  2259. #include "util.h"
  2260. #include "INTERN.h"
  2261. #include "search.h"
  2262.  
  2263. #ifndef BITSPERBYTE
  2264. #define BITSPERBYTE 8
  2265. #endif
  2266.  
  2267. #define BMAPSIZ (127 / BITSPERBYTE + 1)
  2268.  
  2269. /* meta characters in the "compiled" form of a regular expression */
  2270. #define    CBRA    2        /* \( -- begin bracket */
  2271. #define    CCHR    4        /* a vanilla character */
  2272. #define    CDOT    6        /* . -- match anything except a newline */
  2273. #define    CCL    8        /* [...] -- character class */
  2274. #define    NCCL    10        /* [^...] -- negated character class */
  2275. #define    CDOL    12        /* $ -- matches the end of a line */
  2276. #define    CEND    14        /* The end of the pattern */
  2277. #define    CKET    16        /* \) -- close bracket */
  2278. #define    CBACK    18        /* \N -- backreference to the Nth bracketed
  2279.                    string */
  2280. #define CIRC    20        /* ^ matches the beginning of a line */
  2281.  
  2282. #define WORD    32        /* matches word character \w */
  2283. #define NWORD    34        /* matches non-word characer \W */
  2284. #define WBOUND    36        /* matches word boundary \b */
  2285. #define NWBOUND    38        /* matches non-(word boundary) \B */
  2286.  
  2287. #define    STAR    01        /* * -- Kleene star, repeats the previous
  2288.                    REas many times as possible; the value
  2289.                    ORs with the other operator types */
  2290.  
  2291. #define ASCSIZ 0200
  2292. typedef char    TRANSTABLE[ASCSIZ];
  2293.  
  2294. static    TRANSTABLE trans = {
  2295. 0000,0001,0002,0003,0004,0005,0006,0007,
  2296. 0010,0011,0012,0013,0014,0015,0016,0017,
  2297. 0020,0021,0022,0023,0024,0025,0026,0027,
  2298. 0030,0031,0032,0033,0034,0035,0036,0037,
  2299. 0040,0041,0042,0043,0044,0045,0046,0047,
  2300. 0050,0051,0052,0053,0054,0055,0056,0057,
  2301. 0060,0061,0062,0063,0064,0065,0066,0067,
  2302. 0070,0071,0072,0073,0074,0075,0076,0077,
  2303. 0100,0101,0102,0103,0104,0105,0106,0107,
  2304. 0110,0111,0112,0113,0114,0115,0116,0117,
  2305. 0120,0121,0122,0123,0124,0125,0126,0127,
  2306. 0130,0131,0132,0133,0134,0135,0136,0137,
  2307. 0140,0141,0142,0143,0144,0145,0146,0147,
  2308. 0150,0151,0152,0153,0154,0155,0156,0157,
  2309. 0160,0161,0162,0163,0164,0165,0166,0167,
  2310. 0170,0171,0172,0173,0174,0175,0176,0177,
  2311. };
  2312. static bool folding = FALSE;
  2313.  
  2314. static int err;
  2315. static char *FirstCharacter;
  2316.  
  2317. void
  2318. search_init()
  2319. {
  2320. #ifdef UNDEF
  2321.     register int    i;
  2322.     
  2323.     for (i = 0; i < ASCSIZ; i++)
  2324.     trans[i] = i;
  2325. #else
  2326.     ;
  2327. #endif
  2328. }
  2329.  
  2330. void
  2331. init_compex(compex)
  2332. register COMPEX *compex;
  2333. {
  2334.     /* the following must start off zeroed */
  2335.  
  2336.     compex->eblen = 0;
  2337.     compex->brastr = Nullch;
  2338. }
  2339.  
  2340. void
  2341. free_compex(compex)
  2342. register COMPEX *compex;
  2343. {
  2344.     if (compex->eblen) {
  2345.     free(compex->expbuf);
  2346.     compex->eblen = 0;
  2347.     }
  2348.     if (compex->brastr) {
  2349.     free(compex->brastr);
  2350.     compex->brastr = Nullch;
  2351.     }
  2352. }
  2353.  
  2354. static char *gbr_str = Nullch;
  2355. static int gbr_siz = 0;
  2356.  
  2357. char *
  2358. getbracket(compex,n)
  2359. register COMPEX *compex;
  2360. int n;
  2361. {
  2362.     int length = compex->braelist[n] - compex->braslist[n];
  2363.  
  2364.     if (!compex->nbra || n > compex->nbra || !compex->braelist[n] || length<0)
  2365.     return nullstr;
  2366.     growstr(&gbr_str, &gbr_siz, length+1);
  2367.     safecpy(gbr_str, compex->braslist[n], length+1);
  2368.     return gbr_str;
  2369. }
  2370.  
  2371. void
  2372. case_fold(which)
  2373. int which;
  2374. {
  2375.     register int i;
  2376.  
  2377.     if (which != folding) {
  2378.     if (which) {
  2379.         for (i = 'A'; i <= 'Z'; i++)
  2380.         trans[i] = tolower(i);
  2381.     }
  2382.     else {
  2383.         for (i = 'A'; i <= 'Z'; i++)
  2384.         trans[i] = i;
  2385.     }
  2386.     folding = which;
  2387.     }
  2388. }
  2389.  
  2390. /* Compile the given regular expression into a [secret] internal format */
  2391.  
  2392. char *
  2393. compile (compex, strp, RE, fold)
  2394. register COMPEX *compex;
  2395. register char   *strp;
  2396. int RE;
  2397. int fold;
  2398. {
  2399.     register int c;
  2400.     register char  *ep;
  2401.     char   *lastep;
  2402.     char    bracket[NBRA],
  2403.        *bracketp;
  2404.     char **alt = compex->alternatives;
  2405.     char *retmes = "Badly formed search string";
  2406.  
  2407.     case_fold(compex->do_folding = fold);
  2408.     if (!compex->eblen) {
  2409.     compex->expbuf = safemalloc(84);
  2410.     compex->eblen = 80;
  2411.     }
  2412.     ep = compex->expbuf;        /* point at expression buffer */
  2413.     *alt++ = ep;            /* first alternative starts here */
  2414.     bracketp = bracket;            /* first bracket goes here */
  2415.     if (*strp == 0) {            /* nothing to compile? */
  2416.     if (*ep == 0)            /* nothing there yet? */
  2417.         return "Null search string";
  2418.     return Nullch;            /* just keep old expression */
  2419.     }
  2420.     compex->nbra = 0;            /* no brackets yet */
  2421.     lastep = 0;
  2422.     for (;;) {
  2423.     if (ep - compex->expbuf >= compex->eblen)
  2424.         grow_eb(compex);
  2425.     c = *strp++;            /* fetch next char of pattern */
  2426.     if (c == 0) {            /* end of pattern? */
  2427.         if (bracketp != bracket) {    /* balanced brackets? */
  2428. #ifdef VERBOSE
  2429.         retmes = "Unbalanced parens";
  2430. #endif
  2431.         goto cerror;
  2432.         }
  2433.         *ep++ = CEND;        /* terminate expression */
  2434.         *alt++ = 0;            /* terminal alternative list */
  2435.         /*
  2436.         compex->eblen = ep - compex->expbuf + 1;
  2437.         compex->expbuf = saferealloc(compex->expbuf,compex->eblen+4); */
  2438.         return Nullch;        /* return success */
  2439.     }
  2440.     if (c != '*')
  2441.         lastep = ep;
  2442.     if (!RE) {            /* just a normal search string? */
  2443.         *ep++ = CCHR;        /* everything is a normal char */
  2444.         *ep++ = c;
  2445.     }
  2446.     else                /* it is a regular expression */
  2447.         switch (c) {
  2448.  
  2449.         case '\\':        /* meta something */
  2450.             switch (c = *strp++) {
  2451.             case '(':
  2452.             if (compex->nbra >= NBRA) {
  2453. #ifdef VERBOSE
  2454.                 retmes = "Too many parens";
  2455. #endif
  2456.                 goto cerror;
  2457.             }
  2458.             *bracketp++ = ++compex->nbra;
  2459.             *ep++ = CBRA;
  2460.             *ep++ = compex->nbra;
  2461.             break;
  2462.             case '|':
  2463.             if (bracketp>bracket) {
  2464. #ifdef VERBOSE
  2465.                 retmes = "No \\| in parens";    /* Alas! */
  2466. #endif
  2467.                 goto cerror;
  2468.             }
  2469.             *ep++ = CEND;
  2470.             *alt++ = ep;
  2471.             break;
  2472.             case ')':
  2473.             if (bracketp <= bracket) {
  2474. #ifdef VERBOSE
  2475.                 retmes = "Unmatched right paren";
  2476. #endif
  2477.                 goto cerror;
  2478.             }
  2479.             *ep++ = CKET;
  2480.             *ep++ = *--bracketp;
  2481.             break;
  2482.             case 'w':
  2483.             *ep++ = WORD;
  2484.             break;
  2485.             case 'W':
  2486.             *ep++ = NWORD;
  2487.             break;
  2488.             case 'b':
  2489.             *ep++ = WBOUND;
  2490.             break;
  2491.             case 'B':
  2492.             *ep++ = NWBOUND;
  2493.             break;
  2494.             case '0': case '1': case '2': case '3': case '4':
  2495.             case '5': case '6': case '7': case '8': case '9':
  2496.             *ep++ = CBACK;
  2497.             *ep++ = c - '0';
  2498.             break;
  2499.             default:
  2500.             *ep++ = CCHR;
  2501.             if (c == '\0')
  2502.                 goto cerror;
  2503.             *ep++ = c;
  2504.             break;
  2505.             }
  2506.             break;
  2507.         case '.':
  2508.             *ep++ = CDOT;
  2509.             continue;
  2510.  
  2511.         case '*':
  2512.             if (lastep == 0 || *lastep == CBRA || *lastep == CKET
  2513.             || *lastep == CIRC
  2514.             || (*lastep&STAR)|| *lastep>NWORD)
  2515.             goto defchar;
  2516.             *lastep |= STAR;
  2517.             continue;
  2518.  
  2519.         case '^':
  2520.             if (ep != compex->expbuf && ep[-1] != CEND)
  2521.             goto defchar;
  2522.             *ep++ = CIRC;
  2523.             continue;
  2524.  
  2525.         case '$':
  2526.             if (*strp != 0 && (*strp != '\\' || strp[1] != '|'))
  2527.             goto defchar;
  2528.             *ep++ = CDOL;
  2529.             continue;
  2530.  
  2531.         case '[': {        /* character class */
  2532.             register int i;
  2533.             
  2534.             if (ep - compex->expbuf >= compex->eblen - BMAPSIZ)
  2535.             grow_eb(compex);    /* reserve bitmap */
  2536.             for (i = BMAPSIZ; i; --i)
  2537.             ep[i] = 0;
  2538.             
  2539.             if ((c = *strp++) == '^') {
  2540.             c = *strp++;
  2541.             *ep++ = NCCL;    /* negated */
  2542.             }
  2543.             else
  2544.             *ep++ = CCL;    /* normal */
  2545.             
  2546.             i = 0;        /* remember oldchar */
  2547.             do {
  2548.             if (c == '\0') {
  2549. #ifdef VERBOSE
  2550.                 retmes = "Missing ]";
  2551. #endif
  2552.                 goto cerror;
  2553.             }
  2554.             if (*strp == '-' && *(++strp))
  2555.                 i = *strp++;
  2556.             else
  2557.                 i = c;
  2558.             while (c <= i) {
  2559.                 ep[c / BITSPERBYTE] |= 1 << (c % BITSPERBYTE);
  2560.                 if (fold && isalpha(c))
  2561.                 ep[(c ^ 32) / BITSPERBYTE] |=
  2562.                     1 << ((c ^ 32) % BITSPERBYTE);
  2563.                     /* set the other bit too */
  2564.                 c++;
  2565.             }
  2566.             } while ((c = *strp++) != ']');
  2567.             ep += BMAPSIZ;
  2568.             continue;
  2569.         }
  2570.  
  2571.         defchar:
  2572.         default:
  2573.             *ep++ = CCHR;
  2574.             *ep++ = c;
  2575.         }
  2576.     }
  2577. cerror:
  2578.     compex->expbuf[0] = 0;
  2579.     compex->nbra = 0;
  2580.     return retmes;
  2581. }
  2582.  
  2583. void
  2584. grow_eb(compex)
  2585. register COMPEX *compex;
  2586. {
  2587.     compex->eblen += 80;
  2588.     compex->expbuf = saferealloc(compex->expbuf, (MEM_SIZE)compex->eblen + 4);
  2589. }
  2590.  
  2591. char *
  2592. execute (compex, addr)
  2593. register COMPEX *compex;
  2594. char *addr;
  2595. {
  2596.     register char *p1 = addr;
  2597.     register char *trt = trans;
  2598.     register int c;
  2599.  
  2600.     if (addr == Nullch || compex->expbuf == Nullch)
  2601.     return Nullch;
  2602.     if (compex->nbra) {            /* any brackets? */
  2603.     for (c = 0; c <= compex->nbra; c++)
  2604.         compex->braslist[c] = compex->braelist[c] = Nullch;
  2605.     if (compex->brastr)
  2606.         free(compex->brastr);
  2607.     compex->brastr = savestr(p1);    /* in case p1 is not static */
  2608.     p1 = compex->brastr;        /* ! */
  2609.     }
  2610.     case_fold(compex->do_folding);    /* make sure table is correct */
  2611.     FirstCharacter = p1;        /* for ^ tests */
  2612.     if (compex->expbuf[0] == CCHR && !compex->alternatives[1]) {
  2613.     c = trt[compex->expbuf[1]];    /* fast check for first character */
  2614.     do {
  2615.         if (trt[*p1] == c && advance (compex, p1, compex->expbuf))
  2616.         return p1;
  2617.         p1++;
  2618.     } while (*p1 && !err);
  2619.     return Nullch;
  2620.     }
  2621.     else {            /* regular algorithm */
  2622.     do {
  2623.         register char **alt = compex->alternatives;
  2624.         while (*alt) {
  2625.         if (advance (compex, p1, *alt++))
  2626.             return p1;
  2627.         }
  2628.         p1++;
  2629.     } while (*p1 && !err);
  2630.     return Nullch;
  2631.     }
  2632. }
  2633.  
  2634. /* advance the match of the regular expression starting at ep along the
  2635.    string lp, simulates an NDFSA */
  2636. bool
  2637. advance (compex, lp, ep)
  2638. register COMPEX *compex;
  2639. register char *ep;
  2640. register char *lp;
  2641. {
  2642.     register char *curlp;
  2643.     register char *trt = trans;
  2644.     register int i;
  2645.  
  2646.     while ((*ep & STAR) || *lp || *ep == CIRC || *ep == CKET)
  2647.     switch (*ep++) {
  2648.  
  2649.         case CCHR:
  2650.         if (trt[*ep++] != trt[*lp]) return FALSE;
  2651.         lp++;
  2652.         continue;
  2653.  
  2654.         case CDOT:
  2655.         if (*lp == '\n') return FALSE;
  2656.         lp++;
  2657.         continue;
  2658.  
  2659.         case CDOL:
  2660.         if (!*lp || *lp == '\n')
  2661.             continue;
  2662.         return FALSE;
  2663.  
  2664.         case CIRC:
  2665.         if (lp == FirstCharacter || lp[-1]=='\n')
  2666.             continue;
  2667.         return FALSE;
  2668.  
  2669.         case WORD:
  2670.         if (isalnum(*lp)) {
  2671.             lp++;
  2672.             continue;
  2673.         }
  2674.         return FALSE;
  2675.  
  2676.         case NWORD:
  2677.         if (!isalnum(*lp)) {
  2678.             lp++;
  2679.             continue;
  2680.         }
  2681.         return FALSE;
  2682.  
  2683.         case WBOUND:
  2684.         if ((lp == FirstCharacter || !isalnum(lp[-1])) !=
  2685.             (!*lp || !isalnum(*lp)) )
  2686.             continue;
  2687.         return FALSE;
  2688.  
  2689.         case NWBOUND:
  2690.         if ((lp == FirstCharacter || !isalnum(lp[-1])) ==
  2691.             (!*lp || !isalnum(*lp)))
  2692.             continue;
  2693.         return FALSE;
  2694.  
  2695.         case CEND:
  2696.         return TRUE;
  2697.  
  2698.         case CCL:
  2699.         if (cclass (ep, *lp, 1)) {
  2700.             ep += BMAPSIZ;
  2701.             lp++;
  2702.             continue;
  2703.         }
  2704.         return FALSE;
  2705.  
  2706.         case NCCL:
  2707.         if (cclass (ep, *lp, 0)) {
  2708.             ep += BMAPSIZ;
  2709.             lp++;
  2710.             continue;
  2711.         }
  2712.         return FALSE;
  2713.  
  2714.         case CBRA:
  2715.         compex->braslist[*ep++] = lp;
  2716.         continue;
  2717.  
  2718.         case CKET:
  2719.         i = *ep++;
  2720.         compex->braelist[i] = lp;
  2721.         compex->braelist[0] = lp;
  2722.         compex->braslist[0] = compex->braslist[i];
  2723.         continue;
  2724.  
  2725.         case CBACK:
  2726.         if (compex->braelist[i = *ep++] == 0) {
  2727.             fputs("bad braces\n",stdout) FLUSH;
  2728.             err = TRUE;
  2729.             return FALSE;
  2730.         }
  2731.         if (backref (compex, i, lp)) {
  2732.             lp += compex->braelist[i] - compex->braslist[i];
  2733.             continue;
  2734.         }
  2735.         return FALSE;
  2736.  
  2737.         case CBACK | STAR:
  2738.         if (compex->braelist[i = *ep++] == 0) {
  2739.             fputs("bad braces\n",stdout) FLUSH;
  2740.             err = TRUE;
  2741.             return FALSE;
  2742.         }
  2743.         curlp = lp;
  2744.         while (backref (compex, i, lp)) {
  2745.             lp += compex->braelist[i] - compex->braslist[i];
  2746.         }
  2747.         while (lp >= curlp) {
  2748.             if (advance (compex, lp, ep))
  2749.             return TRUE;
  2750.             lp -= compex->braelist[i] - compex->braslist[i];
  2751.         }
  2752.         continue;
  2753.  
  2754.         case CDOT | STAR:
  2755.         curlp = lp;
  2756.         while (*lp++ && lp[-1] != '\n');
  2757.         goto star;
  2758.  
  2759.         case WORD | STAR:
  2760.         curlp = lp;
  2761.         while (*lp++ && isalnum(lp[-1]));
  2762.         goto star;
  2763.  
  2764.         case NWORD | STAR:
  2765.         curlp = lp;
  2766.         while (*lp++ && !isalnum(lp[-1]));
  2767.         goto star;
  2768.  
  2769.         case CCHR | STAR:
  2770.         curlp = lp;
  2771.         while (*lp++ && trt[lp[-1]] == trt[*ep]);
  2772.         ep++;
  2773.         goto star;
  2774.  
  2775.         case CCL | STAR:
  2776.         case NCCL | STAR:
  2777.         curlp = lp;
  2778.         while (*lp++ && cclass (ep, lp[-1], ep[-1] == (CCL | STAR)));
  2779.         ep += BMAPSIZ;
  2780.         goto star;
  2781.  
  2782.     star:
  2783.         do {
  2784.             lp--;
  2785.             if (advance (compex, lp, ep))
  2786.             return TRUE;
  2787.         } while (lp > curlp);
  2788.         return FALSE;
  2789.  
  2790.         default:
  2791.         fputs("Badly compiled pattern\n",stdout) FLUSH;
  2792.         err = TRUE;
  2793.         return -1;
  2794.     }
  2795.     if (*ep == CEND || *ep == CDOL) {
  2796.         return TRUE;
  2797.     }
  2798.     return FALSE;
  2799. }
  2800.  
  2801. bool
  2802. backref (compex, i, lp)
  2803. register COMPEX *compex;
  2804. register int i;
  2805. register char *lp;
  2806. {
  2807.     register char *bp;
  2808.  
  2809.     bp = compex->braslist[i];
  2810.     while (*lp && *bp == *lp) {
  2811.     bp++;
  2812.     lp++;
  2813.     if (bp >= compex->braelist[i])
  2814.         return TRUE;
  2815.     }
  2816.     return FALSE;
  2817. }
  2818.  
  2819. bool
  2820. cclass (set, c, af)
  2821. register char  *set;
  2822. register int c;
  2823. {
  2824.     c &= 0177;
  2825. #if BITSPERBYTE == 8
  2826.     if (set[c >> 3] & 1 << (c & 7))
  2827. #else
  2828.     if (set[c / BITSPERBYTE] & 1 << (c % BITSPERBYTE))
  2829. #endif
  2830.     return af;
  2831.     return !af;
  2832. }
  2833. !STUFFY!FUNK!
  2834. echo Extracting artsrch.h
  2835. cat >artsrch.h <<'!STUFFY!FUNK!'
  2836. /* $Header: artsrch.h,v 4.3 85/05/01 11:35:55 lwall Exp $
  2837.  *
  2838.  * $Log:    artsrch.h,v $
  2839.  * Revision 4.3  85/05/01  11:35:55  lwall
  2840.  * Baseline for release with 4.3bsd.
  2841.  * 
  2842.  */
  2843.  
  2844. #ifndef NBRA
  2845. #include "search.h"
  2846. #endif
  2847.  
  2848. #ifdef ARTSEARCH
  2849.  
  2850. #define SRCH_ABORT 0
  2851. #define SRCH_INTR 1
  2852. #define SRCH_FOUND 2
  2853. #define SRCH_NOTFOUND 3
  2854. #define SRCH_DONE 4
  2855. #define SRCH_SUBJDONE 5
  2856. #define SRCH_ERROR 6
  2857. #endif
  2858.  
  2859. EXT char *lastpat INIT(nullstr);    /* last search pattern */
  2860. #ifdef ARTSEARCH
  2861.     EXT COMPEX sub_compex;        /* last compiled subject search */
  2862.     EXT COMPEX art_compex;        /* last compiled normal search */
  2863. #   ifdef CONDSUB
  2864.     EXT COMPEX *bra_compex INIT(&art_compex);
  2865.                     /* current compex with brackets */
  2866. #   endif
  2867.     EXT char art_howmuch;        /* search just the subjects */
  2868.     EXT bool art_doread;        /* search read articles? */
  2869. #endif
  2870.  
  2871. void    artsrch_init();
  2872. #ifdef ARTSEARCH
  2873.     int        art_search();
  2874.     bool    wanted();    /* return TRUE if current article matches pattern */
  2875. #endif
  2876. !STUFFY!FUNK!
  2877. echo ""
  2878. echo "End of kit 4 (of 9)"
  2879. cat /dev/null >kit4isdone
  2880. config=true
  2881. for iskit in 1 2 3 4 5 6 7 8 9 ; do
  2882.     if test -f kit${iskit}isdone; then
  2883.     echo "You have run kit ${iskit}."
  2884.     else
  2885.     echo "You still need to run kit ${iskit}."
  2886.     config=false
  2887.     fi
  2888. done
  2889. case $config in
  2890.     true)
  2891.     echo "You have run all your kits.  Please read README and then type Configure."
  2892.     chmod 755 Configure
  2893.     ;;
  2894. esac
  2895. : I do not append .signature, but someone might mail this.
  2896. exit
  2897.