/*****************************************************************************/
/*
                                  navig8.c

Navigate through the wasDOC document.

This includes generating a primary Table of Content from the rendered HTML. 

Secondary TOCs for each major section.

Navigation icon/links <back><prev><top><next><forward> with each major section.

An "Index" for the document.



VERSION HISTORY
---------------
28-FEB-2019  MGD  initial
*/
/*****************************************************************************/

#include "wasdoc.h"

extern int  dbug;

/*****************************************************************************/
/*
Generate fragment references from the text of all document headings.
*/

int navig8AnchorHeadings (struct wasdoc_st *docptr)

{
   int  at, length;
   char  *cptr, *hptr, *sptr, *zptr;
   char  anchor [512],
         text [256];

   if (dbug>0) dbugThis (FI_LI, "navig8AnchorHeadings()");

   if (!(hptr = docptr->html)) RETURN_FI_LI (docptr, EILSEQ)

   for (; *hptr; hptr++)
   {
      if (*hptr != '<') continue;
      if (MATCH4 (hptr, "<!--")) hptr = navig8Source (docptr, hptr);
      if (!MATCH2 (hptr, "<h") || !isdigit(hptr[2])) continue;

      at = hptr - docptr->html;
      docptr->hparse = hptr - docptr->html;
      if (!*hptr) goto EILSEQ_error;
      /* skip over the commented fragment ID */
      hptr = navig8SkipHeadingId (hptr);
      if (!hptr) goto EILSEQ_error;
      docptr->hparse = hptr - docptr->html;
      hptr = navig8HeadingText (hptr, text, sizeof(text));
      docptr->hparse = hptr - docptr->html;
      if (!hptr) goto EILSEQ_error;

      zptr = (sptr = anchor) + sizeof(anchor)-1;
      for (cptr = "<a id=\""; *cptr && sptr < zptr; *sptr++ = *cptr++);
      /* skip over any heading TOC n.n.n */
      for (cptr = text; *cptr; cptr++)
         if (!(isdigit (*cptr) || *cptr == '.')) break;
      /* now convert the rest to lower case */
      for (; *cptr; cptr++)
         if (isalnum (*cptr)) *sptr++ = tolower(*cptr);
      for (cptr = "\" href=\"#\"></a>\n"; *cptr && sptr < zptr; *sptr++ = *cptr++);
      *sptr = '\0';
      if (sptr >= zptr) goto EILSEQ_error;
      length = sptr - anchor;

      wasDocInsertAt (docptr, at, 0, anchor, length); 
      /* reposition to end of insert */
      hptr = docptr->html + docptr->hparse;
   }

   return (0);

EILSEQ_error:

   docptr->hparse = hptr - docptr->html;
   RETURN_FI_LI (docptr, EILSEQ)
}

/*****************************************************************************/
/*
Generate a primary Table of Content from the generated HTML.
           ~~~~~~~                  ~~~~~~~~~~~~~~~~~~~~~~~
A primary TOC includes all <h1>..<h3> headings.
Primary heading entries can be excluded by prefixing their |01...| with two
additional zeros, i.e. |001..|.  See renderInsertHeading().
*/

int navig8TOC (struct wasdoc_st *docptr)

{
   int  cnt, period, retval = 0;
   char  ch;
   char  *atptr, *cptr, *hptr, *iptr, *sptr;
   char  text [256];
   struct  wasdoc_st  *tocptr;

   if (dbug>0) dbugThis (FI_LI, "navig8TOC()");

   if (!(hptr = docptr->html)) RETURN_FI_LI (docptr, EILSEQ)

   /* find where the TOC should be inserted */
   for (atptr = docptr->html; *atptr; atptr++)
   {
      if (*atptr != '<') continue;
      if (!MATCH4 (atptr, "<!--")) continue;
      if (!memcmp (atptr, "<!-- $TOC$ -->", 14)) break;
   }
   if (!*atptr) return (0);

   tocptr = calloc (1, sizeof(struct wasdoc_st)); 
   if (!tocptr) exit (vaxc$errno);

   wasDocHtmlPrint (tocptr,
"<div class=\"TOCcols%d\">\n\
<table class=\"TOCtable\">\n",
                    docptr->setTocCols);

   while (*hptr)
   {
      /* search for <h1..4 */
      for (; *hptr; hptr++)
      {
         if (*hptr != '<') continue;
         if (MATCH4 (hptr, "<!--")) hptr = navig8Source (docptr, hptr);
         if (!MATCH2 (hptr, "<h") || !isdigit(hptr[2])) continue;
         break;
      }
      if (!*hptr) break;

      /* TOC entry level? */
      if (hptr[2] != '1' && hptr[2] != '2' && hptr[2] != '3' && hptr[2] != '4')
      {
         hptr += 3;
         continue;
      }

      ch = hptr[2];

      hptr = navig8GetHeadingId (hptr, docptr->fragid);
      if (!hptr) goto EILSEQ_error;

      if (navig8Heading0 (docptr->fragid)) continue;

      hptr = navig8HeadingText (hptr, text, sizeof(text));
      if (!hptr) goto EILSEQ_error;

      /* scan over any TOC numbering */
      period = 0;
      for (cptr = text; *cptr == '.' || isdigit(*cptr); cptr++)
         if (*cptr == '.') period = *cptr;
      if (period)
      {
         *cptr++ = '\0';
         iptr = text;
      }
      else
      {
         cptr = text;
         iptr = "";
      }

      if (docptr->setTocForm[0] >= '1' &&
          docptr->setTocForm[0] <= '9')
      {
         if (docptr->setTocForm[1])
            /* numbering and heading separated by repeated characters */
            wasDocHtmlPrint (tocptr,
"<tr><td class=\"TOCsep\"><a href=\"%s#%s\">%s</a> %s\
<td class=\"TOCtext%s\"><a href=\"%s#%s\">%s</a>\n",
                          navig8ChunkPath(docptr,-1), docptr->fragid, iptr,
                          docptr->setTocForm+1,
                          ch == '1' ? " TOCmajor" : "",
                          navig8ChunkPath(docptr,-1), docptr->fragid, cptr);
         else
            /* just empty space */
            wasDocHtmlPrint (tocptr,
"<tr><td class=\"TOCnum\"><a href=\"%s#%s\">%s</a>\
<td class=\"TOCtext%s\"><a href=\"%s#%s\">%s</a>\n",
                          navig8ChunkPath(docptr,-1),
                          ch == '1' ? " TOCmajor" : "",
                          docptr->fragid, iptr, navig8ChunkPath(docptr,-1),
                          docptr->fragid, cptr);
      }
      else
         /* anything else (e.g. HTML entity) is just used as-is */
         wasDocHtmlPrint (tocptr,
"<tr><td class=\"TOCtext%s\"><a href=\"%s#%s\">%s%s</a>\n",
                          ch == '1' ? " class=\"TOCmajor\"" : "",
                          navig8ChunkPath(docptr,-1),
                          docptr->fragid, docptr->setTocForm, text);
   }

   if (!tocptr->hlength) goto EILSEQ_error;

   wasDocHtmlPrint (tocptr, "</table>\n</div>\n");

   wasDocInsertAt (docptr, atptr - docptr->html, sizeof("<!-- $TOC$ -->")-1,
                   tocptr->html, tocptr->hlength); 

   goto exit_now;

EILSEQ_error:

   docptr->hparse = hptr - docptr->html;
   retval = EILSEQ;
   SET_FI_LI (docptr)
   goto exit_now;

exit_now:

   if (tocptr)
   {
      if (tocptr->html) free (tocptr->html);
      free (tocptr);
   }

   return (retval);
}

/*****************************************************************************/
/*
Generate a secondary (sub-)TOC after each <h1> from the generated HTML.
           ~~~~~~~~~                           ~~~~~~~~~~~~~~~~~~~~~~~
Secondary TOCs can include secondary headings not included in a primary TOC. 
Secondary heading entries can be excluded by prefixing their |0...| with an
additional zero, i.e. |00..|.  See renderInsertHeading().
*/

int navig8SubTOC (struct wasdoc_st *docptr)

{
   int  cnt, error = 0, retval = 0;
   char  *cptr, *hptr, *h1ptr, *sptr;
   char  ch;
   char  fragnum [FRAGID_SIZE],
         text [256];
   struct  wasdoc_st  *tocptr;

   if (dbug>0) dbugThis (FI_LI, "navig8SubTOC()");

   if (!docptr->setToc2) return (0);

   if (!(hptr = docptr->html)) RETURN_FI_LI (docptr, EILSEQ)

   tocptr = calloc (1, sizeof(struct wasdoc_st)); 
   if (!tocptr) exit (vaxc$errno);

   while (*hptr)
   {
      for (; *hptr; hptr++)
      {
         if (*hptr != '<') continue;
         if (MATCH4 (hptr, "<!--")) hptr = navig8Source (docptr, hptr);
         if (!MATCH8 (hptr, "<h1 clas")) continue;
         break;
      }
      if (!*hptr) break;

      hptr = navig8GetHeadingId (hptr, fragnum);
      if (!hptr) goto EILSEQ_error;

      /* but not before the first |1 */
      if (fragnum[0] == '0') continue;

      /* if not a numbered heading */
      if (navig8Heading0 (fragnum)) continue;

      /* search for closing </h1> */
      for (; *hptr; hptr++)
      {
         if (*hptr != '<') continue;
         if (!MATCH5 (hptr, "</h1>")) continue;
         break;
      }
      if (!*hptr) goto EILSEQ_error;

      for (h1ptr = hptr += 5; *hptr; hptr++)
      {
         /* search for sub-headings */
         if (*hptr != '<') continue;

         if (!(MATCH2 (hptr, "<h") && isdigit(hptr[2]))) continue;

         /* if hit the next major section */
         if ((ch = hptr[2]) == '1') break;

         if (docptr->setToc2 == 1 && ch > '4') continue;

         hptr = navig8GetHeadingId (hptr, docptr->fragid);
         if (!hptr) goto EILSEQ_error;

         hptr = navig8HeadingText (hptr, text, sizeof(text));
         if (!hptr) goto EILSEQ_error;

         if (!tocptr->hlength)
         {
            error = wasDocHtmlPrint (tocptr,
"\n\n<table class=\"subTOCtable\">\n");
            if (error) goto exit_now;
         }

         if (docptr->setToc2 == 2 && ch <= '4')
            error = wasDocHtmlPrint (tocptr,
"<tr><td><a class=\"bold\" href=\"%s#%s\">%s</a>\n",
                                     navig8ChunkPath(docptr,-1),
                                     docptr->fragid, text);
         else
            error = wasDocHtmlPrint (tocptr,
"<tr><td><a href=\"%s#%s\">%s</a>\n",
                                     navig8ChunkPath(docptr,-1),
                                     docptr->fragid, text);
         if (error) goto exit_now;
      }

      if (tocptr->hlength)
      {
         error = wasDocHtmlPrint (tocptr, "</table>\n");
         if (error) goto exit_now;

         docptr->hparse = hptr - docptr->html;

         wasDocInsertAt (docptr, h1ptr - docptr->html, 0,
                         tocptr->html, tocptr->hlength); 

         /* just inserted so ... */
         hptr = docptr->html + docptr->hparse;

         /* reset the HTML storage ready for the next <h1> */
         tocptr->html[0] = '\0';
         tocptr->hlength = 0;
      }
   }

   goto exit_now;

EILSEQ_error:

   docptr->hparse = hptr - docptr->html;
   error = EILSEQ;
   SET_FI_LI (docptr)
   goto exit_now;

exit_now:

   if (error) retval = error;

   if (tocptr)
   {
      if (tocptr->html) free (tocptr->html);
      free (tocptr);
   }

   return (retval);
}

/*****************************************************************************/
/*
Generate and insert references across the entire document.
The references each will be contained in <!-- --+fragment-- --> if the
reference description should be substituted, or <!-- --*fragment-- --> if the
text following is the description.  See renderInsertUrl().
*/

int navig8ReferAll (struct wasdoc_st *docptr)

{
   int  at, error;
   char  *hptr;

   if (dbug>0) dbugThis (FI_LI, "navig8ReferAll()");

   if (!(hptr = docptr->html)) RETURN_FI_LI (docptr, EILSEQ)

   for (; *hptr; hptr++)
   {
      if (*hptr != '<') continue;
      if (MATCH4 (hptr, "<!--")) hptr = navig8Source (docptr, hptr);
      if (!MATCH7 (hptr, "<!-- --")) continue;

      at = docptr->hparse = hptr - docptr->html;

      if (error = navig8ReferAt (docptr, at)) return (error);

      /* the buffer can move in memory if realloc()s occur */
      hptr = docptr->html + at + 1;
   }

   return (0);
}

/*****************************************************************************/
/*
The reference will be contained in a <!-- --fragment-- --> which itself is
inside the quotes of an <a href="">.  If the fragment ID is prefixed by an
asterisk then leave the current link description as-is, if a plus symbol then
replace with the next heading description or following text.  See
renderInsertLink().

|9some helpful reference| may be located in the middle of some text and so not
have an associated (nearby) heading.  For these cases keep track of the most
recent heading before the link.  Then extract a representative leading portion
of the text and quote that along with the section heading it occurs in.
*/

int navig8ReferAt
(
struct wasdoc_st *docptr,
int at
)
{
   int  alen, error, excise, hit = 0, idlen, inplace;
   char  *aptr, *cptr, *soaptr, *hptr, *sptr, *zptr;
   char  heading [256],
         id1 [64],
         id2 [64],
         refer [512],
         text [128];

   if (!(hptr = docptr->html)) RETURN_FI_LI (docptr, EILSEQ)

   hptr += at;

   if (dbug>0) dbugThis (FI_LI, "navig8referAt() {%s}", dbugMax(hptr));

   /* should now point to this */
   if (!MATCH7 (soaptr = hptr, "<!-- --"))
      RETURN_FI_LI (docptr, EILSEQ)

   hptr += 7;
   if (*hptr == '*')
      inplace = 1;
   else
   if (*hptr == '+')
      inplace = 0;
   else
      RETURN_FI_LI (docptr, EILSEQ)

   hptr++;
   zptr = (sptr = id1) + sizeof(id1)-1;
   while (*hptr && (*hptr != '-' || !MATCH8(hptr,"-- -->\">")))
   {
      if (sptr < zptr) *sptr++ = *hptr;
      hptr++;
   }
   *sptr = '\0';
   if (!MATCH8 (hptr,"-- -->\">")) RETURN_FI_LI (docptr, EILSEQ)
   hptr += 8;

   if (inplace)
   {
      /* excising only the href= */
      excise = hptr - soaptr;
   }
   else
   {
      /* excising all the href= up to end of link description */
      for (; *hptr; hptr++)
      {
         if (*hptr != '<') hptr++;
         if (MATCH4 (hptr, "</a>")) break;
      }
      if (!*hptr) RETURN_FI_LI (docptr, EILSEQ)
      excise = hptr - soaptr;
   }

   /**********/
   /* search */
   /**********/

   /* search for the reference */
   for (hptr = docptr->html; *hptr; hptr++)
   {
      if (*hptr != '<') continue;
      if (!MATCH7 (hptr, "<a id=\"")) continue;

      hptr += 7;
      zptr = (sptr = id2) + sizeof(id2)-1;
      while (*hptr && *hptr != '\"')
      {
         if (sptr < zptr) *sptr++ = *hptr;
         hptr++;
      }
      *sptr = '\0';

      if (hit = (strcmp (id1, id2) == 0)) break;
   }
   /* if the reference was not found */
   if (!hit) RETURN_FI_LI (docptr, EINVAL)

   /*********/
   /* found */
   /*********/

   if (inplace)
   {
      /* look for a preceding numbered heading */
      aptr = navig8ReferBackward (docptr, hptr);
      if (!aptr)
      {
         /* nothing preceding so look for anything following */
         aptr = navig8ReferForward (docptr, hptr, 1);
         /* can't find forward or backward heading so just ignore */
         if (!aptr) return (0);
      }
      hptr = aptr;

      /* get the fragment ID from the preceding heading flags */
      hptr = navig8GetHeadingId (hptr, docptr->fragid);
      if (!hptr) RETURN_FI_LI (docptr, EILSEQ)

      /* use the already in-place description */
      alen = sprintf (refer, "%s#%s\">",
                      navig8ChunkPath(docptr,-1), id1);
   }
   else
   {
      /* generate reference description */
      error = navig8ReferText (docptr, hptr, text, sizeof(text));
      if (error) return (error);
      alen = sprintf (refer, "%s#%s\">%s",
                      navig8ChunkPath(docptr,-1), id1, text+1);
   }

   error = wasDocInsertAt (docptr, at, excise, refer, alen); 
   if (error) RETURN_FI_LI (docptr, error)

   return (0);
}

/*****************************************************************************/
/*
Generate a document index (of sorts) based on all fragment IDs.
These are collated alaphetically but then listed as occur in the text.
*/

int navig8Index (struct wasdoc_st *docptr)

{
   int  at, error = 0, len, maxch = 0, retval = 0;
   char  ch, ch2;
   char  *cptr, *hptr, *sptr, *zptr;
   char  buf [64],
         fragid [FRAGID_SIZE],
         prevtext [256],
         text [256];
   struct  wasdoc_st  *tocptr[256];

   if (dbug>0) dbugThis (FI_LI, "navig8Index()");

   if (!docptr->html) RETURN_FI_LI (docptr, EILSEQ)

   /* find where the INDEX should be inserted */
   for (hptr = docptr->html; *hptr; hptr++)
   {
      if (*hptr != '<') continue;
      if (!MATCH4 (hptr, "<!--")) continue;
      if (MATCH0 (hptr, "<!-- $IDX$ -->", 14)) break;
   }
   if (!*hptr) return (0);
   at = hptr - docptr->html;

   /* initialise the array of pointers */
   memset (tocptr, 0, sizeof(tocptr));

   hptr = docptr->html;
   while (*hptr)
   {
      /* search for next fragment ID */
      for (; *hptr; hptr++)
      {
         if (*hptr != '<') continue;
         if (MATCH2 (hptr, "</")) continue;

         /* error reporting purposes keep track of which source it's from */
         if (MATCH4 (hptr, "<!--")) hptr = navig8Source (docptr, hptr);

         /* section ID looks like: <a id="athis"> */
         if (MATCH7 (hptr, "<a id=\"")) break;
      }
      if (!*hptr) break;

      /* buffer the fragment ID */
      hptr = navig8IdFrag (hptr, fragid, sizeof(fragid));
      if (!hptr) { SET_FI_LI(docptr); goto EILSEQ_error; }

      /* ignore top-of-document fragment */
      if (fragid[0] == '0' && MATCH11 (fragid, "0.0.0.0.0.0")) continue;

      /* if a numeric fragment copy to the document fragment buffer */
      for (cptr = fragid; isdigit(*cptr) || *cptr == '.'; cptr++);
      if (!*cptr) strcpy (docptr->fragid, fragid);

      /*************/
      /* the entry */
      /*************/

      /* generate reference description */
      error = navig8ReferText (docptr, hptr, text, sizeof(text));
      if (error) goto exit_now;

      /* which alphabetic group */
      if (isalpha (text[0]))
         ch = toupper (text[0]);
      else
         ch = '+';

      /* try and avoid obviously duplicate entries */
      if (!strcmp (text, prevtext)) continue;

      ch2 = ' ';
      if (!tocptr[ch])
      {
         /* allocate a structure for this character */
         tocptr[ch2 = ch] = calloc (1, sizeof(struct wasdoc_st)); 
         if (!tocptr[ch]) exit (vaxc$errno);
         if (ch > maxch) maxch = ch;
      }
      error = wasDocHtmlPrint (tocptr[ch],
"<tr><td class=\"IDXalpha\">%c\
<td class=\"IDXtext\"><a href=\"%s#%s\">%s</a>\n",
                               ch2, navig8ChunkPath(docptr,-1), fragid, text+1);
      if (error) { SET_FI_LI(docptr); goto exit_now; }

      zptr = (sptr = prevtext) + sizeof(prevtext)-1;
      for (cptr = text; *cptr && sptr < zptr; *sptr++ = *cptr++);
      *sptr = '\0';
   }

   /****************/
   /* insert index */
   /****************/

   len = sprintf (buf,
"<div class=\"IDXcols%d\">\n\
<table class=\"IDXtable\">\n",
                  docptr->setIdxCols);

   wasDocInsertAt (docptr, at, 14,  /* <!-- $IDX$ --> */ buf, len);
   at += len;
   for (ch = 'A'; ch <= maxch; ch++)
   {
      if (!tocptr[ch]) continue;
      wasDocInsertAt (docptr, at, 0, tocptr[ch]->html, tocptr[ch]->hlength); 
      at += tocptr[ch]->hlength;
      if (ch == 'Z') ch = 0x7f;
   }
   if (tocptr[ch = '+'])
   {
      wasDocInsertAt (docptr, at, 0, tocptr[ch]->html, tocptr[ch]->hlength); 
      at += tocptr[ch]->hlength;
   }
   wasDocInsertAt (docptr, at, 0, "</table>\n</div>\n", 16); 

   goto exit_now;

EILSEQ_error:

   docptr->hparse = hptr - docptr->html;
   error = EILSEQ;
   goto exit_now;

exit_now:

   if (error) retval = error;

   for (ch = '+'; ch <= maxch; ch++)
   {
      if (!tocptr[ch]) continue;
      if (tocptr[ch]->html) free (tocptr[ch]->html);
      free (tocptr[ch]);
      if (ch == '+') ch = 'A';
   }

   return (retval);
}

/*****************************************************************************/
/*
Generate text for use as the description for an internal reference.
Scan forward from the current reference looking for a visible heading or some
other tag to indicate there is no next heading before intervening text.

If a heading then check if it has a section number (1.2.3.4).  If it does then
that is suitable.  If not then it needs to placed into context (i.e. associated
with a section-numbered heading).

If some other tag (i.e. text) then extract that text and return that. 
*/

int navig8ReferText
(
struct wasdoc_st *docptr,
char *hptr,
char *buf,
int size
)
{
   char  ch;
   char  *aptr, *cptr, *sptr, *zptr;
   char  heading [256],
         text [128];

   if (dbug>0) dbugThis (FI_LI, "navig8referText() {%s}", dbugMax(hptr));

   /* look for any following heading allowing |9 references */
   hptr = aptr = navig8ReferForward (docptr, hptr, 1);
   if (!hptr) RETURN_FI_LI (docptr, EILSEQ)

   hptr = navig8GetHeadingId (hptr, docptr->fragid);
   if (!hptr) RETURN_FI_LI (docptr, EILSEQ)

   hptr = navig8HeadingText (hptr, text, sizeof(text));
   if (!hptr) RETURN_FI_LI (docptr, EILSEQ)

   /* if a |9...| then use the document narrative following */
   if (MATCH4 (text, "...") || MATCH4 (text+1, "..."))
   {
      /* get collating character following the '9' (i.e. 'A', 'B', ... 'C') */
      ch = text[0];

      /* and retrieve that narative ignoring markup HTML tags */
      aptr = navig8JustText (hptr, text, sizeof(text)/2);
      if (!aptr) RETURN_FI_LI (docptr, EILSEQ)

      zptr = (sptr = buf) + size - 1;
      *sptr++ = ch;
      for (cptr = "&quot;"; *cptr && sptr < zptr; *sptr++ = *cptr++);
      for (cptr = text; *cptr && sptr < zptr; *sptr++ = *cptr++);

      /* put the text into the preceding numbered heading context */
      hptr = navig8ReferBackward (docptr, hptr);
      if (hptr)
      {
         hptr = navig8GetHeadingId (hptr, docptr->fragid);
         if (!hptr) RETURN_FI_LI (docptr, EILSEQ)

         hptr = navig8HeadingText (hptr, heading, sizeof(heading));
         if (!hptr) RETURN_FI_LI (docptr, EILSEQ)

         for (cptr = "&quot; &thinsp;in&thinsp; ";
              *cptr && sptr < zptr;
              *sptr++ = *cptr++);
         for (cptr = heading; *cptr && sptr < zptr; *sptr++ = *cptr++);
      }
      else
         for (cptr = "&quot;"; *cptr && sptr < zptr; *sptr++ = *cptr++);

      *sptr = '\0';
   }
   else
   {
      /* skip over white space and section numbering if heading */
      for (cptr = text; *cptr; cptr++)
         if (!(isdigit(*cptr) || *cptr == '.' || isspace(*cptr))) break;

      /* and retrieve the collating character of that heading */
      ch = *cptr;

      /* if no section number */
      if (navig8Heading0 (docptr->fragid))
      {
         /* look forward then backward for a heading excluding |9s */
         hptr = navig8ReferForward (docptr, aptr, 0);
         if (!hptr) hptr = navig8ReferBackward (docptr, aptr);

         if (hptr)
         {
            /* use this heading for the context */
            hptr = navig8SkipHeadingId (hptr);
            if (!hptr) RETURN_FI_LI (docptr, EILSEQ)

            hptr = navig8HeadingText (hptr, heading, sizeof(heading));
            if (!hptr) RETURN_FI_LI (docptr, EILSEQ)

            zptr = (sptr = buf) + size - 1;
            *sptr++ = ch;
            for (cptr = "&lsquo;"; *cptr && sptr < zptr; *sptr++ = *cptr++);
            for (cptr = text; *cptr && isspace(*cptr); cptr++);
            while (*cptr && sptr < zptr) *sptr++ = *cptr++;
            for (cptr = "&rsquo; &thinsp;in&thinsp; ";
                 *cptr && sptr < zptr;
                 *sptr++ = *cptr++);
            for (cptr = heading; *cptr && sptr < zptr; *sptr++ = *cptr++);
            *sptr = '\0';
         }
         else
         {
            /* no preceding heading so use just the text */
            zptr = (sptr = buf) + size - 1;
            *sptr++ = ch;
            for (cptr = text; *cptr && sptr < zptr; *sptr++ = *cptr++);
            *sptr = '\0';
         }
      }
      else
      {
         /* has section number so has implicit context */
         zptr = (sptr = buf) + size - 1;
         *sptr++ = ch;
         for (cptr = text; *cptr && sptr < zptr; *sptr++ = *cptr++);
         *sptr = '\0';
      }
   }

   if (sptr > zptr)
   {
      sptr = buf;
      for (cptr = "[OVERFLOW]"; *cptr; *sptr++ = *cptr++);
   }

   return (0);
}

/*****************************************************************************/
/*
Look forward for the next visible heading.
If allow9 then allow |9 entires to be used as a target.  Otherwise not.
*/

char* navig8ReferForward
(
struct wasdoc_st *docptr,
char *hptr,
int allow9
)
{
   char  *aptr;
   char  fragid [FRAGID_SIZE];

   /* if called already at heading then just scan over that */
   if (MATCH2 (hptr, "<h") && isdigit(hptr[2]))
      for (hptr += 2; *hptr; hptr++)
         if (MATCH3 (hptr, "</h") && isdigit(hptr[3])) break;

   for (; *hptr; hptr++)
   {
      for (; *hptr; hptr++)
      {
         if (*hptr != '<') continue;
         if (MATCH2 (hptr, "</")) continue;
         if (MATCH6 (hptr, "<a id=")) continue;
         break;
      }
      if (MATCH2 (hptr, "<h") && isdigit(hptr[2]))
      {
         if (allow9) return (hptr);
         aptr = navig8GetHeadingId (hptr, fragid);
         if (!aptr) return (NULL);
         if (!navig8Heading9 (fragid)) return (hptr);
         continue;
      }
      break;
   }

   return (NULL);
}

/*****************************************************************************/
/*
Look backard for the previous usable heading.
When looking backwards just want the first usable heading encountered.
Return a pointer to the heading or NULL.
*/

char* navig8ReferBackward
(
struct wasdoc_st *docptr,
char *hptr
)
{
   char  *aptr;
   char  fragid [FRAGID_SIZE];

   /* if called already at heading then just shuffle back a little */
   if (MATCH2 (hptr, "<h") && isdigit(hptr[2])) hptr--;

   while (hptr > docptr->html)
   {
      if (MATCH2 (hptr, "<h") && isdigit(hptr[2]))
      {
         aptr = navig8GetHeadingId (hptr, fragid);
         if (!aptr) return (NULL);
         if (!navig8Heading0 (fragid)) return (hptr);
      }
      hptr--;
   }

   return (NULL);
}

/*****************************************************************************/
/*
Fill the buffer with text filtering out HTML tags while trimming and
compressing white-space.
*/

char* navig8JustText
(
char *cptr,
char *buf,
int size
)
{
   char  *sptr, *zptr;

   if (size <= 4) return (NULL);
   while (isspace(*cptr)) cptr++;

   for (zptr = (sptr = buf) + size - 4; *cptr && sptr < zptr; cptr++)
   {
      if (*cptr == '<')
         while (*cptr && *cptr != '>') cptr++;
      else
      if (*cptr != ' ' && *cptr != '\t' && *cptr != '\n')
         *sptr++ = *cptr;
      else
      if (sptr > buf && *(sptr-1) != ' ')
         *sptr++ = ' ';
   }
   while (sptr > buf && isspace(*(sptr-1))) sptr--;
   *sptr = '\0';

   /* trim potentially hanging partial words and sentences */
   for (sptr = buf; *sptr; sptr++);
   while (sptr > buf && !isspace(*(sptr-1))) sptr--;
   while (sptr > buf && isspace(*(sptr-1))) sptr--;
   if (sptr == buf) return (NULL);
   *sptr = '\0';

   while (sptr > buf && !(*sptr == '.' && isspace(*(sptr+1)))) sptr--;
   if (sptr > buf)
      *(sptr+1) = '\0';
   else
   {
      /* indicate there is more to the sentence */
      while (*sptr) sptr++;
      for (cptr = "..."; *cptr; *sptr++ = *cptr++);
      *sptr = '\0';
   }

   return (cptr);
}

/*****************************************************************************/
/*
Locate where each section begin.  Before that location insert either a page
break (horizontal rule) or if chunked, optional navigation arrows.  At the new
section insert optional navigation arrows.
*/

int navig8Paginate (struct wasdoc_st *docptr)

{
   int  at, error, plusat, number, size;
   char  *cptr, *hptr;
   char  buf [1024],
         fragid [FRAGID_SIZE],
         text [256];

   if (dbug>0) dbugThis (FI_LI, "navig8Paginate()\n");

   if (!(docptr->setNavigate || docptr->setPaginate)) return (0);

   if (!(hptr = docptr->html)) RETURN_FI_LI (docptr, EILSEQ)

   while (*hptr)
   {
      /* look for next fragment ID */
      for (; *hptr; hptr++)
      {
         if (*hptr != '<') continue;
         if (MATCH4 (hptr, "<!--")) hptr = navig8Source (docptr, hptr);
         if (!MATCH2 (hptr, "<a")) continue;
         if (!MATCH7 (hptr, "<a id=\"")) continue;
         break;
      }
      if (!*hptr) break;

      /* check there are only fragment IDs until the next <h1> */
      for (at = hptr - docptr->html; *hptr; hptr++)
      {
         if (*hptr != '<') continue;
         if (MATCH4 (hptr, "</a>")) continue;
         if (MATCH7 (hptr, "<a id=\"")) continue;
         /* divs are from a |this| */
         if (MATCH5 (hptr, "<div>")) continue;
         if (MATCH6 (hptr, "</div>")) continue;
         break;
      }
      if (!*hptr) break;

      /* if not a major heading and not a fragment ID */
      if (!MATCH8 (hptr, "<h1 clas")) continue;

      hptr = navig8GetHeadingId (hptr, docptr->fragid);
      if (!hptr) goto EILSEQ_error;

      if (navig8Heading0 (docptr->fragid)) continue;

      if (!(number = atoi(docptr->fragid))) continue;

      if (docptr->setPaginate)
      {
         /* automatic pagination */
         if (docptr->chunked <= 0)
         {
            /* only if document is not chunked */
            cptr = "<hr class=\"page\">\n";
            size = sizeof("<hr class=\"page\">\n")-1;
            error = wasDocInsertAt (docptr, at, 0, cptr, size); 
            if (error) return (error);
         }
      }

      if (docptr->setNavigate)
      {
         /* previous section's end-of-section navigation arrows */
         if (docptr->chunked > 0)
         {
            if (number > 1)
            {
               /* insert the previously generated navigation */
               error = navig8InsertArrows (docptr, at, -1);
               if (error) return (error);
            }
            else
            {
               /* generate (trailing) arrows for the zeroeth chunk */
               error = navig8InsertArrows (docptr, at, 0);
               if (error) return (error);
            }
         }

         /* (re)initialise the arrow buffer */
         navig8InsertArrows (NULL, 0, 0);

         /* search for closing </h1> */
         for (hptr = docptr->html + at; *hptr; hptr++)
         {
            if (*hptr != '<') continue;
            if (!MATCH5 (hptr, "</h1>")) continue;
            break;
         }
         if (!*hptr) goto EILSEQ_error;
         hptr += 5;

         /* insert immediately following the "</h1>" */
         at = hptr - docptr->html;

         error = navig8InsertArrows (docptr, at, number);
         if (error) return (error);
      }
      else
      {
         /* search for closing </h1> */
         for (hptr = docptr->html + at; *hptr; hptr++)
         {
            if (*hptr != '<') continue;
            if (!MATCH5 (hptr, "</h1>")) continue;
            break;
         }
         if (!*hptr) goto EILSEQ_error;
         hptr += 5;
      }
   }

   if (docptr->setPaginate)
   {
      /* automatic pagination */
      if (docptr->chunked <= 0)
      {
         /* only if document is not chunked */
         cptr = "<hr class=\"epage\">\n";
         size = sizeof("<hr class=\"epage\">\n")-1;
         wasDocInsertAt (docptr, hptr - docptr->html, 0, cptr, size); 
         hptr = docptr->html + docptr->hparse;
      }
   }

   if (docptr->setNavigate)
   {
      /* previous section's end-of-section navigation arrows */
      if (docptr->chunked > 0 && number > 1)
      {
         /* insert the previously generated navigation */
         error = navig8InsertArrows (docptr, docptr->hlength, -1);
         if (error) return (error);
         hptr = docptr->html + docptr->hparse;
      }
   }

   return (0);

EILSEQ_error:

   docptr->hparse = hptr - docptr->html;
   RETURN_FI_LI (docptr, EILSEQ)
}

/*****************************************************************************/
/*
<back> <previous> <top> <next> <forward>
The same section arrows can be reused for top and bottom navigation.
To reset the static buffer call with |docptr| NULL.
If |at| is negative then navigation goes to <stdout>.
*/

int navig8InsertArrows
(
struct wasdoc_st *docptr,
int at,
int number
)
{
   static int  len;
   static char  buf [640];
   char  *hptr, *sptr;

   if (dbug>0) dbugThis (FI_LI, "navig8InsertArrows(%d,%d)", at, number);

   if (!docptr)
   {
      /* reset previously generated navigation arrows */
      buf[len = 0] = '\0';
      return (0);
   }

   if (!docptr->setNavigate) return (0);

   if (!(hptr = docptr->html)) RETURN_FI_LI (docptr, EILSEQ)

   if (number < 0)
   {
      /* insert the previously generated navigation arrows */
      if (!buf[0]) goto EILSEQ_error;
      if (at >= 0)
         wasDocInsertAt (docptr, at, 0, buf, len); 
      else
         wasDocWrite (docptr, buf, len);
      return (0);
   }

   sptr += sprintf (sptr = buf,
"\n<table class=\"navTOCtable%s\"><tr>\n\
<td><a href=\"javascript:window.history.back();\">%s</a>\n",
                    docptr->setNavigate > 1 ? " navTOCprint" : "",
                    docptr->iconBack);
   if (number > 0)
   {
      sptr += sprintf (sptr,
"<td><a href=\"%s%s\">%s</a>\n",
                       navig8ChunkPath(docptr,number-1),
                       navig8ChunkFrag(docptr,number-1),
                       docptr->iconPrev);

      sptr += sprintf (sptr, "<td><a href=\"%s#0.0.0.0.0.0\">%s</a>\n",
                       navig8ChunkPath(docptr,0),
                       docptr->iconTop);
   }
   else
      sptr += sprintf (sptr, "<td><a>%s</a>\n<td><a>%s</a>\n",
                       docptr->iconPrev, docptr->iconTop);



   if (number < docptr->finalH1)
      sptr += sprintf (sptr,
"<td><a href=\"%s%s\">%s</a>\n",
                       navig8ChunkPath(docptr,number+1),
                       navig8ChunkFrag(docptr,number+1),
                       docptr->iconNext);
   else
      sptr += sprintf (sptr, "<td><a>%s</a>\n", docptr->iconNext);

   sptr += sprintf (sptr,
"<td><a href=\"javascript:window.history.forward();\">%s</a>\n\
</table>\n",
                    docptr->iconForw);

   if (sptr > buf + sizeof(buf)-1) exit (SS$_BUGCHECK);

   if (at >= 0)
      wasDocInsertAt (docptr, at, 0, buf, len = sptr - buf); 
   else
      wasDocWrite (docptr, buf, len = sptr - buf);

   return (0);

EILSEQ_error:

   docptr->hparse = hptr - docptr->html;
   RETURN_FI_LI (docptr, EILSEQ)
}

/*****************************************************************************/
/*
Parse to find the specified MAJOR section identified by the fragment ID leading
digit.  It automatically includes the document prologue (e.g. style).
*/

int navig8ChunkOut (struct wasdoc_st *docptr)

{
   int  error, fragnum, len;
   char  *cptr, *hptr, *sptr;
   char  buf [1024],
         title [256] = "";

   if (dbug>0) dbugThis (FI_LI, "navig8ChunkOut() %d", docptr->pchunk);

   if (!(hptr = docptr->html)) RETURN_FI_LI (docptr, EILSEQ)

   /* look for end of prologue (final </style> before <h1>) of document */
   sptr = NULL;
   for (hptr = docptr->html; *hptr; hptr++)
   {
      if (*hptr != '<') continue;
      if (!MATCH8 (hptr, "</style>") &&
          (!MATCH2 (hptr, "<h") || !isdigit(hptr[2]))) continue;
      /* note the end of this style closure */
      if (MATCH8 (hptr, "</style>")) sptr = (hptr += 8);
      /* the first heading encountered terminates the prologue search */
      if (MATCH2 (hptr, "<h") && isdigit(hptr[2])) break;
   }
   if (*hptr)
      if (!(hptr = sptr))
         goto EILSEQ_error;
   while (*hptr == '\n') hptr++;

   /* note the length of the prologue */
   docptr->proLength = hptr - docptr->html;

   if (dbug>0) dbugThis (FI_LI, "->pchunk: %d", docptr->pchunk);

   /* find the requested fragment ID */
   for (hptr = docptr->html; *hptr; hptr++)
   {
      if (*hptr != '<') continue;
      /* section ID looks like: <a id="n.n.n.n.n.n"> */
      if (!MATCH7 (hptr, "<a id=\"")) continue;
      if ((fragnum = atoi(hptr+7)) >= docptr->pchunk) break;
   }

   /* always should find the specified section */
   if (!*hptr) goto EFAIL_error;
   /* a negative chunk number always returns chunk zero */
   if (docptr->pchunk >= 0)
      if (fragnum > docptr->pchunk)
         goto EILSEQ_error; 

   /* note the start of the in-document chunk */
   docptr->chunk = hptr;

   /* now look for the next page (or end of document) */
   for (hptr += 20; *hptr; hptr++)
   {
      if (*hptr != '<') continue;
      if (MATCH7 (hptr, "<a id=\""))
      {
         /* section ID looks like: <a id="n.n.n.n.n.n"> */
         if (atoi(hptr+7) > fragnum) break;
      }
      /* first heading encountered is used as page title */
      if (!title[0])
      {
         if (MATCH2 (hptr, "<h") && isdigit(hptr[2]))
         {
            /* just step over the commented flags */
            hptr = navig8SkipHeadingId (hptr);
            if (!hptr) goto EILSEQ_error;
            hptr = navig8HeadingText (hptr, title, sizeof(title));
            if (!hptr) goto EILSEQ_error;
         }
      }
   }

   /* note the length of this chunk */
   docptr->clength = hptr - docptr->chunk;

   /* first write the prologue */
   wasDocWrite (docptr, docptr->html, docptr->proLength);

   /* the page title */
   if (docptr->title[0] && strcmp (docptr->title, title))
      len = sprintf (buf, "<title>%s &ndash; %s</title>\n",
                     docptr->title, title);
   else
      len = sprintf (buf, "<title>%s</title>\n", title);
   wasDocWrite (docptr, buf, len);

   if (docptr->pchunk > 0)
   {
      /* then the main heading for all but the first section */
      len = sprintf (buf, "%s\n", docptr->mainh);
      wasDocWrite (docptr, buf, len);
   }

   wasDocWrite (docptr, docptr->chunk, docptr->clength);

   return (0);

EFAIL_error:

   docptr->hparse = hptr - docptr->html;
   RETURN_FI_LI (docptr, EFAIL)

EILSEQ_error:

   docptr->hparse = hptr - docptr->html;
   RETURN_FI_LI (docptr, EILSEQ)
}

/*****************************************************************************/
/*
Chunked wasDOC is where the client is provided with only one major section
(<h1>) at a time.  This is a three digit pseudo-section appended to the path,
leading zeroes as required.  This function creates a unique path that includes
a "chunk" number based on the leading fragment ID integer so that the browser
requests using that path keeping all the (global) fragment IDs viable.

This function is NOT REENTRANT and must be used at most ONCE per print.
*/

char* navig8ChunkPath
(
struct wasdoc_st *docptr,
int number
)
{
   static char  path [256];
   int  cnt = 0;
   char  *cptr, *sptr, *zptr;

   if (docptr->chunked <= 0) return ("");

   zptr = (sptr = path) + sizeof(path)-16;
   if (docptr->oname[0])
   {
      /* output to file(s) */
      for (cptr = docptr->oname; *cptr && sptr < zptr; *sptr++ = *cptr++);
      if (number < 0)
         sptr += sprintf (sptr, "%03.3d.html", atoi(docptr->fragid));
      else
         sptr += sprintf (sptr, "%03.3d.html", number);
   }
   else
   {
      /* output via script */
      for (cptr = docptr->uri; *cptr && sptr < zptr; *sptr++ = *cptr++);
      if (*(cptr-1) != '/' && sptr < zptr) *sptr++ = '/';
      if (number < 0)
         sptr += sprintf (sptr, "%03.3d", atoi(docptr->fragid));
      else
         sptr += sprintf (sptr, "%03.3d", number);
      if (sptr < zptr) *sptr++ = '/';
   }
   *sptr = '\0';

   return (path);
}

/*****************************************************************************/
/*
If NOT chunked then provide a URL fragment for the major heading of a link
target, otherwise none.

This function is NOT REENTRANT and must be used at most ONCE per print.
*/

char* navig8ChunkFrag
(
struct wasdoc_st *docptr,
int number
)
{
   static char  fragment [32];

   if (docptr->chunked > 0)
      fragment[0] = '\0';
   else
      sprintf (fragment, "#%d.0.0.0.0.0", number);

   return (fragment);
}

/*****************************************************************************/
/*
Parse and buffer the anchor fragment ID.
*/

char* navig8IdFrag
(
char *hptr,
char *buf,
int size
)
{
   char  *cptr, *sptr, *zptr;

   if (!hptr) return (hptr);

   if (!MATCH7 (hptr, "<a id=\"")) return (NULL);

   zptr = (sptr = buf) + size - 1;
   *sptr = '\0';
   if (sptr >= zptr) return (NULL);

   for (hptr += 7; *hptr && *hptr != '\"' && sptr < zptr; *sptr++ = *hptr++);
   *sptr = '\0';
   if (sptr >= zptr) return (NULL);

   while (*hptr && *hptr != '>') hptr++;
   if (*hptr) hptr++;

   return (hptr);
}

/*****************************************************************************/
/*
Parse out and buffer the heading ID string.  Return a pointer to the next
character following that text, or NULL to indicate the document HTML was not
understood.
*/

char* navig8GetHeadingId
(
char *hptr,
char *buf
)
{
   char  *cptr, *sptr, *zptr;
   char  buf2 [FRAGID_SIZE];

   if (dbug>0) dbugThis (FI_LI, "navig8GetHeadingId() {%s}", dbugMax(hptr));

   if (!hptr) return (hptr);
                    
   if (!MATCH2 (hptr, "<h") || !isdigit(hptr[2])) return (NULL);

   if (buf)
      zptr = (sptr = buf) + FRAGID_SIZE - 1;
   else
      zptr = (sptr = buf2) + sizeof(buf2)-1;
   *sptr = '\0';
   if (sptr >= zptr) return (NULL);

   for (hptr += 3; *hptr && *hptr != '>'; hptr++);
   if (!MATCH6 (hptr, "><!-- ")) return (NULL);
   for (hptr += 6; *hptr && sptr < zptr;)
   {
      if (MATCH4 (hptr, " -->")) break;
      *sptr++ = *hptr++;
   }
   *sptr = '\0';
   if (sptr >= zptr) return (NULL);

   return (hptr + 4);
}

/*****************************************************************************/
/*
Skip over the heading ID string.
*/

char* navig8SkipHeadingId (char *hptr)

{
   if (dbug>0) dbugThis (FI_LI, "navig8SkipHeadingId() {%s}", dbugMax(hptr));

   if (!hptr) return (NULL);
                    
   if (!MATCH2 (hptr, "<h") || !isdigit(hptr[2])) return (NULL);

   for (hptr += 3; *hptr && *hptr != '>'; hptr++);
   if (!MATCH6 (hptr, "><!-- ")) return (NULL);
   for (hptr += 6; *hptr; hptr++)
      if (MATCH4 (hptr, " -->")) return (hptr + 4);

   return (NULL);
}

/*****************************************************************************/
/*
Return true if the ID indicates |0 or |9.
*/

int navig8Heading0 (char *idptr)

{
   if (dbug>0) dbugThis (FI_LI, "navig8Heading0() {%s}", dbugMax(idptr));

   for (int cnt = 4; cnt; cnt--)
   {
      while (isdigit(*idptr)) idptr++;
      if (*idptr++ != '.') return (0);
   }
   while (*idptr == '0' || *idptr == '.') idptr++;
   return (isdigit(*idptr));
}

/*****************************************************************************/
/*
Return true if the ID is a cross-reference (i.e. |9).
*/

int navig8Heading9 (char *idptr)

{
   if (dbug>0) dbugThis (FI_LI, "navig8Heading9() {%s}", dbugMax(idptr));

   for (int cnt = 5; cnt; cnt--)
   {
      while (isdigit(*idptr)) idptr++;
      if (*idptr++ != '.') return (0);
   }
   return (*idptr != '0');
}

/*****************************************************************************/
/*
Parse out and buffer the heading text.  Return a pointer to the next character
following that text, or NULL to indicate the document HTML was not understood.
Must be called pointing to the character immediately following the commented
fragment string that follows the heading "<h.>"..
*/

char* navig8HeadingText
(
char *hptr,
char *buf,
int size
)
{
   char  *cptr, *sptr, *zptr;

   if (dbug>0) dbugThis (FI_LI, "navig8HeadingText()");

   zptr = (sptr = buf) + size - 1;
   if (sptr >= zptr) return (NULL);
   *sptr = '\0';

   if (!hptr) return (hptr);

   if (memcmp (hptr, "<span class=\"tocnum\">", 21)) return (NULL);

   for (hptr += 21; *hptr && *hptr != '<' && sptr < zptr; *sptr++ = *hptr++);
   *sptr = '\0';
   if (sptr >= zptr) return (NULL);
   if (!MATCH7 (hptr, "</span>")) return (NULL);
   hptr += 7;

   if (memcmp (hptr, "<span class=\"toctxt\">", 21)) return (NULL);
   hptr += 21;

   if (sptr > buf) *sptr++ = ' ';
   while (*hptr && sptr < zptr)
   {
      if (*hptr == '<')
      {
         /* don't be fooled by any internal highlight spans */
         if (MATCH10 (hptr, "</span></h") && isdigit(*(hptr+10))) break;
         for (hptr++; *hptr; hptr++)
         {
            if (*hptr != '>') continue;
            hptr++;
            break;
         }
         continue;
      }
      *sptr++ = *hptr++;
   }
   *sptr = '\0';

   if (sptr >= zptr)
   {
      sptr = buf;
      for (cptr = "[OVERFLOW]"; *cptr && sptr < zptr; *sptr++ = *cptr++);
   }

   /* in case it overflowed just ensure were'e at the end of the heading */
   for (; *hptr; hptr++)
   {
      if (*hptr != '<') continue;
      if (MATCH10 (hptr, "</span></h") && isdigit(*(hptr+10))) break;
   }
   if (!*hptr) return (NULL);
 
   if (dbug>0) dbugThis (FI_LI, "%d {%s}", strlen(buf), buf);

   return (hptr + 7);
}

/*****************************************************************************/
/*
Grab the full heading.
*/

char* navig8HeadingMain
(
char *hptr,
char *buf,
int size
)
{
   char  *cptr, *sptr, *zptr;

   if (dbug>0) dbugThis (FI_LI, "navig8HeadingMain() {%s}", dbugMax(hptr));

   zptr = (sptr = buf) + size - 1;
   if (sptr >= zptr) return (NULL);
   *sptr = '\0';

   if (!hptr) return (hptr);

   if (!MATCH2 (hptr, "<h") || !isdigit(hptr[2])) return (NULL);

   while (*hptr && sptr < zptr)
   {
      if (*hptr == '<' && MATCH3 (hptr, "</h") && isdigit(hptr[3])) break;
      *sptr++ = *hptr++;
   }
   while (*hptr && *hptr != '>' && sptr < zptr) *sptr++ = *hptr++;
   if (*hptr && sptr < zptr) *sptr++ = *hptr++;
   *sptr = '\0';

   if (sptr >= zptr)
   {
      sptr = buf;
      for (cptr = "[OVERFLOW]"; *cptr && sptr < zptr; *sptr++ = *cptr++);
   }

   for (; *hptr; hptr++)
      if (*hptr == '<' && MATCH3 (hptr, "</h") && isdigit(hptr[3])) break;
   if (!*hptr) return (NULL);

   if (dbug>0) dbugThis (FI_LI, "%d {%s}", strlen(buf), buf);

   return (hptr + 5);
}

/*****************************************************************************/
/*
When parsing the HTML retrieve the source file name from an appropriate
comment.  Used for error reporting and what-have-you.  Return a pointer to the
next character after the comment.
*/

char* navig8Source
(
struct wasdoc_st *docptr,
char *hptr
)
{
   char  *cptr, *sptr, *zptr;

   if (!MATCH4 (cptr = hptr, "<!--")) return (hptr);
   for (cptr += 4; *cptr && isspace(*cptr); cptr++);
   if (!*cptr) return (hptr);
   if (!MATCH7 (cptr, "source:")) return (hptr);
   zptr = (sptr = docptr->tfname) + sizeof(docptr->tfname)-1;
   for (cptr += 7; *cptr && !isspace(*cptr) && sptr < zptr; *sptr++ = *cptr++);
   *sptr = '\0';
   while (*cptr && !MATCH4 (cptr, " -->")) cptr++;
   if (*cptr) cptr += 4;
   return (cptr);
}

/*****************************************************************************/