cde/programs/dthelp/parser.ccdf/htag/helptag/help.if

   1 /*   Copyright (c) 1986, 1987, 1988, 1989, 1990 Hewlett-Packard Co. */
   2 /* Interface definition for HP Tag/TeX translator */
   3
   4 /* Things to watch out for:
   5
   6    1.  Index processing.  Notice for a number of tags (<BOOK> for example),
   7        there is specific code when the tag is in <IDX>:
   8          <START-CODE * IDX, * IDXSYN>, etc.
   9        Many tags don't have empty <* IDX> string-code processing, to save
  10        on executable size.  Therefore, when you add string-code processing
  11        to a tag, make sure you add empty string-code for <* IDX>.
  12    2.  Index processing for <COMPUTER>, <CURSOR>, <USER>.  They all have
  13        hardcoded default values for their parameters to save on program
  14        size (otherwise we have to uncomment parameter code).  This is not
  15        a problem since parameters is unimplemented.  Need to watch out for
  16        this when we do implement.
  17 */
  18
  19 /* Redefine m-starttextincell to enable */
  20 <!ENTITY m-starttextincell "">
  21
  22 <!ENTITY MINUS SDATA "-">
  23 <!ENTITY PM SDATA "<CHARACTERSET symbol><0xB1></CHARACTERSET>">
  24 <!ENTITY DIV SDATA "<CHARACTERSET symbol><0xB8></CHARACTERSET>">
  25 <!ENTITY TIMES SDATA "<CHARACTERSET symbol><0xB4></CHARACTERSET>">
  26 <!ENTITY LEQ SDATA "<CHARACTERSET symbol><0xA3></CHARACTERSET>">
  27 <!ENTITY GEQ SDATA "<CHARACTERSET symbol><0xB3></CHARACTERSET>">
  28 <!ENTITY NEQ SDATA "<CHARACTERSET symbol><0xB9></CHARACTERSET>">
  29 <!ENTITY COPY SDATA "<CHARACTERSET symbol><0xE3></CHARACTERSET>">
  30 <!ENTITY REG SDATA "<CHARACTERSET symbol><0xE2></CHARACTERSET>">
  31 <!ENTITY TM SDATA "<CHARACTERSET symbol><0xE4></CHARACTERSET>">
  32 <!ENTITY ELLIPSIS SDATA "<CHARACTERSET symbol><0xBC></CHARACTERSET>">
  33 <!ENTITY VELLIPSIS SDATA
  34 "
  35 .
  36 .
  37 .
  38 ">
  39 <!ENTITY PELLIPSIS SDATA "....">
  40 <!ENTITY A.M. SDATA "a.m.">
  41 <!ENTITY P.M. SDATA "p.m.">
  42 <!ENTITY MINUTES SDATA "<CHARACTERSET symbol><0xA2></CHARACTERSET>">
  43 <!ENTITY SECONDS SDATA "<CHARACTERSET symbol><0xB2></CHARACTERSET>">
  44 <!ENTITY DEG SDATA "<CHARACTERSET symbol><0xB0></CHARACTERSET>">
  45 <!ENTITY SQUOTE SDATA "`">
  46 <!ENTITY DQUOTE SDATA '"'>
  47 <!ENTITY ENDASH SDATA "-">
  48 <!ENTITY EMDASH SDATA " <CHARACTERSET symbol><0xBE></CHARACTERSET> ">
  49 <!ENTITY VBLANK SDATA "_">
  50 <!ENTITY CENTS SDATA "<CHARACTERSET iso8859-1><0xA2></CHARACTERSET>">
  51 <!ENTITY STERLING SDATA "<CHARACTERSET iso8859-1><0xA3></CHARACTERSET>">
  52 <!ENTITY M-D- PI "">
  53 <!ENTITY SIGSPACE SDATA "\ ">
  54 <!ENTITY MICRO SDATA "u">
  55 <!ENTITY OHM SDATA "ohm">
  56 <!ENTITY UP SDATA "up arrow">
  57 <!ENTITY DOWN SDATA "down arrow">
  58 <!ENTITY LEFT SDATA "\<-">
  59 <!ENTITY RIGHT SDATA "->">
  60 <!ENTITY HOME SDATA "home key">
  61 <!ENTITY BACK SDATA "\<--">
  62 <!ENTITY DATE SDATA CODE>
  63      time_t nseconds;
  64      struct tm *timefoo;
  65      int maxsize = 20;
  66      char s[20];
  67
  68      nseconds = time(NULL);
  69      timefoo = localtime(&nseconds);
  70      strftime(s, maxsize, "%x", timefoo);
  71      fprintf(outfile, "%s\n", s);
  72 <\CODE>
  73 <!ENTITY TIME SDATA CODE>
  74      time_t nseconds;
  75      struct tm *timefoo;
  76      int maxsize = 20;
  77      char s[20];
  78
  79      nseconds = time(NULL);
  80      timefoo = localtime(&nseconds);
  81      strftime(s, maxsize, "%X", timefoo);
  82      fprintf(outfile, "%s\n", s);
  83 <\CODE>
  84 <!ENTITY HALFSPACE SDATA " ">
  85 <!ENTITY M-SPECCHAR SDATA "Special characters">
  86
  87 /* entities for service documentation, not in doctype */
  88 /*
  89 *<!ENTITY INSTMAN SDATA "Refer to innstruction manual.">
  90 *<!ENTITY HAZVOLT SDATA "Hazardous voltage.">
  91 *<!ENTITY GROUND SDATA "Ground.">
  92 *<!ENTITY DCVOLT SDATA "DC voltage.">
  93 *<!ENTITY NEGPULSE SDATA "Negative pulse.">
  94 *<!ENTITY POSPULSE SDATA "Positive pulse.">
  95 *<!ENTITY SINEWAVE SDATA "Sine wave.">
  96 *<!ENTITY SAWWAVE SDATA "Saw wave.">
  97 *<!ENTITY RAMPWAVE SDATA "Ramp wave.">
  98 *<!ENTITY TRIWAVE SDATA "Triangle wave.">
  99 *<!ENTITY SQWAVE SDATA "Square wave.">
 100 */
 101 /*<!ENTITY calcent FILE "calc.ent">*/
 102
 103 /* Code entities for toggling debugging traces */
 104 <!ENTITY m-aopt PI CODE>
 105   m_malftrace = (LOGICAL) ! m_malftrace ;
 106   <\CODE>
 107
 108 <!ENTITY m-copt PI CODE>
 109   m_chtrace = (LOGICAL) ! m_chtrace ;
 110   <\CODE>
 111
 112 <!ENTITY m-dopt PI CODE>
 113   m_cdtrace = (LOGICAL) ! m_cdtrace ;
 114   <\CODE>
 115
 116 <!ENTITY m-hopt PI CODE>
 117   m_heapchk = (LOGICAL) ! m_heapchk ;
 118   <\CODE>
 119
 120 <!ENTITY m-oopt PI CODE>
 121   tracetostd = (LOGICAL) ! tracetostd ;
 122   <\CODE>
 123
 124 /* This option pertains to automatic index processing only (called by the
 125    scripts only), so we don't need it in pi's.
 126
 127 <!ENTITY m-popt PI CODE>
 128   parentsrch = (LOGICAL) ! parentsrch ;
 129   <\CODE>
 130
 131 */
 132
 133 <!ENTITY m-sopt PI CODE>
 134   m_scantrace = (LOGICAL) ! m_scantrace ;
 135   <\CODE>
 136
 137 <!ENTITY m-topt PI CODE>
 138   m_tagtrace = (LOGICAL) ! m_tagtrace ;
 139   <\CODE>
 140
 141 /* This option does not pertain to a given document, so we don't
 142    need it in pi's.
 143
 144 <!ENTITY m-xopt PI CODE>
 145   showmem = (LOGICAL) ! showmem ;
 146   <\CODE>
 147 */
 148
 149 /* Code entities for MARKUP and HP Tag versions */
 150 <!ENTITY m-markup-ver SDATA CODE>
 151   {
 152   M_WCHAR *wc_1, *wc_2;
 153
 154   wc_1 = MakeWideCharString(M_VERSION);
 155   wc_2 = MakeWideCharString("m-markup-ver");
 156   m_piaction(wc_1, wc_2, M_SDATA) ;
 157   m_free(wc_1,"wide character string");
 158   m_free(wc_2,"wide character string");
 159   }
 160   <\CODE>
 161
 162 <!ENTITY m-tagver SDATA CODE>
 163   {
 164   M_WCHAR *wc_1, *wc_2;
 165
 166   wc_1 = MakeWideCharString(version);
 167   wc_2 = MakeWideCharString("m-tagver");
 168   m_piaction(wc_1, wc_2, M_SDATA) ;
 169   m_free(wc_1,"wide character string");
 170   m_free(wc_2,"wide character string");
 171   }
 172   <\CODE>
 173
 174 <!ENTITY m-machine SDATA CODE>
 175 #if defined(MSDOS)
 176   m_piaction("VECTRA", "m-machine", M_SDATA) ;
 177 #else
 178 #if defined(hpux)
 179   {
 180   M_WCHAR *wc_1, *wc_2;
 181
 182   wc_1 = MakeWideCharString("HPUX");
 183   wc_2 = MakeWideCharString("m-machine");
 184   m_piaction(wc_1, wc_2, M_SDATA) ;
 185   m_free(wc_1,"wide character string");
 186   m_free(wc_2,"wide character string");
 187   }
 188 #else
 189 #if defined(_AIX)
 190   {
 191   M_WCHAR *wc_1, *wc_2;
 192
 193   wc_1 = MakeWideCharString("AIX");
 194   wc_2 = MakeWideCharString("m-machine");
 195   m_piaction(wc_1, wc_2, M_SDATA) ;
 196   m_free(wc_1,"wide character string");
 197   m_free(wc_2,"wide character string");
 198   }
 199 #else
 200 #if defined(sun)
 201   {
 202   M_WCHAR *wc_1, *wc_2;
 203
 204   wc_1 = MakeWideCharString("SUN");
 205   wc_2 = MakeWideCharString("m-machine");
 206   m_piaction(wc_1, wc_2, M_SDATA) ;
 207   m_free(wc_1,"wide character string");
 208   m_free(wc_2,"wide character string");
 209   }
 210 #else
 211   m_piaction("UNDEFINED MACHINE",
 212              "m-machine",
 213              M_SDATA) ;
 214 #endif
 215 #endif
 216 #endif
 217 #endif
 218   <\CODE>
 219
 220 <SIGN-ON>HP HelpTag Formatting System. - Version A.01.00  (DTD Version A.01.23)
 221 <GLOBAL-DEFINE>
 222 #define DEFINE
 223 #include "global.h"
 224 static char ident1[]="@(#)Help Tag Parser";
 225 static char ident2[]="@(#)Version Number: A.01.00";
 226 static char ident3[]="@(#)Copyright (c) 1993 Hewlett-Packard Company.    All rights reserved.";
 227
 228 <GLOBAL-DECLARE>
 229 #include "global.h"
 230
 231 <START-CODE>
 232   SEARCH *new ;
 233   char *p ;
 234   char *q ;
 235
 236   /* Pick version number out of sign-on message */
 237   if (p = strstr(m_signon, VERSION)) {
 238     p += strlen(VERSION) + 1 ;
 239     for (q = p ; *q && *q != '\n'; q++) ;
 240     if (*q == '\n') {
 241       version = (char *) m_malloc(q - p + 1, "version") ;
 242       *q = M_EOS ;
 243       strcpy(version, p) ;
 244       *q = '\n' ;
 245       }
 246     }
 247
 248   /* Following: please refer to comments in custom.c, m_setoptions() */
 249   if (m_argc > 2) {
 250     if ((strchr(m_argv[2], 'p')) || (strchr(m_argv[2], 'P')))
 251       parentsrch = TRUE ;  /* Implies we are processing indexes */
 252     }
 253
 254   helpcharset = MakeWideCharString("iso8859-1");
 255
 256   basename();
 257
 258   options(FALSE) ;
 259   if (m_errexit && stoponerror) m_exit(m_errexit) ;
 260
 261   if (indir) {
 262     new = (SEARCH *) m_malloc(sizeof(SEARCH), "search path") ;
 263     new->directory = indir ;
 264     new->next = path ;
 265     path = new ;
 266     }
 267
 268 <END-CODE>
 269   int i;
 270   prebye = ftell(outfile) ;
 271   fseek(outfile, texcomplete, SEEK_SET) ;
 272   fseek(outfile, 0L, SEEK_END) ;
 273   dumpxref() ;
 274   if (glossary) checkgloss() ;
 275
 276   /* end last node */
 277   fprintf(outfile, "</TOPIC>\n");
 278
 279   /* finish topic map */
 280
 281   fputs("\n", topicmapfp);
 282   while (lastnodelevel--) {
 283        /* indent routine >here< */
 284        for (i = lastnodelevel; i > 0; i--) { fputs("  ", topicmapfp); }
 285        fputs("}\n", topicmapfp);
 286   }
 287
 288   /* polish up .hmi file */
 289   if (!hadtitle) {
 290        fprintf(docregfp, "*title:\t\"No title specified.\"\n");
 291   }
 292   /* else -- handled in element title */
 293
 294   if (!hadabstract) {
 295        fprintf(docregfp, "*abstract:\t\"No abstract specified.");
 296        if (hadtitle) {
 297             char *mb_savedtitle;
 298
 299             mb_savedtitle = MakeMByteString(savedtitle);
 300             fprintf(docregfp, "  Title was ``%s''.", mb_savedtitle);
 301             m_free(mb_savedtitle,"multi-byte string");
 302        }
 303        fprintf(docregfp, "\"\n");
 304   }
 305   /* else -- handled in element abstract */
 306
 307   fprintf(docregfp, "*version:\t\"%s\"\n", version);
 308
 309   {
 310     char *mb_charset;
 311
 312     mb_charset = MakeMByteString(helpcharset);
 313     fprintf(docregfp, "*charSet:\t%s\n", mb_charset);
 314     m_free(mb_charset, "multi-byte string");
 315   }
 316
 317   /* warn if we have forward xrefs */
 318   if (have_forward_xrefs) {
 319        m_exit(77);
 320   }
 321
 322 <TEXT-CODE>
 323     outchar(m_textchar, outfile) ;
 324
 325 <PI-CODE>
 326    outpi(m_enttype, m_pi, m_entname) ;
 327
 328
 329 <ELEMENT ABBREV>
 330   <PARAM>
 331     where = WHERE (QTOC = TOC,
 332                    QFOOTER = FOOTER,
 333                    QBOTH = BOTH) ;
 334   <START-CODE CHAPHEAD RSUB>
 335     abbrev = TRUE ;
 336   <START-CODE CHAPHEAD RSECT>
 337     abbrev = TRUE ;
 338     fabbrev = (LOGICAL)
 339               (! m_wcmbupstrcmp(where, QFOOTER) ||
 340                ! m_wcmbupstrcmp(where, QBOTH)) ;
 341     if (fabbrev) {
 342       didabbrev = TRUE ;
 343       newhline = 0 ;
 344       }
 345     abbrev = TRUE ;
 346     fputs("<ABBREV>", outfile);
 347   <START-CODE CAPTION, CHAPHEAD MSGSUB>
 348     abbrev = TRUE ;
 349   <START-CODE CHAPHEAD CHAPTER, CHAPHEAD APPENDIX, CHAPTER MESSAGE,
 350               CHAPHEAD TEST, CHAPHEAD S1, CHAPHEAD S2, CHAPHEAD S3,
 351               CHAPHEAD S4, CHAPHEAD S5, CHAPHEAD S6, CHAPHEAD S7,
 352               CHAPHEAD S8, CHAPHEAD S9, CHAPHEAD HOMETOPIC>
 353     abbrev = TRUE ;
 354     fabbrev = (LOGICAL)
 355               (! m_wcmbupstrcmp(where, QFOOTER) ||
 356                ! m_wcmbupstrcmp(where, QBOTH)) ;
 357     if (fabbrev) {
 358       newhline = 0 ;
 359      }
 360     fputs("<ABBREV>", outfile);
 361   <START-CODE>
 362     M_WCHAR *wc_stago, *wc_tagc;
 363
 364     wc_stago = MakeWideCharString(m_stago);
 365     wc_tagc  = MakeWideCharString(m_tagc);
 366
 367     abbrev = TRUE ;
 368     fabbrev = (LOGICAL)
 369               (! m_wcmbupstrcmp(where, QFOOTER) ||
 370                ! m_wcmbupstrcmp(where, QBOTH)) ;
 371     if (fabbrev) {
 372       newhline = 0 ;
 373     }
 374     m_err2("Unimplemented %sABBREV%s reached", wc_stago, wc_tagc);
 375     m_free(wc_stago,"wide character string");
 376     m_free(wc_tagc,"wide character string");
 377   <END-CODE>
 378     fabbrev = FALSE ;
 379     abbrev = FALSE ;
 380   <END-CODE  CHAPHEAD RSECT,
 381              CHAPHEAD CHAPTER, CHAPHEAD APPENDIX, CHAPTER MESSAGE,
 382              CHAPHEAD TEST, CHAPHEAD S1, CHAPHEAD S2, CHAPHEAD S3,
 383              CHAPHEAD S4, CHAPHEAD S5, CHAPHEAD S6, CHAPHEAD S7,
 384              CHAPHEAD S8, CHAPHEAD S9, CHAPHEAD HOMETOPIC>
 385     fabbrev = FALSE ;
 386     abbrev = FALSE ;
 387     fputs("</ABBREV>\n", outfile);
 388
 389
 390 <ELEMENT ABSTRACT>
 391   <START-CODE>
 392     M_WCHAR *wc_abstract;
 393
 394     wc_abstract = MakeWideCharString("_ABSTRACT");
 395
 396     hadabstract = TRUE;
 397     needabstracthead = TRUE;
 398     starthelpnode(wc_abstract, TRUE);
 399     fputs("*abstract:\t", docregfp);
 400     m_free(wc_abstract,"wide character string");
 401   <END-CODE>
 402     fputs("\n", docregfp);
 403   <TEXT-CODE>
 404      outchar(m_textchar, outfile);
 405      if (m_textchar == '\n') {
 406         fputs(" \\\n", docregfp);
 407      }
 408      else {
 409          char mb_textchar[32];
 410          int     length;
 411
 412          length = wctomb(mb_textchar, m_textchar);
 413          mb_textchar[length] = '\0';
 414          fputs(mb_textchar, docregfp) ;
 415      }
 416
 417 <ELEMENT ACRO>
 418   <START-CODE>
 419     if (echo) {
 420       mb_echohead(m_stago);
 421       echohead(m_parent(0)) ;
 422       mb_echohead(m_net);
 423       }
 424   <END-CODE>
 425     if (echo) mb_echohead(m_net) ;
 426
 427   <START-CODE * IDX, * IDXSYN>
 428   <END-CODE * IDX, * IDXSYN>
 429   <END-CODE * EXAMPLESEG, * IMAGE>
 430     POPFONT ;
 431   <TEXT-CODE * IDX, * IDXSYN>
 432     indexchar(m_textchar) ;
 433   <TEXT-CODE>
 434     outchar(wc_toupper(m_textchar), outfile) ;
 435
 436 <ELEMENT ANNOTATION>
 437   <START-CODE>
 438     fputs("<TYPE serif><ANGLE italic><SPACING p>\n", outfile);
 439   <END-CODE>
 440     fputs("</SPACING></ANGLE></TYPE>\n", outfile);
 441
 442 <ELEMENT APPENDIX>
 443   <PARAM>
 444     id = ID ;
 445     letter = LETTER ;
 446     include = INCLUDE;
 447     exclude = EXCLUDE;
 448   <START-CODE>
 449     appstart(id, letter) ;
 450     thisnodelevel = 1;
 451     starthelpnode(id, FALSE);
 452   <END-CODE>
 453     rseqend() ;
 454     endhelpnode();
 455
 456
 457 <ELEMENT BIBLIO>
 458   <START-CODE>
 459     unimp(m_parent(0)) ;
 460                          /* when implementing:                              */
 461                          /*  (1) Don't forget need begin/end                */
 462                          /*  (2) Check code for <ITEM>                      */
 463                          /*  (3) Suppression of need between head and text? */
 464                          /*  (4) Consider if missing rev end check needed   */
 465   <TEXT-CODE>
 466   <END-CODE>
 467     outfile = m_outfile;
 468
 469 <ELEMENT BIBSUB>
 470
 471 <ELEMENT BINDERNO>
 472   <START-CODE>
 473     char *string =
 474       GetDefaultHeaderString("BinderNumberElementDefaultHeadingString",
 475                              M_SDATA,
 476                              "Binder Number");
 477
 478     mb_starthelpnode("_BINDERNO", TRUE);
 479     fprintf(outfile,
 480 "<TITLE><TYPE serif><WEIGHT bold><SIZE 14>%s</SIZE></WEIGHT></TYPE></TITLE>\n\n",
 481             string);
 482     fputs("<PARAGRAPH>", outfile);
 483     m_free(string, "default header string return");
 484   <END-CODE>
 485     fputs("</PARAGRAPH>\n\n", outfile);
 486
 487 <ELEMENT BOOK>
 488   <START-CODE>
 489     mb_strcode("<TYPE serif><ANGLE italic>", outfile) ;
 490     if (echo) {
 491       mb_echohead(m_stago) ;
 492       echohead(m_parent(0)) ;
 493       mb_echohead(m_net) ;
 494       }
 495   <END-CODE>
 496     mb_strcode("</ANGLE></TYPE>", outfile) ;
 497     if (echo) mb_echohead(m_net) ;
 498
 499   <START-CODE * IDX, * IDXSYN>
 500   <END-CODE * IDX, * IDXSYN>
 501   <TEXT-CODE * IDX, * IDXSYN>
 502     indexchar(m_textchar) ;
 503
 504 <ELEMENT CAPTION>
 505   <START-CODE FIGURE>
 506     figcaption = TRUE ;
 507     newhline = 0 ;
 508     savhd = TRUE ;
 509     hderr = FALSE ;
 510     svheadlen = 0 ;
 511     tooutput = TRUE ;
 512     fputs("<WEIGHT bold>", outfile);
 513   <END-CODE FIGURE>
 514     savehead[svheadlen] = M_EOS ;
 515     savhd = FALSE ;
 516     tooutput = TRUE ;
 517     fputs("</WEIGHT>", outfile);
 518
 519 <ELEMENT CALLTEXT>
 520   <PARAM>
 521     callno = CALLNO ;
 522   <TEXT-CODE>
 523
 524 <ELEMENT CAUTION>
 525   <START-CODE TEXT ITEM>
 526     STARTSTUFF
 527     /* In a tight list, paragraphs will have no trailing blank line.
 528      * To match HPTag behavior, we need to emit a blank line and
 529      * supress the leading blank line of the next paragraph, figure,
 530      * example, etc., if any.
 531     */
 532     ncwTightList = "";
 533     if ((lastlist->lastlist->space == TIGHT) &&
 534         (lastlist->lastlist->where == INSIDE)) {
 535        ncwTightList = " before 1";
 536     }
 537
 538     rshnewclear() ;
 539     notehead = FALSE ;
 540   <START-CODE>
 541     STARTSTUFF
 542     ncwTightList = "";
 543     rshnewclear() ;
 544     notehead = FALSE ;
 545   <END-CODE TEXT ITEM>
 546     fputs("</PARAGRAPH>\n\n", outfile);
 547     lastlist->lastlist->where = FOLLOW; /* supress leading newline */
 548   <END-CODE>
 549     fputs("</PARAGRAPH>\n\n", outfile);
 550
 551 <ELEMENT CCELL>
 552
 553 <ELEMENT CDISPLAY>
 554   <PARAM>
 555         file = ENTITY ;
 556         startrow = STARTROW  ;
 557         endrow = ENDROW  ;
 558         clip = CLIP ;
 559         margin = MARGIN ;
 560
 561 <ELEMENT CDROM>
 562   <START-CODE>
 563         /* ignore data chars meant only for cdrom */
 564         /* we need CDROMsaveoutfile and can't just say m_outfile,
 565            since we may be inside a table that has already
 566            been sending things to nullfile and it would be incorrect
 567            to start sending to m_outfile now. I.e., if outfile is
 568            currently nullfile, we keep sending to nullfile in the
 569            end-code*/
 570         CDROMsaveoutfile = outfile;
 571         outfile = nullfile;
 572   <END-CODE>
 573         /* OK, let the data flow.  CDROM is ending. */
 574         outfile = CDROMsaveoutfile;
 575
 576 <ELEMENT CELL>
 577   <PARAM>
 578     style = CELLSPEC ;
 579     span = SPAN ;
 580     vspan = VSPAN ;
 581
 582 <ELEMENT CHAPHEAD>
 583   <START-CODE MESSAGE>
 584     emsghead = USERHEAD ;
 585
 586 <ELEMENT CHAPTER>
 587   <PARAM>
 588     id = ID ;
 589     number = NUMBER ;
 590     include = INCLUDE  ;
 591     exclude = EXCLUDE  ;
 592   <START-CODE>
 593     assert_hometopic_exists();
 594     chapstart(id, number, "chapter") ;  /* opens new help file, too */
 595     thisnodelevel = 1;
 596     starthelpnode(id, FALSE);
 597   <END-CODE>
 598     rseqend() ;
 599     endhelpnode();
 600
 601 <ELEMENT CIRCLE>
 602   <TEXT-CODE>
 603     if (echo) mb_echohead("((") ;
 604     mb_strcode("(", outfile) ;
 605     outchar (m_textchar, outfile) ;
 606     mb_strcode(")", outfile) ;
 607     if (echo) mb_echohead("))") ;
 608   <START-CODE * IDX, * IDXSYN>
 609   <END-CODE * IDX, * IDXSYN>
 610   <TEXT-CODE * IDX, * IDXSYN>
 611     indexchar('(');
 612     indexchar(m_textchar) ;
 613     indexchar(')');
 614
 615 <ELEMENT CMD>
 616
 617 <ELEMENT CMDDESC>
 618
 619 <ELEMENT CMDDESCRIP>
 620
 621 <ELEMENT CMDNAME>
 622
 623 <ELEMENT CMDTYPE>
 624
 625 <ELEMENT COLH>
 626   <PARAM>
 627     style = CELLSPEC ;
 628     vspan = VSPAN  ;
 629     span = SPAN ;
 630
 631 <ELEMENT COLHEADS>
 632
 633 <ELEMENT COMPUTER>
 634   <START-CODE>
 635     mb_strcode("<TYPE serif><SPACING m>", outfile);
 636     if (echo) mb_echohead("``") ;
 637   <END-CODE>
 638     POPFONT ;
 639     mb_strcode("</SPACING></TYPE>", outfile);
 640     if (echo) mb_echohead("''") ;
 641   <TEXT-CODE>
 642      esoutchar(m_textchar) ;
 643   <TEXT-CODE * IMAGE>
 644      exoutchar(m_textchar) ;
 645   <TEXT-CODE * EXAMPLESEG>
 646      exoutchar(m_textchar) ;
 647
 648   <START-CODE * IDX, * IDXSYN>
 649   <END-CODE * IDX, * IDXSYN>
 650   <TEXT-CODE * IDX, * IDXSYN>
 651     indexchar(m_textchar) ;
 652
 653 <ELEMENT CONVENTIONS>
 654   <PARAM>
 655     include = INCLUDE  ;
 656     exclude = EXCLUDE  ;
 657   <START-CODE>
 658     mb_starthelpnode("_CONVENTIONS", TRUE);
 659
 660 <ELEMENT COPYRIGHT>
 661   <START-CODE>
 662     mb_starthelpnode("_COPYRIGHT", TRUE);
 663     fprintf(outfile, "<TITLE></TITLE>\n");
 664     /* No Head.  Let author have a clean slate. */
 665
 666 <ELEMENT COUNTRY>
 667   <START-CODE>
 668     char *string =
 669       GetDefaultHeaderString("CountryElementDefaultHeadingString",
 670                              M_SDATA,
 671                              "Country");
 672
 673     mb_starthelpnode("_COUNTRY", TRUE);
 674     fprintf(outfile, "<TITLE><TYPE serif><WEIGHT bold><SIZE 14>%s</SIZE></WEIGHT></TYPE></TITLE>\n\n", string);
 675     fputs("<PARAGRAPH>", outfile);
 676     m_free(string, "default header string return");
 677   <END-CODE>
 678     fputs("</PARAGRAPH>\n\n", outfile);
 679
 680 <ELEMENT CROW>
 681
 682 <ELEMENT CSPOT>
 683   <PARAM>
 684     file = ENTITY ;
 685     graphics = GRAPHICS (QNOGRAPHICS = NOGRAPHICS,
 686                          QGRAPHICS = GRAPHICS) ;
 687     width = WIDTH  ;
 688     height = HEIGHT  ;
 689
 690 <ELEMENT CSUSER>
 691   <START-CODE>
 692     if (echo) {
 693       mb_echohead(m_stago) ;
 694       echohead(m_parent(0)) ;
 695       mb_echohead(m_net) ;
 696       }
 697   <END-CODE>
 698     if (echo) mb_echohead(m_net) ;
 699   <START-CODE * OUTPUT...., * INPUT.....>
 700     if (echo) {
 701       mb_echohead(m_stago) ;
 702       echohead(m_parent(0)) ;
 703       mb_echohead(m_net) ;
 704       }
 705   <TEXT-CODE>
 706     esoutchar(m_textchar) ;
 707
 708 <ELEMENT CSYNHEADS>
 709
 710 <ELEMENT CSYNTAX>
 711   <START-CODE>
 712       char *mb_parent;
 713
 714       mb_parent = MakeMByteString(m_parent(0));
 715       notimp(mb_parent, "BIG/SMALL page styles") ;
 716       m_free(mb_parent,"multi-byte string");
 717   <END-CODE>
 718       outfile = m_outfile ;
 719
 720 <ELEMENT CTABLE>
 721   <PARAM>
 722     type = TYPE (QKEYS2 = KEYS2,
 723                  QCOMMAND = COMMAND) ;
 724     graphics = GRAPHICS (QNOGRAPHICS = NOGRAPHICS,
 725                          QGRAPHICS = GRAPHICS) ;
 726     displines = DISPLINES (QTWO = TWO,
 727                            QFOUR = FOUR,
 728                            QEIGHT = EIGHT,
 729                            QOTHER = OTHER) ;
 730   <START-CODE>
 731        char *mb_parent;
 732
 733        mb_parent = MakeMByteString(m_parent(0));
 734        notimp(mb_parent, "BIG/SMALL page styles") ;
 735        m_free(mb_parent,"multi-byte string");
 736   <END-CODE>
 737       outfile = m_outfile ;
 738
 739 <ELEMENT CURSOR>
 740   <START-CODE>
 741     if (echo) {
 742       mb_echohead(m_stago) ;
 743       echohead(m_parent(0)) ;
 744       mb_echohead(m_net) ;
 745       }
 746   <END-CODE>
 747     if (echo) mb_echohead(m_net) ;
 748   <TEXT-CODE>
 749     esoutchar(m_textchar) ;
 750   <TEXT-CODE * EXAMPLESEG>
 751     exoutchar(m_textchar) ;
 752
 753   <START-CODE * IDX, * IDXSYN>
 754   <END-CODE * IDX, * IDXSYN>
 755   <TEXT-CODE * IDX, * IDXSYN>
 756     indexchar(m_textchar) ;
 757
 758 <ELEMENT DEFAULT>
 759   <PARAM>
 760         calcqrgwidth = CALCQRGWIDTH ;
 761     ctbltype = CTBLTYPE (QKEYS2 = KEYS2,
 762                          QCOMMAND = COMMAND) ;
 763     ctblgraphics = CTBLGRAPHICS (QNOGRAPHICS = NOGRAPHICS,
 764                                  QGRAPHICS = GRAPHICS) ;
 765     ctbldisplines = CTBLDISPLINES (QTWO = TWO,
 766                                    QFOUR = FOUR,
 767                                    QEIGHT = EIGHT,
 768                                    QOTHER = OTHER) ;
 769     extype = EXTYPE (QCOMPUTER = COMPUTER,
 770                      QDISPLAY  = DISPLAY) ;
 771     expos = EXPOS (QLEFT = LEFT,
 772                    QINDENT = INDENT,
 773                    QCENTER = CENTER) ;
 774     exnotes = EXNOTES (QSIDE = SIDE,
 775                        QSTACK = STACK) ;
 776     exlines = EXLINES (QNUMBER = NUMBER,
 777                        QNONUMBER = NONUMBER) ;
 778     extextsize = EXTEXTSIZE (QNORMAL = NORMAL,
 779                              QSMALLER = SMALLER,
 780                              QSMALLEST = SMALLEST) ;
 781     gloss = GLOSS (QGLOSS = GLOSS,
 782                    QNOGLOSS = NOGLOSS) ;
 783     type = LISTTYPE (QORDER = ORDER,
 784                      QBULLET = BULLET,
 785                      QPLAIN = PLAIN,
 786                      QMILSPEC = MILSPEC,
 787                      QCHECK = CHECK) ;
 788     order = LISTORDERTYPE (QUALPHA = UALPHA,
 789                            QLALPHA = LALPHA,
 790                            QARABIC = ARABIC,
 791                            QUROMAN = UROMAN,
 792                            QLROMAN = LROMAN) ;
 793     spacing = LISTSPACING (QTIGHT = TIGHT,
 794                            QLOOSE = LOOSE) ;
 795     longlabel = LONGLABEL (QWRAP = WRAP,
 796                            QNOWRAP = NOWRAP) ;
 797     labelwidth = LABELWIDTH ;
 798     tableborder = TABLEBORDER (QBOX = BOX,
 799                                QNOBOX = NOBOX) ;
 800     tablerule = TABLERULE ;
 801     allvr = TABLEALLVR ;
 802     allhr = TABLEALLHR ;
 803     tablevr = TABLEVR ;
 804     tablehr = TABLEHR ;
 805     tablespacing = TABLESPACING (QTIGHT = TIGHT,
 806                                  QLOOSE = LOOSE) ;
 807     tablepos = TABLEPOS (QLEFT = LEFT,
 808                          QINDENT = INDENT,
 809                          QCENTER = CENTER) ;
 810     tabwidth = TABLEWIDTH (QFULL = FULL) ;
 811     tabletextsize = TABLETEXTSIZE (QNORMAL = NORMAL,
 812                                    QSMALLER = SMALLER,
 813                                    QSMALLEST = SMALLEST) ;
 814     notab = NUMBERTABLES (QNUMBER = NUMBER,
 815                           QNONUMBER = NONUMBER) ;
 816     figtype = FIGTYPE (QART = ART,
 817                        QPCL = PCL,
 818                        QTIFF = TIFF,
 819                        QTIF = TIF,
 820                        QLISTING = LISTING,
 821                        QTEXT = TEXT,
 822                        QHPGL = HPGL,
 823                        QHPG = HPG) ;
 824     oldfigtype = OLDFIGTYPE (QART = ART,
 825                              QPCL = PCL,
 826                              QTIFF = TIFF,
 827                              QLISTING = LISTING,
 828                              QTEXT = TEXT) ;
 829     figmagnify = FIGMAGNIFY (QFIT = FIT) ;
 830     figwidth = FIGWIDTH (QFULL = FULL,
 831                          QTEXT = TEXT,
 832                          QCURRENT = CURRENT) ;
 833     figheight = FIGHEIGHT (QNATURAL = NATURAL) ;
 834     figborder = FIGBORDER  (QTOP = TOP,
 835                             QBOTTOM = BOTTOM,
 836                             QBOX = BOX,
 837                             QSCREEN = SCREEN,
 838                             QNOBOX = NOBOX);
 839     figvideo = FIGVIDEO (QINVERSE = INVERSE,
 840                          QNOINVERSE = NOINVERSE) ;
 841     figstrip = FIGSTRIP (QSTRIP = STRIP,
 842                          QNOSTRIP = NOSTRIP) ;
 843     figmargin = FIGMARGIN ;
 844     figclip = FIGCLIP ;
 845     figpenwidth = FIGPENWIDTH ;
 846     figsnap = FIGSNAP (QSNAP = SNAP,
 847                        QNOSNAP = NOSNAP) ;
 848     figautoscale = FIGAUTOSCALE (QAUTOSCALE = AUTOSCALE,
 849                                  QNOAUTOSCALE = NOAUTOSCALE) ;
 850     figplottype = FIGPLOTTYPE ;
 851     listtextsize = LISTTEXTSIZE (QNORMAL = NORMAL,
 852                                  QSMALLER = SMALLER,
 853                                  QSMALLEST = SMALLEST) ;
 854     nofig = NUMBERFIGS (QNUMBER = NUMBER,
 855                         QNONUMBER = NONUMBER) ;
 856     eqn = EQN (QTEX = TEX) ;
 857     rsectp = RSECTPAGEBREAK (QNEWPAGE = NEWPAGE,
 858                              QSAMEPAGE = SAMEPAGE) ;
 859
 860 <ELEMENT DEFINITION>
 861   <END-CODE>
 862     fputs("</PARAGRAPH>\n\n", outfile);
 863
 864 <ELEMENT DESCRIP>
 865
 866 <ELEMENT DISPLAY> /* we are not handling calculator here */
 867   <START-CODE>
 868     mb_strcode("<TYPE serif><SPACING m>", outfile);
 869     if (echo) mb_echohead("::") ;
 870   <END-CODE>
 871     POPFONT ;
 872     mb_strcode("</SPACING></TYPE>", outfile);
 873     if (echo) mb_echohead("::") ;
 874   <TEXT-CODE, * TNOTE>
 875     esoutchar(m_textchar) ;
 876   <TEXT-CODE * EXAMPLESEG>
 877     exoutchar(m_textchar) ;
 878
 879   <START-CODE * IDX, * IDXSYN>
 880   <END-CODE * IDX, * IDXSYN>
 881   <TEXT-CODE * IDX, * IDXSYN>
 882     indexchar(m_textchar) ;
 883
 884 <ELEMENT DTERM>
 885   <START-CODE>
 886     termp = term ;
 887     tooutput = FALSE;
 888   <END-CODE>
 889     M_WCHAR *p ;
 890     tooutput = TRUE;
 891     *termp = M_EOS ;
 892     /* trim possible (perhaps) last space */
 893     if (termp - term > 1 && *(termp-1) == ' ') {
 894          *(termp-1) = M_EOS;
 895     }
 896     if (m_ntrtrie(term, &gtree, (M_TRIE *) DEFINETERM)) {
 897          if (! m_resettrie(&gtree, term, (M_TRIE *) DEFINETERM)) {
 898               m_error("Internal error. Can't reset glossary trie") ;
 899               m_exit(TRUE) ;
 900          }
 901     }
 902     fputs("<PARAGRAPH after 0 leftindent 3 id \"", outfile);
 903     for (p = term; *p ; p++) {
 904          if (*p == ' ') {
 905               outchar('_', outfile);
 906          }
 907          else {
 908               outchar(wc_toupper(*p), outfile);
 909          }
 910     }
 911     fputs("_DEF\">", outfile);
 912     /* handle .idt file, too */
 913     {
 914     char *mb_nodeid;
 915
 916     mb_nodeid = MakeMByteString(nodeid);
 917     fprintf(idtablefp, "%s> ", mb_nodeid);
 918     m_free(mb_nodeid,"multi-byte string");
 919     }
 920     for (p = term; *p ; p++) {
 921          if (*p == ' ') {
 922               fputc('_', idtablefp);
 923          }
 924          else {
 925               M_WCHAR uwc;
 926               char    mb_uwc[32]; /* arbitrarily large */
 927               int     length;
 928
 929               uwc = wc_toupper(*p);
 930               length = wctomb(mb_uwc, uwc);
 931               mb_uwc[length] = '\0';
 932               fputs(mb_uwc, idtablefp);
 933          }
 934     }
 935     fputs("_DEF\n", idtablefp);
 936     /* end */
 937     fputs("<WEIGHT bold>", outfile);
 938     for(p = term; *p; p++) {
 939          outchar(*p, outfile) ;
 940     }
 941     fputs("</WEIGHT>", outfile);
 942   <TEXT-CODE>
 943     termchar(m_textchar) ;
 944   <PI-CODE>
 945     termpi(m_enttype, m_pi, m_entname) ;
 946
 947 <ELEMENT EDITION>
 948   <START-CODE>
 949     char *string =
 950       GetDefaultHeaderString("EditionElementDefaultHeadingString",
 951                              M_SDATA,
 952                              "Edition");
 953
 954     mb_starthelpnode("_EDITION", TRUE);
 955     fprintf(outfile, "<TITLE><TYPE serif><WEIGHT bold><SIZE 14>%s</SIZE></WEIGHT></TYPE></TITLE>\n\n", string);
 956     fputs("<PARAGRAPH>", outfile);
 957     m_free(string, "default header string return");
 958   <END-CODE>
 959     fputs("</PARAGRAPH>\n\n", outfile);
 960
 961 <ELEMENT EMPH>
 962   <START-CODE>
 963     mb_strcode("<ANGLE italic>", outfile) ;
 964     if (echo) mb_echohead("!!") ;
 965   <END-CODE>
 966     mb_strcode("</ANGLE>", outfile) ;
 967     if (echo) mb_echohead("!!") ;
 968
 969   <START-CODE * IDX, * IDXSYN>
 970   <END-CODE * IDX, * IDXSYN>
 971   <TEXT-CODE * IDX, * IDXSYN>
 972     indexchar(m_textchar) ;
 973
 974 <ELEMENT ENTRYPOINTSET>
 975   <START-CODE>
 976     mb_starthelpnode("_ENTRYPOINTSET", TRUE);
 977     fprintf(outfile, "<PARAGRAPH><TYPE serif><WEIGHT bold><SIZE 14>%s</SIZE></WEIGHT></TYPE></PARAGRAPH>\n\n", "Entrypointset");
 978
 979 <ELEMENT ENTRYPOINT>
 980
 981 <ELEMENT EQN>
 982   <PARAM>
 983     formatter = FORMATTER (QTEX = TEX) ;
 984   <START-CODE>
 985     fputs("<PARAGRAPH>", outfile);
 986     unimp(m_parent(0)) ;
 987   <END-CODE>
 988     fputs("</PARAGRAPH>\n", outfile);
 989
 990 <ELEMENT ESC>
 991   <START-CODE * IDX, * IDXSYN>
 992   <END-CODE * IDX, * IDXSYN>
 993   <TEXT-CODE * IDX, * IDXSYN>
 994     indexchar(m_textchar) ;
 995   <START-CODE>
 996     if (echo) {
 997       mb_echohead(m_stago) ;
 998       echohead(m_parent(0)) ;
 999       mb_echohead(m_net) ;
1000       }
1001   <END-CODE>
1002     if (echo) mb_echohead(m_net) ;
1003
1004 <ELEMENT EX>
1005   <PARAM>
1006     type = TYPE (QCOMPUTER = COMPUTER,
1007                  QDISPLAY  = DISPLAY) ;
1008     position = POSITION (QLEFT = LEFT,
1009                          QINDENT = INDENT,
1010                          QCENTER = CENTER) ;
1011     notes = NOTES (QSIDE = SIDE,
1012                    QSTACK = STACK) ;
1013     width = WIDTH ;
1014     lines = LINES (QNUMBER = NUMBER,
1015                    QNONUMBER = NONUMBER) ;
1016     textsize = TEXTSIZE (QNORMAL = NORMAL,
1017                          QSMALLER = SMALLER,
1018                          QSMALLEST = SMALLEST) ;
1019   <START-CODE TEXT ITEM>
1020     /* In a tight list, paragraphs will have no trailing blank line.
1021      * To match HPTag behavior, we need to emit a blank line and
1022      * supress the leading blank line of the next paragraph, figure,
1023      * example, etc., if any.
1024     */
1025     char *listinfo;
1026
1027     listinfo = "";
1028     if ((lastlist->lastlist->space == TIGHT) &&
1029         (lastlist->lastlist->where == INSIDE)) {
1030        listinfo = " before 1";
1031     }
1032
1033     exvexstart(type, textsize, listinfo);
1034     tonumexlines = (LOGICAL) (vnumber(lines) == NUMBER);
1035     exlineno = 1 ;
1036   <START-CODE>
1037     exvexstart(type, textsize, "") ;
1038     tonumexlines = (LOGICAL) (vnumber(lines) == NUMBER);
1039     exlineno = 1 ;
1040   <END-CODE TEXT ITEM>
1041     /* Clear tonumexlines for other elements (e.g., image) which may
1042        follow */
1043     tonumexlines = FALSE ;
1044     exvexend(textsize);
1045     lastlist->lastlist->where = FOLLOW; /* supress leading newline */
1046   <END-CODE>
1047     /* Clear tonumexlines for other elements (e.g., image) which may
1048        follow */
1049     tonumexlines = FALSE ;
1050     exvexend(textsize);
1051
1052 <ELEMENT EXAMPLESEG>
1053   <START-CODE>
1054     if (tonumexlines) fprintf(outfile, " %d:  ", exlineno) ;
1055   <END-CODE>
1056     exlineno++ ;
1057   <TEXT-CODE>
1058      exoutchar(m_textchar) ;
1059
1060 <ELEMENT EXPLAIN>
1061
1062 <ELEMENT FICHENO>
1063   <START-CODE>
1064     char *string =
1065       GetDefaultHeaderString("FichenoElementDefaultHeadingString",
1066                              M_SDATA,
1067                              "Ficheno");
1068
1069     mb_starthelpnode("_FICHENO", TRUE);
1070     fprintf(outfile, "<TITLE><TYPE serif><WEIGHT bold><SIZE 14>%s</SIZE></WEIGHT></TYPE></TITLE>\n\n", string);
1071     fputs("<PARAGRAPH>", outfile);
1072     m_free(string, "default header string return");
1073   <END-CODE>
1074     fputs("</PARAGRAPH>\n\n", outfile);
1075
1076 <ELEMENT FIGNOTE>
1077   <START-CODE>
1078     if (ftype != ART)
1079       {
1080       M_WCHAR *wc_stago, *wc_tagc;
1081
1082       wc_stago = MakeWideCharString(m_stago);
1083       wc_tagc  = MakeWideCharString(m_tagc);
1084       m_err3("%s%s%s allowed only in ART figures",
1085              wc_stago,
1086              m_parent(0),
1087              wc_tagc) ;
1088       m_free(wc_stago,"wide character string");
1089       m_free(wc_tagc,"wide character string");
1090       }
1091     fignote = TRUE ;
1092
1093 <ELEMENT FIGTEXT>
1094   <START-CODE>
1095     M_WCHAR *wc_stago, *wc_tagc;
1096
1097     wc_stago = MakeWideCharString(m_stago);
1098     wc_tagc  = MakeWideCharString(m_tagc);
1099     if (ftype != TEXT)
1100       {
1101       M_WCHAR *wc_stago, *wc_tagc;
1102
1103       wc_stago = MakeWideCharString(m_stago);
1104       wc_tagc  = MakeWideCharString(m_tagc);
1105       m_err3("%s%s%s allowed only in TEXT figures",
1106              wc_stago,
1107              m_parent(0),
1108              wc_tagc) ;
1109       m_free(wc_stago,"wide character string");
1110       m_free(wc_tagc,"wide character string");
1111       }
1112
1113 <ELEMENT FIGURE>
1114   <PARAM>
1115     number = NUMBER ;
1116     tonumber = TONUMBER (QNUMBER = NUMBER,
1117                          QNONUMBER = NONUMBER) ;
1118     id = ID ;
1119     file = ENTITY ;
1120     figpos = FIGPOS (QLEFT = LEFT,
1121                      QCENTER = CENTER,
1122                      QRIGHT = RIGHT) ;
1123     cappos = CAPPOS (QLEFT = LEFT,
1124                      QCENTER = CENTER,
1125                      QRIGHT = RIGHT) ;
1126     oldtype = OLDTYPE (QART = ART,
1127                        QPCL = PCL,
1128                        QTIFF = TIFF,
1129                        QLISTING = LISTING,
1130                        QTEXT = TEXT) ;
1131     xwidth = WIDTH (QFULL = FULL,
1132                    QTEXT = TEXT,
1133                    QCURRENT = CURRENT) ;
1134     xdepth = HEIGHT (QNATURAL = NATURAL) ;
1135     xhadjust = HADJUST ;
1136     xvadjust = VADJUST ;
1137     border = BORDER (QTOP = TOP,
1138                      QBOTTOM = BOTTOM,
1139                      QBOX = BOX,
1140                      QSCREEN = SCREEN,
1141                      QNOBOX = NOBOX) ;
1142     type = TYPE  (QART = ART,
1143                   QPCL = PCL,
1144                   QTIFF = TIFF,
1145                   QTIF = TIF,
1146                   QLISTING = LISTING,
1147                   QTEXT = TEXT,
1148                   QHPGL = HPGL,
1149                   QHPG = HPG);
1150     xmagnify = MAGNIFY (QFIT = FIT) ;
1151     video = VIDEO (QINVERSE = INVERSE,
1152                    QNOINVERSE = NOINVERSE) ;
1153     strip = STRIP (QSTRIP = STRIP,
1154                    QNOSTRIP = NOSTRIP) ;
1155     mirror = MIRROR (QMIRROR = MIRROR) ;
1156     margin = MARGIN ;
1157     clip = CLIP ;
1158     penwidth = PENWIDTH ;
1159     snap = SNAP (QSNAP = SNAP,
1160                  QNOSNAP = NOSNAP) ;
1161     autoscale = AUTOSCALE (QAUTOSCALE = AUTOSCALE,
1162                            QNOAUTOSCALE = NOAUTOSCALE) ;
1163     plottype = PLOTTYPE ;
1164     callout = CALLOUT ;
1165     textsize = TEXTSIZE (QNORMAL = NORMAL,
1166                          QSMALLER = SMALLER,
1167                          QSMALLEST = SMALLEST) ;
1168     ghyperlink = GHYPERLINK  ;
1169     glinktype = GLINKTYPE (QJUMP = JUMP,
1170                            QJUMPNEWVIEW = JUMPNEWVIEW,
1171                            QDEFINITION = DEFINITION,
1172                            QEXECUTE = EXECUTE,
1173                            QAPPDEFINED = APPDEFINED,
1174                            QMAN = MAN) ;
1175     gdescription = GDESCRIPTION  ;
1176   <START-CODE TEXT ITEM>
1177     /* In a tight list, paragraphs will have no trailing blank line.
1178      * To match HPTag behavior, we need to emit a blank line and
1179      * supress the leading blank line of the next paragraph, figure,
1180      * example, etc., if any.
1181     */
1182      char *listinfo;
1183
1184      listinfo = "";
1185      if ((lastlist->lastlist->space == TIGHT) &&
1186          (lastlist->lastlist->where == INSIDE)) {
1187         listinfo = " before 1";
1188      }
1189
1190      figure(number,
1191             tonumber,
1192             id,
1193             file,
1194             figpos,
1195             cappos,
1196             oldtype,
1197             xwidth,
1198             xdepth,
1199             xhadjust,
1200             xvadjust,
1201             border,
1202             type,
1203             xmagnify,
1204             video,
1205             strip,
1206             mirror,
1207             margin,
1208             clip,
1209             penwidth,
1210             snap,
1211             autoscale,
1212             plottype,
1213             callout,
1214             textsize,
1215             ghyperlink,
1216             glinktype,
1217             gdescription,
1218             listinfo);
1219   <START-CODE>
1220      figure(number,
1221             tonumber,
1222             id,
1223             file,
1224             figpos,
1225             cappos,
1226             oldtype,
1227             xwidth,
1228             xdepth,
1229             xhadjust,
1230             xvadjust,
1231             border,
1232             type,
1233             xmagnify,
1234             video,
1235             strip,
1236             mirror,
1237             margin,
1238             clip,
1239             penwidth,
1240             snap,
1241             autoscale,
1242             plottype,
1243             callout,
1244             textsize,
1245             ghyperlink,
1246             glinktype,
1247             gdescription,
1248             "");
1249   <END-CODE TEXT ITEM>
1250     fputs("\n</FIGURE>\n</PARAGRAPH>\n\n", outfile);
1251     if (id) {
1252      /* id handling */
1253      char *mb_nodeid, *mb_id;
1254
1255      mb_nodeid = MakeMByteString(nodeid);
1256      mb_id     = MakeMByteString(id);
1257      fprintf(idtablefp, "%s> %s\n", mb_nodeid, mb_id);
1258      m_free(mb_nodeid,"multi-byte string");
1259      m_free(mb_id,"multi-byte string");
1260     }
1261     lastlist->lastlist->where = FOLLOW; /* supress leading newline */
1262   <END-CODE>
1263     fputs("\n</FIGURE>\n</PARAGRAPH>\n\n", outfile);
1264     if (id) {
1265      /* id handling */
1266      char *mb_nodeid, *mb_id;
1267
1268      mb_nodeid = MakeMByteString(nodeid);
1269      mb_id     = MakeMByteString(id);
1270      fprintf(idtablefp, "%s> %s\n", mb_nodeid, mb_id);
1271      m_free(mb_nodeid,"multi-byte string");
1272      m_free(mb_id,"multi-byte string");
1273     }
1274
1275
1276 <ELEMENT FILLIN>
1277   <PARAM>
1278     length = LENGTH (QEND = END) ;
1279   <START-CODE>
1280     if (m_wcmbupstrcmp(length, QEND))
1281         {
1282         char *mb_parent;
1283
1284         mb_parent = MakeMByteString(m_parent(0));
1285         if (mb_checkdimen( length, "LENGTH", mb_parent ))
1286             {
1287             /* check for negative values */
1288             M_WCHAR wmi;
1289
1290             mbtowc(&wmi, "-", 1);
1291             if (w_strchr(length, wmi))
1292                 {
1293                 M_WCHAR *wc_stago, *wc_tagc;
1294
1295                 wc_stago = MakeWideCharString(m_stago);
1296                 wc_tagc  = MakeWideCharString(m_tagc);
1297                 m_err3("Negative value [%s] for %sFILLIN%s, positive assumed",
1298                        length,
1299                        wc_stago,
1300                        wc_tagc) ;
1301                 m_free(wc_stago,"wide character string");
1302                 m_free(wc_tagc,"wide character string");
1303                 }
1304             }
1305         m_free(mb_parent,"multi-byte string");
1306         }
1307
1308 <ELEMENT FOOTER>
1309   <START-CODE>
1310       /* Headers and footers make no sense to Cache Creek; throw away
1311        * all content.  We could do this with empty text-code here and
1312        * context sensitive empty text-code in all elements of the model
1313        * group that define their own text-code but that's really error
1314        * prone and difficult to maintain.
1315       */
1316       HFsaveoutfile = outfile;
1317       outfile = nullfile;
1318   <END-CODE>
1319       outfile = HFsaveoutfile;
1320
1321 <ELEMENT FOOTNOTE>
1322   /* When implementing, check conditionals of <FOOTNOTE> in <P>    */
1323   <TEXT-CODE * EXAMPLESEG, * IMAGE>
1324     outchar(m_textchar, outfile) ;
1325   <END-CODE>
1326     footnoteno++;
1327     POPFONT;
1328
1329 <ELEMENT FRONT>
1330
1331 <ELEMENT FRONTSUB>
1332   <PARAM>
1333     include = INCLUDE  ;
1334     exclude = EXCLUDE  ;
1335 <START-CODE OTHERFRONT>
1336    if (!had_an_otherfront_head) {
1337         endhead();
1338    }
1339
1340 <ELEMENT GLOSSARY>
1341   <START-CODE>
1342     char *string =
1343       GetDefaultHeaderString("GlossaryElementDefaultHeadingString",
1344                              M_SDATA,
1345                              "Glossary");
1346
1347     open_new_helpfile();
1348     thisnodelevel = 1;
1349     mb_starthelpnode("_GLOSSARY", FALSE);
1350     strcpy(chapstring, string) ;
1351     if (strlen(chapstring) + 1 > sizeof(chapstring)) {
1352       m_error("Program error: exceeded chapstring") ;
1353       m_exit(TRUE) ;
1354       }
1355     fputs("\nGlossary\n", stderr) ;
1356     glossary = TRUE ;
1357     fprintf(outfile, "<TITLE><TYPE serif><WEIGHT bold><SIZE 14>%s</SIZE></WEIGHT></TYPE></TITLE>\n", string) ;
1358     m_free(string, "default header string return");
1359   <END-CODE>
1360     endhelpnode();
1361
1362 <ELEMENT GRAPHIC>
1363   <PARAM>
1364     id = ID ;
1365     file = ENTITY ;
1366 <START-CODE>
1367     unsigned char etype, wheredef ;
1368      /* Code from figstart */
1369   if (id) {
1370     mbstowcs(xrefstring, "\\<xref graphic>", 400);
1371     xstrlen = w_strlen(xrefstring) ;
1372     m_getline(&xrffile, &xrfline) ;
1373     if (xrffile == NULL) {
1374          /* set to primary input source */
1375          xrffile = inputname;
1376     }
1377     setid(id,
1378           TRUE,
1379           FALSE,
1380           inchapter,
1381           chapstring,
1382           xrffile,
1383           xrfline,
1384           FALSE) ;
1385
1386     {
1387     char *mb_nodeid, *mb_id;
1388
1389     mb_nodeid = MakeMByteString(nodeid);
1390     mb_id     = MakeMByteString(id);
1391     fprintf(idtablefp, "%s> %s\n", mb_nodeid, mb_id);
1392     m_free(mb_nodeid,"multi-byte string");
1393     m_free(mb_id,"multi-byte string");
1394     }
1395     }
1396   /* initialize some stuff first:
1397      - file is the entity name,
1398      - f_file is the content of the entity,
1399        used only if f_content nonNULL
1400      - f_content is f_file with the relative pathname, initialized to NULL,
1401      - f_contqual is fully qualified f_file, assigned ONLY IF
1402        f_content nonNULL
1403   */
1404   file_ent = FALSE ;
1405   f_content = NULL ;
1406   f_contqual[0] = M_EOS ;
1407
1408   /* check ENTITY and determine the figure type  */
1409   if (file) {
1410     m_lookent(file, &etype, &f_file, &wheredef) ;
1411     if (etype != M_SYSTEM) {
1412       M_WCHAR *wc_stago, *wc_tagc, *wc_entsystem, *wc_entkw;
1413
1414       wc_stago     = MakeWideCharString(m_stago);
1415       wc_tagc      = MakeWideCharString(m_tagc);
1416       wc_entsystem = MakeWideCharString(m_entsystem);
1417       wc_entkw     = MakeWideCharString(m_entkw);
1418       m_err6("%s not a %s %s, as required for the ENTITY parameter of %s%s%s",
1419              file,
1420              wc_entsystem,
1421              wc_entkw,
1422              wc_stago,
1423              m_parent(0),
1424              wc_tagc) ;
1425       m_free(wc_stago,"wide character string");
1426       m_free(wc_tagc,"wide character string");
1427       m_free(wc_entsystem,"wide character string");
1428       m_free(wc_entkw,"wide character string");
1429       }
1430     else {
1431       file_ent = TRUE ;
1432       f_content = searchforfile(f_file) ;
1433       if (f_content) {
1434         if (getqualified(f_contqual, f_content)) {
1435           /* unsuccessful qual */
1436           if (w_strlen(f_content) < FNAMELEN)
1437             w_strcpy(f_contqual, f_content) ;
1438           else {
1439             m_err1("Internal error. File name too long: %s", f_content) ;
1440             m_exit(m_errexit) ;
1441             }
1442           }
1443         }
1444       else {
1445         m_err2("Can't find file %s (declared in entity %s)", f_file, file) ;
1446         }
1447       }
1448     }
1449
1450     {
1451     char *mb_content;
1452     static M_WCHAR empty = M_EOS;
1453
1454     if (!f_content) f_content = &empty;
1455
1456     mb_content = MakeMByteString(f_content);
1457     fprintf(outfile, "<GRAPHIC file %s", mb_content);
1458     m_free(mb_content,"multi-byte string");
1459     }
1460     if (id) {
1461          char *mb_id;
1462
1463          mb_id = MakeMByteString(id);
1464          fprintf(outfile, " id %s", mb_id);
1465          m_free(mb_id,"multi-byte string");
1466     }
1467     fputs(">", outfile);
1468
1469 <ELEMENT HARDWARE>
1470   <START-CODE>
1471     char *string =
1472       GetDefaultHeaderString("HardwareElementDefaultHeadingString",
1473                              M_SDATA,
1474                              "Hardware");
1475
1476     mb_starthelpnode("_HARDWARE", TRUE);
1477     fprintf(outfile, "<TITLE><TYPE serif><WEIGHT bold><SIZE 14>%s</SIZE></WEIGHT></TYPE></TITLE>\n\n", string);
1478     newhline = 0 ;
1479     fputs("<PARAGRAPH>", outfile);
1480     m_free(string, "default header string return");
1481   <END-CODE>
1482     fputs("</PARAGRAPH>\n\n", outfile);
1483
1484 <ELEMENT HEAD>
1485 /* Accent headings */
1486   <START-CODE NOTE, CAUTION, WARNING>
1487     notehead = TRUE ;
1488     newhline = 0 ;
1489     fprintf(outfile, ncwStart, ncwTightList);
1490 /* Other headings */
1491   <START-CODE P>
1492     newhline = 0 ;
1493     fputs("<PARAGRAPH><TYPE serif><WEIGHT bold>", outfile);
1494 /* Other headings */
1495   <START-CODE IMAGE>
1496     newhline = 0 ;
1497     fputs("<PARAGRAPH><TYPE serif><WEIGHT bold>", outfile);
1498 /* Other headings */
1499   <START-CODE  LIST, LABLIST, EX, SYNTAX>
1500     newhline = 0 ;
1501     fputs("<PARAGRAPH><TYPE serif><WEIGHT bold>", outfile);
1502 /* Node headings */
1503   <START-CODE CHAPHEAD APPENDIX, CHAPHEAD CHAPTER,
1504               CHAPHEAD RSECT, CHAPHEAD S1, CHAPHEAD S2, CHAPHEAD S3,
1505               CHAPHEAD S4, CHAPHEAD S5, CHAPHEAD S6, CHAPHEAD S7,
1506               CHAPHEAD S8, CHAPHEAD S9, CHAPHEAD TEST, CHAPHEAD BIBLIO,
1507               CHAPHEAD HOMETOPIC
1508               >
1509     newhline = 0 ;
1510     echo = TRUE ;
1511     savhd = TRUE ;
1512     hderr = FALSE ;
1513     svheadlen = 0 ;
1514     fputs("<TITLE><TYPE serif><WEIGHT bold><SIZE 14>", outfile);
1515 /* Non node headings */
1516   <START-CODE OTHERHEAD, CHAPHEAD RSUB, CHAPHEAD MSGSUB>
1517     newhline = 0 ;
1518     echo = TRUE ;
1519     savhd = TRUE ;
1520     hderr = FALSE ;
1521     svheadlen = 0 ;
1522     fputs("<PARAGRAPH><TYPE serif><WEIGHT bold><SIZE 12>", outfile);
1523 /* Other headings */ /* notably procedure */
1524   <START-CODE CHAPHEAD PROCEDURE>
1525     newhline = 0 ;
1526     echo = TRUE ;
1527     savhd = TRUE ;
1528     hderr = FALSE ;
1529     svheadlen = 0 ;
1530     fputs("<PARAGRAPH><TYPE serif><WEIGHT bold>", outfile);
1531 /* Other headings */
1532   <START-CODE CHAPHEAD>
1533      M_WCHAR *wc_stago, *wc_tagc;
1534
1535      wc_stago = MakeWideCharString(m_stago);
1536      wc_tagc  = MakeWideCharString(m_tagc);
1537      m_err2("Unimplemented %sCHAPHEAD%s reached", wc_stago, wc_tagc);
1538      m_free(wc_stago,"wide character string");
1539      m_free(wc_tagc,"wide character string");
1540 /* Node heading */
1541   <START-CODE PART>
1542 /* Non-node headings */
1543   <START-CODE FRONTSUB>
1544     echo = TRUE ;
1545     newhline = 0 ;
1546     fputs("<PARAGRAPH><TYPE serif><WEIGHT bold><SIZE 12>", outfile);
1547 /* Non-node headings */
1548   <START-CODE LEGAL, SAFETY, MAP, ABSTRACT, PREFACE, CONVENTIONS, HISTORY>
1549     echo = TRUE ;
1550     newhline = 0 ;
1551     needabstracthead = FALSE;
1552     fputs("<TITLE><TYPE serif><WEIGHT bold><SIZE 12>", outfile);
1553 /* Node headings */
1554   <START-CODE OTHERFRONT>
1555     had_an_otherfront_head = TRUE;
1556     newhline = 0 ;
1557     echo = TRUE ;
1558     savhd = TRUE ;
1559     hderr = FALSE ;
1560     svheadlen = 0 ;
1561     fputs("<TITLE><TYPE serif><WEIGHT bold><SIZE 14>", outfile);
1562 /* Node headings.*/
1563   <START-CODE MESSAGE>
1564     echo = TRUE ;
1565     newhline = 0 ;
1566     /* Check MESSAGE, MSGSUB, BIBLIO, BIBSUB when implementing need begin */
1567     fputs("<TITLE><TYPE serif><WEIGHT bold><SIZE 14>", outfile);
1568 /* Other headings.*/
1569   <START-CODE BIBLIO, BIBSUB>
1570     echo = TRUE ;
1571     newhline = 0 ;
1572     /* Check MESSAGE, MSGSUB, BIBLIO, BIBSUB when implementing need begin */
1573     fputs("<PARAGRAPH><TYPE serif><WEIGHT bold><SIZE 12>", outfile);
1574 /* Accent headings */
1575   <END-CODE NOTE>
1576     char *iconName =
1577       GetDefaultHeaderString("NoteElementDefaultIconFile", M_SYSTEM, "");
1578
1579     fprintf(outfile, ncwEnd, "");
1580     if (*iconName)
1581       {
1582       fprintf(outfile, ncwGraphic, iconName);
1583       m_free(iconName, "icon name");
1584       }
1585   <END-CODE CAUTION>
1586     char *iconName =
1587       GetDefaultHeaderString("CautionElementDefaultIconFile", M_SYSTEM, "");
1588
1589     fprintf(outfile, ncwEnd, "");
1590     if (*iconName)
1591       {
1592       fprintf(outfile, ncwGraphic, iconName);
1593       m_free(iconName, "icon name");
1594       }
1595   <END-CODE WARNING>
1596     char *iconName =
1597       GetDefaultHeaderString("WarningElementDefaultIconFile", M_SYSTEM, "");
1598
1599     fprintf(outfile, ncwEnd, "");
1600     if (*iconName)
1601       {
1602       fprintf(outfile, ncwGraphic, iconName);
1603       m_free(iconName, "icon name");
1604       }
1605 <END-CODE>
1606     fputs("\n\n", outfile);
1607 /* Other headings */
1608   <END-CODE P>
1609     fputs("</WEIGHT></TYPE></PARAGRAPH>\n\n", outfile);
1610 /* Other headings */
1611   <END-CODE LIST, LABLIST, EX, SYNTAX>
1612     fputs("</WEIGHT></TYPE></PARAGRAPH>\n\n", outfile);
1613 /* Other headings */
1614   <END-CODE IMAGE>
1615     fputs("</WEIGHT></TYPE></PARAGRAPH>\n\n", outfile);
1616 /* Non node headings */
1617   <END-CODE FRONTSUB>
1618     echo = FALSE ;
1619     fputs("</SIZE></WEIGHT></TYPE></PARAGRAPH>\n\n", outfile);
1620 /* Non node headings */
1621   <END-CODE LEGAL, SAFETY, MAP, ABSTRACT, PREFACE, CONVENTIONS, HISTORY>
1622     echo = FALSE ;
1623     fputs("</SIZE></WEIGHT></TYPE></TITLE>\n\n", outfile);
1624 /* Node headings. */
1625   <END-CODE OTHERFRONT>
1626     endhead() ;
1627     fputs("</SIZE></WEIGHT></TYPE></TITLE>\n", outfile);
1628 /* Node headings. */
1629   <END-CODE MESSAGE>
1630     echo = FALSE ;
1631     fputs("</SIZE></WEIGHT></TYPE></TITLE>\n", outfile);
1632 /* Other headings. */
1633   <END-CODE BIBLIO, BIBSUB>
1634     echo = FALSE ;
1635     fputs("</WEIGHT></TYPE></PARAGRAPH>\n\n", outfile);
1636 /* Other headings */
1637   <END-CODE CHAPHEAD PROCEDURE>
1638     endhead() ;
1639     fputs("</WEIGHT></TYPE></PARAGRAPH>\n\n", outfile);
1640 /* Non node headings */
1641   <END-CODE CHAPHEAD MSGSUB>
1642     endhead() ;
1643     fputs("</SIZE></WEIGHT></TYPE></PARAGRAPH>\n\n", outfile);
1644   <END-CODE CHAPHEAD RSUB, OTHERHEAD>
1645     endhead() ;
1646     fputs("</SIZE></WEIGHT></TYPE></PARAGRAPH>\n\n", outfile);
1647 /* Node headings */
1648   <END-CODE CHAPHEAD RSECT,  CHAPHEAD S1, CHAPHEAD S2, CHAPHEAD S3,
1649             CHAPHEAD S4, CHAPHEAD S5, CHAPHEAD S6, CHAPHEAD S7,
1650             CHAPHEAD S8, CHAPHEAD S9, CHAPHEAD TEST, CHAPHEAD BIBLIO,
1651             CHAPHEAD HOMETOPIC>
1652     endhead() ;
1653     fputs("</SIZE></WEIGHT></TYPE></TITLE>\n", outfile);
1654   <END-CODE PART>
1655   <END-CODE CHAPHEAD CHAPTER>
1656     endhead() ;
1657     fputs("</SIZE></WEIGHT></TYPE></TITLE>\n", outfile);
1658   <END-CODE CHAPHEAD APPENDIX>
1659     endhead() ;
1660     fputs("</SIZE></WEIGHT></TYPE></TITLE>\n", outfile);
1661   <END-CODE CHAPHEAD MESSAGE>
1662     endhead() ;
1663     fputs("</SIZE></WEIGHT></TYPE></TITLE>\n", outfile);
1664 <TEXT-CODE IMAGE>
1665     outchar(m_textchar, outfile) ;
1666
1667 <ELEMENT HEADER>
1668   <START-CODE>
1669       /* Headers and footers make no sense to Cache Creek; throw away
1670        * all content.  We could do this with empty text-code here and
1671        * context sensitive empty text-code in all elements of the model
1672        * group that define their own text-code but that's really error
1673        * prone and difficult to maintain.
1674       */
1675       HFsaveoutfile = outfile;
1676       outfile = nullfile;
1677   <END-CODE>
1678       outfile = HFsaveoutfile;
1679
1680 <ELEMENT HELPVOLUME>
1681   <PARAM>
1682     author = AUTHOR  ;
1683     language = LANGUAGE (QENGLISH = ENGLISH,
1684                          QNORWEGIAN = NORWEGIAN,
1685                          QSWEDISH = SWEDISH,
1686                          QDANISH = DANISH,
1687                          QFINNISH = FINNISH,
1688                          QDUTCH = DUTCH,
1689                          QFRENCH = FRENCH,
1690                          QGERMAN = GERMAN,
1691                          QITALIAN = ITALIAN,
1692                          QSPANISH = SPANISH)  ;
1693     idxvol = IDXVOL  ;
1694     status = STATUS  ;
1695   <START-CODE>
1696     thisnodelevel = 0;
1697
1698     mb_starthelpnode("_VERYTOP", TRUE);
1699     manustart(language, idxvol, status) ;
1700   <END-CODE>
1701     endhelpnode();
1702
1703
1704 <ELEMENT HISTORY>
1705   <PARAM>
1706     include = INCLUDE  ;
1707     exclude = EXCLUDE  ;
1708   <START-CODE>
1709     mb_starthelpnode("_HISTORY", TRUE);
1710
1711 <ELEMENT HLINE>
1712   <START-CODE * HEADER>
1713     if (newhline == MAXHEADLINES)
1714       m_error("Too many lines in header") ;
1715     fputs("<NEWLINE>\n", outfile);
1716   <START-CODE * FOOTER>
1717     if (newhline == MAXHEADLINES)
1718       m_error("Too many lines in footer") ;
1719     if (newhline++) fputs("<NEWLINE>\n", outfile) ;
1720   <START-CODE ABBREV>
1721     if (fabbrev) {
1722         if (newhline++) {
1723              fputs("<NEWLINE>\n", outfile);
1724         }
1725       }
1726   <START-CODE CAPTION FIGURE>
1727     if (newhline++)
1728       mb_shstring("<NEWLINE>\n",
1729                &svheadlen,
1730                (sizeof(savehead) / sizeof(M_WCHAR)),
1731                savehead,
1732                "Too many characters in head or caption",
1733                &hderr) ;
1734   <START-CODE CAPTION TABLE>
1735   <START-CODE COLH>
1736   <START-CODE HEAD CHAPHEAD>
1737     if (newhline++) {
1738       fputs("  ", stderr) ;
1739       fputs("<NEWLINE>", outfile) ;
1740       if (savid) shchar(' ',
1741                         &xstrlen,
1742                         (sizeof(xrefstring) / sizeof(M_WCHAR)),
1743                         xrefstring,
1744                         idstring,
1745                         "Too many characters in corresponding cross-reference",
1746                         &iderr) ;
1747       shchar(' ',
1748              &svheadlen,
1749              (sizeof(savehead) / sizeof(M_WCHAR)),
1750              savehead,
1751              svhdstring,
1752              "Too many characters in head or caption",
1753              &hderr) ;
1754       }
1755   <START-CODE TITLE>
1756      if (newhline++) {
1757           fputs("<NEWLINE>", outfile) ;
1758           fputs("\\\n", docregfp) ;
1759      }
1760   <START-CODE HEAD P, HEAD IMAGE, HEAD LIST, HEAD LABLIST, HEAD EX,
1761               HEAD SYNTAX>
1762     if (newhline++) fputc(' ', outfile) ;
1763   <END-CODE HEAD CHAPHEAD,
1764             HEAD FRONTSUB,
1765             HEAD LEGAL,
1766             HEAD SAFETY,
1767             HEAD MAP,
1768             HEAD PREFACE,
1769             HEAD CONVENTIONS,
1770             HEAD HISTORY,
1771             HEAD OTHERFRONT,
1772             HEAD OTHERHEAD>
1773     putc('\n', stderr) ;
1774   <END-CODE HEAD ABSTRACT>
1775     putc('\n', stderr) ;
1776     fputs("\\\n\\\n", docregfp) ;
1777   <END-CODE COLH>
1778   <END-CODE>
1779
1780 <ELEMENT HOMETOPIC>
1781   <START-CODE>
1782      mb_starthelpnode("_HOMETOPIC", FALSE);
1783      nohometopic = FALSE;
1784
1785 <ELEMENT HSEP>
1786   <PARAM>
1787     rule = RULE (QNORULE = NORULE,
1788                  QRULE = RULE,
1789                  QBLANK = BLANK) ;
1790
1791 <ELEMENT HYPHENATIONS>
1792
1793 <ELEMENT HYPHENTRY>
1794   <TEXT-CODE>
1795
1796 <ELEMENT IDSECTION>
1797
1798 <ELEMENT IDX>
1799   <PARAM>
1800     main = MAIN ;
1801     range = RANGE (QBEGIN = BEGIN,
1802                    QEND = END) ;
1803   <START-CODE>
1804     have_index = TRUE ;
1805     print[0] = '\0';
1806     subprint[0] = '\0';
1807     sort[0] = '\0';
1808     subsort[0] = '\0';
1809   <END-CODE>
1810      /* ignore <idx end>'s in cache creek */
1811     if (!range || (range && m_wcmbupstrcmp(range, QEND)) )
1812         { /* sort field */
1813         char *mb_print, *mb_nodeid;
1814         M_WCHAR *pwc, wnl, wsp;
1815
1816         mbtowc(&wnl, "\n", 1);
1817         mbtowc(&wsp, " ", 1);
1818
1819         pwc = print;
1820         while (pwc = w_strchr(pwc, wnl))
1821             *pwc = wsp;
1822         mb_print = MakeMByteString(print);
1823         if (w_strlen(sort) > 0)
1824             { /* use sort[] */
1825             char *mb_sort;
1826
1827             pwc = sort;
1828             while (pwc = w_strchr(pwc, wnl))
1829                 *pwc = wsp;
1830             mb_sort = MakeMByteString(sort);
1831             if (w_strlen(subsort) > 0 || w_strlen(subprint) > 0)
1832                 {
1833                 /* append subsort or subprint */
1834                 char *mb_sub;
1835                 M_WCHAR *pwcSub;
1836
1837                 pwcSub = (w_strlen(subsort) > 0) ? subsort : subprint;
1838                 pwc = pwcSub;
1839                 while (pwc = w_strchr(pwc, wnl))
1840                     *pwc = wsp;
1841                 mb_sub = MakeMByteString(pwcSub);
1842                 fprintf(indexfp, "%s, %s", mb_sort, mb_sub);
1843                 m_free(mb_sub,"multi-byte string");
1844                 }
1845             else
1846                 { /* plain sort */
1847                 fprintf(indexfp, "%s", mb_sort);
1848                 }
1849             m_free(mb_sort,"multi-byte string");
1850             }
1851         else
1852             { /* use print field */
1853             if (w_strlen(subsort) > 0 || w_strlen(subprint) > 0)
1854                 {
1855                 /* append subsort or subprint */
1856                 char *mb_sub;
1857                 M_WCHAR *pwcSub;
1858
1859                 pwcSub = (w_strlen(subsort) > 0) ? subsort : subprint;
1860                 pwc = pwcSub;
1861                 while (pwc = w_strchr(pwc, wnl))
1862                     *pwc = wsp;
1863                 mb_sub = MakeMByteString(pwcSub);
1864                 fprintf(indexfp, "%s, %s", mb_print, mb_sub);
1865                 m_free(mb_sub,"multi-byte string");
1866                 }
1867             else
1868                 { /* plain print */
1869                 fprintf(indexfp, "%s", mb_print);
1870                 }
1871             }
1872         putc('\036', indexfp);
1873
1874         /* print field */
1875         if (w_strlen(subprint) > 0)
1876             {
1877             char *mb_subprint;
1878
1879             pwc = subprint;
1880             while (pwc = w_strchr(pwc, wnl))
1881                 *pwc = wsp;
1882             mb_subprint = MakeMByteString(subprint);
1883             fprintf(indexfp, "%s, %s", mb_print, mb_subprint);
1884             m_free(mb_subprint,"multi-byte string");
1885             }
1886         else
1887             {
1888             fprintf(indexfp, "%s", mb_print);
1889             }
1890         m_free(mb_print,"multi-byte string");
1891         putc('\036', indexfp);
1892
1893         /* id field */
1894
1895         pwc = nodeid;
1896         while (pwc = w_strchr(pwc, wnl))
1897             *pwc = wsp;
1898         mb_nodeid = MakeMByteString(nodeid);
1899         fprintf(indexfp, "%s", mb_nodeid);
1900         m_free(mb_nodeid,"multi-byte string");
1901         putc('\036', indexfp);
1902         putc('\n', indexfp);
1903         }
1904   <TEXT-CODE>
1905     indexchar(m_textchar) ;
1906
1907 <ELEMENT IDX-CHAP>
1908
1909 <ELEMENT IDX-CHAP-REF>
1910   <PARAM>
1911     main = MAIN ;
1912
1913 <ELEMENT IDX-END>
1914
1915 <ELEMENT IDX-ENTRY>
1916
1917 <ELEMENT IDX-FF>
1918
1919 <ELEMENT IDX-LETTER>
1920
1921 <ELEMENT IDX-PRIMARY>
1922
1923 <ELEMENT IDX-PRIMARY-AND-REF>
1924
1925 <ELEMENT IDX-REFS>
1926
1927 <ELEMENT IDX-SECT>
1928
1929 <ELEMENT IDX-START>
1930
1931 <ELEMENT IDX-SUB>
1932
1933 <ELEMENT IDX-SUB-AND-REF>
1934
1935 <ELEMENT IDX-SYN>
1936
1937 <ELEMENT IDX-VOL>
1938
1939 <ELEMENT IDXSYN>
1940   <START-CODE>
1941     have_index = TRUE ;
1942     print[0] = '\0';
1943     subprint[0] = '\0';
1944     sort[0] = '\0';
1945     subsort[0] = '\0';
1946   <TEXT-CODE>
1947     indexchar(m_textchar) ;
1948
1949 <ELEMENT IMAGE>
1950   <PARAM>
1951     indent = INDENT ;
1952     id = ID;
1953     gentity = GENTITY  ;
1954     gposition = GPOSITION (QLEFT = LEFT,
1955                            QRIGHT = RIGHT) ;
1956     ghyperlink = GHYPERLINK  ;
1957     glinktype = GLINKTYPE (QJUMP = JUMP,
1958                            QJUMPNEWVIEW = JUMPNEWVIEW,
1959                            QDEFINITION = DEFINITION,
1960                            QEXECUTE = EXECUTE,
1961                            QAPPDEFINED = APPDEFINED,
1962                            QMAN = MAN) ;
1963     gdescription = GDESCRIPTION  ;
1964   /*
1965     <C variable> = NUMBER ;
1966   */
1967   <START-CODE>
1968     STARTSTUFF
1969     indentp = indent;
1970     imagegentityp = gentity;
1971     imagegpositionp = gposition;
1972     imageghyperlinkp = ghyperlink;
1973     imageglinktypep = glinktype;
1974     imagegdescription = gdescription;
1975     rshnewclear() ;
1976     parspace();
1977     if (id) {
1978       if (imageId)
1979           m_free(imageId,"multi-byte string");
1980       imageId = MakeMByteString(id);
1981       mbstowcs(xrefstring, "\\<xref image>", 400);
1982       xstrlen = w_strlen(xrefstring) ;
1983       m_getline(&xrffile, &xrfline) ;
1984       if (xrffile == NULL) {
1985           /* set to primary input source */
1986           xrffile = inputname;
1987       }
1988       setid(id,
1989             TRUE,
1990             FALSE,
1991             inchapter,
1992             chapstring,
1993             xrffile,
1994             xrfline,
1995             FALSE) ;
1996
1997       {
1998       char *mb_nodeid, *mb_id;
1999
2000       mb_nodeid = MakeMByteString(nodeid);
2001       mb_id     = MakeMByteString(id);
2002       fprintf(idtablefp, "%s> %s\n", mb_nodeid, mb_id);
2003       m_free(mb_nodeid,"multi-byte string");
2004       m_free(mb_id,"multi-byte string");
2005       }
2006     }
2007   <TEXT-CODE>
2008     exoutchar(m_textchar) ;
2009
2010 <ELEMENT IMAGETEXT>
2011   <START-CODE>
2012      M_WCHAR *wc_image;
2013
2014      fputs("<PARAGRAPH", outfile);
2015      if (imageId) {
2016         fprintf(outfile, " id %s", imageId);
2017         m_free(imageId,"multi-byte string");
2018         imageId = NULL;
2019         }
2020      if (indentp) {
2021           fprintf(outfile,
2022                   " firstindent %d leftindent %d",
2023                   LEFTINDENT,
2024                   LEFTINDENT);
2025      }
2026      fputs(" nowrap", outfile);
2027
2028      wc_image = MakeWideCharString("IMAGE");
2029      handle_link_and_graphic(wc_image,
2030                              imagegentityp,
2031                              imagegpositionp,
2032                              imageghyperlinkp,
2033                              imageglinktypep,
2034                              imagegdescription);
2035      m_free(wc_image,"wide character string");
2036
2037     fputs(">", outfile);
2038   <END-CODE>
2039      fputs("</PARAGRAPH>\n\n", outfile);
2040
2041 <ELEMENT INDEX>
2042
2043 <ELEMENT INFOSTART>
2044
2045 <ELEMENT INDEXPRIMARY>
2046   <START-CODE>
2047     idxsavlen = 0;
2048     didsort = FALSE;
2049   <END-CODE>
2050     /* capture saved term unless <sort> got it already */
2051     if (! didsort) {
2052          idxsav[idxsavlen] = M_EOS;
2053          w_strcpy(print, idxsav);
2054
2055     }
2056     else { /* save the sort field */
2057          idxsav[idxsavlen] = M_EOS;
2058          w_strcpy(sort, idxsav);
2059     }
2060
2061 <ELEMENT INDEXSUB>
2062   <START-CODE>
2063     idxsavlen = 0;
2064     didsubsort = FALSE;
2065   <END-CODE>
2066     /* capture saved term unless <sort> got it already */
2067     if (! didsubsort) {
2068          idxsav[idxsavlen] = M_EOS;
2069          w_strcpy(subprint, idxsav);
2070     }
2071     else { /* save the sort field */
2072          idxsav[idxsavlen] = M_EOS;
2073          w_strcpy(subsort, idxsav);
2074     }
2075
2076
2077 <ELEMENT INPUT.....>
2078   <START-CODE>
2079     if (echo) mb_echohead("``") ;
2080   <TEXT-CODE>
2081   <END-CODE>
2082     if (echo) mb_echohead("''") ;
2083
2084 <ELEMENT INSIDE>
2085   <START-CODE HEADER>
2086     newhline = 0 ;
2087   <START-CODE FOOTER>
2088     newhline = 0 ;
2089   <END-CODE>
2090
2091 <ELEMENT ITEM>
2092   <PARAM>
2093     id = ID ;
2094   <START-CODE LIST>
2095     if (lastlist->lastlist->type == PLAIN) {
2096       leaderok = TRUE ;   /* allow <LEADER> only in <LIST PLAIN> */
2097       }
2098     rshnewclear() ;
2099     item(id) ;
2100   <END-CODE LIST>
2101     leaderok = FALSE ;
2102     fputs("</PARAGRAPH>\n\n", outfile);
2103
2104 <ELEMENT KEYCAP>
2105   <START-CODE>
2106     /* also does special handling for calculator--supers/subs */
2107     /*handles super and subs in keys */
2108     mb_strcode("[<TYPE sans_serif>", outfile) ;
2109     if (echo) mb_echohead("[[") ;
2110   <END-CODE>
2111     mb_strcode("</TYPE>]", outfile) ;
2112     if (echo) mb_echohead("]]") ;
2113   <TEXT-CODE>
2114      esoutchar(m_textchar) ;
2115
2116   <START-CODE * IDX, * IDXSYN>
2117     indexchar('[');
2118   <END-CODE * IDX, * IDXSYN>
2119     indexchar(']');
2120   <TEXT-CODE * IDX, * IDXSYN>
2121     indexchar(m_textchar) ;
2122
2123 <ELEMENT KEYS>
2124
2125 <ELEMENT LABEL>
2126   <START-CODE>
2127     rshnewclear() ;
2128     fputs("<PARAGRAPH", outfile);
2129     if (list <= MAXLISTLEV && lablistindented[list]) {
2130          fputs(" after 0", outfile);
2131     }
2132     fputs(" leftindent 14><LABEL>", outfile);
2133   <END-CODE>
2134     fputs("</LABEL>\n", outfile);
2135
2136 <ELEMENT LABH>
2137   <START-CODE>
2138     fputs("<PARAGRAPH leftindent 14><LABEL><WEIGHT bold>", outfile);
2139   <END-CODE>
2140     fputs("</WEIGHT></LABEL>\n", outfile);
2141
2142 <ELEMENT LABHTEXT>
2143   <START-CODE>
2144      fputs("<PARAGRAPH><WEIGHT bold>", outfile);
2145   <END-CODE>
2146      fputs("</WEIGHT></PARAGRAPH>\n", outfile);
2147      fputs("</PARAGRAPH>\n", outfile);
2148
2149 <ELEMENT LABHEADS>
2150
2151 <ELEMENT LABLIST>
2152   <PARAM>
2153     longlabel = LONGLABEL (QWRAP = WRAP,
2154                            QNOWRAP = NOWRAP) ;
2155     width = WIDTH ;
2156     spacing = SPACING (QTIGHT = TIGHT,
2157                        QLOOSE = LOOSE) ;
2158   <START-CODE>
2159     char *mb_parent;
2160
2161     mb_parent = MakeMByteString(m_parent(0));
2162     startlablist(longlabel, mb_checkdimen(width, "WIDTH", mb_parent), spacing) ;
2163     m_free(mb_parent,"multi-byte string");
2164   <END-CODE>
2165     list-- ;
2166     fputs("</PARAGRAPH>\n", outfile);
2167
2168 <ELEMENT LEADER>
2169   <PARAM>
2170     type = TYPE (QSPACE = SPACE,
2171                  QDOTS = DOTS) ;
2172   <START-CODE>
2173     if (leaderok==TRUE)
2174         {
2175         if (! m_wcmbupstrcmp(type, QDOTS))
2176             {
2177             }
2178         else if (! m_wcmbupstrcmp(type, QSPACE))
2179             {
2180             }
2181         else
2182             {
2183             M_WCHAR *wc_stago, *wc_tagc;
2184
2185             wc_stago = MakeWideCharString(m_stago);
2186             wc_tagc  = MakeWideCharString(m_tagc);
2187             m_err2("Internal error: element %sLEADER%s in tex.if",
2188                    wc_stago,
2189                    wc_tagc) ;
2190             m_free(wc_stago,"wide character string");
2191             m_free(wc_tagc,"wide character string");
2192             }
2193         }
2194     else
2195         {
2196         M_WCHAR *wc_stago, *wc_tagc;
2197
2198         wc_stago = MakeWideCharString(m_stago);
2199         wc_tagc  = MakeWideCharString(m_tagc);
2200         m_err4("%sLEADER%s only allowed in %sLIST PLAIN%s",
2201                wc_stago,
2202                wc_tagc,
2203                wc_stago,
2204                wc_tagc) ;
2205         m_free(wc_stago,"wide character string");
2206         m_free(wc_tagc,"wide character string");
2207         }
2208
2209 <ELEMENT LEGAL>
2210   <PARAM>
2211     include = INCLUDE  ;
2212     exclude = EXCLUDE  ;
2213   <START-CODE>
2214     mb_starthelpnode("_LEGAL", TRUE);
2215
2216 <ELEMENT LINENO>
2217   <PARAM>
2218     id = ID ;
2219   <START-CODE>
2220     char mb_xrefstring[400];
2221
2222     if (! tonumexlines)
2223       m_error(
2224     "Preparing cross-reference to a line in an example without line numbers"
2225       ) ;
2226     sprintf(mb_xrefstring, "%d", exlineno) ;
2227     mbstowcs(xrefstring, mb_xrefstring, 400);
2228     xstrlen = w_strlen(xrefstring) ;
2229     m_getline(&xrffile, &xrfline) ;
2230     if (xrffile == NULL) {
2231            /* set to primary input */
2232            xrffile = inputname;
2233     }
2234     setid(id,
2235           TRUE,
2236           FALSE,
2237           inchapter,
2238           chapstring,
2239           xrffile,
2240           xrfline,
2241           TRUE) ;
2242     {
2243     char *mb_id;
2244
2245     mb_id = MakeMByteString(id);
2246     fprintf(outfile, "<ID \"%s\"></ID>", mb_id);
2247     m_free(mb_id,"multi-byte string");
2248     }
2249
2250 <ELEMENT LINK>
2251   <PARAM>
2252      hyperlink = HYPERLINK  ;
2253      type = TYPE (QJUMP = JUMP,
2254                   QJUMPNEWVIEW = JUMPNEWVIEW,
2255                   QDEFINITION = DEFINITION,
2256                   QEXECUTE = EXECUTE,
2257                   QAPPDEFINED = APPDEFINED,
2258                   QMAN = MAN) ;
2259      description = DESCRIPTION  ;
2260   <START-CODE>
2261      fputs("<LINK ", outfile);
2262      if (!type) { /* default to type jump */
2263           fputs("0 ", outfile);
2264      }
2265      else { /* type is set, choose which is correct */
2266           if (!m_wcmbupstrcmp(type, QJUMP))
2267             { fputs("0 ", outfile); global_linktype = 0;}
2268           else if (!m_wcmbupstrcmp(type, QJUMPNEWVIEW))
2269             { fputs("1 ", outfile); global_linktype = 1;}
2270           else if (!m_wcmbupstrcmp(type, QDEFINITION))
2271             { fputs("2 ", outfile); global_linktype = 2;}
2272           else if (!m_wcmbupstrcmp(type, QEXECUTE))
2273             { fputs("3 ", outfile); global_linktype = 3;}
2274           else if (!m_wcmbupstrcmp(type, QMAN))
2275             { fputs("4 ", outfile); global_linktype = 4;}
2276           else if (!m_wcmbupstrcmp(type, QAPPDEFINED))
2277             { fputs("5 ", outfile); global_linktype = 5;}
2278           else { /* parser won't let this case happen */
2279             M_WCHAR *wc_stago, *wc_tagc;
2280
2281             wc_stago = MakeWideCharString(m_stago);
2282             wc_tagc  = MakeWideCharString(m_tagc);
2283             m_err3("%sLINK%s (type=``%s'') did not match an allowed value",
2284                    wc_stago,
2285                    wc_tagc,
2286                    type);
2287             m_free(wc_stago,"wide character string");
2288             m_free(wc_tagc,"wide character string");
2289           }
2290      }
2291      if (hyperlink) {
2292           char *mb_hyperlink;
2293
2294           mb_hyperlink = MakeMByteString(hyperlink);
2295           fprintf(outfile, "\"%s\"", mb_hyperlink);
2296           m_free(mb_hyperlink,"multi-byte string");
2297      }
2298      else {
2299           m_eprefix();
2300           fprintf(stderr,
2301                   "Error: %sLINK%s hyperlink was undefined.\n",
2302                   m_stago,
2303                   m_tagc);
2304           fprintf(m_errfile,
2305                   "Error: %sLINK%s hyperlink was undefined.\n",
2306                   m_stago,
2307                   m_tagc);
2308           fprintf(stderr,
2309     "Beware of using a reserved value such as:\n%s, %s, %s, %s, %s, or %s.\n",
2310                   QJUMP,
2311                   QJUMPNEWVIEW,
2312                   QDEFINITION,
2313                   QEXECUTE,
2314                   QAPPDEFINED,
2315                   QMAN);
2316           fprintf(m_errfile,
2317    "Beware of using a reserved value such as:\n%s, %s, %s, %s, %s, or %s.\n",
2318                   QJUMP,
2319                   QJUMPNEWVIEW,
2320                   QDEFINITION,
2321                   QEXECUTE,
2322                   QAPPDEFINED,
2323                   QMAN);
2324           m_errline("Use ``hyperlink='' if the value contains non-alphabetics");
2325           m_esuffix();
2326           fputs("_undefined", outfile);
2327      }
2328      if (description) {
2329           char *mb_description;
2330
2331           mb_description = MakeMByteString(description);
2332           fprintf(outfile, " \"%s\"", mb_description);
2333           m_free(mb_description,"multi-byte string");
2334      }
2335      fputs(">", outfile);
2336   <END-CODE>
2337      /* reset link type to default.  This is braindead, but enough.
2338
2339         E.g.,
2340
2341            <link foo DEFINITION><XREF bar><\link>
2342
2343         will do the right thing (remember that xref turns to an implicit link).
2344         Right_thing => xref becomes definition link.
2345
2346         However, in
2347
2348            <link foo DEFINITION> <link fub> Test <\link> <xref bar> <\link>
2349
2350         the xref will think that is supposed to become a link of type jump,
2351         not definition.  This case is odd, so we won't worry about it.
2352      */
2353      global_linktype = 0;
2354      fputs("</LINK>", outfile);
2355
2356 <ELEMENT LIST>
2357   <PARAM>
2358     type = TYPE (QORDER = ORDER,
2359                  QBULLET = BULLET,
2360                  QPLAIN = PLAIN,
2361                  QMILSPEC = MILSPEC,
2362                  QCHECK = CHECK) ;
2363     order = ORDERTYPE (QUALPHA = UALPHA,
2364                        QLALPHA = LALPHA,
2365                        QARABIC = ARABIC,
2366                        QUROMAN = UROMAN,
2367                        QLROMAN = LROMAN) ;
2368     spacing = SPACING (QTIGHT = TIGHT,
2369                        QLOOSE = LOOSE) ;
2370     cont = CONTINUE ;
2371   <START-CODE>
2372     startlist(type, order, spacing, cont) ;
2373   <END-CODE>
2374     LIST *curlist ;
2375     CONTCHAIN *chain, *xchain ;
2376
2377     curlist = lastlist->lastlist ;
2378     for (chain = lastlist->chain ; chain ; chain = xchain) {
2379       xchain = chain->next ;
2380       m_free(chain, "list chain") ;
2381       }
2382     m_free(lastlist, "list structure") ;
2383     lastlist = curlist ;
2384     for (chain = lastlist->chain ; chain ; chain = chain->next) {
2385       fseek(outfile, chain->where, SEEK_SET) ;
2386       if (lastlist->count > 999) {
2387         m_error("Unable to support more than 999 items in an ordered list") ;
2388         lastlist->count = 999 ;
2389         }
2390       fseek(outfile, 0L, SEEK_END) ;
2391       }
2392     if (lastlist->type == BULLET) bulcount-- ;
2393     list-- ;
2394     fputs("</PARAGRAPH>\n\n", outfile);
2395
2396 <ELEMENT LOCATION>
2397   <PARAM>
2398     id = ID  ;
2399   <START-CODE>
2400     if (id) {
2401       char mb_xrefstring[400];
2402
2403       sprintf(mb_xrefstring, "\\<xref location>") ;
2404       mbstowcs(xrefstring, mb_xrefstring, 400);
2405       xstrlen = w_strlen(xrefstring) ;
2406       m_getline(&xrffile, &xrfline) ;
2407       if (xrffile == NULL) {
2408            /* set to primary input source */
2409            xrffile = inputname;
2410       }
2411     setid(id,
2412           TRUE,
2413           FALSE,
2414           inchapter,
2415           chapstring,
2416           xrffile,
2417           xrfline,
2418           FALSE) ;
2419
2420     {
2421     char *mb_nodeid, *mb_id;
2422
2423     mb_nodeid = MakeMByteString(nodeid);
2424     mb_id     = MakeMByteString(id);
2425     fprintf(idtablefp, "%s> %s\n", mb_nodeid, mb_id);
2426     fprintf(outfile, "<ID \"%s\">", mb_id);
2427     m_free(mb_nodeid,"multi-byte string");
2428     m_free(mb_id,"multi-byte string");
2429     }
2430     }
2431   <END-CODE>
2432     fprintf(outfile, "</ID>");
2433
2434
2435 <ELEMENT MANUAL>
2436   <PARAM>
2437     language = LANGUAGE (QENGLISH = ENGLISH,
2438                          QNORWEGIAN = NORWEGIAN,
2439                          QSWEDISH = SWEDISH,
2440                          QDANISH = DANISH,
2441                          QFINNISH = FINNISH,
2442                          QDUTCH = DUTCH,
2443                          QFRENCH = FRENCH,
2444                          QGERMAN = GERMAN,
2445                          QITALIAN = ITALIAN,
2446                          QSPANISH = SPANISH) ;
2447     idxvol = IDXVOL ;
2448     status = STATUS ;
2449   <START-CODE>
2450     thisnodelevel = 0;
2451     mb_starthelpnode("_VERYTOP", TRUE);
2452     manustart(language, idxvol, status) ;
2453   <END-CODE>
2454     endhelpnode();
2455
2456 <ELEMENT MAP>
2457   <PARAM>
2458     include = INCLUDE  ;
2459     exclude = EXCLUDE  ;
2460   <START-CODE>
2461     mb_starthelpnode("_MAP", TRUE);
2462
2463 <ELEMENT INEQN>
2464
2465 <ELEMENT MEMO>
2466   <START-CODE>
2467     if (memo && !final) {
2468       if (! m_wcmbupstrcmp(m_parent(1), "TEXT"))
2469       fputs("<WEIGHT bold>", outfile) ;
2470       }
2471   <END-CODE>
2472     if (memo && !final) {
2473       POPFONT ;
2474       fputs("</WEIGHT>", outfile) ;
2475       }
2476   <TEXT-CODE>
2477     if (memo) {
2478       if (m_textchar == '"') { /* handle funny quote in memo bug */
2479         }
2480       else {
2481         outchar(m_textchar, outfile);
2482         }
2483       }
2484   <PI-CODE>
2485     /* could need to handle calculator context sensitive entities
2486      * here if needed to reduce tex macro count
2487      */
2488     if (memo) {
2489          outpi(m_enttype, m_pi, m_entname) ;
2490     }
2491
2492 <ELEMENT MESSAGE>
2493   <PARAM>
2494     include = INCLUDE  ;
2495     exclude = EXCLUDE  ;
2496   <START-CODE>
2497     open_new_helpfile();
2498     thisnodelevel = 1;
2499     mb_starthelpnode("_MESSAGE", FALSE);
2500     chapst = FALSE ;
2501     fprintf(stderr, "\nMessages.\n") ;
2502     emsghead = DEFHEAD ;
2503   <END-CODE>
2504     endhelpnode();
2505
2506 <ELEMENT METAINFO>
2507
2508 <ELEMENT MFGNO>
2509   <START-CODE>
2510     char *string =
2511       GetDefaultHeaderString("MfgNumberElementDefaultHeadingString",
2512                              M_SDATA,
2513                              "Manufacturing Number");
2514
2515     mb_starthelpnode("_MFGNO", TRUE);
2516     fprintf(outfile, "<TITLE><TYPE serif><WEIGHT bold><SIZE 14>%s</SIZE></WEIGHT></TYPE></TITLE>\n\n", string);
2517     fputs("<PARAGRAPH>", outfile);
2518     m_free(string, "default header string return");
2519   <END-CODE>
2520     fputs("</PARAGRAPH>\n\n", outfile);
2521
2522 <ELEMENT MIDDLE>
2523   <START-CODE HEADER>
2524     newhline = 0 ;
2525   <START-CODE FOOTER>
2526     newhline = 0 ;
2527
2528 <ELEMENT MSG>
2529   <START-CODE>
2530     checkmsghead() ;
2531     fprintf(outfile, "<PARAGRAPH leftindent 5>\n");
2532   <END-CODE>
2533     fprintf(outfile, "</PARAGRAPH>\n");
2534
2535 <ELEMENT MSGNUM>
2536   <END-CODE>
2537     fprintf(outfile, "\\ \\ ");
2538
2539 <ELEMENT MSGSUB>
2540   <PARAM>
2541     include = INCLUDE  ;
2542     exclude = EXCLUDE  ;
2543   <START-CODE>
2544     checkmsghead() ;
2545     chapst = TRUE ;
2546     savid = checkid(NULL) ; /* hook for possible future ID */
2547     iderr = FALSE ;
2548
2549 <ELEMENT MSGTEXT>
2550   <START-CODE>
2551     checkmsghead() ;
2552     fprintf(outfile, "<WEIGHT bold>");
2553   <END-CODE>
2554     fprintf(outfile, "</WEIGHT>\n");
2555
2556 <ELEMENT NEED>
2557   <PARAM>
2558     type = TYPE (QBEGIN = BEGIN,
2559                  QEND = END,
2560                  QTOGETHER = TOGETHER) ;
2561     depth = AMOUNT ;
2562
2563 <ELEMENT NEWLINE>
2564   <START-CODE>
2565       fputs("<NEWLINE>", outfile) ;
2566   <START-CODE * ABSTRACT>
2567       fputs("<NEWLINE>", outfile) ;
2568       fputs("\\\n", docregfp) ;
2569
2570
2571 <ELEMENT NEWPAGE>
2572   <START-CODE * RSECT>
2573     if (rsectsame)
2574       rsectholdnew = TRUE ;
2575
2576 <ELEMENT NOBREAK>
2577   <START-CODE>
2578     if (echo) {
2579       mb_echohead(m_stago) ;
2580       echohead(m_parent(0)) ;
2581       mb_echohead(m_net) ;
2582       }
2583   <END-CODE>
2584     if (echo) mb_echohead(m_net) ;
2585
2586   <START-CODE * IDX, * IDXSYN>
2587   <END-CODE * IDX, * IDXSYN>
2588   <TEXT-CODE * IDX, * IDXSYN>
2589     indexchar(m_textchar) ;
2590
2591   <TEXT-CODE * EXAMPLESEG, * IMAGE>
2592     outchar(m_textchar, outfile) ;
2593
2594 <ELEMENT NOT>
2595   <START-CODE>
2596     if (echo) {
2597       mb_echohead(m_stago) ;
2598       echohead(m_parent(0)) ;
2599       mb_echohead(m_net) ;
2600       }
2601   <END-CODE>
2602     if (echo) mb_echohead(m_net) ;
2603
2604   <START-CODE * IDX, * IDXSYN>
2605   <END-CODE * IDX, * IDXSYN>
2606   <TEXT-CODE * IDX, * IDXSYN>
2607     indexchar(m_textchar) ;
2608
2609   <TEXT-CODE * EXAMPLESEG, * IMAGE>
2610     outchar(m_textchar, outfile) ;
2611
2612 <ELEMENT NOTE>
2613   <START-CODE TEXT ITEM>
2614     STARTSTUFF
2615     /* In a tight list, paragraphs will have no trailing blank line.
2616      * To match HPTag behavior, we need to emit a blank line and
2617      * supress the leading blank line of the next paragraph, figure,
2618      * example, etc., if any.
2619     */
2620     ncwTightList = "";
2621     if ((lastlist->lastlist->space == TIGHT) &&
2622         (lastlist->lastlist->where == INSIDE)) {
2623        ncwTightList = " before 1";
2624     }
2625
2626     rshnewclear() ;
2627     notehead = FALSE ;
2628   <START-CODE>
2629     STARTSTUFF
2630     ncwTightList = "";
2631     rshnewclear() ;
2632     notehead = FALSE ;
2633   <END-CODE TEXT ITEM>
2634     fputs("</PARAGRAPH>\n\n", outfile);
2635     lastlist->lastlist->where = FOLLOW; /* supress leading newline */
2636   <END-CODE>
2637     fputs("</PARAGRAPH>\n\n", outfile);
2638
2639 <ELEMENT NUMBER>
2640   <START-CODE * IDX, * IDXSYN>
2641   <END-CODE * IDX, * IDXSYN>
2642   <TEXT-CODE * IDX, * IDXSYN>
2643     indexchar(m_textchar) ;
2644
2645   <TEXT-CODE * EXAMPLESEG, * IMAGE>
2646     outchar(m_textchar, outfile) ;
2647
2648 <ELEMENT OPTBLOCK>
2649   <START-CODE>
2650     synelcnt = 0;
2651     fputs("[", outfile);
2652   <END-CODE>
2653     fputs("]", outfile);
2654
2655
2656 <ELEMENT OTHERFRONT>
2657   <PARAM>
2658     id = ID  ;
2659     include = INCLUDE  ;
2660     exclude = EXCLUDE  ;
2661   <START-CODE>
2662      if (!id) {
2663           m_error("Warning:  <OTHERFRONT> topic will not be reachable because it has no ID");
2664           m_errcnt--;
2665      }
2666      starthelpnode(id, TRUE);
2667     had_an_otherfront_head = FALSE;
2668     savid = checkid(id) ;
2669     iderr = FALSE ;
2670   <END-CODE>
2671      if (id && !had_an_otherfront_head) {
2672         m_errline("You must use a <HEAD> tag after <OTHERFRONT>\n");
2673      }
2674
2675 <ELEMENT OTHERHEAD>
2676
2677 <ELEMENT OUTPUT....>
2678   <START-CODE>
2679     if (echo) mb_echohead("``") ;
2680   <TEXT-CODE>
2681   <END-CODE>
2682     if (echo) mb_echohead("''") ;
2683
2684 <ELEMENT OUTSIDE>
2685   <START-CODE HEADER>
2686     newhline = 0 ;
2687   <START-CODE FOOTER>
2688     newhline = 0 ;
2689   <END-CODE>
2690
2691 <ELEMENT P>
2692   <PARAM>
2693     indent = INDENT ;
2694     id = ID;
2695     gentity = GENTITY  ;
2696     gposition = GPOSITION (QLEFT = LEFT,
2697                            QRIGHT = RIGHT) ;
2698     ghyperlink = GHYPERLINK  ;
2699     glinktype = GLINKTYPE (QJUMP = JUMP,
2700                            QJUMPNEWVIEW = JUMPNEWVIEW,
2701                            QDEFINITION = DEFINITION,
2702                            QEXECUTE = EXECUTE,
2703                            QAPPDEFINED = APPDEFINED,
2704                            QMAN = MAN) ;
2705     gdescription = GDESCRIPTION  ;
2706   <START-CODE TEXT ITEM>
2707     char *listinfo;
2708
2709     listinfo = "";
2710     if (lastlist->lastlist->space == TIGHT) {
2711        if (lastlist->lastlist->where == INSIDE)
2712           listinfo = " before 1 after 0";
2713        else if (lastlist->lastlist->where == FOLLOW)
2714           listinfo = " after 0";
2715     }
2716     lastlist->lastlist->where = INSIDE;
2717
2718     paragraph(indent,
2719               id,
2720               gentity,
2721               gposition,
2722               ghyperlink,
2723               glinktype,
2724               gdescription,
2725               listinfo);
2726   <START-CODE>
2727     paragraph(indent,
2728               id,
2729               gentity,
2730               gposition,
2731               ghyperlink,
2732               glinktype,
2733               gdescription,
2734               "");
2735   <END-CODE>
2736     fputs("</PARAGRAPH>\n\n", outfile);
2737
2738 <ELEMENT PAGENO>
2739
2740 <ELEMENT PARM>
2741   <START-CODE>
2742     if (echo) {
2743       mb_echohead(m_stago) ;
2744       echohead(m_parent(0)) ;
2745       mb_echohead(m_net) ; /* '|' */
2746       }
2747   <END-CODE>
2748     if (echo) mb_echohead(m_net) ; /* '|' */
2749
2750   <START-CODE * IDX, * IDXSYN>
2751     /* We perhaps should allow <parm> to be used in <idx>.
2752        Since we are now dependent on LaserROM, we just can't
2753        add it in (as an inclusion exception to idx).
2754        So, we take out the code that would inplement it and
2755        give an error message. */
2756
2757     M_WCHAR *wc_stago, *wc_tagc;
2758
2759     wc_stago = MakeWideCharString(m_stago);
2760     wc_tagc  = MakeWideCharString(m_tagc);
2761     m_err4("%sPARM%s not allowed in %sIDX%s.",
2762            wc_stago,
2763            wc_tagc,
2764            wc_stago,
2765            wc_tagc);
2766     m_free(wc_stago,"wide character string");
2767     m_free(wc_tagc,"wide character string");
2768   <END-CODE * IDX, * IDXSYN>
2769   <TEXT-CODE * IDX, * IDXSYN>
2770     indexchar(m_textchar) ;
2771   <START-CODE * CHAPHEAD>
2772     M_WCHAR *wc_stago, *wc_tagc;
2773
2774     wc_stago = MakeWideCharString(m_stago);
2775     wc_tagc  = MakeWideCharString(m_tagc);
2776     m_err2("%sPARM%s not allowed in headings.", wc_stago, wc_tagc);
2777     m_free(wc_stago,"wide character string");
2778     m_free(wc_tagc,"wide character string");
2779   <END-CODE * CHAPHEAD>
2780
2781   <END-CODE * EXAMPLESEG, * IMAGE>
2782     POPFONT ;
2783
2784 <ELEMENT PART>
2785   <PARAM>
2786     id = ID  ;
2787     number = NUMBER  ;
2788     include = INCLUDE  ;
2789     exclude = EXCLUDE  ;
2790   <START-CODE>
2791     char *string =
2792       GetDefaultHeaderString("PartElementDefaultHeadingString",
2793                              M_SDATA,
2794                              "Part");
2795
2796       unimp(m_parent(0)) ;
2797       outfile = m_outfile; /* we want part not to trigger nullfile */
2798       m_free(string, "default header string return");
2799   <END-CODE>
2800     endhelpnode();
2801
2802 <ELEMENT PARTEXT>
2803
2804 <ELEMENT PARTNO>
2805   <START-CODE>
2806     char *string =
2807       GetDefaultHeaderString("PartNumberElementDefaultHeadingString",
2808                              M_SDATA,
2809                              "Part Number");
2810
2811     mb_starthelpnode("_PARTNO", TRUE);
2812     fprintf(outfile, "<TITLE><TYPE serif><WEIGHT bold><SIZE 14>%s</SIZE></WEIGHT></TYPE></TITLE>\n\n", string);
2813     fputs("<PARAGRAPH>", outfile);
2814     m_free(string, "default header string return");
2815   <END-CODE>
2816     fputs("</PARAGRAPH>\n\n", outfile);
2817
2818 <ELEMENT PREFACE>
2819   <PARAM>
2820     include = INCLUDE  ;
2821     exclude = EXCLUDE  ;
2822   <START-CODE>
2823     mb_starthelpnode("_PREFACE", TRUE);
2824    <END-CODE>
2825
2826 <ELEMENT PRINTDATE>
2827   <START-CODE>
2828     char *string =
2829       GetDefaultHeaderString("DatePrintedElementDefaultHeadingString",
2830                              M_SDATA,
2831                              "Date Printed");
2832
2833     mb_starthelpnode("_PRINTDATE", TRUE);
2834     fprintf(outfile, "<TITLE><TYPE serif><WEIGHT bold><SIZE 14>%s</SIZE></WEIGHT></TYPE></TITLE>\n\n", string);
2835     fputs("<PARAGRAPH>", outfile);
2836     m_free(string, "default header string return");
2837   <END-CODE>
2838     fputs("</PARAGRAPH>\n\n", outfile);
2839
2840 <ELEMENT PROCEDURE>
2841
2842 <ELEMENT PRODUCT>
2843   <START-CODE>
2844     char *string =
2845       GetDefaultHeaderString("ProductElementDefaultHeadingString",
2846                              M_SDATA,
2847                              "Product");
2848
2849     mb_starthelpnode("_PRODUCT", TRUE);
2850     fprintf(outfile, "<TITLE><TYPE serif><WEIGHT bold><SIZE 14>%s</SIZE></WEIGHT></TYPE></TITLE>\n\n", string);
2851     fputs("<PARAGRAPH>", outfile);
2852     m_free(string, "default header string return");
2853   <END-CODE>
2854     fputs("</PARAGRAPH>\n\n", outfile);
2855
2856 <ELEMENT QUADCELL>
2857
2858 <ELEMENT QUOTE>
2859   <START-CODE * COMPUTER>
2860     mb_strcode("\\\"", outfile) ;
2861     if (echo) putc('"', stderr) ;
2862   <END-CODE * COMPUTER>
2863     mb_strcode("\\\"", outfile) ;
2864     if (echo) putc('"', stderr) ;
2865
2866   <START-CODE>
2867     mb_strcode("``", outfile) ;
2868     if (echo) putc('"', stderr) ;
2869   <END-CODE>
2870     mb_strcode("''", outfile) ;
2871     if (echo) putc('"', stderr) ;
2872
2873   <START-CODE * IDX, * IDXSYN>
2874     indexchar('\"') ;
2875   <END-CODE * IDX, * IDXSYN>
2876     indexchar('\"') ;
2877   <TEXT-CODE * IDX, * IDXSYN>
2878     indexchar(m_textchar) ;
2879
2880 <ELEMENT REFERENCES>
2881
2882 <ELEMENT REPLACES>
2883   <START-CODE>
2884     char *string =
2885       GetDefaultHeaderString("ReplacesElementDefaultHeadingString",
2886                              M_SDATA,
2887                              "Replaces");
2888
2889     mb_starthelpnode("_REPLACES", TRUE);
2890     fprintf(outfile, "<TITLE><TYPE serif><WEIGHT bold><SIZE 14>%s</SIZE></WEIGHT></TYPE></TITLE>\n\n", string);
2891     fputs("<PARAGRAPH>", outfile);
2892     m_free(string, "default header string return");
2893   <END-CODE>
2894     fputs("</PARAGRAPH>\n\n", outfile);
2895
2896 <ELEMENT REQBLOCK>
2897   <START-CODE>
2898     synelcnt = 0;
2899     fputs("{", outfile);
2900   <END-CODE>
2901     fputs("}", outfile);
2902
2903 <ELEMENT REV>
2904   <PARAM>
2905     delim = DELIM (QBEGIN = BEGIN,
2906                    QEND = END,
2907                    QDELETE = DELETE) ;
2908     revid = REVID  ;
2909
2910 <ELEMENT REVIEWER>
2911
2912 <ELEMENT REVIEWERS>
2913   <TEXT-CODE>
2914
2915 <ELEMENT ROW>
2916
2917 <ELEMENT ROWH>
2918   <PARAM>
2919     style = CELLSPEC ;
2920     span = SPAN ;
2921     vspan = VSPAN ;
2922
2923 <ELEMENT RSECT>
2924   <PARAM>
2925     id = ID ;
2926     pagebreak = PAGEBREAK (QNEWPAGE = NEWPAGE,
2927                            QSAMEPAGE = SAMEPAGE) ;
2928     include = INCLUDE  ;
2929     exclude = EXCLUDE  ;
2930   <START-CODE>
2931     assert_hometopic_exists();
2932     if (!rsectseq) thisnodelevel = lastnodelevel + 1;
2933     starthelpnode(id, FALSE);
2934     rsectstart(id, pagebreak) ;
2935   <END-CODE>
2936     if (st4) {
2937       st4 = FALSE ;
2938       }
2939     endhelpnode();
2940
2941 <ELEMENT RSUB>
2942   <PARAM>
2943     include = INCLUDE  ;
2944     exclude = EXCLUDE  ;
2945   <START-CODE>
2946     rshnewclear() ;
2947   <START-CODE * S2>
2948     if (rsectsame) st4 = TRUE ;
2949     rshnewclear() ;
2950   <END-CODE>
2951     if (st4) st4 = FALSE ;
2952
2953 <ELEMENT S1>
2954   <PARAM>
2955     id = ID ;
2956     include = INCLUDE  ;
2957     exclude = EXCLUDE  ;
2958   <START-CODE>
2959     assert_hometopic_exists();
2960     thisnodelevel = 2;
2961     starthelpnode(id, FALSE);
2962     rsectseq = FALSE ;
2963     chapst = TRUE ;
2964     savid = checkid(id) ;
2965     iderr = FALSE ;
2966   <END-CODE>
2967     rseqend() ;
2968     endhelpnode();
2969
2970 <ELEMENT S2>
2971   <PARAM>
2972     id = ID ;
2973     include = INCLUDE  ;
2974     exclude = EXCLUDE  ;
2975   <START-CODE>
2976     thisnodelevel = 3;
2977     starthelpnode(id, FALSE);
2978     rsectseq = FALSE ;
2979     savid = checkid(id) ;
2980     iderr = FALSE ;
2981   <END-CODE>
2982     rseqend() ;
2983     endhelpnode();
2984
2985 <ELEMENT S3>
2986   <PARAM>
2987     id = ID ;
2988     include = INCLUDE  ;
2989     exclude = EXCLUDE  ;
2990   <START-CODE>
2991     thisnodelevel = 4;
2992     starthelpnode(id, FALSE);
2993     rsectseq = FALSE ;
2994     savid = checkid(id) ;
2995     iderr = FALSE ;
2996   <START-CODE * CSPOT>
2997     thisnodelevel = 4;
2998     starthelpnode(id, FALSE);
2999     rsectseq = FALSE ;
3000     savid = checkid(id) ;
3001     iderr = FALSE ;
3002   <END-CODE>
3003     rseqend() ;
3004     endhelpnode();
3005
3006 <ELEMENT S4>
3007   <PARAM>
3008     id = ID ;
3009     include = INCLUDE  ;
3010     exclude = EXCLUDE  ;
3011   <START-CODE>
3012     thisnodelevel = 5;
3013     starthelpnode(id, FALSE);
3014     savid = checkid(id) ;
3015     iderr = FALSE ;
3016     st4 = TRUE ;
3017   <START-CODE * CSPOT>
3018     thisnodelevel = 5;
3019     starthelpnode(id, FALSE);
3020     savid = checkid(id) ;
3021     iderr = FALSE ;
3022     st4 = TRUE ;
3023   <END-CODE>
3024     if (st4) st4 = FALSE ;
3025     endhelpnode();
3026
3027 <ELEMENT S5>
3028   <PARAM>
3029     id = ID ;
3030     include = INCLUDE  ;
3031     exclude = EXCLUDE  ;
3032   <START-CODE>
3033     thisnodelevel = 6;
3034     starthelpnode(id, FALSE);
3035     rsectseq = FALSE ;
3036     savid = checkid(id) ;
3037     iderr = FALSE ;
3038   <END-CODE>
3039     rseqend() ;
3040     endhelpnode();
3041
3042 <ELEMENT S6>
3043   <PARAM>
3044     id = ID ;
3045     include = INCLUDE  ;
3046     exclude = EXCLUDE  ;
3047   <START-CODE>
3048     thisnodelevel = 7;
3049     starthelpnode(id, FALSE);
3050     rsectseq = FALSE ;
3051     savid = checkid(id) ;
3052     iderr = FALSE ;
3053   <END-CODE>
3054     rseqend() ;
3055     endhelpnode();
3056
3057 <ELEMENT S7>
3058   <PARAM>
3059     id = ID ;
3060     include = INCLUDE  ;
3061     exclude = EXCLUDE  ;
3062   <START-CODE>
3063     thisnodelevel = 8;
3064     starthelpnode(id, FALSE);
3065     rsectseq = FALSE ;
3066     savid = checkid(id) ;
3067     iderr = FALSE ;
3068   <END-CODE>
3069     rseqend() ;
3070     endhelpnode();
3071
3072 <ELEMENT S8>
3073   <PARAM>
3074     id = ID ;
3075     include = INCLUDE  ;
3076     exclude = EXCLUDE  ;
3077   <START-CODE>
3078     thisnodelevel = 9;
3079     starthelpnode(id, FALSE);
3080     rsectseq = FALSE ;
3081     savid = checkid(id) ;
3082     iderr = FALSE ;
3083   <END-CODE>
3084     rseqend() ;
3085     endhelpnode();
3086
3087 <ELEMENT S9>
3088   <PARAM>
3089     id = ID ;
3090     include = INCLUDE  ;
3091     exclude = EXCLUDE  ;
3092   <START-CODE>
3093     thisnodelevel = 10;
3094     starthelpnode(id, FALSE);
3095     rsectseq = FALSE ;
3096     savid = checkid(id) ;
3097     iderr = FALSE ;
3098   <END-CODE>
3099     rseqend() ;
3100     endhelpnode();
3101
3102 <ELEMENT SAFETY>
3103   <PARAM>
3104     include = INCLUDE  ;
3105     exclude = EXCLUDE  ;
3106   <START-CODE>
3107     mb_starthelpnode("_SAFETY", TRUE);
3108 <END-CODE>
3109
3110 <ELEMENT SDC>
3111   <START-CODE>
3112     char *string =
3113       GetDefaultHeaderString("SDCElementDefaultHeadingString",
3114                              M_SDATA,
3115                              "SDC");
3116
3117     mb_starthelpnode("_SDC", TRUE);
3118     fprintf(outfile, "<TITLE><TYPE serif><WEIGHT bold><SIZE 14>%s</SIZE></WEIGHT></TYPE></TITLE>\n\n", string);
3119     fputs("<PARAGRAPH>", outfile);
3120     m_free(string, "default header string return");
3121   <END-CODE>
3122     fputs("</PARAGRAPH>\n\n", outfile);
3123
3124 <ELEMENT SEEFROMPRIMARY>
3125   <START-CODE>
3126     IDXSTRT
3127   <END-CODE>
3128     IDXEND
3129
3130 <ELEMENT SEEFROMSUB>
3131   <START-CODE>
3132     IDXSTRT
3133   <END-CODE>
3134     IDXEND
3135
3136 <ELEMENT SEETOPRIMARY>
3137   <START-CODE>
3138     IDXSTRT
3139   <END-CODE>
3140     IDXEND
3141
3142 <ELEMENT SEETOSUB>
3143   <START-CODE>
3144     IDXSTRT
3145   <END-CODE>
3146     IDXEND
3147
3148 <ELEMENT SERIALNO>
3149   <START-CODE>
3150     char *string =
3151       GetDefaultHeaderString("SerialNumberElementDefaultHeadingString",
3152                              M_SDATA,
3153                              "Serial Number");
3154
3155     mb_starthelpnode("_SERIALNO", TRUE);
3156     fprintf(outfile, "<TITLE><TYPE serif><WEIGHT bold><SIZE 14>%s</SIZE></WEIGHT></TYPE></TITLE>\n\n", string);
3157     m_free(string, "default header string return");
3158   <END-CODE>
3159
3160 <ELEMENT SKLINE>
3161   <START-CODE * IDX, * IDXSYN>
3162     if (newhline++) indexchar(' ');
3163   <TEXT-CODE * IDX, * IDXSYN>
3164     indexchar(m_textchar) ;
3165   <END-CODE>
3166     skchars = 0 ;
3167
3168 <ELEMENT SOFTKEY>
3169   <START-CODE * IDX, * IDXSYN>
3170     newhline = 0 ;
3171   <END-CODE * IDX, * IDXSYN>
3172   <TEXT-CODE * IDX, * IDXSYN>
3173     indexchar(m_textchar) ;
3174
3175   <START-CODE>
3176     sklines = 0 ;
3177     skchars = 0 ;
3178     if (echo) mb_echohead("{{") ;
3179   <END-CODE>
3180     if (echo) mb_echohead("}}") ;
3181   <TEXT-CODE>
3182      esoutchar(m_textchar) ;
3183      skchars++ ;
3184
3185 <ELEMENT SORT>
3186   <START-CODE INDEXPRIMARY>
3187      didsort = TRUE;
3188      idxsav[idxsavlen] = M_EOS;
3189      w_strcpy(print, idxsav);
3190      idxsavlen = 0;
3191   <END-CODE INDEXPRIMARY>
3192      idxsav[idxsavlen] = M_EOS;
3193      w_strcpy(sort, idxsav);
3194   <START-CODE INDEXSUB>
3195      didsubsort = TRUE;
3196      idxsav[idxsavlen] = M_EOS;
3197      w_strcpy(subprint, idxsav);
3198      idxsavlen = 0;
3199   <END-CODE INDEXSUB>
3200      idxsav[idxsavlen] = M_EOS;
3201      w_strcpy(subsort, idxsav);
3202   <START-CODE>
3203   <END-CODE>
3204
3205 <ELEMENT SOURCE>
3206   <START-CODE>
3207     char *string =
3208       GetDefaultHeaderString("SourceElementDefaultHeadingString",
3209                              M_SDATA,
3210                              "Source");
3211
3212     mb_starthelpnode("_SOURCE", TRUE);
3213     fprintf(outfile, "<TITLE><TYPE serif><WEIGHT bold><SIZE 14>%s</SIZE></WEIGHT></TYPE></TITLE>\n\n", string);
3214     fputs("<PARAGRAPH>", outfile);
3215     m_free(string, "default header string return");
3216   <END-CODE>
3217     fputs("</PARAGRAPH>\n\n", outfile);
3218
3219 <ELEMENT SUB>
3220   <START-CODE>
3221     if (echo) mb_echohead("__") ;
3222   <END-CODE>
3223     if (echo) mb_echohead("__") ;
3224   <START-CODE * COMPUTER, * SOFTKEY, * WHITEMENU>
3225     if (echo) mb_echohead("__") ;
3226   <END-CODE * COMPUTER, * SOFTKEY, * WHITEMENU>
3227     if (echo) mb_echohead("__") ;
3228   <START-CODE * CCELL>
3229     if (echo) mb_echohead("__") ;
3230   <END-CODE * CCELL>
3231     if (echo) mb_echohead("__") ;
3232
3233   <START-CODE * IDX, * IDXSYN>
3234   <END-CODE * IDX, * IDXSYN>
3235   <TEXT-CODE * IDX, * IDXSYN>
3236     indexchar(m_textchar) ;
3237
3238   <TEXT-CODE * COMPUTER, * SOFTKEY, * WHITEMENU>
3239      outchar(m_textchar, outfile) ;
3240
3241   <TEXT-CODE * EXAMPLESEG, * IMAGE>
3242     outchar(m_textchar, outfile) ;
3243
3244 <ELEMENT SUBCATEGORY>
3245   <START-CODE>
3246      newhline = 0 ;
3247
3248 <ELEMENT SUPER>
3249   <START-CODE>
3250     if (echo) mb_echohead("^^") ;
3251   <END-CODE>
3252     if (echo) mb_echohead("^^") ;
3253   <TEXT-CODE * COMPUTER, * SOFTKEY, * WHITEMENU>
3254      outchar(m_textchar, outfile) ;
3255   <START-CODE * IDX, * IDXSYN>
3256   <END-CODE * IDX, * IDXSYN>
3257   <TEXT-CODE * IDX, * IDXSYN>
3258     indexchar(m_textchar) ;
3259
3260   <TEXT-CODE * EXAMPLESEG, * IMAGE>
3261      outchar(m_textchar, outfile) ;
3262
3263 <ELEMENT SYNEL>
3264   <START-CODE OPTBLOCK, REQBLOCK>
3265     if (synelcnt++) {
3266         fputs("\n", outfile);
3267     }
3268   <END-CODE OPTBLOCK, REQBLOCK>
3269   <END-CODE>
3270     fputs("\n", outfile);
3271   <TEXT-CODE>
3272      if (m_textchar == M_SPACE) fputs("\\ ", outfile) ;
3273      else outchar(m_textchar, outfile) ;
3274
3275 <ELEMENT SYNONYM>
3276
3277 <ELEMENT SYNTAX>
3278   <START-CODE TEXT ITEM>
3279     /* In a tight list, paragraphs will have no trailing blank line.
3280      * To match HPTag behavior, we need to emit a blank line and
3281      * supress the leading blank line of the next paragraph, figure,
3282      * example, etc., if any.
3283     */
3284     char *listinfo;
3285     STARTSTUFF
3286
3287     listinfo = "";
3288     if ((lastlist->lastlist->space == TIGHT) &&
3289         (lastlist->lastlist->where == INSIDE)) {
3290        listinfo = " before 1";
3291     }
3292     rshnewclear() ;
3293     fprintf(outfile,
3294    "<PARAGRAPH%s firstindent %d leftindent %d nowrap><TYPE serif><SPACING m>",
3295             listinfo,
3296             LEFTINDENT,
3297             LEFTINDENT);
3298   <START-CODE>
3299     STARTSTUFF
3300     rshnewclear() ;
3301     fprintf(outfile, "<PARAGRAPH firstindent %d leftindent %d nowrap><TYPE serif><SPACING m>", LEFTINDENT, LEFTINDENT);
3302   <END-CODE TEXT ITEM>
3303     fputs("</SPACING></TYPE></PARAGRAPH>\n\n", outfile);
3304     lastlist->lastlist->where = FOLLOW; /* supress leading newline */
3305   <END-CODE>
3306     fputs("</SPACING></TYPE></PARAGRAPH>\n\n", outfile);
3307   <TEXT-CODE>
3308     if (m_textchar == M_SPACE) fputs("\\ ", outfile) ;
3309     else outchar(m_textchar, outfile) ;
3310
3311 <ELEMENT TABLE>
3312   <PARAM>
3313     style = COLSPEC ;
3314     id = ID ;
3315     number = NUMBER ;
3316     tonumber = TONUMBER (QNUMBER = NUMBER,
3317                          QNONUMBER = NONUMBER) ;
3318     box = BOX (QBOX = BOX,
3319                QNOBOX = NOBOX) ;
3320     rule = RULE (QNORULE = NORULE,
3321                  QHEADRULE = HEADRULE,
3322                  QGRID = GRID) ;
3323     vrule = ALLVRULES ;
3324     hrule = ALLHRULES ;
3325     vcount = VRULE ;
3326     hcount = HRULE ;
3327     spacing = SPACING (QTIGHT = TIGHT,
3328                        QLOOSE = LOOSE) ;
3329     width = WIDTH (QFULL = FULL) ;
3330     position = POSITION (QLEFT = LEFT,
3331                          QINDENT = INDENT,
3332                          QCENTER = CENTER) ;
3333     divide = DIVIDE ;
3334     textsize = TEXTSIZE (QNORMAL = NORMAL,
3335                          QSMALLER = SMALLER,
3336                          QSMALLEST = SMALLEST) ;
3337   <START-CODE>
3338     fputs("<PARAGRAPH>", outfile);
3339     unimp(m_parent(0)) ;
3340   <END-CODE>
3341     fputs("</PARAGRAPH>\n", outfile);
3342
3343 <ELEMENT TABLEHEAD>
3344
3345 <ELEMENT TERM>
3346   <PARAM>
3347     base = BASE ;
3348     gloss = GLOSS (QGLOSS = GLOSS,
3349                    QNOGLOSS = NOGLOSS) ;
3350   <START-CODE>
3351     termp = term ;
3352     wsterm = FALSE ;
3353     tooutput = FALSE;
3354     if (echo) mb_echohead("++") ;
3355   <END-CODE * GLOSSARY>
3356     endterm(base, gloss, 0); /* 0 => don't use definition window for link */
3357   <END-CODE>
3358     endterm(base, gloss, 2); /* 2 => use definition window for link       */
3359   <TEXT-CODE>
3360     termchar(m_textchar) ;
3361   <PI-CODE>
3362     /* could need to handle calculator context sensitive entities
3363      * here if needed to reduce tex macro count
3364      */
3365     termpi(m_enttype, m_pi, m_entname) ;
3366
3367 <ELEMENT TEST>
3368   <PARAM>
3369     id = ID ;
3370     include = INCLUDE  ;
3371     exclude = EXCLUDE  ;
3372   <START-CODE>
3373     thisnodelevel = 2;
3374     starthelpnode(id, FALSE);
3375     rsectseq = FALSE ;
3376     chapst = TRUE ;
3377     savid = checkid(id) ;
3378     iderr = FALSE ;
3379   <END-CODE>
3380     rseqend() ;
3381     endhelpnode();
3382
3383 <ELEMENT TEXT>
3384   <START-CODE NOTE>
3385     char *iconName =
3386       GetDefaultHeaderString("NoteElementDefaultIconFile", M_SYSTEM, "");
3387     char *string =
3388       GetDefaultHeaderString("NoteElementDefaultHeadingString",
3389                              M_SDATA,
3390                              "NOTE");
3391
3392
3393     /* Write default note head if no user-specified head was encountered */
3394     if (! notehead) {
3395       fprintf(outfile, ncwStart, ncwTightList);
3396       fprintf(outfile, ncwEnd, string);
3397       if (*iconName)
3398         {
3399         fprintf(outfile, ncwGraphic, iconName);
3400         m_free(iconName, "icon name");
3401         }
3402       notehead = TRUE;
3403       }
3404     m_free(string, "default header string return");
3405   <START-CODE CAUTION>
3406     char *iconName =
3407       GetDefaultHeaderString("CautionElementDefaultIconFile", M_SYSTEM, "");
3408     char *string =
3409       GetDefaultHeaderString("CautionElementDefaultHeadingString",
3410                              M_SDATA,
3411                              "CAUTION");
3412
3413
3414     /* Write default caution head if no user-specified head was encountered */
3415     if (! notehead) {
3416       fprintf(outfile, ncwStart, ncwTightList);
3417       fprintf(outfile, ncwEnd, string);
3418       if (*iconName)
3419         {
3420         fprintf(outfile, ncwGraphic, iconName);
3421         m_free(iconName, "icon name");
3422         }
3423       notehead = TRUE;
3424       }
3425     m_free(string, "default header string return");
3426   <START-CODE WARNING>
3427     char *iconName =
3428       GetDefaultHeaderString("WarningElementDefaultIconFile", M_SYSTEM, "");
3429     char *string =
3430       GetDefaultHeaderString("WarningElementDefaultHeadingString",
3431                              M_SDATA,
3432                              "WARNING");
3433
3434     /* Write default warning head if no user-specified head was encountered */
3435     if (! notehead) {
3436       fprintf(outfile, ncwStart, ncwTightList);
3437       fprintf(outfile, ncwEnd, string);
3438       if (*iconName)
3439         {
3440         fprintf(outfile, ncwGraphic, iconName);
3441         m_free(iconName, "icon name");
3442         }
3443       notehead = TRUE;
3444       }
3445     m_free(string, "default header string return");
3446   <START-CODE OTHERFRONT>
3447      if (!had_an_otherfront_head) {
3448            endhead();
3449      }
3450   <START-CODE MESSAGE>
3451     checkmsghead() ;
3452   <START-CODE ABSTRACT>
3453      if (needabstracthead)
3454          {
3455          fprintf(outfile, "<TITLE></TITLE>\n");
3456          needabstracthead = FALSE;
3457          }
3458   <END-CODE LABLIST>
3459     fputs("</PARAGRAPH>\n", outfile);
3460
3461 <ELEMENT TITLE>
3462   <START-CODE>
3463     char *string =
3464       GetDefaultHeaderString("TitleElementDefaultHeadingString",
3465                              M_SDATA,
3466                              "Title");
3467
3468     hadtitle = TRUE;
3469     mb_starthelpnode("_TITLE", TRUE);
3470     fprintf(outfile, "<TITLE><TYPE serif><WEIGHT bold><SIZE 14>%s</SIZE></WEIGHT></TYPE></TITLE>\n\n", string);
3471     newhline = 0 ;
3472     savhd = TRUE ;
3473     hderr = FALSE ;
3474     svheadlen = 0 ;
3475     tooutput = TRUE ;
3476     fputs("<PARAGRAPH>", outfile);
3477     m_free(string, "default header string return");
3478   <END-CODE>
3479     fputs("</PARAGRAPH>\n\n", outfile);
3480     savehead[svheadlen] = M_EOS ;
3481     savhd = FALSE ;
3482     if (hderr) {
3483          m_error("Error collecting title characters.");
3484     }
3485
3486     {
3487     char *mb_savehead;
3488
3489     mb_savehead = MakeMByteString(savehead);
3490     fprintf(docregfp, "*title:\t%s\n", mb_savehead);
3491     m_free(mb_savehead,"multi-byte string");
3492     }
3493
3494     savedtitle = (M_WCHAR *) m_malloc(w_strlen(savehead) + 1, "saved title");
3495     w_strcpy(savedtitle, savehead);
3496
3497 <ELEMENT TITLEFIG>
3498
3499 <ELEMENT TNOTE>
3500   <PARAM>
3501     tnoteid = ID  ;
3502
3503 <ELEMENT TNOTEREF>
3504   <PARAM>
3505     tnoteid = ID  ;
3506
3507 <ELEMENT TOC>
3508
3509 <ELEMENT USER>
3510   <START-CODE>
3511     if (echo) {
3512       mb_echohead(m_stago) ;
3513       echohead(m_parent(0)) ;
3514       mb_echohead(m_net) ;
3515       }
3516     mb_strcode("<SPACING m><WEIGHT bold>", outfile);
3517   <TEXT-CODE>
3518     esoutchar(m_textchar) ;
3519   <END-CODE>
3520     if (echo) mb_echohead(m_net) ;
3521     mb_strcode("</WEIGHT></SPACING>", outfile);
3522   <TEXT-CODE * EXAMPLESEG>
3523     exoutchar(m_textchar) ;
3524
3525   <START-CODE * IDX, * IDXSYN>
3526   <END-CODE * IDX, * IDXSYN>
3527   <TEXT-CODE * IDX, * IDXSYN>
3528     indexchar(m_textchar) ;
3529
3530 <ELEMENT VAR>
3531   <START-CODE>
3532     mb_strcode("<TYPE serif><ANGLE italic><SPACING p>", outfile) ;
3533     if (echo) mb_echohead("%%") ;
3534   <END-CODE>
3535     mb_strcode("</SPACING></ANGLE></TYPE>", outfile) ;
3536     if (echo) mb_echohead("%%") ;
3537
3538   <START-CODE * IDX, * IDXSYN>
3539   <END-CODE * IDX, * IDXSYN>
3540   <TEXT-CODE * IDX, * IDXSYN>
3541     indexchar(m_textchar) ;
3542
3543   <END-CODE * EXAMPLESEG, * IMAGE, * SYNEL>
3544     POPFONT ;
3545     mb_strcode("</SPACING></ANGLE></TYPE>", outfile) ;
3546
3547   /* added to fix calculator computer chars */
3548   <TEXT-CODE * SYNEL>
3549     if (m_textchar == M_SPACE) fputs("\\ ", outfile) ;
3550     else outchar(m_textchar, outfile) ;
3551
3552 <ELEMENT VERSION>
3553   <START-CODE>
3554     char *string =
3555       GetDefaultHeaderString("VersionElementDefaultHeadingString",
3556                              M_SDATA,
3557                              "Version");
3558
3559     mb_starthelpnode("_VERSION", TRUE);
3560     fprintf(outfile, "<TITLE><TYPE serif><WEIGHT bold><SIZE 14>%s</SIZE></WEIGHT></TYPE></TITLE>\n\n", string);
3561     fputs("<PARAGRAPH>", outfile);
3562     m_free(string, "default header string return");
3563   <END-CODE>
3564     fputs("</PARAGRAPH>\n\n", outfile);
3565
3566 <ELEMENT VEX>
3567   <PARAM>
3568     type = TYPE (QCOMPUTER = COMPUTER,
3569                  QDISPLAY  = DISPLAY) ;
3570     position = POSITION (QLEFT = LEFT,
3571                          QINDENT = INDENT,
3572                          QCENTER = CENTER) ;
3573     lines = LINES (QNUMBER = NUMBER,
3574                    QNONUMBER = NONUMBER) ;
3575     textsize = TEXTSIZE (QNORMAL = NORMAL,
3576                          QSMALLER = SMALLER,
3577                          QSMALLEST = SMALLEST) ;
3578   <START-CODE TEXT ITEM>
3579     /* In a tight list, paragraphs will have no trailing blank line.
3580      * To match HPTag behavior, we need to emit a blank line and
3581      * supress the leading blank line of the next paragraph, figure,
3582      * example, etc., if any.
3583     */
3584     char *listinfo;
3585
3586     listinfo = "";
3587     if ((lastlist->lastlist->space == TIGHT) &&
3588         (lastlist->lastlist->where == INSIDE)) {
3589        listinfo = " before 1";
3590     }
3591
3592     exvexstart(type, textsize, listinfo) ;
3593     tonumexlines = (LOGICAL) (vnumber(lines) == NUMBER);
3594     exlineno = 1 ;
3595     if (tonumexlines) fprintf(outfile, " %d.  ", exlineno) ;
3596   <START-CODE>
3597     exvexstart(type, textsize, "") ;
3598     tonumexlines = (LOGICAL) (vnumber(lines) == NUMBER);
3599     exlineno = 1 ;
3600     if (tonumexlines) fprintf(outfile, " %d.  ", exlineno) ;
3601   <END-CODE TEXT ITEM>
3602      exvexend(textsize);
3603     lastlist->lastlist->where = FOLLOW; /* supress leading newline */
3604   <END-CODE>
3605      exvexend(textsize);
3606   <TEXT-CODE>
3607       exoutchar(m_textchar) ;
3608
3609 <ELEMENT VOLUME>
3610   <START-CODE>
3611     char *string =
3612       GetDefaultHeaderString("VolumeElementDefaultHeadingString",
3613                              M_SDATA,
3614                              "Volume");
3615
3616     mb_starthelpnode("_VOLUME", TRUE);
3617     fprintf(outfile, "<TITLE><TYPE serif><WEIGHT bold><SIZE 14>%s</SIZE></WEIGHT></TYPE></TITLE>\n\n", string);
3618     fputs("<PARAGRAPH>", outfile);
3619     m_free(string, "default header string return");
3620   <END-CODE>
3621     fputs("</PARAGRAPH>\n\n", outfile);
3622
3623 <ELEMENT WARNING>
3624   <START-CODE TEXT ITEM>
3625     STARTSTUFF
3626     /* In a tight list, paragraphs will have no trailing blank line.
3627      * To match HPTag behavior, we need to emit a blank line and
3628      * supress the leading blank line of the next paragraph, figure,
3629      * example, etc., if any.
3630     */
3631     ncwTightList = "";
3632     if ((lastlist->lastlist->space == TIGHT) &&
3633         (lastlist->lastlist->where == INSIDE)) {
3634        ncwTightList = " before 1";
3635     }
3636
3637     rshnewclear() ;
3638     notehead = FALSE ;
3639   <START-CODE>
3640     STARTSTUFF
3641     ncwTightList = "";
3642     rshnewclear() ;
3643     notehead = FALSE ;
3644   <END-CODE TEXT ITEM>
3645     fputs("</PARAGRAPH>\n\n", outfile);
3646     lastlist->lastlist->where = FOLLOW; /* supress leading newline */
3647   <END-CODE>
3648     fputs("</PARAGRAPH>\n\n", outfile);
3649
3650 <ELEMENT WHATSIT>
3651   <PARAM>
3652     original = ORIGINAL ;
3653   <START-CODE>
3654     --m_errcnt ; /* this is a message, not really an error */
3655     if (original)
3656       m_err1("Convert %s WHATSIT to Tag markup", original) ;
3657     else
3658       m_error("Convert WHATSIT to Tag markup") ;
3659
3660 <ELEMENT WHITEMENU>
3661   <START-CODE * IDX, * IDXSYN>
3662     newhline = 0 ;
3663   <TEXT-CODE * IDX, * IDXSYN>
3664     indexchar(m_textchar) ;
3665   <TEXT-CODE>
3666
3667 <ELEMENT XREF>
3668 /* Cross-referencing that allows forward references is inherently a two-pass
3669 process.  However, this interface assumes a two-pass process.  MARKUP
3670 provides the first pass and TeX the second.  MARKUP can therefore define
3671 a TeX macro for every cross-reference and write a file of definitions of
3672 these macros that is read at the beginning of the TeX pass.  In fact,
3673 information about cross-references is stored in a trie by MARKUP.  Data is
3674 entered into this structure both when a cross-reference is defined (with
3675 an id parameter on a chapter, figure, etc.) and when it is used (with the
3676 xref element).  At the end of the manual, the file xref.tex is written
3677 with definitions of macros corresponding to all cross-references defined
3678 or accessed.  In addition, the file xreftbl is written to save this
3679 information in a form that can be read to initialize the trie the next
3680 time the manual is processed.  Saving cross-reference information across
3681 runs of MARKUP allows a manual to be processed a chapter at a time without
3682 invalidating interchapter references.  The file xreftbl should be
3683 deleted before final processing, however, to verify that no cross-references
3684 remain to an id that existed at one time and was deleted.  Such an id could
3685 remain in the cross-reference table indefinitely.
3686 */
3687   <PARAM>
3688     id = ID ;
3689   <START-CODE * IDX, * IDXSYN>
3690   <TEXT-CODE * IDX, * IDXSYN>
3691     indexchar(m_textchar) ;
3692   <START-CODE>
3693     xrefexpand(id) ;