sys/src/cmd/mothra/rdhtml.c

   1 #include <u.h>
   2 #include <libc.h>
   3 #include <draw.h>
   4 #include <event.h>
   5 #include <panel.h>
   6 #include "mothra.h"
   7 #include "html.h"
   8 #include "rtext.h"
   9
  10 typedef struct Fontdata Fontdata;
  11 struct Fontdata{
  12         char *name;
  13         Font *font;
  14         int space;
  15 }fontlist[4][4]={
  16         "dejavusans/unicode.12", 0, 0,
  17         "dejavusans/unicode.12", 0, 0,
  18         "dejavusans/unicode.14", 0, 0,
  19         "dejavusans/unicode.16", 0, 0,
  20
  21         "dejavusansit/unicode.12", 0, 0,
  22         "dejavusansit/unicode.12", 0, 0,
  23         "dejavusansit/unicode.14", 0, 0,
  24         "dejavusansit/unicode.16", 0, 0,
  25
  26         "dejavusansbd/unicode.12", 0, 0,
  27         "dejavusansbd/unicode.12", 0, 0,
  28         "dejavusansbd/unicode.14", 0, 0,
  29         "dejavusansbd/unicode.16", 0, 0,
  30
  31         "vga/vga", 0, 0,
  32         "terminus/unicode.14", 0, 0,
  33         "terminus/unicode.16", 0, 0,
  34         "terminus/unicode.18", 0, 0,
  35 };
  36 Fontdata *pl_whichfont(int f, int s){
  37         char name[NNAME];
  38
  39         assert(f >= 0 && f < 4);
  40         assert(s >= 0 && s < 4);
  41
  42         if(fontlist[f][s].font==0){
  43                 snprint(name, sizeof(name), "/lib/font/bit/%s.font", fontlist[f][s].name);
  44                 fontlist[f][s].font=openfont(display, name);
  45                 if(fontlist[f][s].font==0) fontlist[f][s].font=font;
  46                 fontlist[f][s].space=stringwidth(fontlist[f][s].font, "0");
  47         }
  48         return &fontlist[f][s];
  49
  50 }
  51 void getfonts(void){
  52         int f, s;
  53         for(f=0;f!=4;f++)
  54                 for(s=0;s!=4;s++)
  55                         pl_whichfont(f, s);
  56 }
  57 void pl_pushstate(Hglob *g, int t){
  58         ++g->state;
  59         if(g->state==&g->stack[NSTACK]){
  60                 htmlerror(g->name, g->lineno, "stack overflow at <%s>", tag[t].name);
  61                 --g->state;
  62         }
  63         g->state[0]=g->state[-1];
  64         g->state->tag=t;
  65 }
  66 void pl_linespace(Hglob *g){
  67         plrtbitmap(&g->dst->text, 1000000, 0, linespace, 0, 0);
  68         g->para=0;
  69         g->linebrk=0;
  70 }
  71 enum{
  72         HORIZ,
  73         VERT,
  74 };
  75 int strtolength(Hglob *g, int dir, char *str)
  76 {
  77         double f;
  78
  79         f = atof(str);
  80         if(cistrstr(str, "px"))
  81                 return floor(f);
  82         if(cistrstr(str, "%"))
  83                 return floor(f*((dir==HORIZ) ? Dx(g->dst->text->r) : Dy(g->dst->text->r))/100);
  84         if(cistrstr(str, "em")){
  85                 Point z;
  86                 z = stringsize(g->dst->text->font, "M");
  87                 return floor(f*((dir==HORIZ) ? z.x : z.y));
  88         }
  89         return floor(f);
  90 }
  91
  92 void pl_htmloutput(Hglob *g, int nsp, char *s, Field *field){
  93         Fontdata *f;
  94         int space, indent;
  95         Action *ap;
  96         if(g->state->tag==Tag_title
  97 /*      || g->state->tag==Tag_textarea */
  98         || g->state->tag==Tag_select){
  99                 if(s){
 100                         if(g->tp!=g->text && g->tp!=g->etext && g->tp[-1]!=' ')
 101                                 *g->tp++=' ';
 102                         while(g->tp!=g->etext && *s) *g->tp++=*s++;
 103                         if(g->state->tag==Tag_title) g->dst->changed=1;
 104                         *g->tp='\0';
 105                 }
 106                 return;
 107         }
 108         f=pl_whichfont(g->state->font, g->state->size);
 109         space=f->space;
 110         indent=g->state->margin;
 111         if(g->para){
 112                 space=1000000;
 113                 indent+=g->state->indent;
 114         }
 115         else if(g->linebrk)
 116                 space=1000000;
 117         else if(nsp<=0)
 118                 space=0;
 119         if(g->state->image[0]==0 && g->state->link[0]==0 && g->state->name[0]==0 && field==0)
 120                 ap=0;
 121         else{
 122                 ap=mallocz(sizeof(Action), 1);
 123                 if(ap!=0){
 124                         if(g->state->image[0])
 125                                 ap->image = strdup(g->state->image);
 126                         if(g->state->link[0])
 127                                 ap->link = strdup(g->state->link);
 128                         if(g->state->name[0])
 129                                 ap->name = strdup(g->state->name);
 130                         ap->ismap=g->state->ismap;
 131                         ap->width=g->state->width;
 132                         ap->height=g->state->height;
 133                         ap->field=field;
 134                 }
 135         }
 136         if(space<0) space=0;
 137         if(indent<0) indent=0;
 138         if(g->state->pre && s[0]=='\t'){
 139                 space=0;
 140                 while(s[0]=='\t'){
 141                         space++;
 142                         s++;
 143                 }
 144                 space=PL_TAB|space;
 145                 if(g->linebrk){
 146                         indent=space;
 147                         space=1000000;
 148                 }
 149         }
 150         plrtstr(&g->dst->text, space, indent, f->font, strdup(s),
 151                 g->state->link[0] || g->state->image[0], ap);
 152         g->para=0;
 153         g->linebrk=0;
 154         g->dst->changed=1;
 155 }
 156
 157 /*
 158  * Buffered read, no translation
 159  * Save in cache.
 160  */
 161 int pl_bread(Hglob *g){
 162         int n, c;
 163         char err[1024];
 164         if(g->hbufp==g->ehbuf){
 165                 n=read(g->hfd, g->hbuf, NHBUF);
 166                 if(n<=0){
 167                         if(n<0){
 168                                 snprint(err, sizeof(err), "%r reading %s", g->name);
 169                                 pl_htmloutput(g, 1, err, 0);
 170                         }
 171                         g->heof=1;
 172                         return EOF;
 173                 }
 174                 g->hbufp=g->hbuf;
 175                 g->ehbuf=g->hbuf+n;
 176         }
 177         c=*g->hbufp++&255;
 178         if(c=='\n') g->lineno++;
 179         return c;
 180 }
 181 /*
 182  * Read a character, translating \r\n, \n\r, \r and \n into \n
 183  */
 184 int pl_readc(Hglob *g){
 185         int c;
 186         static int peek=-1;
 187         if(peek!=-1){
 188                 c=peek;
 189                 peek=-1;
 190         }
 191         else
 192                 c=pl_bread(g);
 193         if(c=='\r'){
 194                 c=pl_bread(g);
 195                 if(c!='\n') peek=c;
 196                 return '\n';
 197         }
 198         if(c=='\n'){
 199                 c=pl_bread(g);
 200                 if(c!='\r') peek=c;
 201                 return '\n';
 202         }
 203         return c;
 204 }
 205 void pl_putback(Hglob *g, int c){
 206         if(g->npeekc==NPEEKC) htmlerror(g->name, g->lineno, "too much putback!");
 207         else if(c!=EOF) g->peekc[g->npeekc++]=c;
 208 }
 209 int pl_nextc(Hglob *g){
 210         int c;
 211         int n;
 212         Rune r;
 213         char crune[UTFmax+1];
 214         if(g->heof) return EOF;
 215         if(g->npeekc!=0) return g->peekc[--g->npeekc];
 216         c=pl_readc(g);
 217         if(c=='<'){
 218                 c=pl_readc(g);
 219                 if(c=='/'){
 220                         c=pl_readc(g);
 221                         pl_putback(g, c);
 222                         pl_putback(g, '/');
 223                         if('a'<=c && c<='z' || 'A'<=c && c<='Z') return STAG;
 224                         return '<';
 225                 }
 226                 pl_putback(g, c);
 227                 if(c=='!' || 'a'<=c && c<='z' || 'A'<=c && c<='Z' || c=='?') return STAG;
 228                 return '<';
 229         }
 230         if(c=='>') return ETAG;
 231         if(c==EOF) return c;
 232         for (n=1; n<=sizeof(crune); n++){
 233                 crune[n-1]=c;
 234                 if(fullrune(crune, n)){
 235                         chartorune(&r, crune);
 236                         return r;
 237                 }
 238                 c=pl_readc(g);
 239                 if(c==EOF)
 240                         return EOF;
 241         }
 242         return c;
 243 }
 244 char *unquot(char *dst, char *src, int len){
 245         char *e;
 246
 247         e=0;
 248         while(strchr("\n\r\t ", *src))
 249                 src++;
 250         if(*src=='\'' || *src=='"'){
 251                 e=strrchr(src+1, *src);
 252                 src++;
 253         }
 254         if(e==0) e=strchr(src, 0);
 255         len--;
 256         if((e - src) < len)
 257                 len=e-src;
 258         if(len>0) memmove(dst, src, len);
 259         dst[len]=0;
 260         return dst;
 261 }
 262 int entchar(int c){
 263         return c=='#' || 'a'<=c && c<='z' || 'A'<=c && c<='Z' || '0'<=c && c<='9';
 264 }
 265 /*
 266  * remove entity references, in place.
 267  * Potential bug:
 268  *      This doesn't work if removing an entity reference can lengthen the string!
 269  *      Fortunately, this doesn't happen.
 270  */
 271 void pl_rmentities(Hglob *g, char *s){
 272         char *t, *u, c, svc;
 273         Entity *ep;
 274         Rune r;
 275         t=s;
 276         do{
 277                 c=*s++;
 278                 if(c=='&'
 279                 && ((*s=='#' && strchr("0123456789Xx", s[1]))
 280                   || 'a'<=*s && *s<='z'
 281                   || 'A'<=*s && *s<='Z')){
 282                         u=s;
 283                         while(entchar(*s)) s++;
 284                         svc=*s;
 285                         *s = 0;
 286                         if(svc==';') s++;
 287                         if(strcmp(u, "lt") == 0)
 288                                 *t++='<';
 289                         else if(strcmp(u, "gt") == 0)
 290                                 *t++='>';
 291                         else if(strcmp(u, "quot") == 0)
 292                                 *t++='"';
 293                         else if(strcmp(u, "apos") == 0)
 294                                 *t++='\'';
 295                         else if(strcmp(u, "amp") == 0)
 296                                 *t++='&';
 297                         else {
 298                                 if(svc==';') s--;
 299                                 *s=svc;
 300                                 *t++='&';
 301                                 while(u<s)
 302                                         *t++=*u++;
 303                         }
 304                 }
 305                 else *t++=c;
 306         }while(c);
 307 }
 308 /*
 309  * Skip over white space
 310  */
 311 char *pl_white(char *s){
 312         while(*s==' ' || *s=='\t' || *s=='\n' || *s=='\r') s++;
 313         return s;
 314 }
 315 /*
 316  * Skip over HTML word
 317  */
 318 char *pl_word(char *s){
 319         if ('a'<=*s && *s<='z' || 'A'<=*s && *s<='Z') {
 320                 s++;
 321                 while('a'<=*s && *s<='z' || 'A'<=*s && *s<='Z' || '0'<=*s && *s<='9' || *s=='-' || *s=='.') s++;
 322         }
 323         return s;
 324 }
 325 /*
 326  * Skip to matching quote
 327  */
 328 char *pl_quote(char *s){
 329         char q;
 330         q=*s++;
 331         while(*s!=q && *s!='\0') s++;
 332         return s;
 333 }
 334 void pl_dnl(char *s){
 335         char *t;
 336         for(t=s;*s;s++) if(*s!='\r' && *s!='\n') *t++=*s;
 337         *t='\0';
 338 }
 339 void pl_tagparse(Hglob *g, char *str){
 340         char *s, *t, *name, c;
 341         Pair *ap;
 342         Tag *tagp;
 343         g->tag=Tag_end;
 344         ap=g->attr;
 345         if(str[0]=='!'){        /* test should be strncmp(str, "!--", 3)==0 */
 346                 g->tag=Tag_comment;
 347                 ap->name=0;
 348                 return;
 349         }
 350         if(str[0]=='/') str++;
 351         name=str;
 352         s=pl_word(str);
 353         if(*s!=' ' && *s!='\n' && *s!='\t' && *s!='\0'){
 354                 htmlerror(g->name, g->lineno, "bad tag name in %s", str);
 355                 ap->name=0;
 356                 return;
 357         }
 358         if(*s!='\0') *s++='\0';
 359         for(t=name;t!=s;t++) if('A'<=*t && *t<='Z') *t+='a'-'A';
 360         /*
 361          * Binary search would be faster here
 362          */
 363         for(tagp=tag;tagp->name;tagp++) if(strcmp(name, tagp->name)==0) break;
 364         g->tag=tagp-tag;
 365         if(g->tag==Tag_end) htmlerror(g->name, g->lineno, "no tag %s", name);
 366         for(;;){
 367                 s=pl_white(s);
 368                 if(*s=='\0'){
 369                         ap->name=0;
 370                         return;
 371                 }
 372                 ap->name=s;
 373                 s=pl_word(s);
 374                 t=pl_white(s);
 375                 c=*t;
 376                 *s='\0';
 377                 for(s=ap->name;*s;s++) if('A'<=*s && *s<='Z') *s+='a'-'A';
 378                 if(c=='='){
 379                         s=pl_white(t+1);
 380                         if(*s=='\'' || *s=='"'){
 381                                 ap->value=s+1;
 382                                 s=pl_quote(s);
 383                                 if(*s=='\0'){
 384                                         htmlerror(g->name, g->lineno,
 385                                                 "No terminating quote in rhs of attribute %s",
 386                                                 ap->name);
 387                                         ap->name=0;
 388                                         return;
 389                                 }
 390                                 *s++='\0';
 391                                 pl_dnl(ap->value);
 392                         }
 393                         else{
 394                                 /* read up to white space or > */
 395                                 ap->value=s;
 396                                 while(*s!=' ' && *s!='\t' && *s!='\n' && *s!='\0') s++;
 397                                 if(*s!='\0') *s++='\0';
 398                         }
 399                         pl_rmentities(g, ap->value);
 400                 }
 401                 else{
 402                         if(c!='\0') s++;
 403                         ap->value="";
 404                 }
 405                 if(ap==&g->attr[NATTR-1])
 406                         htmlerror(g->name, g->lineno, "too many attributes!");
 407                 else ap++;
 408         }
 409 }
 410 int pl_getcomment(Hglob *g){
 411         int c;
 412         if((c=pl_nextc(g))=='-' && (c=pl_nextc(g))=='-'){
 413                 /* <!-- eats everything until --> or EOF */
 414                 for(;;){
 415                         while((c=pl_nextc(g))!='-' && c!=EOF)
 416                                 ;
 417                         if(c==EOF)
 418                                 break;
 419                         if((c=pl_nextc(g))=='-'){
 420                                 while((c=pl_nextc(g))=='-')
 421                                         ;
 422                                 if(c==ETAG || c==EOF)
 423                                         break;
 424                         }
 425                 }
 426         } else {
 427                 /* <! eats everything until > or EOF */
 428                 while(c!=ETAG && c!=EOF)
 429                         c=pl_nextc(g);
 430         }
 431         if(c==EOF)
 432                 htmlerror(g->name, g->lineno, "EOF in comment");
 433         g->tag=Tag_comment;
 434         g->attr->name=0;
 435         g->token[0]='\0';
 436         return TAG;
 437 }
 438 int lrunetochar(char *p, int v)
 439 {
 440         Rune r;
 441
 442         r=v;
 443         return runetochar(p, &r);
 444 }
 445
 446 /*
 447  * Read a start or end tag -- the caller has read the initial <
 448  */
 449 int pl_gettag(Hglob *g){
 450         char *tokp;
 451         int c;
 452         tokp=g->token;
 453         if((c=pl_nextc(g))=='!' || c=='?')
 454                 return pl_getcomment(g);
 455         pl_putback(g, c);
 456         while((c=pl_nextc(g))!=ETAG && c!=EOF)
 457                 if(tokp < &g->token[NTOKEN-UTFmax-1]) tokp += lrunetochar(tokp, c);
 458         *tokp='\0';
 459         if(c==EOF) htmlerror(g->name, g->lineno, "EOF in tag");
 460         pl_tagparse(g, g->token);
 461         if(g->token[0]!='/') return TAG;
 462         if(g->attr[0].name!=0)
 463                 htmlerror(g->name, g->lineno, "end tag should not have attributes");
 464         return ENDTAG;
 465 }
 466 /*
 467  * The next token is a tag, an end tag or a sequence of
 468  * non-white characters.
 469  * If inside <pre>, newlines are converted to <br> and spaces are preserved.
 470  * Otherwise, spaces and newlines are noted and discarded.
 471  */
 472 int pl_gettoken(Hglob *g){
 473         char *tokp;
 474         int c;
 475         if(g->state->pre) switch(c=pl_nextc(g)){
 476         case STAG: return pl_gettag(g);
 477         case EOF: return EOF;
 478         case '\n':
 479                 pl_tagparse(g, "br");
 480                 return TAG;
 481         default:
 482                 tokp=g->token;
 483                 while(c=='\t'){
 484                         if(tokp < &g->token[NTOKEN-UTFmax-1]) tokp += lrunetochar(tokp, c);
 485                         c=pl_nextc(g);
 486                 }
 487                 while(c!='\t' && c!='\n' && c!=STAG && c!=EOF){
 488                         if(c==ETAG) c='>';
 489                         if(tokp < &g->token[NTOKEN-UTFmax-1]) tokp += lrunetochar(tokp, c);
 490                         c=pl_nextc(g);
 491                 }
 492                 *tokp='\0';
 493                 pl_rmentities(g, g->token);
 494                 pl_putback(g, c);
 495                 g->nsp=0;
 496                 g->spacc=0;
 497                 return TEXT;
 498         }
 499         while((c=pl_nextc(g))==' ' || c=='\t' || c=='\n')
 500                 if(g->spacc!=-1)
 501                         g->spacc++;
 502         switch(c){
 503         case STAG: return pl_gettag(g);
 504         case EOF: return EOF;
 505         default:
 506                 tokp=g->token;
 507                 do{
 508                         if(c==ETAG) c='>';
 509                         if(tokp < &g->token[NTOKEN-UTFmax-1]) tokp += lrunetochar(tokp, c);
 510                         c=pl_nextc(g);
 511                 }while(c!=' ' && c!='\t' && c!='\n' && c!=STAG && c!=EOF);
 512                 *tokp='\0';
 513                 pl_rmentities(g, g->token);
 514                 pl_putback(g, c);
 515                 g->nsp=g->spacc;
 516                 g->spacc=0;
 517                 return TEXT;
 518         }
 519 }
 520 char *pl_getattr(Pair *attr, char *name){
 521         for(;attr->name;attr++)
 522                 if(strcmp(attr->name, name)==0)
 523                         return attr->value;
 524         return 0;
 525 }
 526 int pl_hasattr(Pair *attr, char *name){
 527         for(;attr->name;attr++)
 528                 if(strcmp(attr->name, name)==0)
 529                         return 1;
 530         return 0;
 531 }
 532 void plaintext(Hglob *g){
 533         char line[NLINE];
 534         char *lp, *elp;
 535         int c;
 536         g->state->font=CWIDTH;
 537         g->state->size=NORMAL;
 538         elp=&line[NLINE-UTFmax-1];
 539         lp=line;
 540         for(;;){
 541                 c=pl_readc(g);
 542                 if(c==EOF) break;
 543                 if(c=='\n' || lp>=elp){
 544                         *lp='\0';
 545                         g->linebrk=1;
 546                         pl_htmloutput(g, 0, line, 0);
 547                         lp=line;
 548                 }
 549                 if(c=='\t'){
 550                         do *lp++=' '; while(lp<elp && utfnlen(line, lp-line)%8!=0);
 551                 }
 552                 else if(c!='\n')
 553                         lp += lrunetochar(lp, c);
 554         }
 555         if(lp!=line){
 556                 *lp='\0';
 557                 g->linebrk=1;
 558                 pl_htmloutput(g, 0, line, 0);
 559         }
 560 }
 561 void plrdplain(char *name, int fd, Www *dst){
 562         Hglob g;
 563         g.state=g.stack;
 564         g.state->tag=Tag_html;
 565         g.state->font=CWIDTH;
 566         g.state->size=NORMAL;
 567         g.state->pre=0;
 568         g.state->image[0]=0;
 569         g.state->link[0]=0;
 570         g.state->name[0]=0;
 571         g.state->margin=0;
 572         g.state->indent=20;
 573         g.state->ismap=0;
 574         g.state->table=0;
 575         g.dst=dst;
 576         g.hfd=fd;
 577         g.name=name;
 578         g.ehbuf=g.hbufp=g.hbuf;
 579         g.npeekc=0;
 580         g.heof=0;
 581         g.lineno=1;
 582         g.linebrk=1;
 583         g.para=0;
 584         g.text=dst->title;
 585         g.tp=g.text;
 586         g.etext=g.text+NTITLE-1;
 587         g.spacc=0;
 588         g.form=0;
 589         strncpy(g.text, name, NTITLE);
 590         plaintext(&g);
 591         dst->finished=1;
 592 }
 593 void plrdhtml(char *name, int fd, Www *dst){
 594         Stack *sp;
 595         char buf[20];
 596         char *str;
 597         Hglob g;
 598         int t;
 599         int tagerr;
 600
 601         g.state=g.stack;
 602         g.state->tag=Tag_html;
 603         g.state->font=ROMAN;
 604         g.state->size=NORMAL;
 605         g.state->pre=0;
 606         g.state->image[0]=0;
 607         g.state->link[0]=0;
 608         g.state->name[0]=0;
 609         g.state->margin=0;
 610         g.state->indent=25;
 611         g.state->ismap=0;
 612         g.state->width=0;
 613         g.state->height=0;
 614         g.state->table=0;
 615         g.dst=dst;
 616         g.hfd=fd;
 617         g.name=name;
 618         g.ehbuf=g.hbufp=g.hbuf;
 619         g.npeekc=0;
 620         g.heof=0;
 621         g.lineno=1;
 622         g.linebrk=1;
 623         g.para=0;
 624         g.text=dst->title;
 625         g.tp=g.text;
 626         g.etext=g.text+NTITLE-1;
 627         dst->title[0]='\0';
 628         g.spacc=0;
 629         g.form=0;
 630
 631         for(;;) switch(pl_gettoken(&g)){
 632         case TAG:
 633                 switch(tag[g.tag].action){
 634                 case OPTEND:
 635                         for(sp=g.state;sp!=g.stack && sp->tag!=g.tag;--sp);
 636                         if(sp->tag!=g.tag)
 637                                 pl_pushstate(&g, g.tag);
 638                         else
 639                                 for(;g.state!=sp;--g.state)
 640                                         if(tag[g.state->tag].action!=OPTEND)
 641                                                 htmlerror(g.name, g.lineno,
 642                                                         "end tag </%s> missing",
 643                                                         tag[g.state->tag].name);
 644                         break;
 645                 case END:
 646                         pl_pushstate(&g, g.tag);
 647                         break;
 648                 }
 649                 if(str=pl_getattr(g.attr, "id")){
 650                         char swap[NNAME];
 651
 652                         strncpy(swap, g.state->name, sizeof(swap));
 653                         strncpy(g.state->name, str, sizeof(g.state->name));
 654                         pl_htmloutput(&g, 0, "", 0);
 655                         strncpy(g.state->name, swap, sizeof(g.state->name));
 656                 }
 657                 switch(g.tag){
 658                 default:
 659                         htmlerror(g.name, g.lineno,
 660                                 "unimplemented tag <%s>", tag[g.tag].name);
 661                         break;
 662                 case Tag_end:   /* unrecognized start tag */
 663                         break;
 664                 case Tag_img:
 665                         if(str=pl_getattr(g.attr, "src"))
 666                                 strncpy(g.state->image, str, sizeof(g.state->image));
 667                         g.state->ismap=pl_hasattr(g.attr, "ismap");
 668                         if(str=pl_getattr(g.attr, "width"))
 669                                 g.state->width = strtolength(&g, HORIZ, str);
 670                         if(str=pl_getattr(g.attr, "height"))
 671                                 g.state->height = strtolength(&g, VERT, str);
 672                         str=pl_getattr(g.attr, "alt");
 673                         if(str==0){
 674                                 if(g.state->image[0])
 675                                         str=g.state->image;
 676                                 else
 677                                         str="[[image]]";
 678                         }
 679                         pl_htmloutput(&g, 0, str, 0);
 680                         g.state->image[0]=0;
 681                         g.state->ismap=0;
 682                         g.state->width=0;
 683                         g.state->height=0;
 684                         break;
 685                 case Tag_plaintext:
 686                         g.spacc=0;
 687                         plaintext(&g);
 688                         break;
 689                 case Tag_comment:
 690                 case Tag_html:
 691                 case Tag_link:
 692                 case Tag_nextid:
 693                         break;
 694                 case Tag_table:
 695                         g.state->table++;
 696                         break;
 697                 case Tag_tr:
 698                         if(g.state->table==1){
 699                                 g.spacc=0;
 700                                 g.linebrk=1;
 701                         } else
 702                                 g.spacc++;
 703                         break;
 704                 case Tag_td:
 705                         g.spacc++;
 706                         break;
 707                 case Tag_a:
 708                         if(str=pl_getattr(g.attr, "href"))
 709                                 strncpy(g.state->link, str, sizeof(g.state->link));
 710                         if(str=pl_getattr(g.attr, "name")){
 711                                 strncpy(g.state->name, str, sizeof(g.state->name));
 712                                 pl_htmloutput(&g, 0, "", 0);
 713                         }
 714                         break;
 715                 case Tag_meta:
 716                         if((str=pl_getattr(g.attr, "http-equiv"))==0)
 717                                 break;
 718                         if(cistrcmp(str, "refresh"))
 719                                 break;
 720                         if((str=pl_getattr(g.attr, "content"))==0)
 721                                 break;
 722                         if((str=strchr(str, '='))==0)
 723                                 break;
 724                         str++;
 725                         str=unquot(g.state->link, str, sizeof(g.state->link));
 726                         pl_htmloutput(&g, 0, "refresh: ", 0);
 727                         pl_htmloutput(&g, 0, str, 0);
 728                         g.state->link[0]=0;
 729                         g.linebrk=1;
 730                         g.spacc=0;
 731                         break;
 732                 case Tag_source:
 733                 case Tag_video:
 734                 case Tag_audio:
 735                 case Tag_embed:
 736                 case Tag_frame:
 737                 case Tag_iframe:
 738                         if(str=pl_getattr(g.attr, "src"))
 739                                 strncpy(g.state->link, str, sizeof(g.state->link));
 740                         if(str=pl_getattr(g.attr, "name"))
 741                                 strncpy(g.state->name, str, sizeof(g.state->name));
 742                         else
 743                                 str = g.state->link;
 744                         pl_htmloutput(&g, 0, tag[g.tag].name, 0);
 745                         pl_htmloutput(&g, 0, ": ", 0);
 746                         pl_htmloutput(&g, 0, str, 0);
 747                         g.state->link[0]=0;
 748                         g.state->name[0]=0;
 749                         g.linebrk=1;
 750                         g.spacc=0;
 751                         break;
 752                 case Tag_address:
 753                         g.spacc=0;
 754                         g.linebrk=1;
 755                         g.state->font=ROMAN;
 756                         g.state->size=NORMAL;
 757                         g.state->margin=300;
 758                         g.state->indent=50;
 759                         break;
 760                 case Tag_b:
 761                 case Tag_strong:
 762                         g.state->font=BOLD;
 763                         break;
 764                 case Tag_blockquot:
 765                         g.spacc=0;
 766                         g.linebrk=1;
 767                         g.state->margin+=50;
 768                         g.state->indent=20;
 769                         break;
 770                 case Tag_body:
 771                         break;
 772                 case Tag_head:
 773                         g.state->font=ROMAN;
 774                         g.state->size=NORMAL;
 775                         g.state->margin=0;
 776                         g.state->indent=20;
 777                         g.spacc=0;
 778                         break;
 779                 case Tag_div:
 780                 case Tag_br:
 781                         g.spacc=0;
 782                         g.linebrk=1;
 783                         break;
 784                 case Tag_center:
 785                         /* more to come */
 786                         break;
 787                 case Tag_cite:
 788                 case Tag_acronym:
 789                         g.state->font=ITALIC;
 790                         g.state->size=NORMAL;
 791                         break;
 792                 case Tag_code:
 793                         g.state->font=CWIDTH;
 794                         g.state->size=NORMAL;
 795                         break;
 796                 case Tag_dd:
 797                         g.linebrk=1;
 798                         g.state->indent=0;
 799                         g.state->font=ROMAN;
 800                         g.spacc=0;
 801                         break;
 802                 case Tag_dfn:
 803                         htmlerror(g.name, g.lineno, "<dfn> deprecated");
 804                 case Tag_abbr:
 805                         g.state->font=BOLD;
 806                         g.state->size=NORMAL;
 807                         break;
 808                 case Tag_dl:
 809                         g.state->font=BOLD;
 810                         g.state->size=NORMAL;
 811                         g.state->margin+=40;
 812                         g.spacc=0;
 813                         break;
 814                 case Tag_dt:
 815                         g.para=1;
 816                         g.state->indent=-40;
 817                         g.state->font=BOLD;
 818                         g.spacc=0;
 819                         break;
 820                 case Tag_font:
 821                         /* more to come */
 822                         break;
 823                 case Tag_u:
 824                         htmlerror(g.name, g.lineno, "<u> deprecated");
 825                 case Tag_em:
 826                 case Tag_i:
 827                 case Tag_var:
 828                         g.state->font=ITALIC;
 829                         break;
 830                 case Tag_h1:
 831                         g.linebrk=1;
 832                         g.state->font=BOLD;
 833                         g.state->size=ENORMOUS;
 834                         g.state->margin+=100;
 835                         g.spacc=0;
 836                         break;
 837                 case Tag_h2:
 838                         pl_linespace(&g);
 839                         g.state->font=BOLD;
 840                         g.state->size=ENORMOUS;
 841                         g.spacc=0;
 842                         break;
 843                 case Tag_h3:
 844                         g.linebrk=1;
 845                         pl_linespace(&g);
 846                         g.state->font=ITALIC;
 847                         g.state->size=ENORMOUS;
 848                         g.state->margin+=20;
 849                         g.spacc=0;
 850                         break;
 851                 case Tag_h4:
 852                         pl_linespace(&g);
 853                         g.state->font=BOLD;
 854                         g.state->size=LARGE;
 855                         g.state->margin+=10;
 856                         g.spacc=0;
 857                         break;
 858                 case Tag_h5:
 859                         pl_linespace(&g);
 860                         g.state->font=ITALIC;
 861                         g.state->size=LARGE;
 862                         g.state->margin+=10;
 863                         g.spacc=0;
 864                         break;
 865                 case Tag_h6:
 866                         pl_linespace(&g);
 867                         g.state->font=BOLD;
 868                         g.state->size=LARGE;
 869                         g.spacc=0;
 870                         break;
 871                 case Tag_hr:
 872                         g.spacc=0;
 873                         plrtbitmap(&g.dst->text, 1000000, g.state->margin, hrule, 0, 0);
 874                         break;
 875                 case Tag_key:
 876                         htmlerror(g.name, g.lineno, "<key> deprecated");
 877                 case Tag_kbd:
 878                         g.state->font=CWIDTH;
 879                         break;
 880                 case Tag_dir:
 881                 case Tag_menu:
 882                 case Tag_ol:
 883                 case Tag_ul:
 884                         g.state->number=0;
 885                         g.linebrk=1;
 886                         g.state->margin+=25;
 887                         g.state->indent=-25;
 888                         g.spacc=0;
 889                         break;
 890                 case Tag_li:
 891                         g.spacc=0;
 892                         switch(g.state->tag){
 893                         default:
 894                                 htmlerror(g.name, g.lineno, "can't have <li> in <%s>",
 895                                         tag[g.state->tag].name);
 896                         case Tag_dir:   /* supposed to be multi-columns, can't do! */
 897                         case Tag_menu:
 898                                 g.linebrk=1;
 899                                 break;
 900                         case Tag_ol:
 901                                 g.para=1;
 902                                 snprint(buf, sizeof(buf), "%2d  ", ++g.state->number);
 903                                 pl_htmloutput(&g, 0, buf, 0);
 904                                 break;
 905                         case Tag_ul:
 906                                 g.para=0;
 907                                 g.linebrk=0;
 908                                 g.spacc=-1;
 909                                 plrtbitmap(&g.dst->text, 100000,
 910                                         g.state->margin+g.state->indent, bullet, 0, 0);
 911                                 break;
 912                         }
 913                         break;
 914                 case Tag_p:
 915                         pl_linespace(&g);
 916                         g.linebrk=1;
 917                         g.spacc=0;
 918                         break;
 919                 case Tag_listing:
 920                 case Tag_xmp:
 921                         htmlerror(g.name, g.lineno, "<%s> deprecated", tag[g.tag].name);
 922                 case Tag_pre:
 923                 case Tag_samp:
 924                         g.state->indent=0;
 925                         g.state->pre=1;
 926                         g.state->font=CWIDTH;
 927                         g.state->size=NORMAL;
 928                         pl_linespace(&g);
 929                         break;
 930                 case Tag_tt:
 931                         g.state->font=CWIDTH;
 932                         g.state->size=NORMAL;
 933                         break;
 934                 case Tag_title:
 935                         g.text=dst->title+strlen(dst->title);
 936                         g.tp=g.text;
 937                         g.etext=dst->title+NTITLE-1;
 938                         break;
 939                 case Tag_form:
 940                 case Tag_input:
 941                 case Tag_button:
 942                 case Tag_select:
 943                 case Tag_option:
 944                 case Tag_textarea:
 945                 case Tag_isindex:
 946                         rdform(&g);
 947                         break;
 948                 case Tag_script:
 949                 case Tag_object:
 950                 case Tag_applet:
 951                 case Tag_style:
 952                         /*
 953                          * ignore the content of these tags, eat tokens until we
 954                          * reach a matching endtag.
 955                          */
 956                         t = g.tag;
 957                         for(;;){
 958                                 switch(pl_gettoken(&g)){
 959                                 default:
 960                                         continue;
 961                                 case ENDTAG:
 962                                         if(g.tag != t)
 963                                                 continue;
 964                                 case EOF:
 965                                         break;
 966                                 }
 967                                 break;
 968                         }
 969                         break;
 970                 }
 971                 break;
 972
 973         case ENDTAG:
 974                 /*
 975                  * If the end tag doesn't match the top, we try to uncover a match
 976                  * on the stack.
 977                  */
 978                 if(g.state->tag!=g.tag){
 979                         tagerr=0;
 980                         for(sp=g.state;sp!=g.stack;--sp){
 981                                 if(sp->tag==g.tag)
 982                                         break;
 983                                 if(tag[g.state->tag].action!=OPTEND) tagerr++;
 984                         }
 985                         if(sp==g.stack){
 986                                 if(tagerr)
 987                                         htmlerror(g.name, g.lineno,
 988                                                 "end tag mismatch <%s>...</%s>, ignored",
 989                                                 tag[g.state->tag].name, tag[g.tag].name);
 990                         }
 991                         else{
 992                                 if(tagerr)
 993                                         htmlerror(g.name, g.lineno,
 994                                                 "end tag mismatch <%s>...</%s>, "
 995                                                 "intervening tags popped",
 996                                                 tag[g.state->tag].name, tag[g.tag].name);
 997                                 g.state=sp-1;
 998                         }
 999                 }
1000                 else if(g.state==g.stack)
1001                         htmlerror(g.name, g.lineno, "end tag </%s> at stack bottom",
1002                                 tag[g.tag].name);
1003                 else
1004                         --g.state;
1005                 switch(g.tag){
1006                 case Tag_select:
1007                 case Tag_form:
1008                 case Tag_textarea:
1009                         endform(&g);
1010                         break;
1011                 case Tag_h1:
1012                 case Tag_h2:
1013                 case Tag_h3:
1014                 case Tag_h4:
1015                         pl_linespace(&g);
1016                         break;
1017                 case Tag_address:
1018                 case Tag_blockquot:
1019                 case Tag_body:
1020                 case Tag_dir:
1021                 case Tag_dl:
1022                 case Tag_dt:
1023                 case Tag_h5:
1024                 case Tag_h6:
1025                 case Tag_listing:
1026                 case Tag_menu:
1027                 case Tag_ol:
1028                 case Tag_samp:
1029                 case Tag_title:
1030                 case Tag_ul:
1031                 case Tag_xmp:
1032                         g.linebrk=1;
1033                         break;
1034                 case Tag_table:
1035                         if(g.state->table==0)
1036                                 g.linebrk=1;
1037                         break;
1038                 case Tag_pre:
1039                         pl_linespace(&g);
1040                         break;
1041                 }
1042                 break;
1043         case TEXT:
1044                 pl_htmloutput(&g, g.nsp, g.token, 0);
1045                 break;
1046         case EOF:
1047                 for(;g.state!=g.stack;--g.state)
1048                         if(tag[g.state->tag].action!=OPTEND)
1049                                 htmlerror(g.name, g.lineno,
1050                                         "missing </%s> at EOF", tag[g.state->tag].name);
1051                 *g.tp='\0';
1052                 dst->changed=1;
1053                 getpix(dst->text, dst);
1054                 dst->finished=1;
1055                 return;
1056         }
1057 }