HTML Tidy  5.4.0
The HTACG Tidy HTML Project
lexer.h
Go to the documentation of this file.
1 #ifndef __LEXER_H__
2 #define __LEXER_H__
3 
4 /* lexer.h -- Lexer for html parser
5 
6  (c) 1998-2008 (W3C) MIT, ERCIM, Keio University
7  See tidy.h for the copyright notice.
8 
9  Given an input source, it returns a sequence of tokens.
10 
11  GetToken(source) gets the next token
12  UngetToken(source) provides one level undo
13 
14  The tags include an attribute list:
15 
16  - linked list of attribute/value nodes
17  - each node has 2 NULL-terminated strings.
18  - entities are replaced in attribute values
19 
20  white space is compacted if not in preformatted mode
21  If not in preformatted mode then leading white space
22  is discarded and subsequent white space sequences
23  compacted to single space characters.
24 
25  If XmlTags is no then Tag names are folded to upper
26  case and attribute names to lower case.
27 
28  Not yet done:
29  - Doctype subset and marked sections
30 */
31 
32 #ifdef __cplusplus
33 extern "C" {
34 #endif
35 
36 #include "forward.h"
37 
38 /* lexer character types
39 */
40 #define digit 1u
41 #define letter 2u
42 #define namechar 4u
43 #define white 8u
44 #define newline 16u
45 #define lowercase 32u
46 #define uppercase 64u
47 #define digithex 128u
48 
49 
50 /* node->type is one of these values
51 */
52 typedef enum
53 {
68 } NodeType;
69 
70 
71 
72 /* lexer GetToken states
73 */
74 typedef enum
75 {
89 } LexerState;
90 
91 /* ParseDocTypeDecl state constants */
92 typedef enum
93 {
100 
101 /* content model shortcut encoding
102 
103  Descriptions are tentative.
104 */
105 #define CM_UNKNOWN 0
106 /* Elements with no content. Map to HTML specification. */
107 #define CM_EMPTY (1 << 0)
108 /* Elements that appear outside of "BODY". */
109 #define CM_HTML (1 << 1)
110 /* Elements that can appear within HEAD. */
111 #define CM_HEAD (1 << 2)
112 /* HTML "block" elements. */
113 #define CM_BLOCK (1 << 3)
114 /* HTML "inline" elements. */
115 #define CM_INLINE (1 << 4)
116 /* Elements that mark list item ("LI"). */
117 #define CM_LIST (1 << 5)
118 /* Elements that mark definition list item ("DL", "DT"). */
119 #define CM_DEFLIST (1 << 6)
120 /* Elements that can appear inside TABLE. */
121 #define CM_TABLE (1 << 7)
122 /* Used for "THEAD", "TFOOT" or "TBODY". */
123 #define CM_ROWGRP (1 << 8)
124 /* Used for "TD", "TH" */
125 #define CM_ROW (1 << 9)
126 /* Elements whose content must be protected against white space movement.
127  Includes some elements that can found in forms. */
128 #define CM_FIELD (1 << 10)
129 /* Used to avoid propagating inline emphasis inside some elements
130  such as OBJECT or APPLET. */
131 #define CM_OBJECT (1 << 11)
132 /* Elements that allows "PARAM". */
133 #define CM_PARAM (1 << 12)
134 /* "FRAME", "FRAMESET", "NOFRAMES". Used in ParseFrameSet. */
135 #define CM_FRAMES (1 << 13)
136 /* Heading elements (h1, h2, ...). */
137 #define CM_HEADING (1 << 14)
138 /* Elements with an optional end tag. */
139 #define CM_OPT (1 << 15)
140 /* Elements that use "align" attribute for vertical position. */
141 #define CM_IMG (1 << 16)
142 /* Elements with inline and block model. Used to avoid calling InlineDup. */
143 #define CM_MIXED (1 << 17)
144 /* Elements whose content needs to be indented only if containing one
145  CM_BLOCK element. */
146 #define CM_NO_INDENT (1 << 18)
147 /* Elements that are obsolete (such as "dir", "menu"). */
148 #define CM_OBSOLETE (1 << 19)
149 /* User defined elements. Used to determine how attributes wihout value
150  should be printed. */
151 #define CM_NEW (1 << 20)
152 /* Elements that cannot be omitted. */
153 #define CM_OMITST (1 << 21)
154 
155 /* If the document uses just HTML 2.0 tags and attributes described
156 ** it as HTML 2.0 Similarly for HTML 3.2 and the 3 flavors of HTML 4.0.
157 ** If there are proprietary tags and attributes then describe it as
158 ** HTML Proprietary. If it includes the xml-lang or xmlns attributes
159 ** but is otherwise HTML 2.0, 3.2 or 4.0 then describe it as one of the
160 ** flavors of Voyager (strict, loose or frameset).
161 */
162 
163 /* unknown */
164 #define xxxx 0u
165 
166 /* W3C defined HTML/XHTML family document types */
167 #define HT20 1u
168 #define HT32 2u
169 #define H40S 4u
170 #define H40T 8u
171 #define H40F 16u
172 #define H41S 32u
173 #define H41T 64u
174 #define H41F 128u
175 #define X10S 256u
176 #define X10T 512u
177 #define X10F 1024u
178 #define XH11 2048u
179 #define XB10 4096u
180 
181 /* proprietary stuff */
182 #define VERS_SUN 8192u
183 #define VERS_NETSCAPE 16384u
184 #define VERS_MICROSOFT 32768u
185 
186 /* special flag */
187 #define VERS_XML 65536u
188 
189 /* HTML5 */
190 #define HT50 131072u
191 #define XH50 262144u
192 
193 /* compatibility symbols */
194 #define VERS_UNKNOWN (xxxx)
195 #define VERS_HTML20 (HT20)
196 #define VERS_HTML32 (HT32)
197 #define VERS_HTML40_STRICT (H40S|H41S|X10S)
198 #define VERS_HTML40_LOOSE (H40T|H41T|X10T)
199 #define VERS_FRAMESET (H40F|H41F|X10F)
200 #define VERS_XHTML11 (XH11)
201 #define VERS_BASIC (XB10)
202 /* HTML5 */
203 #define VERS_HTML5 (HT50|XH50)
204 
205 /* meta symbols */
206 #define VERS_HTML40 (VERS_HTML40_STRICT|VERS_HTML40_LOOSE|VERS_FRAMESET)
207 #define VERS_IFRAME (VERS_HTML40_LOOSE|VERS_FRAMESET)
208 #define VERS_LOOSE (VERS_HTML20|VERS_HTML32|VERS_IFRAME)
209 #define VERS_EVENTS (VERS_HTML40|VERS_XHTML11)
210 #define VERS_FROM32 (VERS_HTML32|VERS_HTML40)
211 #define VERS_FROM40 (VERS_HTML40|VERS_XHTML11|VERS_BASIC)
212 #define VERS_XHTML (X10S|X10T|X10F|XH11|XB10|XH50)
213 
214 /* strict */
215 #define VERS_STRICT (VERS_HTML5|VERS_HTML40_STRICT)
216 
217 /* all W3C defined document types */
218 #define VERS_ALL (VERS_HTML20|VERS_HTML32|VERS_FROM40|XH50|HT50)
219 
220 /* all proprietary types */
221 #define VERS_PROPRIETARY (VERS_NETSCAPE|VERS_MICROSOFT|VERS_SUN)
222 
223 /* Linked list of class names and styles
224 */
225 struct _Style;
226 typedef struct _Style TagStyle;
227 
228 struct _Style
229 {
233  TagStyle *next;
234 };
235 
236 
237 /* Linked list of style properties
238 */
239 struct _StyleProp;
240 typedef struct _StyleProp StyleProp;
241 
243 {
246  StyleProp *next;
247 };
248 
249 
250 
251 
252 /* Attribute/Value linked list node
253 */
254 
255 struct _AttVal
256 {
257  AttVal* next;
258  const Attribute* dict;
259  Node* asp;
260  Node* php;
261  int delim;
264 };
265 
266 
267 
268 /*
269  Mosaic handles inlines via a separate stack from other elements
270  We duplicate this to recover from inline markup errors such as:
271 
272  <i>italic text
273  <p>more italic text</b> normal text
274 
275  which for compatibility with Mosaic is mapped to:
276 
277  <i>italic text</i>
278  <p><i>more italic text</i> normal text
279 
280  Note that any inline end tag pop's the effect of the current
281  inline start tag, so that </b> pop's <i> in the above example.
282 */
283 struct _IStack
284 {
285  IStack* next;
286  const Dict* tag; /* tag's dictionary definition */
287  tmbstr element; /* name (NULL for text nodes) */
288  AttVal* attributes;
289 };
290 
291 
292 /* HTML/XHTML/XML Element, Comment, PI, DOCTYPE, XML Decl,
293 ** etc. etc.
294 */
295 
296 struct _Node
297 {
298  Node* parent; /* tree structure */
299  Node* prev;
300  Node* next;
301  Node* content;
302  Node* last;
303 
304  AttVal* attributes;
305  const Dict* was; /* old tag when it was changed */
306  const Dict* tag; /* tag's dictionary definition */
307 
308  tmbstr element; /* name (NULL for text nodes) */
309 
310  uint start; /* start of span onto text array */
311  uint end; /* end of span onto text array */
312  NodeType type; /* TextNode, StartTag, EndTag etc. */
313 
314  uint line; /* current line of document */
315  uint column; /* current column of document */
316 
317  Bool closed; /* true if closed by explicit end tag */
318  Bool implicit; /* true if inferred */
319  Bool linebreak; /* true if followed by a line break */
320 
321 #ifdef TIDY_STORE_ORIGINAL_TEXT
322  tmbstr otext;
323 #endif
324 };
325 
326 
327 /*
328  The following are private to the lexer
329  Use NewLexer() to create a lexer, and
330  FreeLexer() to free it.
331 */
332 
333 struct _Lexer
334 {
335 #if 0 /* Move to TidyDocImpl */
336  StreamIn* in; /* document content input */
337  StreamOut* errout; /* error output stream */
338 
339  uint badAccess; /* for accessibility errors */
340  uint badLayout; /* for bad style errors */
341  uint badChars; /* for bad character encodings */
342  uint badForm; /* for mismatched/mispositioned form tags */
343  uint warnings; /* count of warnings in this document */
344  uint errors; /* count of errors */
345 #endif
346 
347  uint lines; /* lines seen */
348  uint columns; /* at start of current token */
349  Bool waswhite; /* used to collapse contiguous white space */
350  Bool pushed; /* true after token has been pushed back */
351  Bool insertspace; /* when space is moved after end tag */
352  Bool excludeBlocks; /* Netscape compatibility */
353  Bool exiled; /* true if moved out of table */
354  Bool isvoyager; /* true if xmlns attribute on html element */
355  uint versions; /* bit vector of HTML versions */
356  uint doctype; /* version as given by doctype (if any) */
357  uint versionEmitted; /* version of doctype emitted */
358  Bool bad_doctype; /* e.g. if html or PUBLIC is missing */
359  uint txtstart; /* start of current node */
360  uint txtend; /* end of current node */
361  LexerState state; /* state of lexer's finite state machine */
362 
363  Node* token; /* last token returned by GetToken() */
364  Node* itoken; /* last duplicate inline returned by GetToken() */
365  Node* root; /* remember root node of the document */
366  Node* parent; /* remember parent node for CDATA elements */
367 
368  Bool seenEndBody; /* true if a </body> tag has been encountered */
369  Bool seenEndHtml; /* true if a </html> tag has been encountered */
370 
371  /*
372  Lexer character buffer
373 
374  Parse tree nodes span onto this buffer
375  which contains the concatenated text
376  contents of all of the elements.
377 
378  lexsize must be reset for each file.
379  */
380  tmbstr lexbuf; /* MB character buffer */
381  uint lexlength; /* allocated */
382  uint lexsize; /* used */
383 
384  /* Inline stack for compatibility with Mosaic */
385  Node* inode; /* for deferring text node */
386  IStack* insert; /* for inferring inline tags */
387  IStack* istack;
388  uint istacklength; /* allocated */
389  uint istacksize; /* used */
390  uint istackbase; /* start of frame */
391 
392  TagStyle *styles; /* used for cleaning up presentation markup */
393 
394  TidyAllocator* allocator; /* allocator */
395 
396 #if 0
397  TidyDocImpl* doc; /* Pointer back to doc for error reporting */
398 #endif
399 };
400 
401 
402 /* Lexer Functions
403 */
404 
405 /* choose what version to use for new doctype */
406 int TY_(HTMLVersion)( TidyDocImpl* doc );
407 
408 /* everything is allowed in proprietary version of HTML */
409 /* this is handled here rather than in the tag/attr dicts */
410 
411 void TY_(ConstrainVersion)( TidyDocImpl* doc, uint vers );
412 
413 Bool TY_(IsWhite)(uint c);
414 Bool TY_(IsDigit)(uint c);
415 Bool TY_(IsLetter)(uint c);
416 Bool TY_(IsHTMLSpace)(uint c);
417 Bool TY_(IsNewline)(uint c);
418 Bool TY_(IsNamechar)(uint c);
419 Bool TY_(IsXMLLetter)(uint c);
420 Bool TY_(IsXMLNamechar)(uint c);
421 
422 /* Bool IsLower(uint c); */
423 Bool TY_(IsUpper)(uint c);
424 uint TY_(ToLower)(uint c);
425 uint TY_(ToUpper)(uint c);
426 
427 Lexer* TY_(NewLexer)( TidyDocImpl* doc );
428 void TY_(FreeLexer)( TidyDocImpl* doc );
429 
430 /* store character c as UTF-8 encoded byte stream */
431 void TY_(AddCharToLexer)( Lexer *lexer, uint c );
432 
433 /*
434  Used for elements and text nodes
435  element name is NULL for text nodes
436  start and end are offsets into lexbuf
437  which contains the textual content of
438  all elements in the parse tree.
439 
440  parent and content allow traversal
441  of the parse tree in any direction.
442  attributes are represented as a linked
443  list of AttVal nodes which hold the
444  strings for attribute/value pairs.
445 */
446 Node* TY_(NewNode)( TidyAllocator* allocator, Lexer* lexer );
447 
448 
449 /* used to clone heading nodes when split by an <HR> */
450 Node* TY_(CloneNode)( TidyDocImpl* doc, Node *element );
451 
452 /* free node's attributes */
453 void TY_(FreeAttrs)( TidyDocImpl* doc, Node *node );
454 
455 /* doesn't repair attribute list linkage */
456 void TY_(FreeAttribute)( TidyDocImpl* doc, AttVal *av );
457 
458 /* detach attribute from node */
459 void TY_(DetachAttribute)( Node *node, AttVal *attr );
460 
461 /* detach attribute from node then free it
462 */
463 void TY_(RemoveAttribute)( TidyDocImpl* doc, Node *node, AttVal *attr );
464 
465 /*
466  Free document nodes by iterating through peers and recursing
467  through children. Set next to NULL before calling FreeNode()
468  to avoid freeing peer nodes. Doesn't patch up prev/next links.
469  */
470 void TY_(FreeNode)( TidyDocImpl* doc, Node *node );
471 
472 Node* TY_(TextToken)( Lexer *lexer );
473 
474 /* used for creating preformatted text from Word2000 */
475 Node* TY_(NewLineNode)( Lexer *lexer );
476 
477 /* used for adding a &nbsp; for Word2000 */
478 Node* TY_(NewLiteralTextNode)(Lexer *lexer, ctmbstr txt );
479 
480 void TY_(AddStringLiteral)( Lexer* lexer, ctmbstr str );
481 /* void AddStringLiteralLen( Lexer* lexer, ctmbstr str, int len ); */
482 
483 /* find element */
484 Node* TY_(FindDocType)( TidyDocImpl* doc );
485 Node* TY_(FindHTML)( TidyDocImpl* doc );
486 Node* TY_(FindHEAD)( TidyDocImpl* doc );
487 Node* TY_(FindTITLE)(TidyDocImpl* doc);
488 Node* TY_(FindBody)( TidyDocImpl* doc );
489 Node* TY_(FindXmlDecl)(TidyDocImpl* doc);
490 
491 /* Returns containing block element, if any */
492 Node* TY_(FindContainer)( Node* node );
493 
494 /* add meta element for Tidy */
495 Bool TY_(AddGenerator)( TidyDocImpl* doc );
496 
497 uint TY_(ApparentVersion)( TidyDocImpl* doc );
498 
499 ctmbstr TY_(HTMLVersionNameFromCode)( uint vers, Bool isXhtml );
500 
501 Bool TY_(WarnMissingSIInEmittedDocType)( TidyDocImpl* doc );
502 
503 Bool TY_(SetXHTMLDocType)( TidyDocImpl* doc );
504 
505 
506 /* fixup doctype if missing */
507 Bool TY_(FixDocType)( TidyDocImpl* doc );
508 
509 /* ensure XML document starts with <?xml version="1.0"?> */
510 /* add encoding attribute if not using ASCII or UTF-8 output */
511 Bool TY_(FixXmlDecl)( TidyDocImpl* doc );
512 
513 Node* TY_(InferredTag)(TidyDocImpl* doc, TidyTagId id);
514 
515 void TY_(UngetToken)( TidyDocImpl* doc );
516 
517 
518 /*
519  modes for GetToken()
520 
521  MixedContent -- for elements which don't accept PCDATA
522  Preformatted -- white space preserved as is
523  IgnoreMarkup -- for CDATA elements such as script, style
524 */
525 typedef enum
526 {
533 } GetTokenMode;
534 
535 Node* TY_(GetToken)( TidyDocImpl* doc, GetTokenMode mode );
536 
537 void TY_(InitMap)(void);
538 
539 
540 /* create a new attribute */
541 AttVal* TY_(NewAttribute)( TidyDocImpl* doc );
542 
543 /* create a new attribute with given name and value */
544 AttVal* TY_(NewAttributeEx)( TidyDocImpl* doc, ctmbstr name, ctmbstr value,
545  int delim );
546 
547 /* insert attribute at the end of attribute list of a node */
548 void TY_(InsertAttributeAtEnd)( Node *node, AttVal *av );
549 
550 /* insert attribute at the start of attribute list of a node */
551 void TY_(InsertAttributeAtStart)( Node *node, AttVal *av );
552 
553 /*************************************
554  In-line Stack functions
555 *************************************/
556 
557 
558 /* duplicate attributes */
559 AttVal* TY_(DupAttrs)( TidyDocImpl* doc, AttVal* attrs );
560 
561 /*
562  push a copy of an inline node onto stack
563  but don't push if implicit or OBJECT or APPLET
564  (implicit tags are ones generated from the istack)
565 
566  One issue arises with pushing inlines when
567  the tag is already pushed. For instance:
568 
569  <p><em>text
570  <p><em>more text
571 
572  Shouldn't be mapped to
573 
574  <p><em>text</em></p>
575  <p><em><em>more text</em></em>
576 */
577 void TY_(PushInline)( TidyDocImpl* doc, Node* node );
578 
579 /* pop inline stack */
580 void TY_(PopInline)( TidyDocImpl* doc, Node* node );
581 
582 Bool TY_(IsPushed)( TidyDocImpl* doc, Node* node );
583 Bool TY_(IsPushedLast)( TidyDocImpl* doc, Node *element, Node *node );
584 
585 /*
586  This has the effect of inserting "missing" inline
587  elements around the contents of blocklevel elements
588  such as P, TD, TH, DIV, PRE etc. This procedure is
589  called at the start of ParseBlock. when the inline
590  stack is not empty, as will be the case in:
591 
592  <i><h1>italic heading</h1></i>
593 
594  which is then treated as equivalent to
595 
596  <h1><i>italic heading</i></h1>
597 
598  This is implemented by setting the lexer into a mode
599  where it gets tokens from the inline stack rather than
600  from the input stream.
601 */
602 int TY_(InlineDup)( TidyDocImpl* doc, Node *node );
603 
604 /*
605  defer duplicates when entering a table or other
606  element where the inlines shouldn't be duplicated
607 */
608 void TY_(DeferDup)( TidyDocImpl* doc );
609 Node* TY_(InsertedToken)( TidyDocImpl* doc );
610 
611 /* stack manipulation for inline elements */
612 Bool TY_(SwitchInline)( TidyDocImpl* doc, Node* element, Node* node );
613 Bool TY_(InlineDup1)( TidyDocImpl* doc, Node* node, Node* element );
614 
615 #ifdef __cplusplus
616 }
617 #endif
618 
619 
620 #endif /* __LEXER_H__ */
uint lexlength
Definition: lexer.h:381
Definition: lexer.h:59
uint doctype
Definition: lexer.h:356
Definition: lexer.h:63
Definition: lexer.h:77
uint end
Definition: lexer.h:311
uint lines
Definition: lexer.h:347
Bool closed
Definition: lexer.h:317
Bool seenEndBody
Definition: lexer.h:368
uint txtend
Definition: lexer.h:360
Definition: lexer.h:531
Definition: lexer.h:85
Node * next
Definition: lexer.h:300
Bool linebreak
Definition: lexer.h:319
tmbstr attribute
Definition: lexer.h:262
TidyAllocator * allocator
Definition: lexer.h:394
tmbstr tag
Definition: lexer.h:230
AttVal * attributes
Definition: lexer.h:288
tmbstr properties
Definition: lexer.h:232
NodeType
Definition: lexer.h:52
LexerState state
Definition: lexer.h:361
TidyTagId
Known HTML element types.
Definition: tidyenum.h:311
int delim
Definition: lexer.h:261
const tmbchar * ctmbstr
Definition: tidyplatform.h:556
StyleProp * next
Definition: lexer.h:246
AttVal * next
Definition: lexer.h:257
uint column
Definition: lexer.h:315
ParseDocTypeDeclState
Definition: lexer.h:92
Definition: lexer.h:97
Bool pushed
Definition: lexer.h:350
const Dict * was
Definition: lexer.h:305
NodeType type
Definition: lexer.h:312
Definition: lexer.h:88
Definition: lexer.h:55
uint line
Definition: lexer.h:314
Definition: lexer.h:527
Definition: lexer.h:242
tmbstr lexbuf
Definition: lexer.h:380
Node * parent
Definition: lexer.h:298
Definition: lexer.h:54
Node * content
Definition: lexer.h:301
Definition: lexer.h:67
Definition: lexer.h:81
tmbstr tag_class
Definition: lexer.h:231
Definition: lexer.h:333
Definition: lexer.h:83
Definition: lexer.h:87
Definition: lexer.h:296
uint start
Definition: lexer.h:310
Bool seenEndHtml
Definition: lexer.h:369
Bool bad_doctype
Definition: lexer.h:358
Node * token
Definition: lexer.h:363
uint istackbase
Definition: lexer.h:390
Node * inode
Definition: lexer.h:385
uint lexsize
Definition: lexer.h:382
Bool
Definition: tidyplatform.h:593
Definition: lexer.h:283
Definition: lexer.h:66
Definition: lexer.h:60
uint versions
Definition: lexer.h:355
Bool isvoyager
Definition: lexer.h:354
Bool implicit
Definition: lexer.h:318
Definition: lexer.h:76
Definition: lexer.h:78
IStack * insert
Definition: lexer.h:386
Definition: lexer.h:95
Bool exiled
Definition: lexer.h:353
tmbchar * tmbstr
Definition: tidyplatform.h:555
Definition: lexer.h:80
uint istacklength
Definition: lexer.h:388
const Dict * tag
Definition: lexer.h:286
Definition: lexer.h:56
TagStyle * next
Definition: lexer.h:233
static FILE * errout
Definition: tidy.c:25
Definition: lexer.h:532
uint txtstart
Definition: lexer.h:359
Node * prev
Definition: lexer.h:299
unsigned int uint
Definition: tidyplatform.h:525
Definition: lexer.h:96
LexerState
Definition: lexer.h:74
uint columns
Definition: lexer.h:348
uint versionEmitted
Definition: lexer.h:357
Definition: lexer.h:529
IStack * next
Definition: lexer.h:285
Definition: lexer.h:84
tmbstr name
Definition: lexer.h:244
Definition: lexer.h:65
Node * root
Definition: lexer.h:365
Definition: lexer.h:94
Definition: lexer.h:64
Definition: lexer.h:82
Node * asp
Definition: lexer.h:259
Definition: lexer.h:528
Definition: lexer.h:255
uint istacksize
Definition: lexer.h:389
TagStyle * styles
Definition: lexer.h:392
Definition: lexer.h:530
const Attribute * dict
Definition: lexer.h:258
tmbstr value
Definition: lexer.h:245
Definition: lexer.h:98
#define TY_(str)
Definition: forward.h:23
Definition: lexer.h:228
Bool insertspace
Definition: lexer.h:351
Bool waswhite
Definition: lexer.h:349
Definition: lexer.h:86
IStack * istack
Definition: lexer.h:387
Definition: lexer.h:62
Definition: lexer.h:57
Node * last
Definition: lexer.h:302
Definition: lexer.h:61
Definition: lexer.h:58
tmbstr element
Definition: lexer.h:287
Definition: lexer.h:79
Node * php
Definition: lexer.h:260
GetTokenMode
Definition: lexer.h:525
Node * itoken
Definition: lexer.h:364
Bool excludeBlocks
Definition: lexer.h:352