← Back to branch summary

~ubuntu-branches/ubuntu/vivid/tidy/vivid-updates

« back to all changes in this revision

Viewing changes to src/tags.c

  • Committer: Bazaar Package Importer
  • Author(s): Jason Thomas
  • Date: 2008-01-20 21:46:03 UTC
  • mfrom: (0.2.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20080120214603-oqicq5jwr1exrm55
Tags: 20080116cvs-2
http://bugs.debian.org/461608
http://bugs.debian.org/461623
* debian/control: build depends on xsltproc
  (closes: #461608)
* debian/tidy.preinst,postinst: add code to move old config file
  (closes: #461623)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/tags.c
1
1
/* tags.c -- recognize HTML tags
2
2
 
3
 
  (c) 1998-2005 (W3C) MIT, ERCIM, Keio University
 
3
  (c) 1998-2006 (W3C) MIT, ERCIM, Keio University
4
4
  See tidy.h for the copyright notice.
5
5
 
6
6
  CVS Info :
7
7
 
8
8
    $Author: arnaud02 $ 
9
 
    $Date: 2005/09/19 16:23:39 $ 
10
 
    $Revision: 1.58 $ 
 
9
    $Date: 2006/12/29 16:31:08 $ 
 
10
    $Revision: 1.69 $ 
11
11
 
12
12
  The HTML tags are stored as 8 bit ASCII strings.
13
13
 
14
14
*/
15
15
 
16
 
#include "tags.h"
17
16
#include "tidy-int.h"
18
17
#include "message.h"
19
18
#include "tmbstr.h"
20
19
 
 
20
/* Attribute checking methods */
 
21
static CheckAttribs CheckIMG;
 
22
static CheckAttribs CheckLINK;
 
23
static CheckAttribs CheckAREA;
 
24
static CheckAttribs CheckTABLE;
 
25
static CheckAttribs CheckCaption;
 
26
static CheckAttribs CheckSCRIPT;
 
27
static CheckAttribs CheckSTYLE;
 
28
static CheckAttribs CheckHTML;
 
29
static CheckAttribs CheckFORM;
 
30
static CheckAttribs CheckMETA;
 
31
 
21
32
#define VERS_ELEM_A          (HT20|HT32|H40T|H41T|X10T|H40F|H41F|X10F|H40S|H41S|X10S|XH11|XB10)
22
33
#define VERS_ELEM_ABBR       (xxxx|xxxx|H40T|H41T|X10T|H40F|H41F|X10F|H40S|H41S|X10S|XH11|XB10)
23
34
#define VERS_ELEM_ACRONYM    (xxxx|xxxx|H40T|H41T|X10T|H40F|H41F|X10F|H40S|H41S|X10S|XH11|XB10)
125
136
  { TidyTag_UNKNOWN,    "unknown!",   VERS_UNKNOWN,         NULL,                       (0),                                           NULL,          NULL           },
126
137
 
127
138
  /* W3C defined elements */
128
 
  { TidyTag_A,          "a",          VERS_ELEM_A,          &W3CAttrsFor_A[0],          (CM_INLINE),                                   ParseInline,   NULL           },
129
 
  { TidyTag_ABBR,       "abbr",       VERS_ELEM_ABBR,       &W3CAttrsFor_ABBR[0],       (CM_INLINE),                                   ParseInline,   NULL           },
130
 
  { TidyTag_ACRONYM,    "acronym",    VERS_ELEM_ACRONYM,    &W3CAttrsFor_ACRONYM[0],    (CM_INLINE),                                   ParseInline,   NULL           },
131
 
  { TidyTag_ADDRESS,    "address",    VERS_ELEM_ADDRESS,    &W3CAttrsFor_ADDRESS[0],    (CM_BLOCK),                                    ParseInline,   NULL           },
132
 
  { TidyTag_APPLET,     "applet",     VERS_ELEM_APPLET,     &W3CAttrsFor_APPLET[0],     (CM_OBJECT|CM_IMG|CM_INLINE|CM_PARAM),         ParseBlock,    NULL           },
133
 
  { TidyTag_AREA,       "area",       VERS_ELEM_AREA,       &W3CAttrsFor_AREA[0],       (CM_BLOCK|CM_EMPTY),                           ParseEmpty,    CheckAREA      },
134
 
  { TidyTag_B,          "b",          VERS_ELEM_B,          &W3CAttrsFor_B[0],          (CM_INLINE),                                   ParseInline,   NULL           },
135
 
  { TidyTag_BASE,       "base",       VERS_ELEM_BASE,       &W3CAttrsFor_BASE[0],       (CM_HEAD|CM_EMPTY),                            ParseEmpty,    NULL           },
136
 
  { TidyTag_BASEFONT,   "basefont",   VERS_ELEM_BASEFONT,   &W3CAttrsFor_BASEFONT[0],   (CM_INLINE|CM_EMPTY),                          ParseEmpty,    NULL           },
137
 
  { TidyTag_BDO,        "bdo",        VERS_ELEM_BDO,        &W3CAttrsFor_BDO[0],        (CM_INLINE),                                   ParseInline,   NULL           },
138
 
  { TidyTag_BIG,        "big",        VERS_ELEM_BIG,        &W3CAttrsFor_BIG[0],        (CM_INLINE),                                   ParseInline,   NULL           },
139
 
  { TidyTag_BLOCKQUOTE, "blockquote", VERS_ELEM_BLOCKQUOTE, &W3CAttrsFor_BLOCKQUOTE[0], (CM_BLOCK),                                    ParseBlock,    NULL           },
140
 
  { TidyTag_BODY,       "body",       VERS_ELEM_BODY,       &W3CAttrsFor_BODY[0],       (CM_HTML|CM_OPT|CM_OMITST),                    ParseBody,     NULL           },
141
 
  { TidyTag_BR,         "br",         VERS_ELEM_BR,         &W3CAttrsFor_BR[0],         (CM_INLINE|CM_EMPTY),                          ParseEmpty,    NULL           },
142
 
  { TidyTag_BUTTON,     "button",     VERS_ELEM_BUTTON,     &W3CAttrsFor_BUTTON[0],     (CM_INLINE),                                   ParseInline,   NULL           },
143
 
  { TidyTag_CAPTION,    "caption",    VERS_ELEM_CAPTION,    &W3CAttrsFor_CAPTION[0],    (CM_TABLE),                                    ParseInline,   CheckCaption   },
144
 
  { TidyTag_CENTER,     "center",     VERS_ELEM_CENTER,     &W3CAttrsFor_CENTER[0],     (CM_BLOCK),                                    ParseBlock,    NULL           },
145
 
  { TidyTag_CITE,       "cite",       VERS_ELEM_CITE,       &W3CAttrsFor_CITE[0],       (CM_INLINE),                                   ParseInline,   NULL           },
146
 
  { TidyTag_CODE,       "code",       VERS_ELEM_CODE,       &W3CAttrsFor_CODE[0],       (CM_INLINE),                                   ParseInline,   NULL           },
147
 
  { TidyTag_COL,        "col",        VERS_ELEM_COL,        &W3CAttrsFor_COL[0],        (CM_TABLE|CM_EMPTY),                           ParseEmpty,    NULL           },
148
 
  { TidyTag_COLGROUP,   "colgroup",   VERS_ELEM_COLGROUP,   &W3CAttrsFor_COLGROUP[0],   (CM_TABLE|CM_OPT),                             ParseColGroup, NULL           },
149
 
  { TidyTag_DD,         "dd",         VERS_ELEM_DD,         &W3CAttrsFor_DD[0],         (CM_DEFLIST|CM_OPT|CM_NO_INDENT),              ParseBlock,    NULL           },
150
 
  { TidyTag_DEL,        "del",        VERS_ELEM_DEL,        &W3CAttrsFor_DEL[0],        (CM_INLINE|CM_BLOCK|CM_MIXED),                 ParseInline,   NULL           },
151
 
  { TidyTag_DFN,        "dfn",        VERS_ELEM_DFN,        &W3CAttrsFor_DFN[0],        (CM_INLINE),                                   ParseInline,   NULL           },
152
 
  { TidyTag_DIR,        "dir",        VERS_ELEM_DIR,        &W3CAttrsFor_DIR[0],        (CM_BLOCK|CM_OBSOLETE),                        ParseList,     NULL           },
153
 
  { TidyTag_DIV,        "div",        VERS_ELEM_DIV,        &W3CAttrsFor_DIV[0],        (CM_BLOCK),                                    ParseBlock,    NULL           },
154
 
  { TidyTag_DL,         "dl",         VERS_ELEM_DL,         &W3CAttrsFor_DL[0],         (CM_BLOCK),                                    ParseDefList,  NULL           },
155
 
  { TidyTag_DT,         "dt",         VERS_ELEM_DT,         &W3CAttrsFor_DT[0],         (CM_DEFLIST|CM_OPT|CM_NO_INDENT),              ParseInline,   NULL           },
156
 
  { TidyTag_EM,         "em",         VERS_ELEM_EM,         &W3CAttrsFor_EM[0],         (CM_INLINE),                                   ParseInline,   NULL           },
157
 
  { TidyTag_FIELDSET,   "fieldset",   VERS_ELEM_FIELDSET,   &W3CAttrsFor_FIELDSET[0],   (CM_BLOCK),                                    ParseBlock,    NULL           },
158
 
  { TidyTag_FONT,       "font",       VERS_ELEM_FONT,       &W3CAttrsFor_FONT[0],       (CM_INLINE),                                   ParseInline,   NULL           },
159
 
  { TidyTag_FORM,       "form",       VERS_ELEM_FORM,       &W3CAttrsFor_FORM[0],       (CM_BLOCK),                                    ParseBlock,    CheckFORM      },
160
 
  { TidyTag_FRAME,      "frame",      VERS_ELEM_FRAME,      &W3CAttrsFor_FRAME[0],      (CM_FRAMES|CM_EMPTY),                          ParseEmpty,    NULL           },
161
 
  { TidyTag_FRAMESET,   "frameset",   VERS_ELEM_FRAMESET,   &W3CAttrsFor_FRAMESET[0],   (CM_HTML|CM_FRAMES),                           ParseFrameSet, NULL           },
162
 
  { TidyTag_H1,         "h1",         VERS_ELEM_H1,         &W3CAttrsFor_H1[0],         (CM_BLOCK|CM_HEADING),                         ParseInline,   NULL           },
163
 
  { TidyTag_H2,         "h2",         VERS_ELEM_H2,         &W3CAttrsFor_H2[0],         (CM_BLOCK|CM_HEADING),                         ParseInline,   NULL           },
164
 
  { TidyTag_H3,         "h3",         VERS_ELEM_H3,         &W3CAttrsFor_H3[0],         (CM_BLOCK|CM_HEADING),                         ParseInline,   NULL           },
165
 
  { TidyTag_H4,         "h4",         VERS_ELEM_H4,         &W3CAttrsFor_H4[0],         (CM_BLOCK|CM_HEADING),                         ParseInline,   NULL           },
166
 
  { TidyTag_H5,         "h5",         VERS_ELEM_H5,         &W3CAttrsFor_H5[0],         (CM_BLOCK|CM_HEADING),                         ParseInline,   NULL           },
167
 
  { TidyTag_H6,         "h6",         VERS_ELEM_H6,         &W3CAttrsFor_H6[0],         (CM_BLOCK|CM_HEADING),                         ParseInline,   NULL           },
168
 
  { TidyTag_HEAD,       "head",       VERS_ELEM_HEAD,       &W3CAttrsFor_HEAD[0],       (CM_HTML|CM_OPT|CM_OMITST),                    ParseHead,     NULL           },
169
 
  { TidyTag_HR,         "hr",         VERS_ELEM_HR,         &W3CAttrsFor_HR[0],         (CM_BLOCK|CM_EMPTY),                           ParseEmpty,    NULL           },
170
 
  { TidyTag_HTML,       "html",       VERS_ELEM_HTML,       &W3CAttrsFor_HTML[0],       (CM_HTML|CM_OPT|CM_OMITST),                    ParseHTML,     CheckHTML      },
171
 
  { TidyTag_I,          "i",          VERS_ELEM_I,          &W3CAttrsFor_I[0],          (CM_INLINE),                                   ParseInline,   NULL           },
172
 
  { TidyTag_IFRAME,     "iframe",     VERS_ELEM_IFRAME,     &W3CAttrsFor_IFRAME[0],     (CM_INLINE),                                   ParseBlock,    NULL           },
173
 
  { TidyTag_IMG,        "img",        VERS_ELEM_IMG,        &W3CAttrsFor_IMG[0],        (CM_INLINE|CM_IMG|CM_EMPTY),                   ParseEmpty,    CheckIMG       },
174
 
  { TidyTag_INPUT,      "input",      VERS_ELEM_INPUT,      &W3CAttrsFor_INPUT[0],      (CM_INLINE|CM_IMG|CM_EMPTY),                   ParseEmpty,    NULL           },
175
 
  { TidyTag_INS,        "ins",        VERS_ELEM_INS,        &W3CAttrsFor_INS[0],        (CM_INLINE|CM_BLOCK|CM_MIXED),                 ParseInline,   NULL           },
176
 
  { TidyTag_ISINDEX,    "isindex",    VERS_ELEM_ISINDEX,    &W3CAttrsFor_ISINDEX[0],    (CM_BLOCK|CM_EMPTY),                           ParseEmpty,    NULL           },
177
 
  { TidyTag_KBD,        "kbd",        VERS_ELEM_KBD,        &W3CAttrsFor_KBD[0],        (CM_INLINE),                                   ParseInline,   NULL           },
178
 
  { TidyTag_LABEL,      "label",      VERS_ELEM_LABEL,      &W3CAttrsFor_LABEL[0],      (CM_INLINE),                                   ParseInline,   NULL           },
179
 
  { TidyTag_LEGEND,     "legend",     VERS_ELEM_LEGEND,     &W3CAttrsFor_LEGEND[0],     (CM_INLINE),                                   ParseInline,   NULL           },
180
 
  { TidyTag_LI,         "li",         VERS_ELEM_LI,         &W3CAttrsFor_LI[0],         (CM_LIST|CM_OPT|CM_NO_INDENT),                 ParseBlock,    NULL           },
181
 
  { TidyTag_LINK,       "link",       VERS_ELEM_LINK,       &W3CAttrsFor_LINK[0],       (CM_HEAD|CM_EMPTY),                            ParseEmpty,    CheckLINK      },
182
 
  { TidyTag_LISTING,    "listing",    VERS_ELEM_LISTING,    &W3CAttrsFor_LISTING[0],    (CM_BLOCK|CM_OBSOLETE),                        ParsePre,      NULL           },
183
 
  { TidyTag_MAP,        "map",        VERS_ELEM_MAP,        &W3CAttrsFor_MAP[0],        (CM_INLINE),                                   ParseBlock,    NULL           },
184
 
  { TidyTag_MENU,       "menu",       VERS_ELEM_MENU,       &W3CAttrsFor_MENU[0],       (CM_BLOCK|CM_OBSOLETE),                        ParseList,     NULL           },
185
 
  { TidyTag_META,       "meta",       VERS_ELEM_META,       &W3CAttrsFor_META[0],       (CM_HEAD|CM_EMPTY),                            ParseEmpty,    CheckMETA      },
186
 
  { TidyTag_NOFRAMES,   "noframes",   VERS_ELEM_NOFRAMES,   &W3CAttrsFor_NOFRAMES[0],   (CM_BLOCK|CM_FRAMES),                          ParseNoFrames, NULL           },
187
 
  { TidyTag_NOSCRIPT,   "noscript",   VERS_ELEM_NOSCRIPT,   &W3CAttrsFor_NOSCRIPT[0],   (CM_BLOCK|CM_INLINE|CM_MIXED),                 ParseBlock,    NULL           },
188
 
  { TidyTag_OBJECT,     "object",     VERS_ELEM_OBJECT,     &W3CAttrsFor_OBJECT[0],     (CM_OBJECT|CM_HEAD|CM_IMG|CM_INLINE|CM_PARAM), ParseBlock,    NULL           },
189
 
  { TidyTag_OL,         "ol",         VERS_ELEM_OL,         &W3CAttrsFor_OL[0],         (CM_BLOCK),                                    ParseList,     NULL           },
190
 
  { TidyTag_OPTGROUP,   "optgroup",   VERS_ELEM_OPTGROUP,   &W3CAttrsFor_OPTGROUP[0],   (CM_FIELD|CM_OPT),                             ParseOptGroup, NULL           },
191
 
  { TidyTag_OPTION,     "option",     VERS_ELEM_OPTION,     &W3CAttrsFor_OPTION[0],     (CM_FIELD|CM_OPT),                             ParseText,     NULL           },
192
 
  { TidyTag_P,          "p",          VERS_ELEM_P,          &W3CAttrsFor_P[0],          (CM_BLOCK|CM_OPT),                             ParseInline,   NULL           },
193
 
  { TidyTag_PARAM,      "param",      VERS_ELEM_PARAM,      &W3CAttrsFor_PARAM[0],      (CM_INLINE|CM_EMPTY),                          ParseEmpty,    NULL           },
194
 
  { TidyTag_PLAINTEXT,  "plaintext",  VERS_ELEM_PLAINTEXT,  &W3CAttrsFor_PLAINTEXT[0],  (CM_BLOCK|CM_OBSOLETE),                        ParsePre,      NULL           },
195
 
  { TidyTag_PRE,        "pre",        VERS_ELEM_PRE,        &W3CAttrsFor_PRE[0],        (CM_BLOCK),                                    ParsePre,      NULL           },
196
 
  { TidyTag_Q,          "q",          VERS_ELEM_Q,          &W3CAttrsFor_Q[0],          (CM_INLINE),                                   ParseInline,   NULL           },
197
 
  { TidyTag_RB,         "rb",         VERS_ELEM_RB,         &W3CAttrsFor_RB[0],         (CM_INLINE),                                   ParseInline,   NULL           },
198
 
  { TidyTag_RBC,        "rbc",        VERS_ELEM_RBC,        &W3CAttrsFor_RBC[0],        (CM_INLINE),                                   ParseInline,   NULL           },
199
 
  { TidyTag_RP,         "rp",         VERS_ELEM_RP,         &W3CAttrsFor_RP[0],         (CM_INLINE),                                   ParseInline,   NULL           },
200
 
  { TidyTag_RT,         "rt",         VERS_ELEM_RT,         &W3CAttrsFor_RT[0],         (CM_INLINE),                                   ParseInline,   NULL           },
201
 
  { TidyTag_RTC,        "rtc",        VERS_ELEM_RTC,        &W3CAttrsFor_RTC[0],        (CM_INLINE),                                   ParseInline,   NULL           },
202
 
  { TidyTag_RUBY,       "ruby",       VERS_ELEM_RUBY,       &W3CAttrsFor_RUBY[0],       (CM_INLINE),                                   ParseInline,   NULL           },
203
 
  { TidyTag_S,          "s",          VERS_ELEM_S,          &W3CAttrsFor_S[0],          (CM_INLINE),                                   ParseInline,   NULL           },
204
 
  { TidyTag_SAMP,       "samp",       VERS_ELEM_SAMP,       &W3CAttrsFor_SAMP[0],       (CM_INLINE),                                   ParseInline,   NULL           },
205
 
  { TidyTag_SCRIPT,     "script",     VERS_ELEM_SCRIPT,     &W3CAttrsFor_SCRIPT[0],     (CM_HEAD|CM_MIXED|CM_BLOCK|CM_INLINE),         ParseScript,   CheckSCRIPT    },
206
 
  { TidyTag_SELECT,     "select",     VERS_ELEM_SELECT,     &W3CAttrsFor_SELECT[0],     (CM_INLINE|CM_FIELD),                          ParseSelect,   NULL           },
207
 
  { TidyTag_SMALL,      "small",      VERS_ELEM_SMALL,      &W3CAttrsFor_SMALL[0],      (CM_INLINE),                                   ParseInline,   NULL           },
208
 
  { TidyTag_SPAN,       "span",       VERS_ELEM_SPAN,       &W3CAttrsFor_SPAN[0],       (CM_INLINE),                                   ParseInline,   NULL           },
209
 
  { TidyTag_STRIKE,     "strike",     VERS_ELEM_STRIKE,     &W3CAttrsFor_STRIKE[0],     (CM_INLINE),                                   ParseInline,   NULL           },
210
 
  { TidyTag_STRONG,     "strong",     VERS_ELEM_STRONG,     &W3CAttrsFor_STRONG[0],     (CM_INLINE),                                   ParseInline,   NULL           },
211
 
  { TidyTag_STYLE,      "style",      VERS_ELEM_STYLE,      &W3CAttrsFor_STYLE[0],      (CM_HEAD),                                     ParseScript,   CheckSTYLE     },
212
 
  { TidyTag_SUB,        "sub",        VERS_ELEM_SUB,        &W3CAttrsFor_SUB[0],        (CM_INLINE),                                   ParseInline,   NULL           },
213
 
  { TidyTag_SUP,        "sup",        VERS_ELEM_SUP,        &W3CAttrsFor_SUP[0],        (CM_INLINE),                                   ParseInline,   NULL           },
214
 
  { TidyTag_TABLE,      "table",      VERS_ELEM_TABLE,      &W3CAttrsFor_TABLE[0],      (CM_BLOCK),                                    ParseTableTag, CheckTABLE     },
215
 
  { TidyTag_TBODY,      "tbody",      VERS_ELEM_TBODY,      &W3CAttrsFor_TBODY[0],      (CM_TABLE|CM_ROWGRP|CM_OPT),                   ParseRowGroup, NULL           },
216
 
  { TidyTag_TD,         "td",         VERS_ELEM_TD,         &W3CAttrsFor_TD[0],         (CM_ROW|CM_OPT|CM_NO_INDENT),                  ParseBlock,    NULL           },
217
 
  { TidyTag_TEXTAREA,   "textarea",   VERS_ELEM_TEXTAREA,   &W3CAttrsFor_TEXTAREA[0],   (CM_INLINE|CM_FIELD),                          ParseText,     NULL           },
218
 
  { TidyTag_TFOOT,      "tfoot",      VERS_ELEM_TFOOT,      &W3CAttrsFor_TFOOT[0],      (CM_TABLE|CM_ROWGRP|CM_OPT),                   ParseRowGroup, NULL           },
219
 
  { TidyTag_TH,         "th",         VERS_ELEM_TH,         &W3CAttrsFor_TH[0],         (CM_ROW|CM_OPT|CM_NO_INDENT),                  ParseBlock,    NULL           },
220
 
  { TidyTag_THEAD,      "thead",      VERS_ELEM_THEAD,      &W3CAttrsFor_THEAD[0],      (CM_TABLE|CM_ROWGRP|CM_OPT),                   ParseRowGroup, NULL           },
221
 
  { TidyTag_TITLE,      "title",      VERS_ELEM_TITLE,      &W3CAttrsFor_TITLE[0],      (CM_HEAD),                                     ParseTitle,    NULL           },
222
 
  { TidyTag_TR,         "tr",         VERS_ELEM_TR,         &W3CAttrsFor_TR[0],         (CM_TABLE|CM_OPT),                             ParseRow,      NULL           },
223
 
  { TidyTag_TT,         "tt",         VERS_ELEM_TT,         &W3CAttrsFor_TT[0],         (CM_INLINE),                                   ParseInline,   NULL           },
224
 
  { TidyTag_U,          "u",          VERS_ELEM_U,          &W3CAttrsFor_U[0],          (CM_INLINE),                                   ParseInline,   NULL           },
225
 
  { TidyTag_UL,         "ul",         VERS_ELEM_UL,         &W3CAttrsFor_UL[0],         (CM_BLOCK),                                    ParseList,     NULL           },
226
 
  { TidyTag_VAR,        "var",        VERS_ELEM_VAR,        &W3CAttrsFor_VAR[0],        (CM_INLINE),                                   ParseInline,   NULL           },
227
 
  { TidyTag_XMP,        "xmp",        VERS_ELEM_XMP,        &W3CAttrsFor_XMP[0],        (CM_BLOCK|CM_OBSOLETE),                        ParsePre,      NULL           },
228
 
  { TidyTag_NEXTID,     "nextid",     VERS_ELEM_NEXTID,     &W3CAttrsFor_NEXTID[0],     (CM_HEAD|CM_EMPTY),                            ParseEmpty,    NULL           },
 
139
  { TidyTag_A,          "a",          VERS_ELEM_A,          &TY_(W3CAttrsFor_A)[0],          (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
140
  { TidyTag_ABBR,       "abbr",       VERS_ELEM_ABBR,       &TY_(W3CAttrsFor_ABBR)[0],       (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
141
  { TidyTag_ACRONYM,    "acronym",    VERS_ELEM_ACRONYM,    &TY_(W3CAttrsFor_ACRONYM)[0],    (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
142
  { TidyTag_ADDRESS,    "address",    VERS_ELEM_ADDRESS,    &TY_(W3CAttrsFor_ADDRESS)[0],    (CM_BLOCK),                                    TY_(ParseInline),   NULL           },
 
143
  { TidyTag_APPLET,     "applet",     VERS_ELEM_APPLET,     &TY_(W3CAttrsFor_APPLET)[0],     (CM_OBJECT|CM_IMG|CM_INLINE|CM_PARAM),         TY_(ParseBlock),    NULL           },
 
144
  { TidyTag_AREA,       "area",       VERS_ELEM_AREA,       &TY_(W3CAttrsFor_AREA)[0],       (CM_BLOCK|CM_EMPTY),                           TY_(ParseEmpty),    CheckAREA      },
 
145
  { TidyTag_B,          "b",          VERS_ELEM_B,          &TY_(W3CAttrsFor_B)[0],          (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
146
  { TidyTag_BASE,       "base",       VERS_ELEM_BASE,       &TY_(W3CAttrsFor_BASE)[0],       (CM_HEAD|CM_EMPTY),                            TY_(ParseEmpty),    NULL           },
 
147
  { TidyTag_BASEFONT,   "basefont",   VERS_ELEM_BASEFONT,   &TY_(W3CAttrsFor_BASEFONT)[0],   (CM_INLINE|CM_EMPTY),                          TY_(ParseEmpty),    NULL           },
 
148
  { TidyTag_BDO,        "bdo",        VERS_ELEM_BDO,        &TY_(W3CAttrsFor_BDO)[0],        (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
149
  { TidyTag_BIG,        "big",        VERS_ELEM_BIG,        &TY_(W3CAttrsFor_BIG)[0],        (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
150
  { TidyTag_BLOCKQUOTE, "blockquote", VERS_ELEM_BLOCKQUOTE, &TY_(W3CAttrsFor_BLOCKQUOTE)[0], (CM_BLOCK),                                    TY_(ParseBlock),    NULL           },
 
151
  { TidyTag_BODY,       "body",       VERS_ELEM_BODY,       &TY_(W3CAttrsFor_BODY)[0],       (CM_HTML|CM_OPT|CM_OMITST),                    TY_(ParseBody),     NULL           },
 
152
  { TidyTag_BR,         "br",         VERS_ELEM_BR,         &TY_(W3CAttrsFor_BR)[0],         (CM_INLINE|CM_EMPTY),                          TY_(ParseEmpty),    NULL           },
 
153
  { TidyTag_BUTTON,     "button",     VERS_ELEM_BUTTON,     &TY_(W3CAttrsFor_BUTTON)[0],     (CM_INLINE),                                   TY_(ParseBlock),    NULL           },
 
154
  { TidyTag_CAPTION,    "caption",    VERS_ELEM_CAPTION,    &TY_(W3CAttrsFor_CAPTION)[0],    (CM_TABLE),                                    TY_(ParseInline),   CheckCaption   },
 
155
  { TidyTag_CENTER,     "center",     VERS_ELEM_CENTER,     &TY_(W3CAttrsFor_CENTER)[0],     (CM_BLOCK),                                    TY_(ParseBlock),    NULL           },
 
156
  { TidyTag_CITE,       "cite",       VERS_ELEM_CITE,       &TY_(W3CAttrsFor_CITE)[0],       (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
157
  { TidyTag_CODE,       "code",       VERS_ELEM_CODE,       &TY_(W3CAttrsFor_CODE)[0],       (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
158
  { TidyTag_COL,        "col",        VERS_ELEM_COL,        &TY_(W3CAttrsFor_COL)[0],        (CM_TABLE|CM_EMPTY),                           TY_(ParseEmpty),    NULL           },
 
159
  { TidyTag_COLGROUP,   "colgroup",   VERS_ELEM_COLGROUP,   &TY_(W3CAttrsFor_COLGROUP)[0],   (CM_TABLE|CM_OPT),                             TY_(ParseColGroup), NULL           },
 
160
  { TidyTag_DD,         "dd",         VERS_ELEM_DD,         &TY_(W3CAttrsFor_DD)[0],         (CM_DEFLIST|CM_OPT|CM_NO_INDENT),              TY_(ParseBlock),    NULL           },
 
161
  { TidyTag_DEL,        "del",        VERS_ELEM_DEL,        &TY_(W3CAttrsFor_DEL)[0],        (CM_INLINE|CM_BLOCK|CM_MIXED),                 TY_(ParseInline),   NULL           },
 
162
  { TidyTag_DFN,        "dfn",        VERS_ELEM_DFN,        &TY_(W3CAttrsFor_DFN)[0],        (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
163
  { TidyTag_DIR,        "dir",        VERS_ELEM_DIR,        &TY_(W3CAttrsFor_DIR)[0],        (CM_BLOCK|CM_OBSOLETE),                        TY_(ParseList),     NULL           },
 
164
  { TidyTag_DIV,        "div",        VERS_ELEM_DIV,        &TY_(W3CAttrsFor_DIV)[0],        (CM_BLOCK),                                    TY_(ParseBlock),    NULL           },
 
165
  { TidyTag_DL,         "dl",         VERS_ELEM_DL,         &TY_(W3CAttrsFor_DL)[0],         (CM_BLOCK),                                    TY_(ParseDefList),  NULL           },
 
166
  { TidyTag_DT,         "dt",         VERS_ELEM_DT,         &TY_(W3CAttrsFor_DT)[0],         (CM_DEFLIST|CM_OPT|CM_NO_INDENT),              TY_(ParseInline),   NULL           },
 
167
  { TidyTag_EM,         "em",         VERS_ELEM_EM,         &TY_(W3CAttrsFor_EM)[0],         (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
168
  { TidyTag_FIELDSET,   "fieldset",   VERS_ELEM_FIELDSET,   &TY_(W3CAttrsFor_FIELDSET)[0],   (CM_BLOCK),                                    TY_(ParseBlock),    NULL           },
 
169
  { TidyTag_FONT,       "font",       VERS_ELEM_FONT,       &TY_(W3CAttrsFor_FONT)[0],       (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
170
  { TidyTag_FORM,       "form",       VERS_ELEM_FORM,       &TY_(W3CAttrsFor_FORM)[0],       (CM_BLOCK),                                    TY_(ParseBlock),    CheckFORM      },
 
171
  { TidyTag_FRAME,      "frame",      VERS_ELEM_FRAME,      &TY_(W3CAttrsFor_FRAME)[0],      (CM_FRAMES|CM_EMPTY),                          TY_(ParseEmpty),    NULL           },
 
172
  { TidyTag_FRAMESET,   "frameset",   VERS_ELEM_FRAMESET,   &TY_(W3CAttrsFor_FRAMESET)[0],   (CM_HTML|CM_FRAMES),                           TY_(ParseFrameSet), NULL           },
 
173
  { TidyTag_H1,         "h1",         VERS_ELEM_H1,         &TY_(W3CAttrsFor_H1)[0],         (CM_BLOCK|CM_HEADING),                         TY_(ParseInline),   NULL           },
 
174
  { TidyTag_H2,         "h2",         VERS_ELEM_H2,         &TY_(W3CAttrsFor_H2)[0],         (CM_BLOCK|CM_HEADING),                         TY_(ParseInline),   NULL           },
 
175
  { TidyTag_H3,         "h3",         VERS_ELEM_H3,         &TY_(W3CAttrsFor_H3)[0],         (CM_BLOCK|CM_HEADING),                         TY_(ParseInline),   NULL           },
 
176
  { TidyTag_H4,         "h4",         VERS_ELEM_H4,         &TY_(W3CAttrsFor_H4)[0],         (CM_BLOCK|CM_HEADING),                         TY_(ParseInline),   NULL           },
 
177
  { TidyTag_H5,         "h5",         VERS_ELEM_H5,         &TY_(W3CAttrsFor_H5)[0],         (CM_BLOCK|CM_HEADING),                         TY_(ParseInline),   NULL           },
 
178
  { TidyTag_H6,         "h6",         VERS_ELEM_H6,         &TY_(W3CAttrsFor_H6)[0],         (CM_BLOCK|CM_HEADING),                         TY_(ParseInline),   NULL           },
 
179
  { TidyTag_HEAD,       "head",       VERS_ELEM_HEAD,       &TY_(W3CAttrsFor_HEAD)[0],       (CM_HTML|CM_OPT|CM_OMITST),                    TY_(ParseHead),     NULL           },
 
180
  { TidyTag_HR,         "hr",         VERS_ELEM_HR,         &TY_(W3CAttrsFor_HR)[0],         (CM_BLOCK|CM_EMPTY),                           TY_(ParseEmpty),    NULL           },
 
181
  { TidyTag_HTML,       "html",       VERS_ELEM_HTML,       &TY_(W3CAttrsFor_HTML)[0],       (CM_HTML|CM_OPT|CM_OMITST),                    TY_(ParseHTML),     CheckHTML      },
 
182
  { TidyTag_I,          "i",          VERS_ELEM_I,          &TY_(W3CAttrsFor_I)[0],          (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
183
  { TidyTag_IFRAME,     "iframe",     VERS_ELEM_IFRAME,     &TY_(W3CAttrsFor_IFRAME)[0],     (CM_INLINE),                                   TY_(ParseBlock),    NULL           },
 
184
  { TidyTag_IMG,        "img",        VERS_ELEM_IMG,        &TY_(W3CAttrsFor_IMG)[0],        (CM_INLINE|CM_IMG|CM_EMPTY),                   TY_(ParseEmpty),    CheckIMG       },
 
185
  { TidyTag_INPUT,      "input",      VERS_ELEM_INPUT,      &TY_(W3CAttrsFor_INPUT)[0],      (CM_INLINE|CM_IMG|CM_EMPTY),                   TY_(ParseEmpty),    NULL           },
 
186
  { TidyTag_INS,        "ins",        VERS_ELEM_INS,        &TY_(W3CAttrsFor_INS)[0],        (CM_INLINE|CM_BLOCK|CM_MIXED),                 TY_(ParseInline),   NULL           },
 
187
  { TidyTag_ISINDEX,    "isindex",    VERS_ELEM_ISINDEX,    &TY_(W3CAttrsFor_ISINDEX)[0],    (CM_BLOCK|CM_EMPTY),                           TY_(ParseEmpty),    NULL           },
 
188
  { TidyTag_KBD,        "kbd",        VERS_ELEM_KBD,        &TY_(W3CAttrsFor_KBD)[0],        (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
189
  { TidyTag_LABEL,      "label",      VERS_ELEM_LABEL,      &TY_(W3CAttrsFor_LABEL)[0],      (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
190
  { TidyTag_LEGEND,     "legend",     VERS_ELEM_LEGEND,     &TY_(W3CAttrsFor_LEGEND)[0],     (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
191
  { TidyTag_LI,         "li",         VERS_ELEM_LI,         &TY_(W3CAttrsFor_LI)[0],         (CM_LIST|CM_OPT|CM_NO_INDENT),                 TY_(ParseBlock),    NULL           },
 
192
  { TidyTag_LINK,       "link",       VERS_ELEM_LINK,       &TY_(W3CAttrsFor_LINK)[0],       (CM_HEAD|CM_EMPTY),                            TY_(ParseEmpty),    CheckLINK      },
 
193
  { TidyTag_LISTING,    "listing",    VERS_ELEM_LISTING,    &TY_(W3CAttrsFor_LISTING)[0],    (CM_BLOCK|CM_OBSOLETE),                        TY_(ParsePre),      NULL           },
 
194
  { TidyTag_MAP,        "map",        VERS_ELEM_MAP,        &TY_(W3CAttrsFor_MAP)[0],        (CM_INLINE),                                   TY_(ParseBlock),    NULL           },
 
195
  { TidyTag_MENU,       "menu",       VERS_ELEM_MENU,       &TY_(W3CAttrsFor_MENU)[0],       (CM_BLOCK|CM_OBSOLETE),                        TY_(ParseList),     NULL           },
 
196
  { TidyTag_META,       "meta",       VERS_ELEM_META,       &TY_(W3CAttrsFor_META)[0],       (CM_HEAD|CM_EMPTY),                            TY_(ParseEmpty),    CheckMETA      },
 
197
  { TidyTag_NOFRAMES,   "noframes",   VERS_ELEM_NOFRAMES,   &TY_(W3CAttrsFor_NOFRAMES)[0],   (CM_BLOCK|CM_FRAMES),                          TY_(ParseNoFrames), NULL           },
 
198
  { TidyTag_NOSCRIPT,   "noscript",   VERS_ELEM_NOSCRIPT,   &TY_(W3CAttrsFor_NOSCRIPT)[0],   (CM_BLOCK|CM_INLINE|CM_MIXED),                 TY_(ParseBlock),    NULL           },
 
199
  { TidyTag_OBJECT,     "object",     VERS_ELEM_OBJECT,     &TY_(W3CAttrsFor_OBJECT)[0],     (CM_OBJECT|CM_HEAD|CM_IMG|CM_INLINE|CM_PARAM), TY_(ParseBlock),    NULL           },
 
200
  { TidyTag_OL,         "ol",         VERS_ELEM_OL,         &TY_(W3CAttrsFor_OL)[0],         (CM_BLOCK),                                    TY_(ParseList),     NULL           },
 
201
  { TidyTag_OPTGROUP,   "optgroup",   VERS_ELEM_OPTGROUP,   &TY_(W3CAttrsFor_OPTGROUP)[0],   (CM_FIELD|CM_OPT),                             TY_(ParseOptGroup), NULL           },
 
202
  { TidyTag_OPTION,     "option",     VERS_ELEM_OPTION,     &TY_(W3CAttrsFor_OPTION)[0],     (CM_FIELD|CM_OPT),                             TY_(ParseText),     NULL           },
 
203
  { TidyTag_P,          "p",          VERS_ELEM_P,          &TY_(W3CAttrsFor_P)[0],          (CM_BLOCK|CM_OPT),                             TY_(ParseInline),   NULL           },
 
204
  { TidyTag_PARAM,      "param",      VERS_ELEM_PARAM,      &TY_(W3CAttrsFor_PARAM)[0],      (CM_INLINE|CM_EMPTY),                          TY_(ParseEmpty),    NULL           },
 
205
  { TidyTag_PLAINTEXT,  "plaintext",  VERS_ELEM_PLAINTEXT,  &TY_(W3CAttrsFor_PLAINTEXT)[0],  (CM_BLOCK|CM_OBSOLETE),                        TY_(ParsePre),      NULL           },
 
206
  { TidyTag_PRE,        "pre",        VERS_ELEM_PRE,        &TY_(W3CAttrsFor_PRE)[0],        (CM_BLOCK),                                    TY_(ParsePre),      NULL           },
 
207
  { TidyTag_Q,          "q",          VERS_ELEM_Q,          &TY_(W3CAttrsFor_Q)[0],          (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
208
  { TidyTag_RB,         "rb",         VERS_ELEM_RB,         &TY_(W3CAttrsFor_RB)[0],         (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
209
  { TidyTag_RBC,        "rbc",        VERS_ELEM_RBC,        &TY_(W3CAttrsFor_RBC)[0],        (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
210
  { TidyTag_RP,         "rp",         VERS_ELEM_RP,         &TY_(W3CAttrsFor_RP)[0],         (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
211
  { TidyTag_RT,         "rt",         VERS_ELEM_RT,         &TY_(W3CAttrsFor_RT)[0],         (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
212
  { TidyTag_RTC,        "rtc",        VERS_ELEM_RTC,        &TY_(W3CAttrsFor_RTC)[0],        (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
213
  { TidyTag_RUBY,       "ruby",       VERS_ELEM_RUBY,       &TY_(W3CAttrsFor_RUBY)[0],       (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
214
  { TidyTag_S,          "s",          VERS_ELEM_S,          &TY_(W3CAttrsFor_S)[0],          (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
215
  { TidyTag_SAMP,       "samp",       VERS_ELEM_SAMP,       &TY_(W3CAttrsFor_SAMP)[0],       (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
216
  { TidyTag_SCRIPT,     "script",     VERS_ELEM_SCRIPT,     &TY_(W3CAttrsFor_SCRIPT)[0],     (CM_HEAD|CM_MIXED|CM_BLOCK|CM_INLINE),         TY_(ParseScript),   CheckSCRIPT    },
 
217
  { TidyTag_SELECT,     "select",     VERS_ELEM_SELECT,     &TY_(W3CAttrsFor_SELECT)[0],     (CM_INLINE|CM_FIELD),                          TY_(ParseSelect),   NULL           },
 
218
  { TidyTag_SMALL,      "small",      VERS_ELEM_SMALL,      &TY_(W3CAttrsFor_SMALL)[0],      (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
219
  { TidyTag_SPAN,       "span",       VERS_ELEM_SPAN,       &TY_(W3CAttrsFor_SPAN)[0],       (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
220
  { TidyTag_STRIKE,     "strike",     VERS_ELEM_STRIKE,     &TY_(W3CAttrsFor_STRIKE)[0],     (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
221
  { TidyTag_STRONG,     "strong",     VERS_ELEM_STRONG,     &TY_(W3CAttrsFor_STRONG)[0],     (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
222
  { TidyTag_STYLE,      "style",      VERS_ELEM_STYLE,      &TY_(W3CAttrsFor_STYLE)[0],      (CM_HEAD),                                     TY_(ParseScript),   CheckSTYLE     },
 
223
  { TidyTag_SUB,        "sub",        VERS_ELEM_SUB,        &TY_(W3CAttrsFor_SUB)[0],        (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
224
  { TidyTag_SUP,        "sup",        VERS_ELEM_SUP,        &TY_(W3CAttrsFor_SUP)[0],        (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
225
  { TidyTag_TABLE,      "table",      VERS_ELEM_TABLE,      &TY_(W3CAttrsFor_TABLE)[0],      (CM_BLOCK),                                    TY_(ParseTableTag), CheckTABLE     },
 
226
  { TidyTag_TBODY,      "tbody",      VERS_ELEM_TBODY,      &TY_(W3CAttrsFor_TBODY)[0],      (CM_TABLE|CM_ROWGRP|CM_OPT),                   TY_(ParseRowGroup), NULL           },
 
227
  { TidyTag_TD,         "td",         VERS_ELEM_TD,         &TY_(W3CAttrsFor_TD)[0],         (CM_ROW|CM_OPT|CM_NO_INDENT),                  TY_(ParseBlock),    NULL           },
 
228
  { TidyTag_TEXTAREA,   "textarea",   VERS_ELEM_TEXTAREA,   &TY_(W3CAttrsFor_TEXTAREA)[0],   (CM_INLINE|CM_FIELD),                          TY_(ParseText),     NULL           },
 
229
  { TidyTag_TFOOT,      "tfoot",      VERS_ELEM_TFOOT,      &TY_(W3CAttrsFor_TFOOT)[0],      (CM_TABLE|CM_ROWGRP|CM_OPT),                   TY_(ParseRowGroup), NULL           },
 
230
  { TidyTag_TH,         "th",         VERS_ELEM_TH,         &TY_(W3CAttrsFor_TH)[0],         (CM_ROW|CM_OPT|CM_NO_INDENT),                  TY_(ParseBlock),    NULL           },
 
231
  { TidyTag_THEAD,      "thead",      VERS_ELEM_THEAD,      &TY_(W3CAttrsFor_THEAD)[0],      (CM_TABLE|CM_ROWGRP|CM_OPT),                   TY_(ParseRowGroup), NULL           },
 
232
  { TidyTag_TITLE,      "title",      VERS_ELEM_TITLE,      &TY_(W3CAttrsFor_TITLE)[0],      (CM_HEAD),                                     TY_(ParseTitle),    NULL           },
 
233
  { TidyTag_TR,         "tr",         VERS_ELEM_TR,         &TY_(W3CAttrsFor_TR)[0],         (CM_TABLE|CM_OPT),                             TY_(ParseRow),      NULL           },
 
234
  { TidyTag_TT,         "tt",         VERS_ELEM_TT,         &TY_(W3CAttrsFor_TT)[0],         (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
235
  { TidyTag_U,          "u",          VERS_ELEM_U,          &TY_(W3CAttrsFor_U)[0],          (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
236
  { TidyTag_UL,         "ul",         VERS_ELEM_UL,         &TY_(W3CAttrsFor_UL)[0],         (CM_BLOCK),                                    TY_(ParseList),     NULL           },
 
237
  { TidyTag_VAR,        "var",        VERS_ELEM_VAR,        &TY_(W3CAttrsFor_VAR)[0],        (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
238
  { TidyTag_XMP,        "xmp",        VERS_ELEM_XMP,        &TY_(W3CAttrsFor_XMP)[0],        (CM_BLOCK|CM_OBSOLETE),                        TY_(ParsePre),      NULL           },
 
239
  { TidyTag_NEXTID,     "nextid",     VERS_ELEM_NEXTID,     &TY_(W3CAttrsFor_NEXTID)[0],     (CM_HEAD|CM_EMPTY),                            TY_(ParseEmpty),    NULL           },
229
240
 
230
241
  /* proprietary elements */
231
 
  { TidyTag_ALIGN,      "align",      VERS_NETSCAPE,        NULL,                       (CM_BLOCK),                                    ParseBlock,    NULL           },
232
 
  { TidyTag_BGSOUND,    "bgsound",    VERS_MICROSOFT,       NULL,                       (CM_HEAD|CM_EMPTY),                            ParseEmpty,    NULL           },
233
 
  { TidyTag_BLINK,      "blink",      VERS_PROPRIETARY,     NULL,                       (CM_INLINE),                                   ParseInline,   NULL           },
234
 
  { TidyTag_COMMENT,    "comment",    VERS_MICROSOFT,       NULL,                       (CM_INLINE),                                   ParseInline,   NULL           },
235
 
  { TidyTag_EMBED,      "embed",      VERS_NETSCAPE,        NULL,                       (CM_INLINE|CM_IMG|CM_EMPTY),                   ParseEmpty,    NULL           },
236
 
  { TidyTag_ILAYER,     "ilayer",     VERS_NETSCAPE,        NULL,                       (CM_INLINE),                                   ParseInline,   NULL           },
237
 
  { TidyTag_KEYGEN,     "keygen",     VERS_NETSCAPE,        NULL,                       (CM_INLINE|CM_EMPTY),                          ParseEmpty,    NULL           },
238
 
  { TidyTag_LAYER,      "layer",      VERS_NETSCAPE,        NULL,                       (CM_BLOCK),                                    ParseBlock,    NULL           },
239
 
  { TidyTag_MARQUEE,    "marquee",    VERS_MICROSOFT,       NULL,                       (CM_INLINE|CM_OPT),                            ParseInline,   NULL           },
240
 
  { TidyTag_MULTICOL,   "multicol",   VERS_NETSCAPE,        NULL,                       (CM_BLOCK),                                    ParseBlock,    NULL           },
241
 
  { TidyTag_NOBR,       "nobr",       VERS_PROPRIETARY,     NULL,                       (CM_INLINE),                                   ParseInline,   NULL           },
242
 
  { TidyTag_NOEMBED,    "noembed",    VERS_NETSCAPE,        NULL,                       (CM_INLINE),                                   ParseInline,   NULL           },
243
 
  { TidyTag_NOLAYER,    "nolayer",    VERS_NETSCAPE,        NULL,                       (CM_BLOCK|CM_INLINE|CM_MIXED),                 ParseBlock,    NULL           },
244
 
  { TidyTag_NOSAVE,     "nosave",     VERS_NETSCAPE,        NULL,                       (CM_BLOCK),                                    ParseBlock,    NULL           },
245
 
  { TidyTag_SERVER,     "server",     VERS_NETSCAPE,        NULL,                       (CM_HEAD|CM_MIXED|CM_BLOCK|CM_INLINE),         ParseScript,   NULL           },
246
 
  { TidyTag_SERVLET,    "servlet",    VERS_SUN,             NULL,                       (CM_OBJECT|CM_IMG|CM_INLINE|CM_PARAM),         ParseBlock,    NULL           },
247
 
  { TidyTag_SPACER,     "spacer",     VERS_NETSCAPE,        NULL,                       (CM_INLINE|CM_EMPTY),                          ParseEmpty,    NULL           },
248
 
  { TidyTag_WBR,        "wbr",        VERS_PROPRIETARY,     NULL,                       (CM_INLINE|CM_EMPTY),                          ParseEmpty,    NULL           },
 
242
  { TidyTag_ALIGN,      "align",      VERS_NETSCAPE,        NULL,                       (CM_BLOCK),                                    TY_(ParseBlock),    NULL           },
 
243
  { TidyTag_BGSOUND,    "bgsound",    VERS_MICROSOFT,       NULL,                       (CM_HEAD|CM_EMPTY),                            TY_(ParseEmpty),    NULL           },
 
244
  { TidyTag_BLINK,      "blink",      VERS_PROPRIETARY,     NULL,                       (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
245
  { TidyTag_COMMENT,    "comment",    VERS_MICROSOFT,       NULL,                       (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
246
  { TidyTag_EMBED,      "embed",      VERS_NETSCAPE,        NULL,                       (CM_INLINE|CM_IMG|CM_EMPTY),                   TY_(ParseEmpty),    NULL           },
 
247
  { TidyTag_ILAYER,     "ilayer",     VERS_NETSCAPE,        NULL,                       (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
248
  { TidyTag_KEYGEN,     "keygen",     VERS_NETSCAPE,        NULL,                       (CM_INLINE|CM_EMPTY),                          TY_(ParseEmpty),    NULL           },
 
249
  { TidyTag_LAYER,      "layer",      VERS_NETSCAPE,        NULL,                       (CM_BLOCK),                                    TY_(ParseBlock),    NULL           },
 
250
  { TidyTag_MARQUEE,    "marquee",    VERS_MICROSOFT,       NULL,                       (CM_INLINE|CM_OPT),                            TY_(ParseInline),   NULL           },
 
251
  { TidyTag_MULTICOL,   "multicol",   VERS_NETSCAPE,        NULL,                       (CM_BLOCK),                                    TY_(ParseBlock),    NULL           },
 
252
  { TidyTag_NOBR,       "nobr",       VERS_PROPRIETARY,     NULL,                       (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
253
  { TidyTag_NOEMBED,    "noembed",    VERS_NETSCAPE,        NULL,                       (CM_INLINE),                                   TY_(ParseInline),   NULL           },
 
254
  { TidyTag_NOLAYER,    "nolayer",    VERS_NETSCAPE,        NULL,                       (CM_BLOCK|CM_INLINE|CM_MIXED),                 TY_(ParseBlock),    NULL           },
 
255
  { TidyTag_NOSAVE,     "nosave",     VERS_NETSCAPE,        NULL,                       (CM_BLOCK),                                    TY_(ParseBlock),    NULL           },
 
256
  { TidyTag_SERVER,     "server",     VERS_NETSCAPE,        NULL,                       (CM_HEAD|CM_MIXED|CM_BLOCK|CM_INLINE),         TY_(ParseScript),   NULL           },
 
257
  { TidyTag_SERVLET,    "servlet",    VERS_SUN,             NULL,                       (CM_OBJECT|CM_IMG|CM_INLINE|CM_PARAM),         TY_(ParseBlock),    NULL           },
 
258
  { TidyTag_SPACER,     "spacer",     VERS_NETSCAPE,        NULL,                       (CM_INLINE|CM_EMPTY),                          TY_(ParseEmpty),    NULL           },
 
259
  { TidyTag_WBR,        "wbr",        VERS_PROPRIETARY,     NULL,                       (CM_INLINE|CM_EMPTY),                          TY_(ParseEmpty),    NULL           },
249
260
 
250
261
  /* this must be the final entry */
251
262
  { (TidyTagId)0,        NULL,         0,                    NULL,                       (0),                                           NULL,          NULL           }
252
263
};
253
264
 
254
 
#ifdef ELEMENT_HASH_LOOKUP
 
265
#if ELEMENT_HASH_LOOKUP
255
266
static uint hash(ctmbstr s)
256
267
{
257
268
    uint hashval;
262
273
    return hashval % ELEMENT_HASH_SIZE;
263
274
}
264
275
 
265
 
static Dict *install(TidyTagImpl* tags, const Dict* old)
 
276
static const Dict *install(TidyDocImpl* doc, TidyTagImpl* tags, const Dict* old)
266
277
{
267
 
    Dict *np;
 
278
    DictHash *np;
268
279
    uint hashval;
269
280
 
270
 
    np = (Dict *)MemAlloc(sizeof(*np));
271
 
    np->name = tmbstrdup(old->name);
272
 
 
273
 
    hashval = hash(np->name);
274
 
    np->next = tags->hashtab[hashval];
275
 
    tags->hashtab[hashval] = np;
276
 
 
277
 
    np->id       = old->id;
278
 
    np->versions = old->versions;
279
 
    np->model    = old->model;
280
 
    np->parser   = old->parser;
281
 
    np->chkattrs = old->chkattrs;
282
 
    np->attrvers = old->attrvers;
283
 
 
284
 
    return np;
 
281
    if (old)
 
282
    {
 
283
        np = (DictHash *)TidyDocAlloc(doc, sizeof(*np));
 
284
        np->tag = old;
 
285
 
 
286
        hashval = hash(old->name);
 
287
        np->next = tags->hashtab[hashval];
 
288
        tags->hashtab[hashval] = np;
 
289
    }
 
290
 
 
291
    return old;
 
292
}
 
293
 
 
294
static void removeFromHash( TidyDocImpl* doc, TidyTagImpl* tags, ctmbstr s )
 
295
{
 
296
    uint h = hash(s);
 
297
    DictHash *p, *prev = NULL;
 
298
    for (p = tags->hashtab[h]; p && p->tag; p = p->next)
 
299
    {
 
300
        if (TY_(tmbstrcmp)(s, p->tag->name) == 0)
 
301
        {
 
302
            DictHash* next = p->next;
 
303
            if ( prev )
 
304
                prev->next = next; 
 
305
            else
 
306
                tags->hashtab[h] = next;
 
307
            TidyDocFree(doc, p);
 
308
            return;
 
309
        }
 
310
        prev = p;
 
311
    }
 
312
}
 
313
 
 
314
static void emptyHash( TidyDocImpl* doc, TidyTagImpl* tags )
 
315
{
 
316
    uint i;
 
317
    DictHash *prev, *next;
 
318
 
 
319
    for (i = 0; i < ELEMENT_HASH_SIZE; ++i)
 
320
    {
 
321
        prev = NULL;
 
322
        next = tags->hashtab[i];
 
323
 
 
324
        while(next)
 
325
        {
 
326
            prev = next->next;
 
327
            TidyDocFree(doc, next);
 
328
            next = prev;
 
329
        }
 
330
 
 
331
        tags->hashtab[i] = NULL;
 
332
    }
285
333
}
286
334
#endif /* ELEMENT_HASH_LOOKUP */
287
335
 
288
 
static const Dict* lookup( TidyTagImpl* tags, ctmbstr s )
 
336
static const Dict* lookup( TidyDocImpl* doc, TidyTagImpl* tags, ctmbstr s )
289
337
{
290
338
    const Dict *np;
 
339
#if ELEMENT_HASH_LOOKUP
 
340
    const DictHash* p;
 
341
#endif
291
342
 
292
343
    if (!s)
293
344
        return NULL;
294
345
 
295
 
#ifdef ELEMENT_HASH_LOOKUP
 
346
#if ELEMENT_HASH_LOOKUP
296
347
    /* this breaks if declared elements get changed between two   */
297
348
    /* parser runs since Tidy would use the cached version rather */
298
 
    /* than the new one                                           */
299
 
    for (np = tags->hashtab[hash(s)]; np != NULL; np = np->next)
300
 
        if (tmbstrcmp(s, np->name) == 0)
301
 
            return np;
 
349
    /* than the new one.                                          */
 
350
    /* However, as FreeDeclaredTags() correctly cleans the hash   */
 
351
    /* this should not be true anymore.                           */
 
352
    for (p = tags->hashtab[hash(s)]; p && p->tag; p = p->next)
 
353
        if (TY_(tmbstrcmp)(s, p->tag->name) == 0)
 
354
            return p->tag;
302
355
 
303
356
    for (np = tag_defs + 1; np < tag_defs + N_TIDY_TAGS; ++np)
304
 
        if (tmbstrcmp(s, np->name) == 0)
305
 
            return install(tags, np);
 
357
        if (TY_(tmbstrcmp)(s, np->name) == 0)
 
358
            return install(doc, tags, np);
306
359
 
307
360
    for (np = tags->declared_tag_list; np; np = np->next)
308
 
        if (tmbstrcmp(s, np->name) == 0)
309
 
            return install(tags, np);
 
361
        if (TY_(tmbstrcmp)(s, np->name) == 0)
 
362
            return install(doc, tags, np);
310
363
#else
311
364
 
312
365
    for (np = tag_defs + 1; np < tag_defs + N_TIDY_TAGS; ++np)
313
 
        if (tmbstrcmp(s, np->name) == 0)
 
366
        if (TY_(tmbstrcmp)(s, np->name) == 0)
314
367
            return np;
315
368
 
316
369
    for (np = tags->declared_tag_list; np; np = np->next)
317
 
        if (tmbstrcmp(s, np->name) == 0)
 
370
        if (TY_(tmbstrcmp)(s, np->name) == 0)
318
371
            return np;
319
372
 
320
373
#endif /* ELEMENT_HASH_LOOKUP */
322
375
    return NULL;
323
376
}
324
377
 
325
 
 
326
 
static void declare( TidyTagImpl* tags,
 
378
static Dict* NewDict( TidyDocImpl* doc, ctmbstr name )
 
379
{
 
380
    Dict *np = (Dict*) TidyDocAlloc( doc, sizeof(Dict) );
 
381
    np->id = TidyTag_UNKNOWN;
 
382
    np->name = name ? TY_(tmbstrdup)( doc->allocator, name ) : NULL;
 
383
    np->versions = VERS_UNKNOWN;
 
384
    np->attrvers = NULL;
 
385
    np->model = CM_UNKNOWN;
 
386
    np->parser = 0;
 
387
    np->chkattrs = 0;
 
388
    np->next = NULL;
 
389
    return np;
 
390
}
 
391
 
 
392
static void FreeDict( TidyDocImpl* doc, Dict *d )
 
393
{
 
394
    if ( d )
 
395
        TidyDocFree( doc, d->name );
 
396
    TidyDocFree( doc, d );
 
397
}
 
398
 
 
399
static void declare( TidyDocImpl* doc, TidyTagImpl* tags,
327
400
                     ctmbstr name, uint versions, uint model, 
328
401
                     Parser *parser, CheckAttribs *chkattrs )
329
402
{
330
403
    if ( name )
331
404
    {
332
 
        Dict* np = (Dict*) lookup( tags, name );
 
405
        Dict* np = (Dict*) lookup( doc, tags, name );
333
406
        if ( np == NULL )
334
407
        {
335
 
            np = (Dict*) MemAlloc( sizeof(Dict) );
336
 
            ClearMemory( np, sizeof(Dict) );
337
 
 
338
 
            np->name = tmbstrdup( name );
 
408
            np = NewDict( doc, name );
339
409
            np->next = tags->declared_tag_list;
340
410
            tags->declared_tag_list = np;
341
411
        }
353
423
}
354
424
 
355
425
/* public interface for finding tag by name */
356
 
Bool FindTag( TidyDocImpl* doc, Node *node )
 
426
Bool TY_(FindTag)( TidyDocImpl* doc, Node *node )
357
427
{
358
428
    const Dict *np = NULL;
359
429
    if ( cfgBool(doc, TidyXmlTags) )
362
432
        return yes;
363
433
    }
364
434
 
365
 
    if ( node->element && (np = lookup(&doc->tags, node->element)) )
 
435
    if ( node->element && (np = lookup(doc, &doc->tags, node->element)) )
366
436
    {
367
437
        node->tag = np;
368
438
        return yes;
371
441
    return no;
372
442
}
373
443
 
374
 
const Dict* LookupTagDef( TidyTagId tid )
 
444
const Dict* TY_(LookupTagDef)( TidyTagId tid )
375
445
{
376
446
    const Dict *np;
377
447
 
382
452
    return NULL;    
383
453
}
384
454
 
385
 
Parser* FindParser( TidyDocImpl* doc, Node *node )
 
455
Parser* TY_(FindParser)( TidyDocImpl* doc, Node *node )
386
456
{
387
 
    const Dict* np = lookup( &doc->tags, node->element );
 
457
    const Dict* np = lookup( doc, &doc->tags, node->element );
388
458
    if ( np )
389
459
        return np->parser;
390
460
    return NULL;
391
461
}
392
462
 
393
 
void DefineTag( TidyDocImpl* doc, UserTagType tagType, ctmbstr name )
 
463
void TY_(DefineTag)( TidyDocImpl* doc, UserTagType tagType, ctmbstr name )
394
464
{
395
 
    Parser* parser = NULL;
396
 
    uint cm = 0;
 
465
    Parser* parser = 0;
 
466
    uint cm = CM_UNKNOWN;
397
467
    uint vers = VERS_PROPRIETARY;
398
468
 
399
469
    switch (tagType)
400
470
    {
401
471
    case tagtype_empty:
402
472
        cm = CM_EMPTY|CM_NO_INDENT|CM_NEW;
403
 
        parser = ParseBlock;
 
473
        parser = TY_(ParseBlock);
404
474
        break;
405
475
 
406
476
    case tagtype_inline:
407
477
        cm = CM_INLINE|CM_NO_INDENT|CM_NEW;
408
 
        parser = ParseInline;
 
478
        parser = TY_(ParseInline);
409
479
        break;
410
480
 
411
481
    case tagtype_block:
412
482
        cm = CM_BLOCK|CM_NO_INDENT|CM_NEW;
413
 
        parser = ParseBlock;
 
483
        parser = TY_(ParseBlock);
414
484
        break;
415
485
 
416
486
    case tagtype_pre:
417
487
        cm = CM_BLOCK|CM_NO_INDENT|CM_NEW;
418
 
        parser = ParsePre;
 
488
        parser = TY_(ParsePre);
419
489
        break;
420
490
 
421
491
    case tagtype_null:
422
492
        break;
423
493
    }
424
494
    if ( cm && parser )
425
 
        declare( &doc->tags, name, vers, cm, parser, NULL );
 
495
        declare( doc, &doc->tags, name, vers, cm, parser, 0 );
426
496
}
427
497
 
428
 
TidyIterator   GetDeclaredTagList( TidyDocImpl* doc )
 
498
TidyIterator   TY_(GetDeclaredTagList)( TidyDocImpl* doc )
429
499
{
430
500
    return (TidyIterator) doc->tags.declared_tag_list;
431
501
}
432
502
 
433
 
ctmbstr        GetNextDeclaredTag( TidyDocImpl* ARG_UNUSED(doc),
434
 
                                   UserTagType tagType, TidyIterator* iter )
 
503
ctmbstr        TY_(GetNextDeclaredTag)( TidyDocImpl* ARG_UNUSED(doc),
 
504
                                        UserTagType tagType, TidyIterator* iter )
435
505
{
436
506
    ctmbstr name = NULL;
437
507
    Dict* curr;
451
521
 
452
522
        case tagtype_block:
453
523
            if ( (curr->model & CM_BLOCK) != 0 &&
454
 
                 curr->parser == ParseBlock )
 
524
                 curr->parser == TY_(ParseBlock) )
455
525
                name = curr->name;
456
526
            break;
457
527
    
458
528
        case tagtype_pre:
459
529
            if ( (curr->model & CM_BLOCK) != 0 &&
460
 
                 curr->parser == ParsePre )
 
530
                 curr->parser == TY_(ParsePre) )
461
531
                name = curr->name;
462
532
            break;
463
533
 
469
539
    return name;
470
540
}
471
541
 
472
 
void InitTags( TidyDocImpl* doc )
 
542
void TY_(InitTags)( TidyDocImpl* doc )
473
543
{
474
544
    Dict* xml;
475
545
    TidyTagImpl* tags = &doc->tags;
476
546
 
477
 
    ClearMemory( tags, sizeof(TidyTagImpl) );
 
547
    TidyClearMemory( tags, sizeof(TidyTagImpl) );
478
548
 
479
549
    /* create dummy entry for all xml tags */
480
 
    xml = (Dict*) MemAlloc( sizeof(Dict) );
481
 
    ClearMemory( xml, sizeof(Dict) );
482
 
    xml->name = NULL;
 
550
    xml =  NewDict( doc, NULL );
483
551
    xml->versions = VERS_XML;
484
552
    xml->model = CM_BLOCK;
485
 
    xml->parser = NULL;
486
 
    xml->chkattrs = NULL;
 
553
    xml->parser = 0;
 
554
    xml->chkattrs = 0;
487
555
    xml->attrvers = NULL;
488
556
    tags->xml_tags = xml;
489
557
}
491
559
/* By default, zap all of them.  But allow
492
560
** an single type to be specified.
493
561
*/
494
 
void FreeDeclaredTags( TidyDocImpl* doc, UserTagType tagType )
 
562
void TY_(FreeDeclaredTags)( TidyDocImpl* doc, UserTagType tagType )
495
563
{
496
564
    TidyTagImpl* tags = &doc->tags;
497
565
    Dict *curr, *next = NULL, *prev = NULL;
512
580
 
513
581
        case tagtype_block:
514
582
            deleteIt = ( (curr->model & CM_BLOCK) != 0 &&
515
 
                         curr->parser == ParseBlock );
 
583
                         curr->parser == TY_(ParseBlock) );
516
584
            break;
517
585
 
518
586
        case tagtype_pre:
519
587
            deleteIt = ( (curr->model & CM_BLOCK) != 0 &&
520
 
                         curr->parser == ParsePre );
 
588
                         curr->parser == TY_(ParsePre) );
521
589
            break;
522
590
 
523
591
        case tagtype_null:
526
594
 
527
595
        if ( deleteIt )
528
596
        {
529
 
          MemFree( curr->name );
530
 
          MemFree( curr );
 
597
#if ELEMENT_HASH_LOOKUP
 
598
          removeFromHash( doc, &doc->tags, curr->name );
 
599
#endif
 
600
          FreeDict( doc, curr );
531
601
          if ( prev )
532
602
            prev->next = next;
533
603
          else
538
608
    }
539
609
}
540
610
 
541
 
void FreeTags( TidyDocImpl* doc )
 
611
void TY_(FreeTags)( TidyDocImpl* doc )
542
612
{
543
613
    TidyTagImpl* tags = &doc->tags;
544
614
 
545
 
#ifdef ELEMENT_HASH_LOOKUP
546
 
    uint i;
547
 
    Dict *prev, *next;
548
 
 
549
 
    for (i = 0; i < ELEMENT_HASH_SIZE; ++i)
550
 
    {
551
 
        prev = NULL;
552
 
        next = tags->hashtab[i];
553
 
 
554
 
        while(next)
555
 
        {
556
 
            prev = next->next;
557
 
            MemFree(next->name);
558
 
            MemFree(next);
559
 
            next = prev;
560
 
        }
561
 
 
562
 
        tags->hashtab[i] = NULL;
563
 
    }
 
615
#if ELEMENT_HASH_LOOKUP
 
616
    emptyHash( doc, tags );
564
617
#endif
565
 
 
566
 
    FreeDeclaredTags( doc, tagtype_null );
567
 
    MemFree( tags->xml_tags );
 
618
    TY_(FreeDeclaredTags)( doc, tagtype_null );
 
619
    FreeDict( doc, tags->xml_tags );
568
620
 
569
621
    /* get rid of dangling tag references */
570
 
    ClearMemory( tags, sizeof(TidyTagImpl) );
 
622
    TidyClearMemory( tags, sizeof(TidyTagImpl) );
571
623
}
572
624
 
573
625
 
574
626
/* default method for checking an element's attributes */
575
 
void CheckAttributes( TidyDocImpl* doc, Node *node )
 
627
void TY_(CheckAttributes)( TidyDocImpl* doc, Node *node )
576
628
{
577
629
    AttVal *next, *attval = node->attributes;
578
630
    while (attval)
579
631
    {
580
632
        next = attval->next;
581
 
        CheckAttribute( doc, node, attval );
 
633
        TY_(CheckAttribute)( doc, node, attval );
582
634
        attval = next;
583
635
    }
584
636
}
587
639
 
588
640
void CheckIMG( TidyDocImpl* doc, Node *node )
589
641
{
590
 
    Bool HasAlt = AttrGetById(node, TidyAttr_ALT) != NULL;
591
 
    Bool HasSrc = AttrGetById(node, TidyAttr_SRC) != NULL;
592
 
    Bool HasUseMap = AttrGetById(node, TidyAttr_USEMAP) != NULL;
593
 
    Bool HasIsMap = AttrGetById(node, TidyAttr_ISMAP) != NULL;
594
 
    Bool HasDataFld = AttrGetById(node, TidyAttr_DATAFLD) != NULL;
 
642
    Bool HasAlt = TY_(AttrGetById)(node, TidyAttr_ALT) != NULL;
 
643
    Bool HasSrc = TY_(AttrGetById)(node, TidyAttr_SRC) != NULL;
 
644
    Bool HasUseMap = TY_(AttrGetById)(node, TidyAttr_USEMAP) != NULL;
 
645
    Bool HasIsMap = TY_(AttrGetById)(node, TidyAttr_ISMAP) != NULL;
 
646
    Bool HasDataFld = TY_(AttrGetById)(node, TidyAttr_DATAFLD) != NULL;
595
647
 
596
 
    CheckAttributes(doc, node);
 
648
    TY_(CheckAttributes)(doc, node);
597
649
 
598
650
    if ( !HasAlt )
599
651
    {
600
652
        if ( cfg(doc, TidyAccessibilityCheckLevel) == 0 )
601
653
        {
602
 
            doc->badAccess |= MISSING_IMAGE_ALT;
603
 
            ReportMissingAttr( doc, node, "alt" );
 
654
            doc->badAccess |= BA_MISSING_IMAGE_ALT;
 
655
            TY_(ReportMissingAttr)( doc, node, "alt" );
604
656
        }
605
657
  
606
658
        if ( cfgStr(doc, TidyAltText) )
607
 
            AddAttribute( doc, node, "alt", cfgStr(doc, TidyAltText) );
 
659
            TY_(AddAttribute)( doc, node, "alt", cfgStr(doc, TidyAltText) );
608
660
    }
609
661
 
610
662
    if ( !HasSrc && !HasDataFld )
611
 
        ReportMissingAttr( doc, node, "src" );
 
663
        TY_(ReportMissingAttr)( doc, node, "src" );
612
664
 
613
665
    if ( cfg(doc, TidyAccessibilityCheckLevel) == 0 )
614
666
    {
615
667
        if ( HasIsMap && !HasUseMap )
616
 
            ReportMissingAttr( doc, node, "ismap" );
 
668
            TY_(ReportAttrError)( doc, node, NULL, MISSING_IMAGEMAP);
617
669
    }
618
670
}
619
671
 
621
673
{
622
674
    AttVal *attval;
623
675
 
624
 
    CheckAttributes(doc, node);
 
676
    TY_(CheckAttributes)(doc, node);
625
677
 
626
 
    attval = AttrGetById(node, TidyAttr_ALIGN);
 
678
    attval = TY_(AttrGetById)(node, TidyAttr_ALIGN);
627
679
 
628
680
    if (!AttrHasValue(attval))
629
681
        return;
630
682
 
631
683
    if (AttrValueIs(attval, "left") || AttrValueIs(attval, "right"))
632
 
        ConstrainVersion(doc, VERS_HTML40_LOOSE);
 
684
        TY_(ConstrainVersion)(doc, VERS_HTML40_LOOSE);
633
685
    else if (AttrValueIs(attval, "top") || AttrValueIs(attval, "bottom"))
634
 
        ConstrainVersion(doc, ~(VERS_HTML20|VERS_HTML32));
 
686
        TY_(ConstrainVersion)(doc, ~(VERS_HTML20|VERS_HTML32));
635
687
    else
636
 
        ReportAttrError(doc, node, attval, BAD_ATTRIBUTE_VALUE);
 
688
        TY_(ReportAttrError)(doc, node, attval, BAD_ATTRIBUTE_VALUE);
637
689
}
638
690
 
639
691
void CheckHTML( TidyDocImpl* doc, Node *node )
640
692
{
641
 
    CheckAttributes(doc, node);
 
693
    TY_(CheckAttributes)(doc, node);
642
694
}
643
695
 
644
696
void CheckAREA( TidyDocImpl* doc, Node *node )
645
697
{
646
 
    Bool HasAlt = AttrGetById(node, TidyAttr_ALT) != NULL;
647
 
    Bool HasHref = AttrGetById(node, TidyAttr_HREF) != NULL;
648
 
    Bool HasNohref = AttrGetById(node, TidyAttr_NOHREF) != NULL;
 
698
    Bool HasAlt = TY_(AttrGetById)(node, TidyAttr_ALT) != NULL;
 
699
    Bool HasHref = TY_(AttrGetById)(node, TidyAttr_HREF) != NULL;
 
700
    Bool HasNohref = TY_(AttrGetById)(node, TidyAttr_NOHREF) != NULL;
649
701
 
650
 
    CheckAttributes(doc, node);
 
702
    TY_(CheckAttributes)(doc, node);
651
703
 
652
704
    if ( !HasAlt )
653
705
    {
654
706
        if ( cfg(doc, TidyAccessibilityCheckLevel) == 0 )
655
707
        {
656
 
            doc->badAccess |= MISSING_LINK_ALT;
657
 
            ReportMissingAttr( doc, node, "alt" );
 
708
            doc->badAccess |= BA_MISSING_LINK_ALT;
 
709
            TY_(ReportMissingAttr)( doc, node, "alt" );
658
710
        }
659
711
    }
660
712
 
661
713
    if ( !HasHref && !HasNohref )
662
 
        ReportMissingAttr( doc, node, "href" );
 
714
        TY_(ReportMissingAttr)( doc, node, "href" );
663
715
}
664
716
 
665
717
void CheckTABLE( TidyDocImpl* doc, Node *node )
666
718
{
667
719
    AttVal* attval;
668
 
    Bool HasSummary = AttrGetById(node, TidyAttr_SUMMARY) != NULL;
 
720
    Bool HasSummary = TY_(AttrGetById)(node, TidyAttr_SUMMARY) != NULL;
669
721
 
670
 
    CheckAttributes(doc, node);
 
722
    TY_(CheckAttributes)(doc, node);
671
723
 
672
724
    /* a missing summary attribute is bad accessibility, no matter
673
725
       what HTML version is involved; a document without is valid */
675
727
    {
676
728
        if (!HasSummary)
677
729
        {
678
 
            doc->badAccess |= MISSING_SUMMARY;
679
 
            ReportMissingAttr( doc, node, "summary");
 
730
            doc->badAccess |= BA_MISSING_SUMMARY;
 
731
            TY_(ReportMissingAttr)( doc, node, "summary");
680
732
        }
681
733
    }
682
734
 
683
735
    /* convert <table border> to <table border="1"> */
684
 
    if ( cfgBool(doc, TidyXmlOut) && (attval = AttrGetById(node, TidyAttr_BORDER)) )
 
736
    if ( cfgBool(doc, TidyXmlOut) && (attval = TY_(AttrGetById)(node, TidyAttr_BORDER)) )
685
737
    {
686
738
        if (attval->value == NULL)
687
 
            attval->value = tmbstrdup("1");
 
739
            attval->value = TY_(tmbstrdup)(doc->allocator, "1");
688
740
    }
689
741
}
690
742
 
694
746
    AttVal *lang, *type;
695
747
    char buf[16];
696
748
 
697
 
    CheckAttributes(doc, node);
 
749
    TY_(CheckAttributes)(doc, node);
698
750
 
699
 
    lang = AttrGetById(node, TidyAttr_LANGUAGE);
700
 
    type = AttrGetById(node, TidyAttr_TYPE);
 
751
    lang = TY_(AttrGetById)(node, TidyAttr_LANGUAGE);
 
752
    type = TY_(AttrGetById)(node, TidyAttr_TYPE);
701
753
 
702
754
    if (!type)
703
755
    {
706
758
        {
707
759
            /* Test #696799. lang->value can be NULL. */
708
760
            buf[0] = '\0';
709
 
            tmbstrncpy(buf, lang->value, sizeof(buf));
 
761
            TY_(tmbstrncpy)(buf, lang->value, sizeof(buf));
710
762
            buf[10] = '\0';
711
763
 
712
 
            if (tmbstrncasecmp(buf, "javascript", 10) == 0 ||
713
 
                 tmbstrncasecmp(buf,   "jscript",  7) == 0)
 
764
            if (TY_(tmbstrncasecmp)(buf, "javascript", 10) == 0 ||
 
765
                 TY_(tmbstrncasecmp)(buf,   "jscript",  7) == 0)
714
766
            {
715
 
                AddAttribute(doc, node, "type", "text/javascript");
 
767
                TY_(AddAttribute)(doc, node, "type", "text/javascript");
716
768
            }
717
 
            else if (tmbstrcasecmp(buf, "vbscript") == 0)
 
769
            else if (TY_(tmbstrcasecmp)(buf, "vbscript") == 0)
718
770
            {
719
771
                /* per Randy Waki 8/6/01 */
720
 
                AddAttribute(doc, node, "type", "text/vbscript");
 
772
                TY_(AddAttribute)(doc, node, "type", "text/vbscript");
721
773
            }
722
774
        }
723
775
        else
724
776
        {
725
 
            AddAttribute(doc, node, "type", "text/javascript");
 
777
            TY_(AddAttribute)(doc, node, "type", "text/javascript");
726
778
        }
727
779
 
728
 
        type = AttrGetById(node, TidyAttr_TYPE);
 
780
        type = TY_(AttrGetById)(node, TidyAttr_TYPE);
729
781
 
730
782
        if (type != NULL)
731
783
        {
732
 
            ReportAttrError(doc, node, type, INSERTING_ATTRIBUTE);
 
784
            TY_(ReportAttrError)(doc, node, type, INSERTING_ATTRIBUTE);
733
785
        }
734
786
        else
735
787
        {
736
 
            ReportMissingAttr(doc, node, "type");
 
788
            TY_(ReportMissingAttr)(doc, node, "type");
737
789
        }
738
790
    }
739
791
}
742
794
/* add missing type attribute when appropriate */
743
795
void CheckSTYLE( TidyDocImpl* doc, Node *node )
744
796
{
745
 
    AttVal *type = AttrGetById(node, TidyAttr_TYPE);
746
 
 
747
 
    CheckAttributes( doc, node );
748
 
 
749
 
    if ( !type || !type->value || !tmbstrlen(type->value) )
 
797
    AttVal *type = TY_(AttrGetById)(node, TidyAttr_TYPE);
 
798
 
 
799
    TY_(CheckAttributes)( doc, node );
 
800
 
 
801
    if ( !type || !type->value || !TY_(tmbstrlen)(type->value) )
750
802
    {
751
 
        type = RepairAttrValue(doc, node, "type", "text/css");
752
 
        ReportAttrError( doc, node, type, INSERTING_ATTRIBUTE );
 
803
        type = TY_(RepairAttrValue)(doc, node, "type", "text/css");
 
804
        TY_(ReportAttrError)( doc, node, type, INSERTING_ATTRIBUTE );
753
805
    }
754
806
}
755
807
 
756
808
/* add missing type attribute when appropriate */
757
809
void CheckLINK( TidyDocImpl* doc, Node *node )
758
810
{
759
 
    AttVal *rel = AttrGetById(node, TidyAttr_REL);
 
811
    AttVal *rel = TY_(AttrGetById)(node, TidyAttr_REL);
760
812
 
761
 
    CheckAttributes( doc, node );
 
813
    TY_(CheckAttributes)( doc, node );
762
814
 
763
815
    /* todo: <link rel="alternate stylesheet"> */
764
816
    if (AttrValueIs(rel, "stylesheet"))
765
817
    {
766
 
        AttVal *type = AttrGetById(node, TidyAttr_TYPE);
 
818
        AttVal *type = TY_(AttrGetById)(node, TidyAttr_TYPE);
767
819
        if (!type)
768
820
        {
769
 
            AddAttribute( doc, node, "type", "text/css" );
770
 
            type = AttrGetById(node, TidyAttr_TYPE);
771
 
            ReportAttrError( doc, node, type, INSERTING_ATTRIBUTE );
 
821
            TY_(AddAttribute)( doc, node, "type", "text/css" );
 
822
            type = TY_(AttrGetById)(node, TidyAttr_TYPE);
 
823
            TY_(ReportAttrError)( doc, node, type, INSERTING_ATTRIBUTE );
772
824
        }
773
825
    }
774
826
}
776
828
/* reports missing action attribute */
777
829
void CheckFORM( TidyDocImpl* doc, Node *node )
778
830
{
779
 
    AttVal *action = AttrGetById(node, TidyAttr_ACTION);
 
831
    AttVal *action = TY_(AttrGetById)(node, TidyAttr_ACTION);
780
832
 
781
 
    CheckAttributes(doc, node);
 
833
    TY_(CheckAttributes)(doc, node);
782
834
 
783
835
    if (!action)
784
 
        ReportMissingAttr(doc, node, "action");
 
836
        TY_(ReportMissingAttr)(doc, node, "action");
785
837
}
786
838
 
787
839
/* reports missing content attribute */
788
840
void CheckMETA( TidyDocImpl* doc, Node *node )
789
841
{
790
 
    AttVal *content = AttrGetById(node, TidyAttr_CONTENT);
 
842
    AttVal *content = TY_(AttrGetById)(node, TidyAttr_CONTENT);
791
843
 
792
 
    CheckAttributes(doc, node);
 
844
    TY_(CheckAttributes)(doc, node);
793
845
 
794
846
    if (!content)
795
 
        ReportMissingAttr( doc, node, "content" );
 
847
        TY_(ReportMissingAttr)( doc, node, "content" );
796
848
    /* name or http-equiv attribute must also be set */
797
849
}
798
850
 
799
851
 
800
 
Bool nodeIsText( Node* node )
 
852
Bool TY_(nodeIsText)( Node* node )
801
853
{
802
854
  return ( node && node->type == TextNode );
803
855
}
804
856
 
805
 
Bool nodeHasText( TidyDocImpl* doc, Node* node )
 
857
Bool TY_(nodeHasText)( TidyDocImpl* doc, Node* node )
806
858
{
807
859
  if ( doc && node )
808
860
  {
811
863
    for ( ix = node->start; ix < node->end; ++ix )
812
864
    {
813
865
        /* whitespace */
814
 
        if ( !IsWhite( lexer->lexbuf[ix] ) )
 
866
        if ( !TY_(IsWhite)( lexer->lexbuf[ix] ) )
815
867
            return yes;
816
868
    }
817
869
  }
818
870
  return no;
819
871
}
820
872
 
821
 
Bool nodeIsElement( Node* node )
 
873
Bool TY_(nodeIsElement)( Node* node )
822
874
{
823
875
  return ( node && 
824
876
           (node->type == StartTag || node->type == StartEndTag) );
825
877
}
826
878
 
 
879
#if 0
827
880
/* Compare & result to operand.  If equal, then all bits
828
881
** requested are set.
829
882
*/
832
885
  return ( node && node->tag && 
833
886
           (node->tag->model & contentModel) == contentModel );
834
887
}
 
888
#endif
835
889
 
836
890
/* True if any of the bits requested are set.
837
891
*/
838
 
Bool nodeHasCM( Node* node, uint contentModel )
 
892
Bool TY_(nodeHasCM)( Node* node, uint contentModel )
839
893
{
840
894
  return ( node && node->tag && 
841
895
           (node->tag->model & contentModel) != 0 );
842
896
}
843
897
 
844
 
Bool nodeCMIsBlock( Node* node )
845
 
{
846
 
  return nodeHasCM( node, CM_BLOCK );
847
 
}
848
 
Bool nodeCMIsInline( Node* node )
849
 
{
850
 
  return nodeHasCM( node, CM_INLINE );
851
 
}
852
 
Bool nodeCMIsEmpty( Node* node )
853
 
{
854
 
  return nodeHasCM( node, CM_EMPTY );
 
898
Bool TY_(nodeCMIsBlock)( Node* node )
 
899
{
 
900
  return TY_(nodeHasCM)( node, CM_BLOCK );
 
901
}
 
902
Bool TY_(nodeCMIsInline)( Node* node )
 
903
{
 
904
  return TY_(nodeHasCM)( node, CM_INLINE );
 
905
}
 
906
Bool TY_(nodeCMIsEmpty)( Node* node )
 
907
{
 
908
  return TY_(nodeHasCM)( node, CM_EMPTY );
855
909
}
856
910
 
857
 
Bool nodeIsHeader( Node* node )
 
911
Bool TY_(nodeIsHeader)( Node* node )
858
912
{
859
913
    TidyTagId tid = TagId( node  );
860
914
    return ( tid && 
866
920
             tid == TidyTag_H6 );
867
921
}
868
922
 
869
 
uint nodeHeaderLevel( Node* node )
 
923
uint TY_(nodeHeaderLevel)( Node* node )
870
924
{
871
925
    TidyTagId tid = TagId( node  );
872
926
    switch ( tid )
890
944
    }
891
945
    return 0;
892
946
}
 
947
 
 
948
/*
 
949
 * local variables:
 
950
 * mode: c
 
951
 * indent-tabs-mode: nil
 
952
 * c-basic-offset: 4
 
953
 * eval: (c-set-offset 'substatement-open 0)
 
954
 * end:
 
955
 */