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         "lucidasans/unicode.7", 0, 0,
  17         "lucidasans/unicode.8", 0, 0,
  18         "lucidasans/unicode.10", 0, 0,
  19         "lucidasans/unicode.13", 0, 0,
  20
  21         "lucidasans/italicunicode.7", 0, 0,
  22         "lucidasans/italicunicode.8", 0, 0,
  23         "lucidasans/italicunicode.10", 0, 0,
  24         "lucidasans/italicunicode.13", 0, 0,
  25
  26         "lucidasans/boldunicode.7", 0, 0,
  27         "lucidasans/boldunicode.8", 0, 0,
  28         "lucidasans/boldunicode.10", 0, 0,
  29         "lucidasans/boldunicode.13", 0, 0,
  30
  31         "lucidasans/typeunicode.7", 0, 0,
  32         "pelm/unicode.8", 0, 0,
  33         "lucidasans/typeunicode.12", 0, 0,
  34         "lucidasans/typeunicode.16", 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[4];
 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         n=0;
 233         for (;;){
 234                 crune[n++]=c;
 235                 if(fullrune(crune, n)){
 236                         chartorune(&r, crune);
 237                         return r;
 238                 }
 239                 c=pl_readc(g);
 240                 if(c==EOF)
 241                         return EOF;
 242         }
 243         return c;
 244 }
 245 int entchar(int c){
 246         return c=='#' || 'a'<=c && c<='z' || 'A'<=c && c<='Z' || '0'<=c && c<='9';
 247 }
 248 /*
 249  * remove entity references, in place.
 250  * Potential bug:
 251  *      This doesn't work if removing an entity reference can lengthen the string!
 252  *      Fortunately, this doesn't happen.
 253  */
 254 void pl_rmentities(Hglob *g, char *s){
 255         char *t, *u, c, svc;
 256         Entity *ep;
 257         Rune r;
 258         t=s;
 259         do{
 260                 c=*s++;
 261                 if(c=='&'
 262                 && ((*s=='#' && strchr("0123456789Xx", s[1]))
 263                   || 'a'<=*s && *s<='z'
 264                   || 'A'<=*s && *s<='Z')){
 265                         u=s;
 266                         while(entchar(*s)) s++;
 267                         svc=*s;
 268                         *s = 0;
 269                         if(svc==';') s++;
 270                         if(strcmp(u, "lt") == 0)
 271                                 *t++='<';
 272                         else if(strcmp(u, "gt") == 0)
 273                                 *t++='>';
 274                         else if(strcmp(u, "quot") == 0)
 275                                 *t++='"';
 276                         else if(strcmp(u, "apos") == 0)
 277                                 *t++='\'';
 278                         else if(strcmp(u, "amp") == 0)
 279                                 *t++='&';
 280                         else {
 281                                 if(svc==';') s--;
 282                                 *s=svc;
 283                                 *t++='&';
 284                                 while(u<s)
 285                                         *t++=*u++;
 286                         }
 287                 }
 288                 else *t++=c;
 289         }while(c);
 290 }
 291 /*
 292  * Skip over white space
 293  */
 294 char *pl_white(char *s){
 295         while(*s==' ' || *s=='\t' || *s=='\n' || *s=='\r') s++;
 296         return s;
 297 }
 298 /*
 299  * Skip over HTML word
 300  */
 301 char *pl_word(char *s){
 302         if ('a'<=*s && *s<='z' || 'A'<=*s && *s<='Z') {
 303                 s++;
 304                 while('a'<=*s && *s<='z' || 'A'<=*s && *s<='Z' || '0'<=*s && *s<='9' || *s=='-' || *s=='.') s++;
 305         }
 306         return s;
 307 }
 308 /*
 309  * Skip to matching quote
 310  */
 311 char *pl_quote(char *s){
 312         char q;
 313         q=*s++;
 314         while(*s!=q && *s!='\0') s++;
 315         return s;
 316 }
 317 void pl_dnl(char *s){
 318         char *t;
 319         for(t=s;*s;s++) if(*s!='\r' && *s!='\n') *t++=*s;
 320         *t='\0';
 321 }
 322 void pl_tagparse(Hglob *g, char *str){
 323         char *s, *t, *name, c;
 324         Pair *ap;
 325         Tag *tagp;
 326         g->tag=Tag_end;
 327         ap=g->attr;
 328         if(str[0]=='!'){        /* test should be strncmp(str, "!--", 3)==0 */
 329                 g->tag=Tag_comment;
 330                 ap->name=0;
 331                 return;
 332         }
 333         if(str[0]=='/') str++;
 334         name=str;
 335         s=pl_word(str);
 336         if(*s!=' ' && *s!='\n' && *s!='\t' && *s!='\0'){
 337                 htmlerror(g->name, g->lineno, "bad tag name in %s", str);
 338                 ap->name=0;
 339                 return;
 340         }
 341         if(*s!='\0') *s++='\0';
 342         for(t=name;t!=s;t++) if('A'<=*t && *t<='Z') *t+='a'-'A';
 343         /*
 344          * Binary search would be faster here
 345          */
 346         for(tagp=tag;tagp->name;tagp++) if(strcmp(name, tagp->name)==0) break;
 347         g->tag=tagp-tag;
 348         if(g->tag==Tag_end) htmlerror(g->name, g->lineno, "no tag %s", name);
 349         for(;;){
 350                 s=pl_white(s);
 351                 if(*s=='\0'){
 352                         ap->name=0;
 353                         return;
 354                 }
 355                 ap->name=s;
 356                 s=pl_word(s);
 357                 t=pl_white(s);
 358                 c=*t;
 359                 *s='\0';
 360                 for(s=ap->name;*s;s++) if('A'<=*s && *s<='Z') *s+='a'-'A';
 361                 if(c=='='){
 362                         s=pl_white(t+1);
 363                         if(*s=='\'' || *s=='"'){
 364                                 ap->value=s+1;
 365                                 s=pl_quote(s);
 366                                 if(*s=='\0'){
 367                                         htmlerror(g->name, g->lineno,
 368                                                 "No terminating quote in rhs of attribute %s",
 369                                                 ap->name);
 370                                         ap->name=0;
 371                                         return;
 372                                 }
 373                                 *s++='\0';
 374                                 pl_dnl(ap->value);
 375                         }
 376                         else{
 377                                 /* read up to white space or > */
 378                                 ap->value=s;
 379                                 while(*s!=' ' && *s!='\t' && *s!='\n' && *s!='\0') s++;
 380                                 if(*s!='\0') *s++='\0';
 381                         }
 382                         pl_rmentities(g, ap->value);
 383                 }
 384                 else{
 385                         if(c!='\0') s++;
 386                         ap->value="";
 387                 }
 388                 if(ap==&g->attr[NATTR-1])
 389                         htmlerror(g->name, g->lineno, "too many attributes!");
 390                 else ap++;
 391         }
 392 }
 393 int pl_getcomment(Hglob *g){
 394         int c;
 395         if((c=pl_nextc(g))=='-' && (c=pl_nextc(g))=='-'){
 396                 /* <!-- eats everything until --> or EOF */
 397                 for(;;){
 398                         while((c=pl_nextc(g))!='-' && c!=EOF)
 399                                 ;
 400                         if(c==EOF)
 401                                 break;
 402                         if((c=pl_nextc(g))=='-'){
 403                                 while((c=pl_nextc(g))=='-')
 404                                         ;
 405                                 if(c==ETAG || c==EOF)
 406                                         break;
 407                         }
 408                 }
 409         } else {
 410                 /* <! eats everything until > or EOF */
 411                 while(c!=ETAG && c!=EOF)
 412                         c=pl_nextc(g);
 413         }
 414         if(c==EOF)
 415                 htmlerror(g->name, g->lineno, "EOF in comment");
 416         g->tag=Tag_comment;
 417         g->attr->name=0;
 418         g->token[0]='\0';
 419         return TAG;
 420 }
 421 int lrunetochar(char *p, int v)
 422 {
 423         Rune r;
 424
 425         r=v;
 426         return runetochar(p, &r);
 427 }
 428
 429 /*
 430  * Read a start or end tag -- the caller has read the initial <
 431  */
 432 int pl_gettag(Hglob *g){
 433         char *tokp;
 434         int c;
 435         tokp=g->token;
 436         if((c=pl_nextc(g))=='!' || c=='?')
 437                 return pl_getcomment(g);
 438         pl_putback(g, c);
 439         while((c=pl_nextc(g))!=ETAG && c!=EOF)
 440                 if(tokp!=&g->token[NTOKEN-3]) tokp += lrunetochar(tokp, c);
 441         *tokp='\0';
 442         if(c==EOF) htmlerror(g->name, g->lineno, "EOF in tag");
 443         pl_tagparse(g, g->token);
 444         if(g->token[0]!='/') return TAG;
 445         if(g->attr[0].name!=0)
 446                 htmlerror(g->name, g->lineno, "end tag should not have attributes");
 447         return ENDTAG;
 448 }
 449 /*
 450  * The next token is a tag, an end tag or a sequence of
 451  * non-white characters.
 452  * If inside <pre>, newlines are converted to <br> and spaces are preserved.
 453  * Otherwise, spaces and newlines are noted and discarded.
 454  */
 455 int pl_gettoken(Hglob *g){
 456         char *tokp;
 457         int c;
 458         if(g->state->pre) switch(c=pl_nextc(g)){
 459         case STAG: return pl_gettag(g);
 460         case EOF: return EOF;
 461         case '\n':
 462                 pl_tagparse(g, "br");
 463                 return TAG;
 464         default:
 465                 tokp=g->token;
 466                 while(c=='\t'){
 467                         if(tokp!=&g->token[NTOKEN-3]) tokp += lrunetochar(tokp, c);
 468                         c=pl_nextc(g);
 469                 }
 470                 while(c!='\t' && c!='\n' && c!=STAG && c!=EOF){
 471                         if(c==ETAG) c='>';
 472                         if(tokp!=&g->token[NTOKEN-3]) tokp += lrunetochar(tokp, c);
 473                         c=pl_nextc(g);
 474                 }
 475                 *tokp='\0';
 476                 pl_rmentities(g, g->token);
 477                 pl_putback(g, c);
 478                 g->nsp=0;
 479                 g->spacc=0;
 480                 return TEXT;
 481         }
 482         while((c=pl_nextc(g))==' ' || c=='\t' || c=='\n')
 483                 if(g->spacc!=-1)
 484                         g->spacc++;
 485         switch(c){
 486         case STAG: return pl_gettag(g);
 487         case EOF: return EOF;
 488         default:
 489                 tokp=g->token;
 490                 do{
 491                         if(c==ETAG) c='>';
 492                         if(tokp!=&g->token[NTOKEN-3]) tokp += lrunetochar(tokp, c);
 493                         c=pl_nextc(g);
 494                 }while(c!=' ' && c!='\t' && c!='\n' && c!=STAG && c!=EOF);
 495                 *tokp='\0';
 496                 pl_rmentities(g, g->token);
 497                 pl_putback(g, c);
 498                 g->nsp=g->spacc;
 499                 g->spacc=0;
 500                 return TEXT;
 501         }
 502 }
 503 char *pl_getattr(Pair *attr, char *name){
 504         for(;attr->name;attr++)
 505                 if(strcmp(attr->name, name)==0)
 506                         return attr->value;
 507         return 0;
 508 }
 509 int pl_hasattr(Pair *attr, char *name){
 510         for(;attr->name;attr++)
 511                 if(strcmp(attr->name, name)==0)
 512                         return 1;
 513         return 0;
 514 }
 515 void plaintext(Hglob *g){
 516         char line[NLINE];
 517         char *lp, *elp;
 518         int c;
 519         g->state->font=CWIDTH;
 520         g->state->size=NORMAL;
 521         elp=&line[NLINE+1];
 522         lp=line;
 523         for(;;){
 524                 c=pl_readc(g);
 525                 if(c==EOF) break;
 526                 if(c=='\n' || lp==elp){
 527                         *lp='\0';
 528                         g->linebrk=1;
 529                         pl_htmloutput(g, 0, line, 0);
 530                         lp=line;
 531                 }
 532                 if(c=='\t'){
 533                         do *lp++=' '; while(lp!=elp && utfnlen(line, lp-line)%8!=0);
 534                 }
 535                 else if(c!='\n')
 536                         lp += lrunetochar(lp, c);
 537         }
 538         if(lp!=line){
 539                 *lp='\0';
 540                 g->linebrk=1;
 541                 pl_htmloutput(g, 0, line, 0);
 542         }
 543 }
 544 void plrdplain(char *name, int fd, Www *dst){
 545         Hglob g;
 546         g.state=g.stack;
 547         g.state->tag=Tag_html;
 548         g.state->font=CWIDTH;
 549         g.state->size=NORMAL;
 550         g.state->pre=0;
 551         g.state->image[0]=0;
 552         g.state->link[0]=0;
 553         g.state->name[0]=0;
 554         g.state->margin=0;
 555         g.state->indent=20;
 556         g.state->ismap=0;
 557         g.state->table=0;
 558         g.dst=dst;
 559         g.hfd=fd;
 560         g.name=name;
 561         g.ehbuf=g.hbufp=g.hbuf;
 562         g.npeekc=0;
 563         g.heof=0;
 564         g.lineno=1;
 565         g.linebrk=1;
 566         g.para=0;
 567         g.text=dst->title;
 568         g.tp=g.text;
 569         g.etext=g.text+NTITLE-1;
 570         g.spacc=0;
 571         g.form=0;
 572         strncpy(g.text, name, NTITLE);
 573         plaintext(&g);
 574         dst->finished=1;
 575 }
 576 void plrdhtml(char *name, int fd, Www *dst){
 577         Stack *sp;
 578         char buf[20];
 579         char *str;
 580         Hglob g;
 581         int t;
 582         int tagerr;
 583         g.state=g.stack;
 584         g.state->tag=Tag_html;
 585         g.state->font=ROMAN;
 586         g.state->size=NORMAL;
 587         g.state->pre=0;
 588         g.state->image[0]=0;
 589         g.state->link[0]=0;
 590         g.state->name[0]=0;
 591         g.state->margin=0;
 592         g.state->indent=25;
 593         g.state->ismap=0;
 594         g.state->width=0;
 595         g.state->height=0;
 596         g.state->table=0;
 597         g.dst=dst;
 598         g.hfd=fd;
 599         g.name=name;
 600         g.ehbuf=g.hbufp=g.hbuf;
 601         g.npeekc=0;
 602         g.heof=0;
 603         g.lineno=1;
 604         g.linebrk=1;
 605         g.para=0;
 606         g.text=dst->title;
 607         g.tp=g.text;
 608         g.etext=g.text+NTITLE-1;
 609         dst->title[0]='\0';
 610         g.spacc=0;
 611         g.form=0;
 612
 613         for(;;) switch(pl_gettoken(&g)){
 614         case TAG:
 615                 switch(tag[g.tag].action){
 616                 case OPTEND:
 617                         for(sp=g.state;sp!=g.stack && sp->tag!=g.tag;--sp);
 618                         if(sp->tag!=g.tag)
 619                                 pl_pushstate(&g, g.tag);
 620                         else
 621                                 for(;g.state!=sp;--g.state)
 622                                         if(tag[g.state->tag].action!=OPTEND)
 623                                                 htmlerror(g.name, g.lineno,
 624                                                         "end tag </%s> missing",
 625                                                         tag[g.state->tag].name);
 626                         break;
 627                 case END:
 628                         pl_pushstate(&g, g.tag);
 629                         break;
 630                 }
 631                 switch(g.tag){
 632                 default:
 633                         htmlerror(g.name, g.lineno,
 634                                 "unimplemented tag <%s>", tag[g.tag].name);
 635                         break;
 636                 case Tag_end:   /* unrecognized start tag */
 637                         break;
 638                 case Tag_meta:
 639                         break;
 640                 case Tag_img:
 641                         if(str=pl_getattr(g.attr, "src"))
 642                                 strncpy(g.state->image, str, sizeof(g.state->image));
 643                         g.state->ismap=pl_hasattr(g.attr, "ismap");
 644                         if(str=pl_getattr(g.attr, "width"))
 645                                 g.state->width = strtolength(&g, HORIZ, str);
 646                         if(str=pl_getattr(g.attr, "height"))
 647                                 g.state->height = strtolength(&g, VERT, str);
 648                         str=pl_getattr(g.attr, "alt");
 649                         if(str==0){
 650                                 if(g.state->image[0])
 651                                         str=g.state->image;
 652                                 else
 653                                         str="[[image]]";
 654                         }
 655                         pl_htmloutput(&g, 0, str, 0);
 656                         g.state->image[0]=0;
 657                         g.state->ismap=0;
 658                         g.state->width=0;
 659                         g.state->height=0;
 660                         break;
 661                 case Tag_plaintext:
 662                         g.spacc=0;
 663                         plaintext(&g);
 664                         break;
 665                 case Tag_comment:
 666                 case Tag_html:
 667                 case Tag_link:
 668                 case Tag_nextid:
 669                         break;
 670                 case Tag_table:
 671                         g.state->table++;
 672                         break;
 673                 case Tag_tr:
 674                         if(g.state->table==1){
 675                                 g.spacc=0;
 676                                 g.linebrk=1;
 677                         } else
 678                                 g.spacc++;
 679                         break;
 680                 case Tag_td:
 681                         g.spacc++;
 682                         break;
 683                 case Tag_a:
 684                         if(str=pl_getattr(g.attr, "href"))
 685                                 strncpy(g.state->link, str, sizeof(g.state->link));
 686                         if(str=pl_getattr(g.attr, "name")){
 687                                 strncpy(g.state->name, str, sizeof(g.state->name));
 688                                 pl_htmloutput(&g, 0, "", 0);
 689                         }
 690                         break;
 691                 case Tag_frame:
 692                         pl_htmloutput(&g, 0, "FRAME: ", 0);
 693                         if(str=pl_getattr(g.attr, "src"))
 694                                 strncpy(g.state->link, str, sizeof(g.state->link));
 695                         if(str=pl_getattr(g.attr, "name"))
 696                                 strncpy(g.state->name, str, sizeof(g.state->name));
 697                         else
 698                                 str = g.state->link;
 699                         pl_htmloutput(&g, 0, str, 0);
 700                         g.state->link[0]=0;
 701                         g.state->name[0] =0;
 702                         g.spacc=0;
 703                         g.linebrk=1;
 704                         break;
 705                 case Tag_address:
 706                         g.spacc=0;
 707                         g.linebrk=1;
 708                         g.state->font=ROMAN;
 709                         g.state->size=NORMAL;
 710                         g.state->margin=300;
 711                         g.state->indent=50;
 712                         break;
 713                 case Tag_b:
 714                 case Tag_strong:
 715                         g.state->font=BOLD;
 716                         break;
 717                 case Tag_blockquot:
 718                         g.spacc=0;
 719                         g.linebrk=1;
 720                         g.state->margin+=50;
 721                         g.state->indent=20;
 722                         break;
 723                 case Tag_body:
 724                         break;
 725                 case Tag_head:
 726                         g.state->font=ROMAN;
 727                         g.state->size=NORMAL;
 728                         g.state->margin=0;
 729                         g.state->indent=20;
 730                         g.spacc=0;
 731                         break;
 732                 case Tag_br:
 733                         g.spacc=0;
 734                         g.linebrk=1;
 735                         break;
 736                 case Tag_center:
 737                         /* more to come */
 738                         break;
 739                 case Tag_cite:
 740                         g.state->font=ITALIC;
 741                         g.state->size=NORMAL;
 742                         break;
 743                 case Tag_code:
 744                         g.state->font=CWIDTH;
 745                         g.state->size=NORMAL;
 746                         break;
 747                 case Tag_dd:
 748                         g.linebrk=1;
 749                         g.state->indent=0;
 750                         g.state->font=ROMAN;
 751                         g.spacc=0;
 752                         break;
 753                 case Tag_dfn:
 754                         htmlerror(g.name, g.lineno, "<dfn> deprecated");
 755                         g.state->font=BOLD;
 756                         g.state->size=NORMAL;
 757                         break;
 758                 case Tag_dl:
 759                         g.state->font=BOLD;
 760                         g.state->size=NORMAL;
 761                         g.state->margin+=40;
 762                         g.spacc=0;
 763                         break;
 764                 case Tag_dt:
 765                         g.para=1;
 766                         g.state->indent=-40;
 767                         g.state->font=BOLD;
 768                         g.spacc=0;
 769                         break;
 770                 case Tag_font:
 771                         /* more to come */
 772                         break;
 773                 case Tag_u:
 774                         htmlerror(g.name, g.lineno, "<u> deprecated");
 775                 case Tag_em:
 776                 case Tag_i:
 777                 case Tag_var:
 778                         g.state->font=ITALIC;
 779                         break;
 780                 case Tag_h1:
 781                         g.linebrk=1;
 782                         g.state->font=BOLD;
 783                         g.state->size=ENORMOUS;
 784                         g.state->margin+=100;
 785                         g.spacc=0;
 786                         break;
 787                 case Tag_h2:
 788                         pl_linespace(&g);
 789                         g.state->font=BOLD;
 790                         g.state->size=ENORMOUS;
 791                         g.spacc=0;
 792                         break;
 793                 case Tag_h3:
 794                         g.linebrk=1;
 795                         pl_linespace(&g);
 796                         g.state->font=ITALIC;
 797                         g.state->size=ENORMOUS;
 798                         g.state->margin+=20;
 799                         g.spacc=0;
 800                         break;
 801                 case Tag_h4:
 802                         pl_linespace(&g);
 803                         g.state->font=BOLD;
 804                         g.state->size=LARGE;
 805                         g.state->margin+=10;
 806                         g.spacc=0;
 807                         break;
 808                 case Tag_h5:
 809                         pl_linespace(&g);
 810                         g.state->font=ITALIC;
 811                         g.state->size=LARGE;
 812                         g.state->margin+=10;
 813                         g.spacc=0;
 814                         break;
 815                 case Tag_h6:
 816                         pl_linespace(&g);
 817                         g.state->font=BOLD;
 818                         g.state->size=LARGE;
 819                         g.spacc=0;
 820                         break;
 821                 case Tag_hr:
 822                         g.spacc=0;
 823                         plrtbitmap(&g.dst->text, 1000000, g.state->margin, hrule, 0, 0);
 824                         break;
 825                 case Tag_key:
 826                         htmlerror(g.name, g.lineno, "<key> deprecated");
 827                 case Tag_kbd:
 828                         g.state->font=CWIDTH;
 829                         break;
 830                 case Tag_dir:
 831                 case Tag_menu:
 832                 case Tag_ol:
 833                 case Tag_ul:
 834                         g.state->number=0;
 835                         g.linebrk=1;
 836                         g.state->margin+=25;
 837                         g.state->indent=-25;
 838                         g.spacc=0;
 839                         break;
 840                 case Tag_li:
 841                         g.spacc=0;
 842                         switch(g.state->tag){
 843                         default:
 844                                 htmlerror(g.name, g.lineno, "can't have <li> in <%s>",
 845                                         tag[g.state->tag].name);
 846                         case Tag_dir:   /* supposed to be multi-columns, can't do! */
 847                         case Tag_menu:
 848                                 g.linebrk=1;
 849                                 break;
 850                         case Tag_ol:
 851                                 g.para=1;
 852                                 snprint(buf, sizeof(buf), "%2d  ", ++g.state->number);
 853                                 pl_htmloutput(&g, 0, buf, 0);
 854                                 break;
 855                         case Tag_ul:
 856                                 g.para=0;
 857                                 g.linebrk=0;
 858                                 g.spacc=-1;
 859                                 plrtbitmap(&g.dst->text, 100000,
 860                                         g.state->margin+g.state->indent, bullet, 0, 0);
 861                                 break;
 862                         }
 863                         break;
 864                 case Tag_p:
 865                         pl_linespace(&g);
 866                         g.linebrk=1;
 867                         g.spacc=0;
 868                         break;
 869                 case Tag_listing:
 870                 case Tag_xmp:
 871                         htmlerror(g.name, g.lineno, "<%s> deprecated", tag[g.tag].name);
 872                 case Tag_pre:
 873                 case Tag_samp:
 874                         g.state->indent=0;
 875                         g.state->pre=1;
 876                         g.state->font=CWIDTH;
 877                         g.state->size=NORMAL;
 878                         pl_linespace(&g);
 879                         break;
 880                 case Tag_tt:
 881                         g.state->font=CWIDTH;
 882                         g.state->size=NORMAL;
 883                         break;
 884                 case Tag_title:
 885                         g.text=dst->title+strlen(dst->title);
 886                         g.tp=g.text;
 887                         g.etext=dst->title+NTITLE-1;
 888                         break;
 889                 case Tag_form:
 890                 case Tag_input:
 891                 case Tag_button:
 892                 case Tag_select:
 893                 case Tag_option:
 894                 case Tag_textarea:
 895                 case Tag_isindex:
 896                         rdform(&g);
 897                         break;
 898                 case Tag_script:
 899                 case Tag_style:
 900                         /*
 901                          * ignore the content of these tags, eat tokens until we
 902                          * reach a matching endtag.
 903                          */
 904                         t = g.tag;
 905                         for(;;){
 906                                 switch(pl_gettoken(&g)){
 907                                 default:
 908                                         continue;
 909                                 case ENDTAG:
 910                                         if(g.tag != t)
 911                                                 continue;
 912                                 case EOF:
 913                                         break;
 914                                 }
 915                                 break;
 916                         }
 917                         break;
 918                 }
 919                 break;
 920
 921         case ENDTAG:
 922                 /*
 923                  * If the end tag doesn't match the top, we try to uncover a match
 924                  * on the stack.
 925                  */
 926                 if(g.state->tag!=g.tag){
 927                         tagerr=0;
 928                         for(sp=g.state;sp!=g.stack;--sp){
 929                                 if(sp->tag==g.tag)
 930                                         break;
 931                                 if(tag[g.state->tag].action!=OPTEND) tagerr++;
 932                         }
 933                         if(sp==g.stack){
 934                                 if(tagerr)
 935                                         htmlerror(g.name, g.lineno,
 936                                                 "end tag mismatch <%s>...</%s>, ignored",
 937                                                 tag[g.state->tag].name, tag[g.tag].name);
 938                         }
 939                         else{
 940                                 if(tagerr)
 941                                         htmlerror(g.name, g.lineno,
 942                                                 "end tag mismatch <%s>...</%s>, "
 943                                                 "intervening tags popped",
 944                                                 tag[g.state->tag].name, tag[g.tag].name);
 945                                 g.state=sp-1;
 946                         }
 947                 }
 948                 else if(g.state==g.stack)
 949                         htmlerror(g.name, g.lineno, "end tag </%s> at stack bottom",
 950                                 tag[g.tag].name);
 951                 else
 952                         --g.state;
 953                 switch(g.tag){
 954                 case Tag_select:
 955                 case Tag_form:
 956                 case Tag_textarea:
 957                         endform(&g);
 958                         break;
 959                 case Tag_h1:
 960                 case Tag_h2:
 961                 case Tag_h3:
 962                 case Tag_h4:
 963                         pl_linespace(&g);
 964                         break;
 965                 case Tag_address:
 966                 case Tag_blockquot:
 967                 case Tag_body:
 968                 case Tag_dir:
 969                 case Tag_dl:
 970                 case Tag_dt:
 971                 case Tag_h5:
 972                 case Tag_h6:
 973                 case Tag_listing:
 974                 case Tag_menu:
 975                 case Tag_ol:
 976                 case Tag_samp:
 977                 case Tag_title:
 978                 case Tag_ul:
 979                 case Tag_xmp:
 980                         g.linebrk=1;
 981                         break;
 982                 case Tag_table:
 983                         if(g.state->table==0)
 984                                 g.linebrk=1;
 985                         break;
 986                 case Tag_pre:
 987                         pl_linespace(&g);
 988                         break;
 989                 }
 990                 break;
 991         case TEXT:
 992                 pl_htmloutput(&g, g.nsp, g.token, 0);
 993                 break;
 994         case EOF:
 995                 for(;g.state!=g.stack;--g.state)
 996                         if(tag[g.state->tag].action!=OPTEND)
 997                                 htmlerror(g.name, g.lineno,
 998                                         "missing </%s> at EOF", tag[g.state->tag].name);
 999                 *g.tp='\0';
1000                 dst->changed=1;
1001                 getpix(dst->text, dst);
1002                 dst->finished=1;
1003                 return;
1004         }
1005 }