Graphviz  2.41.20170921.2350
htmlparse.c
Go to the documentation of this file.
1 /* A Bison parser, made by GNU Bison 2.7. */
2 
3 /* Bison implementation for Yacc-like parsers in C
4 
5  Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation, Inc.
6 
7  This program is free software: you can redistribute it and/or modify
8  it under the terms of the GNU General Public License as published by
9  the Free Software Foundation, either version 3 of the License, or
10  (at your option) any later version.
11 
12  This program is distributed in the hope that it will be useful,
13  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  GNU General Public License for more details.
16 
17  You should have received a copy of the GNU General Public License
18  along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 
20 /* As a special exception, you may create a larger work that contains
21  part or all of the Bison parser skeleton and distribute that work
22  under terms of your choice, so long as that work isn't itself a
23  parser generator using the skeleton or a modified version thereof
24  as a parser skeleton. Alternatively, if you modify or redistribute
25  the parser skeleton itself, you may (at your option) remove this
26  special exception, which will cause the skeleton and the resulting
27  Bison output files to be licensed under the GNU General Public
28  License without this special exception.
29 
30  This special exception was added by the Free Software Foundation in
31  version 2.2 of Bison. */
32 
33 /* C LALR(1) parser skeleton written by Richard Stallman, by
34  simplifying the original so-called "semantic" parser. */
35 
36 /* All symbols defined below should begin with html or YY, to avoid
37  infringing on user name space. This should be done even for local
38  variables, as they might otherwise be expanded by user macros.
39  There are some unavoidable exceptions within include files to
40  define necessary library symbols; they are noted "INFRINGES ON
41  USER NAME SPACE" below. */
42 
43 /* Identify Bison output. */
44 #define YYBISON 1
45 
46 /* Bison version. */
47 #define YYBISON_VERSION "2.7"
48 
49 /* Skeleton name. */
50 #define YYSKELETON_NAME "yacc.c"
51 
52 /* Pure parsers. */
53 #define YYPURE 0
54 
55 /* Push parsers. */
56 #define YYPUSH 0
57 
58 /* Pull parsers. */
59 #define YYPULL 1
60 
61 
62 
63 
64 /* Copy the first part of user declarations. */
65 /* Line 371 of yacc.c */
66 #line 14 "../../lib/common/htmlparse.y"
67 
68 
69 #include "render.h"
70 #include "htmltable.h"
71 #include "htmllex.h"
72 
73 extern int htmlparse(void);
74 
75 typedef struct sfont_t {
77  struct sfont_t *pfont;
78 } sfont_t;
79 
80 static struct {
81  htmllabel_t* lbl; /* Generated label */
82  htmltbl_t* tblstack; /* Stack of tables maintained during parsing */
83  Dt_t* fitemList; /* Dictionary for font text items */
85  agxbuf* str; /* Buffer for text */
88 } HTMLstate;
89 
90 /* free_ritem:
91  * Free row. This closes and frees row's list, then
92  * the pitem itself is freed.
93  */
94 static void
95 free_ritem(Dt_t* d, pitem* p,Dtdisc_t* ds)
96 {
97  dtclose (p->u.rp);
98  free (p);
99 }
100 
101 /* free_item:
102  * Generic Dt free. Only frees container, assuming contents
103  * have been copied elsewhere.
104  */
105 static void
106 free_item(Dt_t* d, void* p,Dtdisc_t* ds)
107 {
108  free (p);
109 }
110 
111 /* cleanTbl:
112  * Clean up table if error in parsing.
113  */
114 static void
115 cleanTbl (htmltbl_t* tp)
116 {
117  dtclose (tp->u.p.rows);
118  free_html_data (&tp->data);
119  free (tp);
120 }
121 
122 /* cleanCell:
123  * Clean up cell if error in parsing.
124  */
125 static void
126 cleanCell (htmlcell_t* cp)
127 {
128  if (cp->child.kind == HTML_TBL) cleanTbl (cp->child.u.tbl);
129  else if (cp->child.kind == HTML_TEXT) free_html_text (cp->child.u.txt);
130  free_html_data (&cp->data);
131  free (cp);
132 }
133 
134 /* free_citem:
135  * Free cell item during parsing. This frees cell and pitem.
136  */
137 static void
138 free_citem(Dt_t* d, pitem* p,Dtdisc_t* ds)
139 {
140  cleanCell (p->u.cp);
141  free (p);
142 }
143 
144 static Dtdisc_t rowDisc = {
145  offsetof(pitem,u),
146  sizeof(void*),
147  offsetof(pitem,link),
148  NIL(Dtmake_f),
149  (Dtfree_f)free_ritem,
150  NIL(Dtcompar_f),
151  NIL(Dthash_f),
152  NIL(Dtmemory_f),
153  NIL(Dtevent_f)
154 };
155 static Dtdisc_t cellDisc = {
156  offsetof(pitem,u),
157  sizeof(void*),
158  offsetof(pitem,link),
159  NIL(Dtmake_f),
160  (Dtfree_f)free_item,
161  NIL(Dtcompar_f),
162  NIL(Dthash_f),
163  NIL(Dtmemory_f),
164  NIL(Dtevent_f)
165 };
166 
167 typedef struct {
170 } fitem;
171 
172 typedef struct {
175 } fspan;
176 
177 static void
178 free_fitem(Dt_t* d, fitem* p, Dtdisc_t* ds)
179 {
180  if (p->ti.str)
181  free (p->ti.str);
182  free (p);
183 }
184 
185 static void
186 free_fspan(Dt_t* d, fspan* p, Dtdisc_t* ds)
187 {
188  textspan_t* ti;
189 
190  if (p->lp.nitems) {
191  int i;
192  ti = p->lp.items;
193  for (i = 0; i < p->lp.nitems; i++) {
194  if (ti->str) free (ti->str);
195  ti++;
196  }
197  free (p->lp.items);
198  }
199  free (p);
200 }
201 
202 static Dtdisc_t fstrDisc = {
203  0,
204  0,
205  offsetof(fitem,link),
206  NIL(Dtmake_f),
207  (Dtfree_f)free_item,
208  NIL(Dtcompar_f),
209  NIL(Dthash_f),
210  NIL(Dtmemory_f),
211  NIL(Dtevent_f)
212 };
213 
214 
215 static Dtdisc_t fspanDisc = {
216  0,
217  0,
218  offsetof(fspan,link),
219  NIL(Dtmake_f),
220  (Dtfree_f)free_item,
221  NIL(Dtcompar_f),
222  NIL(Dthash_f),
223  NIL(Dtmemory_f),
224  NIL(Dtevent_f)
225 };
226 
227 /* appendFItemList:
228  * Append a new fitem to the list.
229  */
230 static void
231 appendFItemList (agxbuf *ag)
232 {
233  fitem *fi = NEW(fitem);
234 
235  fi->ti.str = strdup(agxbuse(ag));
236  fi->ti.font = HTMLstate.fontstack->cfont;
237  dtinsert(HTMLstate.fitemList, fi);
238 }
239 
240 /* appendFLineList:
241  */
242 static void
243 appendFLineList (int v)
244 {
245  int cnt;
246  fspan *ln = NEW(fspan);
247  fitem *fi;
248  Dt_t *ilist = HTMLstate.fitemList;
249 
250  cnt = dtsize(ilist);
251  ln->lp.just = v;
252  if (cnt) {
253  int i = 0;
254  ln->lp.nitems = cnt;
255  ln->lp.items = N_NEW(cnt, textspan_t);
256 
257  fi = (fitem*)dtflatten(ilist);
258  for (; fi; fi = (fitem*)dtlink(fitemList,(Dtlink_t*)fi)) {
259  /* NOTE: When fitemList is closed, it uses free_item, which only frees the container,
260  * not the contents, so this copy is safe.
261  */
262  ln->lp.items[i] = fi->ti;
263  i++;
264  }
265  }
266  else {
267  ln->lp.items = NEW(textspan_t);
268  ln->lp.nitems = 1;
269  ln->lp.items[0].str = strdup("");
270  ln->lp.items[0].font = HTMLstate.fontstack->cfont;
271  }
272 
273  dtclear(ilist);
274 
275  dtinsert(HTMLstate.fspanList, ln);
276 }
277 
278 static htmltxt_t*
279 mkText(void)
280 {
281  int cnt;
282  Dt_t * ispan = HTMLstate.fspanList;
283  fspan *fl ;
284  htmltxt_t *hft = NEW(htmltxt_t);
285 
286  if (dtsize (HTMLstate.fitemList))
287  appendFLineList (UNSET_ALIGN);
288 
289  cnt = dtsize(ispan);
290  hft->nspans = cnt;
291 
292  if (cnt) {
293  int i = 0;
294  hft->spans = N_NEW(cnt,htextspan_t);
295  for(fl=(fspan *)dtfirst(ispan); fl; fl=(fspan *)dtnext(ispan,fl)) {
296  hft->spans[i] = fl->lp;
297  i++;
298  }
299  }
300 
301  dtclear(ispan);
302 
303  return hft;
304 }
305 
306 static pitem* lastRow (void)
307 {
308  htmltbl_t* tbl = HTMLstate.tblstack;
309  pitem* sp = dtlast (tbl->u.p.rows);
310  return sp;
311 }
312 
313 /* addRow:
314  * Add new cell row to current table.
315  */
316 static pitem* addRow (void)
317 {
318  Dt_t* dp = dtopen(&cellDisc, Dtqueue);
319  htmltbl_t* tbl = HTMLstate.tblstack;
320  pitem* sp = NEW(pitem);
321  sp->u.rp = dp;
322  if (tbl->flags & HTML_HRULE)
323  sp->ruled = 1;
324  dtinsert (tbl->u.p.rows, sp);
325  return sp;
326 }
327 
328 /* setCell:
329  * Set cell body and type and attach to row
330  */
331 static void setCell (htmlcell_t* cp, void* obj, int kind)
332 {
333  pitem* sp = NEW(pitem);
334  htmltbl_t* tbl = HTMLstate.tblstack;
335  pitem* rp = (pitem*)dtlast (tbl->u.p.rows);
336  Dt_t* row = rp->u.rp;
337  sp->u.cp = cp;
338  dtinsert (row, sp);
339  cp->child.kind = kind;
340  if (tbl->flags & HTML_VRULE)
341  cp->ruled = HTML_VRULE;
342 
343  if(kind == HTML_TEXT)
344  cp->child.u.txt = (htmltxt_t*)obj;
345  else if (kind == HTML_IMAGE)
346  cp->child.u.img = (htmlimg_t*)obj;
347  else
348  cp->child.u.tbl = (htmltbl_t*)obj;
349 }
350 
351 /* mkLabel:
352  * Create label, given body and type.
353  */
354 static htmllabel_t* mkLabel (void* obj, int kind)
355 {
356  htmllabel_t* lp = NEW(htmllabel_t);
357 
358  lp->kind = kind;
359  if (kind == HTML_TEXT)
360  lp->u.txt = (htmltxt_t*)obj;
361  else
362  lp->u.tbl = (htmltbl_t*)obj;
363  return lp;
364 }
365 
366 /* freeFontstack:
367  * Free all stack items but the last, which is
368  * put on artificially during in parseHTML.
369  */
370 static void
371 freeFontstack(void)
372 {
373  sfont_t* s;
374  sfont_t* next;
375 
376  for (s = HTMLstate.fontstack; (next = s->pfont); s = next) {
377  free(s);
378  }
379 }
380 
381 /* cleanup:
382  * Called on error. Frees resources allocated during parsing.
383  * This includes a label, plus a walk down the stack of
384  * tables. Note that we use the free_citem function to actually
385  * free cells.
386  */
387 static void cleanup (void)
388 {
389  htmltbl_t* tp = HTMLstate.tblstack;
390  htmltbl_t* next;
391 
392  if (HTMLstate.lbl) {
393  free_html_label (HTMLstate.lbl,1);
394  HTMLstate.lbl = NULL;
395  }
396  cellDisc.freef = (Dtfree_f)free_citem;
397  while (tp) {
398  next = tp->u.p.prev;
399  cleanTbl (tp);
400  tp = next;
401  }
402  cellDisc.freef = (Dtfree_f)free_item;
403 
404  fstrDisc.freef = (Dtfree_f)free_fitem;
405  dtclear (HTMLstate.fitemList);
406  fstrDisc.freef = (Dtfree_f)free_item;
407 
408  fspanDisc.freef = (Dtfree_f)free_fspan;
409  dtclear (HTMLstate.fspanList);
410  fspanDisc.freef = (Dtfree_f)free_item;
411 
412  freeFontstack();
413 }
414 
415 /* nonSpace:
416  * Return 1 if s contains a non-space character.
417  */
418 static int nonSpace (char* s)
419 {
420  char c;
421 
422  while ((c = *s++)) {
423  if (c != ' ') return 1;
424  }
425  return 0;
426 }
427 
428 /* pushFont:
429  * Fonts are allocated in the lexer.
430  */
431 static void
432 pushFont (textfont_t *fp)
433 {
434  sfont_t *ft = NEW(sfont_t);
435  textfont_t* curfont = HTMLstate.fontstack->cfont;
436  textfont_t f = *fp;
437 
438  if (curfont) {
439  if (!f.color && curfont->color)
440  f.color = curfont->color;
441  if ((f.size < 0.0) && (curfont->size >= 0.0))
442  f.size = curfont->size;
443  if (!f.name && curfont->name)
444  f.name = curfont->name;
445  if (curfont->flags)
446  f.flags |= curfont->flags;
447  }
448 
449  ft->cfont = dtinsert(HTMLstate.gvc->textfont_dt, &f);
450  ft->pfont = HTMLstate.fontstack;
451  HTMLstate.fontstack = ft;
452 }
453 
454 /* popFont:
455  */
456 static void
457 popFont (void)
458 {
459  sfont_t* curfont = HTMLstate.fontstack;
460  sfont_t* prevfont = curfont->pfont;
461 
462  free (curfont);
463  HTMLstate.fontstack = prevfont;
464 }
465 
466 
467 /* Line 371 of yacc.c */
468 #line 469 "y.tab.c"
469 
470 # ifndef YY_NULL
471 # if defined __cplusplus && 201103L <= __cplusplus
472 # define YY_NULL nullptr
473 # else
474 # define YY_NULL 0
475 # endif
476 # endif
477 
478 /* Enabling verbose error messages. */
479 #ifdef YYERROR_VERBOSE
480 # undef YYERROR_VERBOSE
481 # define YYERROR_VERBOSE 1
482 #else
483 # define YYERROR_VERBOSE 0
484 #endif
485 
486 /* In a future release of Bison, this section will be replaced
487  by #include "y.tab.h". */
488 #ifndef YY_YY_Y_TAB_H_INCLUDED
489 # define YY_YY_Y_TAB_H_INCLUDED
490 /* Enabling traces. */
491 #ifndef YYDEBUG
492 # define YYDEBUG 0
493 #endif
494 #if YYDEBUG
495 extern int htmldebug;
496 #endif
497 
498 /* Tokens. */
499 #ifndef YYTOKENTYPE
500 # define YYTOKENTYPE
501  /* Put the tokens into the symbol table, so that GDB and other debuggers
502  know about them. */
504  T_end_br = 258,
505  T_end_img = 259,
506  T_row = 260,
507  T_end_row = 261,
508  T_html = 262,
509  T_end_html = 263,
510  T_end_table = 264,
511  T_end_cell = 265,
512  T_end_font = 266,
513  T_string = 267,
514  T_error = 268,
515  T_n_italic = 269,
516  T_n_bold = 270,
519  T_n_sup = 273,
520  T_n_sub = 274,
521  T_n_s = 275,
522  T_HR = 276,
523  T_hr = 277,
524  T_end_hr = 278,
525  T_VR = 279,
526  T_vr = 280,
527  T_end_vr = 281,
528  T_BR = 282,
529  T_br = 283,
530  T_IMG = 284,
531  T_img = 285,
532  T_table = 286,
533  T_cell = 287,
534  T_font = 288,
535  T_italic = 289,
536  T_bold = 290,
537  T_underline = 291,
538  T_overline = 292,
539  T_sup = 293,
540  T_sub = 294,
541  T_s = 295
542  };
543 #endif
544 /* Tokens. */
545 #define T_end_br 258
546 #define T_end_img 259
547 #define T_row 260
548 #define T_end_row 261
549 #define T_html 262
550 #define T_end_html 263
551 #define T_end_table 264
552 #define T_end_cell 265
553 #define T_end_font 266
554 #define T_string 267
555 #define T_error 268
556 #define T_n_italic 269
557 #define T_n_bold 270
558 #define T_n_underline 271
559 #define T_n_overline 272
560 #define T_n_sup 273
561 #define T_n_sub 274
562 #define T_n_s 275
563 #define T_HR 276
564 #define T_hr 277
565 #define T_end_hr 278
566 #define T_VR 279
567 #define T_vr 280
568 #define T_end_vr 281
569 #define T_BR 282
570 #define T_br 283
571 #define T_IMG 284
572 #define T_img 285
573 #define T_table 286
574 #define T_cell 287
575 #define T_font 288
576 #define T_italic 289
577 #define T_bold 290
578 #define T_underline 291
579 #define T_overline 292
580 #define T_sup 293
581 #define T_sub 294
582 #define T_s 295
583 
584 
585 
586 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
587 typedef union YYSTYPE
588 {
589 /* Line 387 of yacc.c */
590 #line 415 "../../lib/common/htmlparse.y"
591 
592  int i;
599 
600 
601 /* Line 387 of yacc.c */
602 #line 603 "y.tab.c"
603 } YYSTYPE;
604 # define YYSTYPE_IS_TRIVIAL 1
605 # define htmlstype YYSTYPE /* obsolescent; will be withdrawn */
606 # define YYSTYPE_IS_DECLARED 1
607 #endif
608 
609 extern YYSTYPE htmllval;
610 
611 #ifdef YYPARSE_PARAM
612 #if defined __STDC__ || defined __cplusplus
613 int htmlparse (void *YYPARSE_PARAM);
614 #else
615 int htmlparse ();
616 #endif
617 #else /* ! YYPARSE_PARAM */
618 #if defined __STDC__ || defined __cplusplus
619 int htmlparse (void);
620 #else
621 int htmlparse ();
622 #endif
623 #endif /* ! YYPARSE_PARAM */
624 
625 #endif /* !YY_YY_Y_TAB_H_INCLUDED */
626 
627 /* Copy the second part of user declarations. */
628 
629 /* Line 390 of yacc.c */
630 #line 631 "y.tab.c"
631 
632 #ifdef short
633 # undef short
634 #endif
635 
636 #ifdef YYTYPE_UINT8
637 typedef YYTYPE_UINT8 htmltype_uint8;
638 #else
639 typedef unsigned char htmltype_uint8;
640 #endif
641 
642 #ifdef YYTYPE_INT8
643 typedef YYTYPE_INT8 htmltype_int8;
644 #elif (defined __STDC__ || defined __C99__FUNC__ \
645  || defined __cplusplus || defined _MSC_VER)
646 typedef signed char htmltype_int8;
647 #else
648 typedef short int htmltype_int8;
649 #endif
650 
651 #ifdef YYTYPE_UINT16
652 typedef YYTYPE_UINT16 htmltype_uint16;
653 #else
654 typedef unsigned short int htmltype_uint16;
655 #endif
656 
657 #ifdef YYTYPE_INT16
658 typedef YYTYPE_INT16 htmltype_int16;
659 #else
660 typedef short int htmltype_int16;
661 #endif
662 
663 #ifndef YYSIZE_T
664 # ifdef __SIZE_TYPE__
665 # define YYSIZE_T __SIZE_TYPE__
666 # elif defined size_t
667 # define YYSIZE_T size_t
668 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
669  || defined __cplusplus || defined _MSC_VER)
670 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
671 # define YYSIZE_T size_t
672 # else
673 # define YYSIZE_T unsigned int
674 # endif
675 #endif
676 
677 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
678 
679 #ifndef YY_
680 # if defined YYENABLE_NLS && YYENABLE_NLS
681 # if ENABLE_NLS
682 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
683 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
684 # endif
685 # endif
686 # ifndef YY_
687 # define YY_(Msgid) Msgid
688 # endif
689 #endif
690 
691 /* Suppress unused-variable warnings by "using" E. */
692 #if ! defined lint || defined __GNUC__
693 # define YYUSE(E) ((void) (E))
694 #else
695 # define YYUSE(E) /* empty */
696 #endif
697 
698 /* Identity function, used to suppress warnings about constant conditions. */
699 #ifndef lint
700 # define YYID(N) (N)
701 #else
702 #if (defined __STDC__ || defined __C99__FUNC__ \
703  || defined __cplusplus || defined _MSC_VER)
704 static int
705 YYID (int htmli)
706 #else
707 static int
708 YYID (htmli)
709  int htmli;
710 #endif
711 {
712  return htmli;
713 }
714 #endif
715 
716 #if ! defined htmloverflow || YYERROR_VERBOSE
717 
718 /* The parser invokes alloca or malloc; define the necessary symbols. */
719 
720 # ifdef YYSTACK_USE_ALLOCA
721 # if YYSTACK_USE_ALLOCA
722 # ifdef __GNUC__
723 # define YYSTACK_ALLOC __builtin_alloca
724 # elif defined __BUILTIN_VA_ARG_INCR
725 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
726 # elif defined _AIX
727 # define YYSTACK_ALLOC __alloca
728 # elif defined _MSC_VER
729 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
730 # define alloca _alloca
731 # else
732 # define YYSTACK_ALLOC alloca
733 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
734  || defined __cplusplus || defined _MSC_VER)
735 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
736  /* Use EXIT_SUCCESS as a witness for stdlib.h. */
737 # ifndef EXIT_SUCCESS
738 # define EXIT_SUCCESS 0
739 # endif
740 # endif
741 # endif
742 # endif
743 # endif
744 
745 # ifdef YYSTACK_ALLOC
746  /* Pacify GCC's `empty if-body' warning. */
747 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
748 # ifndef YYSTACK_ALLOC_MAXIMUM
749  /* The OS might guarantee only one guard page at the bottom of the stack,
750  and a page size can be as small as 4096 bytes. So we cannot safely
751  invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
752  to allow for a few compiler-allocated temporary stack slots. */
753 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
754 # endif
755 # else
756 # define YYSTACK_ALLOC YYMALLOC
757 # define YYSTACK_FREE YYFREE
758 # ifndef YYSTACK_ALLOC_MAXIMUM
759 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
760 # endif
761 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
762  && ! ((defined YYMALLOC || defined malloc) \
763  && (defined YYFREE || defined free)))
764 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
765 # ifndef EXIT_SUCCESS
766 # define EXIT_SUCCESS 0
767 # endif
768 # endif
769 # ifndef YYMALLOC
770 # define YYMALLOC malloc
771 # if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
772  || defined __cplusplus || defined _MSC_VER)
773 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
774 # endif
775 # endif
776 # ifndef YYFREE
777 # define YYFREE free
778 # if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
779  || defined __cplusplus || defined _MSC_VER)
780 void free (void *); /* INFRINGES ON USER NAME SPACE */
781 # endif
782 # endif
783 # endif
784 #endif /* ! defined htmloverflow || YYERROR_VERBOSE */
785 
786 
787 #if (! defined htmloverflow \
788  && (! defined __cplusplus \
789  || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
790 
791 /* A type that is properly aligned for any stack member. */
793 {
794  htmltype_int16 htmlss_alloc;
796 };
797 
798 /* The size of the maximum gap between one aligned stack and the next. */
799 # define YYSTACK_GAP_MAXIMUM (sizeof (union htmlalloc) - 1)
800 
801 /* The size of an array large to enough to hold all stacks, each with
802  N elements. */
803 # define YYSTACK_BYTES(N) \
804  ((N) * (sizeof (htmltype_int16) + sizeof (YYSTYPE)) \
805  + YYSTACK_GAP_MAXIMUM)
806 
807 # define YYCOPY_NEEDED 1
808 
809 /* Relocate STACK from its old location to the new one. The
810  local variables YYSIZE and YYSTACKSIZE give the old and new number of
811  elements in the stack, and YYPTR gives the new location of the
812  stack. Advance YYPTR to a properly aligned location for the next
813  stack. */
814 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
815  do \
816  { \
817  YYSIZE_T htmlnewbytes; \
818  YYCOPY (&htmlptr->Stack_alloc, Stack, htmlsize); \
819  Stack = &htmlptr->Stack_alloc; \
820  htmlnewbytes = htmlstacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
821  htmlptr += htmlnewbytes / sizeof (*htmlptr); \
822  } \
823  while (YYID (0))
824 
825 #endif
826 
827 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
828 /* Copy COUNT objects from SRC to DST. The source and destination do
829  not overlap. */
830 # ifndef YYCOPY
831 # if defined __GNUC__ && 1 < __GNUC__
832 # define YYCOPY(Dst, Src, Count) \
833  __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
834 # else
835 # define YYCOPY(Dst, Src, Count) \
836  do \
837  { \
838  YYSIZE_T htmli; \
839  for (htmli = 0; htmli < (Count); htmli++) \
840  (Dst)[htmli] = (Src)[htmli]; \
841  } \
842  while (YYID (0))
843 # endif
844 # endif
845 #endif /* !YYCOPY_NEEDED */
846 
847 /* YYFINAL -- State number of the termination state. */
848 #define YYFINAL 31
849 /* YYLAST -- Last index in YYTABLE. */
850 #define YYLAST 271
851 
852 /* YYNTOKENS -- Number of terminals. */
853 #define YYNTOKENS 41
854 /* YYNNTS -- Number of nonterminals. */
855 #define YYNNTS 39
856 /* YYNRULES -- Number of rules. */
857 #define YYNRULES 69
858 /* YYNRULES -- Number of states. */
859 #define YYNSTATES 116
860 
861 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
862 #define YYUNDEFTOK 2
863 #define YYMAXUTOK 295
864 
865 #define YYTRANSLATE(YYX) \
866  ((unsigned int) (YYX) <= YYMAXUTOK ? htmltranslate[YYX] : YYUNDEFTOK)
867 
868 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
869 static const htmltype_uint8 htmltranslate[] =
870 {
871  0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
872  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
873  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
874  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
875  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
876  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
877  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
878  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
879  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
880  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
881  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
882  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
883  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
884  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
885  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
886  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
887  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
888  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
889  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
890  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
891  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
892  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
893  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
894  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
895  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
896  2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
897  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
898  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
899  25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
900  35, 36, 37, 38, 39, 40
901 };
902 
903 #if YYDEBUG
904 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
905  YYRHS. */
906 static const htmltype_uint8 htmlprhs[] =
907 {
908  0, 0, 3, 7, 11, 13, 15, 18, 20, 22,
909  24, 28, 32, 36, 40, 44, 48, 52, 56, 58,
910  60, 62, 64, 66, 68, 70, 72, 74, 76, 78,
911  80, 82, 84, 86, 88, 91, 93, 95, 98, 99,
912  106, 108, 112, 116, 120, 124, 128, 130, 131, 133,
913  136, 140, 141, 146, 148, 151, 155, 156, 161, 162,
914  167, 168, 173, 174, 178, 181, 183, 186, 188, 191
915 };
916 
917 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
918 static const htmltype_int8 htmlrhs[] =
919 {
920  42, 0, -1, 7, 43, 8, -1, 7, 66, 8,
921  -1, 1, -1, 44, -1, 44, 45, -1, 45, -1,
922  63, -1, 62, -1, 46, 44, 47, -1, 48, 44,
923  49, -1, 54, 44, 55, -1, 56, 44, 57, -1,
924  50, 44, 51, -1, 58, 44, 59, -1, 60, 44,
925  61, -1, 52, 44, 53, -1, 33, -1, 11, -1,
926  34, -1, 14, -1, 35, -1, 15, -1, 40, -1,
927  20, -1, 36, -1, 16, -1, 37, -1, 17, -1,
928  38, -1, 18, -1, 39, -1, 19, -1, 28, 3,
929  -1, 27, -1, 12, -1, 63, 12, -1, -1, 67,
930  31, 65, 68, 9, 67, -1, 64, -1, 46, 64,
931  47, -1, 48, 64, 49, -1, 54, 64, 55, -1,
932  56, 64, 57, -1, 50, 64, 51, -1, 63, -1,
933  -1, 69, -1, 68, 69, -1, 68, 78, 69, -1,
934  -1, 5, 70, 71, 6, -1, 72, -1, 71, 72,
935  -1, 71, 79, 72, -1, -1, 32, 66, 73, 10,
936  -1, -1, 32, 43, 74, 10, -1, -1, 32, 77,
937  75, 10, -1, -1, 32, 76, 10, -1, 30, 4,
938  -1, 29, -1, 22, 23, -1, 21, -1, 25, 26,
939  -1, 24, -1
940 };
941 
942 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
943 static const htmltype_uint16 htmlrline[] =
944 {
945  0, 447, 447, 448, 449, 452, 455, 456, 459, 460,
946  461, 462, 463, 464, 465, 466, 467, 468, 471, 474,
947  477, 480, 483, 486, 489, 492, 495, 498, 501, 504,
948  507, 510, 513, 516, 519, 520, 523, 524, 527, 527,
949  548, 549, 550, 551, 552, 553, 556, 557, 560, 561,
950  562, 565, 565, 568, 569, 570, 573, 573, 574, 574,
951  575, 575, 576, 576, 579, 580, 583, 584, 587, 588
952 };
953 #endif
954 
955 #if YYDEBUG || YYERROR_VERBOSE || 0
956 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
957  First, the terminals, then, starting at YYNTOKENS, nonterminals. */
958 static const char *const htmltname[] =
959 {
960  "$end", "error", "$undefined", "T_end_br", "T_end_img", "T_row",
961  "T_end_row", "T_html", "T_end_html", "T_end_table", "T_end_cell",
962  "T_end_font", "T_string", "T_error", "T_n_italic", "T_n_bold",
963  "T_n_underline", "T_n_overline", "T_n_sup", "T_n_sub", "T_n_s", "T_HR",
964  "T_hr", "T_end_hr", "T_VR", "T_vr", "T_end_vr", "T_BR", "T_br", "T_IMG",
965  "T_img", "T_table", "T_cell", "T_font", "T_italic", "T_bold",
966  "T_underline", "T_overline", "T_sup", "T_sub", "T_s", "$accept", "html",
967  "fonttext", "text", "textitem", "font", "n_font", "italic", "n_italic",
968  "bold", "n_bold", "strike", "n_strike", "underline", "n_underline",
969  "overline", "n_overline", "sup", "n_sup", "sub", "n_sub", "br", "string",
970  "table", "@1", "fonttable", "opt_space", "rows", "row", "$@2", "cells",
971  "cell", "$@3", "$@4", "$@5", "$@6", "image", "HR", "VR", YY_NULL
972 };
973 #endif
974 
975 # ifdef YYPRINT
976 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
977  token YYLEX-NUM. */
978 static const htmltype_uint16 htmltoknum[] =
979 {
980  0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
981  265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
982  275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
983  285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
984  295
985 };
986 # endif
987 
988 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
989 static const htmltype_uint8 htmlr1[] =
990 {
991  0, 41, 42, 42, 42, 43, 44, 44, 45, 45,
992  45, 45, 45, 45, 45, 45, 45, 45, 46, 47,
993  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
994  58, 59, 60, 61, 62, 62, 63, 63, 65, 64,
995  66, 66, 66, 66, 66, 66, 67, 67, 68, 68,
996  68, 70, 69, 71, 71, 71, 73, 72, 74, 72,
997  75, 72, 76, 72, 77, 77, 78, 78, 79, 79
998 };
999 
1000 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
1001 static const htmltype_uint8 htmlr2[] =
1002 {
1003  0, 2, 3, 3, 1, 1, 2, 1, 1, 1,
1004  3, 3, 3, 3, 3, 3, 3, 3, 1, 1,
1005  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1006  1, 1, 1, 1, 2, 1, 1, 2, 0, 6,
1007  1, 3, 3, 3, 3, 3, 1, 0, 1, 2,
1008  3, 0, 4, 1, 2, 3, 0, 4, 0, 4,
1009  0, 4, 0, 3, 2, 1, 2, 1, 2, 1
1010 };
1011 
1012 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
1013  Performed when YYTABLE doesn't specify something else to do. Zero
1014  means the default is an error. */
1015 static const htmltype_uint8 htmldefact[] =
1016 {
1017  0, 4, 47, 0, 36, 35, 0, 18, 20, 22,
1018  26, 28, 30, 32, 24, 0, 5, 7, 47, 47,
1019  47, 0, 47, 47, 0, 0, 9, 8, 40, 0,
1020  0, 1, 34, 2, 6, 0, 0, 0, 0, 0,
1021  8, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1022  0, 0, 0, 0, 37, 3, 38, 19, 10, 41,
1023  21, 11, 42, 23, 14, 45, 25, 17, 27, 12,
1024  43, 29, 13, 44, 31, 15, 33, 16, 0, 51,
1025  0, 48, 0, 47, 67, 0, 49, 0, 47, 0,
1026  53, 46, 39, 66, 50, 65, 0, 58, 56, 0,
1027  60, 52, 69, 0, 54, 0, 64, 0, 0, 63,
1028  0, 68, 55, 59, 57, 61
1029 };
1030 
1031 /* YYDEFGOTO[NTERM-NUM]. */
1032 static const htmltype_int8 htmldefgoto[] =
1033 {
1034  -1, 3, 15, 16, 17, 35, 58, 36, 61, 37,
1035  64, 21, 67, 38, 69, 39, 72, 24, 75, 25,
1036  77, 26, 40, 28, 78, 29, 30, 80, 81, 82,
1037  89, 90, 108, 107, 110, 99, 100, 87, 105
1038 };
1039 
1040 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1041  STATE-NUM. */
1042 #define YYPACT_NINF -82
1043 static const htmltype_int16 htmlpact[] =
1044 {
1045  8, -82, 209, 10, -82, -82, 11, -82, -82, -82,
1046  -82, -82, -82, -82, -82, 5, 209, -82, 209, 209,
1047  209, 209, 209, 209, 209, 209, -82, -5, -82, 14,
1048  -20, -82, -82, -82, -82, 209, 209, 209, 209, 209,
1049  13, 37, 12, 66, 16, 80, 19, 109, 123, 20,
1050  152, 15, 166, 195, -82, -82, -82, -82, -82, -82,
1051  -82, -82, -82, -82, -82, -82, -82, -82, -82, -82,
1052  -82, -82, -82, -82, -82, -82, -82, -82, 23, -82,
1053  119, -82, 7, 46, -82, 38, -82, 23, 17, 35,
1054  -82, 13, -82, -82, -82, -82, 58, -82, -82, 53,
1055  -82, -82, -82, 40, -82, 7, -82, 59, 69, -82,
1056  72, -82, -82, -82, -82, -82
1057 };
1058 
1059 /* YYPGOTO[NTERM-NUM]. */
1060 static const htmltype_int16 htmlpgoto[] =
1061 {
1062  -82, -82, -4, 232, -10, -1, 26, 0, 39, 1,
1063  50, -82, -82, 2, 36, 3, 47, -82, -82, -82,
1064  -82, -82, -2, 148, -82, 9, 27, -82, -68, -82,
1065  -82, -81, -82, -82, -82, -82, -82, -82, -82
1066 };
1067 
1068 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
1069  positive, shift that token. If negative, reduce the rule which
1070  number is the opposite. If YYTABLE_NINF, syntax error. */
1071 #define YYTABLE_NINF -63
1072 static const htmltype_int8 htmltable[] =
1073 {
1074  27, 18, 19, 20, 22, 23, 34, 54, 104, 1,
1075  31, 56, 86, 33, 32, 2, 27, 27, 27, 94,
1076  27, 27, 55, 57, 112, 54, -46, -62, 79, 4,
1077  60, 34, 71, 34, 63, 34, 68, 34, 34, 88,
1078  34, 101, 34, 34, 5, 6, 95, 96, 57, 4,
1079  7, 8, 9, 10, 11, 12, 13, 14, 4, 102,
1080  103, 93, 106, 109, 5, 6, 111, 88, 59, 113,
1081  7, 8, 9, 10, 11, 12, 13, 14, 4, 114,
1082  60, 91, 115, 62, 97, 70, 27, 18, 19, 20,
1083  22, 23, 4, 5, 6, 63, 65, 98, 73, 7,
1084  8, 9, 10, 11, 12, 13, 14, 5, 6, 0,
1085  92, 0, 0, 7, 8, 9, 10, 11, 12, 13,
1086  14, 4, 0, 0, 79, 0, 0, 0, 83, 66,
1087  0, 0, 0, 0, 0, 4, 5, 6, 0, 68,
1088  84, 85, 7, 8, 9, 10, 11, 12, 13, 14,
1089  5, 6, 0, 0, 0, 0, 7, 8, 9, 10,
1090  11, 12, 13, 14, 4, 0, 42, 44, 46, 71,
1091  49, 51, 0, 0, 0, 0, 0, 0, 4, 5,
1092  6, 0, 0, 0, 74, 7, 8, 9, 10, 11,
1093  12, 13, 14, 5, 6, 0, 0, 0, 0, 7,
1094  8, 9, 10, 11, 12, 13, 14, 4, 0, 0,
1095  0, 0, 0, 0, 76, 0, 0, 0, 0, 0,
1096  0, 4, 5, 6, 0, 0, 0, 0, 7, 8,
1097  9, 10, 11, 12, 13, 14, 5, 6, 0, 0,
1098  0, 0, 7, 8, 9, 10, 11, 12, 13, 14,
1099  41, 43, 45, 47, 48, 50, 52, 53, 0, 0,
1100  0, 0, 0, 0, 0, 0, 0, 41, 43, 45,
1101  48, 50
1102 };
1103 
1104 #define htmlpact_value_is_default(Yystate) \
1105  (!!((Yystate) == (-82)))
1106 
1107 #define htmltable_value_is_error(Yytable_value) \
1108  YYID (0)
1109 
1110 static const htmltype_int8 htmlcheck[] =
1111 {
1112  2, 2, 2, 2, 2, 2, 16, 12, 89, 1,
1113  0, 31, 80, 8, 3, 7, 18, 19, 20, 87,
1114  22, 23, 8, 11, 105, 12, 31, 10, 5, 12,
1115  14, 41, 17, 43, 15, 45, 16, 47, 48, 32,
1116  50, 6, 52, 53, 27, 28, 29, 30, 11, 12,
1117  33, 34, 35, 36, 37, 38, 39, 40, 12, 24,
1118  25, 23, 4, 10, 27, 28, 26, 32, 42, 10,
1119  33, 34, 35, 36, 37, 38, 39, 40, 12, 10,
1120  14, 83, 10, 44, 88, 49, 88, 88, 88, 88,
1121  88, 88, 12, 27, 28, 15, 46, 88, 51, 33,
1122  34, 35, 36, 37, 38, 39, 40, 27, 28, -1,
1123  83, -1, -1, 33, 34, 35, 36, 37, 38, 39,
1124  40, 12, -1, -1, 5, -1, -1, -1, 9, 20,
1125  -1, -1, -1, -1, -1, 12, 27, 28, -1, 16,
1126  21, 22, 33, 34, 35, 36, 37, 38, 39, 40,
1127  27, 28, -1, -1, -1, -1, 33, 34, 35, 36,
1128  37, 38, 39, 40, 12, -1, 18, 19, 20, 17,
1129  22, 23, -1, -1, -1, -1, -1, -1, 12, 27,
1130  28, -1, -1, -1, 18, 33, 34, 35, 36, 37,
1131  38, 39, 40, 27, 28, -1, -1, -1, -1, 33,
1132  34, 35, 36, 37, 38, 39, 40, 12, -1, -1,
1133  -1, -1, -1, -1, 19, -1, -1, -1, -1, -1,
1134  -1, 12, 27, 28, -1, -1, -1, -1, 33, 34,
1135  35, 36, 37, 38, 39, 40, 27, 28, -1, -1,
1136  -1, -1, 33, 34, 35, 36, 37, 38, 39, 40,
1137  18, 19, 20, 21, 22, 23, 24, 25, -1, -1,
1138  -1, -1, -1, -1, -1, -1, -1, 35, 36, 37,
1139  38, 39
1140 };
1141 
1142 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1143  symbol of state STATE-NUM. */
1144 static const htmltype_uint8 htmlstos[] =
1145 {
1146  0, 1, 7, 42, 12, 27, 28, 33, 34, 35,
1147  36, 37, 38, 39, 40, 43, 44, 45, 46, 48,
1148  50, 52, 54, 56, 58, 60, 62, 63, 64, 66,
1149  67, 0, 3, 8, 45, 46, 48, 50, 54, 56,
1150  63, 44, 64, 44, 64, 44, 64, 44, 44, 64,
1151  44, 64, 44, 44, 12, 8, 31, 11, 47, 47,
1152  14, 49, 49, 15, 51, 51, 20, 53, 16, 55,
1153  55, 17, 57, 57, 18, 59, 19, 61, 65, 5,
1154  68, 69, 70, 9, 21, 22, 69, 78, 32, 71,
1155  72, 63, 67, 23, 69, 29, 30, 43, 66, 76,
1156  77, 6, 24, 25, 72, 79, 4, 74, 73, 10,
1157  75, 26, 72, 10, 10, 10
1158 };
1159 
1160 #define htmlerrok (htmlerrstatus = 0)
1161 #define htmlclearin (htmlchar = YYEMPTY)
1162 #define YYEMPTY (-2)
1163 #define YYEOF 0
1164 
1165 #define YYACCEPT goto htmlacceptlab
1166 #define YYABORT goto htmlabortlab
1167 #define YYERROR goto htmlerrorlab
1168 
1169 
1170 /* Like YYERROR except do call htmlerror. This remains here temporarily
1171  to ease the transition to the new meaning of YYERROR, for GCC.
1172  Once GCC version 2 has supplanted version 1, this can go. However,
1173  YYFAIL appears to be in use. Nevertheless, it is formally deprecated
1174  in Bison 2.4.2's NEWS entry, where a plan to phase it out is
1175  discussed. */
1176 
1177 #define YYFAIL goto htmlerrlab
1178 #if defined YYFAIL
1179  /* This is here to suppress warnings from the GCC cpp's
1180  -Wunused-macros. Normally we don't worry about that warning, but
1181  some users do, and we want to make it easy for users to remove
1182  YYFAIL uses, which will produce warnings from Bison 2.5. */
1183 #endif
1184 
1185 #define YYRECOVERING() (!!htmlerrstatus)
1186 
1187 #define YYBACKUP(Token, Value) \
1188 do \
1189  if (htmlchar == YYEMPTY) \
1190  { \
1191  htmlchar = (Token); \
1192  htmllval = (Value); \
1193  YYPOPSTACK (htmllen); \
1194  htmlstate = *htmlssp; \
1195  goto htmlbackup; \
1196  } \
1197  else \
1198  { \
1199  htmlerror (YY_("syntax error: cannot back up")); \
1200  YYERROR; \
1201  } \
1202 while (YYID (0))
1203 
1204 /* Error token number */
1205 #define YYTERROR 1
1206 #define YYERRCODE 256
1207 
1208 
1209 /* This macro is provided for backward compatibility. */
1210 #ifndef YY_LOCATION_PRINT
1211 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1212 #endif
1213 
1214 
1215 /* YYLEX -- calling `htmllex' with the right arguments. */
1216 #ifdef YYLEX_PARAM
1217 # define YYLEX htmllex (YYLEX_PARAM)
1218 #else
1219 # define YYLEX htmllex ()
1220 #endif
1221 
1222 /* Enable debugging if requested. */
1223 #if YYDEBUG
1224 
1225 # ifndef YYFPRINTF
1226 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1227 # define YYFPRINTF fprintf
1228 # endif
1229 
1230 # define YYDPRINTF(Args) \
1231 do { \
1232  if (htmldebug) \
1233  YYFPRINTF Args; \
1234 } while (YYID (0))
1235 
1236 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1237 do { \
1238  if (htmldebug) \
1239  { \
1240  YYFPRINTF (stderr, "%s ", Title); \
1241  html_symbol_print (stderr, \
1242  Type, Value); \
1243  YYFPRINTF (stderr, "\n"); \
1244  } \
1245 } while (YYID (0))
1246 
1247 
1248 /*--------------------------------.
1249 | Print this symbol on YYOUTPUT. |
1250 `--------------------------------*/
1251 
1252 /*ARGSUSED*/
1253 #if (defined __STDC__ || defined __C99__FUNC__ \
1254  || defined __cplusplus || defined _MSC_VER)
1255 static void
1256 html_symbol_value_print (FILE *htmloutput, int htmltype, YYSTYPE const * const htmlvaluep)
1257 #else
1258 static void
1259 html_symbol_value_print (htmloutput, htmltype, htmlvaluep)
1260  FILE *htmloutput;
1261  int htmltype;
1262  YYSTYPE const * const htmlvaluep;
1263 #endif
1264 {
1265  FILE *htmlo = htmloutput;
1266  YYUSE (htmlo);
1267  if (!htmlvaluep)
1268  return;
1269 # ifdef YYPRINT
1270  if (htmltype < YYNTOKENS)
1271  YYPRINT (htmloutput, htmltoknum[htmltype], *htmlvaluep);
1272 # else
1273  YYUSE (htmloutput);
1274 # endif
1275  switch (htmltype)
1276  {
1277  default:
1278  break;
1279  }
1280 }
1281 
1282 
1283 /*--------------------------------.
1284 | Print this symbol on YYOUTPUT. |
1285 `--------------------------------*/
1286 
1287 #if (defined __STDC__ || defined __C99__FUNC__ \
1288  || defined __cplusplus || defined _MSC_VER)
1289 static void
1290 html_symbol_print (FILE *htmloutput, int htmltype, YYSTYPE const * const htmlvaluep)
1291 #else
1292 static void
1293 html_symbol_print (htmloutput, htmltype, htmlvaluep)
1294  FILE *htmloutput;
1295  int htmltype;
1296  YYSTYPE const * const htmlvaluep;
1297 #endif
1298 {
1299  if (htmltype < YYNTOKENS)
1300  YYFPRINTF (htmloutput, "token %s (", htmltname[htmltype]);
1301  else
1302  YYFPRINTF (htmloutput, "nterm %s (", htmltname[htmltype]);
1303 
1304  html_symbol_value_print (htmloutput, htmltype, htmlvaluep);
1305  YYFPRINTF (htmloutput, ")");
1306 }
1307 
1308 /*------------------------------------------------------------------.
1309 | html_stack_print -- Print the state stack from its BOTTOM up to its |
1310 | TOP (included). |
1311 `------------------------------------------------------------------*/
1312 
1313 #if (defined __STDC__ || defined __C99__FUNC__ \
1314  || defined __cplusplus || defined _MSC_VER)
1315 static void
1316 html_stack_print (htmltype_int16 *htmlbottom, htmltype_int16 *htmltop)
1317 #else
1318 static void
1319 html_stack_print (htmlbottom, htmltop)
1320  htmltype_int16 *htmlbottom;
1321  htmltype_int16 *htmltop;
1322 #endif
1323 {
1324  YYFPRINTF (stderr, "Stack now");
1325  for (; htmlbottom <= htmltop; htmlbottom++)
1326  {
1327  int htmlbot = *htmlbottom;
1328  YYFPRINTF (stderr, " %d", htmlbot);
1329  }
1330  YYFPRINTF (stderr, "\n");
1331 }
1332 
1333 # define YY_STACK_PRINT(Bottom, Top) \
1334 do { \
1335  if (htmldebug) \
1336  html_stack_print ((Bottom), (Top)); \
1337 } while (YYID (0))
1338 
1339 
1340 /*------------------------------------------------.
1341 | Report that the YYRULE is going to be reduced. |
1342 `------------------------------------------------*/
1343 
1344 #if (defined __STDC__ || defined __C99__FUNC__ \
1345  || defined __cplusplus || defined _MSC_VER)
1346 static void
1347 html_reduce_print (YYSTYPE *htmlvsp, int htmlrule)
1348 #else
1349 static void
1350 html_reduce_print (htmlvsp, htmlrule)
1351  YYSTYPE *htmlvsp;
1352  int htmlrule;
1353 #endif
1354 {
1355  int htmlnrhs = htmlr2[htmlrule];
1356  int htmli;
1357  unsigned long int htmllno = htmlrline[htmlrule];
1358  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1359  htmlrule - 1, htmllno);
1360  /* The symbols being reduced. */
1361  for (htmli = 0; htmli < htmlnrhs; htmli++)
1362  {
1363  YYFPRINTF (stderr, " $%d = ", htmli + 1);
1364  html_symbol_print (stderr, htmlrhs[htmlprhs[htmlrule] + htmli],
1365  &(htmlvsp[(htmli + 1) - (htmlnrhs)])
1366  );
1367  YYFPRINTF (stderr, "\n");
1368  }
1369 }
1370 
1371 # define YY_REDUCE_PRINT(Rule) \
1372 do { \
1373  if (htmldebug) \
1374  html_reduce_print (htmlvsp, Rule); \
1375 } while (YYID (0))
1376 
1377 /* Nonzero means print parse trace. It is left uninitialized so that
1378  multiple parsers can coexist. */
1379 int htmldebug;
1380 #else /* !YYDEBUG */
1381 # define YYDPRINTF(Args)
1382 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1383 # define YY_STACK_PRINT(Bottom, Top)
1384 # define YY_REDUCE_PRINT(Rule)
1385 #endif /* !YYDEBUG */
1386 
1387 
1388 /* YYINITDEPTH -- initial size of the parser's stacks. */
1389 #ifndef YYINITDEPTH
1390 # define YYINITDEPTH 200
1391 #endif
1392 
1393 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1394  if the built-in stack extension method is used).
1395 
1396  Do not make this value too large; the results are undefined if
1397  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1398  evaluated with infinite-precision integer arithmetic. */
1399 
1400 #ifndef YYMAXDEPTH
1401 # define YYMAXDEPTH 10000
1402 #endif
1403 
1404 
1405 #if YYERROR_VERBOSE
1406 
1407 # ifndef htmlstrlen
1408 # if defined __GLIBC__ && defined _STRING_H
1409 # define htmlstrlen strlen
1410 # else
1411 /* Return the length of YYSTR. */
1412 #if (defined __STDC__ || defined __C99__FUNC__ \
1413  || defined __cplusplus || defined _MSC_VER)
1414 static YYSIZE_T
1415 htmlstrlen (const char *htmlstr)
1416 #else
1417 static YYSIZE_T
1418 htmlstrlen (htmlstr)
1419  const char *htmlstr;
1420 #endif
1421 {
1422  YYSIZE_T htmllen;
1423  for (htmllen = 0; htmlstr[htmllen]; htmllen++)
1424  continue;
1425  return htmllen;
1426 }
1427 # endif
1428 # endif
1429 
1430 # ifndef htmlstpcpy
1431 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1432 # define htmlstpcpy stpcpy
1433 # else
1434 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1435  YYDEST. */
1436 #if (defined __STDC__ || defined __C99__FUNC__ \
1437  || defined __cplusplus || defined _MSC_VER)
1438 static char *
1439 htmlstpcpy (char *htmldest, const char *htmlsrc)
1440 #else
1441 static char *
1442 htmlstpcpy (htmldest, htmlsrc)
1443  char *htmldest;
1444  const char *htmlsrc;
1445 #endif
1446 {
1447  char *htmld = htmldest;
1448  const char *htmls = htmlsrc;
1449 
1450  while ((*htmld++ = *htmls++) != '\0')
1451  continue;
1452 
1453  return htmld - 1;
1454 }
1455 # endif
1456 # endif
1457 
1458 # ifndef htmltnamerr
1459 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1460  quotes and backslashes, so that it's suitable for htmlerror. The
1461  heuristic is that double-quoting is unnecessary unless the string
1462  contains an apostrophe, a comma, or backslash (other than
1463  backslash-backslash). YYSTR is taken from htmltname. If YYRES is
1464  null, do not copy; instead, return the length of what the result
1465  would have been. */
1466 static YYSIZE_T
1467 htmltnamerr (char *htmlres, const char *htmlstr)
1468 {
1469  if (*htmlstr == '"')
1470  {
1471  YYSIZE_T htmln = 0;
1472  char const *htmlp = htmlstr;
1473 
1474  for (;;)
1475  switch (*++htmlp)
1476  {
1477  case '\'':
1478  case ',':
1479  goto do_not_strip_quotes;
1480 
1481  case '\\':
1482  if (*++htmlp != '\\')
1483  goto do_not_strip_quotes;
1484  /* Fall through. */
1485  default:
1486  if (htmlres)
1487  htmlres[htmln] = *htmlp;
1488  htmln++;
1489  break;
1490 
1491  case '"':
1492  if (htmlres)
1493  htmlres[htmln] = '\0';
1494  return htmln;
1495  }
1496  do_not_strip_quotes: ;
1497  }
1498 
1499  if (! htmlres)
1500  return htmlstrlen (htmlstr);
1501 
1502  return htmlstpcpy (htmlres, htmlstr) - htmlres;
1503 }
1504 # endif
1505 
1506 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1507  about the unexpected token YYTOKEN for the state stack whose top is
1508  YYSSP.
1509 
1510  Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1511  not large enough to hold the message. In that case, also set
1512  *YYMSG_ALLOC to the required number of bytes. Return 2 if the
1513  required number of bytes is too large to store. */
1514 static int
1515 htmlsyntax_error (YYSIZE_T *htmlmsg_alloc, char **htmlmsg,
1516  htmltype_int16 *htmlssp, int htmltoken)
1517 {
1518  YYSIZE_T htmlsize0 = htmltnamerr (YY_NULL, htmltname[htmltoken]);
1519  YYSIZE_T htmlsize = htmlsize0;
1520  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1521  /* Internationalized format string. */
1522  const char *htmlformat = YY_NULL;
1523  /* Arguments of htmlformat. */
1524  char const *htmlarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1525  /* Number of reported tokens (one for the "unexpected", one per
1526  "expected"). */
1527  int htmlcount = 0;
1528 
1529  /* There are many possibilities here to consider:
1530  - Assume YYFAIL is not used. It's too flawed to consider. See
1531  <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
1532  for details. YYERROR is fine as it does not invoke this
1533  function.
1534  - If this state is a consistent state with a default action, then
1535  the only way this function was invoked is if the default action
1536  is an error action. In that case, don't check for expected
1537  tokens because there are none.
1538  - The only way there can be no lookahead present (in htmlchar) is if
1539  this state is a consistent state with a default action. Thus,
1540  detecting the absence of a lookahead is sufficient to determine
1541  that there is no unexpected or expected token to report. In that
1542  case, just report a simple "syntax error".
1543  - Don't assume there isn't a lookahead just because this state is a
1544  consistent state with a default action. There might have been a
1545  previous inconsistent state, consistent state with a non-default
1546  action, or user semantic action that manipulated htmlchar.
1547  - Of course, the expected token list depends on states to have
1548  correct lookahead information, and it depends on the parser not
1549  to perform extra reductions after fetching a lookahead from the
1550  scanner and before detecting a syntax error. Thus, state merging
1551  (from LALR or IELR) and default reductions corrupt the expected
1552  token list. However, the list is correct for canonical LR with
1553  one exception: it will still contain any token that will not be
1554  accepted due to an error action in a later state.
1555  */
1556  if (htmltoken != YYEMPTY)
1557  {
1558  int htmln = htmlpact[*htmlssp];
1559  htmlarg[htmlcount++] = htmltname[htmltoken];
1560  if (!htmlpact_value_is_default (htmln))
1561  {
1562  /* Start YYX at -YYN if negative to avoid negative indexes in
1563  YYCHECK. In other words, skip the first -YYN actions for
1564  this state because they are default actions. */
1565  int htmlxbegin = htmln < 0 ? -htmln : 0;
1566  /* Stay within bounds of both htmlcheck and htmltname. */
1567  int htmlchecklim = YYLAST - htmln + 1;
1568  int htmlxend = htmlchecklim < YYNTOKENS ? htmlchecklim : YYNTOKENS;
1569  int htmlx;
1570 
1571  for (htmlx = htmlxbegin; htmlx < htmlxend; ++htmlx)
1572  if (htmlcheck[htmlx + htmln] == htmlx && htmlx != YYTERROR
1573  && !htmltable_value_is_error (htmltable[htmlx + htmln]))
1574  {
1575  if (htmlcount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1576  {
1577  htmlcount = 1;
1578  htmlsize = htmlsize0;
1579  break;
1580  }
1581  htmlarg[htmlcount++] = htmltname[htmlx];
1582  {
1583  YYSIZE_T htmlsize1 = htmlsize + htmltnamerr (YY_NULL, htmltname[htmlx]);
1584  if (! (htmlsize <= htmlsize1
1585  && htmlsize1 <= YYSTACK_ALLOC_MAXIMUM))
1586  return 2;
1587  htmlsize = htmlsize1;
1588  }
1589  }
1590  }
1591  }
1592 
1593  switch (htmlcount)
1594  {
1595 # define YYCASE_(N, S) \
1596  case N: \
1597  htmlformat = S; \
1598  break
1599  YYCASE_(0, YY_("syntax error"));
1600  YYCASE_(1, YY_("syntax error, unexpected %s"));
1601  YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1602  YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1603  YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1604  YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1605 # undef YYCASE_
1606  }
1607 
1608  {
1609  YYSIZE_T htmlsize1 = htmlsize + htmlstrlen (htmlformat);
1610  if (! (htmlsize <= htmlsize1 && htmlsize1 <= YYSTACK_ALLOC_MAXIMUM))
1611  return 2;
1612  htmlsize = htmlsize1;
1613  }
1614 
1615  if (*htmlmsg_alloc < htmlsize)
1616  {
1617  *htmlmsg_alloc = 2 * htmlsize;
1618  if (! (htmlsize <= *htmlmsg_alloc
1619  && *htmlmsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1620  *htmlmsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1621  return 1;
1622  }
1623 
1624  /* Avoid sprintf, as that infringes on the user's name space.
1625  Don't have undefined behavior even if the translation
1626  produced a string with the wrong number of "%s"s. */
1627  {
1628  char *htmlp = *htmlmsg;
1629  int htmli = 0;
1630  while ((*htmlp = *htmlformat) != '\0')
1631  if (*htmlp == '%' && htmlformat[1] == 's' && htmli < htmlcount)
1632  {
1633  htmlp += htmltnamerr (htmlp, htmlarg[htmli++]);
1634  htmlformat += 2;
1635  }
1636  else
1637  {
1638  htmlp++;
1639  htmlformat++;
1640  }
1641  }
1642  return 0;
1643 }
1644 #endif /* YYERROR_VERBOSE */
1645 
1646 /*-----------------------------------------------.
1647 | Release the memory associated to this symbol. |
1648 `-----------------------------------------------*/
1649 
1650 /*ARGSUSED*/
1651 #if (defined __STDC__ || defined __C99__FUNC__ \
1652  || defined __cplusplus || defined _MSC_VER)
1653 static void
1654 htmldestruct (const char *htmlmsg, int htmltype, YYSTYPE *htmlvaluep)
1655 #else
1656 static void
1657 htmldestruct (htmlmsg, htmltype, htmlvaluep)
1658  const char *htmlmsg;
1659  int htmltype;
1660  YYSTYPE *htmlvaluep;
1661 #endif
1662 {
1663  YYUSE (htmlvaluep);
1664 
1665  if (!htmlmsg)
1666  htmlmsg = "Deleting";
1667  YY_SYMBOL_PRINT (htmlmsg, htmltype, htmlvaluep, htmllocationp);
1668 
1669  switch (htmltype)
1670  {
1671 
1672  default:
1673  break;
1674  }
1675 }
1676 
1677 
1678 
1679 
1680 /* The lookahead symbol. */
1682 
1683 
1684 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1685 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1686 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
1687 #endif
1688 #ifndef YY_INITIAL_VALUE
1689 # define YY_INITIAL_VALUE(Value) /* Nothing. */
1690 #endif
1691 
1692 /* The semantic value of the lookahead symbol. */
1693 YYSTYPE htmllval YY_INITIAL_VALUE(htmlval_default);
1694 
1695 /* Number of syntax errors so far. */
1697 
1698 
1699 /*----------.
1700 | htmlparse. |
1701 `----------*/
1702 
1703 #ifdef YYPARSE_PARAM
1704 #if (defined __STDC__ || defined __C99__FUNC__ \
1705  || defined __cplusplus || defined _MSC_VER)
1706 int
1707 htmlparse (void *YYPARSE_PARAM)
1708 #else
1709 int
1710 htmlparse (YYPARSE_PARAM)
1711  void *YYPARSE_PARAM;
1712 #endif
1713 #else /* ! YYPARSE_PARAM */
1714 #if (defined __STDC__ || defined __C99__FUNC__ \
1715  || defined __cplusplus || defined _MSC_VER)
1716 int
1717 htmlparse (void)
1718 #else
1719 int
1720 htmlparse ()
1721 
1722 #endif
1723 #endif
1725  int htmlstate;
1726  /* Number of tokens to shift before error messages enabled. */
1728 
1729  /* The stacks and their tools:
1730  `htmlss': related to states.
1731  `htmlvs': related to semantic values.
1732 
1733  Refer to the stacks through separate pointers, to allow htmloverflow
1734  to reallocate them elsewhere. */
1735 
1736  /* The state stack. */
1737  htmltype_int16 htmlssa[YYINITDEPTH];
1738  htmltype_int16 *htmlss;
1739  htmltype_int16 *htmlssp;
1740 
1741  /* The semantic value stack. */
1745 
1747 
1748  int htmln;
1750  /* Lookahead token as an internal (translated) token number. */
1751  int htmltoken = 0;
1752  /* The variables used to return semantic value and location from the
1753  action routines. */
1755 
1756 #if YYERROR_VERBOSE
1757  /* Buffer for error messages, and its allocated size. */
1758  char htmlmsgbuf[128];
1759  char *htmlmsg = htmlmsgbuf;
1760  YYSIZE_T htmlmsg_alloc = sizeof htmlmsgbuf;
1761 #endif
1762 
1763 #define YYPOPSTACK(N) (htmlvsp -= (N), htmlssp -= (N))
1764 
1765  /* The number of symbols on the RHS of the reduced rule.
1766  Keep to zero when no symbol should be popped. */
1767  int htmllen = 0;
1768 
1769  htmlssp = htmlss = htmlssa;
1770  htmlvsp = htmlvs = htmlvsa;
1771  htmlstacksize = YYINITDEPTH;
1772 
1773  YYDPRINTF ((stderr, "Starting parse\n"));
1774 
1775  htmlstate = 0;
1776  htmlerrstatus = 0;
1777  htmlnerrs = 0;
1778  htmlchar = YYEMPTY; /* Cause a token to be read. */
1780 
1781 /*------------------------------------------------------------.
1782 | htmlnewstate -- Push a new state, which is found in htmlstate. |
1783 `------------------------------------------------------------*/
1784  htmlnewstate:
1785  /* In all cases, when you get here, the value and location stacks
1786  have just been pushed. So pushing a state here evens the stacks. */
1787  htmlssp++;
1788 
1789  htmlsetstate:
1790  *htmlssp = htmlstate;
1791 
1792  if (htmlss + htmlstacksize - 1 <= htmlssp)
1793  {
1794  /* Get the current used size of the three stacks, in elements. */
1795  YYSIZE_T htmlsize = htmlssp - htmlss + 1;
1796 
1797 #ifdef htmloverflow
1798  {
1799  /* Give user a chance to reallocate the stack. Use copies of
1800  these so that the &'s don't force the real ones into
1801  memory. */
1802  YYSTYPE *htmlvs1 = htmlvs;
1803  htmltype_int16 *htmlss1 = htmlss;
1804 
1805  /* Each stack pointer address is followed by the size of the
1806  data in use in that stack, in bytes. This used to be a
1807  conditional around just the two extra args, but that might
1808  be undefined if htmloverflow is a macro. */
1809  htmloverflow (YY_("memory exhausted"),
1810  &htmlss1, htmlsize * sizeof (*htmlssp),
1811  &htmlvs1, htmlsize * sizeof (*htmlvsp),
1812  &htmlstacksize);
1813 
1814  htmlss = htmlss1;
1815  htmlvs = htmlvs1;
1816  }
1817 #else /* no htmloverflow */
1818 # ifndef YYSTACK_RELOCATE
1819  goto htmlexhaustedlab;
1820 # else
1821  /* Extend the stack our own way. */
1822  if (YYMAXDEPTH <= htmlstacksize)
1823  goto htmlexhaustedlab;
1824  htmlstacksize *= 2;
1825  if (YYMAXDEPTH < htmlstacksize)
1826  htmlstacksize = YYMAXDEPTH;
1827 
1828  {
1829  htmltype_int16 *htmlss1 = htmlss;
1830  union htmlalloc *htmlptr =
1831  (union htmlalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (htmlstacksize));
1832  if (! htmlptr)
1833  goto htmlexhaustedlab;
1834  YYSTACK_RELOCATE (htmlss_alloc, htmlss);
1835  YYSTACK_RELOCATE (htmlvs_alloc, htmlvs);
1836 # undef YYSTACK_RELOCATE
1837  if (htmlss1 != htmlssa)
1838  YYSTACK_FREE (htmlss1);
1839  }
1840 # endif
1841 #endif /* no htmloverflow */
1842 
1843  htmlssp = htmlss + htmlsize - 1;
1844  htmlvsp = htmlvs + htmlsize - 1;
1845 
1846  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1847  (unsigned long int) htmlstacksize));
1848 
1849  if (htmlss + htmlstacksize - 1 <= htmlssp)
1850  YYABORT;
1851  }
1852 
1853  YYDPRINTF ((stderr, "Entering state %d\n", htmlstate));
1854 
1855  if (htmlstate == YYFINAL)
1857 
1859 
1860 /*-----------.
1861 | htmlbackup. |
1862 `-----------*/
1863 htmlbackup:
1864 
1865  /* Do appropriate processing given the current state. Read a
1866  lookahead token if we need one and don't already have one. */
1867 
1868  /* First try to decide what to do without reference to lookahead token. */
1869  htmln = htmlpact[htmlstate];
1870  if (htmlpact_value_is_default (htmln))
1872 
1873  /* Not known => get a lookahead token if don't already have one. */
1874 
1875  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1876  if (htmlchar == YYEMPTY)
1877  {
1878  YYDPRINTF ((stderr, "Reading a token: "));
1879  htmlchar = YYLEX;
1880  }
1881 
1882  if (htmlchar <= YYEOF)
1883  {
1884  htmlchar = htmltoken = YYEOF;
1885  YYDPRINTF ((stderr, "Now at end of input.\n"));
1886  }
1887  else
1888  {
1889  htmltoken = YYTRANSLATE (htmlchar);
1890  YY_SYMBOL_PRINT ("Next token is", htmltoken, &htmllval, &htmllloc);
1891  }
1892 
1893  /* If the proper action on seeing token YYTOKEN is to reduce or to
1894  detect an error, take that action. */
1895  htmln += htmltoken;
1896  if (htmln < 0 || YYLAST < htmln || htmlcheck[htmln] != htmltoken)
1897  goto htmldefault;
1898  htmln = htmltable[htmln];
1899  if (htmln <= 0)
1900  {
1901  if (htmltable_value_is_error (htmln))
1902  goto htmlerrlab;
1903  htmln = -htmln;
1904  goto htmlreduce;
1905  }
1906 
1907  /* Count tokens shifted since error; after three, turn off error
1908  status. */
1909  if (htmlerrstatus)
1910  htmlerrstatus--;
1911 
1912  /* Shift the lookahead token. */
1913  YY_SYMBOL_PRINT ("Shifting", htmltoken, &htmllval, &htmllloc);
1914 
1915  /* Discard the shifted token. */
1916  htmlchar = YYEMPTY;
1917 
1918  htmlstate = htmln;
1920  *++htmlvsp = htmllval;
1922 
1924 
1925 
1926 /*-----------------------------------------------------------.
1927 | htmldefault -- do the default action for the current state. |
1928 `-----------------------------------------------------------*/
1929 htmldefault:
1930  htmln = htmldefact[htmlstate];
1931  if (htmln == 0)
1934 
1935 
1936 /*-----------------------------.
1937 | htmlreduce -- Do a reduction. |
1938 `-----------------------------*/
1939 htmlreduce:
1940  /* htmln is the number of a rule to reduce with. */
1941  htmllen = htmlr2[htmln];
1942 
1943  /* If YYLEN is nonzero, implement the default value of the action:
1944  `$$ = $1'.
1945 
1946  Otherwise, the following line sets YYVAL to garbage.
1947  This behavior is undocumented and Bison
1948  users should not rely upon it. Assigning to YYVAL
1949  unconditionally makes the parser a bit smaller, and it avoids a
1950  GCC warning that YYVAL may be used uninitialized. */
1951  htmlval = htmlvsp[1-htmllen];
1952 
1953 
1954  YY_REDUCE_PRINT (htmln);
1955  switch (htmln)
1956  {
1957  case 2:
1958 /* Line 1792 of yacc.c */
1959 #line 447 "../../lib/common/htmlparse.y"
1960  { HTMLstate.lbl = mkLabel((htmlvsp[(2) - (3)].txt),HTML_TEXT); }
1961  break;
1962 
1963  case 3:
1964 /* Line 1792 of yacc.c */
1965 #line 448 "../../lib/common/htmlparse.y"
1966  { HTMLstate.lbl = mkLabel((htmlvsp[(2) - (3)].tbl),HTML_TBL); }
1967  break;
1968 
1969  case 4:
1970 /* Line 1792 of yacc.c */
1971 #line 449 "../../lib/common/htmlparse.y"
1972  { cleanup(); YYABORT; }
1973  break;
1974 
1975  case 5:
1976 /* Line 1792 of yacc.c */
1977 #line 452 "../../lib/common/htmlparse.y"
1978  { (htmlval.txt) = mkText(); }
1979  break;
1980 
1981  case 8:
1982 /* Line 1792 of yacc.c */
1983 #line 459 "../../lib/common/htmlparse.y"
1984  { appendFItemList(HTMLstate.str);}
1985  break;
1986 
1987  case 9:
1988 /* Line 1792 of yacc.c */
1989 #line 460 "../../lib/common/htmlparse.y"
1990  {appendFLineList((htmlvsp[(1) - (1)].i));}
1991  break;
1992 
1993  case 18:
1994 /* Line 1792 of yacc.c */
1995 #line 471 "../../lib/common/htmlparse.y"
1996  { pushFont ((htmlvsp[(1) - (1)].font)); }
1997  break;
1998 
1999  case 19:
2000 /* Line 1792 of yacc.c */
2001 #line 474 "../../lib/common/htmlparse.y"
2002  { popFont (); }
2003  break;
2004 
2005  case 20:
2006 /* Line 1792 of yacc.c */
2007 #line 477 "../../lib/common/htmlparse.y"
2008  {pushFont((htmlvsp[(1) - (1)].font));}
2009  break;
2010 
2011  case 21:
2012 /* Line 1792 of yacc.c */
2013 #line 480 "../../lib/common/htmlparse.y"
2014  {popFont();}
2015  break;
2016 
2017  case 22:
2018 /* Line 1792 of yacc.c */
2019 #line 483 "../../lib/common/htmlparse.y"
2020  {pushFont((htmlvsp[(1) - (1)].font));}
2021  break;
2022 
2023  case 23:
2024 /* Line 1792 of yacc.c */
2025 #line 486 "../../lib/common/htmlparse.y"
2026  {popFont();}
2027  break;
2028 
2029  case 24:
2030 /* Line 1792 of yacc.c */
2031 #line 489 "../../lib/common/htmlparse.y"
2032  {pushFont((htmlvsp[(1) - (1)].font));}
2033  break;
2034 
2035  case 25:
2036 /* Line 1792 of yacc.c */
2037 #line 492 "../../lib/common/htmlparse.y"
2038  {popFont();}
2039  break;
2040 
2041  case 26:
2042 /* Line 1792 of yacc.c */
2043 #line 495 "../../lib/common/htmlparse.y"
2044  {pushFont((htmlvsp[(1) - (1)].font));}
2045  break;
2046 
2047  case 27:
2048 /* Line 1792 of yacc.c */
2049 #line 498 "../../lib/common/htmlparse.y"
2050  {popFont();}
2051  break;
2052 
2053  case 28:
2054 /* Line 1792 of yacc.c */
2055 #line 501 "../../lib/common/htmlparse.y"
2056  {pushFont((htmlvsp[(1) - (1)].font));}
2057  break;
2058 
2059  case 29:
2060 /* Line 1792 of yacc.c */
2061 #line 504 "../../lib/common/htmlparse.y"
2062  {popFont();}
2063  break;
2064 
2065  case 30:
2066 /* Line 1792 of yacc.c */
2067 #line 507 "../../lib/common/htmlparse.y"
2068  {pushFont((htmlvsp[(1) - (1)].font));}
2069  break;
2070 
2071  case 31:
2072 /* Line 1792 of yacc.c */
2073 #line 510 "../../lib/common/htmlparse.y"
2074  {popFont();}
2075  break;
2076 
2077  case 32:
2078 /* Line 1792 of yacc.c */
2079 #line 513 "../../lib/common/htmlparse.y"
2080  {pushFont((htmlvsp[(1) - (1)].font));}
2081  break;
2082 
2083  case 33:
2084 /* Line 1792 of yacc.c */
2085 #line 516 "../../lib/common/htmlparse.y"
2086  {popFont();}
2087  break;
2088 
2089  case 34:
2090 /* Line 1792 of yacc.c */
2091 #line 519 "../../lib/common/htmlparse.y"
2092  { (htmlval.i) = (htmlvsp[(1) - (2)].i); }
2093  break;
2094 
2095  case 35:
2096 /* Line 1792 of yacc.c */
2097 #line 520 "../../lib/common/htmlparse.y"
2098  { (htmlval.i) = (htmlvsp[(1) - (1)].i); }
2099  break;
2100 
2101  case 38:
2102 /* Line 1792 of yacc.c */
2103 #line 527 "../../lib/common/htmlparse.y"
2104  {
2105  if (nonSpace(agxbuse(HTMLstate.str))) {
2106  htmlerror ("Syntax error: non-space string used before <TABLE>");
2107  cleanup(); YYABORT;
2108  }
2109  (htmlvsp[(2) - (2)].tbl)->u.p.prev = HTMLstate.tblstack;
2110  (htmlvsp[(2) - (2)].tbl)->u.p.rows = dtopen(&rowDisc, Dtqueue);
2111  HTMLstate.tblstack = (htmlvsp[(2) - (2)].tbl);
2112  (htmlvsp[(2) - (2)].tbl)->font = HTMLstate.fontstack->cfont;
2113  (htmlval.tbl) = (htmlvsp[(2) - (2)].tbl);
2114  }
2115  break;
2116 
2117  case 39:
2118 /* Line 1792 of yacc.c */
2119 #line 538 "../../lib/common/htmlparse.y"
2120  {
2121  if (nonSpace(agxbuse(HTMLstate.str))) {
2122  htmlerror ("Syntax error: non-space string used after </TABLE>");
2123  cleanup(); YYABORT;
2124  }
2125  (htmlval.tbl) = HTMLstate.tblstack;
2126  HTMLstate.tblstack = HTMLstate.tblstack->u.p.prev;
2127  }
2128  break;
2129 
2130  case 40:
2131 /* Line 1792 of yacc.c */
2132 #line 548 "../../lib/common/htmlparse.y"
2133  { (htmlval.tbl) = (htmlvsp[(1) - (1)].tbl); }
2134  break;
2135 
2136  case 41:
2137 /* Line 1792 of yacc.c */
2138 #line 549 "../../lib/common/htmlparse.y"
2139  { (htmlval.tbl)=(htmlvsp[(2) - (3)].tbl); }
2140  break;
2141 
2142  case 42:
2143 /* Line 1792 of yacc.c */
2144 #line 550 "../../lib/common/htmlparse.y"
2145  { (htmlval.tbl)=(htmlvsp[(2) - (3)].tbl); }
2146  break;
2147 
2148  case 43:
2149 /* Line 1792 of yacc.c */
2150 #line 551 "../../lib/common/htmlparse.y"
2151  { (htmlval.tbl)=(htmlvsp[(2) - (3)].tbl); }
2152  break;
2153 
2154  case 44:
2155 /* Line 1792 of yacc.c */
2156 #line 552 "../../lib/common/htmlparse.y"
2157  { (htmlval.tbl)=(htmlvsp[(2) - (3)].tbl); }
2158  break;
2159 
2160  case 45:
2161 /* Line 1792 of yacc.c */
2162 #line 553 "../../lib/common/htmlparse.y"
2163  { (htmlval.tbl)=(htmlvsp[(2) - (3)].tbl); }
2164  break;
2165 
2166  case 48:
2167 /* Line 1792 of yacc.c */
2168 #line 560 "../../lib/common/htmlparse.y"
2169  { (htmlval.p) = (htmlvsp[(1) - (1)].p); }
2170  break;
2171 
2172  case 49:
2173 /* Line 1792 of yacc.c */
2174 #line 561 "../../lib/common/htmlparse.y"
2175  { (htmlval.p) = (htmlvsp[(2) - (2)].p); }
2176  break;
2177 
2178  case 50:
2179 /* Line 1792 of yacc.c */
2180 #line 562 "../../lib/common/htmlparse.y"
2181  { (htmlvsp[(1) - (3)].p)->ruled = 1; (htmlval.p) = (htmlvsp[(3) - (3)].p); }
2182  break;
2183 
2184  case 51:
2185 /* Line 1792 of yacc.c */
2186 #line 565 "../../lib/common/htmlparse.y"
2187  { addRow (); }
2188  break;
2189 
2190  case 52:
2191 /* Line 1792 of yacc.c */
2192 #line 565 "../../lib/common/htmlparse.y"
2193  { (htmlval.p) = lastRow(); }
2194  break;
2195 
2196  case 53:
2197 /* Line 1792 of yacc.c */
2198 #line 568 "../../lib/common/htmlparse.y"
2199  { (htmlval.cell) = (htmlvsp[(1) - (1)].cell); }
2200  break;
2201 
2202  case 54:
2203 /* Line 1792 of yacc.c */
2204 #line 569 "../../lib/common/htmlparse.y"
2205  { (htmlval.cell) = (htmlvsp[(2) - (2)].cell); }
2206  break;
2207 
2208  case 55:
2209 /* Line 1792 of yacc.c */
2210 #line 570 "../../lib/common/htmlparse.y"
2211  { (htmlvsp[(1) - (3)].cell)->ruled |= HTML_VRULE; (htmlval.cell) = (htmlvsp[(3) - (3)].cell); }
2212  break;
2213 
2214  case 56:
2215 /* Line 1792 of yacc.c */
2216 #line 573 "../../lib/common/htmlparse.y"
2217  { setCell((htmlvsp[(1) - (2)].cell),(htmlvsp[(2) - (2)].tbl),HTML_TBL); }
2218  break;
2219 
2220  case 57:
2221 /* Line 1792 of yacc.c */
2222 #line 573 "../../lib/common/htmlparse.y"
2223  { (htmlval.cell) = (htmlvsp[(1) - (4)].cell); }
2224  break;
2225 
2226  case 58:
2227 /* Line 1792 of yacc.c */
2228 #line 574 "../../lib/common/htmlparse.y"
2229  { setCell((htmlvsp[(1) - (2)].cell),(htmlvsp[(2) - (2)].txt),HTML_TEXT); }
2230  break;
2231 
2232  case 59:
2233 /* Line 1792 of yacc.c */
2234 #line 574 "../../lib/common/htmlparse.y"
2235  { (htmlval.cell) = (htmlvsp[(1) - (4)].cell); }
2236  break;
2237 
2238  case 60:
2239 /* Line 1792 of yacc.c */
2240 #line 575 "../../lib/common/htmlparse.y"
2241  { setCell((htmlvsp[(1) - (2)].cell),(htmlvsp[(2) - (2)].img),HTML_IMAGE); }
2242  break;
2243 
2244  case 61:
2245 /* Line 1792 of yacc.c */
2246 #line 575 "../../lib/common/htmlparse.y"
2247  { (htmlval.cell) = (htmlvsp[(1) - (4)].cell); }
2248  break;
2249 
2250  case 62:
2251 /* Line 1792 of yacc.c */
2252 #line 576 "../../lib/common/htmlparse.y"
2253  { setCell((htmlvsp[(1) - (1)].cell),mkText(),HTML_TEXT); }
2254  break;
2255 
2256  case 63:
2257 /* Line 1792 of yacc.c */
2258 #line 576 "../../lib/common/htmlparse.y"
2259  { (htmlval.cell) = (htmlvsp[(1) - (3)].cell); }
2260  break;
2261 
2262  case 64:
2263 /* Line 1792 of yacc.c */
2264 #line 579 "../../lib/common/htmlparse.y"
2265  { (htmlval.img) = (htmlvsp[(1) - (2)].img); }
2266  break;
2267 
2268  case 65:
2269 /* Line 1792 of yacc.c */
2270 #line 580 "../../lib/common/htmlparse.y"
2271  { (htmlval.img) = (htmlvsp[(1) - (1)].img); }
2272  break;
2273 
2274 
2275 /* Line 1792 of yacc.c */
2276 #line 2277 "y.tab.c"
2277  default: break;
2278  }
2279  /* User semantic actions sometimes alter htmlchar, and that requires
2280  that htmltoken be updated with the new translation. We take the
2281  approach of translating immediately before every use of htmltoken.
2282  One alternative is translating here after every semantic action,
2283  but that translation would be missed if the semantic action invokes
2284  YYABORT, YYACCEPT, or YYERROR immediately after altering htmlchar or
2285  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
2286  incorrect destructor might then be invoked immediately. In the
2287  case of YYERROR or YYBACKUP, subsequent parser actions might lead
2288  to an incorrect destructor call or verbose syntax error message
2289  before the lookahead is translated. */
2290  YY_SYMBOL_PRINT ("-> $$ =", htmlr1[htmln], &htmlval, &htmlloc);
2291 
2292  YYPOPSTACK (htmllen);
2293  htmllen = 0;
2294  YY_STACK_PRINT (htmlss, htmlssp);
2295 
2296  *++htmlvsp = htmlval;
2297 
2298  /* Now `shift' the result of the reduction. Determine what state
2299  that goes to, based on the state we popped back to and the rule
2300  number reduced by. */
2301 
2302  htmln = htmlr1[htmln];
2303 
2304  htmlstate = htmlpgoto[htmln - YYNTOKENS] + *htmlssp;
2305  if (0 <= htmlstate && htmlstate <= YYLAST && htmlcheck[htmlstate] == *htmlssp)
2306  htmlstate = htmltable[htmlstate];
2307  else
2308  htmlstate = htmldefgoto[htmln - YYNTOKENS];
2309 
2310  goto htmlnewstate;
2311 
2312 
2313 /*------------------------------------.
2314 | htmlerrlab -- here on detecting error |
2315 `------------------------------------*/
2316 htmlerrlab:
2317  /* Make sure we have latest lookahead translation. See comments at
2318  user semantic actions for why this is necessary. */
2319  htmltoken = htmlchar == YYEMPTY ? YYEMPTY : YYTRANSLATE (htmlchar);
2320 
2321  /* If not already recovering from an error, report this error. */
2322  if (!htmlerrstatus)
2323  {
2324  ++htmlnerrs;
2325 #if ! YYERROR_VERBOSE
2326  htmlerror (YY_("syntax error"));
2327 #else
2328 # define YYSYNTAX_ERROR htmlsyntax_error (&htmlmsg_alloc, &htmlmsg, \
2329  htmlssp, htmltoken)
2330  {
2331  char const *htmlmsgp = YY_("syntax error");
2332  int htmlsyntax_error_status;
2333  htmlsyntax_error_status = YYSYNTAX_ERROR;
2334  if (htmlsyntax_error_status == 0)
2335  htmlmsgp = htmlmsg;
2336  else if (htmlsyntax_error_status == 1)
2337  {
2338  if (htmlmsg != htmlmsgbuf)
2339  YYSTACK_FREE (htmlmsg);
2340  htmlmsg = (char *) YYSTACK_ALLOC (htmlmsg_alloc);
2341  if (!htmlmsg)
2342  {
2343  htmlmsg = htmlmsgbuf;
2344  htmlmsg_alloc = sizeof htmlmsgbuf;
2345  htmlsyntax_error_status = 2;
2346  }
2347  else
2348  {
2349  htmlsyntax_error_status = YYSYNTAX_ERROR;
2350  htmlmsgp = htmlmsg;
2351  }
2352  }
2353  htmlerror (htmlmsgp);
2354  if (htmlsyntax_error_status == 2)
2355  goto htmlexhaustedlab;
2356  }
2357 # undef YYSYNTAX_ERROR
2358 #endif
2359  }
2360 
2361 
2362 
2363  if (htmlerrstatus == 3)
2364  {
2365  /* If just tried and failed to reuse lookahead token after an
2366  error, discard it. */
2367 
2368  if (htmlchar <= YYEOF)
2369  {
2370  /* Return failure if at end of input. */
2371  if (htmlchar == YYEOF)
2372  YYABORT;
2373  }
2374  else
2375  {
2376  htmldestruct ("Error: discarding",
2377  htmltoken, &htmllval);
2378  htmlchar = YYEMPTY;
2379  }
2380  }
2381 
2382  /* Else will try to reuse lookahead token after shifting the error
2383  token. */
2385 
2386 
2387 /*---------------------------------------------------.
2388 | htmlerrorlab -- error raised explicitly by YYERROR. |
2389 `---------------------------------------------------*/
2390 htmlerrorlab:
2391 
2392  /* Pacify compilers like GCC when the user code never invokes
2393  YYERROR and the label htmlerrorlab therefore never appears in user
2394  code. */
2395  if (/*CONSTCOND*/ 0)
2396  goto htmlerrorlab;
2397 
2398  /* Do not reclaim the symbols of the rule which action triggered
2399  this YYERROR. */
2400  YYPOPSTACK (htmllen);
2401  htmllen = 0;
2402  YY_STACK_PRINT (htmlss, htmlssp);
2403  htmlstate = *htmlssp;
2404  goto htmlerrlab1;
2405 
2406 
2407 /*-------------------------------------------------------------.
2408 | htmlerrlab1 -- common code for both syntax error and YYERROR. |
2409 `-------------------------------------------------------------*/
2410 htmlerrlab1:
2411  htmlerrstatus = 3; /* Each real token shifted decrements this. */
2412 
2413  for (;;)
2414  {
2415  htmln = htmlpact[htmlstate];
2416  if (!htmlpact_value_is_default (htmln))
2417  {
2418  htmln += YYTERROR;
2419  if (0 <= htmln && htmln <= YYLAST && htmlcheck[htmln] == YYTERROR)
2420  {
2421  htmln = htmltable[htmln];
2422  if (0 < htmln)
2423  break;
2424  }
2425  }
2426 
2427  /* Pop the current state because it cannot handle the error token. */
2428  if (htmlssp == htmlss)
2429  YYABORT;
2430 
2431 
2432  htmldestruct ("Error: popping",
2433  htmlstos[htmlstate], htmlvsp);
2434  YYPOPSTACK (1);
2435  htmlstate = *htmlssp;
2436  YY_STACK_PRINT (htmlss, htmlssp);
2437  }
2438 
2440  *++htmlvsp = htmllval;
2442 
2443 
2444  /* Shift the error token. */
2445  YY_SYMBOL_PRINT ("Shifting", htmlstos[htmln], htmlvsp, htmllsp);
2446 
2447  htmlstate = htmln;
2448  goto htmlnewstate;
2449 
2450 
2451 /*-------------------------------------.
2452 | htmlacceptlab -- YYACCEPT comes here. |
2453 `-------------------------------------*/
2454 htmlacceptlab:
2455  htmlresult = 0;
2457 
2458 /*-----------------------------------.
2459 | htmlabortlab -- YYABORT comes here. |
2460 `-----------------------------------*/
2461 htmlabortlab:
2462  htmlresult = 1;
2463  goto htmlreturn;
2464 
2465 #if !defined htmloverflow || YYERROR_VERBOSE
2466 /*-------------------------------------------------.
2467 | htmlexhaustedlab -- memory exhaustion comes here. |
2468 `-------------------------------------------------*/
2469 htmlexhaustedlab:
2470  htmlerror (YY_("memory exhausted"));
2471  htmlresult = 2;
2472  /* Fall through. */
2473 #endif
2474 
2475 htmlreturn:
2476  if (htmlchar != YYEMPTY)
2477  {
2478  /* Make sure we have latest lookahead translation. See comments at
2479  user semantic actions for why this is necessary. */
2480  htmltoken = YYTRANSLATE (htmlchar);
2481  htmldestruct ("Cleanup: discarding lookahead",
2482  htmltoken, &htmllval);
2483  }
2484  /* Do not reclaim the symbols of the rule which action triggered
2485  this YYABORT or YYACCEPT. */
2486  YYPOPSTACK (htmllen);
2487  YY_STACK_PRINT (htmlss, htmlssp);
2488  while (htmlssp != htmlss)
2489  {
2490  htmldestruct ("Cleanup: popping",
2491  htmlstos[*htmlssp], htmlvsp);
2492  YYPOPSTACK (1);
2493  }
2494 #ifndef htmloverflow
2495  if (htmlss != htmlssa)
2496  YYSTACK_FREE (htmlss);
2497 #endif
2498 #if YYERROR_VERBOSE
2499  if (htmlmsg != htmlmsgbuf)
2500  YYSTACK_FREE (htmlmsg);
2501 #endif
2502  /* Make sure YYID is used. */
2503  return YYID (htmlresult);
2504 }
2505 
2506 
2507 /* Line 2055 of yacc.c */
2508 #line 592 "../../lib/common/htmlparse.y"
2509 
2510 
2511 /* parseHTML:
2512  * Return parsed label or NULL if failure.
2513  * Set warn to 0 on success; 1 for warning message; 2 if no expat.
2514  */
2515 htmllabel_t*
2516 parseHTML (char* txt, int* warn, htmlenv_t *env)
2517 {
2518  unsigned char buf[SMALLBUF];
2519  agxbuf str;
2520  htmllabel_t* l;
2521  sfont_t dfltf;
2522 
2523  dfltf.cfont = NULL;
2524  dfltf.pfont = NULL;
2525  HTMLstate.fontstack = &dfltf;
2526  HTMLstate.tblstack = 0;
2527  HTMLstate.lbl = 0;
2528  HTMLstate.gvc = GD_gvc(env->g);
2529  HTMLstate.fitemList = dtopen(&fstrDisc, Dtqueue);
2530  HTMLstate.fspanList = dtopen(&fspanDisc, Dtqueue);
2531 
2532  agxbinit (&str, SMALLBUF, buf);
2533  HTMLstate.str = &str;
2534 
2535  if (initHTMLlexer (txt, &str, env)) {/* failed: no libexpat - give up */
2536  *warn = 2;
2537  l = NULL;
2538  }
2539  else {
2540  htmlparse();
2541  *warn = clearHTMLlexer ();
2542  l = HTMLstate.lbl;
2543  }
2544 
2545  dtclose (HTMLstate.fitemList);
2546  dtclose (HTMLstate.fspanList);
2547 
2548  HTMLstate.fitemList = NULL;
2549  HTMLstate.fspanList = NULL;
2550  HTMLstate.fontstack = NULL;
2551 
2552  agxbfree (&str);
2553 
2554  return l;
2555 }
2556 
#define HTML_VRULE
Definition: htmltable.h:95
YYSTYPE * htmlvsp
Definition: htmlparse.c:1744
#define T_font
Definition: htmlparse.c:575
int(* Dtcompar_f)(Dt_t *, void *, void *, Dtdisc_t *)
Definition: cdt.h:40
unsigned int(* Dthash_f)(Dt_t *, void *, Dtdisc_t *)
Definition: cdt.h:41
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
Definition: htmlparse.c:814
#define T_hr
Definition: htmlparse.c:564
#define YYSTACK_ALLOC
Definition: htmlparse.c:756
CDT_API int dtclose(Dt_t *)
#define htmltable_value_is_error(Yytable_value)
Definition: htmlparse.c:1107
#define N_NEW(n, t)
Definition: memory.h:36
void *(* Dtmake_f)(Dt_t *, void *, Dtdisc_t *)
Definition: cdt.h:38
goto htmlreturn
Definition: htmlparse.c:2456
#define agxbuse(X)
Definition: agxbuf.h:83
#define T_end_font
Definition: htmlparse.c:553
#define T_end_cell
Definition: htmlparse.c:552
#define YY_NULL
Definition: htmlparse.c:474
htmltype_int16 * htmlss
Definition: htmlparse.c:1738
Dtfree_f freef
Definition: cdt.h:85
htmldata_t data
Definition: htmltable.h:102
#define YY_(Msgid)
Definition: htmlparse.c:687
#define UNSET_ALIGN
Definition: htmltable.h:41
#define T_html
Definition: htmlparse.c:549
htmltxt_t * txt
Definition: htmltable.h:125
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
Definition: htmlparse.c:1686
int initHTMLlexer(char *src, agxbuf *xb, htmlenv_t *env)
Definition: htmllex.c:768
#define SMALLBUF
Definition: const.h:17
Dt_t * fitemList
Definition: htmlparse.c:83
CDT_API Dtlink_t * dtflatten(Dt_t *)
Definition: dtflatten.c:9
double size
Definition: textspan.h:52
union pitem::@16 u
#define T_br
Definition: htmlparse.c:570
#define T_n_underline
Definition: htmlparse.c:558
#define T_table
Definition: htmlparse.c:573
Definition: cdt.h:80
textfont_t * font
Definition: htmlparse.c:596
union YYSTYPE YYSTYPE
#define dtfirst(d)
Definition: cdt.h:254
htmllabel_t * parseHTML(char *txt, int *warn, htmlenv_t *env)
Definition: htmlparse.c:2516
goto htmlsetstate
Definition: htmlparse.c:1779
union htmltbl_t::@12 u
#define HTML_TBL
Definition: htmltable.h:91
#define YYABORT
Definition: htmlparse.c:1166
htmltbl_t * tblstack
Definition: htmlparse.c:82
#define dtlast(d)
Definition: cdt.h:257
#define YYID(N)
Definition: grammar.c:308
Dt_t * fspanList
Definition: htmlparse.c:84
#define T_overline
Definition: htmlparse.c:579
#define YYINITDEPTH
Definition: htmlparse.c:1390
#define YYTRANSLATE(YYX)
Definition: htmlparse.c:865
int i
Definition: grammar.c:204
#define htmlpact_value_is_default(Yystate)
Definition: htmlparse.c:1104
#define YYDPRINTF(Args)
Definition: grammar.c:921
goto htmlreduce
Definition: htmlparse.c:1933
char * name
Definition: textspan.h:49
#define T_vr
Definition: htmlparse.c:567
#define YYUSE(E)
Definition: htmlparse.c:693
#define T_BR
Definition: htmlparse.c:569
int htmllen
Definition: htmlparse.c:1767
#define YYEOF
Definition: htmlparse.c:1163
#define GD_gvc(g)
Definition: types.h:358
#define T_end_hr
Definition: htmlparse.c:565
void free_html_text(htmltxt_t *t)
Definition: htmltable.c:805
CDT_API Dt_t * dtopen(Dtdisc_t *, Dtmethod_t *)
Definition: dtopen.c:9
CDT_API Dtmethod_t * Dtqueue
Definition: cdt.h:170
htextspan_t lp
Definition: htmlparse.c:174
goto htmlbackup
Definition: htmlparse.c:1858
#define HTML_IMAGE
Definition: htmltable.h:93
unsigned char htmltype_uint8
Definition: htmlparse.c:639
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: grammar.c:922
#define T_HR
Definition: htmlparse.c:563
graph_t * g
Definition: htmltable.h:160
char * str
Definition: textspan.h:59
#define YYSIZE_T
Definition: htmlparse.c:673
short int htmltype_int16
Definition: htmlparse.c:660
#define T_n_italic
Definition: htmlparse.c:556
void free_html_label(htmllabel_t *lp, int root)
Definition: htmltable.c:870
unsigned int flags
Definition: textspan.h:53
#define NIL(t)
Definition: dthdr.h:13
int
Definition: grammar.c:1264
int htmlresult
Definition: htmlparse.c:1749
int htmlnerrs
Definition: htmlparse.c:1696
#define YYLEX
Definition: htmlparse.c:1219
#define YYMAXDEPTH
Definition: htmlparse.c:1401
htmltype_int16 * htmlssp
Definition: htmlparse.c:1739
YYSTYPE htmlvs_alloc
Definition: htmlparse.c:795
goto htmlerrlab
Definition: htmlparse.c:1932
Definition: gvcint.h:70
#define T_cell
Definition: htmlparse.c:574
#define T_row
Definition: htmlparse.c:547
int htmlchar
Definition: htmlparse.c:1681
int htmlparse(void)
#define YYNTOKENS
Definition: htmlparse.c:853
#define HTML_TEXT
Definition: htmltable.h:92
#define T_IMG
Definition: htmlparse.c:571
Definition: grid.h:37
unsigned char flags
Definition: htmltable.h:119
#define dtnext(d, o)
Definition: cdt.h:255
htmlcell_t * cell
Definition: htmlparse.c:594
goto htmlerrlab1
Definition: htmlparse.c:2384
#define YYLAST
Definition: htmlparse.c:850
htmllabel_t * lbl
Definition: htmlparse.c:81
htmlcell_t * cp
Definition: htmltable.h:151
htmltokentype
Definition: htmlparse.c:503
#define YY_INITIAL_VALUE(Value)
Definition: grammar.c:1229
#define YYSTACK_FREE
Definition: grammar.c:365
void *(* Dtmemory_f)(Dt_t *, void *, size_t, Dtdisc_t *)
Definition: cdt.h:36
#define YY_REDUCE_PRINT(Rule)
Definition: grammar.c:924
pitem * p
Definition: htmlparse.c:598
#define T_bold
Definition: htmlparse.c:577
#define YYPOPSTACK(N)
Definition: grammar.c:1303
htmltype_int16 htmlssa[YYINITDEPTH]
Definition: htmlparse.c:1737
YYSTYPE * htmlvs
Definition: htmlparse.c:1743
short nitems
Definition: htmltable.h:51
#define YYFINAL
Definition: htmlparse.c:848
void agxbinit(agxbuf *xb, unsigned int hint, unsigned char *init)
Definition: agxbuf.c:25
struct htmltbl_t::@12::@14 p
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Definition: htmlparse.c:1685
CDT_API int dtsize(Dt_t *)
Definition: dtsize.c:12
#define YYTERROR
Definition: htmlparse.c:1205
Dtlink_t link
Definition: htmlparse.c:168
#define YYSTACK_BYTES(N)
Definition: htmlparse.c:803
Definition: grammar.c:79
htmlstate
Definition: htmlparse.c:1775
YYSIZE_T htmlstacksize
Definition: htmlparse.c:1746
struct sfont_t sfont_t
#define T_end_img
Definition: htmlparse.c:546
char * color
Definition: textspan.h:50
#define T_end_table
Definition: htmlparse.c:551
#define dtinsert(d, o)
Definition: cdt.h:262
#define T_end_br
Definition: htmlparse.c:545
#define T_n_sup
Definition: htmlparse.c:560
htmllabel_t child
Definition: htmltable.h:137
void free_html_data(htmldata_t *dp)
Definition: htmltable.c:794
htmlimg_t * img
Definition: htmlparse.c:597
#define T_n_overline
Definition: htmlparse.c:559
#define NULL
Definition: logic.h:39
union htmllabel_t::@15 u
#define T_img
Definition: htmlparse.c:572
#define YYEMPTY
Definition: htmlparse.c:1162
short int htmltype_int8
Definition: htmlparse.c:648
#define HTML_HRULE
Definition: htmltable.h:96
textspan_t ti
Definition: htmlparse.c:169
htmltbl_t * tbl
Definition: htmlparse.c:595
GVC_t * gvc
Definition: htmlparse.c:87
YYSTYPE htmlvsa[YYINITDEPTH]
Definition: htmlparse.c:1742
#define dtclear(d)
Definition: cdt.h:267
int htmln
Definition: htmlparse.c:1748
int htmltoken
Definition: htmlparse.c:1751
htmldata_t data
Definition: htmltable.h:132
YYSTYPE htmllval
#define T_n_sub
Definition: htmlparse.c:561
Dtlink_t link
Definition: htmlparse.c:173
htmlimg_t * img
Definition: htmltable.h:126
#define T_end_row
Definition: htmlparse.c:548
#define YYSTACK_ALLOC_MAXIMUM
Definition: htmlparse.c:759
int(* Dtevent_f)(Dt_t *, int, void *, Dtdisc_t *)
Definition: cdt.h:42
YYSTYPE htmlval
Definition: htmlparse.c:1754
int htmlerrstatus
Definition: htmlparse.c:1727
textfont_t * cfont
Definition: htmlparse.c:76
#define T_end_html
Definition: htmlparse.c:550
#define T_end_vr
Definition: htmlparse.c:568
sfont_t * fontstack
Definition: htmlparse.c:86
void(* Dtfree_f)(Dt_t *, void *, Dtdisc_t *)
Definition: cdt.h:39
void htmlerror(const char *msg)
Definition: htmllex.c:64
unsigned char ruled
Definition: htmltable.h:139
htmltbl_t * tbl
Definition: htmltable.h:124
Definition: cdt.h:99
#define T_sub
Definition: htmlparse.c:581
#define T_n_s
Definition: htmlparse.c:562
int htmltype
Definition: htmlparse.c:1659
YY_IGNORE_MAYBE_UNINITIALIZED_END goto htmlnewstate
Definition: htmlparse.c:1923
agxbuf * str
Definition: htmlparse.c:85
unsigned short int htmltype_uint16
Definition: htmlparse.c:654
Definition: agxbuf.h:34
htextspan_t * spans
Definition: htmltable.h:58
char just
Definition: htmltable.h:52
#define T_s
Definition: htmlparse.c:582
struct sfont_t * pfont
Definition: htmlparse.c:77
#define YYACCEPT
Definition: grammar.c:705
Dt_t * rp
Definition: htmltable.h:150
#define T_italic
Definition: htmlparse.c:576
htmltype_int16 htmlss_alloc
Definition: htmlparse.c:794
short nspans
Definition: htmltable.h:59
#define T_underline
Definition: htmlparse.c:578
htmldestruct("Cleanup: discarding lookahead", htmltoken,&htmllval)
#define T_sup
Definition: htmlparse.c:580
#define YY_STACK_PRINT(Bottom, Top)
Definition: grammar.c:923
#define T_error
Definition: htmlparse.c:555
#define T_string
Definition: htmlparse.c:554
#define dtlink(d, e)
Definition: cdt.h:250
void agxbfree(agxbuf *xb)
Definition: agxbuf.c:94
goto htmldefault
Definition: htmlparse.c:1871
int clearHTMLlexer()
Definition: htmllex.c:798
textfont_t * font
Definition: textspan.h:60
htmltxt_t * txt
Definition: htmlparse.c:593
#define T_VR
Definition: htmlparse.c:566
#define T_n_bold
Definition: htmlparse.c:557
#define NEW(t)
Definition: memory.h:35
YYSTYPE * htmlvaluep
Definition: htmlparse.c:1660
textspan_t * items
Definition: htmltable.h:50
unsigned char ruled
Definition: htmltable.h:153