diplodocus.org Git - nmh/blob - docs/historical/mh-6.8.5/uip/RCS/mhlsbr.c,v

   1 head    1.30;
   2 access;
   3 symbols;
   4 locks; strict;
   5 comment @ * @;
   6
   7
   8 1.30
   9 date    95.12.08.17.57.16;      author jromine; state Exp;
  10 branches;
  11 next    1.29;
  12
  13 1.29
  14 date    93.08.20.15.50.44;      author jromine; state Exp;
  15 branches;
  16 next    1.28;
  17
  18 1.28
  19 date    92.12.15.00.20.22;      author jromine; state Exp;
  20 branches;
  21 next    1.27;
  22
  23 1.27
  24 date    92.12.03.16.50.27;      author jromine; state Exp;
  25 branches;
  26 next    1.26;
  27
  28 1.26
  29 date    92.12.03.16.28.56;      author jromine; state Exp;
  30 branches;
  31 next    1.25;
  32
  33 1.25
  34 date    92.11.18.00.19.56;      author jromine; state Exp;
  35 branches;
  36 next    1.24;
  37
  38 1.24
  39 date    92.11.18.00.19.00;      author jromine; state Exp;
  40 branches;
  41 next    1.23;
  42
  43 1.23
  44 date    92.11.17.00.03.06;      author jromine; state Exp;
  45 branches;
  46 next    1.22;
  47
  48 1.22
  49 date    92.10.26.23.00.16;      author jromine; state Exp;
  50 branches;
  51 next    1.21;
  52
  53 1.21
  54 date    92.10.16.21.36.54;      author jromine; state Exp;
  55 branches;
  56 next    1.20;
  57
  58 1.20
  59 date    92.02.10.20.30.11;      author jromine; state Exp;
  60 branches;
  61 next    1.19;
  62
  63 1.19
  64 date    92.02.10.20.11.37;      author jromine; state Exp;
  65 branches;
  66 next    1.18;
  67
  68 1.18
  69 date    92.02.05.07.26.30;      author jromine; state Exp;
  70 branches;
  71 next    1.17;
  72
  73 1.17
  74 date    92.01.31.22.12.40;      author jromine; state Exp;
  75 branches;
  76 next    1.16;
  77
  78 1.16
  79 date    91.01.25.14.49.46;      author mh;      state Exp;
  80 branches;
  81 next    1.15;
  82
  83 1.15
  84 date    91.01.16.08.56.04;      author mh;      state Exp;
  85 branches;
  86 next    1.14;
  87
  88 1.14
  89 date    90.04.05.14.58.08;      author sources; state Exp;
  90 branches;
  91 next    1.13;
  92
  93 1.13
  94 date    90.03.23.15.02.52;      author sources; state Exp;
  95 branches;
  96 next    1.12;
  97
  98 1.12
  99 date    90.03.22.13.59.45;      author sources; state Exp;
 100 branches;
 101 next    1.11;
 102
 103 1.11
 104 date    90.03.20.22.30.10;      author sources; state Exp;
 105 branches;
 106 next    1.10;
 107
 108 1.10
 109 date    90.03.20.10.36.09;      author sources; state Exp;
 110 branches;
 111 next    1.9;
 112
 113 1.9
 114 date    90.02.06.13.20.49;      author sources; state Exp;
 115 branches;
 116 next    1.8;
 117
 118 1.8
 119 date    90.02.05.14.57.13;      author sources; state Exp;
 120 branches;
 121 next    1.7;
 122
 123 1.7
 124 date    90.02.05.14.24.31;      author sources; state Exp;
 125 branches;
 126 next    1.6;
 127
 128 1.6
 129 date    90.02.05.14.00.22;      author sources; state Exp;
 130 branches;
 131 next    1.5;
 132
 133 1.5
 134 date    90.02.05.13.59.39;      author sources; state Exp;
 135 branches;
 136 next    1.4;
 137
 138 1.4
 139 date    90.01.31.14.19.17;      author sources; state Exp;
 140 branches;
 141 next    1.3;
 142
 143 1.3
 144 date    90.01.26.15.55.57;      author sources; state Exp;
 145 branches;
 146 next    1.2;
 147
 148 1.2
 149 date    89.11.17.16.12.25;      author sources; state Exp;
 150 branches;
 151 next    1.1;
 152
 153 1.1
 154 date    89.11.17.16.10.27;      author sources; state Exp;
 155 branches;
 156 next    ;
 157
 158
 159 desc
 160 @@
 161
 162
 163 1.30
 164 log
 165 @fixup fmtscan newline for #ifdef JLR
 166 @
 167 text
 168 @/* mhlsbr.c - implement the "nifty" message lister */
 169 #ifndef lint
 170 static char ident[] = "@@(#)$Id: mhlsbr.c,v 1.29 1993/08/20 15:50:44 jromine Exp jromine $";
 171 #endif  /* lint */
 172
 173 #include "../h/mh.h"
 174 #include "../h/addrsbr.h"
 175 #include "../h/formatsbr.h"
 176 #include "../zotnet/tws.h"
 177 #ifdef SVR4
 178 #undef  NULLVP          /* XXX  */
 179 #endif
 180 #if     defined(SYS5) && defined(AUX)
 181 #define u_short ushort
 182 #define u_long  ulong
 183 #endif
 184 #include <ctype.h>
 185 #include <setjmp.h>
 186 #include <signal.h>
 187 #include <stdio.h>
 188 #include <sys/types.h>
 189 #include <sys/stat.h>
 190
 191
 192 /* MAJOR BUG:
 193    for a component containing addresses, ADDRFMT, if COMPRESS is also
 194    set, then addresses get split wrong (not at the spaces between commas).
 195    To fix this correctly, putstr() should know about "atomic" strings that
 196    must NOT be broken across lines.  That's too difficult for right now
 197    (it turns out that there are a number of degernate cases), so in
 198    oneline(), instead of
 199
 200                      (*onelp == '\n' && !onelp[1])
 201
 202    being a terminating condition,
 203
 204          (*onelp == '\n' && (!onelp[1] || (flags & ADDRFMT)))
 205
 206    is used instead.  This cuts the line prematurely, and gives us a much
 207    better chance of getting things right.
 208  */
 209
 210
 211 #ifdef  SYS5
 212 #define u_short ushort
 213 #endif  /* SYS5 */
 214
 215 #define ONECOMP         0
 216 #define TWOCOMP         1
 217 #define BODYCOMP        2
 218
 219 #define adios   mhladios
 220 #define done    mhldone
 221
 222 #define QUOTE   '\\'
 223
 224 /* \f */
 225
 226 static struct swit mhlswitches[] = {
 227 #define BELLSW  0
 228     "bell", 0,
 229 #define NBELLSW 1
 230     "nobell", 0,
 231
 232 #define CLRSW   2
 233     "clear", 0,
 234 #define NCLRSW  3
 235     "noclear", 0,
 236
 237 #define FACESW  4
 238     "faceproc program", 0,
 239 #define NFACESW 5
 240     "nofaceproc", 0,
 241
 242 #define FOLDSW  6
 243     "folder +folder", 0,
 244 #define FORMSW  7
 245     "form formfile", 0,
 246
 247 #define PROGSW  8
 248     "moreproc program", 0,
 249 #define NPROGSW 9
 250     "nomoreproc", 0,
 251
 252 #define LENSW   10
 253     "length lines", 0,
 254 #define WIDSW   11
 255     "width columns", 0,
 256
 257 #define SLEEPSW 12
 258     "sleep seconds",  0,
 259
 260 #define DASHSW  13
 261     "dashmunging", -4,
 262 #define NDASHSW 14
 263     "nodashmunging", -6,
 264
 265 #define HELPSW  15
 266     "help", 4,
 267
 268 #define FORW1SW 16
 269     "forward", -7,              /* interface from forw */
 270 #define FORW2SW 17
 271     "forwall", -7,              /*   .. */
 272 #define DGSTSW  18
 273     "digest list", -6,
 274 #define VOLUMSW 19
 275     "volume number", -6,
 276 #define ISSUESW 20
 277     "issue number", -5,
 278 #define NBODYSW 21
 279     "nobody", -6,
 280
 281     NULL, 0
 282 };
 283
 284 /* \f */
 285
 286 struct mcomp {
 287     char   *c_name;             /* component name                       */
 288     char   *c_text;             /* component text                       */
 289     char   *c_ovtxt;            /* text overflow indicator              */
 290     char   *c_nfs;              /* iff FORMAT                           */
 291     struct format *c_fmt;       /*   ..                                 */
 292     char   *c_face;             /* face designator                      */
 293
 294     int     c_offset;           /* left margin indentation              */
 295     int     c_ovoff;            /* overflow indentation                 */
 296     int     c_width;            /* width of field                       */
 297     int     c_cwidth;           /* width of component                   */
 298     int     c_length;           /* length in lines                      */
 299
 300     long   c_flags;
 301 #define NOCOMPONENT     0x000001/* don't show component name            */
 302 #define UPPERCASE       0x000002/* display in all upper case            */
 303 #define CENTER          0x000004/* center line                          */
 304 #define CLEARTEXT       0x000008/* cleartext                            */
 305 #define EXTRA           0x000010/* an "extra" component                 */
 306 #define HDROUTPUT       0x000020/* already output                       */
 307 #define CLEARSCR        0x000040/* clear screen                         */
 308 #define LEFTADJUST      0x000080/* left justify multiple lines          */
 309 #define COMPRESS        0x000100/* compress text                        */
 310 #define ADDRFMT         0x000200/* contains addresses                   */
 311 #define BELL            0x000400/* sound bell at EOP                    */
 312 #define DATEFMT         0x000800/* contains dates                       */
 313 #define FORMAT          0x001000/* parse address/date                   */
 314 #define INIT            0x002000/* initialize component                 */
 315 #define FACEFMT         0x004000/* contains face                        */
 316 #define FACEDFLT        0x008000/* default for face                     */
 317 #define SPLIT           0x010000/* split headers (don't concatenate)    */
 318 #define NONEWLINE       0x020000/* don't write trailing newline         */
 319 #define LBITS   "\020\01NOCOMPONENT\02UPPERCASE\03CENTER\04CLEARTEXT\05EXTRA\06HDROUTPUT\07CLEARSCR\010LEFTADJUST\011COMPRESS\012ADDRFMT\013BELL\014DATEFMT\015FORMAT\016INIT\017FACEFMT\020FACEDFLT\021SPLIT\022NONEWLINE"
 320 #define GFLAGS  (NOCOMPONENT | UPPERCASE | CENTER | LEFTADJUST | COMPRESS \
 321                         | SPLIT)
 322
 323     struct mcomp *c_next;
 324 };
 325
 326 static struct mcomp *msghd = NULL;
 327 static struct mcomp *msgtl = NULL;
 328 static struct mcomp *fmthd = NULL;
 329 static struct mcomp *fmttl = NULL;
 330
 331 static struct mcomp global = {
 332     NULL, NULL, "", NULL, NULL, 0, -1, 80, -1, 40, BELL, 0
 333 };
 334 static struct mcomp  holder =
 335 {
 336     NULL, NULL, NULL, NULL, NULL, 0, 0, 0, 0, 0, NOCOMPONENT, 0
 337 };
 338
 339
 340 static struct pair {
 341     char   *p_name;
 342     long    p_flags;
 343 }                   pairs[] = {
 344                         "Date", DATEFMT,
 345                         "From", ADDRFMT | FACEDFLT,
 346                         "Sender", ADDRFMT,
 347                         "Reply-To", ADDRFMT,
 348                         "To", ADDRFMT,
 349                         "cc", ADDRFMT,
 350                         "Bcc", ADDRFMT,
 351                         "Resent-Date", DATEFMT,
 352                         "Resent-From", ADDRFMT,
 353                         "Resent-Sender", ADDRFMT,
 354                         "Resent-Reply-To", ADDRFMT,
 355                         "Resent-To", ADDRFMT,
 356                         "Resent-cc", ADDRFMT,
 357                         "Resent-Bcc", ADDRFMT,
 358                         "Face", FACEFMT,
 359
 360                         NULL
 361 };
 362
 363 static struct triple {
 364     char   *t_name;
 365     long    t_on;
 366     long    t_off;
 367 }                       triples[] = {
 368                             "nocomponent", NOCOMPONENT, 0,
 369                             "uppercase", UPPERCASE, 0,
 370                             "nouppercase", 0, UPPERCASE,
 371                             "center", CENTER, 0,
 372                             "nocenter", 0, CENTER,
 373                             "clearscreen", CLEARSCR, 0,
 374                             "noclearscreen", 0, CLEARSCR,
 375                             "noclear", 0, CLEARSCR,
 376                             "leftadjust", LEFTADJUST, 0,
 377                             "noleftadjust", 0, LEFTADJUST,
 378                             "compress", COMPRESS, 0,
 379                             "nocompress", 0, COMPRESS,
 380                             "split", SPLIT, 0,
 381                             "nosplit", 0, SPLIT,
 382                             "addrfield", ADDRFMT, DATEFMT,
 383                             "bell", BELL, 0,
 384                             "nobell", 0, BELL,
 385                             "datefield", DATEFMT, ADDRFMT,
 386                             "newline", 0, NONEWLINE,
 387                             "nonewline", NONEWLINE, 0,
 388
 389                             NULL
 390 };
 391
 392 /* \f */
 393
 394 static int  bellflg = 0;
 395 static int  clearflg = 0;
 396 static int  dashflg = 1;
 397 static int  dobody = 1;
 398 static int  forwflg = 0;
 399 static int  forwall = 0;
 400
 401 static int  sleepsw = NOTOK;
 402
 403 static char *digest = NULL;
 404 static int  volume = 0;
 405 static int  issue = 0;
 406
 407 static int  exitstat = 0;
 408 static int  mhldebug = 0;
 409
 410 #define PITTY   (-1)
 411 #define NOTTY   0
 412 #define ISTTY   1
 413 static int  ontty = NOTTY;
 414
 415 static int  row;
 416 static int  column;
 417
 418 static int  lm;
 419 static int  llim;
 420 static int  ovoff;
 421 static int  term;
 422 static int  wid;
 423
 424
 425 static char *ovtxt;
 426
 427 static char *onelp;
 428
 429
 430 static char *parptr;
 431 static char *ignores[MAXARGS];
 432
 433
 434 static  jmp_buf env;
 435 static  jmp_buf mhlenv;
 436
 437
 438 static char delim3[] =          /* from forw.c */
 439     "\n----------------------------------------------------------------------\n\n";
 440 static char delim4[] = "\n------------------------------\n\n";
 441
 442
 443 static  FP (*mhl_action) () = (FP (*) ()) 0;
 444
 445
 446 static void     mhladios (), mhldone ();
 447 static TYPESIG  intrser (), pipeser (), quitser ();
 448 static char   *mcomp_add (), *oneline (), *parse ();
 449 static struct mcomp *add_queue ();
 450
 451 static  mhl_format(), evalvar(), process(), mhlfile(), free_queue(), putcomp();
 452 static  putstr(), putch(), face_format(), m_popen();
 453 static int      ptoi(), ptos(), doface();
 454
 455 void    clear_screen ();
 456
 457 /* \f */
 458
 459 /* ARGSUSED */
 460
 461 int     mhl (argc, argv)
 462 int     argc;
 463 char   *argv[];
 464 {
 465     int     length = 0,
 466             nomore = 0,
 467             width = 0,
 468             vecp = 0,
 469             i;
 470     register char   *cp,
 471                     *folder = NULL,
 472                     *form = NULL,
 473                     **ap,
 474                     **argp;
 475     char    buf[80],
 476            *arguments[MAXARGS],
 477            *files[MAXARGS];
 478
 479     invo_name = r1bindex (argv[0], '/');
 480     if ((cp = getenv ("MHLDEBUG")) && *cp)
 481         mhldebug++;
 482     if ((cp = m_find (invo_name)) != NULL) {
 483         ap = brkstring (getcpy (cp), " ", "\n");
 484         ap = copyip (ap, arguments);
 485     }
 486     else
 487         ap = arguments;
 488     (void) copyip (argv + 1, ap);
 489     argp = arguments;
 490
 491 /* \f */
 492
 493     if (cp = getenv ("FACEPROC"))
 494         faceproc = cp;
 495
 496     vecp = 0;
 497     while (cp = *argp++) {
 498         if (*cp == '-')
 499             switch (smatch (++cp, mhlswitches)) {
 500                 case AMBIGSW:
 501                     ambigsw (cp, mhlswitches);
 502                     done (1);
 503                 case UNKWNSW:
 504                     adios (NULLCP, "-%s unknown\n", cp);
 505                 case HELPSW:
 506                     (void) sprintf (buf, "%s [switches] [files ...]",
 507                             invo_name);
 508                     help (buf, mhlswitches);
 509                     done (1);
 510
 511                 case BELLSW:
 512                     bellflg = 1;
 513                     continue;
 514                 case NBELLSW:
 515                     bellflg = -1;
 516                     continue;
 517
 518                 case CLRSW:
 519                     clearflg = 1;
 520                     continue;
 521                 case NCLRSW:
 522                     clearflg = -1;
 523                     continue;
 524
 525                 case FOLDSW:
 526                     if (!(folder = *argp++) || *folder == '-')
 527                         adios (NULLCP, "missing argument to %s", argp[-2]);
 528                     continue;
 529                 case FORMSW:
 530                     if (!(form = *argp++) || *form == '-')
 531                         adios (NULLCP, "missing argument to %s", argp[-2]);
 532                     continue;
 533
 534                 case FACESW:
 535                     if (!(faceproc = *argp++) || *faceproc == '-')
 536                         adios (NULLCP, "missing argument to %s", argp[-2]);
 537                     continue;
 538                 case NFACESW:
 539                     faceproc = NULL;
 540                     continue;
 541                 case SLEEPSW:
 542                     if (!(cp = *argp++) || *cp == '-')
 543                         adios (NULLCP, "missing argument to %s", argp[-2]);
 544                     sleepsw = atoi (cp);/* ZERO ok! */
 545                     continue;
 546
 547                 case PROGSW:
 548                     if (!(moreproc = *argp++) || *moreproc == '-')
 549                         adios (NULLCP, "missing argument to %s", argp[-2]);
 550                     continue;
 551                 case NPROGSW:
 552                     nomore++;
 553                     continue;
 554
 555                 case LENSW:
 556                     if (!(cp = *argp++) || *cp == '-')
 557                         adios (NULLCP, "missing argument to %s", argp[-2]);
 558                     if ((length = atoi (cp)) < 1)
 559                         adios (NULLCP, "bad argument %s %s", argp[-2], cp);
 560                     continue;
 561                 case WIDSW:
 562                     if (!(cp = *argp++) || *cp == '-')
 563                         adios (NULLCP, "missing argument to %s", argp[-2]);
 564                     if ((width = atoi (cp)) < 1)
 565                         adios (NULLCP, "bad argument %s %s", argp[-2], cp);
 566                     continue;
 567
 568                 case DGSTSW:
 569                     if (!(digest = *argp++) || *digest == '-')
 570                         adios (NULLCP, "missing argument to %s", argp[-2]);
 571                     continue;
 572                 case ISSUESW:
 573                     if (!(cp = *argp++) || *cp == '-')
 574                         adios (NULLCP, "missing argument to %s", argp[-2]);
 575                     if ((issue = atoi (cp)) < 1)
 576                         adios (NULLCP, "bad argument %s %s", argp[-2], cp);
 577                     continue;
 578                 case VOLUMSW:
 579                     if (!(cp = *argp++) || *cp == '-')
 580                         adios (NULLCP, "missing argument to %s", argp[-2]);
 581                     if ((volume = atoi (cp)) < 1)
 582                         adios (NULLCP, "bad argument %s %s", argp[-2], cp);
 583                     continue;
 584
 585                 case FORW2SW:
 586                     forwall++;  /* fall */
 587                 case FORW1SW:
 588                     forwflg++;
 589                     clearflg = -1;/* XXX */
 590                     continue;
 591
 592                 case DASHSW:
 593                     dashflg++;
 594                     continue;
 595                 case NDASHSW:
 596                     dashflg = 0;
 597                     continue;
 598
 599                 case NBODYSW:
 600                     dobody = 0;
 601                     continue;
 602             }
 603         files[vecp++] = cp;
 604     }
 605
 606 /* \f */
 607
 608     if (!folder)
 609         folder = getenv ("mhfolder");
 610
 611     if (isatty (fileno (stdout)))
 612         if (!nomore && !sc_hardcopy () && moreproc && *moreproc) {
 613             if (mhl_action) {
 614                 setsig (SIGINT, SIG_IGN);
 615                 setsig (SIGQUIT, quitser);
 616             }
 617             m_popen (moreproc);
 618             ontty = PITTY;
 619         }
 620         else {
 621             setsig (SIGINT, SIG_IGN);
 622             setsig (SIGQUIT, quitser);
 623             ontty = ISTTY;
 624         }
 625     else
 626         ontty = NOTTY;
 627
 628     mhl_format (form ? form : mhlformat, length, width);
 629
 630     if (vecp == 0)
 631         process (folder, NULLCP, 1, vecp = 1);
 632     else
 633         for (i = 0; i < vecp; i++)
 634             process (folder, files[i], i + 1, vecp);
 635
 636     if (forwall) {
 637         if (digest) {
 638             printf ("%s", delim4);
 639             if (volume == 0) {
 640                (void) sprintf (buf, "End of %s Digest\n", digest);
 641              }
 642             else
 643               (void) sprintf (buf, "End of %s Digest [Volume %d Issue %d]\n", digest, volume, issue);
 644             i = strlen (buf);
 645             for (cp = buf + i; i > 1; i--)
 646                 *cp++ = '*';
 647             *cp++ = '\n';
 648             *cp = 0;
 649             printf ("%s", buf);
 650         }
 651         else
 652             printf ("\n------- End of Forwarded Message%s\n\n",
 653                     vecp > 1 ? "s" : "");
 654     }
 655
 656     if (clearflg > 0 && ontty == NOTTY)
 657         clear_screen ();
 658
 659     if (ontty == PITTY)
 660         m_pclose ();
 661
 662     return exitstat;
 663 }
 664
 665 /* \f */
 666
 667 static  mhl_format (file, length, width)
 668 register char   *file;
 669 int     length,
 670         width;
 671 {
 672     int     i;
 673     register char  *bp,
 674                    *cp,
 675                   **ip;
 676     char   *ap,
 677             buffer[BUFSIZ],
 678             name[NAMESZ];
 679     register struct mcomp   *c1;
 680     struct stat st;
 681     register    FILE *fp;
 682     static  dev_t dev = 0;
 683     static  ino_t ino = 0;
 684     static  time_t mtime = 0;
 685
 686     if (fmthd != NULL)
 687         if (stat (libpath (file), &st) != NOTOK
 688                 && mtime == st.st_mtime
 689                 && dev == st.st_dev
 690                 && ino == st.st_ino)
 691             goto out;
 692         else
 693             free_queue (&fmthd, &fmttl);
 694
 695     if ((fp = fopen (libpath (file), "r")) == NULL)
 696         adios (file, "unable to open format file");
 697
 698     if (fstat (fileno (fp), &st) != NOTOK)
 699         mtime = st.st_mtime, dev = st.st_dev, ino = st.st_ino;
 700
 701     global.c_ovtxt = global.c_nfs = NULL;
 702     global.c_fmt = NULL;
 703     global.c_offset = 0;
 704     global.c_ovoff = -1;
 705     if ((i = sc_width ()) > 5)
 706         global.c_width = i;
 707     global.c_cwidth = -1;
 708     if ((i = sc_length ()) > 5)
 709         global.c_length = i - 1;
 710     global.c_flags = BELL;              /* BELL is default */
 711     *(ip = ignores) = NULL;
 712
 713     while (vfgets (fp, &ap) == OK) {
 714         bp = ap;
 715         if (*bp == ';')
 716             continue;
 717
 718         if (cp = index (bp, '\n'))
 719             *cp = 0;
 720
 721         if (*bp == ':') {
 722             c1 = add_queue (&fmthd, &fmttl, NULLCP, bp + 1, CLEARTEXT);
 723             continue;
 724         }
 725
 726         parptr = bp;
 727         (void) strcpy (name, parse ());
 728         switch (*parptr) {
 729             case '\0':
 730             case ',':
 731             case '=':
 732                 if (uleq (name, "ignores")) {
 733                     ip = copyip (brkstring (getcpy (++parptr), ",", NULLCP), ip);
 734                     continue;
 735                 }
 736                 parptr = bp;
 737                 while (*parptr) {
 738                     if (evalvar (&global))
 739                         adios (NULLCP, "format file syntax error: %s", bp);
 740                     if (*parptr)
 741                         parptr++;
 742                 }
 743                 continue;
 744
 745             case ':':
 746                 c1 = add_queue (&fmthd, &fmttl, name, NULLCP, INIT);
 747                 while (*parptr == ':' || *parptr == ',') {
 748                     parptr++;
 749                     if (evalvar (c1))
 750                         adios (NULLCP, "format file syntax error: %s", bp);
 751                 }
 752                 if (!c1 -> c_nfs && global.c_nfs)
 753                     if (c1 -> c_flags & DATEFMT) {
 754                         if (global.c_flags & DATEFMT)
 755                             c1 -> c_nfs = getcpy (global.c_nfs);
 756                     }
 757                     else
 758                         if (c1 -> c_flags & ADDRFMT) {
 759                             if (global.c_flags & ADDRFMT)
 760                                 c1 -> c_nfs = getcpy (global.c_nfs);
 761                         }
 762                 continue;
 763
 764             default:
 765                 adios (NULLCP, "format file syntax error: %s", bp);
 766         }
 767     }
 768     (void) fclose (fp);
 769
 770     if (mhldebug)
 771         for (c1 = fmthd; c1; c1 = c1 -> c_next) {
 772             fprintf (stderr, "c1: name=\"%s\" text=\"%s\" ovtxt=\"%s\"\n",
 773                     c1 -> c_name, c1 -> c_text, c1 -> c_ovtxt);
 774             fprintf (stderr, "\tnfs=0x%x fmt=0x%x\n",
 775                     c1 -> c_nfs, c1 -> c_fmt);
 776             fprintf (stderr, "\toffset=%d ovoff=%d width=%d cwidth=%d length=%d\n",
 777                     c1 -> c_offset, c1 -> c_ovoff, c1 -> c_width,
 778                     c1 -> c_cwidth, c1 -> c_length);
 779             fprintf (stderr, "\tflags=%s\n",
 780                     sprintb (buffer, (unsigned) c1 -> c_flags, LBITS));
 781         }
 782
 783 out: ;
 784     if (clearflg == 1)
 785         global.c_flags |= CLEARSCR;
 786     else
 787         if (clearflg == -1)
 788             global.c_flags &= ~CLEARSCR;
 789
 790     switch (bellflg) {          /* command line may override format file */
 791         case 1:
 792             global.c_flags |= BELL;
 793             break;
 794         case -1:
 795             global.c_flags &= ~BELL;
 796             break;
 797     }
 798
 799     if (length)
 800         global.c_length = length;
 801     if (width)
 802         global.c_width = width;
 803     if (global.c_length < 5)
 804         global.c_length = 10000;
 805     if (global.c_width < 5)
 806         global.c_width = 10000;
 807 }
 808
 809 /* \f */
 810
 811 static  evalvar (c1)
 812 register struct mcomp *c1;
 813 {
 814     char   *cp,
 815             name[NAMESZ];
 816     register struct triple *ap;
 817
 818     if (!*parptr)
 819         return 0;
 820     (void) strcpy (name, parse ());
 821
 822     if (uleq (name, "component")) {
 823         if (ptos (name, &c1 -> c_text))
 824             return 1;
 825         c1 -> c_flags &= ~NOCOMPONENT;
 826         return 0;
 827     }
 828     if (uleq (name, "overflowtext"))
 829         return ptos (name, &c1 -> c_ovtxt);
 830     if (uleq (name, "formatfield")) {
 831         if (ptos (name, &cp))
 832             return 1;
 833         c1 -> c_nfs = getcpy (new_fs (NULLCP, NULLCP, cp));
 834         c1 -> c_flags |= FORMAT;
 835         return 0;
 836     }
 837
 838     if (uleq (name, "offset"))
 839         return ptoi (name, &c1 -> c_offset);
 840     if (uleq (name, "overflowoffset"))
 841         return ptoi (name, &c1 -> c_ovoff);
 842     if (uleq (name, "width"))
 843         return ptoi (name, &c1 -> c_width);
 844     if (uleq (name, "compwidth"))
 845         return ptoi (name, &c1 -> c_cwidth);
 846     if (uleq (name, "length"))
 847         return ptoi (name, &c1 -> c_length);
 848     if (uleq (name, "nodashmunging"))
 849         return (dashflg = 0);
 850
 851     for (ap = triples; ap -> t_name; ap++)
 852         if (uleq (ap -> t_name, name)) {
 853             c1 -> c_flags |= ap -> t_on;
 854             c1 -> c_flags &= ~ap -> t_off;
 855             return 0;
 856         }
 857
 858     return 1;
 859 }
 860
 861 /* \f */
 862
 863 static int  ptoi (name, i)
 864 register char  *name;
 865 register int   *i;
 866 {
 867     char   *cp;
 868
 869     if (*parptr++ != '=' || !*(cp = parse ())) {
 870         advise (NULLCP, "missing argument to variable %s", name);
 871         return 1;
 872     }
 873
 874     *i = atoi (cp);
 875     return 0;
 876 }
 877
 878
 879 static int  ptos (name, s)
 880 register char  *name,
 881               **s;
 882 {
 883     char    c,
 884            *cp;
 885
 886     if (*parptr++ != '=') {
 887         advise (NULLCP, "missing argument to variable %s", name);
 888         return 1;
 889     }
 890
 891     if (*parptr != '"')
 892         for (cp = parptr;
 893                 *parptr && *parptr != ':' && *parptr != ',';
 894                 parptr++)
 895             continue;
 896     else
 897         for (cp = ++parptr; *parptr && *parptr != '"'; parptr++)
 898             if (*parptr == QUOTE)
 899                 if (!*++parptr)
 900                     parptr--;
 901     c = *parptr;
 902     *parptr = 0;
 903     *s = getcpy (cp);
 904     if ((*parptr = c) == '"')
 905         parptr++;
 906     return 0;
 907 }
 908
 909 /* \f */
 910
 911 static char *parse () {
 912     int     c;
 913     register char   *cp;
 914     static char result[NAMESZ];
 915
 916     for (cp = result; c = *parptr; parptr++)
 917         if (isalnum (c)
 918                 || c == '.'
 919                 || c == '-'
 920                 || c == '_'
 921                 || c =='['
 922                 || c == ']')
 923             *cp++ = c;
 924         else
 925             break;
 926     *cp = 0;
 927
 928     return result;
 929 }
 930
 931 /* \f */
 932
 933 static  process (folder, fname, ofilen, ofilec)
 934 char   *folder,
 935        *fname;
 936 int     ofilen,
 937         ofilec;
 938 {
 939     char  *cp;
 940     FILE  *fp;
 941     struct mcomp  *c1;
 942
 943     switch (setjmp (env)) {
 944         case OK:
 945             if (fname) {
 946                 fp = mhl_action ? (*mhl_action) (fname) : fopen (fname, "r");
 947                 if (fp == NULL) {
 948                     advise (fname, "unable to open");
 949                     exitstat++;
 950                     return;
 951                 }
 952             }
 953             else {
 954                 fname = "(stdin)";
 955                 fp = stdin;
 956             }
 957             cp = folder ? concat (folder, ":", fname, NULLCP) : getcpy (fname);
 958             if (ontty != PITTY)
 959                 (void) signal (SIGINT, intrser);
 960             mhlfile (fp, cp, ofilen, ofilec);/* fall */
 961
 962         default:
 963             if (ontty != PITTY)
 964                 (void) signal (SIGINT, SIG_IGN);
 965             if (mhl_action == NULL && fp != stdin)
 966                 (void) fclose (fp);
 967             free (cp);
 968             if (holder.c_text) {
 969                 free (holder.c_text);
 970                 holder.c_text = NULL;
 971             }
 972             free_queue (&msghd, &msgtl);
 973             for (c1 = fmthd; c1; c1 = c1 -> c_next)
 974                 c1 -> c_flags &= ~HDROUTPUT;
 975             break;
 976     }
 977 }
 978
 979 /* \f */
 980
 981 static mhlfile (fp, mname, ofilen, ofilec)
 982 register FILE   *fp;
 983 register char   *mname;
 984 int     ofilen,
 985         ofilec;
 986 {
 987     int     state;
 988     register struct mcomp  *c1,
 989                            *c2,
 990                            *c3;
 991     register char **ip;
 992     char    name[NAMESZ],
 993             buf[BUFSIZ];
 994
 995     if (forwall) {
 996         if (digest)
 997             printf ("%s", ofilen == 1 ? delim3 : delim4);
 998         else {
 999             printf ("\n-------");
1000             if (ofilen == 1)
1001                 printf (" Forwarded Message%s", ofilec > 1 ? "s" : "");
1002             else
1003                 printf (" Message %d", ofilen);
1004             printf ("\n\n");
1005         }
1006     }
1007     else
1008         switch (ontty) {
1009             case PITTY:
1010                 if (ofilec > 1) {
1011                     if (ofilen > 1) {
1012                         if ((global.c_flags & CLEARSCR))
1013                             clear_screen ();
1014                         else
1015                             printf ("\n\n\n");
1016                     }
1017                     printf (">>> %s\n\n", mname);
1018                 }
1019                 break;
1020
1021             case ISTTY:
1022                 (void) strcpy (buf, "\n");
1023                 if (ofilec > 1) {
1024                     if (SOprintf ("Press <return> to list \"%s\"...", mname)) {
1025                         if (ofilen > 1)
1026                             printf ("\n\n\n");
1027                         printf ("Press <return> to list \"%s\"...", mname);
1028                     }
1029                     (void) fflush (stdout);
1030                     buf[0] = 0;
1031                     (void) read (fileno (stdout), buf, sizeof buf);
1032                 }
1033                 if (index (buf, '\n')) {
1034                     if ((global.c_flags & CLEARSCR))
1035                         clear_screen ();
1036                 }
1037                 else
1038                     printf ("\n");
1039                 break;
1040
1041             default:
1042                 if (ofilec > 1) {
1043                     if (ofilen > 1) {
1044                         printf ("\n\n\n");
1045                         if (clearflg > 0)
1046                             clear_screen ();
1047                     }
1048                     printf (">>> %s\n\n", mname);
1049                 }
1050                 break;
1051         }
1052
1053 /* \f */
1054
1055     for (state = FLD;;)
1056         switch (state = m_getfld (state, name, buf, sizeof buf, fp)) {
1057             case FLD:
1058             case FLDPLUS:
1059                 for (ip = ignores; *ip; ip++)
1060                     if (uleq (name, *ip)) {
1061                         while (state == FLDPLUS)
1062                             state = m_getfld (state, name, buf, sizeof buf, fp);
1063                         break;
1064                     }
1065                 if (*ip)
1066                     continue;
1067
1068                 for (c2 = fmthd; c2; c2 = c2 -> c_next)
1069                     if (uleq (c2 -> c_name, name))
1070                         break;
1071                 c1 = NULL;
1072                 if (!((c3 = c2 ? c2 : &global) -> c_flags & SPLIT))
1073                     for (c1 = msghd; c1; c1 = c1 -> c_next)
1074                         if (uleq (c1 -> c_name, c3 -> c_name)) {
1075                             c1 -> c_text =
1076                                 mcomp_add (c1 -> c_flags, buf, c1 -> c_text);
1077                             break;
1078                         }
1079                 if (c1 == NULL)
1080                     c1 = add_queue (&msghd, &msgtl, name, buf, 0);
1081                 while (state == FLDPLUS) {
1082                     state = m_getfld (state, name, buf, sizeof buf, fp);
1083                     c1 -> c_text = add (buf, c1 -> c_text);
1084                 }
1085                 if (c2 == NULL)
1086                     c1 -> c_flags |= EXTRA;
1087                 continue;
1088
1089             case BODY:
1090             case FILEEOF:
1091                 row = column = 0;
1092                 for (c1 = fmthd; c1; c1 = c1 -> c_next) {
1093                     if (c1 -> c_flags & CLEARTEXT) {
1094                         putcomp (c1, c1, ONECOMP);
1095                         continue;
1096                     }
1097                     if (uleq (c1 -> c_name, "messagename")) {
1098                         holder.c_text = concat ("(Message ", mname, ")\n",
1099                                             NULLCP);
1100                         putcomp (c1, &holder, ONECOMP);
1101                         free (holder.c_text);
1102                         holder.c_text = NULL;
1103                         continue;
1104                     }
1105                     if (uleq (c1 -> c_name, "extras")) {
1106                         for (c2 = msghd; c2; c2 = c2 -> c_next)
1107                             if (c2 -> c_flags & EXTRA)
1108                                 putcomp (c1, c2, TWOCOMP);
1109                         continue;
1110                     }
1111                     if (dobody && uleq (c1 -> c_name, "body")) {
1112                         if ((holder.c_text = malloc (sizeof buf)) == NULL)
1113                             adios (NULLCP, "unable to allocate buffer memory");
1114                         (void) strcpy (holder.c_text, buf);
1115                         while (state == BODY) {
1116                             putcomp (c1, &holder, BODYCOMP);
1117                             state = m_getfld (state, name, holder.c_text,
1118                                         sizeof buf, fp);
1119                         }
1120                         free (holder.c_text);
1121                         holder.c_text = NULL;
1122                         continue;
1123                     }
1124                     for (c2 = msghd; c2; c2 = c2 -> c_next)
1125                         if (uleq (c2 -> c_name, c1 -> c_name)) {
1126                             putcomp (c1, c2, ONECOMP);
1127                             if (!(c1 -> c_flags & SPLIT))
1128                                 break;
1129                         }
1130                     if (faceproc && c2 == NULL && (c1 -> c_flags & FACEFMT))
1131                         for (c2 = msghd; c2; c2 = c2 -> c_next)
1132                             if (c2 -> c_flags & FACEDFLT) {
1133                                 if (c2 -> c_face == NULL)
1134                                     face_format (c2);
1135                                 if (holder.c_text = c2 -> c_face) {
1136                                     putcomp (c1, &holder, ONECOMP);
1137                                     holder.c_text = NULL;
1138                                 }
1139                                 break;
1140                             }
1141                 }
1142                 return;
1143
1144             case LENERR:
1145             case FMTERR:
1146                 advise (NULLCP, "format error in message %s", mname);
1147                 exitstat++;
1148                 return;
1149
1150             default:
1151                 adios (NULLCP, "getfld() returned %d", state);
1152         }
1153 }
1154
1155 /* \f */
1156
1157 static int  mcomp_flags (name)
1158 register char   *name;
1159 {
1160     register struct pair   *ap;
1161
1162     for (ap = pairs; ap -> p_name; ap++)
1163         if (uleq (ap -> p_name, name))
1164             return (ap -> p_flags);
1165
1166     return 0;
1167 }
1168
1169
1170 static char *mcomp_add (flags, s1, s2)
1171 long    flags;
1172 register char   *s1,
1173                 *s2;
1174 {
1175     register char   *dp;
1176
1177     if (!(flags & ADDRFMT))
1178         return add (s1, s2);
1179
1180     if (s2 && *(dp = s2 + strlen (s2) - 1) == '\n')
1181         *dp = 0;
1182
1183     return add (s1, add (",\n", s2));
1184 }
1185
1186 /* \f */
1187
1188 struct pqpair {
1189     char    *pq_text;
1190     char    *pq_error;
1191     struct pqpair *pq_next;
1192 };
1193
1194
1195 static mcomp_format (c1, c2)
1196 register struct mcomp *c1,
1197                       *c2;
1198 {
1199     int     dat[5];
1200     register char  *ap,
1201                    *cp;
1202     char    buffer[BUFSIZ],
1203             error[BUFSIZ];
1204     register struct comp   *cptr;
1205     register struct pqpair *p,
1206                            *q;
1207     struct pqpair   pq;
1208     register struct mailname   *mp;
1209
1210     ap = c2 -> c_text;
1211     c2 -> c_text = NULL;
1212     dat[0] = dat[1] = dat[2] = dat[4] = 0;
1213     dat[3] = sizeof buffer - 1;
1214     (void) fmt_compile (c1 -> c_nfs, &c1 -> c_fmt);
1215
1216     if (!(c1 -> c_flags & ADDRFMT)) {
1217         FINDCOMP (cptr, "text");
1218         if (cptr)
1219             cptr -> c_text = ap;
1220         if (cp = rindex(ap, '\n'))      /* drop ending newline */
1221             if (!cp[1])
1222                 *cp = 0;
1223
1224         (void) fmtscan (c1 -> c_fmt, buffer, sizeof buffer - 1, dat);
1225         c2 -> c_text = getcpy (buffer);
1226 #ifndef JLR
1227         /* Don't need to append a newline, dctime() already did */
1228 #else
1229         if (!(c1 -> c_flags & NONEWLINE))
1230             c2 -> c_text = add ("\n", c2 -> c_text);
1231 #endif
1232
1233         free (ap);
1234         return;
1235     }
1236
1237     (q = &pq) -> pq_next = NULL;
1238     while (cp = getname (ap)) {
1239         if ((p = (struct pqpair *) calloc ((unsigned) 1, sizeof *p)) == NULL)
1240             adios (NULLCP, "unable to allocate pqpair memory");
1241
1242         if ((mp = getm (cp, NULLCP, 0, AD_NAME, error)) == NULL) {
1243             p -> pq_text = getcpy (cp);
1244             p -> pq_error = getcpy (error);
1245         }
1246         else {
1247             if ((c1 -> c_flags & FACEDFLT) && c2 -> c_face == NULL) {
1248                 char   *h, *o;
1249                 if ((h = mp -> m_host) == NULL)
1250                     h = LocalName ();
1251                 if (o = OfficialName (h))
1252                     h = o;
1253                 c2 -> c_face = concat ("address ", h, " ", mp -> m_mbox,
1254                                     NULLCP);
1255             }
1256             p -> pq_text = getcpy (mp -> m_text);
1257             mnfree (mp);
1258         }
1259         q = (q -> pq_next = p);
1260     }
1261
1262     for (p = pq.pq_next; p; p = q) {
1263         FINDCOMP (cptr, "text");
1264         if (cptr)
1265             cptr -> c_text = p -> pq_text;
1266         FINDCOMP (cptr, "error");
1267         if (cptr)
1268             cptr -> c_text = p -> pq_error;
1269
1270         (void) fmtscan (c1 -> c_fmt, buffer, sizeof buffer - 1, dat);
1271         if (*buffer) {
1272             if (c2 -> c_text)
1273                 c2 -> c_text = add (",\n", c2 -> c_text);
1274             if (*(cp = buffer + strlen (buffer) - 1) == '\n')
1275                 *cp = 0;
1276             c2 -> c_text = add (buffer, c2 -> c_text);
1277         }
1278
1279         free (p -> pq_text);
1280         if (p -> pq_error)
1281             free (p -> pq_error);
1282         q = p -> pq_next;
1283         free ((char *) p);
1284     }
1285
1286     c2 -> c_text = add ("\n", c2 -> c_text);
1287     free (ap);
1288 }
1289
1290 /* \f */
1291
1292 static struct mcomp *add_queue (head, tail, name, text, flags)
1293 register struct mcomp **head,
1294                       **tail;
1295 register char   *name,
1296                 *text;
1297 int     flags;
1298 {
1299     register struct mcomp  *c1;
1300
1301     if ((c1 = (struct mcomp *) calloc ((unsigned) 1, sizeof *c1)) == NULL)
1302         adios (NULLCP, "unable to allocate comp memory");
1303
1304     c1 -> c_flags = flags & ~INIT;
1305     if (c1 -> c_name = name ? getcpy (name) : NULL)
1306         c1 -> c_flags |= mcomp_flags (c1 -> c_name);
1307     c1 -> c_text = text ? getcpy (text) : NULL;
1308     if (flags & INIT) {
1309         if (global.c_ovtxt)
1310             c1 -> c_ovtxt = getcpy (global.c_ovtxt);
1311         c1 -> c_offset = global.c_offset;
1312         c1 -> c_ovoff = global. c_ovoff;
1313         c1 -> c_width = c1 -> c_length = 0;
1314         c1 -> c_cwidth = global.c_cwidth;
1315         c1 -> c_flags |= global.c_flags & GFLAGS;
1316     }
1317     if (*head == NULL)
1318         *head = c1;
1319     if (*tail != NULL)
1320         (*tail) -> c_next = c1;
1321     *tail = c1;
1322
1323     return c1;
1324 }
1325
1326
1327 static  free_queue (head, tail)
1328 register struct mcomp **head,
1329                       **tail;
1330 {
1331     register struct mcomp *c1,
1332                           *c2;
1333
1334     for (c1 = *head; c1; c1 = c2) {
1335         c2 = c1 -> c_next;
1336         if (c1 -> c_name)
1337             free (c1 -> c_name);
1338         if (c1 -> c_text)
1339             free (c1 -> c_text);
1340         if (c1 -> c_ovtxt)
1341             free (c1 -> c_ovtxt);
1342         if (c1 -> c_nfs)
1343             free (c1 -> c_nfs);
1344         if (c1 -> c_fmt)
1345             free ((char *) c1 -> c_fmt);
1346         if (c1 -> c_face)
1347             free (c1 -> c_face);
1348         free ((char *) c1);
1349     }
1350
1351     *head = *tail = NULL;
1352 }
1353
1354 /* \f */
1355
1356 static  putcomp (c1, c2, flag)
1357 register struct mcomp *c1,
1358                       *c2;
1359 int     flag;
1360 {
1361     int     count,
1362             cchdr;
1363     register char   *cp;
1364
1365     cchdr = 0;
1366     lm = 0;
1367     llim = c1 -> c_length ? c1 -> c_length : -1;
1368     wid = c1 -> c_width ? c1 -> c_width : global.c_width;
1369     ovoff = (c1 -> c_ovoff >= 0 ? c1 -> c_ovoff : global.c_ovoff)
1370         + c1 -> c_offset;
1371     if ((ovtxt = c1 -> c_ovtxt ? c1 -> c_ovtxt : global.c_ovtxt) == NULL)
1372         ovtxt = "";
1373     if (wid < ovoff + strlen (ovtxt) + 5)
1374         adios (NULLCP, "component: %s width(%d) too small for overflow(%d)",
1375                 c1 -> c_name, wid, ovoff + strlen (ovtxt) + 5);
1376     onelp = NULL;
1377
1378     if (c1 -> c_flags & CLEARTEXT) {
1379         putstr (c1 -> c_text);
1380         putstr ("\n");
1381         return;
1382     }
1383
1384     if (c1 -> c_flags & FACEFMT)
1385         switch (doface (c2)) {
1386             case NOTOK:         /* error */
1387             case OK:            /* async faceproc */
1388                 return;
1389
1390             default:            /* sync faceproc */
1391                 break;
1392         }
1393
1394     if (c1 -> c_nfs && (c1 -> c_flags & (ADDRFMT | DATEFMT | FORMAT)))
1395         mcomp_format (c1, c2);
1396
1397     if (c1 -> c_flags & CENTER) {
1398         count = (c1 -> c_width ? c1 -> c_width : global.c_width)
1399             - c1 -> c_offset - strlen (c2 -> c_text);
1400         if (!(c1 -> c_flags & HDROUTPUT) && !(c1 -> c_flags & NOCOMPONENT))
1401             count -= strlen (c1 -> c_text ? c1 -> c_text : c1 -> c_name) + 2;
1402         lm = c1 -> c_offset + (count / 2);
1403     }
1404     else
1405         if (c1 -> c_offset)
1406             lm = c1 -> c_offset;
1407
1408     if (!(c1 -> c_flags & HDROUTPUT) && !(c1 -> c_flags & NOCOMPONENT)) {
1409         if (c1 -> c_flags & UPPERCASE)          /* uppercase component also */
1410             for (cp = (c1 -> c_text ? c1 -> c_text : c1 -> c_name); *cp; cp++)
1411                 if (islower (*cp))
1412                     *cp = toupper (*cp);
1413         putstr (c1 -> c_text ? c1 -> c_text : c1 -> c_name);
1414         if (flag != BODYCOMP) {
1415             putstr (": ");
1416             if (!(c1 -> c_flags & SPLIT))
1417                 c1 -> c_flags |= HDROUTPUT;
1418
1419         cchdr++;
1420         if ((count = c1 -> c_cwidth -
1421                 strlen (c1 -> c_text ? c1 -> c_text : c1 -> c_name) - 2) > 0)
1422             while (count--)
1423                 putstr (" ");
1424         }
1425         else
1426             c1 -> c_flags |= HDROUTPUT;         /* for BODYCOMP */
1427     }
1428
1429     if (flag == TWOCOMP
1430             && !(c2 -> c_flags & HDROUTPUT)
1431             && !(c2 -> c_flags & NOCOMPONENT)) {
1432         if (c1 -> c_flags & UPPERCASE)
1433             for (cp = c2 -> c_name; *cp; cp++)
1434                 if (islower (*cp))
1435                     *cp = toupper (*cp);
1436         putstr (c2 -> c_name);
1437         putstr (": ");
1438         if (!(c1 -> c_flags & SPLIT))
1439             c2 -> c_flags |= HDROUTPUT;
1440
1441         cchdr++;
1442         if ((count = c1 -> c_cwidth - strlen (c2 -> c_name) - 2) > 0)
1443             while (count--)
1444                 putstr (" ");
1445     }
1446     if (c1 -> c_flags & UPPERCASE)
1447         for (cp = c2 -> c_text; *cp; cp++)
1448             if (islower (*cp))
1449                 *cp = toupper (*cp);
1450
1451     count = 0;
1452     if (cchdr)
1453         if (flag == TWOCOMP)
1454             count = (c1 -> c_cwidth >= 0) ? c1 -> c_cwidth
1455                         : strlen (c2 -> c_name) + 2;
1456         else
1457             count = (c1 -> c_cwidth >= 0) ? c1 -> c_cwidth
1458                         : strlen (c1->c_text ? c1->c_text : c1->c_name) + 2;
1459     count += c1 -> c_offset;
1460
1461     if (cp = oneline (c2 -> c_text, c1 -> c_flags))
1462        putstr(cp);
1463     if (term == '\n')
1464         putstr ("\n");
1465     while (cp = oneline (c2 -> c_text, c1 -> c_flags)) {
1466         lm = count;
1467         if (flag == BODYCOMP
1468                 && !(c1 -> c_flags & NOCOMPONENT))
1469             putstr (c1 -> c_text ? c1 -> c_text : c1 -> c_name);
1470         if (*cp)
1471             putstr (cp);
1472         if (term == '\n')
1473             putstr ("\n");
1474     }
1475 }
1476
1477 /* \f */
1478
1479 static char *oneline (stuff, flags)
1480 register char   *stuff;
1481 long   flags;
1482 {
1483     int     spc;
1484     register char   *cp,
1485                     *ret;
1486
1487     if (onelp == NULL)
1488         onelp = stuff;
1489     if (*onelp == 0)
1490         return (onelp = NULL);
1491
1492     ret = onelp;
1493     term = 0;
1494     if (flags & COMPRESS) {
1495         for (spc = 1, cp = ret; *onelp; onelp++)
1496             if (isspace (*onelp)) {
1497                 if (*onelp == '\n' && (!onelp[1] || (flags & ADDRFMT))) {
1498                     term = '\n';
1499                     *onelp++ = 0;
1500                     break;
1501                 }
1502                 else
1503                     if (!spc) {
1504                         *cp++ = ' ';
1505                         spc++;
1506                     }
1507             }
1508             else {
1509                 *cp++ = *onelp;
1510                 spc = 0;
1511             }
1512
1513         *cp = 0;
1514     }
1515     else {
1516         while (*onelp && *onelp != '\n')
1517             onelp++;
1518         if (*onelp == '\n') {
1519             term = '\n';
1520             *onelp++ = 0;
1521         }
1522         if (flags & LEFTADJUST)
1523             while (*ret == ' ' || *ret == '\t')
1524                 ret++;
1525     }
1526     if (*onelp == 0 && term == '\n' && (flags & NONEWLINE))
1527         term = 0;
1528
1529     return ret;
1530 }
1531
1532 /* \f */
1533
1534 static  putstr (string)
1535 register char   *string;
1536 {
1537     if (!column && lm > 0)
1538         while (lm > 0)
1539             if (lm >= 8) {
1540                 putch ('\t');
1541                 lm -= 8;
1542             }
1543             else {
1544                 putch (' ');
1545                 lm--;
1546             }
1547     lm = 0;
1548     while (*string)
1549         putch (*string++);
1550 }
1551
1552 /* \f */
1553
1554 static putch (ch)
1555 register char   ch;
1556 {
1557     char    buf[BUFSIZ];
1558
1559     if (llim == 0)
1560         return;
1561
1562     switch (ch) {
1563         case '\n':
1564             if (llim > 0)
1565                 llim--;
1566             column = 0;
1567             row++;
1568             if (ontty != ISTTY || row != global.c_length)
1569                 break;
1570             if (global.c_flags & BELL)
1571                 (void) putchar ('\007');
1572             (void) fflush (stdout);
1573             buf[0] = 0;
1574             (void) read (fileno (stdout), buf, sizeof buf);
1575             if (index (buf, '\n')) {
1576                 if (global.c_flags & CLEARSCR)
1577                     clear_screen ();
1578                 row = 0;
1579             }
1580             else {
1581                 (void) putchar ('\n');
1582                 row = global.c_length / 3;
1583             }
1584             return;
1585
1586         case '\t':
1587             column |= 07;
1588             column++;
1589             break;
1590
1591         case '\b':
1592             column--;
1593             break;
1594
1595         case '\r':
1596             column = 0;
1597             break;
1598
1599         default:
1600             if (column == 0 && forwflg && dashflg && ch == '-')
1601                 (void) putchar ('-'), putchar (' ');
1602             if (ch >= ' ')
1603                 column++;
1604             break;
1605     }
1606
1607     if (column >= wid) {
1608         putch ('\n');
1609         if (ovoff > 0)
1610             lm = ovoff;
1611         putstr (ovtxt ? ovtxt : "");
1612         putch (ch);
1613         return;
1614     }
1615
1616     (void) putchar (ch);
1617 }
1618
1619 /* \f */
1620
1621 /* ARGSUSED */
1622
1623 static  TYPESIG intrser (i)
1624 int     i;
1625 {
1626 #ifndef BSD42
1627     (void) signal (SIGINT, intrser);
1628 #endif  /* BSD42 */
1629
1630     discard (stdout);
1631     (void) putchar ('\n');
1632
1633     longjmp (env, DONE);
1634 }
1635
1636
1637 /* ARGSUSED */
1638
1639 static  TYPESIG pipeser (i)
1640 int     i;
1641 {
1642 #ifndef BSD42
1643     (void) signal (SIGPIPE, pipeser);
1644 #endif  /* BSD42 */
1645
1646     done (NOTOK);
1647 }
1648
1649
1650 /* ARGSUSED */
1651
1652 static  TYPESIG quitser (i)
1653 int     i;
1654 {
1655 #ifndef BSD42
1656     (void) signal (SIGQUIT, quitser);
1657 #endif  /* BSD42 */
1658
1659     (void) putchar ('\n');
1660     (void) fflush (stdout);
1661
1662     done (NOTOK);
1663 }
1664
1665 /* \f */
1666
1667 static  face_format (c1)
1668 register struct mcomp *c1;
1669 {
1670     register char  *cp;
1671     register struct mailname   *mp;
1672
1673     if ((cp = c1 -> c_text) == NULL)
1674         return;
1675
1676     if (cp = getname (cp)) {
1677         if (mp = getm (cp, NULLCP, 0, AD_NAME, NULLCP)) {
1678             char *h, *o;
1679             if ((h = mp -> m_host) == NULL)
1680                 h = LocalName ();
1681             if (o = OfficialName (h))
1682                 h = o;
1683             c1 -> c_face = concat ("address ", h, " ", mp -> m_mbox, NULLCP);
1684         }
1685
1686         while (cp = getname (cp))
1687             continue;
1688     }
1689 }
1690
1691 /* \f */
1692
1693 #if     defined(BSD42) || defined(SOCKETS)
1694
1695 /* faceproc is two elements defining the image agent's location:
1696         Internet host
1697         UDP port
1698  */
1699
1700 #include <sys/socket.h>
1701 #include <netinet/in.h>
1702 #include <netdb.h>
1703 #ifndef hpux
1704 #include <arpa/inet.h>
1705 #endif
1706
1707 struct hostent *gethostbystring ();
1708
1709
1710 static int  doface (c1)
1711 register struct mcomp *c1;
1712 {
1713     int     i,
1714             result,
1715             sd;
1716     struct sockaddr_in in_socket;
1717     register struct sockaddr_in *isock = &in_socket;
1718     static int inited = OK;
1719     static int addrlen;
1720     static struct in_addr addr;
1721     static u_short portno;
1722
1723     if (inited == OK) {
1724         u_long  iaddr;
1725         char   *cp;
1726         char  **ap = brkstring (cp = getcpy (faceproc), " ", "\n");
1727         struct hostent *hp;
1728
1729         if (ap[0] == NULL || ap[1] == NULL) {
1730 bad_faceproc: ;
1731             free (cp);
1732             return (inited = NOTOK);
1733         }
1734
1735         if (!(hp = gethostbystring (ap[0])))
1736             goto bad_faceproc;
1737         bcopy (hp -> h_addr, (char *) &addr, addrlen = hp -> h_length);
1738
1739         portno = htons ((u_short) atoi (ap[1]));
1740         free (cp);
1741
1742         inited = DONE;
1743     }
1744     if (inited == NOTOK)
1745         return NOTOK;
1746
1747     isock -> sin_family = AF_INET;
1748     isock -> sin_port = portno;
1749     bcopy ((char *) &addr, (char *) &isock -> sin_addr, addrlen);
1750
1751     if ((sd = socket (AF_INET, SOCK_DGRAM, 0)) == NOTOK)
1752         return NOTOK;
1753
1754     result = sendto (sd, c1 -> c_text, strlen (c1 -> c_text), 0,
1755                 (struct sockaddr *) isock, sizeof *isock);
1756
1757     (void) close (sd);
1758
1759     return (result != NOTOK ? OK : NOTOK);
1760 }
1761
1762 #else   /* not BSD42 and not SOCKETS */
1763
1764 static int  doface (c1)
1765 register struct mcomp *c1;
1766 {
1767     register int    i,
1768                     len,
1769                     vecp;
1770     int     child_id,
1771             result,
1772             pdi[2],
1773             pdo[2];
1774     register char  *bp,
1775                    *cp;
1776     char    buffer[BUFSIZ],
1777            *vec[10];
1778
1779     if (pipe (pdi) == NOTOK)
1780         return NOTOK;
1781     if (pipe (pdo) == NOTOK) {
1782         (void) close (pdi[0]);
1783         (void) close (pdi[1]);
1784         return NOTOK;
1785     }
1786
1787     for (i = 0; (child_id = vfork ()) == NOTOK && i < 5; i++)
1788         sleep (5);
1789
1790     switch (child_id) {
1791         case NOTOK:
1792             return NOTOK;
1793
1794         case OK:
1795             (void) signal (SIGINT, SIG_IGN);
1796             (void) signal (SIGQUIT, SIG_IGN);
1797             if (pdi[0] != fileno (stdin)) {
1798                 (void) dup2 (pdi[0], fileno (stdin));
1799                 (void) close (pdi[0]);
1800             }
1801             (void) close (pdi[1]);
1802             (void) close (pdo[0]);
1803             if (pdo[1] != fileno (stdout)) {
1804                 (void) dup2 (pdo[1], fileno (stdout));
1805                 (void) close (pdo[1]);
1806             }
1807             vecp = 0;
1808             vec[vecp++] = r1bindex (faceproc, '/');
1809             vec[vecp++] = "-e";
1810             if (sleepsw != NOTOK) {
1811                 vec[vecp++] = "-s";
1812                 (void) sprintf (buffer, "%d", sleepsw);
1813                 vec[vecp++] = buffer;
1814             }
1815             vec[vecp] = NULL;
1816             execvp (faceproc, vec);
1817             fprintf (stderr, "unable to exec ");
1818             perror (faceproc);
1819             _exit (-1);         /* NOTREACHED */
1820
1821         default:
1822             (void) close (pdi[0]);
1823             i = strlen (c1 -> c_text);
1824             if (write (pdi[1], c1 -> c_text, i) != i)
1825                 adios ("pipe", "error writing to");
1826             free (c1 -> c_text), c1 -> c_text = NULL;
1827             (void) close (pdi[1]);
1828
1829             (void) close (pdo[1]);
1830             cp = NULL, len = 0;
1831             result = DONE;
1832             while ((i = read (pdo[0], buffer, strlen (buffer))) > 0) {
1833                 if (cp) {
1834                     register int    j;
1835                     register char  *dp;
1836                     if ((dp = realloc (cp, (unsigned) (j = len + i))) == NULL)
1837                         adios (NULLCP, "unable to allocate face storage");
1838                     bcopy (buffer, dp + len, i);
1839                     cp = dp, len = j;
1840                 }
1841                 else {
1842                     if ((cp = malloc ((unsigned) i)) == NULL)
1843                         adios (NULLCP, "unable to allocate face storage");
1844                     bcopy (buffer, cp, i);
1845                     len = i;
1846                 }
1847                 if (result == DONE)
1848                     for (bp = buffer + i - 1; bp >= buffer; bp--)
1849                         if (!isascii (*bp) || iscntrl (*bp)) {
1850                             result = OK;
1851                             break;
1852                         }
1853             }
1854             (void) close (pdo[0]);
1855
1856 /* no waiting for child... */
1857
1858             if (result == OK) { /* binary */
1859                 if (write (1, cp, len) != len)
1860                     adios ("writing", "error");
1861                 free (cp);
1862             }
1863             else                /* empty */
1864                 if ((c1 -> c_text = cp) == NULL)
1865                     result = OK;
1866             break;
1867     }
1868
1869     return result;
1870 }
1871 #endif  /* not BSD42 and not SOCKETS */
1872
1873 /* \f */
1874
1875 #undef  adios
1876 #undef  done
1877
1878 int     mhlsbr (argc, argv, action)
1879 int     argc;
1880 char  **argv;
1881 FP    (*action) ();
1882 {
1883     TYPESIG (*istat) (), (*pstat) (), (*qstat) ();
1884     char   *cp;
1885     struct mcomp  *c1;
1886
1887     switch (setjmp (mhlenv)) {
1888         case OK:
1889             cp = invo_name;
1890             sleepsw = 0;        /* XXX */
1891             bellflg = clearflg = forwflg = forwall = exitstat = 0;
1892             digest = NULL;
1893             ontty = NOTTY;
1894             mhl_action = action;
1895             if ((istat = signal (SIGINT, SIG_IGN)) != SIG_DFL)
1896                 (void) signal (SIGINT, istat);
1897             if ((qstat = signal (SIGQUIT, SIG_IGN)) != SIG_DFL)
1898                 (void) signal (SIGQUIT, qstat);
1899             pstat = signal (SIGPIPE, pipeser);
1900             (void) mhl (argc, argv);    /* fall */
1901
1902         default:
1903             (void) signal (SIGINT, istat);
1904             (void) signal (SIGQUIT, qstat);
1905             (void) signal (SIGPIPE, SIG_IGN);/* XXX */
1906             if (ontty == PITTY)
1907                 m_pclose ();
1908             (void) signal (SIGPIPE, pstat);
1909             invo_name = cp;
1910             if (holder.c_text) {
1911                 free (holder.c_text);
1912                 holder.c_text = NULL;
1913             }
1914             free_queue (&msghd, &msgtl);
1915             for (c1 = fmthd; c1; c1 = c1 -> c_next)
1916                 c1 -> c_flags &= ~HDROUTPUT;
1917             return exitstat;
1918     }
1919 }
1920
1921 /* \f */
1922
1923 /* VARARGS2 */
1924
1925 static void mhladios (what, fmt, a, b, c, d, e, f)
1926 char   *what,
1927        *fmt,
1928        *a,
1929        *b,
1930        *c,
1931        *d,
1932        *e,
1933        *f;
1934 {
1935     advise (what, fmt, a, b, c, d, e, f);
1936     mhldone (1);
1937 }
1938
1939
1940 static void mhldone (status)
1941 int     status;
1942 {
1943     exitstat = status;
1944     if (mhl_action)
1945         longjmp (mhlenv, DONE);
1946     else
1947         done (exitstat);
1948 }
1949
1950 /* \f */
1951
1952 static  int m_pid = NOTOK;
1953 static  int sd = NOTOK;
1954
1955
1956 static  m_popen (name)
1957 char *name;
1958 {
1959     int     pd[2];
1960
1961     if (mhl_action && (sd = dup (fileno (stdout))) == NOTOK)
1962         adios ("standard output", "unable to dup()");
1963
1964     if (pipe (pd) == NOTOK)
1965         adios ("pipe", "unable to");
1966
1967     switch (m_pid = vfork ()) {
1968         case NOTOK:
1969             adios ("fork", "unable to");
1970
1971         case OK:
1972             (void) signal (SIGINT, SIG_DFL);
1973             (void) signal (SIGQUIT, SIG_DFL);
1974
1975             (void) close (pd[1]);
1976             if (pd[0] != fileno (stdin)) {
1977                 (void) dup2 (pd[0], fileno (stdin));
1978                 (void) close (pd[0]);
1979             }
1980             execlp (name, r1bindex (name, '/'), NULLCP);
1981             fprintf (stderr, "unable to exec ");
1982             perror (name);
1983             _exit (-1);
1984
1985         default:
1986             (void) close (pd[0]);
1987             if (pd[1] != fileno (stdout)) {
1988                 (void) dup2 (pd[1], fileno (stdout));
1989                 (void) close (pd[1]);
1990             }
1991     }
1992 }
1993
1994
1995 m_pclose () {
1996     if (m_pid == NOTOK)
1997         return;
1998
1999     if (sd != NOTOK) {
2000         (void) fflush (stdout);
2001         if (dup2 (sd, fileno (stdout)) == NOTOK)
2002             adios ("standard output", "unable to dup2()");
2003
2004         clearerr (stdout);
2005         (void) close (sd);
2006         sd = NOTOK;
2007     }
2008     else
2009         (void) fclose (stdout);
2010
2011     (void) pidwait (m_pid, OK);
2012     m_pid = NOTOK;
2013 }
2014 @
2015
2016
2017 1.29
2018 log
2019 @use gethostbystring()
2020 @
2021 text
2022 @d3 1
2023 a3 1
2024 static char ident[] = "@@(#)$Id: mhlsbr.c,v 1.28 1992/12/15 00:20:22 jromine Exp jromine $";
2025 d1058 2
2026 d1061 4
2027 a1064 1
2028         c2 -> c_text = getcpy (buffer);
2029 @
2030
2031
2032 1.28
2033 log
2034 @endif sugar
2035 @
2036 text
2037 @d3 1
2038 a3 1
2039 static char ident[] = "@@(#)$Id: mhlsbr.c,v 1.27 1992/12/03 16:50:27 jromine Exp jromine $";
2040 d1535 3
2041 d1563 3
2042 a1565 8
2043         if (hp = gethostbyname (ap[0]))
2044             bcopy (hp -> h_addr, (char *) &addr, addrlen = hp -> h_length);
2045         else
2046             if (iaddr = inet_addr (ap[0]))
2047                 bcopy ((char *) &iaddr, (char *) &addr,
2048                         addrlen = sizeof iaddr);
2049             else
2050                 goto bad_faceproc;
2051 @
2052
2053
2054 1.27
2055 log
2056 @put u_short ifdef under #if AUX
2057 @
2058 text
2059 @d3 2
2060 a4 2
2061 static char ident[] = "@@(#)$Id: mhlsbr.c,v 1.26 1992/12/03 16:28:56 jromine Exp jromine $";
2062 #endif  lint
2063 d46 1
2064 a46 1
2065 #endif  SYS5
2066 d1456 1
2067 a1456 1
2068 #endif  BSD42
2069 d1472 1
2070 a1472 1
2071 #endif  BSD42
2072 d1485 1
2073 a1485 1
2074 #endif  BSD42
2075 d1592 1
2076 a1592 1
2077 #else   not BSD42 and not SOCKETS
2078 d1701 1
2079 a1701 1
2080 #endif  not BSD42 and not SOCKETS
2081 @
2082
2083
2084 1.26
2085 log
2086 @u_short AUX changes from Jim Guyton
2087 @
2088 text
2089 @d3 1
2090 a3 1
2091 static char ident[] = "@@(#)$Id: mhlsbr.c,v 1.25 1992/11/18 00:19:56 jromine Exp jromine $";
2092 d13 1
2093 a13 1
2094 #ifdef  SYS5
2095 @
2096
2097
2098 1.25
2099 log
2100 @add "newline" for consistency
2101 @
2102 text
2103 @d3 1
2104 a3 1
2105 static char ident[] = "@@(#)$Id: mhlsbr.c,v 1.24 1992/11/18 00:19:00 jromine Exp jromine $";
2106 d12 4
2107 @
2108
2109
2110 1.24
2111 log
2112 @add "nonewline" option
2113 @
2114 text
2115 @d3 1
2116 a3 1
2117 static char ident[] = "@@(#)$Id: mhlsbr.c,v 1.23 1992/11/17 00:03:06 jromine Exp jromine $";
2118 a197 1
2119                             "nonewline", NONEWLINE, 0,
2120 d215 2
2121 @
2122
2123
2124 1.23
2125 log
2126 @don't put an extra space at the end of the `%{text}' in a formatfield
2127 @
2128 text
2129 @d3 1
2130 a3 1
2131 static char ident[] = "@@(#)$Id: mhlsbr.c,v 1.22 1992/10/26 23:00:16 jromine Exp jromine $";
2132 d147 2
2133 a148 1
2134 #define LBITS   "\020\01NOCOMPONENT\02UPPERCASE\03CENTER\04CLEARTEXT\05EXTRA\06HDROUTPUT\07CLEARSCR\010LEFTADJUST\011COMPRESS\012ADDRFMT\013BELL\014DATEFMT\015FORMAT\016INIT\017FACEFMT\020FACEDFLT\021SPLIT"
2135 d198 1
2136 d1349 2
2137 @
2138
2139
2140 1.22
2141 log
2142 @TYPESIG
2143 @
2144 text
2145 @d3 1
2146 a3 1
2147 static char ident[] = "@@(#)$Id: mhlsbr.c,v 1.21 1992/10/16 21:36:54 jromine Exp jromine $";
2148 d1046 3
2149 @
2150
2151
2152 1.21
2153 log
2154 @add "-nobody"
2155 @
2156 text
2157 @d3 1
2158 a3 1
2159 static char ident[] = "@@(#)$Id: mhlsbr.c,v 1.20 1992/02/10 20:30:11 jromine Exp jromine $";
2160 d10 3
2161 d273 1
2162 a273 1
2163 static int      intrser (), pipeser (), quitser ();
2164 d1439 1
2165 a1439 1
2166 static  int intrser (i)
2167 d1455 1
2168 a1455 1
2169 static  int pipeser (i)
2170 d1468 1
2171 a1468 1
2172 static  int quitser (i)
2173 @
2174
2175
2176 1.20
2177 log
2178 @conform with RFC1153 for digests
2179 @
2180 text
2181 @d3 1
2182 a3 1
2183 static char ident[] = "@@(#)$Id: mhlsbr.c,v 1.19 1992/02/10 20:11:37 jromine Exp jromine $";
2184 d104 2
2185 d220 1
2186 d421 4
2187 d934 1
2188 a934 1
2189                     if (uleq (c1 -> c_name, "body")) {
2190 @
2191
2192
2193 1.19
2194 log
2195 @fix
2196 @
2197 text
2198 @d3 1
2199 a3 1
2200 static char ident[] = "@@(#)$Id: mhlsbr.c,v 1.18 1992/02/05 07:26:30 jromine Exp jromine $";
2201 d259 1
2202 a259 1
2203     "\n------------------------------------------------------------\n\n";
2204 @
2205
2206
2207 1.18
2208 log
2209 @put unseen sequence in mh-format
2210 @
2211 text
2212 @d3 1
2213 a3 1
2214 static char ident[] = "@@(#)$Id: mhlsbr.c,v 1.17 1992/01/31 22:12:40 jromine Exp jromine $";
2215 d1269 2
2216 a1270 1
2217     putstr (oneline (c2 -> c_text, c1 -> c_flags));
2218 @
2219
2220
2221 1.17
2222 log
2223 @kerberos
2224 @
2225 text
2226 @d3 1
2227 a3 1
2228 static char ident[] = "@@(#)$Id: mhlsbr.c,v 1.16 1991/01/25 14:49:46 mh Exp jromine $";
2229 d1015 1
2230 a1015 1
2231     int     dat[4];
2232 d1028 1
2233 a1028 1
2234     dat[0] = dat[1] = dat[2] = 0;
2235 @
2236
2237
2238 1.16
2239 log
2240 @don't include arpa/inet.h on hpux
2241 @
2242 text
2243 @d3 1
2244 a3 1
2245 static char ident[] = "@@(#)$Id: mhlsbr.c,v 1.15 91/01/16 08:56:04 mh Exp Locker: mh $";
2246 d105 1
2247 a105 1
2248     NULL, NULL
2249 d155 1
2250 a155 1
2251     NULL, NULL, "", NULL, NULL, 0, -1, 80, -1, 40, BELL, NULL
2252 d159 1
2253 a159 1
2254     NULL, NULL, NULL, NULL, NULL, 0, 0, 0, 0, 0, NOCOMPONENT, NULL
2255 d464 1
2256 a464 1
2257             *cp = NULL;
2258 d535 1
2259 a535 1
2260             *cp = NULL;
2261 d718 1
2262 a718 1
2263     *parptr = NULL;
2264 d742 1
2265 a742 1
2266     *cp = NULL;
2267 d846 1
2268 a846 1
2269                     buf[0] = NULL;
2270 d982 1
2271 a982 1
2272     return NULL;
2273 d997 1
2274 a997 1
2275         *dp = NULL;
2276 d1083 1
2277 a1083 1
2278                 *cp = NULL;
2279 d1296 1
2280 a1296 1
2281     if (*onelp == NULL)
2282 d1306 1
2283 a1306 1
2284                     *onelp++ = NULL;
2285 d1320 1
2286 a1320 1
2287         *cp = NULL;
2288 d1327 1
2289 a1327 1
2290             *onelp++ = NULL;
2291 d1378 1
2292 a1378 1
2293             buf[0] = NULL;
2294 @
2295
2296
2297 1.15
2298 log
2299 @add :nodashmunging option
2300 @
2301 text
2302 @d3 1
2303 a3 1
2304 static char ident[] = "@@(#)$Id: mhlsbr.c,v 1.14 90/04/05 14:58:08 sources Exp Locker: mh $";
2305 d1508 1
2306 d1510 1
2307 @
2308
2309
2310 1.14
2311 log
2312 @add ID
2313 @
2314 text
2315 @d3 1
2316 a3 1
2317 static char ident[] = "@@(#)$Id:$";
2318 d664 2
2319 @
2320
2321
2322 1.13
2323 log
2324 @make -[no]dashmunging hidden
2325 @
2326 text
2327 @d2 3
2328 @
2329
2330
2331 1.12
2332 log
2333 @allow formatfield on all fields
2334 @
2335 text
2336 @d84 1
2337 a84 1
2338     "dashmunging", 0,
2339 d86 1
2340 a86 1
2341     "nodashmunging", 0,
2342 @
2343
2344
2345 1.11
2346 log
2347 @goof in #define ...SW ordering
2348 @
2349 text
2350 @d1027 1
2351 a1027 1
2352     if (c1 -> c_flags & DATEFMT) {
2353 d1197 1
2354 a1197 1
2355     if (c1 -> c_nfs && (c1 -> c_flags & (ADDRFMT | DATEFMT)))
2356 @
2357
2358
2359 1.10
2360 log
2361 @additions for digests
2362 @
2363 text
2364 @d83 6
2365 a88 1
2366 #define HELPSW  13
2367 d91 1
2368 a91 1
2369 #define FORW1SW 14
2370 d93 1
2371 a93 1
2372 #define FORW2SW 15
2373 d95 1
2374 a95 1
2375 #define DGSTSW  16
2376 d97 1
2377 a97 1
2378 #define VOLUMSW 17
2379 d99 1
2380 a99 1
2381 #define ISSUESW 18
2382 a100 5
2383
2384 #define DASHSW  17
2385     "dashmunging", 0,
2386 #define NDASHSW 18
2387     "nodashmunging", 0,
2388 @
2389
2390
2391 1.9
2392 log
2393 @ANSI Compilance
2394 @
2395 text
2396 @d92 4
2397 d221 2
2398 d388 14
2399 d452 5
2400 a456 1
2401             (void) sprintf (buf, "End of %s Digest\n", digest);
2402 @
2403
2404
2405 1.8
2406 log
2407 @SOCKETS
2408 @
2409 text
2410 @d257 4
2411 a260 4
2412 void    mhladios (), mhldone ();
2413 int     intrser (), pipeser (), quitser ();
2414 char   *mcomp_add (), *oneline (), *parse ();
2415 struct mcomp *add_queue ();
2416 d262 3
2417 @
2418
2419
2420 1.7
2421 log
2422 @TYPESIG
2423 @
2424 text
2425 @d1466 1
2426 a1466 1
2427 #if defined(BSD42) || defined(hpux)
2428 d1535 1
2429 a1535 1
2430 #else
2431 d1644 1
2432 a1644 1
2433 #endif
2434 @
2435
2436
2437 1.6
2438 log
2439 @SYS5
2440 @
2441 text
2442 @d1656 1
2443 a1656 1
2444     int     (*istat) (), (*pstat) (), (*qstat) ();
2445 @
2446
2447
2448 1.5
2449 log
2450 @-[no]dashmunging
2451 some network defns
2452 @
2453 text
2454 @d34 4
2455 @
2456
2457
2458 1.4
2459 log
2460 @body: fix for missing component on blank lines
2461 @
2462 text
2463 @d90 1
2464 a90 1
2465     "dashmunging", -4,
2466 d92 1
2467 a92 1
2468     "nodashmunging", -6,
2469 d1462 1
2470 a1462 1
2471 #ifdef  BSD42
2472 d1472 1
2473 a1473 4
2474
2475 long    inet_addr ();
2476
2477
2478 d1488 1
2479 a1488 1
2480         long    iaddr;
2481 @
2482
2483
2484 1.3
2485 log
2486 @fix for BODYCOMP bug
2487 @
2488 text
2489 @d1236 6
2490 a1241 6
2491     while (cp = oneline (c2 -> c_text, c1 -> c_flags))
2492         if (*cp) {
2493             lm = count;
2494             if (flag == BODYCOMP
2495                     && !(c1 -> c_flags & NOCOMPONENT))
2496                 putstr (c1 -> c_text ? c1 -> c_text : c1 -> c_name);
2497 d1243 3
2498 a1245 6
2499             if (term == '\n')
2500                 putstr ("\n");
2501         }
2502         else
2503             if (term == '\n')
2504                 putstr ("\n");
2505 @
2506
2507
2508 1.2
2509 log
2510 @don't append extra newline to date fields
2511 @
2512 text
2513 @d1197 2
2514 a1239 1
2515                     && !(c1 -> c_flags & HDROUTPUT)
2516 @
2517
2518
2519 1.1
2520 log
2521 @Initial revision
2522 @
2523 text
2524 @d1002 2
2525 a1003 1
2526         c2 -> c_text = concat (buffer, "\n", NULLCP);
2527 @