HTML Tidy  5.9.15
The HTACG Tidy HTML Project
tags.h
Go to the documentation of this file.
1 #ifndef __TAGS_H__
2 #define __TAGS_H__
3 
4 /**************************************************************************//**
5  * @file
6  * Recognize HTML Tags.
7  *
8  * The HTML tags are stored as 8 bit ASCII strings.
9  * Use lookupw() to find a tag given a wide char string.
10  *
11  * @author HTACG, et al (consult git log)
12  *
13  * @copyright
14  * Copyright (c) 1998-2017 World Wide Web Consortium (Massachusetts
15  * Institute of Technology, European Research Consortium for Informatics
16  * and Mathematics, Keio University) and HTACG.
17  * @par
18  * All Rights Reserved.
19  * @par
20  * See `tidy.h` for the complete license.
21  *
22  * @date Additional updates: consult git log
23  *
24  ******************************************************************************/
25 
26 #include "forward.h"
27 #include "attrdict.h"
28 
29 /** @addtogroup internal_api */
30 /** @{ */
31 
32 
33 /***************************************************************************//**
34  ** @defgroup tags_h HTML Tags
35  **
36  ** This module organizes all of Tidy's HTML tag operations, such as parsing
37  ** tags, defining tags, and user-defined tags.
38  **
39  ** @{
40  ******************************************************************************/
41 
42 
43 /** @name Basic Structures and Tag Operations.
44  ** These structures form the backbone of Tidy tag processing, and the
45  ** functions in this group provide basic operations with tags and nodes.
46  */
47 /** @{ */
48 
49 
50 /** This enumeration defines the types of user-defined tags that can be
51  ** created.
52  */
53 typedef enum
54 {
55  tagtype_null = 0, /**< First item marker. */
56  tagtype_empty = 1, /**< Tag is an empty element. */
57  tagtype_inline = 2, /**< Tag is an inline element. */
58  tagtype_block = 4, /**< Tag is a block level element. */
59  tagtype_pre = 8 /**< Tag is a preformatted tag. */
61 
62 
63 /** This typedef describes a function to be used to parse HTML of a Tidy tag.
64  ** @param doc The Tidy document.
65  ** @param node The node being parsed.
66  ** @param mode The GetTokenMode to be used for parsing the node contents.
67  ** @param popStack A flag indicating that we are re-entering this parser, and
68  ** it should restore a state from the stack.
69  */
70 typedef Node* (Parser)( TidyDocImpl* doc, Node *node, GetTokenMode mode );
71 
72 
73 /** This typedef describes a function be be used to check the attributes
74  ** of a Tidy tag.
75  */
76 typedef void (CheckAttribs)( TidyDocImpl* doc, Node *node );
77 
78 
79 /** Defines a dictionary entry for a single Tidy tag, including all of the
80  ** relevant information that it requires.
81  */
82 struct _Dict
83 {
84  TidyTagId id; /**< Identifier for this tag. */
85  tmbstr name; /**< The tag name. */
86  uint versions; /**< Accumulates potential HTML versions. See TY_(ConstrainVersion). */
87  AttrVersion const * attrvers; /**< Accumulates potential HTML versions for attributes. */
88  uint model; /**< Indicates the relevant content models for the tag. See lexer.h; there is no enum. */
89  Parser* parser; /**< Specifies the parser to use for this tag. */
90  CheckAttribs* chkattrs; /**< Specifies the function to check this tag's attributes. */
91  Dict* next; /**< Link to next tag. */
92 };
93 
94 
95 /** This enum indicates the maximum size of the has table for tag hash lookup.
96  */
97 enum
98 {
99  ELEMENT_HASH_SIZE=178u /**< Maximum number of tags in the hash table. */
100 };
101 
102 
103 /** This structure provide hash lookup for Tidy tags.
104  */
105 typedef struct _DictHash
106 {
107  Dict const* tag; /**< The current tag. */
108  struct _DictHash* next; /**< The next tag. */
109 } DictHash;
110 
111 
112 /** This structure consists of the lists of all tags known to Tidy.
113  */
114 typedef struct _TidyTagImpl
115 {
116  Dict* xml_tags; /**< Placeholder for all xml tags. */
117  Dict* declared_tag_list; /**< User-declared tags. */
118  DictHash* hashtab[ELEMENT_HASH_SIZE]; /**< All of Tidy's built-in tags. */
119 } TidyTagImpl;
120 
121 
122 /** Coordinates Config update and Tags data.
123  ** @param doc The Tidy document.
124  ** @param opt The option the tag is intended for.
125  ** @param name The name of the new tag.
126  */
127 TY_PRIVATE void TY_(DeclareUserTag)( TidyDocImpl* doc, const TidyOptionImpl* opt, ctmbstr name );
128 
129 
130 /** Interface for finding a tag by TidyTagId.
131  ** @param tid The TidyTagId to search for.
132  ** @returns An instance of a Tidy tag.
133  */
134 TY_PRIVATE const Dict* TY_(LookupTagDef)( TidyTagId tid );
135 
136 /** Assigns the node's tag.
137  ** @param doc The Tidy document.
138  ** @param node The node to assign the tag to.
139  ** @returns Returns a bool indicating whether or not the tag was assigned.
140  */
141 TY_PRIVATE Bool TY_(FindTag)( TidyDocImpl* doc, Node *node );
142 
143 
144 /** Finds the parser function for a given node.
145  ** @param doc The Tidy document.
146  ** @param node The node to lookup.
147  ** @returns The parser for the given node.
148  */
149 TY_PRIVATE Parser* TY_(FindParser)( TidyDocImpl* doc, Node *node );
150 
151 
152 /** Defines a new user-defined tag.
153  ** @param doc The Tidy document.
154  ** @param tagType The type of user-defined tag to define.
155  ** @param name The name of the new tag.
156  */
157 TY_PRIVATE void TY_(DefineTag)( TidyDocImpl* doc, UserTagType tagType, ctmbstr name );
158 
159 
160 /** Frees user-defined tags of the given type, or all user tags in given
161  ** `tagtype_null`.
162  ** @param doc The Tidy document.
163  ** @param tagType The type of tag to free, or `tagtype_null` to free all
164  ** user-defined tags.
165  */
166 TY_PRIVATE void TY_(FreeDeclaredTags)( TidyDocImpl* doc, UserTagType tagType );
167 
168 
169 /** Initiates an iterator for a list of user-declared tags, including autonomous
170  ** custom tags detected in the document if @ref TidyUseCustomTags is not set to
171  ** **no**.
172  ** @param doc An instance of a TidyDocImp to query.
173  ** @result Returns a TidyIterator, which is a token used to represent the
174  ** current position in a list within LibTidy.
175  */
176 TY_PRIVATE TidyIterator TY_(GetDeclaredTagList)( TidyDocImpl* doc );
177 
178 
179 /** Given a valid TidyIterator initiated with TY_(GetDeclaredTagList)(),
180  ** returns a string representing a user-declared or autonomous custom tag.
181  ** @remark Specifying tagType limits the scope of the tags to one of
182  ** @ref UserTagType types. Note that autonomous custom tags (if used)
183  ** are added to one of these option types, depending on the value of
184  ** @ref TidyUseCustomTags.
185  ** @param doc The Tidy document.
186  ** @param tagType The type of tag to iterate through.
187  ** @param iter The iterator token provided initially by
188  ** TY_(GetDeclaredTagList)().
189  ** @result A string containing the next tag.
190  */
191 TY_PRIVATE ctmbstr TY_(GetNextDeclaredTag)( TidyDocImpl* doc, UserTagType tagType,
192  TidyIterator* iter );
193 
194 
195 /** Initializes tags and tag structures for the given Tidy document.
196  ** @param doc The Tidy document.
197  */
198 TY_PRIVATE void TY_(InitTags)( TidyDocImpl* doc );
199 
200 
201 /** Frees the tags and structures used by Tidy for tags.
202  ** @param doc The Tidy document.
203  */
204 TY_PRIVATE void TY_(FreeTags)( TidyDocImpl* doc );
205 
206 
207 /** Tidy defaults to HTML5 mode. If the <!DOCTYPE ...> is found to NOT be
208  ** HTML5, then adjust the tags table to HTML4 mode.
209  ** @param doc The Tidy document.
210  */
211 TY_PRIVATE void TY_(AdjustTags)( TidyDocImpl *doc );
212 
213 
214 /** Reset the tags table back to default HTML5 mode.
215  ** @param doc The Tidy document.
216  */
217 TY_PRIVATE void TY_(ResetTags)( TidyDocImpl *doc );
218 
219 
220 /** Indicates whether or not the Tidy is processing in HTML5 mode.
221  ** @param doc The Tidy document.
222  ** @returns Returns `yes` if processing in HTML5 mode.
223  */
224 TY_PRIVATE Bool TY_(IsHTML5Mode)( TidyDocImpl *doc );
225 
226 
227 /** @} */
228 /** @name Parser Methods And Attribute Checker Functions for Tags
229  ** These functions define the parsers and attribute checking functions for
230  ** each of Tidy's tags.
231  */
232 /** @{ */
233 
234 
235 TY_PRIVATE Parser TY_(ParseHTML);
236 TY_PRIVATE Parser TY_(ParseHead);
237 TY_PRIVATE Parser TY_(ParseTitle);
238 TY_PRIVATE Parser TY_(ParseScript);
239 TY_PRIVATE Parser TY_(ParseFrameSet);
240 TY_PRIVATE Parser TY_(ParseNoFrames);
241 TY_PRIVATE Parser TY_(ParseBody);
243 TY_PRIVATE Parser TY_(ParseList);
244 TY_PRIVATE Parser TY_(ParseDefList);
245 TY_PRIVATE Parser TY_(ParseBlock);
246 TY_PRIVATE Parser TY_(ParseInline);
247 TY_PRIVATE Parser TY_(ParseEmpty);
248 TY_PRIVATE Parser TY_(ParseTableTag);
249 TY_PRIVATE Parser TY_(ParseColGroup);
250 TY_PRIVATE Parser TY_(ParseRowGroup);
252 TY_PRIVATE Parser TY_(ParseSelect);
253 TY_PRIVATE Parser TY_(ParseOptGroup);
254 TY_PRIVATE Parser TY_(ParseText);
255 TY_PRIVATE Parser TY_(ParseDatalist);
256 TY_PRIVATE Parser TY_(ParseNamespace);
257 
258 TY_PRIVATE CheckAttribs TY_(CheckAttributes);
259 
260 
261 /** @} */
262 /** @name Other Tag and Node Lookup Functions
263  ** These functions perform additional lookup on tags and nodes.
264  */
265 /** @{ */
266 
267 
268 /** Gets the TidyTagId of the given node. 0 == TidyTag_UNKNOWN.
269  */
270 #define TagId(node) ((node) && (node)->tag ? (node)->tag->id : TidyTag_UNKNOWN)
271 
272 
273 /** Determines if the given node is of the given tag id type.
274  */
275 #define TagIsId(node, tid) ((node) && (node)->tag && (node)->tag->id == tid)
276 
277 
278 /** Inquires whether or not the given node is a text node.
279  ** @param node The node being interrogated.
280  ** @returns The status of the inquiry.
281  */
282 TY_PRIVATE Bool TY_(nodeIsText)( Node* node );
283 
284 
285 /** Inquires whether or not the given node is an element node.
286  ** @param node The node being interrogated.
287  ** @returns The status of the inquiry.
288  */
289 TY_PRIVATE Bool TY_(nodeIsElement)( Node* node );
290 
291 
292 /** Inquires whether or not the given node has any text.
293  ** @param doc The Tidy document.
294  ** @param node The node being interrogated.
295  ** @returns The status of the inquiry.
296  */
297 TY_PRIVATE Bool TY_(nodeHasText)( TidyDocImpl* doc, Node* node );
298 
299 
300 /** Inquires whether the given element looks like it's an autonomous custom
301  ** element tag.
302  ** @param element A string to be checked.
303  ** @returns The status of the inquiry.
304  */
305 TY_PRIVATE Bool TY_(elementIsAutonomousCustomFormat)( ctmbstr element );
306 
307 
308 /** Inquires whether the given node looks like it's an autonomous custom
309  ** element tag.
310  ** @param node The node being interrogated.
311  ** @returns The status of the inquiry.
312  */
313 TY_PRIVATE Bool TY_(nodeIsAutonomousCustomFormat)( Node* node );
314 
315 
316 /** True if the node looks like it's an autonomous custom element tag, and
317  ** TidyCustomTags is not disabled, and we're in HTML5 mode, which are all
318  ** requirements for valid autonomous custom tags.
319  ** @param doc The Tidy document.
320  ** @param node The node being interrogated.
321  ** @returns The status of the inquiry.
322  */
323 TY_PRIVATE Bool TY_(nodeIsAutonomousCustomTag)( TidyDocImpl* doc, Node* node );
324 
325 
326 /** Does the node have the indicated content model? True if any of the bits
327  ** requested are set.
328  ** @param node The node being interrogated.
329  ** @param contentModel The content model to check against.
330  ** @returns The status of the inquiry.
331  */
332 TY_PRIVATE Bool TY_(nodeHasCM)( Node* node, uint contentModel );
333 
334 
335 /** Does the content model of the node include block?
336  ** @param node The node being interrogated.
337  ** @returns The status of the inquiry.
338  */
339 TY_PRIVATE Bool TY_(nodeCMIsBlock)( Node* node );
340 
341 
342 /** Does the content model of the node include inline?
343  ** @param node The node being interrogated.
344  ** @returns The status of the inquiry.
345  */
346 TY_PRIVATE Bool TY_(nodeCMIsInline)( Node* node );
347 
348 
349 /** Does the content model of the node include empty?
350  ** @param node The node being interrogated.
351  ** @returns The status of the inquiry.
352  */
353 TY_PRIVATE Bool TY_(nodeCMIsEmpty)( Node* node );
354 
355 
356 /** Is the node a header, such as H1, H2, ..., H6?
357  ** @param node The node being interrogated.
358  ** @returns The status of the inquiry.
359  */
360 TY_PRIVATE Bool TY_(nodeIsHeader)( Node* node );
361 
362 
363 /** Inquires as to the header level of the given node: 1, 2, ..., 6.
364  ** @param node The node being interrogated.
365  ** @returns The header level.
366  */
367 TY_PRIVATE uint TY_(nodeHeaderLevel)( Node* node );
368 
369 
370 #define nodeIsHTML( node ) TagIsId( node, TidyTag_HTML )
371 #define nodeIsHEAD( node ) TagIsId( node, TidyTag_HEAD )
372 #define nodeIsTITLE( node ) TagIsId( node, TidyTag_TITLE )
373 #define nodeIsBASE( node ) TagIsId( node, TidyTag_BASE )
374 #define nodeIsMETA( node ) TagIsId( node, TidyTag_META )
375 #define nodeIsBODY( node ) TagIsId( node, TidyTag_BODY )
376 #define nodeIsFRAMESET( node ) TagIsId( node, TidyTag_FRAMESET )
377 #define nodeIsFRAME( node ) TagIsId( node, TidyTag_FRAME )
378 #define nodeIsIFRAME( node ) TagIsId( node, TidyTag_IFRAME )
379 #define nodeIsNOFRAMES( node ) TagIsId( node, TidyTag_NOFRAMES )
380 #define nodeIsHR( node ) TagIsId( node, TidyTag_HR )
381 #define nodeIsH1( node ) TagIsId( node, TidyTag_H1 )
382 #define nodeIsH2( node ) TagIsId( node, TidyTag_H2 )
383 #define nodeIsPRE( node ) TagIsId( node, TidyTag_PRE )
384 #define nodeIsLISTING( node ) TagIsId( node, TidyTag_LISTING )
385 #define nodeIsP( node ) TagIsId( node, TidyTag_P )
386 #define nodeIsUL( node ) TagIsId( node, TidyTag_UL )
387 #define nodeIsOL( node ) TagIsId( node, TidyTag_OL )
388 #define nodeIsDL( node ) TagIsId( node, TidyTag_DL )
389 #define nodeIsDIR( node ) TagIsId( node, TidyTag_DIR )
390 #define nodeIsLI( node ) TagIsId( node, TidyTag_LI )
391 #define nodeIsDT( node ) TagIsId( node, TidyTag_DT )
392 #define nodeIsDD( node ) TagIsId( node, TidyTag_DD )
393 #define nodeIsTABLE( node ) TagIsId( node, TidyTag_TABLE )
394 #define nodeIsCAPTION( node ) TagIsId( node, TidyTag_CAPTION )
395 #define nodeIsTD( node ) TagIsId( node, TidyTag_TD )
396 #define nodeIsTH( node ) TagIsId( node, TidyTag_TH )
397 #define nodeIsTR( node ) TagIsId( node, TidyTag_TR )
398 #define nodeIsCOL( node ) TagIsId( node, TidyTag_COL )
399 #define nodeIsCOLGROUP( node ) TagIsId( node, TidyTag_COLGROUP )
400 #define nodeIsBR( node ) TagIsId( node, TidyTag_BR )
401 #define nodeIsA( node ) TagIsId( node, TidyTag_A )
402 #define nodeIsLINK( node ) TagIsId( node, TidyTag_LINK )
403 #define nodeIsB( node ) TagIsId( node, TidyTag_B )
404 #define nodeIsI( node ) TagIsId( node, TidyTag_I )
405 #define nodeIsSTRONG( node ) TagIsId( node, TidyTag_STRONG )
406 #define nodeIsEM( node ) TagIsId( node, TidyTag_EM )
407 #define nodeIsBIG( node ) TagIsId( node, TidyTag_BIG )
408 #define nodeIsSMALL( node ) TagIsId( node, TidyTag_SMALL )
409 #define nodeIsPARAM( node ) TagIsId( node, TidyTag_PARAM )
410 #define nodeIsOPTION( node ) TagIsId( node, TidyTag_OPTION )
411 #define nodeIsOPTGROUP( node ) TagIsId( node, TidyTag_OPTGROUP )
412 #define nodeIsIMG( node ) TagIsId( node, TidyTag_IMG )
413 #define nodeIsMAP( node ) TagIsId( node, TidyTag_MAP )
414 #define nodeIsAREA( node ) TagIsId( node, TidyTag_AREA )
415 #define nodeIsNOBR( node ) TagIsId( node, TidyTag_NOBR )
416 #define nodeIsWBR( node ) TagIsId( node, TidyTag_WBR )
417 #define nodeIsFONT( node ) TagIsId( node, TidyTag_FONT )
418 #define nodeIsLAYER( node ) TagIsId( node, TidyTag_LAYER )
419 #define nodeIsSPACER( node ) TagIsId( node, TidyTag_SPACER )
420 #define nodeIsCENTER( node ) TagIsId( node, TidyTag_CENTER )
421 #define nodeIsSTYLE( node ) TagIsId( node, TidyTag_STYLE )
422 #define nodeIsSCRIPT( node ) TagIsId( node, TidyTag_SCRIPT )
423 #define nodeIsNOSCRIPT( node ) TagIsId( node, TidyTag_NOSCRIPT )
424 #define nodeIsFORM( node ) TagIsId( node, TidyTag_FORM )
425 #define nodeIsTEXTAREA( node ) TagIsId( node, TidyTag_TEXTAREA )
426 #define nodeIsBLOCKQUOTE( node ) TagIsId( node, TidyTag_BLOCKQUOTE )
427 #define nodeIsAPPLET( node ) TagIsId( node, TidyTag_APPLET )
428 #define nodeIsOBJECT( node ) TagIsId( node, TidyTag_OBJECT )
429 #define nodeIsDIV( node ) TagIsId( node, TidyTag_DIV )
430 #define nodeIsSPAN( node ) TagIsId( node, TidyTag_SPAN )
431 #define nodeIsINPUT( node ) TagIsId( node, TidyTag_INPUT )
432 #define nodeIsQ( node ) TagIsId( node, TidyTag_Q )
433 #define nodeIsLABEL( node ) TagIsId( node, TidyTag_LABEL )
434 #define nodeIsH3( node ) TagIsId( node, TidyTag_H3 )
435 #define nodeIsH4( node ) TagIsId( node, TidyTag_H4 )
436 #define nodeIsH5( node ) TagIsId( node, TidyTag_H5 )
437 #define nodeIsH6( node ) TagIsId( node, TidyTag_H6 )
438 #define nodeIsADDRESS( node ) TagIsId( node, TidyTag_ADDRESS )
439 #define nodeIsXMP( node ) TagIsId( node, TidyTag_XMP )
440 #define nodeIsSELECT( node ) TagIsId( node, TidyTag_SELECT )
441 #define nodeIsBLINK( node ) TagIsId( node, TidyTag_BLINK )
442 #define nodeIsMARQUEE( node ) TagIsId( node, TidyTag_MARQUEE )
443 #define nodeIsEMBED( node ) TagIsId( node, TidyTag_EMBED )
444 #define nodeIsBASEFONT( node ) TagIsId( node, TidyTag_BASEFONT )
445 #define nodeIsISINDEX( node ) TagIsId( node, TidyTag_ISINDEX )
446 #define nodeIsS( node ) TagIsId( node, TidyTag_S )
447 #define nodeIsSTRIKE( node ) TagIsId( node, TidyTag_STRIKE )
448 #define nodeIsSUB( node ) TagIsId( node, TidyTag_SUB )
449 #define nodeIsSUP( node ) TagIsId( node, TidyTag_SUP )
450 #define nodeIsU( node ) TagIsId( node, TidyTag_U )
451 #define nodeIsMENU( node ) TagIsId( node, TidyTag_MENU )
452 #define nodeIsMAIN( node ) TagIsId( node, TidyTag_MAIN )
453 #define nodeIsBUTTON( node ) TagIsId( node, TidyTag_BUTTON )
454 #define nodeIsCANVAS( node ) TagIsId( node, TidyTag_CANVAS )
455 #define nodeIsPROGRESS( node ) TagIsId( node, TidyTag_PROGRESS )
456 
457 #define nodeIsINS( node ) TagIsId( node, TidyTag_INS )
458 #define nodeIsDEL( node ) TagIsId( node, TidyTag_DEL )
459 
460 #define nodeIsSVG( node ) TagIsId( node, TidyTag_SVG )
461 
462 /* HTML5 */
463 #define nodeIsDATALIST( node ) TagIsId( node, TidyTag_DATALIST )
464 #define nodeIsDATA( node ) TagIsId( node, TidyTag_DATA )
465 #define nodeIsMATHML( node ) TagIsId( node, TidyTag_MATHML ) /* #130 MathML attr and entity fix! */
466 #define nodeIsTEMPLATE( node ) TagIsId( node, TidyTag_TEMPLATE )
467 
468 /* NOT in HTML 5 */
469 #define nodeIsACRONYM( node ) TagIsId( node, TidyTag_ACRONYM )
470 #define nodesIsFRAME( node ) TagIsId( node, TidyTag_FRAME )
471 #define nodeIsTT( node ) TagIsId( node, TidyTag_TT )
472 
473 
474 /** @} name */
475 /** @} tags_h group */
476 /** @} internal_api addtogroup */
477 
478 
479 #endif /* __TAGS_H__ */
Definition: attrdict.h:14
#define TY_PRIVATE
Definition: forward.h:29
#define TY_(str)
Definition: forward.h:23
GetTokenMode
modes for GetToken()
Definition: lexer.h:397
TidyTagId
Known HTML element types.
Definition: tidyenum.h:857
Dict * declared_tag_list
User-declared tags.
Definition: tags.h:117
uint model
Indicates the relevant content models for the tag.
Definition: tags.h:88
CheckAttribs * chkattrs
Specifies the function to check this tag's attributes.
Definition: tags.h:90
AttrVersion const * attrvers
Accumulates potential HTML versions for attributes.
Definition: tags.h:87
struct _DictHash * next
The next tag.
Definition: tags.h:108
TidyTagId id
Identifier for this tag.
Definition: tags.h:84
uint versions
Accumulates potential HTML versions.
Definition: tags.h:86
Dict * xml_tags
Placeholder for all xml tags.
Definition: tags.h:116
Parser * parser
Specifies the parser to use for this tag.
Definition: tags.h:89
Dict const * tag
The current tag.
Definition: tags.h:107
Dict * next
Link to next tag.
Definition: tags.h:91
tmbstr name
The tag name.
Definition: tags.h:85
Node *() Parser(TidyDocImpl *doc, Node *node, GetTokenMode mode)
This typedef describes a function to be used to parse HTML of a Tidy tag.
Definition: tags.h:70
UserTagType
This enumeration defines the types of user-defined tags that can be created.
Definition: tags.h:54
void() CheckAttribs(TidyDocImpl *doc, Node *node)
This typedef describes a function be be used to check the attributes of a Tidy tag.
Definition: tags.h:76
@ ELEMENT_HASH_SIZE
Maximum number of tags in the hash table.
Definition: tags.h:99
@ tagtype_block
Tag is a block level element.
Definition: tags.h:58
@ tagtype_pre
Tag is a preformatted tag.
Definition: tags.h:59
@ tagtype_inline
Tag is an inline element.
Definition: tags.h:57
@ tagtype_empty
Tag is an empty element.
Definition: tags.h:56
@ tagtype_null
First item marker.
Definition: tags.h:55
This structure provide hash lookup for Tidy tags.
Definition: tags.h:106
This structure consists of the lists of all tags known to Tidy.
Definition: tags.h:115
Defines a dictionary entry for a single Tidy tag, including all of the relevant information that it r...
Definition: tags.h:83
Bool
Definition: tidyplatform.h:662
unsigned int uint
Definition: tidyplatform.h:576
const tmbchar * ctmbstr
Definition: tidyplatform.h:624
tmbchar * tmbstr
Definition: tidyplatform.h:623