/*

** This program was written by Richard Verhoeven (NL:5482ZX35)

** at the Eindhoven University of Technology. Email: rcb5@win.tue.nl

**

** Permission is granted to distribute, modify and use this program

** as long as this comment is not removed or changed.

*/

/* BSD mandoc stuff added by Michael Hamilton. */

/* This program is rather buggy, but in spite of that it often works.

   Improved things a little - April 1997 & January 1998 & Dec 2001 -

   aeb@cwi.nl. */

/* some code added by Tsukasa Hamnao. */

#include 

#include 

#include 

#include 

#include 

#ifdef _KOLIBRI

#include 

#include 

#else

#include 

#include 

#endif

#include "defs.h"

static char version[] = "1.6f-1";

/* BSD mandoc Bd/Ed example(?) blocks */

#define BD_LITERAL  1

#define BD_INDENT   2

#define SIZE(a)    (sizeof(a)/sizeof(*a))

static char NEWLINE[2]="\n";

static char idxlabel[6] = "ixAAA";

#ifdef _KOLIBRI

    #define INDEXFILE "/tmp0/1/manindex.list"

#else

    #define INDEXFILE "./manindex.list"

#endif

char *fname;

//char *directory;

FILE *idxfile;

char eqndelimopen=0, eqndelimclose=0;

char escapesym='\\', nobreaksym='\'', controlsym='.', fieldsym=0, padsym=0;

char *buffer=NULL;

int buffpos=0, buffmax=0;

int scaninbuff=0;

int still_dd=0;

int tabstops[20] = { 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96 };

int maxtstop=12;

int curpos=0;

static char *scan_troff(char *c, int san, char **result);

static char *scan_troff_mandoc(char *c, int san, char **result);

static char **argument=NULL;

static char charb[3];

FILE *out;

static char *

expand_char(int nr)

{

    STRDEF *h;

    if (!nr)

        return NULL;

    h = chardef;

    if (h->nr != V('*','*')) {

        fprintf(out, "chardef corrupted\n");

        exit(1);

    }

    for (h = chardef; h; h = h->next)

        if (h->nr == nr) {

            curpos += h->slen;

            return h->st;

        }

    charb[0] = nr/256;

    charb[1] = nr%256;

    charb[2] = 0;

    curpos += 2;

    return charb;

}

static char *

expand_string(int nr)

{

    STRDEF *h;

    if (!nr)

        return NULL;

    for (h = strdef; h; h = h->next)

        if (h->nr == nr) {

            curpos += h->slen;

            return h->st;

        }

    return NULL;

}

static char outbuffer[1024];

static int obp=0;

static int no_newline_output=0;        /* boolean, set by \c */

static int newline_for_fun=0;

static int output_possible=0;

static int out_length=0;

static void

add_links(char *c)

{

    /*

    ** Add the links to the output.

    ** At the moment the following are recognized:

    **

    ** name(*)                 -> ../man?/name.*

    ** method://string         -> method://string

    ** www.host.name           -> http://www.host.name

    ** ftp.host.name           -> ftp://ftp.host.name

    ** name@host               -> mailto:name@host

    **                 -> file:/usr/include/name.h   (guess)

    **

    ** Other possible links to add in the future:

    **

    ** /dir/dir/file  -> file:/dir/dir/file

    */

    int i,j,nr;

    char *f, *g, *h;

    char *idtest[6]; /* url, mailto, www, ftp, manpage, include file */

    out_length+=strlen(c);

    nr=0;

    idtest[0]=strstr(c+1,"://");

    /* idtest[1]=strchr(c+1,'@'); */

    idtest[1]=NULL; /* don't create mailto links. */

    idtest[2]=strstr(c,"www.");

    idtest[3]=strstr(c,"ftp.");

    idtest[4]=strchr(c+1,'(');

    idtest[5]=strstr(c+1,".h>");

    for (i=0; i<6; i++) nr += (idtest[i]!=NULL);

    while (nr) {

    j=-1;

    for (i=0; i<6; i++)

        if (idtest[i] && (j<0 || idtest[i]

    switch (j) {

    case 5: /*  */

        f=idtest[5];

        h=f+2;

        g=f;

        while (g>c && g[-1]!=';') g--;

        if (g!=c) {

        char t;

        t=*g;

        *g=0;

        fprintf(out, "%s",c);

        *g=t;*h=0;

        include_file_html(g);

        c=f+6;

        } else {

        f[5]=0;

        fprintf(out, "%s",c);

        f[5]=';';

        c=f+5;

        }

        break;

    case 4:            /* manpage? */

        f=idtest[j];

        /* find section - accept (1), (3F), (3Xt), (n), (l) */

        g=strchr(f,')');

        if (g && g-f<7    /* section has length at most 5, like 3Xlib */

                        /* preceded by name or html markup */

          && (isalnum(f[-1]) || f[-1]=='>')

                                /* section is n or l or starts with a digit */

          && strchr("123456789nl", f[1])

          && (g-f == 2 || (g-f == 3 && isdigit(f[1]) && isalpha(f[2]))

                       || (f[2] == 'X' && isdigit(f[1])))

           ) {

        /* this might be a link */

        h=f-1;

        /* skip html markup */

        while (h>c && *h=='>') {

            while (h!=c && *h!='<') h--;

            if (h!=c) h--;

        }

        if (isalnum(*h)) {

            char t,te,tg,*e;

            e=h+1;

            while (h>c && (isalnum(h[-1]) || h[-1]=='_' ||

                    h[-1]=='-' || h[-1]=='.' || h[-1]==':'))

            h--;

            t=*h; *h=0;

            fprintf(out, "%s", c);

            *h=t;

            tg=*g; *g=0;

            te=*e; *e=0;

            man_page_html(f+1, h);     /* section, page */

            *e=te;

            *g=tg;

            c=e;

        }

        }

        *f=0;

        fprintf(out, "%s", c);

        *f='(';

        idtest[4]=f-1;

        c=f;

        break; /* manpage */

    case 3: /* ftp */

    case 2: /* www */

        g=f=idtest[j];

        while (*g && (isalnum(*g) || *g=='_' || *g=='-' || *g=='+' ||

              *g=='.')) g++;

        if (g[-1]=='.') g--;

        if (g-f>4) {

        char t;

        t=*f; *f=0;

        fprintf(out, "%s",c);

        *f=t; t=*g;*g=0;

        if (j==3)

             ftp_html(f);

        else

             www_html(f);

        *g=t;

        c=g;

        } else {

        f[3]=0;

        fprintf(out, "%s",c);

        c=f+3;

        f[3]='.';

        }

        break;

    case 1: /* mailto */

        g=f=idtest[1];

        while (g>c && (isalnum(g[-1]) || g[-1]=='_' || g[-1]=='-' ||

               g[-1]=='+' || g[-1]=='.' || g[-1]=='%')) g--;

        h=f+1;

        while (*h && (isalnum(*h) || *h=='_' || *h=='-' || *h=='+' ||

              *h=='.')) h++;

        if (h[-1]=='.') h--;

        if (h-f>4 && f-g>1) {

        char t;

        t=*g;

        *g=0;

        fprintf(out, "%s",c);

        *g=t;t=*h;*h=0;

        mailto_html(g);

        *h=t;

        c=h;

        } else {

        *f=0;

        fprintf(out, "%s",c);

        *f='@';

        idtest[1]=c;

        c=f;

        }

        break;

    case 0: /* url */

        g=f=idtest[0];

        while (g>c && isalpha(g[-1]) && islower(g[-1])) g--;

        h=f+3;

        while (*h && !isspace(*h) && *h!='<' && *h!='>' && *h!='"' &&

           *h!='&') h++;

        if (f-g>2 && f-g<7 && h-f>3) {

        char t;

        t=*g;

        *g=0;

        fprintf(out, "%s", c);

        *g=t; t=*h; *h=0;

        url_html(g);

        *h=t;

        c=h;

        } else {

        f[1]=0;

        fprintf(out, "%s", c);

        f[1]='/';

        c=f+1;

        }

        break;

    default:

        break;

    }

    nr=0;

    if (idtest[0] && idtest[0]

    if (idtest[1] && idtest[1]

    if (idtest[2] && idtest[2]

    if (idtest[3] && idtest[3]

    if (idtest[4] && idtest[4]

    if (idtest[5] && idtest[5]

    for (i=0; i<6; i++) nr += (idtest[i]!=NULL);

    }

    fprintf(out, "%s", c);

}

int current_font=0;

int current_size=0;

int fillout = 1;

/*

 * Kludge: remove \a - in the context

 *   .TH NAME 2 date "Version" "Title"

 * we got output \aTitle\a.

 */

static void

out_html(char *c) {

    if (!c)

        return;

    if (no_newline_output) {    /* remove \n if present */

        int i=0;

        while (c[i]) {

            if (!no_newline_output)

                c[i-1]=c[i];

            if (c[i]=='\n')

                no_newline_output=0;

            i++;

        }

        if (!no_newline_output)

            c[i-1]=0;

    }

    if (scaninbuff) {

        while (*c) {

            if (buffpos >= buffmax) {

                buffer = xrealloc(buffer, buffmax*2);

                buffmax = buffmax*2;

            }

            if (*c != '\a')

                buffer[buffpos++] = *c;

            c++;

        }

    } else if (output_possible) {

        while (*c) {

            if (*c != '\a')

                outbuffer[obp++] = *c;

            if (*c == '\n' || obp > 1000) {

                outbuffer[obp] = 0;

                add_links(outbuffer);

                obp = 0;

            }

            c++;

        }

    }

}

/* --------------------------------------------------------------- */

/* All references to dl_set and itemdepth are here.                */

/* --------------------------------------------------------------- */

static int itemdepth=0;

static int dl_set[30]= { 0 };

#define noDL  0

#define DL    1

#define UL    2

#define OL    3

static char *dl_open[4] = { "", "
\n", "
", "
" };

static char *dl_close[4] = { "", "\n", "", "" };

static inline void

dl_begin(void) {

     if (itemdepth < SIZE(dl_set) && dl_set[itemdepth] == noDL) {

      out_html(dl_open[DL]);

      dl_set[itemdepth]=DL;

     }

     out_html("
");

}

static inline void

dl_end(void) {

     if (itemdepth < SIZE(dl_set)) {

      int type = dl_set[itemdepth];

      if (type == DL) {

           out_html(dl_close[type]);

           dl_set[itemdepth]=noDL;

      }

     }

}

static inline void

dl_newlevel(void) {

     itemdepth++;

     if (itemdepth < SIZE(dl_set))

      dl_set[itemdepth]=noDL;

     out_html("
");

}

static inline void

dl_endlevel(void) {

     if (itemdepth) {

      dl_end();

      out_html("\n");

      itemdepth--;

     }

}

static inline void

dl_down(void) {

     while (itemdepth)

      dl_endlevel();

     dl_end();

}

static inline int

dl_type(int type) {

     return (itemdepth < SIZE(dl_set) && dl_set[itemdepth] == type);

}

static inline void

dl_newlevel_type(int type) {

     itemdepth++;

     if (itemdepth < SIZE(dl_set)) {

      dl_set[itemdepth]=type;

      out_html(dl_open[type]);

     }

}

static inline void

dl_endlevel_type(void) {

     if (itemdepth) {

      if (itemdepth < SIZE(dl_set))

           out_html(dl_close[dl_set[itemdepth]]);

      itemdepth--;

     }

}

/* --------------------------------------------------------------- */

/* This stuff is broken.

It generates

   
TIOCLINUX, subcode=0

   Dump the screen.

   argp points to a

from

   .IP "\fBTIOCLINUX, subcode=0"

   Dump the screen.

   \fIargp\fP points to a

Bug 1: incorrect nesting:  is needed before 
.

Bug 2: incorrect font: after the .IP things are roman again.

*/

#define FO0 ""

#define FC0 ""

#define FO1 ""

#define FC1 ""

#define FO2 ""

#define FC2 ""

#define FO3 ""

#define FC3 ""

char *switchfont[16] = { "", FC0 FO1, FC0 FO2, FC0 FO3,

                         FC1 FO0, "", FC1 FO2, FC1 FO3,

                         FC2 FO0, FC2 FO1, ""     , FC2 FO3,

                         FC3 FO0, FC3 FO1, FC3 FO2, ""};

static char *

change_to_font(int nr)

{

  int i;

  switch (nr) {

  case '0': nr++;

  case '1': case '2': case '3': case '4':

       nr = nr-'1'; break;

  case V('C','W'): nr=3; break;

  case 'L': nr=3; break;

  case 'B': nr=2; break;

  case 'I': nr=1; break;

  case 0: case 1: case 2: case 3:

       break;

  case 'P': case 'R':

  default: nr=0; break;

  }

  i= current_font*4+nr%4;

  current_font=nr%4;

  return switchfont[i];

}

static char sizebuf[200];

static char *

change_to_size(int nr)

{

  int i;

  switch (nr) {

  case '0': case '1': case '2': case '3': case '4': case '5': case '6':

  case '7': case '8': case '9': nr=nr-'0'; break;

  case '\0': break;

  default: nr=current_size+nr; if (nr>9) nr=9; if (nr< -9) nr=-9; break;

  }

  if (nr==current_size) return "";

  i=current_font;

  sizebuf[0]=0;

  strcat(sizebuf, change_to_font(0));

  if (current_size) strcat(sizebuf, "");

  current_size=nr;

  if (nr) {

    int l;

    strcat(sizebuf, "

    l=strlen(sizebuf);

    if (nr>0) sizebuf[l++]='+'; else sizebuf[l++]='-',nr=-nr;

    sizebuf[l++]=nr+'0';

    sizebuf[l++]='"';

    sizebuf[l++]='>';

    sizebuf[l]=0;

  }

  strcat(sizebuf, change_to_font(i));

  return sizebuf;

}

int asint=0;

int intresult=0;

#define SKIPEOL while (*c && *c++!='\n')

static int skip_escape=0;

static int single_escape=0;

static char *

scan_escape(char *c) {

    char *h=NULL;

    char b[5];

    INTDEF *intd;

    int exoutputp,exskipescape;

    int i,j;

    intresult=0;

    switch (*c) {

    case 'e': h="\\"; curpos++;break;

    case '0':

    case ' ': h=" ";curpos++; break;

    case '|': h=""; break;

    case '"': SKIPEOL; c--; h=""; break;

    case '$':

    if (argument) {

        c++;

        i=(*c -'1');

        if (!(h=argument[i])) h="";

    }

    break;

    case 'z':

    c++;

    if (*c=='\\') { c=scan_escape(c+1); c--;h=""; }

    else {

        b[0]=*c;

        b[1]=0;

        h="";

    }

    break;

    case 'k': c++; if (*c=='(') c+=2;

    case '^':

    case '!':

    case '%':

    case 'a':

    case 'd':

    case 'r':

    case 'u':

    case '\n':

    case '&': h=""; break;

    case '(':

    c++;

    i= c[0]*256+c[1];

    c++;

    h = expand_char(i);

    break;

    case '*':

    c++;

    if (*c=='(') {

        c++;

        i= c[0]*256+c[1];

        c++;

    } else

        i= *c *256+' ';

    h = expand_string(i);

    break;

    case 'f':

    c++;

    if (*c=='\\') {

        c++;

        c=scan_escape(c);

        c--;

        i=intresult;

    } else     if (*c != '(')

        i=*c;

    else {

        c++;

        i=c[0]*256+c[1];

        c++;

    }

    if (!skip_escape) h=change_to_font(i); else h="";

    break;

    case 's':

    c++;

    j=0;i=0;

    if (*c=='-') {j= -1; c++;} else if (*c=='+') {j=1; c++;}

    if (*c=='0') c++; else if (*c=='\\') {

        c++;

        c=scan_escape(c);

        i=intresult; if (!j) j=1;

    } else

        while (isdigit(*c) && (!i || (!j && i<4))) i=i*10+(*c++)-'0';

    if (!j) { j=1; if (i) i=i-10; }

    if (!skip_escape) h=change_to_size(i*j); else h="";

    c--;

    break;

    case 'n':

    c++;

    j=0;

    switch (*c) {

    case '+': j=1; c++; break;

    case '-': j=-1; c++; break;

    default: break;

    }

    if (*c=='(') {

        c++;

        i=V(c[0],c[1]);

        c=c+1;

    } else {

        i=V(c[0],' ');

    }

    intd=intdef;

    while (intd && intd->nr!=i) intd=intd->next;

    if (intd) {

        intd->val=intd->val+j*intd->incr;

        intresult=intd->val;

    } else {

        switch (i) {

        case V('.','s'): intresult=current_size; break;

        case V('.','f'): intresult=current_font; break;

        default: intresult=0; break;

        }

    }

    h="";

    break;

    case 'w':

    c++;

    i=*c;

    c++;

    exoutputp=output_possible;

    exskipescape=skip_escape;

    output_possible=0;

    skip_escape=1;

    j=0;

    while (*c!=i) {

        j++;

        if (*c==escapesym) c=scan_escape(c+1); else c++;

    }

    output_possible=exoutputp;

    skip_escape=exskipescape;

    intresult=j;

    break;

    case 'l': h="
"; curpos=0;

    case 'b':

    case 'v':

    case 'x':

    case 'o':

    case 'L':

    case 'h':

    c++;

    i=*c;

    c++;

    exoutputp=output_possible;

    exskipescape=skip_escape;

    output_possible=0;

    skip_escape=1;

    while (*c != i)

        if (*c==escapesym) c=scan_escape(c+1);

        else c++;

    output_possible=exoutputp;

    skip_escape=exskipescape;

    break;

    case 'c': no_newline_output=1; break;

    case '{': newline_for_fun++; h="";break;

    case '}': if (newline_for_fun) newline_for_fun--; h="";break;

    case 'p': h="
\n";curpos=0; break;

    case 't': h="\t";curpos=(curpos+8)&0xfff8; break;

    case '<': h="<";curpos++; break;

    case '>': h=">";curpos++; break;

    case '\\': if (single_escape) { c--; break;}

    default: b[0]=*c; b[1]=0; h=b; curpos++; break;

    }

    c++;

    if (!skip_escape) out_html(h);

    return c;

}

typedef struct TABLEITEM TABLEITEM;

struct TABLEITEM {

    char *contents;

    int size,align,valign,colspan,rowspan,font,vleft,vright,space,width;

    TABLEITEM *next;

};

static TABLEITEM emptyfield = {NULL,0,0,0,1,1,0,0,0,0,0,NULL};

typedef struct TABLEROW TABLEROW;

struct TABLEROW {

    TABLEITEM *first;

    TABLEROW *prev, *next;

};

static char *tableopt[]= { "center", "expand", "box", "allbox", "doublebox",

               "tab", "linesize", "delim", NULL };

static int tableoptl[] = { 6,6,3,6,9,3,8,5,0};

static void clear_table(TABLEROW *table)

{

    TABLEROW *tr1,*tr2;

    TABLEITEM *ti1,*ti2;

    tr1=table;

    while (tr1->prev) tr1=tr1->prev;

    while (tr1) {

    ti1=tr1->first;

    while (ti1) {

        ti2=ti1->next;

        if (ti1->contents) free(ti1->contents);

        free(ti1);

        ti1=ti2;

    }

    tr2=tr1;

    tr1=tr1->next;

    free(tr2);

    }

}

char *scan_expression(char *c, int *result);

static char *scan_format(char *c, TABLEROW **result, int *maxcol)

{

    TABLEROW *layout, *currow;

    TABLEITEM *curfield;

    int i,j;

    if (*result) {

    clear_table(*result);

    }

    layout= currow=(TABLEROW*) xmalloc(sizeof(TABLEROW));

    currow->next=currow->prev=NULL;

    currow->first=curfield=(TABLEITEM*) xmalloc(sizeof(TABLEITEM));

    *curfield=emptyfield;

    while (*c && *c!='.') {

    switch (*c) {

    case 'C': case 'c': case 'N': case 'n':

    case 'R': case 'r': case 'A': case 'a':

    case 'L': case 'l': case 'S': case 's':

    case '^': case '_':

        if (curfield->align) {

        curfield->next=(TABLEITEM*)xmalloc(sizeof(TABLEITEM));

        curfield=curfield->next;

        *curfield=emptyfield;

        }

        curfield->align=toupper(*c);

        c++;

        break;

    case 'i': case 'I': case 'B': case 'b':

        curfield->font = toupper(*c);

        c++;

        break;

    case 'f': case 'F':

        c++;

        curfield->font = toupper(*c);

        c++;

        if (!isspace(*c)) c++;

        break;

    case 't': case 'T': curfield->valign='t'; c++; break;

    case 'p': case 'P':

        c++;

        i=j=0;

        if (*c=='+') { j=1; c++; }

        if (*c=='-') { j=-1; c++; }

        while (isdigit(*c)) i=i*10+(*c++)-'0';

        if (j) curfield->size= i*j; else curfield->size=j-10;

        break;

    case 'v': case 'V':

    case 'w': case 'W':

//        c=scan_expression(c+2,&curfield->width);

             c++;

         if (*c == '(') {

            c=scan_expression(c+1,&curfield->width);

         } else {

             i=0;

             while (isdigit(*c)) i=i*10+(*c++)-'0';

            curfield->width=i;

         }

        break;

    case '|':

        if (curfield->align) curfield->vleft++;

        else curfield->vright++;

        c++;

        break;

    case 'e': case 'E':

        c++;

        break;

    case '0': case '1': case '2': case '3': case '4':

    case '5': case '6': case '7': case '8': case '9':

        i=0;

        while (isdigit(*c)) i=i*10+(*c++)-'0';

        curfield->space=i;

        break;

    case ',': case '\n':

        currow->next=(TABLEROW*)xmalloc(sizeof(TABLEROW));

        currow->next->prev=currow;

        currow=currow->next;

        currow->next=NULL;

        curfield=currow->first=(TABLEITEM*)xmalloc(sizeof(TABLEITEM));

        *curfield=emptyfield;

        c++;

        break;

    default:

        c++;

        break;

    }

    }

    if (*c=='.') while (*c++!='\n');

    *maxcol=0;

    currow=layout;

    while (currow) {

    curfield=layout->first;

    i=0;

    while (curfield) {

        i++;

        curfield=curfield->next;

    }

    if (i>*maxcol) *maxcol=i;

    currow=currow->next;

    }

    *result=layout;

    return c;

}

static TABLEROW *

next_row(TABLEROW *tr)

{

    if (tr->next) {

    tr=tr->next;

    if (!tr->next) next_row(tr);

    return tr;

    } else {

    TABLEITEM *ti, *ti2;

    tr->next=(TABLEROW*)xmalloc(sizeof(TABLEROW));

    tr->next->prev=tr;

    ti=tr->first;

    tr=tr->next;

    tr->next=NULL;

    if (ti) tr->first=ti2=(TABLEITEM*) xmalloc(sizeof(TABLEITEM));

    else tr->first=ti2=NULL;

    while (ti!=ti2) {

        *ti2=*ti;

        ti2->contents=NULL;

        if ((ti=ti->next)) {

        ti2->next=(TABLEITEM*) xmalloc(sizeof(TABLEITEM));

        }

        ti2=ti2->next;

    }

    return tr;

    }

}

char itemreset[20]="\\fR\\s0";

static char *

scan_table(char *c) {

    char *h;

    char *g;

    int center=0, expand=0, box=0, border=0, linesize=1;

    int i,j,maxcol=0, finished=0;

    int oldfont, oldsize,oldfillout;

    char itemsep='\t';

    TABLEROW *layout=NULL, *currow;

    TABLEITEM *curfield;

    while (*c++!='\n');        /* skip TS */

    h=c;

    if (*h=='.') return c-1;

    oldfont=current_font;

    oldsize=current_size;

    oldfillout=fillout;

    out_html(change_to_font(0));

    out_html(change_to_size(0));

    if (!fillout) {

    fillout=1;

    out_html("

    }

    while (*h && *h!='\n') h++;

    if (h[-1]==';') {

    /* scan table options */

    while (c

        while (isspace(*c)) c++;

        for (i=0; tableopt[i] && strncmp(tableopt[i],c,tableoptl[i]);i++);

        c=c+tableoptl[i];

        switch (i) {

        case 0: center=1; break;

        case 1: expand=1; break;

        case 2: box=1; break;

        case 3: border=1; break;

        case 4: box=2; break;

        case 5: while (*c++!='('); itemsep=*c++; break;

        case 6: while (*c++!='('); linesize=0;

        while (isdigit(*c)) linesize=linesize*10+(*c++)-'0';

        break;

        case 7: while (*c!=')') c++;

        default: break;

        }

        c++;

    }

    c=h+1;

    }

    /* scan layout */

    c=scan_format(c,&layout, &maxcol);

    currow=layout;

    next_row(currow);

    curfield=layout->first;

    i=0;

    while (!finished && *c) {

    /* search item */

    h=c;

    if ((*c=='_' || *c=='=') && (c[1]==itemsep || c[1]=='\n')) {

        if (c[-1]=='\n' && c[1]=='\n') {

        if (currow->prev) {

            currow->prev->next=(TABLEROW*) xmalloc(sizeof(TABLEROW));

            currow->prev->next->next=currow;

            currow->prev->next->prev=currow->prev;

            currow->prev=currow->prev->next;

        } else {

            currow->prev=layout=(TABLEROW*) xmalloc(sizeof(TABLEROW));

            currow->prev->prev=NULL;

            currow->prev->next=currow;

        }

        curfield=currow->prev->first=

            (TABLEITEM*) xmalloc(sizeof(TABLEITEM));

        *curfield=emptyfield;

        curfield->align=*c;

        curfield->colspan=maxcol;

        curfield=currow->first;

        c=c+2;

        } else {

        if (curfield) {

            curfield->align=*c;

            do {

            curfield=curfield->next;

            } while (curfield && curfield->align=='S');

        }

        if (c[1]=='\n') {

            currow=next_row(currow);

            curfield=currow->first;

        }

        c=c+2;

        }

    } else if (*c=='T' && c[1]=='{') {

        h=c+2;

        c=strstr(h,"\nT}");

        c++;

        *c=0;

        g=NULL;

        scan_troff(h, 0, &g);

        scan_troff(itemreset, 0, &g);

        *c='T';

        c+=3;

        if (curfield) {

        curfield->contents=g;

        do {

            curfield=curfield->next;

        } while (curfield && curfield->align=='S');

        } else

        if (g) free(g);

        if (c[-1]=='\n') {

        currow=next_row(currow);

        curfield=currow->first;

        }

    } else if (*c=='.' && c[1]=='T' && c[2]=='&' && c[-1]=='\n') {

        TABLEROW *hr;

        while (*c++!='\n');

        hr=currow;

        currow=currow->prev;

        hr->prev=NULL;

        c=scan_format(c,&hr, &i);

        hr->prev=currow;

        currow->next=hr;

        currow=hr;

        next_row(currow);

        curfield=currow->first;

    } else if (*c=='.' && c[1]=='T' && c[2]=='E' && c[-1]=='\n') {

        finished=1;

        while (*c++!='\n');

        if (currow->prev)

        currow->prev->next=NULL;

        currow->prev=NULL;

        clear_table(currow);

    } else if (*c=='.' && c[-1]=='\n' && !isdigit(c[1])) {

        /* skip troff request inside table (usually only .sp ) */

        while (*c++!='\n');

    } else {

        h=c;

        while (*c && (*c!=itemsep || c[-1]=='\\') &&

           (*c!='\n' || c[-1]=='\\')) c++;

        i=0;

        if (*c==itemsep) {i=1; *c='\n'; }

        if (h[0]=='\\' && h[2]=='\n' &&

        (h[1]=='_' || h[1]=='^')) {

        if (curfield) {

            curfield->align=h[1];

            do {

            curfield=curfield->next;

            } while (curfield && curfield->align=='S');

        }

        h=h+3;

        } else {

        g=NULL;

        h=scan_troff(h,1,&g);

        scan_troff(itemreset,0,&g);

        if (curfield) {

            curfield->contents=g;

            do {

            curfield=curfield->next;

            } while (curfield && curfield->align=='S');

        } else if (g) free(g);

        }

        if (i) *c=itemsep;

        c=h;

        if (c[-1]=='\n') {

        currow=next_row(currow);

        curfield=currow->first;

        }

    }

    }

    /* calculate colspan and rowspan */

#if 0

    currow=layout;

    while (currow->next) currow=currow->next;

    while (currow) {

    TABLEITEM *ti, *ti1=NULL, *ti2=NULL;

    ti=currow->first;

    if (currow->prev) ti1=currow->prev->first;

    while (ti) {

        switch (ti->align) {

        case 'S':

        if (ti2) {

            ti2->colspan++;

            if (ti2->rowspanrowspan) ti2->rowspan=ti->rowspan;

        }

        break;

        case '^':

        if (ti1) ti1->rowspan++;

        default:

        if (!ti2) ti2=ti;

        else {

            do {

            ti2=ti2->next;

            } while (ti2 && curfield->align=='S');

        }

        break;

        }

        ti=ti->next;

        if (ti1) ti1=ti1->next;

    }

    currow=currow->prev;

    }

#endif

    /* produce html output */

    if (center) out_html("");

    if (box==2) out_html("");");\n");
");
        
        

           

           

           

           
    out_html("
        
        

           

           

           

           
    if (box || border) {
        
        

           

           
turbocat
           

           
    out_html(" BORDER");
        
        

           

           

           

           
    if (!border) out_html(">

        
        

           

           

           

           
    if (expand) out_html(" WIDTH=100%");
        
        

           

           
navichok26
           

           
    }
        
        

           

           

           

           
    out_html(">\n");
        
        

           

           

           

           
    currow=layout;
        
        

           

           

           

           
    while (currow) {
        
        

           

           
turbocat
           

           
    j=0;
        
        

           

           

           

           
    out_html("

        
        

           

           

           

           
    curfield=currow->first;
        
        

           

           

           

           
    while (curfield) {
        
        

           

           

           

           
        if (curfield->align!='S' && curfield->align!='^') {
        
        

           

           

           

           
        out_html("
        
        

           

           

           

           
        switch (curfield->align) {
        
        

           

           

           

           
        case 'N':
        
        

           

           

           

           
            curfield->space+=4;
        
        

           

           

           

           
        case 'R':
        
        

           

           

           

           
            out_html(" ALIGN=right");
        
        

           

           

           

           
            break;
        
        

           

           

           

           
        case 'C':
        
        

           

           

           

           
            out_html(" ALIGN=center");
        
        

           

           

           

           
        default:
        
        

           

           

           

           
            break;
        
        

           

           

           

           
        }
        
        

           

           

           

           
        if (!curfield->valign && curfield->rowspan>1)
        
        

           

           

           

           
            out_html(" VALIGN=center");
        
        

           

           

           

           
        if (curfield->colspan>1) {
        
        

           

           

           

           
            char buf[5];
        
        

           

           

           

           
            out_html(" COLSPAN=");
        
        

           

           

           

           
            sprintf(buf, "%i", curfield->colspan);
        
        

           

           

           

           
            out_html(buf);
        
        

           

           

           

           
        }
        
        

           

           

           

           
        if (curfield->rowspan>1) {
        
        

           

           

           

           
            char buf[5];
        
        

           

           

           

           
            out_html(" ROWSPAN=");
        
        

           

           

           

           
            sprintf(buf, "%i", curfield->rowspan);
        
        

           

           

           

           
            out_html(buf);
        
        

           

           

           

           
        }
        
        

           

           

           

           
        j=j+curfield->colspan;
        
        

           

           

           

           
        out_html(">");
        
        

           

           

           

           
        if (curfield->size) out_html(change_to_size(curfield->size));
        
        

           

           

           

           
        if (curfield->font) out_html(change_to_font(curfield->font));
        
        

           

           

           

           
        switch (curfield->align) {
        
        

           

           

           

           
        case '=': out_html("
"); break;
        
        

           

           

           

           
        case '_': out_html("
"); break;
        
        

           

           

           

           
        default:
        
        

           

           

           

           
            if (curfield->contents) out_html(curfield->contents);
        
        

           

           

           

           
            break;
        
        

           

           

           

           
        }
        
        

           

           

           

           
        if (curfield->space)
        
        

           

           

           

           
            for (i=0; ispace;i++) out_html(" ");
        
        

           

           

           

           
        if (curfield->font) out_html(change_to_font(0));
        
        

           

           

           

           
        if (curfield->size) out_html(change_to_size(0));
        
        

           

           

           

           
        if (j>=maxcol && curfield->align>'@' && curfield->align!='_')
        
        

           

           

           

           
            out_html("
");
        
        

           

           

           

           
        out_html("
        
        

           

           

           

           
        }
        
        

           

           

           

           
        curfield=curfield->next;
        
        

           

           
navichok26
           

           
    }
        
        

           

           
turbocat
           

           
    out_html("
        
        

           

           

           

           
    currow=currow->next;
        
        

           

           

           

           
    }
        
        

           

           
navichok26
           

           
    if (box && !border) out_html("
");