1: /*
2: * Summary: internals routines and limits exported by the parser.
3: * Description: this module exports a number of internal parsing routines
4: * they are not really all intended for applications but
5: * can prove useful doing low level processing.
6: *
7: * Copy: See Copyright for the status of this software.
8: *
9: * Author: Daniel Veillard
10: */
11:
12: #ifndef __XML_PARSER_INTERNALS_H__
13: #define __XML_PARSER_INTERNALS_H__
14:
15: #include <libxml/xmlversion.h>
16: #include <libxml/parser.h>
17: #include <libxml/HTMLparser.h>
18: #include <libxml/chvalid.h>
19:
20: #ifdef __cplusplus
21: extern "C" {
22: #endif
23:
24: /**
25: * xmlParserMaxDepth:
26: *
27: * arbitrary depth limit for the XML documents that we allow to
28: * process. This is not a limitation of the parser but a safety
29: * boundary feature, use XML_PARSE_HUGE option to override it.
30: */
31: XMLPUBVAR unsigned int xmlParserMaxDepth;
32:
33: /**
34: * XML_MAX_TEXT_LENGTH:
35: *
36: * Maximum size allowed for a single text node when building a tree.
37: * This is not a limitation of the parser but a safety boundary feature,
38: * use XML_PARSE_HUGE option to override it.
39: * Introduced in 2.9.0
40: */
41: #define XML_MAX_TEXT_LENGTH 10000000
42:
43: /**
44: * XML_MAX_NAME_LENGTH:
45: *
46: * Maximum size allowed for a markup identitier
47: * This is not a limitation of the parser but a safety boundary feature,
48: * use XML_PARSE_HUGE option to override it.
49: * Note that with the use of parsing dictionaries overriding the limit
50: * may result in more runtime memory usage in face of "unfriendly' content
51: * Introduced in 2.9.0
52: */
53: #define XML_MAX_NAME_LENGTH 50000
54:
55: /**
56: * XML_MAX_DICTIONARY_LIMIT:
57: *
58: * Maximum size allowed by the parser for a dictionary by default
59: * This is not a limitation of the parser but a safety boundary feature,
60: * use XML_PARSE_HUGE option to override it.
61: * Introduced in 2.9.0
62: */
63: #define XML_MAX_DICTIONARY_LIMIT 10000000
64:
65: /**
66: * XML_MAX_LOOKUP_LIMIT:
67: *
68: * Maximum size allowed by the parser for ahead lookup
69: * This is an upper boundary enforced by the parser to avoid bad
70: * behaviour on "unfriendly' content
71: * Introduced in 2.9.0
72: */
73: #define XML_MAX_LOOKUP_LIMIT 10000000
74:
75: /**
76: * XML_MAX_NAMELEN:
77: *
78: * Identifiers can be longer, but this will be more costly
79: * at runtime.
80: */
81: #define XML_MAX_NAMELEN 100
82:
83: /**
84: * INPUT_CHUNK:
85: *
86: * The parser tries to always have that amount of input ready.
87: * One of the point is providing context when reporting errors.
88: */
89: #define INPUT_CHUNK 250
90:
91: /************************************************************************
92: * *
93: * UNICODE version of the macros. *
94: * *
95: ************************************************************************/
96: /**
97: * IS_BYTE_CHAR:
98: * @c: an byte value (int)
99: *
100: * Macro to check the following production in the XML spec:
101: *
102: * [2] Char ::= #x9 | #xA | #xD | [#x20...]
103: * any byte character in the accepted range
104: */
105: #define IS_BYTE_CHAR(c) xmlIsChar_ch(c)
106:
107: /**
108: * IS_CHAR:
109: * @c: an UNICODE value (int)
110: *
111: * Macro to check the following production in the XML spec:
112: *
113: * [2] Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD]
114: * | [#x10000-#x10FFFF]
115: * any Unicode character, excluding the surrogate blocks, FFFE, and FFFF.
116: */
117: #define IS_CHAR(c) xmlIsCharQ(c)
118:
119: /**
120: * IS_CHAR_CH:
121: * @c: an xmlChar (usually an unsigned char)
122: *
123: * Behaves like IS_CHAR on single-byte value
124: */
125: #define IS_CHAR_CH(c) xmlIsChar_ch(c)
126:
127: /**
128: * IS_BLANK:
129: * @c: an UNICODE value (int)
130: *
131: * Macro to check the following production in the XML spec:
132: *
133: * [3] S ::= (#x20 | #x9 | #xD | #xA)+
134: */
135: #define IS_BLANK(c) xmlIsBlankQ(c)
136:
137: /**
138: * IS_BLANK_CH:
139: * @c: an xmlChar value (normally unsigned char)
140: *
141: * Behaviour same as IS_BLANK
142: */
143: #define IS_BLANK_CH(c) xmlIsBlank_ch(c)
144:
145: /**
146: * IS_BASECHAR:
147: * @c: an UNICODE value (int)
148: *
149: * Macro to check the following production in the XML spec:
150: *
151: * [85] BaseChar ::= ... long list see REC ...
152: */
153: #define IS_BASECHAR(c) xmlIsBaseCharQ(c)
154:
155: /**
156: * IS_DIGIT:
157: * @c: an UNICODE value (int)
158: *
159: * Macro to check the following production in the XML spec:
160: *
161: * [88] Digit ::= ... long list see REC ...
162: */
163: #define IS_DIGIT(c) xmlIsDigitQ(c)
164:
165: /**
166: * IS_DIGIT_CH:
167: * @c: an xmlChar value (usually an unsigned char)
168: *
169: * Behaves like IS_DIGIT but with a single byte argument
170: */
171: #define IS_DIGIT_CH(c) xmlIsDigit_ch(c)
172:
173: /**
174: * IS_COMBINING:
175: * @c: an UNICODE value (int)
176: *
177: * Macro to check the following production in the XML spec:
178: *
179: * [87] CombiningChar ::= ... long list see REC ...
180: */
181: #define IS_COMBINING(c) xmlIsCombiningQ(c)
182:
183: /**
184: * IS_COMBINING_CH:
185: * @c: an xmlChar (usually an unsigned char)
186: *
187: * Always false (all combining chars > 0xff)
188: */
189: #define IS_COMBINING_CH(c) 0
190:
191: /**
192: * IS_EXTENDER:
193: * @c: an UNICODE value (int)
194: *
195: * Macro to check the following production in the XML spec:
196: *
197: *
198: * [89] Extender ::= #x00B7 | #x02D0 | #x02D1 | #x0387 | #x0640 |
199: * #x0E46 | #x0EC6 | #x3005 | [#x3031-#x3035] |
200: * [#x309D-#x309E] | [#x30FC-#x30FE]
201: */
202: #define IS_EXTENDER(c) xmlIsExtenderQ(c)
203:
204: /**
205: * IS_EXTENDER_CH:
206: * @c: an xmlChar value (usually an unsigned char)
207: *
208: * Behaves like IS_EXTENDER but with a single-byte argument
209: */
210: #define IS_EXTENDER_CH(c) xmlIsExtender_ch(c)
211:
212: /**
213: * IS_IDEOGRAPHIC:
214: * @c: an UNICODE value (int)
215: *
216: * Macro to check the following production in the XML spec:
217: *
218: *
219: * [86] Ideographic ::= [#x4E00-#x9FA5] | #x3007 | [#x3021-#x3029]
220: */
221: #define IS_IDEOGRAPHIC(c) xmlIsIdeographicQ(c)
222:
223: /**
224: * IS_LETTER:
225: * @c: an UNICODE value (int)
226: *
227: * Macro to check the following production in the XML spec:
228: *
229: *
230: * [84] Letter ::= BaseChar | Ideographic
231: */
232: #define IS_LETTER(c) (IS_BASECHAR(c) || IS_IDEOGRAPHIC(c))
233:
234: /**
235: * IS_LETTER_CH:
236: * @c: an xmlChar value (normally unsigned char)
237: *
238: * Macro behaves like IS_LETTER, but only check base chars
239: *
240: */
241: #define IS_LETTER_CH(c) xmlIsBaseChar_ch(c)
242:
243: /**
244: * IS_ASCII_LETTER:
245: * @c: an xmlChar value
246: *
247: * Macro to check [a-zA-Z]
248: *
249: */
250: #define IS_ASCII_LETTER(c) (((0x41 <= (c)) && ((c) <= 0x5a)) || \
251: ((0x61 <= (c)) && ((c) <= 0x7a)))
252:
253: /**
254: * IS_ASCII_DIGIT:
255: * @c: an xmlChar value
256: *
257: * Macro to check [0-9]
258: *
259: */
260: #define IS_ASCII_DIGIT(c) ((0x30 <= (c)) && ((c) <= 0x39))
261:
262: /**
263: * IS_PUBIDCHAR:
264: * @c: an UNICODE value (int)
265: *
266: * Macro to check the following production in the XML spec:
267: *
268: *
269: * [13] PubidChar ::= #x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%]
270: */
271: #define IS_PUBIDCHAR(c) xmlIsPubidCharQ(c)
272:
273: /**
274: * IS_PUBIDCHAR_CH:
275: * @c: an xmlChar value (normally unsigned char)
276: *
277: * Same as IS_PUBIDCHAR but for single-byte value
278: */
279: #define IS_PUBIDCHAR_CH(c) xmlIsPubidChar_ch(c)
280:
281: /**
282: * SKIP_EOL:
283: * @p: and UTF8 string pointer
284: *
285: * Skips the end of line chars.
286: */
287: #define SKIP_EOL(p) \
288: if (*(p) == 0x13) { p++ ; if (*(p) == 0x10) p++; } \
289: if (*(p) == 0x10) { p++ ; if (*(p) == 0x13) p++; }
290:
291: /**
292: * MOVETO_ENDTAG:
293: * @p: and UTF8 string pointer
294: *
295: * Skips to the next '>' char.
296: */
297: #define MOVETO_ENDTAG(p) \
298: while ((*p) && (*(p) != '>')) (p)++
299:
300: /**
301: * MOVETO_STARTTAG:
302: * @p: and UTF8 string pointer
303: *
304: * Skips to the next '<' char.
305: */
306: #define MOVETO_STARTTAG(p) \
307: while ((*p) && (*(p) != '<')) (p)++
308:
309: /**
310: * Global variables used for predefined strings.
311: */
312: XMLPUBVAR const xmlChar xmlStringText[];
313: XMLPUBVAR const xmlChar xmlStringTextNoenc[];
314: XMLPUBVAR const xmlChar xmlStringComment[];
315:
316: /*
317: * Function to finish the work of the macros where needed.
318: */
319: XMLPUBFUN int XMLCALL xmlIsLetter (int c);
320:
321: /**
322: * Parser context.
323: */
324: XMLPUBFUN xmlParserCtxtPtr XMLCALL
325: xmlCreateFileParserCtxt (const char *filename);
326: XMLPUBFUN xmlParserCtxtPtr XMLCALL
327: xmlCreateURLParserCtxt (const char *filename,
328: int options);
329: XMLPUBFUN xmlParserCtxtPtr XMLCALL
330: xmlCreateMemoryParserCtxt(const char *buffer,
331: int size);
332: XMLPUBFUN xmlParserCtxtPtr XMLCALL
333: xmlCreateEntityParserCtxt(const xmlChar *URL,
334: const xmlChar *ID,
335: const xmlChar *base);
336: XMLPUBFUN int XMLCALL
337: xmlSwitchEncoding (xmlParserCtxtPtr ctxt,
338: xmlCharEncoding enc);
339: XMLPUBFUN int XMLCALL
340: xmlSwitchToEncoding (xmlParserCtxtPtr ctxt,
341: xmlCharEncodingHandlerPtr handler);
342: XMLPUBFUN int XMLCALL
343: xmlSwitchInputEncoding (xmlParserCtxtPtr ctxt,
344: xmlParserInputPtr input,
345: xmlCharEncodingHandlerPtr handler);
346:
347: #ifdef IN_LIBXML
348: /* internal error reporting */
349: XMLPUBFUN void XMLCALL
350: __xmlErrEncoding (xmlParserCtxtPtr ctxt,
351: xmlParserErrors xmlerr,
352: const char *msg,
353: const xmlChar * str1,
354: const xmlChar * str2);
355: #endif
356:
357: /**
358: * Input Streams.
359: */
360: XMLPUBFUN xmlParserInputPtr XMLCALL
361: xmlNewStringInputStream (xmlParserCtxtPtr ctxt,
362: const xmlChar *buffer);
363: XMLPUBFUN xmlParserInputPtr XMLCALL
364: xmlNewEntityInputStream (xmlParserCtxtPtr ctxt,
365: xmlEntityPtr entity);
366: XMLPUBFUN int XMLCALL
367: xmlPushInput (xmlParserCtxtPtr ctxt,
368: xmlParserInputPtr input);
369: XMLPUBFUN xmlChar XMLCALL
370: xmlPopInput (xmlParserCtxtPtr ctxt);
371: XMLPUBFUN void XMLCALL
372: xmlFreeInputStream (xmlParserInputPtr input);
373: XMLPUBFUN xmlParserInputPtr XMLCALL
374: xmlNewInputFromFile (xmlParserCtxtPtr ctxt,
375: const char *filename);
376: XMLPUBFUN xmlParserInputPtr XMLCALL
377: xmlNewInputStream (xmlParserCtxtPtr ctxt);
378:
379: /**
380: * Namespaces.
381: */
382: XMLPUBFUN xmlChar * XMLCALL
383: xmlSplitQName (xmlParserCtxtPtr ctxt,
384: const xmlChar *name,
385: xmlChar **prefix);
386:
387: /**
388: * Generic production rules.
389: */
390: XMLPUBFUN const xmlChar * XMLCALL
391: xmlParseName (xmlParserCtxtPtr ctxt);
392: XMLPUBFUN xmlChar * XMLCALL
393: xmlParseNmtoken (xmlParserCtxtPtr ctxt);
394: XMLPUBFUN xmlChar * XMLCALL
395: xmlParseEntityValue (xmlParserCtxtPtr ctxt,
396: xmlChar **orig);
397: XMLPUBFUN xmlChar * XMLCALL
398: xmlParseAttValue (xmlParserCtxtPtr ctxt);
399: XMLPUBFUN xmlChar * XMLCALL
400: xmlParseSystemLiteral (xmlParserCtxtPtr ctxt);
401: XMLPUBFUN xmlChar * XMLCALL
402: xmlParsePubidLiteral (xmlParserCtxtPtr ctxt);
403: XMLPUBFUN void XMLCALL
404: xmlParseCharData (xmlParserCtxtPtr ctxt,
405: int cdata);
406: XMLPUBFUN xmlChar * XMLCALL
407: xmlParseExternalID (xmlParserCtxtPtr ctxt,
408: xmlChar **publicID,
409: int strict);
410: XMLPUBFUN void XMLCALL
411: xmlParseComment (xmlParserCtxtPtr ctxt);
412: XMLPUBFUN const xmlChar * XMLCALL
413: xmlParsePITarget (xmlParserCtxtPtr ctxt);
414: XMLPUBFUN void XMLCALL
415: xmlParsePI (xmlParserCtxtPtr ctxt);
416: XMLPUBFUN void XMLCALL
417: xmlParseNotationDecl (xmlParserCtxtPtr ctxt);
418: XMLPUBFUN void XMLCALL
419: xmlParseEntityDecl (xmlParserCtxtPtr ctxt);
420: XMLPUBFUN int XMLCALL
421: xmlParseDefaultDecl (xmlParserCtxtPtr ctxt,
422: xmlChar **value);
423: XMLPUBFUN xmlEnumerationPtr XMLCALL
424: xmlParseNotationType (xmlParserCtxtPtr ctxt);
425: XMLPUBFUN xmlEnumerationPtr XMLCALL
426: xmlParseEnumerationType (xmlParserCtxtPtr ctxt);
427: XMLPUBFUN int XMLCALL
428: xmlParseEnumeratedType (xmlParserCtxtPtr ctxt,
429: xmlEnumerationPtr *tree);
430: XMLPUBFUN int XMLCALL
431: xmlParseAttributeType (xmlParserCtxtPtr ctxt,
432: xmlEnumerationPtr *tree);
433: XMLPUBFUN void XMLCALL
434: xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt);
435: XMLPUBFUN xmlElementContentPtr XMLCALL
436: xmlParseElementMixedContentDecl
437: (xmlParserCtxtPtr ctxt,
438: int inputchk);
439: XMLPUBFUN xmlElementContentPtr XMLCALL
440: xmlParseElementChildrenContentDecl
441: (xmlParserCtxtPtr ctxt,
442: int inputchk);
443: XMLPUBFUN int XMLCALL
444: xmlParseElementContentDecl(xmlParserCtxtPtr ctxt,
445: const xmlChar *name,
446: xmlElementContentPtr *result);
447: XMLPUBFUN int XMLCALL
448: xmlParseElementDecl (xmlParserCtxtPtr ctxt);
449: XMLPUBFUN void XMLCALL
450: xmlParseMarkupDecl (xmlParserCtxtPtr ctxt);
451: XMLPUBFUN int XMLCALL
452: xmlParseCharRef (xmlParserCtxtPtr ctxt);
453: XMLPUBFUN xmlEntityPtr XMLCALL
454: xmlParseEntityRef (xmlParserCtxtPtr ctxt);
455: XMLPUBFUN void XMLCALL
456: xmlParseReference (xmlParserCtxtPtr ctxt);
457: XMLPUBFUN void XMLCALL
458: xmlParsePEReference (xmlParserCtxtPtr ctxt);
459: XMLPUBFUN void XMLCALL
460: xmlParseDocTypeDecl (xmlParserCtxtPtr ctxt);
461: #ifdef LIBXML_SAX1_ENABLED
462: XMLPUBFUN const xmlChar * XMLCALL
463: xmlParseAttribute (xmlParserCtxtPtr ctxt,
464: xmlChar **value);
465: XMLPUBFUN const xmlChar * XMLCALL
466: xmlParseStartTag (xmlParserCtxtPtr ctxt);
467: XMLPUBFUN void XMLCALL
468: xmlParseEndTag (xmlParserCtxtPtr ctxt);
469: #endif /* LIBXML_SAX1_ENABLED */
470: XMLPUBFUN void XMLCALL
471: xmlParseCDSect (xmlParserCtxtPtr ctxt);
472: XMLPUBFUN void XMLCALL
473: xmlParseContent (xmlParserCtxtPtr ctxt);
474: XMLPUBFUN void XMLCALL
475: xmlParseElement (xmlParserCtxtPtr ctxt);
476: XMLPUBFUN xmlChar * XMLCALL
477: xmlParseVersionNum (xmlParserCtxtPtr ctxt);
478: XMLPUBFUN xmlChar * XMLCALL
479: xmlParseVersionInfo (xmlParserCtxtPtr ctxt);
480: XMLPUBFUN xmlChar * XMLCALL
481: xmlParseEncName (xmlParserCtxtPtr ctxt);
482: XMLPUBFUN const xmlChar * XMLCALL
483: xmlParseEncodingDecl (xmlParserCtxtPtr ctxt);
484: XMLPUBFUN int XMLCALL
485: xmlParseSDDecl (xmlParserCtxtPtr ctxt);
486: XMLPUBFUN void XMLCALL
487: xmlParseXMLDecl (xmlParserCtxtPtr ctxt);
488: XMLPUBFUN void XMLCALL
489: xmlParseTextDecl (xmlParserCtxtPtr ctxt);
490: XMLPUBFUN void XMLCALL
491: xmlParseMisc (xmlParserCtxtPtr ctxt);
492: XMLPUBFUN void XMLCALL
493: xmlParseExternalSubset (xmlParserCtxtPtr ctxt,
494: const xmlChar *ExternalID,
495: const xmlChar *SystemID);
496: /**
497: * XML_SUBSTITUTE_NONE:
498: *
499: * If no entities need to be substituted.
500: */
501: #define XML_SUBSTITUTE_NONE 0
502: /**
503: * XML_SUBSTITUTE_REF:
504: *
505: * Whether general entities need to be substituted.
506: */
507: #define XML_SUBSTITUTE_REF 1
508: /**
509: * XML_SUBSTITUTE_PEREF:
510: *
511: * Whether parameter entities need to be substituted.
512: */
513: #define XML_SUBSTITUTE_PEREF 2
514: /**
515: * XML_SUBSTITUTE_BOTH:
516: *
517: * Both general and parameter entities need to be substituted.
518: */
519: #define XML_SUBSTITUTE_BOTH 3
520:
521: XMLPUBFUN xmlChar * XMLCALL
522: xmlStringDecodeEntities (xmlParserCtxtPtr ctxt,
523: const xmlChar *str,
524: int what,
525: xmlChar end,
526: xmlChar end2,
527: xmlChar end3);
528: XMLPUBFUN xmlChar * XMLCALL
529: xmlStringLenDecodeEntities (xmlParserCtxtPtr ctxt,
530: const xmlChar *str,
531: int len,
532: int what,
533: xmlChar end,
534: xmlChar end2,
535: xmlChar end3);
536:
537: /*
538: * Generated by MACROS on top of parser.c c.f. PUSH_AND_POP.
539: */
540: XMLPUBFUN int XMLCALL nodePush (xmlParserCtxtPtr ctxt,
541: xmlNodePtr value);
542: XMLPUBFUN xmlNodePtr XMLCALL nodePop (xmlParserCtxtPtr ctxt);
543: XMLPUBFUN int XMLCALL inputPush (xmlParserCtxtPtr ctxt,
544: xmlParserInputPtr value);
545: XMLPUBFUN xmlParserInputPtr XMLCALL inputPop (xmlParserCtxtPtr ctxt);
546: XMLPUBFUN const xmlChar * XMLCALL namePop (xmlParserCtxtPtr ctxt);
547: XMLPUBFUN int XMLCALL namePush (xmlParserCtxtPtr ctxt,
548: const xmlChar *value);
549:
550: /*
551: * other commodities shared between parser.c and parserInternals.
552: */
553: XMLPUBFUN int XMLCALL xmlSkipBlankChars (xmlParserCtxtPtr ctxt);
554: XMLPUBFUN int XMLCALL xmlStringCurrentChar (xmlParserCtxtPtr ctxt,
555: const xmlChar *cur,
556: int *len);
557: XMLPUBFUN void XMLCALL xmlParserHandlePEReference(xmlParserCtxtPtr ctxt);
558: XMLPUBFUN int XMLCALL xmlCheckLanguageID (const xmlChar *lang);
559:
560: /*
561: * Really core function shared with HTML parser.
562: */
563: XMLPUBFUN int XMLCALL xmlCurrentChar (xmlParserCtxtPtr ctxt,
564: int *len);
565: XMLPUBFUN int XMLCALL xmlCopyCharMultiByte (xmlChar *out,
566: int val);
567: XMLPUBFUN int XMLCALL xmlCopyChar (int len,
568: xmlChar *out,
569: int val);
570: XMLPUBFUN void XMLCALL xmlNextChar (xmlParserCtxtPtr ctxt);
571: XMLPUBFUN void XMLCALL xmlParserInputShrink (xmlParserInputPtr in);
572:
573: #ifdef LIBXML_HTML_ENABLED
574: /*
575: * Actually comes from the HTML parser but launched from the init stuff.
576: */
577: XMLPUBFUN void XMLCALL htmlInitAutoClose (void);
578: XMLPUBFUN htmlParserCtxtPtr XMLCALL htmlCreateFileParserCtxt(const char *filename,
579: const char *encoding);
580: #endif
581:
582: /*
583: * Specific function to keep track of entities references
584: * and used by the XSLT debugger.
585: */
586: #ifdef LIBXML_LEGACY_ENABLED
587: /**
588: * xmlEntityReferenceFunc:
589: * @ent: the entity
590: * @firstNode: the fist node in the chunk
591: * @lastNode: the last nod in the chunk
592: *
593: * Callback function used when one needs to be able to track back the
594: * provenance of a chunk of nodes inherited from an entity replacement.
595: */
596: typedef void (*xmlEntityReferenceFunc) (xmlEntityPtr ent,
597: xmlNodePtr firstNode,
598: xmlNodePtr lastNode);
599:
600: XMLPUBFUN void XMLCALL xmlSetEntityReferenceFunc (xmlEntityReferenceFunc func);
601:
602: XMLPUBFUN xmlChar * XMLCALL
603: xmlParseQuotedString (xmlParserCtxtPtr ctxt);
604: XMLPUBFUN void XMLCALL
605: xmlParseNamespace (xmlParserCtxtPtr ctxt);
606: XMLPUBFUN xmlChar * XMLCALL
607: xmlNamespaceParseNSDef (xmlParserCtxtPtr ctxt);
608: XMLPUBFUN xmlChar * XMLCALL
609: xmlScanName (xmlParserCtxtPtr ctxt);
610: XMLPUBFUN xmlChar * XMLCALL
611: xmlNamespaceParseNCName (xmlParserCtxtPtr ctxt);
612: XMLPUBFUN void XMLCALL xmlParserHandleReference(xmlParserCtxtPtr ctxt);
613: XMLPUBFUN xmlChar * XMLCALL
614: xmlNamespaceParseQName (xmlParserCtxtPtr ctxt,
615: xmlChar **prefix);
616: /**
617: * Entities
618: */
619: XMLPUBFUN xmlChar * XMLCALL
620: xmlDecodeEntities (xmlParserCtxtPtr ctxt,
621: int len,
622: int what,
623: xmlChar end,
624: xmlChar end2,
625: xmlChar end3);
626: XMLPUBFUN void XMLCALL
627: xmlHandleEntity (xmlParserCtxtPtr ctxt,
628: xmlEntityPtr entity);
629:
630: #endif /* LIBXML_LEGACY_ENABLED */
631:
632: #ifdef IN_LIBXML
633: /*
634: * internal only
635: */
636: XMLPUBFUN void XMLCALL
637: xmlErrMemory (xmlParserCtxtPtr ctxt,
638: const char *extra);
639: #endif
640:
641: #ifdef __cplusplus
642: }
643: #endif
644: #endif /* __XML_PARSER_INTERNALS_H__ */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to parserInternals.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2 / include / libxml