libxml-parser.html revision 9cb5ff4e6a18f557a2332111686f0ca69cd43917 
1<HTML
2><HEAD
3><TITLE
4>parser</TITLE
5><META
6NAME="GENERATOR"
7CONTENT="Modular DocBook HTML Stylesheet Version 1.44"><LINK
8REL="HOME"
9TITLE="Gnome XML Library Reference Manual"
10HREF="book1.html"><LINK
11REL="UP"
12TITLE="Libxml Library Reference"
13HREF="libxml-lib.html"><LINK
14REL="PREVIOUS"
15TITLE="Libxml Library Reference"
16HREF="libxml-lib.html"><LINK
17REL="NEXT"
18TITLE="SAX"
19HREF="libxml-sax.html"></HEAD
20><BODY
21BGCOLOR="#FFFFFF"
22TEXT="#000000"
23LINK="#0000FF"
24VLINK="#840084"
25ALINK="#0000FF"
26><DIV
27CLASS="NAVHEADER"
28><TABLE
29WIDTH="100%"
30BORDER="0"
31BGCOLOR="#000000"
32CELLPADDING="1"
33CELLSPACING="0"
34><TR
35><TH
36COLSPAN="4"
37ALIGN="center"
38><FONT
39COLOR="#FFFFFF"
40SIZE="5"
41>Gnome XML Library Reference Manual</FONT
42></TH
43></TR
44><TR
45><TD
46WIDTH="25%"
47BGCOLOR="#C00000"
48ALIGN="left"
49><A
50HREF="libxml-lib.html"
51><FONT
52COLOR="#FFFFFF"
53SIZE="3"
54><B
55>&#60;&#60;&#60; Previous Page</B
56></FONT
57></A
58></TD
59><TD
60WIDTH="25%"
61BGCOLOR="#0000C0"
62ALIGN="center"
63><FONT
64COLOR="#FFFFFF"
65SIZE="3"
66><B
67><A
68HREF="book1.html"
69><FONT
70COLOR="#FFFFFF"
71SIZE="3"
72><B
73>Home</B
74></FONT
75></A
76></B
77></FONT
78></TD
79><TD
80WIDTH="25%"
81BGCOLOR="#00C000"
82ALIGN="center"
83><FONT
84COLOR="#FFFFFF"
85SIZE="3"
86><B
87><A
88HREF="libxml-lib.html"
89><FONT
90COLOR="#FFFFFF"
91SIZE="3"
92><B
93>Up</B
94></FONT
95></A
96></B
97></FONT
98></TD
99><TD
100WIDTH="25%"
101BGCOLOR="#C00000"
102ALIGN="right"
103><A
104HREF="libxml-sax.html"
105><FONT
106COLOR="#FFFFFF"
107SIZE="3"
108><B
109>Next Page &#62;&#62;&#62;</B
110></FONT
111></A
112></TD
113></TR
114></TABLE
115></DIV
116><H1
117><A
118NAME="LIBXML-PARSER"
119>parser</A
120></H1
121><DIV
122CLASS="REFNAMEDIV"
123><A
124NAME="AEN31"
125></A
126><H2
127>Name</H2
128>parser&nbsp;--&nbsp;</DIV
129><DIV
130CLASS="REFSYNOPSISDIV"
131><A
132NAME="AEN34"
133></A
134><H2
135>Synopsis</H2
136><TABLE
137BORDER="0"
138BGCOLOR="#D6E8FF"
139WIDTH="100%"
140CELLPADDING="6"
141><TR
142><TD
143><PRE
144CLASS="SYNOPSIS"
145>&#13;
146
147#define     <A
148HREF="libxml-parser.html#XML-DEFAULT-VERSION-CAPS"
149>XML_DEFAULT_VERSION</A
150>
151void        (<A
152HREF="libxml-parser.html#XMLPARSERINPUTDEALLOCATE"
153>*xmlParserInputDeallocate</A
154>)     (<A
155HREF="libxml-tree.html#XMLCHAR"
156>xmlChar</A
157>*);
158struct      <A
159HREF="libxml-parser.html#XMLPARSERINPUT"
160>xmlParserInput</A
161>;
162typedef     <A
163HREF="libxml-parser.html#XMLPARSERINPUTPTR"
164>xmlParserInputPtr</A
165>;
166struct      <A
167HREF="libxml-parser.html#XMLPARSERNODEINFO"
168>xmlParserNodeInfo</A
169>;
170typedef     <A
171HREF="libxml-parser.html#XMLPARSERNODEINFOPTR"
172>xmlParserNodeInfoPtr</A
173>;
174struct      <A
175HREF="libxml-parser.html#XMLPARSERNODEINFOSEQ"
176>xmlParserNodeInfoSeq</A
177>;
178typedef     <A
179HREF="libxml-parser.html#XMLPARSERNODEINFOSEQPTR"
180>xmlParserNodeInfoSeqPtr</A
181>;
182enum        <A
183HREF="libxml-parser.html#XMLPARSERINPUTSTATE"
184>xmlParserInputState</A
185>;
186struct      <A
187HREF="libxml-parser.html#XMLPARSERCTXT"
188>xmlParserCtxt</A
189>;
190typedef     <A
191HREF="libxml-parser.html#XMLPARSERCTXTPTR"
192>xmlParserCtxtPtr</A
193>;
194struct      <A
195HREF="libxml-parser.html#XMLSAXLOCATOR"
196>xmlSAXLocator</A
197>;
198typedef     <A
199HREF="libxml-parser.html#XMLSAXLOCATORPTR"
200>xmlSAXLocatorPtr</A
201>;
202<A
203HREF="libxml-parser.html#XMLPARSERINPUTPTR"
204>xmlParserInputPtr</A
205> (<A
206HREF="libxml-parser.html#RESOLVEENTITYSAXFUNC"
207>*resolveEntitySAXFunc</A
208>)   (void *ctx,
209                                             const <A
210HREF="libxml-tree.html#XMLCHAR"
211>xmlChar</A
212> *publicId,
213                                             const <A
214HREF="libxml-tree.html#XMLCHAR"
215>xmlChar</A
216> *systemId);
217void        (<A
218HREF="libxml-parser.html#INTERNALSUBSETSAXFUNC"
219>*internalSubsetSAXFunc</A
220>)        (void *ctx,
221                                             const <A
222HREF="libxml-tree.html#XMLCHAR"
223>xmlChar</A
224> *name,
225                                             const <A
226HREF="libxml-tree.html#XMLCHAR"
227>xmlChar</A
228> *ExternalID,
229                                             const <A
230HREF="libxml-tree.html#XMLCHAR"
231>xmlChar</A
232> *SystemID);
233void        (<A
234HREF="libxml-parser.html#EXTERNALSUBSETSAXFUNC"
235>*externalSubsetSAXFunc</A
236>)        (void *ctx,
237                                             const <A
238HREF="libxml-tree.html#XMLCHAR"
239>xmlChar</A
240> *name,
241                                             const <A
242HREF="libxml-tree.html#XMLCHAR"
243>xmlChar</A
244> *ExternalID,
245                                             const <A
246HREF="libxml-tree.html#XMLCHAR"
247>xmlChar</A
248> *SystemID);
249<A
250HREF="libxml-entities.html#XMLENTITYPTR"
251>xmlEntityPtr</A
252> (<A
253HREF="libxml-parser.html#GETENTITYSAXFUNC"
254>*getEntitySAXFunc</A
255>)            (void *ctx,
256                                             const <A
257HREF="libxml-tree.html#XMLCHAR"
258>xmlChar</A
259> *name);
260<A
261HREF="libxml-entities.html#XMLENTITYPTR"
262>xmlEntityPtr</A
263> (<A
264HREF="libxml-parser.html#GETPARAMETERENTITYSAXFUNC"
265>*getParameterEntitySAXFunc</A
266>)   (void *ctx,
267                                             const <A
268HREF="libxml-tree.html#XMLCHAR"
269>xmlChar</A
270> *name);
271void        (<A
272HREF="libxml-parser.html#ENTITYDECLSAXFUNC"
273>*entityDeclSAXFunc</A
274>)            (void *ctx,
275                                             const <A
276HREF="libxml-tree.html#XMLCHAR"
277>xmlChar</A
278> *name,
279                                             int type,
280                                             const <A
281HREF="libxml-tree.html#XMLCHAR"
282>xmlChar</A
283> *publicId,
284                                             const <A
285HREF="libxml-tree.html#XMLCHAR"
286>xmlChar</A
287> *systemId,
288                                             <A
289HREF="libxml-tree.html#XMLCHAR"
290>xmlChar</A
291> *content);
292void        (<A
293HREF="libxml-parser.html#NOTATIONDECLSAXFUNC"
294>*notationDeclSAXFunc</A
295>)          (void *ctx,
296                                             const <A
297HREF="libxml-tree.html#XMLCHAR"
298>xmlChar</A
299> *name,
300                                             const <A
301HREF="libxml-tree.html#XMLCHAR"
302>xmlChar</A
303> *publicId,
304                                             const <A
305HREF="libxml-tree.html#XMLCHAR"
306>xmlChar</A
307> *systemId);
308void        (<A
309HREF="libxml-parser.html#ATTRIBUTEDECLSAXFUNC"
310>*attributeDeclSAXFunc</A
311>)         (void *ctx,
312                                             const <A
313HREF="libxml-tree.html#XMLCHAR"
314>xmlChar</A
315> *elem,
316                                             const <A
317HREF="libxml-tree.html#XMLCHAR"
318>xmlChar</A
319> *name,
320                                             int type,
321                                             int def,
322                                             const <A
323HREF="libxml-tree.html#XMLCHAR"
324>xmlChar</A
325> *defaultValue,
326                                             <A
327HREF="libxml-tree.html#XMLENUMERATIONPTR"
328>xmlEnumerationPtr</A
329> tree);
330void        (<A
331HREF="libxml-parser.html#ELEMENTDECLSAXFUNC"
332>*elementDeclSAXFunc</A
333>)           (void *ctx,
334                                             const <A
335HREF="libxml-tree.html#XMLCHAR"
336>xmlChar</A
337> *name,
338                                             int type,
339                                             <A
340HREF="libxml-tree.html#XMLELEMENTCONTENTPTR"
341>xmlElementContentPtr</A
342> content);
343void        (<A
344HREF="libxml-parser.html#UNPARSEDENTITYDECLSAXFUNC"
345>*unparsedEntityDeclSAXFunc</A
346>)    (void *ctx,
347                                             const <A
348HREF="libxml-tree.html#XMLCHAR"
349>xmlChar</A
350> *name,
351                                             const <A
352HREF="libxml-tree.html#XMLCHAR"
353>xmlChar</A
354> *publicId,
355                                             const <A
356HREF="libxml-tree.html#XMLCHAR"
357>xmlChar</A
358> *systemId,
359                                             const <A
360HREF="libxml-tree.html#XMLCHAR"
361>xmlChar</A
362> *notationName);
363void        (<A
364HREF="libxml-parser.html#SETDOCUMENTLOCATORSAXFUNC"
365>*setDocumentLocatorSAXFunc</A
366>)    (void *ctx,
367                                             <A
368HREF="libxml-parser.html#XMLSAXLOCATORPTR"
369>xmlSAXLocatorPtr</A
370> loc);
371void        (<A
372HREF="libxml-parser.html#STARTDOCUMENTSAXFUNC"
373>*startDocumentSAXFunc</A
374>)         (void *ctx);
375void        (<A
376HREF="libxml-parser.html#ENDDOCUMENTSAXFUNC"
377>*endDocumentSAXFunc</A
378>)           (void *ctx);
379void        (<A
380HREF="libxml-parser.html#STARTELEMENTSAXFUNC"
381>*startElementSAXFunc</A
382>)          (void *ctx,
383                                             const <A
384HREF="libxml-tree.html#XMLCHAR"
385>xmlChar</A
386> *name,
387                                             const <A
388HREF="libxml-tree.html#XMLCHAR"
389>xmlChar</A
390> **atts);
391void        (<A
392HREF="libxml-parser.html#ENDELEMENTSAXFUNC"
393>*endElementSAXFunc</A
394>)            (void *ctx,
395                                             const <A
396HREF="libxml-tree.html#XMLCHAR"
397>xmlChar</A
398> *name);
399void        (<A
400HREF="libxml-parser.html#ATTRIBUTESAXFUNC"
401>*attributeSAXFunc</A
402>)             (void *ctx,
403                                             const <A
404HREF="libxml-tree.html#XMLCHAR"
405>xmlChar</A
406> *name,
407                                             const <A
408HREF="libxml-tree.html#XMLCHAR"
409>xmlChar</A
410> *value);
411void        (<A
412HREF="libxml-parser.html#REFERENCESAXFUNC"
413>*referenceSAXFunc</A
414>)             (void *ctx,
415                                             const <A
416HREF="libxml-tree.html#XMLCHAR"
417>xmlChar</A
418> *name);
419void        (<A
420HREF="libxml-parser.html#CHARACTERSSAXFUNC"
421>*charactersSAXFunc</A
422>)            (void *ctx,
423                                             const <A
424HREF="libxml-tree.html#XMLCHAR"
425>xmlChar</A
426> *ch,
427                                             int len);
428void        (<A
429HREF="libxml-parser.html#IGNORABLEWHITESPACESAXFUNC"
430>*ignorableWhitespaceSAXFunc</A
431>)   (void *ctx,
432                                             const <A
433HREF="libxml-tree.html#XMLCHAR"
434>xmlChar</A
435> *ch,
436                                             int len);
437void        (<A
438HREF="libxml-parser.html#PROCESSINGINSTRUCTIONSAXFUNC"
439>*processingInstructionSAXFunc</A
440>) (void *ctx,
441                                             const <A
442HREF="libxml-tree.html#XMLCHAR"
443>xmlChar</A
444> *target,
445                                             const <A
446HREF="libxml-tree.html#XMLCHAR"
447>xmlChar</A
448> *data);
449void        (<A
450HREF="libxml-parser.html#COMMENTSAXFUNC"
451>*commentSAXFunc</A
452>)               (void *ctx,
453                                             const <A
454HREF="libxml-tree.html#XMLCHAR"
455>xmlChar</A
456> *value);
457void        (<A
458HREF="libxml-parser.html#CDATABLOCKSAXFUNC"
459>*cdataBlockSAXFunc</A
460>)            (void *ctx,
461                                             const <A
462HREF="libxml-tree.html#XMLCHAR"
463>xmlChar</A
464> *value,
465                                             int len);
466void        (<A
467HREF="libxml-parser.html#WARNINGSAXFUNC"
468>*warningSAXFunc</A
469>)               (void *ctx,
470                                             const char *msg,
471                                             ...);
472void        (<A
473HREF="libxml-parser.html#ERRORSAXFUNC"
474>*errorSAXFunc</A
475>)                 (void *ctx,
476                                             const char *msg,
477                                             ...);
478void        (<A
479HREF="libxml-parser.html#FATALERRORSAXFUNC"
480>*fatalErrorSAXFunc</A
481>)            (void *ctx,
482                                             const char *msg,
483                                             ...);
484int         (<A
485HREF="libxml-parser.html#ISSTANDALONESAXFUNC"
486>*isStandaloneSAXFunc</A
487>)          (void *ctx);
488int         (<A
489HREF="libxml-parser.html#HASINTERNALSUBSETSAXFUNC"
490>*hasInternalSubsetSAXFunc</A
491>)     (void *ctx);
492int         (<A
493HREF="libxml-parser.html#HASEXTERNALSUBSETSAXFUNC"
494>*hasExternalSubsetSAXFunc</A
495>)     (void *ctx);
496struct      <A
497HREF="libxml-parser.html#XMLSAXHANDLER"
498>xmlSAXHandler</A
499>;
500typedef     <A
501HREF="libxml-parser.html#XMLSAXHANDLERPTR"
502>xmlSAXHandlerPtr</A
503>;
504<A
505HREF="libxml-parser.html#XMLPARSERINPUTPTR"
506>xmlParserInputPtr</A
507> (<A
508HREF="libxml-parser.html#XMLEXTERNALENTITYLOADER"
509>*xmlExternalEntityLoader</A
510>)
511                                            (const char *URL,
512                                             const char *ID,
513                                             <A
514HREF="libxml-parser.html#XMLPARSERCTXTPTR"
515>xmlParserCtxtPtr</A
516> context);
517#define     <A
518HREF="libxml-parser.html#XMLSUBSTITUTEENTITIESDEFAULTVALUE"
519>xmlSubstituteEntitiesDefaultValue</A
520>
521void        <A
522HREF="libxml-parser.html#XMLINITPARSER"
523>xmlInitParser</A
524>                   (void);
525void        <A
526HREF="libxml-parser.html#XMLCLEANUPPARSER"
527>xmlCleanupParser</A
528>                (void);
529int         <A
530HREF="libxml-parser.html#XMLPARSERINPUTREAD"
531>xmlParserInputRead</A
532>              (<A
533HREF="libxml-parser.html#XMLPARSERINPUTPTR"
534>xmlParserInputPtr</A
535> in,
536                                             int len);
537int         <A
538HREF="libxml-parser.html#XMLPARSERINPUTGROW"
539>xmlParserInputGrow</A
540>              (<A
541HREF="libxml-parser.html#XMLPARSERINPUTPTR"
542>xmlParserInputPtr</A
543> in,
544                                             int len);
545<A
546HREF="libxml-tree.html#XMLCHAR"
547>xmlChar</A
548>*    <A
549HREF="libxml-parser.html#XMLSTRDUP"
550>xmlStrdup</A
551>                       (const <A
552HREF="libxml-tree.html#XMLCHAR"
553>xmlChar</A
554> *cur);
555<A
556HREF="libxml-tree.html#XMLCHAR"
557>xmlChar</A
558>*    <A
559HREF="libxml-parser.html#XMLSTRNDUP"
560>xmlStrndup</A
561>                      (const <A
562HREF="libxml-tree.html#XMLCHAR"
563>xmlChar</A
564> *cur,
565                                             int len);
566<A
567HREF="libxml-tree.html#XMLCHAR"
568>xmlChar</A
569>*    <A
570HREF="libxml-parser.html#XMLSTRSUB"
571>xmlStrsub</A
572>                       (const <A
573HREF="libxml-tree.html#XMLCHAR"
574>xmlChar</A
575> *str,
576                                             int start,
577                                             int len);
578const <A
579HREF="libxml-tree.html#XMLCHAR"
580>xmlChar</A
581>* <A
582HREF="libxml-parser.html#XMLSTRCHR"
583>xmlStrchr</A
584>                    (const <A
585HREF="libxml-tree.html#XMLCHAR"
586>xmlChar</A
587> *str,
588                                             <A
589HREF="libxml-tree.html#XMLCHAR"
590>xmlChar</A
591> val);
592const <A
593HREF="libxml-tree.html#XMLCHAR"
594>xmlChar</A
595>* <A
596HREF="libxml-parser.html#XMLSTRSTR"
597>xmlStrstr</A
598>                    (const <A
599HREF="libxml-tree.html#XMLCHAR"
600>xmlChar</A
601> *str,
602                                             <A
603HREF="libxml-tree.html#XMLCHAR"
604>xmlChar</A
605> *val);
606const <A
607HREF="libxml-tree.html#XMLCHAR"
608>xmlChar</A
609>* <A
610HREF="libxml-parser.html#XMLSTRCASESTR"
611>xmlStrcasestr</A
612>                (const <A
613HREF="libxml-tree.html#XMLCHAR"
614>xmlChar</A
615> *str,
616                                             <A
617HREF="libxml-tree.html#XMLCHAR"
618>xmlChar</A
619> *val);
620int         <A
621HREF="libxml-parser.html#XMLSTRCMP"
622>xmlStrcmp</A
623>                       (const <A
624HREF="libxml-tree.html#XMLCHAR"
625>xmlChar</A
626> *str1,
627                                             const <A
628HREF="libxml-tree.html#XMLCHAR"
629>xmlChar</A
630> *str2);
631int         <A
632HREF="libxml-parser.html#XMLSTRNCMP"
633>xmlStrncmp</A
634>                      (const <A
635HREF="libxml-tree.html#XMLCHAR"
636>xmlChar</A
637> *str1,
638                                             const <A
639HREF="libxml-tree.html#XMLCHAR"
640>xmlChar</A
641> *str2,
642                                             int len);
643int         <A
644HREF="libxml-parser.html#XMLSTRCASECMP"
645>xmlStrcasecmp</A
646>                   (const <A
647HREF="libxml-tree.html#XMLCHAR"
648>xmlChar</A
649> *str1,
650                                             const <A
651HREF="libxml-tree.html#XMLCHAR"
652>xmlChar</A
653> *str2);
654int         <A
655HREF="libxml-parser.html#XMLSTRNCASECMP"
656>xmlStrncasecmp</A
657>                  (const <A
658HREF="libxml-tree.html#XMLCHAR"
659>xmlChar</A
660> *str1,
661                                             const <A
662HREF="libxml-tree.html#XMLCHAR"
663>xmlChar</A
664> *str2,
665                                             int len);
666int         <A
667HREF="libxml-parser.html#XMLSTREQUAL"
668>xmlStrEqual</A
669>                     (const <A
670HREF="libxml-tree.html#XMLCHAR"
671>xmlChar</A
672> *str1,
673                                             const <A
674HREF="libxml-tree.html#XMLCHAR"
675>xmlChar</A
676> *str2);
677int         <A
678HREF="libxml-parser.html#XMLSTRLEN"
679>xmlStrlen</A
680>                       (const <A
681HREF="libxml-tree.html#XMLCHAR"
682>xmlChar</A
683> *str);
684<A
685HREF="libxml-tree.html#XMLCHAR"
686>xmlChar</A
687>*    <A
688HREF="libxml-parser.html#XMLSTRCAT"
689>xmlStrcat</A
690>                       (<A
691HREF="libxml-tree.html#XMLCHAR"
692>xmlChar</A
693> *cur,
694                                             const <A
695HREF="libxml-tree.html#XMLCHAR"
696>xmlChar</A
697> *add);
698<A
699HREF="libxml-tree.html#XMLCHAR"
700>xmlChar</A
701>*    <A
702HREF="libxml-parser.html#XMLSTRNCAT"
703>xmlStrncat</A
704>                      (<A
705HREF="libxml-tree.html#XMLCHAR"
706>xmlChar</A
707> *cur,
708                                             const <A
709HREF="libxml-tree.html#XMLCHAR"
710>xmlChar</A
711> *add,
712                                             int len);
713<A
714HREF="libxml-tree.html#XMLDOCPTR"
715>xmlDocPtr</A
716>   <A
717HREF="libxml-parser.html#XMLPARSEDOC"
718>xmlParseDoc</A
719>                     (<A
720HREF="libxml-tree.html#XMLCHAR"
721>xmlChar</A
722> *cur);
723<A
724HREF="libxml-tree.html#XMLDOCPTR"
725>xmlDocPtr</A
726>   <A
727HREF="libxml-parser.html#XMLPARSEMEMORY"
728>xmlParseMemory</A
729>                  (char *buffer,
730                                             int size);
731<A
732HREF="libxml-tree.html#XMLDOCPTR"
733>xmlDocPtr</A
734>   <A
735HREF="libxml-parser.html#XMLPARSEFILE"
736>xmlParseFile</A
737>                    (const char *filename);
738int         <A
739HREF="libxml-parser.html#XMLSUBSTITUTEENTITIESDEFAULT"
740>xmlSubstituteEntitiesDefault</A
741>    (int val);
742int         <A
743HREF="libxml-parser.html#XMLKEEPBLANKSDEFAULT"
744>xmlKeepBlanksDefault</A
745>            (int val);
746void        <A
747HREF="libxml-parser.html#XMLSTOPPARSER"
748>xmlStopParser</A
749>                   (<A
750HREF="libxml-parser.html#XMLPARSERCTXTPTR"
751>xmlParserCtxtPtr</A
752> ctxt);
753int         <A
754HREF="libxml-parser.html#XMLPEDANTICPARSERDEFAULT"
755>xmlPedanticParserDefault</A
756>        (int val);
757<A
758HREF="libxml-tree.html#XMLDOCPTR"
759>xmlDocPtr</A
760>   <A
761HREF="libxml-parser.html#XMLRECOVERDOC"
762>xmlRecoverDoc</A
763>                   (<A
764HREF="libxml-tree.html#XMLCHAR"
765>xmlChar</A
766> *cur);
767<A
768HREF="libxml-tree.html#XMLDOCPTR"
769>xmlDocPtr</A
770>   <A
771HREF="libxml-parser.html#XMLRECOVERMEMORY"
772>xmlRecoverMemory</A
773>                (char *buffer,
774                                             int size);
775<A
776HREF="libxml-tree.html#XMLDOCPTR"
777>xmlDocPtr</A
778>   <A
779HREF="libxml-parser.html#XMLRECOVERFILE"
780>xmlRecoverFile</A
781>                  (const char *filename);
782int         <A
783HREF="libxml-parser.html#XMLPARSEDOCUMENT"
784>xmlParseDocument</A
785>                (<A
786HREF="libxml-parser.html#XMLPARSERCTXTPTR"
787>xmlParserCtxtPtr</A
788> ctxt);
789int         <A
790HREF="libxml-parser.html#XMLPARSEEXTPARSEDENT"
791>xmlParseExtParsedEnt</A
792>            (<A
793HREF="libxml-parser.html#XMLPARSERCTXTPTR"
794>xmlParserCtxtPtr</A
795> ctxt);
796<A
797HREF="libxml-tree.html#XMLDOCPTR"
798>xmlDocPtr</A
799>   <A
800HREF="libxml-parser.html#XMLSAXPARSEDOC"
801>xmlSAXParseDoc</A
802>                  (<A
803HREF="libxml-parser.html#XMLSAXHANDLERPTR"
804>xmlSAXHandlerPtr</A
805> sax,
806                                             <A
807HREF="libxml-tree.html#XMLCHAR"
808>xmlChar</A
809> *cur,
810                                             int recovery);
811int         <A
812HREF="libxml-parser.html#XMLSAXUSERPARSEFILE"
813>xmlSAXUserParseFile</A
814>             (<A
815HREF="libxml-parser.html#XMLSAXHANDLERPTR"
816>xmlSAXHandlerPtr</A
817> sax,
818                                             void *user_data,
819                                             const char *filename);
820int         <A
821HREF="libxml-parser.html#XMLSAXUSERPARSEMEMORY"
822>xmlSAXUserParseMemory</A
823>           (<A
824HREF="libxml-parser.html#XMLSAXHANDLERPTR"
825>xmlSAXHandlerPtr</A
826> sax,
827                                             void *user_data,
828                                             char *buffer,
829                                             int size);
830<A
831HREF="libxml-tree.html#XMLDOCPTR"
832>xmlDocPtr</A
833>   <A
834HREF="libxml-parser.html#XMLSAXPARSEMEMORY"
835>xmlSAXParseMemory</A
836>               (<A
837HREF="libxml-parser.html#XMLSAXHANDLERPTR"
838>xmlSAXHandlerPtr</A
839> sax,
840                                             char *buffer,
841                                             int size,
842                                             int recovery);
843<A
844HREF="libxml-tree.html#XMLDOCPTR"
845>xmlDocPtr</A
846>   <A
847HREF="libxml-parser.html#XMLSAXPARSEFILE"
848>xmlSAXParseFile</A
849>                 (<A
850HREF="libxml-parser.html#XMLSAXHANDLERPTR"
851>xmlSAXHandlerPtr</A
852> sax,
853                                             const char *filename,
854                                             int recovery);
855<A
856HREF="libxml-tree.html#XMLDOCPTR"
857>xmlDocPtr</A
858>   <A
859HREF="libxml-parser.html#XMLSAXPARSEENTITY"
860>xmlSAXParseEntity</A
861>               (<A
862HREF="libxml-parser.html#XMLSAXHANDLERPTR"
863>xmlSAXHandlerPtr</A
864> sax,
865                                             const char *filename);
866<A
867HREF="libxml-tree.html#XMLDOCPTR"
868>xmlDocPtr</A
869>   <A
870HREF="libxml-parser.html#XMLPARSEENTITY"
871>xmlParseEntity</A
872>                  (const char *filename);
873<A
874HREF="libxml-tree.html#XMLDTDPTR"
875>xmlDtdPtr</A
876>   <A
877HREF="libxml-parser.html#XMLPARSEDTD"
878>xmlParseDTD</A
879>                     (const <A
880HREF="libxml-tree.html#XMLCHAR"
881>xmlChar</A
882> *ExternalID,
883                                             const <A
884HREF="libxml-tree.html#XMLCHAR"
885>xmlChar</A
886> *SystemID);
887<A
888HREF="libxml-tree.html#XMLDTDPTR"
889>xmlDtdPtr</A
890>   <A
891HREF="libxml-parser.html#XMLSAXPARSEDTD"
892>xmlSAXParseDTD</A
893>                  (<A
894HREF="libxml-parser.html#XMLSAXHANDLERPTR"
895>xmlSAXHandlerPtr</A
896> sax,
897                                             const <A
898HREF="libxml-tree.html#XMLCHAR"
899>xmlChar</A
900> *ExternalID,
901                                             const <A
902HREF="libxml-tree.html#XMLCHAR"
903>xmlChar</A
904> *SystemID);
905<A
906HREF="libxml-tree.html#XMLDTDPTR"
907>xmlDtdPtr</A
908>   <A
909HREF="libxml-parser.html#XMLIOPARSEDTD"
910>xmlIOParseDTD</A
911>                   (<A
912HREF="libxml-parser.html#XMLSAXHANDLERPTR"
913>xmlSAXHandlerPtr</A
914> sax,
915                                             <A
916HREF="libxml-xmlio.html#XMLPARSERINPUTBUFFERPTR"
917>xmlParserInputBufferPtr</A
918> input,
919                                             <A
920HREF="libxml-encoding.html#XMLCHARENCODING"
921>xmlCharEncoding</A
922> enc);
923int         <A
924HREF="libxml-parser.html#XMLPARSEBALANCEDCHUNKMEMORY"
925>xmlParseBalancedChunkMemory</A
926>     (<A
927HREF="libxml-tree.html#XMLDOCPTR"
928>xmlDocPtr</A
929> doc,
930                                             <A
931HREF="libxml-parser.html#XMLSAXHANDLERPTR"
932>xmlSAXHandlerPtr</A
933> sax,
934                                             void *user_data,
935                                             int depth,
936                                             const <A
937HREF="libxml-tree.html#XMLCHAR"
938>xmlChar</A
939> *string,
940                                             <A
941HREF="libxml-tree.html#XMLNODEPTR"
942>xmlNodePtr</A
943> *list);
944int         <A
945HREF="libxml-parser.html#XMLPARSEEXTERNALENTITY"
946>xmlParseExternalEntity</A
947>          (<A
948HREF="libxml-tree.html#XMLDOCPTR"
949>xmlDocPtr</A
950> doc,
951                                             <A
952HREF="libxml-parser.html#XMLSAXHANDLERPTR"
953>xmlSAXHandlerPtr</A
954> sax,
955                                             void *user_data,
956                                             int depth,
957                                             const <A
958HREF="libxml-tree.html#XMLCHAR"
959>xmlChar</A
960> *URL,
961                                             const <A
962HREF="libxml-tree.html#XMLCHAR"
963>xmlChar</A
964> *ID,
965                                             <A
966HREF="libxml-tree.html#XMLNODEPTR"
967>xmlNodePtr</A
968> *list);
969int         <A
970HREF="libxml-parser.html#XMLPARSECTXTEXTERNALENTITY"
971>xmlParseCtxtExternalEntity</A
972>      (<A
973HREF="libxml-parser.html#XMLPARSERCTXTPTR"
974>xmlParserCtxtPtr</A
975> ctx,
976                                             const <A
977HREF="libxml-tree.html#XMLCHAR"
978>xmlChar</A
979> *URL,
980                                             const <A
981HREF="libxml-tree.html#XMLCHAR"
982>xmlChar</A
983> *ID,
984                                             <A
985HREF="libxml-tree.html#XMLNODEPTR"
986>xmlNodePtr</A
987> *list);
988void        <A
989HREF="libxml-parser.html#XMLDEFAULTSAXHANDLERINIT"
990>xmlDefaultSAXHandlerInit</A
991>        (void);
992void        <A
993HREF="libxml-parser.html#HTMLDEFAULTSAXHANDLERINIT"
994>htmlDefaultSAXHandlerInit</A
995>       (void);
996void        <A
997HREF="libxml-parser.html#XMLINITPARSERCTXT"
998>xmlInitParserCtxt</A
999>               (<A
1000HREF="libxml-parser.html#XMLPARSERCTXTPTR"
1001>xmlParserCtxtPtr</A
1002> ctxt);
1003void        <A
1004HREF="libxml-parser.html#XMLCLEARPARSERCTXT"
1005>xmlClearParserCtxt</A
1006>              (<A
1007HREF="libxml-parser.html#XMLPARSERCTXTPTR"
1008>xmlParserCtxtPtr</A
1009> ctxt);
1010void        <A
1011HREF="libxml-parser.html#XMLFREEPARSERCTXT"
1012>xmlFreeParserCtxt</A
1013>               (<A
1014HREF="libxml-parser.html#XMLPARSERCTXTPTR"
1015>xmlParserCtxtPtr</A
1016> ctxt);
1017void        <A
1018HREF="libxml-parser.html#XMLSETUPPARSERFORBUFFER"
1019>xmlSetupParserForBuffer</A
1020>         (<A
1021HREF="libxml-parser.html#XMLPARSERCTXTPTR"
1022>xmlParserCtxtPtr</A
1023> ctxt,
1024                                             const <A
1025HREF="libxml-tree.html#XMLCHAR"
1026>xmlChar</A
1027> *buffer,
1028                                             const char *filename);
1029<A
1030HREF="libxml-parser.html#XMLPARSERCTXTPTR"
1031>xmlParserCtxtPtr</A
1032> <A
1033HREF="libxml-parser.html#XMLCREATEDOCPARSERCTXT"
1034>xmlCreateDocParserCtxt</A
1035>     (<A
1036HREF="libxml-tree.html#XMLCHAR"
1037>xmlChar</A
1038> *cur);
1039int         <A
1040HREF="libxml-parser.html#XMLGETFEATURESLIST"
1041>xmlGetFeaturesList</A
1042>              (int *len,
1043                                             const char **result);
1044int         <A
1045HREF="libxml-parser.html#XMLGETFEATURE"
1046>xmlGetFeature</A
1047>                   (<A
1048HREF="libxml-parser.html#XMLPARSERCTXTPTR"
1049>xmlParserCtxtPtr</A
1050> ctxt,
1051                                             const char *name,
1052                                             void *result);
1053int         <A
1054HREF="libxml-parser.html#XMLSETFEATURE"
1055>xmlSetFeature</A
1056>                   (<A
1057HREF="libxml-parser.html#XMLPARSERCTXTPTR"
1058>xmlParserCtxtPtr</A
1059> ctxt,
1060                                             const char *name,
1061                                             void *value);
1062<A
1063HREF="libxml-parser.html#XMLPARSERCTXTPTR"
1064>xmlParserCtxtPtr</A
1065> <A
1066HREF="libxml-parser.html#XMLCREATEPUSHPARSERCTXT"
1067>xmlCreatePushParserCtxt</A
1068>    (<A
1069HREF="libxml-parser.html#XMLSAXHANDLERPTR"
1070>xmlSAXHandlerPtr</A
1071> sax,
1072                                             void *user_data,
1073                                             const char *chunk,
1074                                             int size,
1075                                             const char *filename);
1076int         <A
1077HREF="libxml-parser.html#XMLPARSECHUNK"
1078>xmlParseChunk</A
1079>                   (<A
1080HREF="libxml-parser.html#XMLPARSERCTXTPTR"
1081>xmlParserCtxtPtr</A
1082> ctxt,
1083                                             const char *chunk,
1084                                             int size,
1085                                             int terminate);
1086<A
1087HREF="libxml-parser.html#XMLPARSERCTXTPTR"
1088>xmlParserCtxtPtr</A
1089> <A
1090HREF="libxml-parser.html#XMLCREATEIOPARSERCTXT"
1091>xmlCreateIOParserCtxt</A
1092>      (<A
1093HREF="libxml-parser.html#XMLSAXHANDLERPTR"
1094>xmlSAXHandlerPtr</A
1095> sax,
1096                                             void *user_data,
1097                                             <A
1098HREF="libxml-xmlio.html#XMLINPUTREADCALLBACK"
1099>xmlInputReadCallback</A
1100> ioread,
1101                                             <A
1102HREF="libxml-xmlio.html#XMLINPUTCLOSECALLBACK"
1103>xmlInputCloseCallback</A
1104> ioclose,
1105                                             void *ioctx,
1106                                             <A
1107HREF="libxml-encoding.html#XMLCHARENCODING"
1108>xmlCharEncoding</A
1109> enc);
1110<A
1111HREF="libxml-parser.html#XMLPARSERINPUTPTR"
1112>xmlParserInputPtr</A
1113> <A
1114HREF="libxml-parser.html#XMLNEWIOINPUTSTREAM"
1115>xmlNewIOInputStream</A
1116>       (<A
1117HREF="libxml-parser.html#XMLPARSERCTXTPTR"
1118>xmlParserCtxtPtr</A
1119> ctxt,
1120                                             <A
1121HREF="libxml-xmlio.html#XMLPARSERINPUTBUFFERPTR"
1122>xmlParserInputBufferPtr</A
1123> input,
1124                                             <A
1125HREF="libxml-encoding.html#XMLCHARENCODING"
1126>xmlCharEncoding</A
1127> enc);
1128const <A
1129HREF="libxml-parser.html#XMLPARSERNODEINFO"
1130>xmlParserNodeInfo</A
1131>* <A
1132HREF="libxml-parser.html#XMLPARSERFINDNODEINFO"
1133>xmlParserFindNodeInfo</A
1134>
1135                                            (const <A
1136HREF="libxml-parser.html#XMLPARSERCTXT"
1137>xmlParserCtxt</A
1138> *ctxt,
1139                                             const <A
1140HREF="libxml-tree.html#XMLNODE"
1141>xmlNode</A
1142> *node);
1143void        <A
1144HREF="libxml-parser.html#XMLINITNODEINFOSEQ"
1145>xmlInitNodeInfoSeq</A
1146>              (<A
1147HREF="libxml-parser.html#XMLPARSERNODEINFOSEQPTR"
1148>xmlParserNodeInfoSeqPtr</A
1149> seq);
1150void        <A
1151HREF="libxml-parser.html#XMLCLEARNODEINFOSEQ"
1152>xmlClearNodeInfoSeq</A
1153>             (<A
1154HREF="libxml-parser.html#XMLPARSERNODEINFOSEQPTR"
1155>xmlParserNodeInfoSeqPtr</A
1156> seq);
1157unsigned <GTKDOCLINK
1158HREF="LONG"
1159>long</GTKDOCLINK
1160> <A
1161HREF="libxml-parser.html#XMLPARSERFINDNODEINFOINDEX"
1162>xmlParserFindNodeInfoIndex</A
1163>    (const <A
1164HREF="libxml-parser.html#XMLPARSERNODEINFOSEQ"
1165>xmlParserNodeInfoSeq</A
1166> *seq,
1167                                             const <A
1168HREF="libxml-tree.html#XMLNODE"
1169>xmlNode</A
1170> *node);
1171void        <A
1172HREF="libxml-parser.html#XMLPARSERADDNODEINFO"
1173>xmlParserAddNodeInfo</A
1174>            (<A
1175HREF="libxml-parser.html#XMLPARSERCTXTPTR"
1176>xmlParserCtxtPtr</A
1177> ctxt,
1178                                             const <A
1179HREF="libxml-parser.html#XMLPARSERNODEINFO"
1180>xmlParserNodeInfo</A
1181> *info);
1182void        <A
1183HREF="libxml-parser.html#XMLSETEXTERNALENTITYLOADER"
1184>xmlSetExternalEntityLoader</A
1185>      (<A
1186HREF="libxml-parser.html#XMLEXTERNALENTITYLOADER"
1187>xmlExternalEntityLoader</A
1188> f);
1189<A
1190HREF="libxml-parser.html#XMLEXTERNALENTITYLOADER"
1191>xmlExternalEntityLoader</A
1192> <A
1193HREF="libxml-parser.html#XMLGETEXTERNALENTITYLOADER"
1194>xmlGetExternalEntityLoader</A
1195>
1196                                            (void);
1197<A
1198HREF="libxml-parser.html#XMLPARSERINPUTPTR"
1199>xmlParserInputPtr</A
1200> <A
1201HREF="libxml-parser.html#XMLLOADEXTERNALENTITY"
1202>xmlLoadExternalEntity</A
1203>     (const char *URL,
1204                                             const char *ID,
1205                                             <A
1206HREF="libxml-parser.html#XMLPARSERCTXTPTR"
1207>xmlParserCtxtPtr</A
1208> context);</PRE
1209></TD
1210></TR
1211></TABLE
1212></DIV
1213><DIV
1214CLASS="REFSECT1"
1215><A
1216NAME="AEN309"
1217></A
1218><H2
1219>Description</H2
1220><P
1221></P
1222></DIV
1223><DIV
1224CLASS="REFSECT1"
1225><A
1226NAME="AEN312"
1227></A
1228><H2
1229>Details</H2
1230><DIV
1231CLASS="REFSECT2"
1232><A
1233NAME="AEN314"
1234></A
1235><H3
1236><A
1237NAME="XML-DEFAULT-VERSION-CAPS"
1238></A
1239>XML_DEFAULT_VERSION</H3
1240><TABLE
1241BORDER="0"
1242BGCOLOR="#D6E8FF"
1243WIDTH="100%"
1244CELLPADDING="6"
1245><TR
1246><TD
1247><PRE
1248CLASS="PROGRAMLISTING"
1249>#define XML_DEFAULT_VERSION	"1.0"</PRE
1250></TD
1251></TR
1252></TABLE
1253><P
1254></P
1255></DIV
1256><HR><DIV
1257CLASS="REFSECT2"
1258><A
1259NAME="AEN319"
1260></A
1261><H3
1262><A
1263NAME="XMLPARSERINPUTDEALLOCATE"
1264></A
1265>xmlParserInputDeallocate ()</H3
1266><TABLE
1267BORDER="0"
1268BGCOLOR="#D6E8FF"
1269WIDTH="100%"
1270CELLPADDING="6"
1271><TR
1272><TD
1273><PRE
1274CLASS="PROGRAMLISTING"
1275>void        (*xmlParserInputDeallocate)     (<A
1276HREF="libxml-tree.html#XMLCHAR"
1277>xmlChar</A
1278>*);</PRE
1279></TD
1280></TR
1281></TABLE
1282><P
1283></P
1284><DIV
1285CLASS="INFORMALTABLE"
1286><P
1287></P
1288><TABLE
1289BORDER="0"
1290WIDTH="100%"
1291BGCOLOR="#FFD0D0"
1292CELLSPACING="0"
1293CELLPADDING="4"
1294CLASS="CALSTABLE"
1295><TR
1296><TD
1297WIDTH="20%"
1298ALIGN="RIGHT"
1299VALIGN="TOP"
1300><TT
1301CLASS="PARAMETER"
1302><I
1303>Param1</I
1304></TT
1305>&nbsp;:</TD
1306><TD
1307WIDTH="80%"
1308ALIGN="LEFT"
1309VALIGN="TOP"
1310>&#13;</TD
1311></TR
1312></TABLE
1313><P
1314></P
1315></DIV
1316></DIV
1317><HR><DIV
1318CLASS="REFSECT2"
1319><A
1320NAME="AEN334"
1321></A
1322><H3
1323><A
1324NAME="XMLPARSERINPUT"
1325></A
1326>struct xmlParserInput</H3
1327><TABLE
1328BORDER="0"
1329BGCOLOR="#D6E8FF"
1330WIDTH="100%"
1331CELLPADDING="6"
1332><TR
1333><TD
1334><PRE
1335CLASS="PROGRAMLISTING"
1336>struct xmlParserInput {
1337    /* Input buffer */
1338    xmlParserInputBufferPtr buf;      /* UTF-8 encoded buffer */
1339
1340    const char *filename;             /* The file analyzed, if any */
1341    const char *directory;            /* the directory/base of teh file */
1342    const xmlChar *base;              /* Base of the array to parse */
1343    const xmlChar *cur;               /* Current char being parsed */
1344    int length;                       /* length if known */
1345    int line;                         /* Current line */
1346    int col;                          /* Current column */
1347    int consumed;                     /* How many xmlChars already consumed */
1348    xmlParserInputDeallocate free;    /* function to deallocate the base */
1349    const xmlChar *encoding;          /* the encoding string for entity */
1350    const xmlChar *version;           /* the version string for entity */
1351    int standalone;                   /* Was that entity marked standalone */
1352};</PRE
1353></TD
1354></TR
1355></TABLE
1356><P
1357></P
1358></DIV
1359><HR><DIV
1360CLASS="REFSECT2"
1361><A
1362NAME="AEN339"
1363></A
1364><H3
1365><A
1366NAME="XMLPARSERINPUTPTR"
1367></A
1368>xmlParserInputPtr</H3
1369><TABLE
1370BORDER="0"
1371BGCOLOR="#D6E8FF"
1372WIDTH="100%"
1373CELLPADDING="6"
1374><TR
1375><TD
1376><PRE
1377CLASS="PROGRAMLISTING"
1378>typedef xmlParserInput *xmlParserInputPtr;</PRE
1379></TD
1380></TR
1381></TABLE
1382><P
1383></P
1384></DIV
1385><HR><DIV
1386CLASS="REFSECT2"
1387><A
1388NAME="AEN344"
1389></A
1390><H3
1391><A
1392NAME="XMLPARSERNODEINFO"
1393></A
1394>struct xmlParserNodeInfo</H3
1395><TABLE
1396BORDER="0"
1397BGCOLOR="#D6E8FF"
1398WIDTH="100%"
1399CELLPADDING="6"
1400><TR
1401><TD
1402><PRE
1403CLASS="PROGRAMLISTING"
1404>struct xmlParserNodeInfo {
1405  const struct _xmlNode* node;
1406  /* Position &amp; line # that text that created the node begins &amp; ends on */
1407  unsigned long begin_pos;
1408  unsigned long begin_line;
1409  unsigned long end_pos;
1410  unsigned long end_line;
1411};</PRE
1412></TD
1413></TR
1414></TABLE
1415><P
1416></P
1417></DIV
1418><HR><DIV
1419CLASS="REFSECT2"
1420><A
1421NAME="AEN349"
1422></A
1423><H3
1424><A
1425NAME="XMLPARSERNODEINFOPTR"
1426></A
1427>xmlParserNodeInfoPtr</H3
1428><TABLE
1429BORDER="0"
1430BGCOLOR="#D6E8FF"
1431WIDTH="100%"
1432CELLPADDING="6"
1433><TR
1434><TD
1435><PRE
1436CLASS="PROGRAMLISTING"
1437>typedef xmlParserNodeInfo *xmlParserNodeInfoPtr;</PRE
1438></TD
1439></TR
1440></TABLE
1441><P
1442></P
1443></DIV
1444><HR><DIV
1445CLASS="REFSECT2"
1446><A
1447NAME="AEN354"
1448></A
1449><H3
1450><A
1451NAME="XMLPARSERNODEINFOSEQ"
1452></A
1453>struct xmlParserNodeInfoSeq</H3
1454><TABLE
1455BORDER="0"
1456BGCOLOR="#D6E8FF"
1457WIDTH="100%"
1458CELLPADDING="6"
1459><TR
1460><TD
1461><PRE
1462CLASS="PROGRAMLISTING"
1463>struct xmlParserNodeInfoSeq {
1464  unsigned long maximum;
1465  unsigned long length;
1466  xmlParserNodeInfo* buffer;
1467};</PRE
1468></TD
1469></TR
1470></TABLE
1471><P
1472></P
1473></DIV
1474><HR><DIV
1475CLASS="REFSECT2"
1476><A
1477NAME="AEN359"
1478></A
1479><H3
1480><A
1481NAME="XMLPARSERNODEINFOSEQPTR"
1482></A
1483>xmlParserNodeInfoSeqPtr</H3
1484><TABLE
1485BORDER="0"
1486BGCOLOR="#D6E8FF"
1487WIDTH="100%"
1488CELLPADDING="6"
1489><TR
1490><TD
1491><PRE
1492CLASS="PROGRAMLISTING"
1493>typedef xmlParserNodeInfoSeq *xmlParserNodeInfoSeqPtr;</PRE
1494></TD
1495></TR
1496></TABLE
1497><P
1498></P
1499></DIV
1500><HR><DIV
1501CLASS="REFSECT2"
1502><A
1503NAME="AEN364"
1504></A
1505><H3
1506><A
1507NAME="XMLPARSERINPUTSTATE"
1508></A
1509>enum xmlParserInputState</H3
1510><TABLE
1511BORDER="0"
1512BGCOLOR="#D6E8FF"
1513WIDTH="100%"
1514CELLPADDING="6"
1515><TR
1516><TD
1517><PRE
1518CLASS="PROGRAMLISTING"
1519>typedef enum {
1520    XML_PARSER_EOF = -1,	/* nothing is to be parsed */
1521    XML_PARSER_START = 0,	/* nothing has been parsed */
1522    XML_PARSER_MISC,		/* Misc* before int subset */
1523    XML_PARSER_PI,		/* Whithin a processing instruction */
1524    XML_PARSER_DTD,		/* within some DTD content */
1525    XML_PARSER_PROLOG,		/* Misc* after internal subset */
1526    XML_PARSER_COMMENT,		/* within a comment */
1527    XML_PARSER_START_TAG,	/* within a start tag */
1528    XML_PARSER_CONTENT,		/* within the content */
1529    XML_PARSER_CDATA_SECTION,	/* within a CDATA section */
1530    XML_PARSER_END_TAG,		/* within a closing tag */
1531    XML_PARSER_ENTITY_DECL,	/* within an entity declaration */
1532    XML_PARSER_ENTITY_VALUE,	/* within an entity value in a decl */
1533    XML_PARSER_ATTRIBUTE_VALUE,	/* within an attribute value */
1534    XML_PARSER_SYSTEM_LITERAL,	/* within a SYSTEM value */
1535    XML_PARSER_EPILOG, 		/* the Misc* after the last end tag */
1536    XML_PARSER_IGNORE		/* within an IGNORED section */
1537} xmlParserInputState;</PRE
1538></TD
1539></TR
1540></TABLE
1541><P
1542></P
1543></DIV
1544><HR><DIV
1545CLASS="REFSECT2"
1546><A
1547NAME="AEN369"
1548></A
1549><H3
1550><A
1551NAME="XMLPARSERCTXT"
1552></A
1553>struct xmlParserCtxt</H3
1554><TABLE
1555BORDER="0"
1556BGCOLOR="#D6E8FF"
1557WIDTH="100%"
1558CELLPADDING="6"
1559><TR
1560><TD
1561><PRE
1562CLASS="PROGRAMLISTING"
1563>struct xmlParserCtxt {
1564    struct _xmlSAXHandler *sax;       /* The SAX handler */
1565    void            *userData;        /* For SAX interface only, used by DOM build */
1566    xmlDocPtr           myDoc;        /* the document being built */
1567    int            wellFormed;        /* is the document well formed */
1568    int       replaceEntities;        /* shall we replace entities ? */
1569    const xmlChar    *version;        /* the XML version string */
1570    const xmlChar   *encoding;        /* the declared encoding, if any */
1571    int            standalone;        /* standalone document */
1572    int                  html;        /* an HTML(1)/Docbook(2) document */
1573
1574    /* Input stream stack */
1575    xmlParserInputPtr  input;         /* Current input stream */
1576    int                inputNr;       /* Number of current input streams */
1577    int                inputMax;      /* Max number of input streams */
1578    xmlParserInputPtr *inputTab;      /* stack of inputs */
1579
1580    /* Node analysis stack only used for DOM building */
1581    xmlNodePtr         node;          /* Current parsed Node */
1582    int                nodeNr;        /* Depth of the parsing stack */
1583    int                nodeMax;       /* Max depth of the parsing stack */
1584    xmlNodePtr        *nodeTab;       /* array of nodes */
1585
1586    int record_info;                  /* Whether node info should be kept */
1587    xmlParserNodeInfoSeq node_seq;    /* info about each node parsed */
1588
1589    int errNo;                        /* error code */
1590
1591    int     hasExternalSubset;        /* reference and external subset */
1592    int             hasPErefs;        /* the internal subset has PE refs */
1593    int              external;        /* are we parsing an external entity */
1594
1595    int                 valid;        /* is the document valid */
1596    int              validate;        /* shall we try to validate ? */
1597    xmlValidCtxt        vctxt;        /* The validity context */
1598
1599    xmlParserInputState instate;      /* current type of input */
1600    int                 token;        /* next char look-ahead */    
1601
1602    char           *directory;        /* the data directory */
1603
1604    /* Node name stack */
1605    xmlChar           *name;          /* Current parsed Node */
1606    int                nameNr;        /* Depth of the parsing stack */
1607    int                nameMax;       /* Max depth of the parsing stack */
1608    xmlChar *         *nameTab;       /* array of nodes */
1609
1610    long               nbChars;       /* number of xmlChar processed */
1611    long            checkIndex;       /* used by progressive parsing lookup */
1612    int             keepBlanks;       /* ugly but ... */
1613    int             disableSAX;       /* SAX callbacks are disabled */
1614    int               inSubset;       /* Parsing is in int 1/ext 2 subset */
1615    xmlChar *          intSubName;    /* name of subset */
1616    xmlChar *          extSubURI;     /* URI of external subset */
1617    xmlChar *          extSubSystem;  /* SYSTEM ID of external subset */
1618
1619    /* xml:space values */
1620    int *              space;         /* Should the parser preserve spaces */
1621    int                spaceNr;       /* Depth of the parsing stack */
1622    int                spaceMax;      /* Max depth of the parsing stack */
1623    int *              spaceTab;      /* array of space infos */
1624
1625    int                depth;         /* to prevent entity substitution loops */
1626    xmlParserInputPtr  entity;        /* used to check entities boundaries */
1627    int                charset;       /* encoding of the in-memory content
1628				         actually an xmlCharEncoding */
1629    int                nodelen;       /* Those two fields are there to */
1630    int                nodemem;       /* Speed up large node parsing */
1631    int                pedantic;      /* signal pedantic warnings */
1632    void              *_private;      /* For user data, libxml won't touch it */
1633};</PRE
1634></TD
1635></TR
1636></TABLE
1637><P
1638></P
1639></DIV
1640><HR><DIV
1641CLASS="REFSECT2"
1642><A
1643NAME="AEN374"
1644></A
1645><H3
1646><A
1647NAME="XMLPARSERCTXTPTR"
1648></A
1649>xmlParserCtxtPtr</H3
1650><TABLE
1651BORDER="0"
1652BGCOLOR="#D6E8FF"
1653WIDTH="100%"
1654CELLPADDING="6"
1655><TR
1656><TD
1657><PRE
1658CLASS="PROGRAMLISTING"
1659>typedef xmlParserCtxt *xmlParserCtxtPtr;</PRE
1660></TD
1661></TR
1662></TABLE
1663><P
1664></P
1665></DIV
1666><HR><DIV
1667CLASS="REFSECT2"
1668><A
1669NAME="AEN379"
1670></A
1671><H3
1672><A
1673NAME="XMLSAXLOCATOR"
1674></A
1675>struct xmlSAXLocator</H3
1676><TABLE
1677BORDER="0"
1678BGCOLOR="#D6E8FF"
1679WIDTH="100%"
1680CELLPADDING="6"
1681><TR
1682><TD
1683><PRE
1684CLASS="PROGRAMLISTING"
1685>struct xmlSAXLocator {
1686    const xmlChar *(*getPublicId)(void *ctx);
1687    const xmlChar *(*getSystemId)(void *ctx);
1688    int (*getLineNumber)(void *ctx);
1689    int (*getColumnNumber)(void *ctx);
1690};</PRE
1691></TD
1692></TR
1693></TABLE
1694><P
1695></P
1696></DIV
1697><HR><DIV
1698CLASS="REFSECT2"
1699><A
1700NAME="AEN384"
1701></A
1702><H3
1703><A
1704NAME="XMLSAXLOCATORPTR"
1705></A
1706>xmlSAXLocatorPtr</H3
1707><TABLE
1708BORDER="0"
1709BGCOLOR="#D6E8FF"
1710WIDTH="100%"
1711CELLPADDING="6"
1712><TR
1713><TD
1714><PRE
1715CLASS="PROGRAMLISTING"
1716>typedef xmlSAXLocator *xmlSAXLocatorPtr;</PRE
1717></TD
1718></TR
1719></TABLE
1720><P
1721></P
1722></DIV
1723><HR><DIV
1724CLASS="REFSECT2"
1725><A
1726NAME="AEN389"
1727></A
1728><H3
1729><A
1730NAME="RESOLVEENTITYSAXFUNC"
1731></A
1732>resolveEntitySAXFunc ()</H3
1733><TABLE
1734BORDER="0"
1735BGCOLOR="#D6E8FF"
1736WIDTH="100%"
1737CELLPADDING="6"
1738><TR
1739><TD
1740><PRE
1741CLASS="PROGRAMLISTING"
1742><A
1743HREF="libxml-parser.html#XMLPARSERINPUTPTR"
1744>xmlParserInputPtr</A
1745> (*resolveEntitySAXFunc)   (void *ctx,
1746                                             const <A
1747HREF="libxml-tree.html#XMLCHAR"
1748>xmlChar</A
1749> *publicId,
1750                                             const <A
1751HREF="libxml-tree.html#XMLCHAR"
1752>xmlChar</A
1753> *systemId);</PRE
1754></TD
1755></TR
1756></TABLE
1757><P
1758></P
1759><DIV
1760CLASS="INFORMALTABLE"
1761><P
1762></P
1763><TABLE
1764BORDER="0"
1765WIDTH="100%"
1766BGCOLOR="#FFD0D0"
1767CELLSPACING="0"
1768CELLPADDING="4"
1769CLASS="CALSTABLE"
1770><TR
1771><TD
1772WIDTH="20%"
1773ALIGN="RIGHT"
1774VALIGN="TOP"
1775><TT
1776CLASS="PARAMETER"
1777><I
1778>ctx</I
1779></TT
1780>&nbsp;:</TD
1781><TD
1782WIDTH="80%"
1783ALIGN="LEFT"
1784VALIGN="TOP"
1785>&nbsp;</TD
1786></TR
1787><TR
1788><TD
1789WIDTH="20%"
1790ALIGN="RIGHT"
1791VALIGN="TOP"
1792><TT
1793CLASS="PARAMETER"
1794><I
1795>publicId</I
1796></TT
1797>&nbsp;:</TD
1798><TD
1799WIDTH="80%"
1800ALIGN="LEFT"
1801VALIGN="TOP"
1802>&nbsp;</TD
1803></TR
1804><TR
1805><TD
1806WIDTH="20%"
1807ALIGN="RIGHT"
1808VALIGN="TOP"
1809><TT
1810CLASS="PARAMETER"
1811><I
1812>systemId</I
1813></TT
1814>&nbsp;:</TD
1815><TD
1816WIDTH="80%"
1817ALIGN="LEFT"
1818VALIGN="TOP"
1819>&nbsp;</TD
1820></TR
1821><TR
1822><TD
1823WIDTH="20%"
1824ALIGN="RIGHT"
1825VALIGN="TOP"
1826><I
1827CLASS="EMPHASIS"
1828>Returns</I
1829> :</TD
1830><TD
1831WIDTH="80%"
1832ALIGN="LEFT"
1833VALIGN="TOP"
1834>&#13;</TD
1835></TR
1836></TABLE
1837><P
1838></P
1839></DIV
1840></DIV
1841><HR><DIV
1842CLASS="REFSECT2"
1843><A
1844NAME="AEN418"
1845></A
1846><H3
1847><A
1848NAME="INTERNALSUBSETSAXFUNC"
1849></A
1850>internalSubsetSAXFunc ()</H3
1851><TABLE
1852BORDER="0"
1853BGCOLOR="#D6E8FF"
1854WIDTH="100%"
1855CELLPADDING="6"
1856><TR
1857><TD
1858><PRE
1859CLASS="PROGRAMLISTING"
1860>void        (*internalSubsetSAXFunc)        (void *ctx,
1861                                             const <A
1862HREF="libxml-tree.html#XMLCHAR"
1863>xmlChar</A
1864> *name,
1865                                             const <A
1866HREF="libxml-tree.html#XMLCHAR"
1867>xmlChar</A
1868> *ExternalID,
1869                                             const <A
1870HREF="libxml-tree.html#XMLCHAR"
1871>xmlChar</A
1872> *SystemID);</PRE
1873></TD
1874></TR
1875></TABLE
1876><P
1877></P
1878><DIV
1879CLASS="INFORMALTABLE"
1880><P
1881></P
1882><TABLE
1883BORDER="0"
1884WIDTH="100%"
1885BGCOLOR="#FFD0D0"
1886CELLSPACING="0"
1887CELLPADDING="4"
1888CLASS="CALSTABLE"
1889><TR
1890><TD
1891WIDTH="20%"
1892ALIGN="RIGHT"
1893VALIGN="TOP"
1894><TT
1895CLASS="PARAMETER"
1896><I
1897>ctx</I
1898></TT
1899>&nbsp;:</TD
1900><TD
1901WIDTH="80%"
1902ALIGN="LEFT"
1903VALIGN="TOP"
1904>&nbsp;</TD
1905></TR
1906><TR
1907><TD
1908WIDTH="20%"
1909ALIGN="RIGHT"
1910VALIGN="TOP"
1911><TT
1912CLASS="PARAMETER"
1913><I
1914>name</I
1915></TT
1916>&nbsp;:</TD
1917><TD
1918WIDTH="80%"
1919ALIGN="LEFT"
1920VALIGN="TOP"
1921>&nbsp;</TD
1922></TR
1923><TR
1924><TD
1925WIDTH="20%"
1926ALIGN="RIGHT"
1927VALIGN="TOP"
1928><TT
1929CLASS="PARAMETER"
1930><I
1931>ExternalID</I
1932></TT
1933>&nbsp;:</TD
1934><TD
1935WIDTH="80%"
1936ALIGN="LEFT"
1937VALIGN="TOP"
1938>&nbsp;</TD
1939></TR
1940><TR
1941><TD
1942WIDTH="20%"
1943ALIGN="RIGHT"
1944VALIGN="TOP"
1945><TT
1946CLASS="PARAMETER"
1947><I
1948>SystemID</I
1949></TT
1950>&nbsp;:</TD
1951><TD
1952WIDTH="80%"
1953ALIGN="LEFT"
1954VALIGN="TOP"
1955>&#13;</TD
1956></TR
1957></TABLE
1958><P
1959></P
1960></DIV
1961></DIV
1962><HR><DIV
1963CLASS="REFSECT2"
1964><A
1965NAME="AEN447"
1966></A
1967><H3
1968><A
1969NAME="EXTERNALSUBSETSAXFUNC"
1970></A
1971>externalSubsetSAXFunc ()</H3
1972><TABLE
1973BORDER="0"
1974BGCOLOR="#D6E8FF"
1975WIDTH="100%"
1976CELLPADDING="6"
1977><TR
1978><TD
1979><PRE
1980CLASS="PROGRAMLISTING"
1981>void        (*externalSubsetSAXFunc)        (void *ctx,
1982                                             const <A
1983HREF="libxml-tree.html#XMLCHAR"
1984>xmlChar</A
1985> *name,
1986                                             const <A
1987HREF="libxml-tree.html#XMLCHAR"
1988>xmlChar</A
1989> *ExternalID,
1990                                             const <A
1991HREF="libxml-tree.html#XMLCHAR"
1992>xmlChar</A
1993> *SystemID);</PRE
1994></TD
1995></TR
1996></TABLE
1997><P
1998></P
1999><DIV
2000CLASS="INFORMALTABLE"
2001><P
2002></P
2003><TABLE
2004BORDER="0"
2005WIDTH="100%"
2006BGCOLOR="#FFD0D0"
2007CELLSPACING="0"
2008CELLPADDING="4"
2009CLASS="CALSTABLE"
2010><TR
2011><TD
2012WIDTH="20%"
2013ALIGN="RIGHT"
2014VALIGN="TOP"
2015><TT
2016CLASS="PARAMETER"
2017><I
2018>ctx</I
2019></TT
2020>&nbsp;:</TD
2021><TD
2022WIDTH="80%"
2023ALIGN="LEFT"
2024VALIGN="TOP"
2025>&nbsp;</TD
2026></TR
2027><TR
2028><TD
2029WIDTH="20%"
2030ALIGN="RIGHT"
2031VALIGN="TOP"
2032><TT
2033CLASS="PARAMETER"
2034><I
2035>name</I
2036></TT
2037>&nbsp;:</TD
2038><TD
2039WIDTH="80%"
2040ALIGN="LEFT"
2041VALIGN="TOP"
2042>&nbsp;</TD
2043></TR
2044><TR
2045><TD
2046WIDTH="20%"
2047ALIGN="RIGHT"
2048VALIGN="TOP"
2049><TT
2050CLASS="PARAMETER"
2051><I
2052>ExternalID</I
2053></TT
2054>&nbsp;:</TD
2055><TD
2056WIDTH="80%"
2057ALIGN="LEFT"
2058VALIGN="TOP"
2059>&nbsp;</TD
2060></TR
2061><TR
2062><TD
2063WIDTH="20%"
2064ALIGN="RIGHT"
2065VALIGN="TOP"
2066><TT
2067CLASS="PARAMETER"
2068><I
2069>SystemID</I
2070></TT
2071>&nbsp;:</TD
2072><TD
2073WIDTH="80%"
2074ALIGN="LEFT"
2075VALIGN="TOP"
2076>&#13;</TD
2077></TR
2078></TABLE
2079><P
2080></P
2081></DIV
2082></DIV
2083><HR><DIV
2084CLASS="REFSECT2"
2085><A
2086NAME="AEN476"
2087></A
2088><H3
2089><A
2090NAME="GETENTITYSAXFUNC"
2091></A
2092>getEntitySAXFunc ()</H3
2093><TABLE
2094BORDER="0"
2095BGCOLOR="#D6E8FF"
2096WIDTH="100%"
2097CELLPADDING="6"
2098><TR
2099><TD
2100><PRE
2101CLASS="PROGRAMLISTING"
2102><A
2103HREF="libxml-entities.html#XMLENTITYPTR"
2104>xmlEntityPtr</A
2105> (*getEntitySAXFunc)            (void *ctx,
2106                                             const <A
2107HREF="libxml-tree.html#XMLCHAR"
2108>xmlChar</A
2109> *name);</PRE
2110></TD
2111></TR
2112></TABLE
2113><P
2114></P
2115><DIV
2116CLASS="INFORMALTABLE"
2117><P
2118></P
2119><TABLE
2120BORDER="0"
2121WIDTH="100%"
2122BGCOLOR="#FFD0D0"
2123CELLSPACING="0"
2124CELLPADDING="4"
2125CLASS="CALSTABLE"
2126><TR
2127><TD
2128WIDTH="20%"
2129ALIGN="RIGHT"
2130VALIGN="TOP"
2131><TT
2132CLASS="PARAMETER"
2133><I
2134>ctx</I
2135></TT
2136>&nbsp;:</TD
2137><TD
2138WIDTH="80%"
2139ALIGN="LEFT"
2140VALIGN="TOP"
2141>&nbsp;</TD
2142></TR
2143><TR
2144><TD
2145WIDTH="20%"
2146ALIGN="RIGHT"
2147VALIGN="TOP"
2148><TT
2149CLASS="PARAMETER"
2150><I
2151>name</I
2152></TT
2153>&nbsp;:</TD
2154><TD
2155WIDTH="80%"
2156ALIGN="LEFT"
2157VALIGN="TOP"
2158>&nbsp;</TD
2159></TR
2160><TR
2161><TD
2162WIDTH="20%"
2163ALIGN="RIGHT"
2164VALIGN="TOP"
2165><I
2166CLASS="EMPHASIS"
2167>Returns</I
2168> :</TD
2169><TD
2170WIDTH="80%"
2171ALIGN="LEFT"
2172VALIGN="TOP"
2173>&#13;</TD
2174></TR
2175></TABLE
2176><P
2177></P
2178></DIV
2179></DIV
2180><HR><DIV
2181CLASS="REFSECT2"
2182><A
2183NAME="AEN500"
2184></A
2185><H3
2186><A
2187NAME="GETPARAMETERENTITYSAXFUNC"
2188></A
2189>getParameterEntitySAXFunc ()</H3
2190><TABLE
2191BORDER="0"
2192BGCOLOR="#D6E8FF"
2193WIDTH="100%"
2194CELLPADDING="6"
2195><TR
2196><TD
2197><PRE
2198CLASS="PROGRAMLISTING"
2199><A
2200HREF="libxml-entities.html#XMLENTITYPTR"
2201>xmlEntityPtr</A
2202> (*getParameterEntitySAXFunc)   (void *ctx,
2203                                             const <A
2204HREF="libxml-tree.html#XMLCHAR"
2205>xmlChar</A
2206> *name);</PRE
2207></TD
2208></TR
2209></TABLE
2210><P
2211></P
2212><DIV
2213CLASS="INFORMALTABLE"
2214><P
2215></P
2216><TABLE
2217BORDER="0"
2218WIDTH="100%"
2219BGCOLOR="#FFD0D0"
2220CELLSPACING="0"
2221CELLPADDING="4"
2222CLASS="CALSTABLE"
2223><TR
2224><TD
2225WIDTH="20%"
2226ALIGN="RIGHT"
2227VALIGN="TOP"
2228><TT
2229CLASS="PARAMETER"
2230><I
2231>ctx</I
2232></TT
2233>&nbsp;:</TD
2234><TD
2235WIDTH="80%"
2236ALIGN="LEFT"
2237VALIGN="TOP"
2238>&nbsp;</TD
2239></TR
2240><TR
2241><TD
2242WIDTH="20%"
2243ALIGN="RIGHT"
2244VALIGN="TOP"
2245><TT
2246CLASS="PARAMETER"
2247><I
2248>name</I
2249></TT
2250>&nbsp;:</TD
2251><TD
2252WIDTH="80%"
2253ALIGN="LEFT"
2254VALIGN="TOP"
2255>&nbsp;</TD
2256></TR
2257><TR
2258><TD
2259WIDTH="20%"
2260ALIGN="RIGHT"
2261VALIGN="TOP"
2262><I
2263CLASS="EMPHASIS"
2264>Returns</I
2265> :</TD
2266><TD
2267WIDTH="80%"
2268ALIGN="LEFT"
2269VALIGN="TOP"
2270>&#13;</TD
2271></TR
2272></TABLE
2273><P
2274></P
2275></DIV
2276></DIV
2277><HR><DIV
2278CLASS="REFSECT2"
2279><A
2280NAME="AEN524"
2281></A
2282><H3
2283><A
2284NAME="ENTITYDECLSAXFUNC"
2285></A
2286>entityDeclSAXFunc ()</H3
2287><TABLE
2288BORDER="0"
2289BGCOLOR="#D6E8FF"
2290WIDTH="100%"
2291CELLPADDING="6"
2292><TR
2293><TD
2294><PRE
2295CLASS="PROGRAMLISTING"
2296>void        (*entityDeclSAXFunc)            (void *ctx,
2297                                             const <A
2298HREF="libxml-tree.html#XMLCHAR"
2299>xmlChar</A
2300> *name,
2301                                             int type,
2302                                             const <A
2303HREF="libxml-tree.html#XMLCHAR"
2304>xmlChar</A
2305> *publicId,
2306                                             const <A
2307HREF="libxml-tree.html#XMLCHAR"
2308>xmlChar</A
2309> *systemId,
2310                                             <A
2311HREF="libxml-tree.html#XMLCHAR"
2312>xmlChar</A
2313> *content);</PRE
2314></TD
2315></TR
2316></TABLE
2317><P
2318></P
2319><DIV
2320CLASS="INFORMALTABLE"
2321><P
2322></P
2323><TABLE
2324BORDER="0"
2325WIDTH="100%"
2326BGCOLOR="#FFD0D0"
2327CELLSPACING="0"
2328CELLPADDING="4"
2329CLASS="CALSTABLE"
2330><TR
2331><TD
2332WIDTH="20%"
2333ALIGN="RIGHT"
2334VALIGN="TOP"
2335><TT
2336CLASS="PARAMETER"
2337><I
2338>ctx</I
2339></TT
2340>&nbsp;:</TD
2341><TD
2342WIDTH="80%"
2343ALIGN="LEFT"
2344VALIGN="TOP"
2345>&nbsp;</TD
2346></TR
2347><TR
2348><TD
2349WIDTH="20%"
2350ALIGN="RIGHT"
2351VALIGN="TOP"
2352><TT
2353CLASS="PARAMETER"
2354><I
2355>name</I
2356></TT
2357>&nbsp;:</TD
2358><TD
2359WIDTH="80%"
2360ALIGN="LEFT"
2361VALIGN="TOP"
2362>&nbsp;</TD
2363></TR
2364><TR
2365><TD
2366WIDTH="20%"
2367ALIGN="RIGHT"
2368VALIGN="TOP"
2369><TT
2370CLASS="PARAMETER"
2371><I
2372>type</I
2373></TT
2374>&nbsp;:</TD
2375><TD
2376WIDTH="80%"
2377ALIGN="LEFT"
2378VALIGN="TOP"
2379>&nbsp;</TD
2380></TR
2381><TR
2382><TD
2383WIDTH="20%"
2384ALIGN="RIGHT"
2385VALIGN="TOP"
2386><TT
2387CLASS="PARAMETER"
2388><I
2389>publicId</I
2390></TT
2391>&nbsp;:</TD
2392><TD
2393WIDTH="80%"
2394ALIGN="LEFT"
2395VALIGN="TOP"
2396>&nbsp;</TD
2397></TR
2398><TR
2399><TD
2400WIDTH="20%"
2401ALIGN="RIGHT"
2402VALIGN="TOP"
2403><TT
2404CLASS="PARAMETER"
2405><I
2406>systemId</I
2407></TT
2408>&nbsp;:</TD
2409><TD
2410WIDTH="80%"
2411ALIGN="LEFT"
2412VALIGN="TOP"
2413>&nbsp;</TD
2414></TR
2415><TR
2416><TD
2417WIDTH="20%"
2418ALIGN="RIGHT"
2419VALIGN="TOP"
2420><TT
2421CLASS="PARAMETER"
2422><I
2423>content</I
2424></TT
2425>&nbsp;:</TD
2426><TD
2427WIDTH="80%"
2428ALIGN="LEFT"
2429VALIGN="TOP"
2430>&#13;</TD
2431></TR
2432></TABLE
2433><P
2434></P
2435></DIV
2436></DIV
2437><HR><DIV
2438CLASS="REFSECT2"
2439><A
2440NAME="AEN562"
2441></A
2442><H3
2443><A
2444NAME="NOTATIONDECLSAXFUNC"
2445></A
2446>notationDeclSAXFunc ()</H3
2447><TABLE
2448BORDER="0"
2449BGCOLOR="#D6E8FF"
2450WIDTH="100%"
2451CELLPADDING="6"
2452><TR
2453><TD
2454><PRE
2455CLASS="PROGRAMLISTING"
2456>void        (*notationDeclSAXFunc)          (void *ctx,
2457                                             const <A
2458HREF="libxml-tree.html#XMLCHAR"
2459>xmlChar</A
2460> *name,
2461                                             const <A
2462HREF="libxml-tree.html#XMLCHAR"
2463>xmlChar</A
2464> *publicId,
2465                                             const <A
2466HREF="libxml-tree.html#XMLCHAR"
2467>xmlChar</A
2468> *systemId);</PRE
2469></TD
2470></TR
2471></TABLE
2472><P
2473></P
2474><DIV
2475CLASS="INFORMALTABLE"
2476><P
2477></P
2478><TABLE
2479BORDER="0"
2480WIDTH="100%"
2481BGCOLOR="#FFD0D0"
2482CELLSPACING="0"
2483CELLPADDING="4"
2484CLASS="CALSTABLE"
2485><TR
2486><TD
2487WIDTH="20%"
2488ALIGN="RIGHT"
2489VALIGN="TOP"
2490><TT
2491CLASS="PARAMETER"
2492><I
2493>ctx</I
2494></TT
2495>&nbsp;:</TD
2496><TD
2497WIDTH="80%"
2498ALIGN="LEFT"
2499VALIGN="TOP"
2500>&nbsp;</TD
2501></TR
2502><TR
2503><TD
2504WIDTH="20%"
2505ALIGN="RIGHT"
2506VALIGN="TOP"
2507><TT
2508CLASS="PARAMETER"
2509><I
2510>name</I
2511></TT
2512>&nbsp;:</TD
2513><TD
2514WIDTH="80%"
2515ALIGN="LEFT"
2516VALIGN="TOP"
2517>&nbsp;</TD
2518></TR
2519><TR
2520><TD
2521WIDTH="20%"
2522ALIGN="RIGHT"
2523VALIGN="TOP"
2524><TT
2525CLASS="PARAMETER"
2526><I
2527>publicId</I
2528></TT
2529>&nbsp;:</TD
2530><TD
2531WIDTH="80%"
2532ALIGN="LEFT"
2533VALIGN="TOP"
2534>&nbsp;</TD
2535></TR
2536><TR
2537><TD
2538WIDTH="20%"
2539ALIGN="RIGHT"
2540VALIGN="TOP"
2541><TT
2542CLASS="PARAMETER"
2543><I
2544>systemId</I
2545></TT
2546>&nbsp;:</TD
2547><TD
2548WIDTH="80%"
2549ALIGN="LEFT"
2550VALIGN="TOP"
2551>&#13;</TD
2552></TR
2553></TABLE
2554><P
2555></P
2556></DIV
2557></DIV
2558><HR><DIV
2559CLASS="REFSECT2"
2560><A
2561NAME="AEN591"
2562></A
2563><H3
2564><A
2565NAME="ATTRIBUTEDECLSAXFUNC"
2566></A
2567>attributeDeclSAXFunc ()</H3
2568><TABLE
2569BORDER="0"
2570BGCOLOR="#D6E8FF"
2571WIDTH="100%"
2572CELLPADDING="6"
2573><TR
2574><TD
2575><PRE
2576CLASS="PROGRAMLISTING"
2577>void        (*attributeDeclSAXFunc)         (void *ctx,
2578                                             const <A
2579HREF="libxml-tree.html#XMLCHAR"
2580>xmlChar</A
2581> *elem,
2582                                             const <A
2583HREF="libxml-tree.html#XMLCHAR"
2584>xmlChar</A
2585> *name,
2586                                             int type,
2587                                             int def,
2588                                             const <A
2589HREF="libxml-tree.html#XMLCHAR"
2590>xmlChar</A
2591> *defaultValue,
2592                                             <A
2593HREF="libxml-tree.html#XMLENUMERATIONPTR"
2594>xmlEnumerationPtr</A
2595> tree);</PRE
2596></TD
2597></TR
2598></TABLE
2599><P
2600></P
2601><DIV
2602CLASS="INFORMALTABLE"
2603><P
2604></P
2605><TABLE
2606BORDER="0"
2607WIDTH="100%"
2608BGCOLOR="#FFD0D0"
2609CELLSPACING="0"
2610CELLPADDING="4"
2611CLASS="CALSTABLE"
2612><TR
2613><TD
2614WIDTH="20%"
2615ALIGN="RIGHT"
2616VALIGN="TOP"
2617><TT
2618CLASS="PARAMETER"
2619><I
2620>ctx</I
2621></TT
2622>&nbsp;:</TD
2623><TD
2624WIDTH="80%"
2625ALIGN="LEFT"
2626VALIGN="TOP"
2627>&nbsp;</TD
2628></TR
2629><TR
2630><TD
2631WIDTH="20%"
2632ALIGN="RIGHT"
2633VALIGN="TOP"
2634><TT
2635CLASS="PARAMETER"
2636><I
2637>elem</I
2638></TT
2639>&nbsp;:</TD
2640><TD
2641WIDTH="80%"
2642ALIGN="LEFT"
2643VALIGN="TOP"
2644>&nbsp;</TD
2645></TR
2646><TR
2647><TD
2648WIDTH="20%"
2649ALIGN="RIGHT"
2650VALIGN="TOP"
2651><TT
2652CLASS="PARAMETER"
2653><I
2654>name</I
2655></TT
2656>&nbsp;:</TD
2657><TD
2658WIDTH="80%"
2659ALIGN="LEFT"
2660VALIGN="TOP"
2661>&nbsp;</TD
2662></TR
2663><TR
2664><TD
2665WIDTH="20%"
2666ALIGN="RIGHT"
2667VALIGN="TOP"
2668><TT
2669CLASS="PARAMETER"
2670><I
2671>type</I
2672></TT
2673>&nbsp;:</TD
2674><TD
2675WIDTH="80%"
2676ALIGN="LEFT"
2677VALIGN="TOP"
2678>&nbsp;</TD
2679></TR
2680><TR
2681><TD
2682WIDTH="20%"
2683ALIGN="RIGHT"
2684VALIGN="TOP"
2685><TT
2686CLASS="PARAMETER"
2687><I
2688>def</I
2689></TT
2690>&nbsp;:</TD
2691><TD
2692WIDTH="80%"
2693ALIGN="LEFT"
2694VALIGN="TOP"
2695>&nbsp;</TD
2696></TR
2697><TR
2698><TD
2699WIDTH="20%"
2700ALIGN="RIGHT"
2701VALIGN="TOP"
2702><TT
2703CLASS="PARAMETER"
2704><I
2705>defaultValue</I
2706></TT
2707>&nbsp;:</TD
2708><TD
2709WIDTH="80%"
2710ALIGN="LEFT"
2711VALIGN="TOP"
2712>&nbsp;</TD
2713></TR
2714><TR
2715><TD
2716WIDTH="20%"
2717ALIGN="RIGHT"
2718VALIGN="TOP"
2719><TT
2720CLASS="PARAMETER"
2721><I
2722>tree</I
2723></TT
2724>&nbsp;:</TD
2725><TD
2726WIDTH="80%"
2727ALIGN="LEFT"
2728VALIGN="TOP"
2729>&#13;</TD
2730></TR
2731></TABLE
2732><P
2733></P
2734></DIV
2735></DIV
2736><HR><DIV
2737CLASS="REFSECT2"
2738><A
2739NAME="AEN633"
2740></A
2741><H3
2742><A
2743NAME="ELEMENTDECLSAXFUNC"
2744></A
2745>elementDeclSAXFunc ()</H3
2746><TABLE
2747BORDER="0"
2748BGCOLOR="#D6E8FF"
2749WIDTH="100%"
2750CELLPADDING="6"
2751><TR
2752><TD
2753><PRE
2754CLASS="PROGRAMLISTING"
2755>void        (*elementDeclSAXFunc)           (void *ctx,
2756                                             const <A
2757HREF="libxml-tree.html#XMLCHAR"
2758>xmlChar</A
2759> *name,
2760                                             int type,
2761                                             <A
2762HREF="libxml-tree.html#XMLELEMENTCONTENTPTR"
2763>xmlElementContentPtr</A
2764> content);</PRE
2765></TD
2766></TR
2767></TABLE
2768><P
2769></P
2770><DIV
2771CLASS="INFORMALTABLE"
2772><P
2773></P
2774><TABLE
2775BORDER="0"
2776WIDTH="100%"
2777BGCOLOR="#FFD0D0"
2778CELLSPACING="0"
2779CELLPADDING="4"
2780CLASS="CALSTABLE"
2781><TR
2782><TD
2783WIDTH="20%"
2784ALIGN="RIGHT"
2785VALIGN="TOP"
2786><TT
2787CLASS="PARAMETER"
2788><I
2789>ctx</I
2790></TT
2791>&nbsp;:</TD
2792><TD
2793WIDTH="80%"
2794ALIGN="LEFT"
2795VALIGN="TOP"
2796>&nbsp;</TD
2797></TR
2798><TR
2799><TD
2800WIDTH="20%"
2801ALIGN="RIGHT"
2802VALIGN="TOP"
2803><TT
2804CLASS="PARAMETER"
2805><I
2806>name</I
2807></TT
2808>&nbsp;:</TD
2809><TD
2810WIDTH="80%"
2811ALIGN="LEFT"
2812VALIGN="TOP"
2813>&nbsp;</TD
2814></TR
2815><TR
2816><TD
2817WIDTH="20%"
2818ALIGN="RIGHT"
2819VALIGN="TOP"
2820><TT
2821CLASS="PARAMETER"
2822><I
2823>type</I
2824></TT
2825>&nbsp;:</TD
2826><TD
2827WIDTH="80%"
2828ALIGN="LEFT"
2829VALIGN="TOP"
2830>&nbsp;</TD
2831></TR
2832><TR
2833><TD
2834WIDTH="20%"
2835ALIGN="RIGHT"
2836VALIGN="TOP"
2837><TT
2838CLASS="PARAMETER"
2839><I
2840>content</I
2841></TT
2842>&nbsp;:</TD
2843><TD
2844WIDTH="80%"
2845ALIGN="LEFT"
2846VALIGN="TOP"
2847>&#13;</TD
2848></TR
2849></TABLE
2850><P
2851></P
2852></DIV
2853></DIV
2854><HR><DIV
2855CLASS="REFSECT2"
2856><A
2857NAME="AEN661"
2858></A
2859><H3
2860><A
2861NAME="UNPARSEDENTITYDECLSAXFUNC"
2862></A
2863>unparsedEntityDeclSAXFunc ()</H3
2864><TABLE
2865BORDER="0"
2866BGCOLOR="#D6E8FF"
2867WIDTH="100%"
2868CELLPADDING="6"
2869><TR
2870><TD
2871><PRE
2872CLASS="PROGRAMLISTING"
2873>void        (*unparsedEntityDeclSAXFunc)    (void *ctx,
2874                                             const <A
2875HREF="libxml-tree.html#XMLCHAR"
2876>xmlChar</A
2877> *name,
2878                                             const <A
2879HREF="libxml-tree.html#XMLCHAR"
2880>xmlChar</A
2881> *publicId,
2882                                             const <A
2883HREF="libxml-tree.html#XMLCHAR"
2884>xmlChar</A
2885> *systemId,
2886                                             const <A
2887HREF="libxml-tree.html#XMLCHAR"
2888>xmlChar</A
2889> *notationName);</PRE
2890></TD
2891></TR
2892></TABLE
2893><P
2894></P
2895><DIV
2896CLASS="INFORMALTABLE"
2897><P
2898></P
2899><TABLE
2900BORDER="0"
2901WIDTH="100%"
2902BGCOLOR="#FFD0D0"
2903CELLSPACING="0"
2904CELLPADDING="4"
2905CLASS="CALSTABLE"
2906><TR
2907><TD
2908WIDTH="20%"
2909ALIGN="RIGHT"
2910VALIGN="TOP"
2911><TT
2912CLASS="PARAMETER"
2913><I
2914>ctx</I
2915></TT
2916>&nbsp;:</TD
2917><TD
2918WIDTH="80%"
2919ALIGN="LEFT"
2920VALIGN="TOP"
2921>&nbsp;</TD
2922></TR
2923><TR
2924><TD
2925WIDTH="20%"
2926ALIGN="RIGHT"
2927VALIGN="TOP"
2928><TT
2929CLASS="PARAMETER"
2930><I
2931>name</I
2932></TT
2933>&nbsp;:</TD
2934><TD
2935WIDTH="80%"
2936ALIGN="LEFT"
2937VALIGN="TOP"
2938>&nbsp;</TD
2939></TR
2940><TR
2941><TD
2942WIDTH="20%"
2943ALIGN="RIGHT"
2944VALIGN="TOP"
2945><TT
2946CLASS="PARAMETER"
2947><I
2948>publicId</I
2949></TT
2950>&nbsp;:</TD
2951><TD
2952WIDTH="80%"
2953ALIGN="LEFT"
2954VALIGN="TOP"
2955>&nbsp;</TD
2956></TR
2957><TR
2958><TD
2959WIDTH="20%"
2960ALIGN="RIGHT"
2961VALIGN="TOP"
2962><TT
2963CLASS="PARAMETER"
2964><I
2965>systemId</I
2966></TT
2967>&nbsp;:</TD
2968><TD
2969WIDTH="80%"
2970ALIGN="LEFT"
2971VALIGN="TOP"
2972>&nbsp;</TD
2973></TR
2974><TR
2975><TD
2976WIDTH="20%"
2977ALIGN="RIGHT"
2978VALIGN="TOP"
2979><TT
2980CLASS="PARAMETER"
2981><I
2982>notationName</I
2983></TT
2984>&nbsp;:</TD
2985><TD
2986WIDTH="80%"
2987ALIGN="LEFT"
2988VALIGN="TOP"
2989>&#13;</TD
2990></TR
2991></TABLE
2992><P
2993></P
2994></DIV
2995></DIV
2996><HR><DIV
2997CLASS="REFSECT2"
2998><A
2999NAME="AEN695"
3000></A
3001><H3
3002><A
3003NAME="SETDOCUMENTLOCATORSAXFUNC"
3004></A
3005>setDocumentLocatorSAXFunc ()</H3
3006><TABLE
3007BORDER="0"
3008BGCOLOR="#D6E8FF"
3009WIDTH="100%"
3010CELLPADDING="6"
3011><TR
3012><TD
3013><PRE
3014CLASS="PROGRAMLISTING"
3015>void        (*setDocumentLocatorSAXFunc)    (void *ctx,
3016                                             <A
3017HREF="libxml-parser.html#XMLSAXLOCATORPTR"
3018>xmlSAXLocatorPtr</A
3019> loc);</PRE
3020></TD
3021></TR
3022></TABLE
3023><P
3024></P
3025><DIV
3026CLASS="INFORMALTABLE"
3027><P
3028></P
3029><TABLE
3030BORDER="0"
3031WIDTH="100%"
3032BGCOLOR="#FFD0D0"
3033CELLSPACING="0"
3034CELLPADDING="4"
3035CLASS="CALSTABLE"
3036><TR
3037><TD
3038WIDTH="20%"
3039ALIGN="RIGHT"
3040VALIGN="TOP"
3041><TT
3042CLASS="PARAMETER"
3043><I
3044>ctx</I
3045></TT
3046>&nbsp;:</TD
3047><TD
3048WIDTH="80%"
3049ALIGN="LEFT"
3050VALIGN="TOP"
3051>&nbsp;</TD
3052></TR
3053><TR
3054><TD
3055WIDTH="20%"
3056ALIGN="RIGHT"
3057VALIGN="TOP"
3058><TT
3059CLASS="PARAMETER"
3060><I
3061>loc</I
3062></TT
3063>&nbsp;:</TD
3064><TD
3065WIDTH="80%"
3066ALIGN="LEFT"
3067VALIGN="TOP"
3068>&#13;</TD
3069></TR
3070></TABLE
3071><P
3072></P
3073></DIV
3074></DIV
3075><HR><DIV
3076CLASS="REFSECT2"
3077><A
3078NAME="AEN714"
3079></A
3080><H3
3081><A
3082NAME="STARTDOCUMENTSAXFUNC"
3083></A
3084>startDocumentSAXFunc ()</H3
3085><TABLE
3086BORDER="0"
3087BGCOLOR="#D6E8FF"
3088WIDTH="100%"
3089CELLPADDING="6"
3090><TR
3091><TD
3092><PRE
3093CLASS="PROGRAMLISTING"
3094>void        (*startDocumentSAXFunc)         (void *ctx);</PRE
3095></TD
3096></TR
3097></TABLE
3098><P
3099></P
3100><DIV
3101CLASS="INFORMALTABLE"
3102><P
3103></P
3104><TABLE
3105BORDER="0"
3106WIDTH="100%"
3107BGCOLOR="#FFD0D0"
3108CELLSPACING="0"
3109CELLPADDING="4"
3110CLASS="CALSTABLE"
3111><TR
3112><TD
3113WIDTH="20%"
3114ALIGN="RIGHT"
3115VALIGN="TOP"
3116><TT
3117CLASS="PARAMETER"
3118><I
3119>ctx</I
3120></TT
3121>&nbsp;:</TD
3122><TD
3123WIDTH="80%"
3124ALIGN="LEFT"
3125VALIGN="TOP"
3126>&#13;</TD
3127></TR
3128></TABLE
3129><P
3130></P
3131></DIV
3132></DIV
3133><HR><DIV
3134CLASS="REFSECT2"
3135><A
3136NAME="AEN728"
3137></A
3138><H3
3139><A
3140NAME="ENDDOCUMENTSAXFUNC"
3141></A
3142>endDocumentSAXFunc ()</H3
3143><TABLE
3144BORDER="0"
3145BGCOLOR="#D6E8FF"
3146WIDTH="100%"
3147CELLPADDING="6"
3148><TR
3149><TD
3150><PRE
3151CLASS="PROGRAMLISTING"
3152>void        (*endDocumentSAXFunc)           (void *ctx);</PRE
3153></TD
3154></TR
3155></TABLE
3156><P
3157></P
3158><DIV
3159CLASS="INFORMALTABLE"
3160><P
3161></P
3162><TABLE
3163BORDER="0"
3164WIDTH="100%"
3165BGCOLOR="#FFD0D0"
3166CELLSPACING="0"
3167CELLPADDING="4"
3168CLASS="CALSTABLE"
3169><TR
3170><TD
3171WIDTH="20%"
3172ALIGN="RIGHT"
3173VALIGN="TOP"
3174><TT
3175CLASS="PARAMETER"
3176><I
3177>ctx</I
3178></TT
3179>&nbsp;:</TD
3180><TD
3181WIDTH="80%"
3182ALIGN="LEFT"
3183VALIGN="TOP"
3184>&#13;</TD
3185></TR
3186></TABLE
3187><P
3188></P
3189></DIV
3190></DIV
3191><HR><DIV
3192CLASS="REFSECT2"
3193><A
3194NAME="AEN742"
3195></A
3196><H3
3197><A
3198NAME="STARTELEMENTSAXFUNC"
3199></A
3200>startElementSAXFunc ()</H3
3201><TABLE
3202BORDER="0"
3203BGCOLOR="#D6E8FF"
3204WIDTH="100%"
3205CELLPADDING="6"
3206><TR
3207><TD
3208><PRE
3209CLASS="PROGRAMLISTING"
3210>void        (*startElementSAXFunc)          (void *ctx,
3211                                             const <A
3212HREF="libxml-tree.html#XMLCHAR"
3213>xmlChar</A
3214> *name,
3215                                             const <A
3216HREF="libxml-tree.html#XMLCHAR"
3217>xmlChar</A
3218> **atts);</PRE
3219></TD
3220></TR
3221></TABLE
3222><P
3223></P
3224><DIV
3225CLASS="INFORMALTABLE"
3226><P
3227></P
3228><TABLE
3229BORDER="0"
3230WIDTH="100%"
3231BGCOLOR="#FFD0D0"
3232CELLSPACING="0"
3233CELLPADDING="4"
3234CLASS="CALSTABLE"
3235><TR
3236><TD
3237WIDTH="20%"
3238ALIGN="RIGHT"
3239VALIGN="TOP"
3240><TT
3241CLASS="PARAMETER"
3242><I
3243>ctx</I
3244></TT
3245>&nbsp;:</TD
3246><TD
3247WIDTH="80%"
3248ALIGN="LEFT"
3249VALIGN="TOP"
3250>&nbsp;</TD
3251></TR
3252><TR
3253><TD
3254WIDTH="20%"
3255ALIGN="RIGHT"
3256VALIGN="TOP"
3257><TT
3258CLASS="PARAMETER"
3259><I
3260>name</I
3261></TT
3262>&nbsp;:</TD
3263><TD
3264WIDTH="80%"
3265ALIGN="LEFT"
3266VALIGN="TOP"
3267>&nbsp;</TD
3268></TR
3269><TR
3270><TD
3271WIDTH="20%"
3272ALIGN="RIGHT"
3273VALIGN="TOP"
3274><TT
3275CLASS="PARAMETER"
3276><I
3277>atts</I
3278></TT
3279>&nbsp;:</TD
3280><TD
3281WIDTH="80%"
3282ALIGN="LEFT"
3283VALIGN="TOP"
3284>&#13;</TD
3285></TR
3286></TABLE
3287><P
3288></P
3289></DIV
3290></DIV
3291><HR><DIV
3292CLASS="REFSECT2"
3293><A
3294NAME="AEN766"
3295></A
3296><H3
3297><A
3298NAME="ENDELEMENTSAXFUNC"
3299></A
3300>endElementSAXFunc ()</H3
3301><TABLE
3302BORDER="0"
3303BGCOLOR="#D6E8FF"
3304WIDTH="100%"
3305CELLPADDING="6"
3306><TR
3307><TD
3308><PRE
3309CLASS="PROGRAMLISTING"
3310>void        (*endElementSAXFunc)            (void *ctx,
3311                                             const <A
3312HREF="libxml-tree.html#XMLCHAR"
3313>xmlChar</A
3314> *name);</PRE
3315></TD
3316></TR
3317></TABLE
3318><P
3319></P
3320><DIV
3321CLASS="INFORMALTABLE"
3322><P
3323></P
3324><TABLE
3325BORDER="0"
3326WIDTH="100%"
3327BGCOLOR="#FFD0D0"
3328CELLSPACING="0"
3329CELLPADDING="4"
3330CLASS="CALSTABLE"
3331><TR
3332><TD
3333WIDTH="20%"
3334ALIGN="RIGHT"
3335VALIGN="TOP"
3336><TT
3337CLASS="PARAMETER"
3338><I
3339>ctx</I
3340></TT
3341>&nbsp;:</TD
3342><TD
3343WIDTH="80%"
3344ALIGN="LEFT"
3345VALIGN="TOP"
3346>&nbsp;</TD
3347></TR
3348><TR
3349><TD
3350WIDTH="20%"
3351ALIGN="RIGHT"
3352VALIGN="TOP"
3353><TT
3354CLASS="PARAMETER"
3355><I
3356>name</I
3357></TT
3358>&nbsp;:</TD
3359><TD
3360WIDTH="80%"
3361ALIGN="LEFT"
3362VALIGN="TOP"
3363>&#13;</TD
3364></TR
3365></TABLE
3366><P
3367></P
3368></DIV
3369></DIV
3370><HR><DIV
3371CLASS="REFSECT2"
3372><A
3373NAME="AEN785"
3374></A
3375><H3
3376><A
3377NAME="ATTRIBUTESAXFUNC"
3378></A
3379>attributeSAXFunc ()</H3
3380><TABLE
3381BORDER="0"
3382BGCOLOR="#D6E8FF"
3383WIDTH="100%"
3384CELLPADDING="6"
3385><TR
3386><TD
3387><PRE
3388CLASS="PROGRAMLISTING"
3389>void        (*attributeSAXFunc)             (void *ctx,
3390                                             const <A
3391HREF="libxml-tree.html#XMLCHAR"
3392>xmlChar</A
3393> *name,
3394                                             const <A
3395HREF="libxml-tree.html#XMLCHAR"
3396>xmlChar</A
3397> *value);</PRE
3398></TD
3399></TR
3400></TABLE
3401><P
3402></P
3403><DIV
3404CLASS="INFORMALTABLE"
3405><P
3406></P
3407><TABLE
3408BORDER="0"
3409WIDTH="100%"
3410BGCOLOR="#FFD0D0"
3411CELLSPACING="0"
3412CELLPADDING="4"
3413CLASS="CALSTABLE"
3414><TR
3415><TD
3416WIDTH="20%"
3417ALIGN="RIGHT"
3418VALIGN="TOP"
3419><TT
3420CLASS="PARAMETER"
3421><I
3422>ctx</I
3423></TT
3424>&nbsp;:</TD
3425><TD
3426WIDTH="80%"
3427ALIGN="LEFT"
3428VALIGN="TOP"
3429>&nbsp;</TD
3430></TR
3431><TR
3432><TD
3433WIDTH="20%"
3434ALIGN="RIGHT"
3435VALIGN="TOP"
3436><TT
3437CLASS="PARAMETER"
3438><I
3439>name</I
3440></TT
3441>&nbsp;:</TD
3442><TD
3443WIDTH="80%"
3444ALIGN="LEFT"
3445VALIGN="TOP"
3446>&nbsp;</TD
3447></TR
3448><TR
3449><TD
3450WIDTH="20%"
3451ALIGN="RIGHT"
3452VALIGN="TOP"
3453><TT
3454CLASS="PARAMETER"
3455><I
3456>value</I
3457></TT
3458>&nbsp;:</TD
3459><TD
3460WIDTH="80%"
3461ALIGN="LEFT"
3462VALIGN="TOP"
3463>&#13;</TD
3464></TR
3465></TABLE
3466><P
3467></P
3468></DIV
3469></DIV
3470><HR><DIV
3471CLASS="REFSECT2"
3472><A
3473NAME="AEN809"
3474></A
3475><H3
3476><A
3477NAME="REFERENCESAXFUNC"
3478></A
3479>referenceSAXFunc ()</H3
3480><TABLE
3481BORDER="0"
3482BGCOLOR="#D6E8FF"
3483WIDTH="100%"
3484CELLPADDING="6"
3485><TR
3486><TD
3487><PRE
3488CLASS="PROGRAMLISTING"
3489>void        (*referenceSAXFunc)             (void *ctx,
3490                                             const <A
3491HREF="libxml-tree.html#XMLCHAR"
3492>xmlChar</A
3493> *name);</PRE
3494></TD
3495></TR
3496></TABLE
3497><P
3498></P
3499><DIV
3500CLASS="INFORMALTABLE"
3501><P
3502></P
3503><TABLE
3504BORDER="0"
3505WIDTH="100%"
3506BGCOLOR="#FFD0D0"
3507CELLSPACING="0"
3508CELLPADDING="4"
3509CLASS="CALSTABLE"
3510><TR
3511><TD
3512WIDTH="20%"
3513ALIGN="RIGHT"
3514VALIGN="TOP"
3515><TT
3516CLASS="PARAMETER"
3517><I
3518>ctx</I
3519></TT
3520>&nbsp;:</TD
3521><TD
3522WIDTH="80%"
3523ALIGN="LEFT"
3524VALIGN="TOP"
3525>&nbsp;</TD
3526></TR
3527><TR
3528><TD
3529WIDTH="20%"
3530ALIGN="RIGHT"
3531VALIGN="TOP"
3532><TT
3533CLASS="PARAMETER"
3534><I
3535>name</I
3536></TT
3537>&nbsp;:</TD
3538><TD
3539WIDTH="80%"
3540ALIGN="LEFT"
3541VALIGN="TOP"
3542>&#13;</TD
3543></TR
3544></TABLE
3545><P
3546></P
3547></DIV
3548></DIV
3549><HR><DIV
3550CLASS="REFSECT2"
3551><A
3552NAME="AEN828"
3553></A
3554><H3
3555><A
3556NAME="CHARACTERSSAXFUNC"
3557></A
3558>charactersSAXFunc ()</H3
3559><TABLE
3560BORDER="0"
3561BGCOLOR="#D6E8FF"
3562WIDTH="100%"
3563CELLPADDING="6"
3564><TR
3565><TD
3566><PRE
3567CLASS="PROGRAMLISTING"
3568>void        (*charactersSAXFunc)            (void *ctx,
3569                                             const <A
3570HREF="libxml-tree.html#XMLCHAR"
3571>xmlChar</A
3572> *ch,
3573                                             int len);</PRE
3574></TD
3575></TR
3576></TABLE
3577><P
3578></P
3579><DIV
3580CLASS="INFORMALTABLE"
3581><P
3582></P
3583><TABLE
3584BORDER="0"
3585WIDTH="100%"
3586BGCOLOR="#FFD0D0"
3587CELLSPACING="0"
3588CELLPADDING="4"
3589CLASS="CALSTABLE"
3590><TR
3591><TD
3592WIDTH="20%"
3593ALIGN="RIGHT"
3594VALIGN="TOP"
3595><TT
3596CLASS="PARAMETER"
3597><I
3598>ctx</I
3599></TT
3600>&nbsp;:</TD
3601><TD
3602WIDTH="80%"
3603ALIGN="LEFT"
3604VALIGN="TOP"
3605>&nbsp;</TD
3606></TR
3607><TR
3608><TD
3609WIDTH="20%"
3610ALIGN="RIGHT"
3611VALIGN="TOP"
3612><TT
3613CLASS="PARAMETER"
3614><I
3615>ch</I
3616></TT
3617>&nbsp;:</TD
3618><TD
3619WIDTH="80%"
3620ALIGN="LEFT"
3621VALIGN="TOP"
3622>&nbsp;</TD
3623></TR
3624><TR
3625><TD
3626WIDTH="20%"
3627ALIGN="RIGHT"
3628VALIGN="TOP"
3629><TT
3630CLASS="PARAMETER"
3631><I
3632>len</I
3633></TT
3634>&nbsp;:</TD
3635><TD
3636WIDTH="80%"
3637ALIGN="LEFT"
3638VALIGN="TOP"
3639>&#13;</TD
3640></TR
3641></TABLE
3642><P
3643></P
3644></DIV
3645></DIV
3646><HR><DIV
3647CLASS="REFSECT2"
3648><A
3649NAME="AEN851"
3650></A
3651><H3
3652><A
3653NAME="IGNORABLEWHITESPACESAXFUNC"
3654></A
3655>ignorableWhitespaceSAXFunc ()</H3
3656><TABLE
3657BORDER="0"
3658BGCOLOR="#D6E8FF"
3659WIDTH="100%"
3660CELLPADDING="6"
3661><TR
3662><TD
3663><PRE
3664CLASS="PROGRAMLISTING"
3665>void        (*ignorableWhitespaceSAXFunc)   (void *ctx,
3666                                             const <A
3667HREF="libxml-tree.html#XMLCHAR"
3668>xmlChar</A
3669> *ch,
3670                                             int len);</PRE
3671></TD
3672></TR
3673></TABLE
3674><P
3675></P
3676><DIV
3677CLASS="INFORMALTABLE"
3678><P
3679></P
3680><TABLE
3681BORDER="0"
3682WIDTH="100%"
3683BGCOLOR="#FFD0D0"
3684CELLSPACING="0"
3685CELLPADDING="4"
3686CLASS="CALSTABLE"
3687><TR
3688><TD
3689WIDTH="20%"
3690ALIGN="RIGHT"
3691VALIGN="TOP"
3692><TT
3693CLASS="PARAMETER"
3694><I
3695>ctx</I
3696></TT
3697>&nbsp;:</TD
3698><TD
3699WIDTH="80%"
3700ALIGN="LEFT"
3701VALIGN="TOP"
3702>&nbsp;</TD
3703></TR
3704><TR
3705><TD
3706WIDTH="20%"
3707ALIGN="RIGHT"
3708VALIGN="TOP"
3709><TT
3710CLASS="PARAMETER"
3711><I
3712>ch</I
3713></TT
3714>&nbsp;:</TD
3715><TD
3716WIDTH="80%"
3717ALIGN="LEFT"
3718VALIGN="TOP"
3719>&nbsp;</TD
3720></TR
3721><TR
3722><TD
3723WIDTH="20%"
3724ALIGN="RIGHT"
3725VALIGN="TOP"
3726><TT
3727CLASS="PARAMETER"
3728><I
3729>len</I
3730></TT
3731>&nbsp;:</TD
3732><TD
3733WIDTH="80%"
3734ALIGN="LEFT"
3735VALIGN="TOP"
3736>&#13;</TD
3737></TR
3738></TABLE
3739><P
3740></P
3741></DIV
3742></DIV
3743><HR><DIV
3744CLASS="REFSECT2"
3745><A
3746NAME="AEN874"
3747></A
3748><H3
3749><A
3750NAME="PROCESSINGINSTRUCTIONSAXFUNC"
3751></A
3752>processingInstructionSAXFunc ()</H3
3753><TABLE
3754BORDER="0"
3755BGCOLOR="#D6E8FF"
3756WIDTH="100%"
3757CELLPADDING="6"
3758><TR
3759><TD
3760><PRE
3761CLASS="PROGRAMLISTING"
3762>void        (*processingInstructionSAXFunc) (void *ctx,
3763                                             const <A
3764HREF="libxml-tree.html#XMLCHAR"
3765>xmlChar</A
3766> *target,
3767                                             const <A
3768HREF="libxml-tree.html#XMLCHAR"
3769>xmlChar</A
3770> *data);</PRE
3771></TD
3772></TR
3773></TABLE
3774><P
3775></P
3776><DIV
3777CLASS="INFORMALTABLE"
3778><P
3779></P
3780><TABLE
3781BORDER="0"
3782WIDTH="100%"
3783BGCOLOR="#FFD0D0"
3784CELLSPACING="0"
3785CELLPADDING="4"
3786CLASS="CALSTABLE"
3787><TR
3788><TD
3789WIDTH="20%"
3790ALIGN="RIGHT"
3791VALIGN="TOP"
3792><TT
3793CLASS="PARAMETER"
3794><I
3795>ctx</I
3796></TT
3797>&nbsp;:</TD
3798><TD
3799WIDTH="80%"
3800ALIGN="LEFT"
3801VALIGN="TOP"
3802>&nbsp;</TD
3803></TR
3804><TR
3805><TD
3806WIDTH="20%"
3807ALIGN="RIGHT"
3808VALIGN="TOP"
3809><TT
3810CLASS="PARAMETER"
3811><I
3812>target</I
3813></TT
3814>&nbsp;:</TD
3815><TD
3816WIDTH="80%"
3817ALIGN="LEFT"
3818VALIGN="TOP"
3819>&nbsp;</TD
3820></TR
3821><TR
3822><TD
3823WIDTH="20%"
3824ALIGN="RIGHT"
3825VALIGN="TOP"
3826><TT
3827CLASS="PARAMETER"
3828><I
3829>data</I
3830></TT
3831>&nbsp;:</TD
3832><TD
3833WIDTH="80%"
3834ALIGN="LEFT"
3835VALIGN="TOP"
3836>&#13;</TD
3837></TR
3838></TABLE
3839><P
3840></P
3841></DIV
3842></DIV
3843><HR><DIV
3844CLASS="REFSECT2"
3845><A
3846NAME="AEN898"
3847></A
3848><H3
3849><A
3850NAME="COMMENTSAXFUNC"
3851></A
3852>commentSAXFunc ()</H3
3853><TABLE
3854BORDER="0"
3855BGCOLOR="#D6E8FF"
3856WIDTH="100%"
3857CELLPADDING="6"
3858><TR
3859><TD
3860><PRE
3861CLASS="PROGRAMLISTING"
3862>void        (*commentSAXFunc)               (void *ctx,
3863                                             const <A
3864HREF="libxml-tree.html#XMLCHAR"
3865>xmlChar</A
3866> *value);</PRE
3867></TD
3868></TR
3869></TABLE
3870><P
3871></P
3872><DIV
3873CLASS="INFORMALTABLE"
3874><P
3875></P
3876><TABLE
3877BORDER="0"
3878WIDTH="100%"
3879BGCOLOR="#FFD0D0"
3880CELLSPACING="0"
3881CELLPADDING="4"
3882CLASS="CALSTABLE"
3883><TR
3884><TD
3885WIDTH="20%"
3886ALIGN="RIGHT"
3887VALIGN="TOP"
3888><TT
3889CLASS="PARAMETER"
3890><I
3891>ctx</I
3892></TT
3893>&nbsp;:</TD
3894><TD
3895WIDTH="80%"
3896ALIGN="LEFT"
3897VALIGN="TOP"
3898>&nbsp;</TD
3899></TR
3900><TR
3901><TD
3902WIDTH="20%"
3903ALIGN="RIGHT"
3904VALIGN="TOP"
3905><TT
3906CLASS="PARAMETER"
3907><I
3908>value</I
3909></TT
3910>&nbsp;:</TD
3911><TD
3912WIDTH="80%"
3913ALIGN="LEFT"
3914VALIGN="TOP"
3915>&#13;</TD
3916></TR
3917></TABLE
3918><P
3919></P
3920></DIV
3921></DIV
3922><HR><DIV
3923CLASS="REFSECT2"
3924><A
3925NAME="AEN917"
3926></A
3927><H3
3928><A
3929NAME="CDATABLOCKSAXFUNC"
3930></A
3931>cdataBlockSAXFunc ()</H3
3932><TABLE
3933BORDER="0"
3934BGCOLOR="#D6E8FF"
3935WIDTH="100%"
3936CELLPADDING="6"
3937><TR
3938><TD
3939><PRE
3940CLASS="PROGRAMLISTING"
3941>void        (*cdataBlockSAXFunc)            (void *ctx,
3942                                             const <A
3943HREF="libxml-tree.html#XMLCHAR"
3944>xmlChar</A
3945> *value,
3946                                             int len);</PRE
3947></TD
3948></TR
3949></TABLE
3950><P
3951></P
3952><DIV
3953CLASS="INFORMALTABLE"
3954><P
3955></P
3956><TABLE
3957BORDER="0"
3958WIDTH="100%"
3959BGCOLOR="#FFD0D0"
3960CELLSPACING="0"
3961CELLPADDING="4"
3962CLASS="CALSTABLE"
3963><TR
3964><TD
3965WIDTH="20%"
3966ALIGN="RIGHT"
3967VALIGN="TOP"
3968><TT
3969CLASS="PARAMETER"
3970><I
3971>ctx</I
3972></TT
3973>&nbsp;:</TD
3974><TD
3975WIDTH="80%"
3976ALIGN="LEFT"
3977VALIGN="TOP"
3978>&nbsp;</TD
3979></TR
3980><TR
3981><TD
3982WIDTH="20%"
3983ALIGN="RIGHT"
3984VALIGN="TOP"
3985><TT
3986CLASS="PARAMETER"
3987><I
3988>value</I
3989></TT
3990>&nbsp;:</TD
3991><TD
3992WIDTH="80%"
3993ALIGN="LEFT"
3994VALIGN="TOP"
3995>&nbsp;</TD
3996></TR
3997><TR
3998><TD
3999WIDTH="20%"
4000ALIGN="RIGHT"
4001VALIGN="TOP"
4002><TT
4003CLASS="PARAMETER"
4004><I
4005>len</I
4006></TT
4007>&nbsp;:</TD
4008><TD
4009WIDTH="80%"
4010ALIGN="LEFT"
4011VALIGN="TOP"
4012>&#13;</TD
4013></TR
4014></TABLE
4015><P
4016></P
4017></DIV
4018></DIV
4019><HR><DIV
4020CLASS="REFSECT2"
4021><A
4022NAME="AEN940"
4023></A
4024><H3
4025><A
4026NAME="WARNINGSAXFUNC"
4027></A
4028>warningSAXFunc ()</H3
4029><TABLE
4030BORDER="0"
4031BGCOLOR="#D6E8FF"
4032WIDTH="100%"
4033CELLPADDING="6"
4034><TR
4035><TD
4036><PRE
4037CLASS="PROGRAMLISTING"
4038>void        (*warningSAXFunc)               (void *ctx,
4039                                             const char *msg,
4040                                             ...);</PRE
4041></TD
4042></TR
4043></TABLE
4044><P
4045></P
4046><DIV
4047CLASS="INFORMALTABLE"
4048><P
4049></P
4050><TABLE
4051BORDER="0"
4052WIDTH="100%"
4053BGCOLOR="#FFD0D0"
4054CELLSPACING="0"
4055CELLPADDING="4"
4056CLASS="CALSTABLE"
4057><TR
4058><TD
4059WIDTH="20%"
4060ALIGN="RIGHT"
4061VALIGN="TOP"
4062><TT
4063CLASS="PARAMETER"
4064><I
4065>ctx</I
4066></TT
4067>&nbsp;:</TD
4068><TD
4069WIDTH="80%"
4070ALIGN="LEFT"
4071VALIGN="TOP"
4072>&nbsp;</TD
4073></TR
4074><TR
4075><TD
4076WIDTH="20%"
4077ALIGN="RIGHT"
4078VALIGN="TOP"
4079><TT
4080CLASS="PARAMETER"
4081><I
4082>msg</I
4083></TT
4084>&nbsp;:</TD
4085><TD
4086WIDTH="80%"
4087ALIGN="LEFT"
4088VALIGN="TOP"
4089>&nbsp;</TD
4090></TR
4091><TR
4092><TD
4093WIDTH="20%"
4094ALIGN="RIGHT"
4095VALIGN="TOP"
4096><TT
4097CLASS="PARAMETER"
4098><I
4099>...</I
4100></TT
4101>&nbsp;:</TD
4102><TD
4103WIDTH="80%"
4104ALIGN="LEFT"
4105VALIGN="TOP"
4106>&#13;</TD
4107></TR
4108></TABLE
4109><P
4110></P
4111></DIV
4112></DIV
4113><HR><DIV
4114CLASS="REFSECT2"
4115><A
4116NAME="AEN962"
4117></A
4118><H3
4119><A
4120NAME="ERRORSAXFUNC"
4121></A
4122>errorSAXFunc ()</H3
4123><TABLE
4124BORDER="0"
4125BGCOLOR="#D6E8FF"
4126WIDTH="100%"
4127CELLPADDING="6"
4128><TR
4129><TD
4130><PRE
4131CLASS="PROGRAMLISTING"
4132>void        (*errorSAXFunc)                 (void *ctx,
4133                                             const char *msg,
4134                                             ...);</PRE
4135></TD
4136></TR
4137></TABLE
4138><P
4139></P
4140><DIV
4141CLASS="INFORMALTABLE"
4142><P
4143></P
4144><TABLE
4145BORDER="0"
4146WIDTH="100%"
4147BGCOLOR="#FFD0D0"
4148CELLSPACING="0"
4149CELLPADDING="4"
4150CLASS="CALSTABLE"
4151><TR
4152><TD
4153WIDTH="20%"
4154ALIGN="RIGHT"
4155VALIGN="TOP"
4156><TT
4157CLASS="PARAMETER"
4158><I
4159>ctx</I
4160></TT
4161>&nbsp;:</TD
4162><TD
4163WIDTH="80%"
4164ALIGN="LEFT"
4165VALIGN="TOP"
4166>&nbsp;</TD
4167></TR
4168><TR
4169><TD
4170WIDTH="20%"
4171ALIGN="RIGHT"
4172VALIGN="TOP"
4173><TT
4174CLASS="PARAMETER"
4175><I
4176>msg</I
4177></TT
4178>&nbsp;:</TD
4179><TD
4180WIDTH="80%"
4181ALIGN="LEFT"
4182VALIGN="TOP"
4183>&nbsp;</TD
4184></TR
4185><TR
4186><TD
4187WIDTH="20%"
4188ALIGN="RIGHT"
4189VALIGN="TOP"
4190><TT
4191CLASS="PARAMETER"
4192><I
4193>...</I
4194></TT
4195>&nbsp;:</TD
4196><TD
4197WIDTH="80%"
4198ALIGN="LEFT"
4199VALIGN="TOP"
4200>&#13;</TD
4201></TR
4202></TABLE
4203><P
4204></P
4205></DIV
4206></DIV
4207><HR><DIV
4208CLASS="REFSECT2"
4209><A
4210NAME="AEN984"
4211></A
4212><H3
4213><A
4214NAME="FATALERRORSAXFUNC"
4215></A
4216>fatalErrorSAXFunc ()</H3
4217><TABLE
4218BORDER="0"
4219BGCOLOR="#D6E8FF"
4220WIDTH="100%"
4221CELLPADDING="6"
4222><TR
4223><TD
4224><PRE
4225CLASS="PROGRAMLISTING"
4226>void        (*fatalErrorSAXFunc)            (void *ctx,
4227                                             const char *msg,
4228                                             ...);</PRE
4229></TD
4230></TR
4231></TABLE
4232><P
4233></P
4234><DIV
4235CLASS="INFORMALTABLE"
4236><P
4237></P
4238><TABLE
4239BORDER="0"
4240WIDTH="100%"
4241BGCOLOR="#FFD0D0"
4242CELLSPACING="0"
4243CELLPADDING="4"
4244CLASS="CALSTABLE"
4245><TR
4246><TD
4247WIDTH="20%"
4248ALIGN="RIGHT"
4249VALIGN="TOP"
4250><TT
4251CLASS="PARAMETER"
4252><I
4253>ctx</I
4254></TT
4255>&nbsp;:</TD
4256><TD
4257WIDTH="80%"
4258ALIGN="LEFT"
4259VALIGN="TOP"
4260>&nbsp;</TD
4261></TR
4262><TR
4263><TD
4264WIDTH="20%"
4265ALIGN="RIGHT"
4266VALIGN="TOP"
4267><TT
4268CLASS="PARAMETER"
4269><I
4270>msg</I
4271></TT
4272>&nbsp;:</TD
4273><TD
4274WIDTH="80%"
4275ALIGN="LEFT"
4276VALIGN="TOP"
4277>&nbsp;</TD
4278></TR
4279><TR
4280><TD
4281WIDTH="20%"
4282ALIGN="RIGHT"
4283VALIGN="TOP"
4284><TT
4285CLASS="PARAMETER"
4286><I
4287>...</I
4288></TT
4289>&nbsp;:</TD
4290><TD
4291WIDTH="80%"
4292ALIGN="LEFT"
4293VALIGN="TOP"
4294>&#13;</TD
4295></TR
4296></TABLE
4297><P
4298></P
4299></DIV
4300></DIV
4301><HR><DIV
4302CLASS="REFSECT2"
4303><A
4304NAME="AEN1006"
4305></A
4306><H3
4307><A
4308NAME="ISSTANDALONESAXFUNC"
4309></A
4310>isStandaloneSAXFunc ()</H3
4311><TABLE
4312BORDER="0"
4313BGCOLOR="#D6E8FF"
4314WIDTH="100%"
4315CELLPADDING="6"
4316><TR
4317><TD
4318><PRE
4319CLASS="PROGRAMLISTING"
4320>int         (*isStandaloneSAXFunc)          (void *ctx);</PRE
4321></TD
4322></TR
4323></TABLE
4324><P
4325></P
4326><DIV
4327CLASS="INFORMALTABLE"
4328><P
4329></P
4330><TABLE
4331BORDER="0"
4332WIDTH="100%"
4333BGCOLOR="#FFD0D0"
4334CELLSPACING="0"
4335CELLPADDING="4"
4336CLASS="CALSTABLE"
4337><TR
4338><TD
4339WIDTH="20%"
4340ALIGN="RIGHT"
4341VALIGN="TOP"
4342><TT
4343CLASS="PARAMETER"
4344><I
4345>ctx</I
4346></TT
4347>&nbsp;:</TD
4348><TD
4349WIDTH="80%"
4350ALIGN="LEFT"
4351VALIGN="TOP"
4352>&nbsp;</TD
4353></TR
4354><TR
4355><TD
4356WIDTH="20%"
4357ALIGN="RIGHT"
4358VALIGN="TOP"
4359><I
4360CLASS="EMPHASIS"
4361>Returns</I
4362> :</TD
4363><TD
4364WIDTH="80%"
4365ALIGN="LEFT"
4366VALIGN="TOP"
4367>&#13;</TD
4368></TR
4369></TABLE
4370><P
4371></P
4372></DIV
4373></DIV
4374><HR><DIV
4375CLASS="REFSECT2"
4376><A
4377NAME="AEN1024"
4378></A
4379><H3
4380><A
4381NAME="HASINTERNALSUBSETSAXFUNC"
4382></A
4383>hasInternalSubsetSAXFunc ()</H3
4384><TABLE
4385BORDER="0"
4386BGCOLOR="#D6E8FF"
4387WIDTH="100%"
4388CELLPADDING="6"
4389><TR
4390><TD
4391><PRE
4392CLASS="PROGRAMLISTING"
4393>int         (*hasInternalSubsetSAXFunc)     (void *ctx);</PRE
4394></TD
4395></TR
4396></TABLE
4397><P
4398></P
4399><DIV
4400CLASS="INFORMALTABLE"
4401><P
4402></P
4403><TABLE
4404BORDER="0"
4405WIDTH="100%"
4406BGCOLOR="#FFD0D0"
4407CELLSPACING="0"
4408CELLPADDING="4"
4409CLASS="CALSTABLE"
4410><TR
4411><TD
4412WIDTH="20%"
4413ALIGN="RIGHT"
4414VALIGN="TOP"
4415><TT
4416CLASS="PARAMETER"
4417><I
4418>ctx</I
4419></TT
4420>&nbsp;:</TD
4421><TD
4422WIDTH="80%"
4423ALIGN="LEFT"
4424VALIGN="TOP"
4425>&nbsp;</TD
4426></TR
4427><TR
4428><TD
4429WIDTH="20%"
4430ALIGN="RIGHT"
4431VALIGN="TOP"
4432><I
4433CLASS="EMPHASIS"
4434>Returns</I
4435> :</TD
4436><TD
4437WIDTH="80%"
4438ALIGN="LEFT"
4439VALIGN="TOP"
4440>&#13;</TD
4441></TR
4442></TABLE
4443><P
4444></P
4445></DIV
4446></DIV
4447><HR><DIV
4448CLASS="REFSECT2"
4449><A
4450NAME="AEN1042"
4451></A
4452><H3
4453><A
4454NAME="HASEXTERNALSUBSETSAXFUNC"
4455></A
4456>hasExternalSubsetSAXFunc ()</H3
4457><TABLE
4458BORDER="0"
4459BGCOLOR="#D6E8FF"
4460WIDTH="100%"
4461CELLPADDING="6"
4462><TR
4463><TD
4464><PRE
4465CLASS="PROGRAMLISTING"
4466>int         (*hasExternalSubsetSAXFunc)     (void *ctx);</PRE
4467></TD
4468></TR
4469></TABLE
4470><P
4471></P
4472><DIV
4473CLASS="INFORMALTABLE"
4474><P
4475></P
4476><TABLE
4477BORDER="0"
4478WIDTH="100%"
4479BGCOLOR="#FFD0D0"
4480CELLSPACING="0"
4481CELLPADDING="4"
4482CLASS="CALSTABLE"
4483><TR
4484><TD
4485WIDTH="20%"
4486ALIGN="RIGHT"
4487VALIGN="TOP"
4488><TT
4489CLASS="PARAMETER"
4490><I
4491>ctx</I
4492></TT
4493>&nbsp;:</TD
4494><TD
4495WIDTH="80%"
4496ALIGN="LEFT"
4497VALIGN="TOP"
4498>&nbsp;</TD
4499></TR
4500><TR
4501><TD
4502WIDTH="20%"
4503ALIGN="RIGHT"
4504VALIGN="TOP"
4505><I
4506CLASS="EMPHASIS"
4507>Returns</I
4508> :</TD
4509><TD
4510WIDTH="80%"
4511ALIGN="LEFT"
4512VALIGN="TOP"
4513>&#13;</TD
4514></TR
4515></TABLE
4516><P
4517></P
4518></DIV
4519></DIV
4520><HR><DIV
4521CLASS="REFSECT2"
4522><A
4523NAME="AEN1060"
4524></A
4525><H3
4526><A
4527NAME="XMLSAXHANDLER"
4528></A
4529>struct xmlSAXHandler</H3
4530><TABLE
4531BORDER="0"
4532BGCOLOR="#D6E8FF"
4533WIDTH="100%"
4534CELLPADDING="6"
4535><TR
4536><TD
4537><PRE
4538CLASS="PROGRAMLISTING"
4539>struct xmlSAXHandler {
4540    internalSubsetSAXFunc internalSubset;
4541    isStandaloneSAXFunc isStandalone;
4542    hasInternalSubsetSAXFunc hasInternalSubset;
4543    hasExternalSubsetSAXFunc hasExternalSubset;
4544    resolveEntitySAXFunc resolveEntity;
4545    getEntitySAXFunc getEntity;
4546    entityDeclSAXFunc entityDecl;
4547    notationDeclSAXFunc notationDecl;
4548    attributeDeclSAXFunc attributeDecl;
4549    elementDeclSAXFunc elementDecl;
4550    unparsedEntityDeclSAXFunc unparsedEntityDecl;
4551    setDocumentLocatorSAXFunc setDocumentLocator;
4552    startDocumentSAXFunc startDocument;
4553    endDocumentSAXFunc endDocument;
4554    startElementSAXFunc startElement;
4555    endElementSAXFunc endElement;
4556    referenceSAXFunc reference;
4557    charactersSAXFunc characters;
4558    ignorableWhitespaceSAXFunc ignorableWhitespace;
4559    processingInstructionSAXFunc processingInstruction;
4560    commentSAXFunc comment;
4561    warningSAXFunc warning;
4562    errorSAXFunc error;
4563    fatalErrorSAXFunc fatalError;
4564    getParameterEntitySAXFunc getParameterEntity;
4565    cdataBlockSAXFunc cdataBlock;
4566    externalSubsetSAXFunc externalSubset;
4567};</PRE
4568></TD
4569></TR
4570></TABLE
4571><P
4572></P
4573></DIV
4574><HR><DIV
4575CLASS="REFSECT2"
4576><A
4577NAME="AEN1065"
4578></A
4579><H3
4580><A
4581NAME="XMLSAXHANDLERPTR"
4582></A
4583>xmlSAXHandlerPtr</H3
4584><TABLE
4585BORDER="0"
4586BGCOLOR="#D6E8FF"
4587WIDTH="100%"
4588CELLPADDING="6"
4589><TR
4590><TD
4591><PRE
4592CLASS="PROGRAMLISTING"
4593>typedef xmlSAXHandler *xmlSAXHandlerPtr;</PRE
4594></TD
4595></TR
4596></TABLE
4597><P
4598></P
4599></DIV
4600><HR><DIV
4601CLASS="REFSECT2"
4602><A
4603NAME="AEN1070"
4604></A
4605><H3
4606><A
4607NAME="XMLEXTERNALENTITYLOADER"
4608></A
4609>xmlExternalEntityLoader ()</H3
4610><TABLE
4611BORDER="0"
4612BGCOLOR="#D6E8FF"
4613WIDTH="100%"
4614CELLPADDING="6"
4615><TR
4616><TD
4617><PRE
4618CLASS="PROGRAMLISTING"
4619><A
4620HREF="libxml-parser.html#XMLPARSERINPUTPTR"
4621>xmlParserInputPtr</A
4622> (*xmlExternalEntityLoader)
4623                                            (const char *URL,
4624                                             const char *ID,
4625                                             <A
4626HREF="libxml-parser.html#XMLPARSERCTXTPTR"
4627>xmlParserCtxtPtr</A
4628> context);</PRE
4629></TD
4630></TR
4631></TABLE
4632><P
4633></P
4634><DIV
4635CLASS="INFORMALTABLE"
4636><P
4637></P
4638><TABLE
4639BORDER="0"
4640WIDTH="100%"
4641BGCOLOR="#FFD0D0"
4642CELLSPACING="0"
4643CELLPADDING="4"
4644CLASS="CALSTABLE"
4645><TR
4646><TD
4647WIDTH="20%"
4648ALIGN="RIGHT"
4649VALIGN="TOP"
4650><TT
4651CLASS="PARAMETER"
4652><I
4653>URL</I
4654></TT
4655>&nbsp;:</TD
4656><TD
4657WIDTH="80%"
4658ALIGN="LEFT"
4659VALIGN="TOP"
4660>&nbsp;</TD
4661></TR
4662><TR
4663><TD
4664WIDTH="20%"
4665ALIGN="RIGHT"
4666VALIGN="TOP"
4667><TT
4668CLASS="PARAMETER"
4669><I
4670>ID</I
4671></TT
4672>&nbsp;:</TD
4673><TD
4674WIDTH="80%"
4675ALIGN="LEFT"
4676VALIGN="TOP"
4677>&nbsp;</TD
4678></TR
4679><TR
4680><TD
4681WIDTH="20%"
4682ALIGN="RIGHT"
4683VALIGN="TOP"
4684><TT
4685CLASS="PARAMETER"
4686><I
4687>context</I
4688></TT
4689>&nbsp;:</TD
4690><TD
4691WIDTH="80%"
4692ALIGN="LEFT"
4693VALIGN="TOP"
4694>&nbsp;</TD
4695></TR
4696><TR
4697><TD
4698WIDTH="20%"
4699ALIGN="RIGHT"
4700VALIGN="TOP"
4701><I
4702CLASS="EMPHASIS"
4703>Returns</I
4704> :</TD
4705><TD
4706WIDTH="80%"
4707ALIGN="LEFT"
4708VALIGN="TOP"
4709>&#13;</TD
4710></TR
4711></TABLE
4712><P
4713></P
4714></DIV
4715></DIV
4716><HR><DIV
4717CLASS="REFSECT2"
4718><A
4719NAME="AEN1098"
4720></A
4721><H3
4722><A
4723NAME="XMLSUBSTITUTEENTITIESDEFAULTVALUE"
4724></A
4725>xmlSubstituteEntitiesDefaultValue</H3
4726><TABLE
4727BORDER="0"
4728BGCOLOR="#D6E8FF"
4729WIDTH="100%"
4730CELLPADDING="6"
4731><TR
4732><TD
4733><PRE
4734CLASS="PROGRAMLISTING"
4735>#define xmlSubstituteEntitiesDefaultValue xmlSubstituteEntitiesDefaultVal</PRE
4736></TD
4737></TR
4738></TABLE
4739><P
4740></P
4741></DIV
4742><HR><DIV
4743CLASS="REFSECT2"
4744><A
4745NAME="AEN1103"
4746></A
4747><H3
4748><A
4749NAME="XMLINITPARSER"
4750></A
4751>xmlInitParser ()</H3
4752><TABLE
4753BORDER="0"
4754BGCOLOR="#D6E8FF"
4755WIDTH="100%"
4756CELLPADDING="6"
4757><TR
4758><TD
4759><PRE
4760CLASS="PROGRAMLISTING"
4761>void        xmlInitParser                   (void);</PRE
4762></TD
4763></TR
4764></TABLE
4765><P
4766>Initialization function for the XML parser.
4767This is not reentrant. Call once before processing in case of
4768use in multithreaded programs.</P
4769><P
4770></P
4771></DIV
4772><HR><DIV
4773CLASS="REFSECT2"
4774><A
4775NAME="AEN1109"
4776></A
4777><H3
4778><A
4779NAME="XMLCLEANUPPARSER"
4780></A
4781>xmlCleanupParser ()</H3
4782><TABLE
4783BORDER="0"
4784BGCOLOR="#D6E8FF"
4785WIDTH="100%"
4786CELLPADDING="6"
4787><TR
4788><TD
4789><PRE
4790CLASS="PROGRAMLISTING"
4791>void        xmlCleanupParser                (void);</PRE
4792></TD
4793></TR
4794></TABLE
4795><P
4796>Cleanup function for the XML parser. It tries to reclaim all
4797parsing related global memory allocated for the parser processing.
4798It doesn't deallocate any document related memory. Calling this
4799function should not prevent reusing the parser.</P
4800><P
4801></P
4802></DIV
4803><HR><DIV
4804CLASS="REFSECT2"
4805><A
4806NAME="AEN1115"
4807></A
4808><H3
4809><A
4810NAME="XMLPARSERINPUTREAD"
4811></A
4812>xmlParserInputRead ()</H3
4813><TABLE
4814BORDER="0"
4815BGCOLOR="#D6E8FF"
4816WIDTH="100%"
4817CELLPADDING="6"
4818><TR
4819><TD
4820><PRE
4821CLASS="PROGRAMLISTING"
4822>int         xmlParserInputRead              (<A
4823HREF="libxml-parser.html#XMLPARSERINPUTPTR"
4824>xmlParserInputPtr</A
4825> in,
4826                                             int len);</PRE
4827></TD
4828></TR
4829></TABLE
4830><P
4831>This function refresh the input for the parser. It doesn't try to
4832preserve pointers to the input buffer, and discard already read data</P
4833><P
4834></P
4835><DIV
4836CLASS="INFORMALTABLE"
4837><P
4838></P
4839><TABLE
4840BORDER="0"
4841WIDTH="100%"
4842BGCOLOR="#FFD0D0"
4843CELLSPACING="0"
4844CELLPADDING="4"
4845CLASS="CALSTABLE"
4846><TR
4847><TD
4848WIDTH="20%"
4849ALIGN="RIGHT"
4850VALIGN="TOP"
4851><TT
4852CLASS="PARAMETER"
4853><I
4854>in</I
4855></TT
4856>&nbsp;:</TD
4857><TD
4858WIDTH="80%"
4859ALIGN="LEFT"
4860VALIGN="TOP"
4861>  an XML parser input</TD
4862></TR
4863><TR
4864><TD
4865WIDTH="20%"
4866ALIGN="RIGHT"
4867VALIGN="TOP"
4868><TT
4869CLASS="PARAMETER"
4870><I
4871>len</I
4872></TT
4873>&nbsp;:</TD
4874><TD
4875WIDTH="80%"
4876ALIGN="LEFT"
4877VALIGN="TOP"
4878>  an indicative size for the lookahead</TD
4879></TR
4880><TR
4881><TD
4882WIDTH="20%"
4883ALIGN="RIGHT"
4884VALIGN="TOP"
4885><I
4886CLASS="EMPHASIS"
4887>Returns</I
4888> :</TD
4889><TD
4890WIDTH="80%"
4891ALIGN="LEFT"
4892VALIGN="TOP"
4893>the number of xmlChars read, or -1 in case of error, 0 indicate the
4894end of this entity</TD
4895></TR
4896></TABLE
4897><P
4898></P
4899></DIV
4900></DIV
4901><HR><DIV
4902CLASS="REFSECT2"
4903><A
4904NAME="AEN1139"
4905></A
4906><H3
4907><A
4908NAME="XMLPARSERINPUTGROW"
4909></A
4910>xmlParserInputGrow ()</H3
4911><TABLE
4912BORDER="0"
4913BGCOLOR="#D6E8FF"
4914WIDTH="100%"
4915CELLPADDING="6"
4916><TR
4917><TD
4918><PRE
4919CLASS="PROGRAMLISTING"
4920>int         xmlParserInputGrow              (<A
4921HREF="libxml-parser.html#XMLPARSERINPUTPTR"
4922>xmlParserInputPtr</A
4923> in,
4924                                             int len);</PRE
4925></TD
4926></TR
4927></TABLE
4928><P
4929>This function increase the input for the parser. It tries to
4930preserve pointers to the input buffer, and keep already read data</P
4931><P
4932></P
4933><DIV
4934CLASS="INFORMALTABLE"
4935><P
4936></P
4937><TABLE
4938BORDER="0"
4939WIDTH="100%"
4940BGCOLOR="#FFD0D0"
4941CELLSPACING="0"
4942CELLPADDING="4"
4943CLASS="CALSTABLE"
4944><TR
4945><TD
4946WIDTH="20%"
4947ALIGN="RIGHT"
4948VALIGN="TOP"
4949><TT
4950CLASS="PARAMETER"
4951><I
4952>in</I
4953></TT
4954>&nbsp;:</TD
4955><TD
4956WIDTH="80%"
4957ALIGN="LEFT"
4958VALIGN="TOP"
4959>  an XML parser input</TD
4960></TR
4961><TR
4962><TD
4963WIDTH="20%"
4964ALIGN="RIGHT"
4965VALIGN="TOP"
4966><TT
4967CLASS="PARAMETER"
4968><I
4969>len</I
4970></TT
4971>&nbsp;:</TD
4972><TD
4973WIDTH="80%"
4974ALIGN="LEFT"
4975VALIGN="TOP"
4976>  an indicative size for the lookahead</TD
4977></TR
4978><TR
4979><TD
4980WIDTH="20%"
4981ALIGN="RIGHT"
4982VALIGN="TOP"
4983><I
4984CLASS="EMPHASIS"
4985>Returns</I
4986> :</TD
4987><TD
4988WIDTH="80%"
4989ALIGN="LEFT"
4990VALIGN="TOP"
4991>the number of xmlChars read, or -1 in case of error, 0 indicate the
4992end of this entity</TD
4993></TR
4994></TABLE
4995><P
4996></P
4997></DIV
4998></DIV
4999><HR><DIV
5000CLASS="REFSECT2"
5001><A
5002NAME="AEN1163"
5003></A
5004><H3
5005><A
5006NAME="XMLSTRDUP"
5007></A
5008>xmlStrdup ()</H3
5009><TABLE
5010BORDER="0"
5011BGCOLOR="#D6E8FF"
5012WIDTH="100%"
5013CELLPADDING="6"
5014><TR
5015><TD
5016><PRE
5017CLASS="PROGRAMLISTING"
5018><A
5019HREF="libxml-tree.html#XMLCHAR"
5020>xmlChar</A
5021>*    xmlStrdup                       (const <A
5022HREF="libxml-tree.html#XMLCHAR"
5023>xmlChar</A
5024> *cur);</PRE
5025></TD
5026></TR
5027></TABLE
5028><P
5029>a strdup for array of xmlChar's. Since they are supposed to be
5030encoded in UTF-8 or an encoding with 8bit based chars, we assume
5031a termination mark of '0'.</P
5032><P
5033></P
5034><DIV
5035CLASS="INFORMALTABLE"
5036><P
5037></P
5038><TABLE
5039BORDER="0"
5040WIDTH="100%"
5041BGCOLOR="#FFD0D0"
5042CELLSPACING="0"
5043CELLPADDING="4"
5044CLASS="CALSTABLE"
5045><TR
5046><TD
5047WIDTH="20%"
5048ALIGN="RIGHT"
5049VALIGN="TOP"
5050><TT
5051CLASS="PARAMETER"
5052><I
5053>cur</I
5054></TT
5055>&nbsp;:</TD
5056><TD
5057WIDTH="80%"
5058ALIGN="LEFT"
5059VALIGN="TOP"
5060>  the input xmlChar *</TD
5061></TR
5062><TR
5063><TD
5064WIDTH="20%"
5065ALIGN="RIGHT"
5066VALIGN="TOP"
5067><I
5068CLASS="EMPHASIS"
5069>Returns</I
5070> :</TD
5071><TD
5072WIDTH="80%"
5073ALIGN="LEFT"
5074VALIGN="TOP"
5075>a new xmlChar * or NULL</TD
5076></TR
5077></TABLE
5078><P
5079></P
5080></DIV
5081></DIV
5082><HR><DIV
5083CLASS="REFSECT2"
5084><A
5085NAME="AEN1184"
5086></A
5087><H3
5088><A
5089NAME="XMLSTRNDUP"
5090></A
5091>xmlStrndup ()</H3
5092><TABLE
5093BORDER="0"
5094BGCOLOR="#D6E8FF"
5095WIDTH="100%"
5096CELLPADDING="6"
5097><TR
5098><TD
5099><PRE
5100CLASS="PROGRAMLISTING"
5101><A
5102HREF="libxml-tree.html#XMLCHAR"
5103>xmlChar</A
5104>*    xmlStrndup                      (const <A
5105HREF="libxml-tree.html#XMLCHAR"
5106>xmlChar</A
5107> *cur,
5108                                             int len);</PRE
5109></TD
5110></TR
5111></TABLE
5112><P
5113>a strndup for array of xmlChar's</P
5114><P
5115></P
5116><DIV
5117CLASS="INFORMALTABLE"
5118><P
5119></P
5120><TABLE
5121BORDER="0"
5122WIDTH="100%"
5123BGCOLOR="#FFD0D0"
5124CELLSPACING="0"
5125CELLPADDING="4"
5126CLASS="CALSTABLE"
5127><TR
5128><TD
5129WIDTH="20%"
5130ALIGN="RIGHT"
5131VALIGN="TOP"
5132><TT
5133CLASS="PARAMETER"
5134><I
5135>cur</I
5136></TT
5137>&nbsp;:</TD
5138><TD
5139WIDTH="80%"
5140ALIGN="LEFT"
5141VALIGN="TOP"
5142>  the input xmlChar *</TD
5143></TR
5144><TR
5145><TD
5146WIDTH="20%"
5147ALIGN="RIGHT"
5148VALIGN="TOP"
5149><TT
5150CLASS="PARAMETER"
5151><I
5152>len</I
5153></TT
5154>&nbsp;:</TD
5155><TD
5156WIDTH="80%"
5157ALIGN="LEFT"
5158VALIGN="TOP"
5159>  the len of <TT
5160CLASS="PARAMETER"
5161><I
5162>cur</I
5163></TT
5164></TD
5165></TR
5166><TR
5167><TD
5168WIDTH="20%"
5169ALIGN="RIGHT"
5170VALIGN="TOP"
5171><I
5172CLASS="EMPHASIS"
5173>Returns</I
5174> :</TD
5175><TD
5176WIDTH="80%"
5177ALIGN="LEFT"
5178VALIGN="TOP"
5179>a new xmlChar * or NULL</TD
5180></TR
5181></TABLE
5182><P
5183></P
5184></DIV
5185></DIV
5186><HR><DIV
5187CLASS="REFSECT2"
5188><A
5189NAME="AEN1210"
5190></A
5191><H3
5192><A
5193NAME="XMLSTRSUB"
5194></A
5195>xmlStrsub ()</H3
5196><TABLE
5197BORDER="0"
5198BGCOLOR="#D6E8FF"
5199WIDTH="100%"
5200CELLPADDING="6"
5201><TR
5202><TD
5203><PRE
5204CLASS="PROGRAMLISTING"
5205><A
5206HREF="libxml-tree.html#XMLCHAR"
5207>xmlChar</A
5208>*    xmlStrsub                       (const <A
5209HREF="libxml-tree.html#XMLCHAR"
5210>xmlChar</A
5211> *str,
5212                                             int start,
5213                                             int len);</PRE
5214></TD
5215></TR
5216></TABLE
5217><P
5218>Extract a substring of a given string</P
5219><P
5220></P
5221><DIV
5222CLASS="INFORMALTABLE"
5223><P
5224></P
5225><TABLE
5226BORDER="0"
5227WIDTH="100%"
5228BGCOLOR="#FFD0D0"
5229CELLSPACING="0"
5230CELLPADDING="4"
5231CLASS="CALSTABLE"
5232><TR
5233><TD
5234WIDTH="20%"
5235ALIGN="RIGHT"
5236VALIGN="TOP"
5237><TT
5238CLASS="PARAMETER"
5239><I
5240>str</I
5241></TT
5242>&nbsp;:</TD
5243><TD
5244WIDTH="80%"
5245ALIGN="LEFT"
5246VALIGN="TOP"
5247>  the xmlChar * array (haystack)</TD
5248></TR
5249><TR
5250><TD
5251WIDTH="20%"
5252ALIGN="RIGHT"
5253VALIGN="TOP"
5254><TT
5255CLASS="PARAMETER"
5256><I
5257>start</I
5258></TT
5259>&nbsp;:</TD
5260><TD
5261WIDTH="80%"
5262ALIGN="LEFT"
5263VALIGN="TOP"
5264>  the index of the first char (zero based)</TD
5265></TR
5266><TR
5267><TD
5268WIDTH="20%"
5269ALIGN="RIGHT"
5270VALIGN="TOP"
5271><TT
5272CLASS="PARAMETER"
5273><I
5274>len</I
5275></TT
5276>&nbsp;:</TD
5277><TD
5278WIDTH="80%"
5279ALIGN="LEFT"
5280VALIGN="TOP"
5281>  the length of the substring</TD
5282></TR
5283><TR
5284><TD
5285WIDTH="20%"
5286ALIGN="RIGHT"
5287VALIGN="TOP"
5288><I
5289CLASS="EMPHASIS"
5290>Returns</I
5291> :</TD
5292><TD
5293WIDTH="80%"
5294ALIGN="LEFT"
5295VALIGN="TOP"
5296>the xmlChar * for the first occurence or NULL.</TD
5297></TR
5298></TABLE
5299><P
5300></P
5301></DIV
5302></DIV
5303><HR><DIV
5304CLASS="REFSECT2"
5305><A
5306NAME="AEN1239"
5307></A
5308><H3
5309><A
5310NAME="XMLSTRCHR"
5311></A
5312>xmlStrchr ()</H3
5313><TABLE
5314BORDER="0"
5315BGCOLOR="#D6E8FF"
5316WIDTH="100%"
5317CELLPADDING="6"
5318><TR
5319><TD
5320><PRE
5321CLASS="PROGRAMLISTING"
5322>const <A
5323HREF="libxml-tree.html#XMLCHAR"
5324>xmlChar</A
5325>* xmlStrchr                    (const <A
5326HREF="libxml-tree.html#XMLCHAR"
5327>xmlChar</A
5328> *str,
5329                                             <A
5330HREF="libxml-tree.html#XMLCHAR"
5331>xmlChar</A
5332> val);</PRE
5333></TD
5334></TR
5335></TABLE
5336><P
5337>a strchr for xmlChar's</P
5338><P
5339></P
5340><DIV
5341CLASS="INFORMALTABLE"
5342><P
5343></P
5344><TABLE
5345BORDER="0"
5346WIDTH="100%"
5347BGCOLOR="#FFD0D0"
5348CELLSPACING="0"
5349CELLPADDING="4"
5350CLASS="CALSTABLE"
5351><TR
5352><TD
5353WIDTH="20%"
5354ALIGN="RIGHT"
5355VALIGN="TOP"
5356><TT
5357CLASS="PARAMETER"
5358><I
5359>str</I
5360></TT
5361>&nbsp;:</TD
5362><TD
5363WIDTH="80%"
5364ALIGN="LEFT"
5365VALIGN="TOP"
5366>  the xmlChar * array</TD
5367></TR
5368><TR
5369><TD
5370WIDTH="20%"
5371ALIGN="RIGHT"
5372VALIGN="TOP"
5373><TT
5374CLASS="PARAMETER"
5375><I
5376>val</I
5377></TT
5378>&nbsp;:</TD
5379><TD
5380WIDTH="80%"
5381ALIGN="LEFT"
5382VALIGN="TOP"
5383>  the xmlChar to search</TD
5384></TR
5385><TR
5386><TD
5387WIDTH="20%"
5388ALIGN="RIGHT"
5389VALIGN="TOP"
5390><I
5391CLASS="EMPHASIS"
5392>Returns</I
5393> :</TD
5394><TD
5395WIDTH="80%"
5396ALIGN="LEFT"
5397VALIGN="TOP"
5398>the xmlChar * for the first occurence or NULL.</TD
5399></TR
5400></TABLE
5401><P
5402></P
5403></DIV
5404></DIV
5405><HR><DIV
5406CLASS="REFSECT2"
5407><A
5408NAME="AEN1265"
5409></A
5410><H3
5411><A
5412NAME="XMLSTRSTR"
5413></A
5414>xmlStrstr ()</H3
5415><TABLE
5416BORDER="0"
5417BGCOLOR="#D6E8FF"
5418WIDTH="100%"
5419CELLPADDING="6"
5420><TR
5421><TD
5422><PRE
5423CLASS="PROGRAMLISTING"
5424>const <A
5425HREF="libxml-tree.html#XMLCHAR"
5426>xmlChar</A
5427>* xmlStrstr                    (const <A
5428HREF="libxml-tree.html#XMLCHAR"
5429>xmlChar</A
5430> *str,
5431                                             <A
5432HREF="libxml-tree.html#XMLCHAR"
5433>xmlChar</A
5434> *val);</PRE
5435></TD
5436></TR
5437></TABLE
5438><P
5439>a strstr for xmlChar's</P
5440><P
5441></P
5442><DIV
5443CLASS="INFORMALTABLE"
5444><P
5445></P
5446><TABLE
5447BORDER="0"
5448WIDTH="100%"
5449BGCOLOR="#FFD0D0"
5450CELLSPACING="0"
5451CELLPADDING="4"
5452CLASS="CALSTABLE"
5453><TR
5454><TD
5455WIDTH="20%"
5456ALIGN="RIGHT"
5457VALIGN="TOP"
5458><TT
5459CLASS="PARAMETER"
5460><I
5461>str</I
5462></TT
5463>&nbsp;:</TD
5464><TD
5465WIDTH="80%"
5466ALIGN="LEFT"
5467VALIGN="TOP"
5468>  the xmlChar * array (haystack)</TD
5469></TR
5470><TR
5471><TD
5472WIDTH="20%"
5473ALIGN="RIGHT"
5474VALIGN="TOP"
5475><TT
5476CLASS="PARAMETER"
5477><I
5478>val</I
5479></TT
5480>&nbsp;:</TD
5481><TD
5482WIDTH="80%"
5483ALIGN="LEFT"
5484VALIGN="TOP"
5485>  the xmlChar to search (needle)</TD
5486></TR
5487><TR
5488><TD
5489WIDTH="20%"
5490ALIGN="RIGHT"
5491VALIGN="TOP"
5492><I
5493CLASS="EMPHASIS"
5494>Returns</I
5495> :</TD
5496><TD
5497WIDTH="80%"
5498ALIGN="LEFT"
5499VALIGN="TOP"
5500>the xmlChar * for the first occurence or NULL.</TD
5501></TR
5502></TABLE
5503><P
5504></P
5505></DIV
5506></DIV
5507><HR><DIV
5508CLASS="REFSECT2"
5509><A
5510NAME="AEN1291"
5511></A
5512><H3
5513><A
5514NAME="XMLSTRCASESTR"
5515></A
5516>xmlStrcasestr ()</H3
5517><TABLE
5518BORDER="0"
5519BGCOLOR="#D6E8FF"
5520WIDTH="100%"
5521CELLPADDING="6"
5522><TR
5523><TD
5524><PRE
5525CLASS="PROGRAMLISTING"
5526>const <A
5527HREF="libxml-tree.html#XMLCHAR"
5528>xmlChar</A
5529>* xmlStrcasestr                (const <A
5530HREF="libxml-tree.html#XMLCHAR"
5531>xmlChar</A
5532> *str,
5533                                             <A
5534HREF="libxml-tree.html#XMLCHAR"
5535>xmlChar</A
5536> *val);</PRE
5537></TD
5538></TR
5539></TABLE
5540><P
5541>a case-ignoring strstr for xmlChar's</P
5542><P
5543></P
5544><DIV
5545CLASS="INFORMALTABLE"
5546><P
5547></P
5548><TABLE
5549BORDER="0"
5550WIDTH="100%"
5551BGCOLOR="#FFD0D0"
5552CELLSPACING="0"
5553CELLPADDING="4"
5554CLASS="CALSTABLE"
5555><TR
5556><TD
5557WIDTH="20%"
5558ALIGN="RIGHT"
5559VALIGN="TOP"
5560><TT
5561CLASS="PARAMETER"
5562><I
5563>str</I
5564></TT
5565>&nbsp;:</TD
5566><TD
5567WIDTH="80%"
5568ALIGN="LEFT"
5569VALIGN="TOP"
5570>  the xmlChar * array (haystack)</TD
5571></TR
5572><TR
5573><TD
5574WIDTH="20%"
5575ALIGN="RIGHT"
5576VALIGN="TOP"
5577><TT
5578CLASS="PARAMETER"
5579><I
5580>val</I
5581></TT
5582>&nbsp;:</TD
5583><TD
5584WIDTH="80%"
5585ALIGN="LEFT"
5586VALIGN="TOP"
5587>  the xmlChar to search (needle)</TD
5588></TR
5589><TR
5590><TD
5591WIDTH="20%"
5592ALIGN="RIGHT"
5593VALIGN="TOP"
5594><I
5595CLASS="EMPHASIS"
5596>Returns</I
5597> :</TD
5598><TD
5599WIDTH="80%"
5600ALIGN="LEFT"
5601VALIGN="TOP"
5602>the xmlChar * for the first occurence or NULL.</TD
5603></TR
5604></TABLE
5605><P
5606></P
5607></DIV
5608></DIV
5609><HR><DIV
5610CLASS="REFSECT2"
5611><A
5612NAME="AEN1317"
5613></A
5614><H3
5615><A
5616NAME="XMLSTRCMP"
5617></A
5618>xmlStrcmp ()</H3
5619><TABLE
5620BORDER="0"
5621BGCOLOR="#D6E8FF"
5622WIDTH="100%"
5623CELLPADDING="6"
5624><TR
5625><TD
5626><PRE
5627CLASS="PROGRAMLISTING"
5628>int         xmlStrcmp                       (const <A
5629HREF="libxml-tree.html#XMLCHAR"
5630>xmlChar</A
5631> *str1,
5632                                             const <A
5633HREF="libxml-tree.html#XMLCHAR"
5634>xmlChar</A
5635> *str2);</PRE
5636></TD
5637></TR
5638></TABLE
5639><P
5640>a strcmp for xmlChar's</P
5641><P
5642></P
5643><DIV
5644CLASS="INFORMALTABLE"
5645><P
5646></P
5647><TABLE
5648BORDER="0"
5649WIDTH="100%"
5650BGCOLOR="#FFD0D0"
5651CELLSPACING="0"
5652CELLPADDING="4"
5653CLASS="CALSTABLE"
5654><TR
5655><TD
5656WIDTH="20%"
5657ALIGN="RIGHT"
5658VALIGN="TOP"
5659><TT
5660CLASS="PARAMETER"
5661><I
5662>str1</I
5663></TT
5664>&nbsp;:</TD
5665><TD
5666WIDTH="80%"
5667ALIGN="LEFT"
5668VALIGN="TOP"
5669>  the first xmlChar *</TD
5670></TR
5671><TR
5672><TD
5673WIDTH="20%"
5674ALIGN="RIGHT"
5675VALIGN="TOP"
5676><TT
5677CLASS="PARAMETER"
5678><I
5679>str2</I
5680></TT
5681>&nbsp;:</TD
5682><TD
5683WIDTH="80%"
5684ALIGN="LEFT"
5685VALIGN="TOP"
5686>  the second xmlChar *</TD
5687></TR
5688><TR
5689><TD
5690WIDTH="20%"
5691ALIGN="RIGHT"
5692VALIGN="TOP"
5693><I
5694CLASS="EMPHASIS"
5695>Returns</I
5696> :</TD
5697><TD
5698WIDTH="80%"
5699ALIGN="LEFT"
5700VALIGN="TOP"
5701>the integer result of the comparison</TD
5702></TR
5703></TABLE
5704><P
5705></P
5706></DIV
5707></DIV
5708><HR><DIV
5709CLASS="REFSECT2"
5710><A
5711NAME="AEN1342"
5712></A
5713><H3
5714><A
5715NAME="XMLSTRNCMP"
5716></A
5717>xmlStrncmp ()</H3
5718><TABLE
5719BORDER="0"
5720BGCOLOR="#D6E8FF"
5721WIDTH="100%"
5722CELLPADDING="6"
5723><TR
5724><TD
5725><PRE
5726CLASS="PROGRAMLISTING"
5727>int         xmlStrncmp                      (const <A
5728HREF="libxml-tree.html#XMLCHAR"
5729>xmlChar</A
5730> *str1,
5731                                             const <A
5732HREF="libxml-tree.html#XMLCHAR"
5733>xmlChar</A
5734> *str2,
5735                                             int len);</PRE
5736></TD
5737></TR
5738></TABLE
5739><P
5740>a strncmp for xmlChar's</P
5741><P
5742></P
5743><DIV
5744CLASS="INFORMALTABLE"
5745><P
5746></P
5747><TABLE
5748BORDER="0"
5749WIDTH="100%"
5750BGCOLOR="#FFD0D0"
5751CELLSPACING="0"
5752CELLPADDING="4"
5753CLASS="CALSTABLE"
5754><TR
5755><TD
5756WIDTH="20%"
5757ALIGN="RIGHT"
5758VALIGN="TOP"
5759><TT
5760CLASS="PARAMETER"
5761><I
5762>str1</I
5763></TT
5764>&nbsp;:</TD
5765><TD
5766WIDTH="80%"
5767ALIGN="LEFT"
5768VALIGN="TOP"
5769>  the first xmlChar *</TD
5770></TR
5771><TR
5772><TD
5773WIDTH="20%"
5774ALIGN="RIGHT"
5775VALIGN="TOP"
5776><TT
5777CLASS="PARAMETER"
5778><I
5779>str2</I
5780></TT
5781>&nbsp;:</TD
5782><TD
5783WIDTH="80%"
5784ALIGN="LEFT"
5785VALIGN="TOP"
5786>  the second xmlChar *</TD
5787></TR
5788><TR
5789><TD
5790WIDTH="20%"
5791ALIGN="RIGHT"
5792VALIGN="TOP"
5793><TT
5794CLASS="PARAMETER"
5795><I
5796>len</I
5797></TT
5798>&nbsp;:</TD
5799><TD
5800WIDTH="80%"
5801ALIGN="LEFT"
5802VALIGN="TOP"
5803>  the max comparison length</TD
5804></TR
5805><TR
5806><TD
5807WIDTH="20%"
5808ALIGN="RIGHT"
5809VALIGN="TOP"
5810><I
5811CLASS="EMPHASIS"
5812>Returns</I
5813> :</TD
5814><TD
5815WIDTH="80%"
5816ALIGN="LEFT"
5817VALIGN="TOP"
5818>the integer result of the comparison</TD
5819></TR
5820></TABLE
5821><P
5822></P
5823></DIV
5824></DIV
5825><HR><DIV
5826CLASS="REFSECT2"
5827><A
5828NAME="AEN1371"
5829></A
5830><H3
5831><A
5832NAME="XMLSTRCASECMP"
5833></A
5834>xmlStrcasecmp ()</H3
5835><TABLE
5836BORDER="0"
5837BGCOLOR="#D6E8FF"
5838WIDTH="100%"
5839CELLPADDING="6"
5840><TR
5841><TD
5842><PRE
5843CLASS="PROGRAMLISTING"
5844>int         xmlStrcasecmp                   (const <A
5845HREF="libxml-tree.html#XMLCHAR"
5846>xmlChar</A
5847> *str1,
5848                                             const <A
5849HREF="libxml-tree.html#XMLCHAR"
5850>xmlChar</A
5851> *str2);</PRE
5852></TD
5853></TR
5854></TABLE
5855><P
5856>a strcasecmp for xmlChar's</P
5857><P
5858></P
5859><DIV
5860CLASS="INFORMALTABLE"
5861><P
5862></P
5863><TABLE
5864BORDER="0"
5865WIDTH="100%"
5866BGCOLOR="#FFD0D0"
5867CELLSPACING="0"
5868CELLPADDING="4"
5869CLASS="CALSTABLE"
5870><TR
5871><TD
5872WIDTH="20%"
5873ALIGN="RIGHT"
5874VALIGN="TOP"
5875><TT
5876CLASS="PARAMETER"
5877><I
5878>str1</I
5879></TT
5880>&nbsp;:</TD
5881><TD
5882WIDTH="80%"
5883ALIGN="LEFT"
5884VALIGN="TOP"
5885>  the first xmlChar *</TD
5886></TR
5887><TR
5888><TD
5889WIDTH="20%"
5890ALIGN="RIGHT"
5891VALIGN="TOP"
5892><TT
5893CLASS="PARAMETER"
5894><I
5895>str2</I
5896></TT
5897>&nbsp;:</TD
5898><TD
5899WIDTH="80%"
5900ALIGN="LEFT"
5901VALIGN="TOP"
5902>  the second xmlChar *</TD
5903></TR
5904><TR
5905><TD
5906WIDTH="20%"
5907ALIGN="RIGHT"
5908VALIGN="TOP"
5909><I
5910CLASS="EMPHASIS"
5911>Returns</I
5912> :</TD
5913><TD
5914WIDTH="80%"
5915ALIGN="LEFT"
5916VALIGN="TOP"
5917>the integer result of the comparison</TD
5918></TR
5919></TABLE
5920><P
5921></P
5922></DIV
5923></DIV
5924><HR><DIV
5925CLASS="REFSECT2"
5926><A
5927NAME="AEN1396"
5928></A
5929><H3
5930><A
5931NAME="XMLSTRNCASECMP"
5932></A
5933>xmlStrncasecmp ()</H3
5934><TABLE
5935BORDER="0"
5936BGCOLOR="#D6E8FF"
5937WIDTH="100%"
5938CELLPADDING="6"
5939><TR
5940><TD
5941><PRE
5942CLASS="PROGRAMLISTING"
5943>int         xmlStrncasecmp                  (const <A
5944HREF="libxml-tree.html#XMLCHAR"
5945>xmlChar</A
5946> *str1,
5947                                             const <A
5948HREF="libxml-tree.html#XMLCHAR"
5949>xmlChar</A
5950> *str2,
5951                                             int len);</PRE
5952></TD
5953></TR
5954></TABLE
5955><P
5956>a strncasecmp for xmlChar's</P
5957><P
5958></P
5959><DIV
5960CLASS="INFORMALTABLE"
5961><P
5962></P
5963><TABLE
5964BORDER="0"
5965WIDTH="100%"
5966BGCOLOR="#FFD0D0"
5967CELLSPACING="0"
5968CELLPADDING="4"
5969CLASS="CALSTABLE"
5970><TR
5971><TD
5972WIDTH="20%"
5973ALIGN="RIGHT"
5974VALIGN="TOP"
5975><TT
5976CLASS="PARAMETER"
5977><I
5978>str1</I
5979></TT
5980>&nbsp;:</TD
5981><TD
5982WIDTH="80%"
5983ALIGN="LEFT"
5984VALIGN="TOP"
5985>  the first xmlChar *</TD
5986></TR
5987><TR
5988><TD
5989WIDTH="20%"
5990ALIGN="RIGHT"
5991VALIGN="TOP"
5992><TT
5993CLASS="PARAMETER"
5994><I
5995>str2</I
5996></TT
5997>&nbsp;:</TD
5998><TD
5999WIDTH="80%"
6000ALIGN="LEFT"
6001VALIGN="TOP"
6002>  the second xmlChar *</TD
6003></TR
6004><TR
6005><TD
6006WIDTH="20%"
6007ALIGN="RIGHT"
6008VALIGN="TOP"
6009><TT
6010CLASS="PARAMETER"
6011><I
6012>len</I
6013></TT
6014>&nbsp;:</TD
6015><TD
6016WIDTH="80%"
6017ALIGN="LEFT"
6018VALIGN="TOP"
6019>  the max comparison length</TD
6020></TR
6021><TR
6022><TD
6023WIDTH="20%"
6024ALIGN="RIGHT"
6025VALIGN="TOP"
6026><I
6027CLASS="EMPHASIS"
6028>Returns</I
6029> :</TD
6030><TD
6031WIDTH="80%"
6032ALIGN="LEFT"
6033VALIGN="TOP"
6034>the integer result of the comparison</TD
6035></TR
6036></TABLE
6037><P
6038></P
6039></DIV
6040></DIV
6041><HR><DIV
6042CLASS="REFSECT2"
6043><A
6044NAME="AEN1425"
6045></A
6046><H3
6047><A
6048NAME="XMLSTREQUAL"
6049></A
6050>xmlStrEqual ()</H3
6051><TABLE
6052BORDER="0"
6053BGCOLOR="#D6E8FF"
6054WIDTH="100%"
6055CELLPADDING="6"
6056><TR
6057><TD
6058><PRE
6059CLASS="PROGRAMLISTING"
6060>int         xmlStrEqual                     (const <A
6061HREF="libxml-tree.html#XMLCHAR"
6062>xmlChar</A
6063> *str1,
6064                                             const <A
6065HREF="libxml-tree.html#XMLCHAR"
6066>xmlChar</A
6067> *str2);</PRE
6068></TD
6069></TR
6070></TABLE
6071><P
6072>Check if both string are equal of have same content
6073Should be a bit more readable and faster than <A
6074HREF="libxml-parser.html#XMLSTREQUAL"
6075>xmlStrEqual</A
6076>()</P
6077><P
6078></P
6079><DIV
6080CLASS="INFORMALTABLE"
6081><P
6082></P
6083><TABLE
6084BORDER="0"
6085WIDTH="100%"
6086BGCOLOR="#FFD0D0"
6087CELLSPACING="0"
6088CELLPADDING="4"
6089CLASS="CALSTABLE"
6090><TR
6091><TD
6092WIDTH="20%"
6093ALIGN="RIGHT"
6094VALIGN="TOP"
6095><TT
6096CLASS="PARAMETER"
6097><I
6098>str1</I
6099></TT
6100>&nbsp;:</TD
6101><TD
6102WIDTH="80%"
6103ALIGN="LEFT"
6104VALIGN="TOP"
6105>  the first xmlChar *</TD
6106></TR
6107><TR
6108><TD
6109WIDTH="20%"
6110ALIGN="RIGHT"
6111VALIGN="TOP"
6112><TT
6113CLASS="PARAMETER"
6114><I
6115>str2</I
6116></TT
6117>&nbsp;:</TD
6118><TD
6119WIDTH="80%"
6120ALIGN="LEFT"
6121VALIGN="TOP"
6122>  the second xmlChar *</TD
6123></TR
6124><TR
6125><TD
6126WIDTH="20%"
6127ALIGN="RIGHT"
6128VALIGN="TOP"
6129><I
6130CLASS="EMPHASIS"
6131>Returns</I
6132> :</TD
6133><TD
6134WIDTH="80%"
6135ALIGN="LEFT"
6136VALIGN="TOP"
6137>1 if they are equal, 0 if they are different</TD
6138></TR
6139></TABLE
6140><P
6141></P
6142></DIV
6143></DIV
6144><HR><DIV
6145CLASS="REFSECT2"
6146><A
6147NAME="AEN1451"
6148></A
6149><H3
6150><A
6151NAME="XMLSTRLEN"
6152></A
6153>xmlStrlen ()</H3
6154><TABLE
6155BORDER="0"
6156BGCOLOR="#D6E8FF"
6157WIDTH="100%"
6158CELLPADDING="6"
6159><TR
6160><TD
6161><PRE
6162CLASS="PROGRAMLISTING"
6163>int         xmlStrlen                       (const <A
6164HREF="libxml-tree.html#XMLCHAR"
6165>xmlChar</A
6166> *str);</PRE
6167></TD
6168></TR
6169></TABLE
6170><P
6171>length of a xmlChar's string</P
6172><P
6173></P
6174><DIV
6175CLASS="INFORMALTABLE"
6176><P
6177></P
6178><TABLE
6179BORDER="0"
6180WIDTH="100%"
6181BGCOLOR="#FFD0D0"
6182CELLSPACING="0"
6183CELLPADDING="4"
6184CLASS="CALSTABLE"
6185><TR
6186><TD
6187WIDTH="20%"
6188ALIGN="RIGHT"
6189VALIGN="TOP"
6190><TT
6191CLASS="PARAMETER"
6192><I
6193>str</I
6194></TT
6195>&nbsp;:</TD
6196><TD
6197WIDTH="80%"
6198ALIGN="LEFT"
6199VALIGN="TOP"
6200>  the xmlChar * array</TD
6201></TR
6202><TR
6203><TD
6204WIDTH="20%"
6205ALIGN="RIGHT"
6206VALIGN="TOP"
6207><I
6208CLASS="EMPHASIS"
6209>Returns</I
6210> :</TD
6211><TD
6212WIDTH="80%"
6213ALIGN="LEFT"
6214VALIGN="TOP"
6215>the number of xmlChar contained in the ARRAY.</TD
6216></TR
6217></TABLE
6218><P
6219></P
6220></DIV
6221></DIV
6222><HR><DIV
6223CLASS="REFSECT2"
6224><A
6225NAME="AEN1471"
6226></A
6227><H3
6228><A
6229NAME="XMLSTRCAT"
6230></A
6231>xmlStrcat ()</H3
6232><TABLE
6233BORDER="0"
6234BGCOLOR="#D6E8FF"
6235WIDTH="100%"
6236CELLPADDING="6"
6237><TR
6238><TD
6239><PRE
6240CLASS="PROGRAMLISTING"
6241><A
6242HREF="libxml-tree.html#XMLCHAR"
6243>xmlChar</A
6244>*    xmlStrcat                       (<A
6245HREF="libxml-tree.html#XMLCHAR"
6246>xmlChar</A
6247> *cur,
6248                                             const <A
6249HREF="libxml-tree.html#XMLCHAR"
6250>xmlChar</A
6251> *add);</PRE
6252></TD
6253></TR
6254></TABLE
6255><P
6256>a strcat for array of xmlChar's. Since they are supposed to be
6257encoded in UTF-8 or an encoding with 8bit based chars, we assume
6258a termination mark of '0'.</P
6259><P
6260></P
6261><DIV
6262CLASS="INFORMALTABLE"
6263><P
6264></P
6265><TABLE
6266BORDER="0"
6267WIDTH="100%"
6268BGCOLOR="#FFD0D0"
6269CELLSPACING="0"
6270CELLPADDING="4"
6271CLASS="CALSTABLE"
6272><TR
6273><TD
6274WIDTH="20%"
6275ALIGN="RIGHT"
6276VALIGN="TOP"
6277><TT
6278CLASS="PARAMETER"
6279><I
6280>cur</I
6281></TT
6282>&nbsp;:</TD
6283><TD
6284WIDTH="80%"
6285ALIGN="LEFT"
6286VALIGN="TOP"
6287>  the original xmlChar * array</TD
6288></TR
6289><TR
6290><TD
6291WIDTH="20%"
6292ALIGN="RIGHT"
6293VALIGN="TOP"
6294><TT
6295CLASS="PARAMETER"
6296><I
6297>add</I
6298></TT
6299>&nbsp;:</TD
6300><TD
6301WIDTH="80%"
6302ALIGN="LEFT"
6303VALIGN="TOP"
6304>  the xmlChar * array added</TD
6305></TR
6306><TR
6307><TD
6308WIDTH="20%"
6309ALIGN="RIGHT"
6310VALIGN="TOP"
6311><I
6312CLASS="EMPHASIS"
6313>Returns</I
6314> :</TD
6315><TD
6316WIDTH="80%"
6317ALIGN="LEFT"
6318VALIGN="TOP"
6319>a new xmlChar * containing the concatenated string.</TD
6320></TR
6321></TABLE
6322><P
6323></P
6324></DIV
6325></DIV
6326><HR><DIV
6327CLASS="REFSECT2"
6328><A
6329NAME="AEN1497"
6330></A
6331><H3
6332><A
6333NAME="XMLSTRNCAT"
6334></A
6335>xmlStrncat ()</H3
6336><TABLE
6337BORDER="0"
6338BGCOLOR="#D6E8FF"
6339WIDTH="100%"
6340CELLPADDING="6"
6341><TR
6342><TD
6343><PRE
6344CLASS="PROGRAMLISTING"
6345><A
6346HREF="libxml-tree.html#XMLCHAR"
6347>xmlChar</A
6348>*    xmlStrncat                      (<A
6349HREF="libxml-tree.html#XMLCHAR"
6350>xmlChar</A
6351> *cur,
6352                                             const <A
6353HREF="libxml-tree.html#XMLCHAR"
6354>xmlChar</A
6355> *add,
6356                                             int len);</PRE
6357></TD
6358></TR
6359></TABLE
6360><P
6361>a strncat for array of xmlChar's</P
6362><P
6363></P
6364><DIV
6365CLASS="INFORMALTABLE"
6366><P
6367></P
6368><TABLE
6369BORDER="0"
6370WIDTH="100%"
6371BGCOLOR="#FFD0D0"
6372CELLSPACING="0"
6373CELLPADDING="4"
6374CLASS="CALSTABLE"
6375><TR
6376><TD
6377WIDTH="20%"
6378ALIGN="RIGHT"
6379VALIGN="TOP"
6380><TT
6381CLASS="PARAMETER"
6382><I
6383>cur</I
6384></TT
6385>&nbsp;:</TD
6386><TD
6387WIDTH="80%"
6388ALIGN="LEFT"
6389VALIGN="TOP"
6390>  the original xmlChar * array</TD
6391></TR
6392><TR
6393><TD
6394WIDTH="20%"
6395ALIGN="RIGHT"
6396VALIGN="TOP"
6397><TT
6398CLASS="PARAMETER"
6399><I
6400>add</I
6401></TT
6402>&nbsp;:</TD
6403><TD
6404WIDTH="80%"
6405ALIGN="LEFT"
6406VALIGN="TOP"
6407>  the xmlChar * array added</TD
6408></TR
6409><TR
6410><TD
6411WIDTH="20%"
6412ALIGN="RIGHT"
6413VALIGN="TOP"
6414><TT
6415CLASS="PARAMETER"
6416><I
6417>len</I
6418></TT
6419>&nbsp;:</TD
6420><TD
6421WIDTH="80%"
6422ALIGN="LEFT"
6423VALIGN="TOP"
6424>  the length of <TT
6425CLASS="PARAMETER"
6426><I
6427>add</I
6428></TT
6429></TD
6430></TR
6431><TR
6432><TD
6433WIDTH="20%"
6434ALIGN="RIGHT"
6435VALIGN="TOP"
6436><I
6437CLASS="EMPHASIS"
6438>Returns</I
6439> :</TD
6440><TD
6441WIDTH="80%"
6442ALIGN="LEFT"
6443VALIGN="TOP"
6444>a new xmlChar * containing the concatenated string.</TD
6445></TR
6446></TABLE
6447><P
6448></P
6449></DIV
6450></DIV
6451><HR><DIV
6452CLASS="REFSECT2"
6453><A
6454NAME="AEN1528"
6455></A
6456><H3
6457><A
6458NAME="XMLPARSEDOC"
6459></A
6460>xmlParseDoc ()</H3
6461><TABLE
6462BORDER="0"
6463BGCOLOR="#D6E8FF"
6464WIDTH="100%"
6465CELLPADDING="6"
6466><TR
6467><TD
6468><PRE
6469CLASS="PROGRAMLISTING"
6470><A
6471HREF="libxml-tree.html#XMLDOCPTR"
6472>xmlDocPtr</A
6473>   xmlParseDoc                     (<A
6474HREF="libxml-tree.html#XMLCHAR"
6475>xmlChar</A
6476> *cur);</PRE
6477></TD
6478></TR
6479></TABLE
6480><P
6481>parse an XML in-memory document and build a tree.</P
6482><P
6483></P
6484><DIV
6485CLASS="INFORMALTABLE"
6486><P
6487></P
6488><TABLE
6489BORDER="0"
6490WIDTH="100%"
6491BGCOLOR="#FFD0D0"
6492CELLSPACING="0"
6493CELLPADDING="4"
6494CLASS="CALSTABLE"
6495><TR
6496><TD
6497WIDTH="20%"
6498ALIGN="RIGHT"
6499VALIGN="TOP"
6500><TT
6501CLASS="PARAMETER"
6502><I
6503>cur</I
6504></TT
6505>&nbsp;:</TD
6506><TD
6507WIDTH="80%"
6508ALIGN="LEFT"
6509VALIGN="TOP"
6510>  a pointer to an array of xmlChar</TD
6511></TR
6512><TR
6513><TD
6514WIDTH="20%"
6515ALIGN="RIGHT"
6516VALIGN="TOP"
6517><I
6518CLASS="EMPHASIS"
6519>Returns</I
6520> :</TD
6521><TD
6522WIDTH="80%"
6523ALIGN="LEFT"
6524VALIGN="TOP"
6525>the resulting document tree</TD
6526></TR
6527></TABLE
6528><P
6529></P
6530></DIV
6531></DIV
6532><HR><DIV
6533CLASS="REFSECT2"
6534><A
6535NAME="AEN1549"
6536></A
6537><H3
6538><A
6539NAME="XMLPARSEMEMORY"
6540></A
6541>xmlParseMemory ()</H3
6542><TABLE
6543BORDER="0"
6544BGCOLOR="#D6E8FF"
6545WIDTH="100%"
6546CELLPADDING="6"
6547><TR
6548><TD
6549><PRE
6550CLASS="PROGRAMLISTING"
6551><A
6552HREF="libxml-tree.html#XMLDOCPTR"
6553>xmlDocPtr</A
6554>   xmlParseMemory                  (char *buffer,
6555                                             int size);</PRE
6556></TD
6557></TR
6558></TABLE
6559><P
6560>parse an XML in-memory block and build a tree.</P
6561><P
6562></P
6563><DIV
6564CLASS="INFORMALTABLE"
6565><P
6566></P
6567><TABLE
6568BORDER="0"
6569WIDTH="100%"
6570BGCOLOR="#FFD0D0"
6571CELLSPACING="0"
6572CELLPADDING="4"
6573CLASS="CALSTABLE"
6574><TR
6575><TD
6576WIDTH="20%"
6577ALIGN="RIGHT"
6578VALIGN="TOP"
6579><TT
6580CLASS="PARAMETER"
6581><I
6582>buffer</I
6583></TT
6584>&nbsp;:</TD
6585><TD
6586WIDTH="80%"
6587ALIGN="LEFT"
6588VALIGN="TOP"
6589>  an pointer to a char array</TD
6590></TR
6591><TR
6592><TD
6593WIDTH="20%"
6594ALIGN="RIGHT"
6595VALIGN="TOP"
6596><TT
6597CLASS="PARAMETER"
6598><I
6599>size</I
6600></TT
6601>&nbsp;:</TD
6602><TD
6603WIDTH="80%"
6604ALIGN="LEFT"
6605VALIGN="TOP"
6606>  the size of the array</TD
6607></TR
6608><TR
6609><TD
6610WIDTH="20%"
6611ALIGN="RIGHT"
6612VALIGN="TOP"
6613><I
6614CLASS="EMPHASIS"
6615>Returns</I
6616> :</TD
6617><TD
6618WIDTH="80%"
6619ALIGN="LEFT"
6620VALIGN="TOP"
6621>the resulting document tree</TD
6622></TR
6623></TABLE
6624><P
6625></P
6626></DIV
6627></DIV
6628><HR><DIV
6629CLASS="REFSECT2"
6630><A
6631NAME="AEN1573"
6632></A
6633><H3
6634><A
6635NAME="XMLPARSEFILE"
6636></A
6637>xmlParseFile ()</H3
6638><TABLE
6639BORDER="0"
6640BGCOLOR="#D6E8FF"
6641WIDTH="100%"
6642CELLPADDING="6"
6643><TR
6644><TD
6645><PRE
6646CLASS="PROGRAMLISTING"
6647><A
6648HREF="libxml-tree.html#XMLDOCPTR"
6649>xmlDocPtr</A
6650>   xmlParseFile                    (const char *filename);</PRE
6651></TD
6652></TR
6653></TABLE
6654><P
6655>parse an XML file and build a tree. Automatic support for ZLIB/Compress
6656compressed document is provided by default if found at compile-time.</P
6657><P
6658></P
6659><DIV
6660CLASS="INFORMALTABLE"
6661><P
6662></P
6663><TABLE
6664BORDER="0"
6665WIDTH="100%"
6666BGCOLOR="#FFD0D0"
6667CELLSPACING="0"
6668CELLPADDING="4"
6669CLASS="CALSTABLE"
6670><TR
6671><TD
6672WIDTH="20%"
6673ALIGN="RIGHT"
6674VALIGN="TOP"
6675><TT
6676CLASS="PARAMETER"
6677><I
6678>filename</I
6679></TT
6680>&nbsp;:</TD
6681><TD
6682WIDTH="80%"
6683ALIGN="LEFT"
6684VALIGN="TOP"
6685>  the filename</TD
6686></TR
6687><TR
6688><TD
6689WIDTH="20%"
6690ALIGN="RIGHT"
6691VALIGN="TOP"
6692><I
6693CLASS="EMPHASIS"
6694>Returns</I
6695> :</TD
6696><TD
6697WIDTH="80%"
6698ALIGN="LEFT"
6699VALIGN="TOP"
6700>the resulting document tree</TD
6701></TR
6702></TABLE
6703><P
6704></P
6705></DIV
6706></DIV
6707><HR><DIV
6708CLASS="REFSECT2"
6709><A
6710NAME="AEN1593"
6711></A
6712><H3
6713><A
6714NAME="XMLSUBSTITUTEENTITIESDEFAULT"
6715></A
6716>xmlSubstituteEntitiesDefault ()</H3
6717><TABLE
6718BORDER="0"
6719BGCOLOR="#D6E8FF"
6720WIDTH="100%"
6721CELLPADDING="6"
6722><TR
6723><TD
6724><PRE
6725CLASS="PROGRAMLISTING"
6726>int         xmlSubstituteEntitiesDefault    (int val);</PRE
6727></TD
6728></TR
6729></TABLE
6730><P
6731>Set and return the previous value for default entity support.
6732Initially the parser always keep entity references instead of substituting
6733entity values in the output. This function has to be used to change the
6734default parser behaviour
6735SAX::<GTKDOCLINK
6736HREF="SUBTITUTEENTITIES"
6737>subtituteEntities</GTKDOCLINK
6738>() has to be used for changing that on a file by
6739file basis.</P
6740><P
6741></P
6742><DIV
6743CLASS="INFORMALTABLE"
6744><P
6745></P
6746><TABLE
6747BORDER="0"
6748WIDTH="100%"
6749BGCOLOR="#FFD0D0"
6750CELLSPACING="0"
6751CELLPADDING="4"
6752CLASS="CALSTABLE"
6753><TR
6754><TD
6755WIDTH="20%"
6756ALIGN="RIGHT"
6757VALIGN="TOP"
6758><TT
6759CLASS="PARAMETER"
6760><I
6761>val</I
6762></TT
6763>&nbsp;:</TD
6764><TD
6765WIDTH="80%"
6766ALIGN="LEFT"
6767VALIGN="TOP"
6768>  int 0 or 1 </TD
6769></TR
6770><TR
6771><TD
6772WIDTH="20%"
6773ALIGN="RIGHT"
6774VALIGN="TOP"
6775><I
6776CLASS="EMPHASIS"
6777>Returns</I
6778> :</TD
6779><TD
6780WIDTH="80%"
6781ALIGN="LEFT"
6782VALIGN="TOP"
6783>the last value for 0 for no substitution, 1 for substitution.</TD
6784></TR
6785></TABLE
6786><P
6787></P
6788></DIV
6789></DIV
6790><HR><DIV
6791CLASS="REFSECT2"
6792><A
6793NAME="AEN1613"
6794></A
6795><H3
6796><A
6797NAME="XMLKEEPBLANKSDEFAULT"
6798></A
6799>xmlKeepBlanksDefault ()</H3
6800><TABLE
6801BORDER="0"
6802BGCOLOR="#D6E8FF"
6803WIDTH="100%"
6804CELLPADDING="6"
6805><TR
6806><TD
6807><PRE
6808CLASS="PROGRAMLISTING"
6809>int         xmlKeepBlanksDefault            (int val);</PRE
6810></TD
6811></TR
6812></TABLE
6813><P
6814>Set and return the previous value for default blanks text nodes support.
6815The 1.x version of the parser used an heuristic to try to detect
6816ignorable white spaces. As a result the SAX callback was generating
6817<A
6818HREF="libxml-sax.html#IGNORABLEWHITESPACE"
6819>ignorableWhitespace</A
6820>() callbacks instead of <A
6821HREF="libxml-sax.html#CHARACTERS"
6822>characters</A
6823>() one, and when
6824using the DOM output text nodes containing those blanks were not generated.
6825The 2.x and later version will switch to the XML standard way and
6826<A
6827HREF="libxml-sax.html#IGNORABLEWHITESPACE"
6828>ignorableWhitespace</A
6829>() are only generated when running the parser in
6830validating mode and when the current element doesn't allow CDATA or
6831mixed content.
6832This function is provided as a way to force the standard behaviour 
6833on 1.X libs and to switch back to the old mode for compatibility when
6834running 1.X client code on 2.X . Upgrade of 1.X code should be done
6835by using <A
6836HREF="libxml-tree.html#XMLISBLANKNODE"
6837>xmlIsBlankNode</A
6838>() commodity function to detect the "empty"
6839nodes generated.
6840This value also affect autogeneration of indentation when saving code
6841if blanks sections are kept, indentation is not generated.</P
6842><P
6843></P
6844><DIV
6845CLASS="INFORMALTABLE"
6846><P
6847></P
6848><TABLE
6849BORDER="0"
6850WIDTH="100%"
6851BGCOLOR="#FFD0D0"
6852CELLSPACING="0"
6853CELLPADDING="4"
6854CLASS="CALSTABLE"
6855><TR
6856><TD
6857WIDTH="20%"
6858ALIGN="RIGHT"
6859VALIGN="TOP"
6860><TT
6861CLASS="PARAMETER"
6862><I
6863>val</I
6864></TT
6865>&nbsp;:</TD
6866><TD
6867WIDTH="80%"
6868ALIGN="LEFT"
6869VALIGN="TOP"
6870>  int 0 or 1 </TD
6871></TR
6872><TR
6873><TD
6874WIDTH="20%"
6875ALIGN="RIGHT"
6876VALIGN="TOP"
6877><I
6878CLASS="EMPHASIS"
6879>Returns</I
6880> :</TD
6881><TD
6882WIDTH="80%"
6883ALIGN="LEFT"
6884VALIGN="TOP"
6885>the last value for 0 for no substitution, 1 for substitution.</TD
6886></TR
6887></TABLE
6888><P
6889></P
6890></DIV
6891></DIV
6892><HR><DIV
6893CLASS="REFSECT2"
6894><A
6895NAME="AEN1636"
6896></A
6897><H3
6898><A
6899NAME="XMLSTOPPARSER"
6900></A
6901>xmlStopParser ()</H3
6902><TABLE
6903BORDER="0"
6904BGCOLOR="#D6E8FF"
6905WIDTH="100%"
6906CELLPADDING="6"
6907><TR
6908><TD
6909><PRE
6910CLASS="PROGRAMLISTING"
6911>void        xmlStopParser                   (<A
6912HREF="libxml-parser.html#XMLPARSERCTXTPTR"
6913>xmlParserCtxtPtr</A
6914> ctxt);</PRE
6915></TD
6916></TR
6917></TABLE
6918><P
6919>Blocks further parser processing</P
6920><P
6921></P
6922><DIV
6923CLASS="INFORMALTABLE"
6924><P
6925></P
6926><TABLE
6927BORDER="0"
6928WIDTH="100%"
6929BGCOLOR="#FFD0D0"
6930CELLSPACING="0"
6931CELLPADDING="4"
6932CLASS="CALSTABLE"
6933><TR
6934><TD
6935WIDTH="20%"
6936ALIGN="RIGHT"
6937VALIGN="TOP"
6938><TT
6939CLASS="PARAMETER"
6940><I
6941>ctxt</I
6942></TT
6943>&nbsp;:</TD
6944><TD
6945WIDTH="80%"
6946ALIGN="LEFT"
6947VALIGN="TOP"
6948>  an XML parser context</TD
6949></TR
6950></TABLE
6951><P
6952></P
6953></DIV
6954></DIV
6955><HR><DIV
6956CLASS="REFSECT2"
6957><A
6958NAME="AEN1652"
6959></A
6960><H3
6961><A
6962NAME="XMLPEDANTICPARSERDEFAULT"
6963></A
6964>xmlPedanticParserDefault ()</H3
6965><TABLE
6966BORDER="0"
6967BGCOLOR="#D6E8FF"
6968WIDTH="100%"
6969CELLPADDING="6"
6970><TR
6971><TD
6972><PRE
6973CLASS="PROGRAMLISTING"
6974>int         xmlPedanticParserDefault        (int val);</PRE
6975></TD
6976></TR
6977></TABLE
6978><P
6979>Set and return the previous value for enabling pedantic warnings.</P
6980><P
6981></P
6982><DIV
6983CLASS="INFORMALTABLE"
6984><P
6985></P
6986><TABLE
6987BORDER="0"
6988WIDTH="100%"
6989BGCOLOR="#FFD0D0"
6990CELLSPACING="0"
6991CELLPADDING="4"
6992CLASS="CALSTABLE"
6993><TR
6994><TD
6995WIDTH="20%"
6996ALIGN="RIGHT"
6997VALIGN="TOP"
6998><TT
6999CLASS="PARAMETER"
7000><I
7001>val</I
7002></TT
7003>&nbsp;:</TD
7004><TD
7005WIDTH="80%"
7006ALIGN="LEFT"
7007VALIGN="TOP"
7008>  int 0 or 1 </TD
7009></TR
7010><TR
7011><TD
7012WIDTH="20%"
7013ALIGN="RIGHT"
7014VALIGN="TOP"
7015><I
7016CLASS="EMPHASIS"
7017>Returns</I
7018> :</TD
7019><TD
7020WIDTH="80%"
7021ALIGN="LEFT"
7022VALIGN="TOP"
7023>the last value for 0 for no substitution, 1 for substitution.</TD
7024></TR
7025></TABLE
7026><P
7027></P
7028></DIV
7029></DIV
7030><HR><DIV
7031CLASS="REFSECT2"
7032><A
7033NAME="AEN1671"
7034></A
7035><H3
7036><A
7037NAME="XMLRECOVERDOC"
7038></A
7039>xmlRecoverDoc ()</H3
7040><TABLE
7041BORDER="0"
7042BGCOLOR="#D6E8FF"
7043WIDTH="100%"
7044CELLPADDING="6"
7045><TR
7046><TD
7047><PRE
7048CLASS="PROGRAMLISTING"
7049><A
7050HREF="libxml-tree.html#XMLDOCPTR"
7051>xmlDocPtr</A
7052>   xmlRecoverDoc                   (<A
7053HREF="libxml-tree.html#XMLCHAR"
7054>xmlChar</A
7055> *cur);</PRE
7056></TD
7057></TR
7058></TABLE
7059><P
7060>parse an XML in-memory document and build a tree.
7061In the case the document is not Well Formed, a tree is built anyway</P
7062><P
7063></P
7064><DIV
7065CLASS="INFORMALTABLE"
7066><P
7067></P
7068><TABLE
7069BORDER="0"
7070WIDTH="100%"
7071BGCOLOR="#FFD0D0"
7072CELLSPACING="0"
7073CELLPADDING="4"
7074CLASS="CALSTABLE"
7075><TR
7076><TD
7077WIDTH="20%"
7078ALIGN="RIGHT"
7079VALIGN="TOP"
7080><TT
7081CLASS="PARAMETER"
7082><I
7083>cur</I
7084></TT
7085>&nbsp;:</TD
7086><TD
7087WIDTH="80%"
7088ALIGN="LEFT"
7089VALIGN="TOP"
7090>  a pointer to an array of xmlChar</TD
7091></TR
7092><TR
7093><TD
7094WIDTH="20%"
7095ALIGN="RIGHT"
7096VALIGN="TOP"
7097><I
7098CLASS="EMPHASIS"
7099>Returns</I
7100> :</TD
7101><TD
7102WIDTH="80%"
7103ALIGN="LEFT"
7104VALIGN="TOP"
7105>the resulting document tree</TD
7106></TR
7107></TABLE
7108><P
7109></P
7110></DIV
7111></DIV
7112><HR><DIV
7113CLASS="REFSECT2"
7114><A
7115NAME="AEN1692"
7116></A
7117><H3
7118><A
7119NAME="XMLRECOVERMEMORY"
7120></A
7121>xmlRecoverMemory ()</H3
7122><TABLE
7123BORDER="0"
7124BGCOLOR="#D6E8FF"
7125WIDTH="100%"
7126CELLPADDING="6"
7127><TR
7128><TD
7129><PRE
7130CLASS="PROGRAMLISTING"
7131><A
7132HREF="libxml-tree.html#XMLDOCPTR"
7133>xmlDocPtr</A
7134>   xmlRecoverMemory                (char *buffer,
7135                                             int size);</PRE
7136></TD
7137></TR
7138></TABLE
7139><P
7140>parse an XML in-memory block and build a tree.
7141In the case the document is not Well Formed, a tree is built anyway</P
7142><P
7143></P
7144><DIV
7145CLASS="INFORMALTABLE"
7146><P
7147></P
7148><TABLE
7149BORDER="0"
7150WIDTH="100%"
7151BGCOLOR="#FFD0D0"
7152CELLSPACING="0"
7153CELLPADDING="4"
7154CLASS="CALSTABLE"
7155><TR
7156><TD
7157WIDTH="20%"
7158ALIGN="RIGHT"
7159VALIGN="TOP"
7160><TT
7161CLASS="PARAMETER"
7162><I
7163>buffer</I
7164></TT
7165>&nbsp;:</TD
7166><TD
7167WIDTH="80%"
7168ALIGN="LEFT"
7169VALIGN="TOP"
7170>  an pointer to a char array</TD
7171></TR
7172><TR
7173><TD
7174WIDTH="20%"
7175ALIGN="RIGHT"
7176VALIGN="TOP"
7177><TT
7178CLASS="PARAMETER"
7179><I
7180>size</I
7181></TT
7182>&nbsp;:</TD
7183><TD
7184WIDTH="80%"
7185ALIGN="LEFT"
7186VALIGN="TOP"
7187>  the size of the array</TD
7188></TR
7189><TR
7190><TD
7191WIDTH="20%"
7192ALIGN="RIGHT"
7193VALIGN="TOP"
7194><I
7195CLASS="EMPHASIS"
7196>Returns</I
7197> :</TD
7198><TD
7199WIDTH="80%"
7200ALIGN="LEFT"
7201VALIGN="TOP"
7202>the resulting document tree</TD
7203></TR
7204></TABLE
7205><P
7206></P
7207></DIV
7208></DIV
7209><HR><DIV
7210CLASS="REFSECT2"
7211><A
7212NAME="AEN1716"
7213></A
7214><H3
7215><A
7216NAME="XMLRECOVERFILE"
7217></A
7218>xmlRecoverFile ()</H3
7219><TABLE
7220BORDER="0"
7221BGCOLOR="#D6E8FF"
7222WIDTH="100%"
7223CELLPADDING="6"
7224><TR
7225><TD
7226><PRE
7227CLASS="PROGRAMLISTING"
7228><A
7229HREF="libxml-tree.html#XMLDOCPTR"
7230>xmlDocPtr</A
7231>   xmlRecoverFile                  (const char *filename);</PRE
7232></TD
7233></TR
7234></TABLE
7235><P
7236>parse an XML file and build a tree. Automatic support for ZLIB/Compress
7237compressed document is provided by default if found at compile-time.
7238In the case the document is not Well Formed, a tree is built anyway</P
7239><P
7240></P
7241><DIV
7242CLASS="INFORMALTABLE"
7243><P
7244></P
7245><TABLE
7246BORDER="0"
7247WIDTH="100%"
7248BGCOLOR="#FFD0D0"
7249CELLSPACING="0"
7250CELLPADDING="4"
7251CLASS="CALSTABLE"
7252><TR
7253><TD
7254WIDTH="20%"
7255ALIGN="RIGHT"
7256VALIGN="TOP"
7257><TT
7258CLASS="PARAMETER"
7259><I
7260>filename</I
7261></TT
7262>&nbsp;:</TD
7263><TD
7264WIDTH="80%"
7265ALIGN="LEFT"
7266VALIGN="TOP"
7267>  the filename</TD
7268></TR
7269><TR
7270><TD
7271WIDTH="20%"
7272ALIGN="RIGHT"
7273VALIGN="TOP"
7274><I
7275CLASS="EMPHASIS"
7276>Returns</I
7277> :</TD
7278><TD
7279WIDTH="80%"
7280ALIGN="LEFT"
7281VALIGN="TOP"
7282>the resulting document tree</TD
7283></TR
7284></TABLE
7285><P
7286></P
7287></DIV
7288></DIV
7289><HR><DIV
7290CLASS="REFSECT2"
7291><A
7292NAME="AEN1736"
7293></A
7294><H3
7295><A
7296NAME="XMLPARSEDOCUMENT"
7297></A
7298>xmlParseDocument ()</H3
7299><TABLE
7300BORDER="0"
7301BGCOLOR="#D6E8FF"
7302WIDTH="100%"
7303CELLPADDING="6"
7304><TR
7305><TD
7306><PRE
7307CLASS="PROGRAMLISTING"
7308>int         xmlParseDocument                (<A
7309HREF="libxml-parser.html#XMLPARSERCTXTPTR"
7310>xmlParserCtxtPtr</A
7311> ctxt);</PRE
7312></TD
7313></TR
7314></TABLE
7315><P
7316>parse an XML document (and build a tree if using the standard SAX
7317interface).</P
7318><P
7319>[1] document ::= prolog element Misc*</P
7320><P
7321>[22] prolog ::= XMLDecl? Misc* (doctypedecl Misc*)?</P
7322><P
7323></P
7324><DIV
7325CLASS="INFORMALTABLE"
7326><P
7327></P
7328><TABLE
7329BORDER="0"
7330WIDTH="100%"
7331BGCOLOR="#FFD0D0"
7332CELLSPACING="0"
7333CELLPADDING="4"
7334CLASS="CALSTABLE"
7335><TR
7336><TD
7337WIDTH="20%"
7338ALIGN="RIGHT"
7339VALIGN="TOP"
7340><TT
7341CLASS="PARAMETER"
7342><I
7343>ctxt</I
7344></TT
7345>&nbsp;:</TD
7346><TD
7347WIDTH="80%"
7348ALIGN="LEFT"
7349VALIGN="TOP"
7350>  an XML parser context</TD
7351></TR
7352><TR
7353><TD
7354WIDTH="20%"
7355ALIGN="RIGHT"
7356VALIGN="TOP"
7357><I
7358CLASS="EMPHASIS"
7359>Returns</I
7360> :</TD
7361><TD
7362WIDTH="80%"
7363ALIGN="LEFT"
7364VALIGN="TOP"
7365>0, -1 in case of error. the parser context is augmented
7366as a result of the parsing.</TD
7367></TR
7368></TABLE
7369><P
7370></P
7371></DIV
7372></DIV
7373><HR><DIV
7374CLASS="REFSECT2"
7375><A
7376NAME="AEN1758"
7377></A
7378><H3
7379><A
7380NAME="XMLPARSEEXTPARSEDENT"
7381></A
7382>xmlParseExtParsedEnt ()</H3
7383><TABLE
7384BORDER="0"
7385BGCOLOR="#D6E8FF"
7386WIDTH="100%"
7387CELLPADDING="6"
7388><TR
7389><TD
7390><PRE
7391CLASS="PROGRAMLISTING"
7392>int         xmlParseExtParsedEnt            (<A
7393HREF="libxml-parser.html#XMLPARSERCTXTPTR"
7394>xmlParserCtxtPtr</A
7395> ctxt);</PRE
7396></TD
7397></TR
7398></TABLE
7399><P
7400>parse a genreral parsed entity
7401An external general parsed entity is well-formed if it matches the
7402production labeled extParsedEnt.</P
7403><P
7404>[78] extParsedEnt ::= TextDecl? content</P
7405><P
7406></P
7407><DIV
7408CLASS="INFORMALTABLE"
7409><P
7410></P
7411><TABLE
7412BORDER="0"
7413WIDTH="100%"
7414BGCOLOR="#FFD0D0"
7415CELLSPACING="0"
7416CELLPADDING="4"
7417CLASS="CALSTABLE"
7418><TR
7419><TD
7420WIDTH="20%"
7421ALIGN="RIGHT"
7422VALIGN="TOP"
7423><TT
7424CLASS="PARAMETER"
7425><I
7426>ctxt</I
7427></TT
7428>&nbsp;:</TD
7429><TD
7430WIDTH="80%"
7431ALIGN="LEFT"
7432VALIGN="TOP"
7433>  an XML parser context</TD
7434></TR
7435><TR
7436><TD
7437WIDTH="20%"
7438ALIGN="RIGHT"
7439VALIGN="TOP"
7440><I
7441CLASS="EMPHASIS"
7442>Returns</I
7443> :</TD
7444><TD
7445WIDTH="80%"
7446ALIGN="LEFT"
7447VALIGN="TOP"
7448>0, -1 in case of error. the parser context is augmented
7449as a result of the parsing.</TD
7450></TR
7451></TABLE
7452><P
7453></P
7454></DIV
7455></DIV
7456><HR><DIV
7457CLASS="REFSECT2"
7458><A
7459NAME="AEN1779"
7460></A
7461><H3
7462><A
7463NAME="XMLSAXPARSEDOC"
7464></A
7465>xmlSAXParseDoc ()</H3
7466><TABLE
7467BORDER="0"
7468BGCOLOR="#D6E8FF"
7469WIDTH="100%"
7470CELLPADDING="6"
7471><TR
7472><TD
7473><PRE
7474CLASS="PROGRAMLISTING"
7475><A
7476HREF="libxml-tree.html#XMLDOCPTR"
7477>xmlDocPtr</A
7478>   xmlSAXParseDoc                  (<A
7479HREF="libxml-parser.html#XMLSAXHANDLERPTR"
7480>xmlSAXHandlerPtr</A
7481> sax,
7482                                             <A
7483HREF="libxml-tree.html#XMLCHAR"
7484>xmlChar</A
7485> *cur,
7486                                             int recovery);</PRE
7487></TD
7488></TR
7489></TABLE
7490><P
7491>parse an XML in-memory document and build a tree.
7492It use the given SAX function block to handle the parsing callback.
7493If sax is NULL, fallback to the default DOM tree building routines.</P
7494><P
7495></P
7496><DIV
7497CLASS="INFORMALTABLE"
7498><P
7499></P
7500><TABLE
7501BORDER="0"
7502WIDTH="100%"
7503BGCOLOR="#FFD0D0"
7504CELLSPACING="0"
7505CELLPADDING="4"
7506CLASS="CALSTABLE"
7507><TR
7508><TD
7509WIDTH="20%"
7510ALIGN="RIGHT"
7511VALIGN="TOP"
7512><TT
7513CLASS="PARAMETER"
7514><I
7515>sax</I
7516></TT
7517>&nbsp;:</TD
7518><TD
7519WIDTH="80%"
7520ALIGN="LEFT"
7521VALIGN="TOP"
7522>  the SAX handler block</TD
7523></TR
7524><TR
7525><TD
7526WIDTH="20%"
7527ALIGN="RIGHT"
7528VALIGN="TOP"
7529><TT
7530CLASS="PARAMETER"
7531><I
7532>cur</I
7533></TT
7534>&nbsp;:</TD
7535><TD
7536WIDTH="80%"
7537ALIGN="LEFT"
7538VALIGN="TOP"
7539>  a pointer to an array of xmlChar</TD
7540></TR
7541><TR
7542><TD
7543WIDTH="20%"
7544ALIGN="RIGHT"
7545VALIGN="TOP"
7546><TT
7547CLASS="PARAMETER"
7548><I
7549>recovery</I
7550></TT
7551>&nbsp;:</TD
7552><TD
7553WIDTH="80%"
7554ALIGN="LEFT"
7555VALIGN="TOP"
7556>  work in recovery mode, i.e. tries to read no Well Formed
7557documents</TD
7558></TR
7559><TR
7560><TD
7561WIDTH="20%"
7562ALIGN="RIGHT"
7563VALIGN="TOP"
7564><I
7565CLASS="EMPHASIS"
7566>Returns</I
7567> :</TD
7568><TD
7569WIDTH="80%"
7570ALIGN="LEFT"
7571VALIGN="TOP"
7572>the resulting document tree</TD
7573></TR
7574></TABLE
7575><P
7576></P
7577></DIV
7578></DIV
7579><HR><DIV
7580CLASS="REFSECT2"
7581><A
7582NAME="AEN1809"
7583></A
7584><H3
7585><A
7586NAME="XMLSAXUSERPARSEFILE"
7587></A
7588>xmlSAXUserParseFile ()</H3
7589><TABLE
7590BORDER="0"
7591BGCOLOR="#D6E8FF"
7592WIDTH="100%"
7593CELLPADDING="6"
7594><TR
7595><TD
7596><PRE
7597CLASS="PROGRAMLISTING"
7598>int         xmlSAXUserParseFile             (<A
7599HREF="libxml-parser.html#XMLSAXHANDLERPTR"
7600>xmlSAXHandlerPtr</A
7601> sax,
7602                                             void *user_data,
7603                                             const char *filename);</PRE
7604></TD
7605></TR
7606></TABLE
7607><P
7608>parse an XML file and call the given SAX handler routines.
7609Automatic support for ZLIB/Compress compressed document is provided</P
7610><P
7611></P
7612><DIV
7613CLASS="INFORMALTABLE"
7614><P
7615></P
7616><TABLE
7617BORDER="0"
7618WIDTH="100%"
7619BGCOLOR="#FFD0D0"
7620CELLSPACING="0"
7621CELLPADDING="4"
7622CLASS="CALSTABLE"
7623><TR
7624><TD
7625WIDTH="20%"
7626ALIGN="RIGHT"
7627VALIGN="TOP"
7628><TT
7629CLASS="PARAMETER"
7630><I
7631>sax</I
7632></TT
7633>&nbsp;:</TD
7634><TD
7635WIDTH="80%"
7636ALIGN="LEFT"
7637VALIGN="TOP"
7638>  a SAX handler</TD
7639></TR
7640><TR
7641><TD
7642WIDTH="20%"
7643ALIGN="RIGHT"
7644VALIGN="TOP"
7645><TT
7646CLASS="PARAMETER"
7647><I
7648>user_data</I
7649></TT
7650>&nbsp;:</TD
7651><TD
7652WIDTH="80%"
7653ALIGN="LEFT"
7654VALIGN="TOP"
7655>  The user data returned on SAX callbacks</TD
7656></TR
7657><TR
7658><TD
7659WIDTH="20%"
7660ALIGN="RIGHT"
7661VALIGN="TOP"
7662><TT
7663CLASS="PARAMETER"
7664><I
7665>filename</I
7666></TT
7667>&nbsp;:</TD
7668><TD
7669WIDTH="80%"
7670ALIGN="LEFT"
7671VALIGN="TOP"
7672>  a file name</TD
7673></TR
7674><TR
7675><TD
7676WIDTH="20%"
7677ALIGN="RIGHT"
7678VALIGN="TOP"
7679><I
7680CLASS="EMPHASIS"
7681>Returns</I
7682> :</TD
7683><TD
7684WIDTH="80%"
7685ALIGN="LEFT"
7686VALIGN="TOP"
7687>0 in case of success or a error number otherwise</TD
7688></TR
7689></TABLE
7690><P
7691></P
7692></DIV
7693></DIV
7694><HR><DIV
7695CLASS="REFSECT2"
7696><A
7697NAME="AEN1837"
7698></A
7699><H3
7700><A
7701NAME="XMLSAXUSERPARSEMEMORY"
7702></A
7703>xmlSAXUserParseMemory ()</H3
7704><TABLE
7705BORDER="0"
7706BGCOLOR="#D6E8FF"
7707WIDTH="100%"
7708CELLPADDING="6"
7709><TR
7710><TD
7711><PRE
7712CLASS="PROGRAMLISTING"
7713>int         xmlSAXUserParseMemory           (<A
7714HREF="libxml-parser.html#XMLSAXHANDLERPTR"
7715>xmlSAXHandlerPtr</A
7716> sax,
7717                                             void *user_data,
7718                                             char *buffer,
7719                                             int size);</PRE
7720></TD
7721></TR
7722></TABLE
7723><P
7724>A better SAX parsing routine.
7725parse an XML in-memory buffer and call the given SAX handler routines.</P
7726><P
7727></P
7728><DIV
7729CLASS="INFORMALTABLE"
7730><P
7731></P
7732><TABLE
7733BORDER="0"
7734WIDTH="100%"
7735BGCOLOR="#FFD0D0"
7736CELLSPACING="0"
7737CELLPADDING="4"
7738CLASS="CALSTABLE"
7739><TR
7740><TD
7741WIDTH="20%"
7742ALIGN="RIGHT"
7743VALIGN="TOP"
7744><TT
7745CLASS="PARAMETER"
7746><I
7747>sax</I
7748></TT
7749>&nbsp;:</TD
7750><TD
7751WIDTH="80%"
7752ALIGN="LEFT"
7753VALIGN="TOP"
7754>  a SAX handler</TD
7755></TR
7756><TR
7757><TD
7758WIDTH="20%"
7759ALIGN="RIGHT"
7760VALIGN="TOP"
7761><TT
7762CLASS="PARAMETER"
7763><I
7764>user_data</I
7765></TT
7766>&nbsp;:</TD
7767><TD
7768WIDTH="80%"
7769ALIGN="LEFT"
7770VALIGN="TOP"
7771>  The user data returned on SAX callbacks</TD
7772></TR
7773><TR
7774><TD
7775WIDTH="20%"
7776ALIGN="RIGHT"
7777VALIGN="TOP"
7778><TT
7779CLASS="PARAMETER"
7780><I
7781>buffer</I
7782></TT
7783>&nbsp;:</TD
7784><TD
7785WIDTH="80%"
7786ALIGN="LEFT"
7787VALIGN="TOP"
7788>  an in-memory XML document input</TD
7789></TR
7790><TR
7791><TD
7792WIDTH="20%"
7793ALIGN="RIGHT"
7794VALIGN="TOP"
7795><TT
7796CLASS="PARAMETER"
7797><I
7798>size</I
7799></TT
7800>&nbsp;:</TD
7801><TD
7802WIDTH="80%"
7803ALIGN="LEFT"
7804VALIGN="TOP"
7805>  the length of the XML document in bytes</TD
7806></TR
7807><TR
7808><TD
7809WIDTH="20%"
7810ALIGN="RIGHT"
7811VALIGN="TOP"
7812><I
7813CLASS="EMPHASIS"
7814>Returns</I
7815> :</TD
7816><TD
7817WIDTH="80%"
7818ALIGN="LEFT"
7819VALIGN="TOP"
7820>0 in case of success or a error number otherwise</TD
7821></TR
7822></TABLE
7823><P
7824></P
7825></DIV
7826></DIV
7827><HR><DIV
7828CLASS="REFSECT2"
7829><A
7830NAME="AEN1869"
7831></A
7832><H3
7833><A
7834NAME="XMLSAXPARSEMEMORY"
7835></A
7836>xmlSAXParseMemory ()</H3
7837><TABLE
7838BORDER="0"
7839BGCOLOR="#D6E8FF"
7840WIDTH="100%"
7841CELLPADDING="6"
7842><TR
7843><TD
7844><PRE
7845CLASS="PROGRAMLISTING"
7846><A
7847HREF="libxml-tree.html#XMLDOCPTR"
7848>xmlDocPtr</A
7849>   xmlSAXParseMemory               (<A
7850HREF="libxml-parser.html#XMLSAXHANDLERPTR"
7851>xmlSAXHandlerPtr</A
7852> sax,
7853                                             char *buffer,
7854                                             int size,
7855                                             int recovery);</PRE
7856></TD
7857></TR
7858></TABLE
7859><P
7860>parse an XML in-memory block and use the given SAX function block
7861to handle the parsing callback. If sax is NULL, fallback to the default
7862DOM tree building routines.</P
7863><P
7864></P
7865><DIV
7866CLASS="INFORMALTABLE"
7867><P
7868></P
7869><TABLE
7870BORDER="0"
7871WIDTH="100%"
7872BGCOLOR="#FFD0D0"
7873CELLSPACING="0"
7874CELLPADDING="4"
7875CLASS="CALSTABLE"
7876><TR
7877><TD
7878WIDTH="20%"
7879ALIGN="RIGHT"
7880VALIGN="TOP"
7881><TT
7882CLASS="PARAMETER"
7883><I
7884>sax</I
7885></TT
7886>&nbsp;:</TD
7887><TD
7888WIDTH="80%"
7889ALIGN="LEFT"
7890VALIGN="TOP"
7891>  the SAX handler block</TD
7892></TR
7893><TR
7894><TD
7895WIDTH="20%"
7896ALIGN="RIGHT"
7897VALIGN="TOP"
7898><TT
7899CLASS="PARAMETER"
7900><I
7901>buffer</I
7902></TT
7903>&nbsp;:</TD
7904><TD
7905WIDTH="80%"
7906ALIGN="LEFT"
7907VALIGN="TOP"
7908>  an pointer to a char array</TD
7909></TR
7910><TR
7911><TD
7912WIDTH="20%"
7913ALIGN="RIGHT"
7914VALIGN="TOP"
7915><TT
7916CLASS="PARAMETER"
7917><I
7918>size</I
7919></TT
7920>&nbsp;:</TD
7921><TD
7922WIDTH="80%"
7923ALIGN="LEFT"
7924VALIGN="TOP"
7925>  the size of the array</TD
7926></TR
7927><TR
7928><TD
7929WIDTH="20%"
7930ALIGN="RIGHT"
7931VALIGN="TOP"
7932><TT
7933CLASS="PARAMETER"
7934><I
7935>recovery</I
7936></TT
7937>&nbsp;:</TD
7938><TD
7939WIDTH="80%"
7940ALIGN="LEFT"
7941VALIGN="TOP"
7942>  work in recovery mode, i.e. tries to read not Well Formed
7943documents</TD
7944></TR
7945><TR
7946><TD
7947WIDTH="20%"
7948ALIGN="RIGHT"
7949VALIGN="TOP"
7950><I
7951CLASS="EMPHASIS"
7952>Returns</I
7953> :</TD
7954><TD
7955WIDTH="80%"
7956ALIGN="LEFT"
7957VALIGN="TOP"
7958>the resulting document tree</TD
7959></TR
7960></TABLE
7961><P
7962></P
7963></DIV
7964></DIV
7965><HR><DIV
7966CLASS="REFSECT2"
7967><A
7968NAME="AEN1902"
7969></A
7970><H3
7971><A
7972NAME="XMLSAXPARSEFILE"
7973></A
7974>xmlSAXParseFile ()</H3
7975><TABLE
7976BORDER="0"
7977BGCOLOR="#D6E8FF"
7978WIDTH="100%"
7979CELLPADDING="6"
7980><TR
7981><TD
7982><PRE
7983CLASS="PROGRAMLISTING"
7984><A
7985HREF="libxml-tree.html#XMLDOCPTR"
7986>xmlDocPtr</A
7987>   xmlSAXParseFile                 (<A
7988HREF="libxml-parser.html#XMLSAXHANDLERPTR"
7989>xmlSAXHandlerPtr</A
7990> sax,
7991                                             const char *filename,
7992                                             int recovery);</PRE
7993></TD
7994></TR
7995></TABLE
7996><P
7997>parse an XML file and build a tree. Automatic support for ZLIB/Compress
7998compressed document is provided by default if found at compile-time.
7999It use the given SAX function block to handle the parsing callback.
8000If sax is NULL, fallback to the default DOM tree building routines.</P
8001><P
8002></P
8003><DIV
8004CLASS="INFORMALTABLE"
8005><P
8006></P
8007><TABLE
8008BORDER="0"
8009WIDTH="100%"
8010BGCOLOR="#FFD0D0"
8011CELLSPACING="0"
8012CELLPADDING="4"
8013CLASS="CALSTABLE"
8014><TR
8015><TD
8016WIDTH="20%"
8017ALIGN="RIGHT"
8018VALIGN="TOP"
8019><TT
8020CLASS="PARAMETER"
8021><I
8022>sax</I
8023></TT
8024>&nbsp;:</TD
8025><TD
8026WIDTH="80%"
8027ALIGN="LEFT"
8028VALIGN="TOP"
8029>  the SAX handler block</TD
8030></TR
8031><TR
8032><TD
8033WIDTH="20%"
8034ALIGN="RIGHT"
8035VALIGN="TOP"
8036><TT
8037CLASS="PARAMETER"
8038><I
8039>filename</I
8040></TT
8041>&nbsp;:</TD
8042><TD
8043WIDTH="80%"
8044ALIGN="LEFT"
8045VALIGN="TOP"
8046>  the filename</TD
8047></TR
8048><TR
8049><TD
8050WIDTH="20%"
8051ALIGN="RIGHT"
8052VALIGN="TOP"
8053><TT
8054CLASS="PARAMETER"
8055><I
8056>recovery</I
8057></TT
8058>&nbsp;:</TD
8059><TD
8060WIDTH="80%"
8061ALIGN="LEFT"
8062VALIGN="TOP"
8063>  work in recovery mode, i.e. tries to read no Well Formed
8064documents</TD
8065></TR
8066><TR
8067><TD
8068WIDTH="20%"
8069ALIGN="RIGHT"
8070VALIGN="TOP"
8071><I
8072CLASS="EMPHASIS"
8073>Returns</I
8074> :</TD
8075><TD
8076WIDTH="80%"
8077ALIGN="LEFT"
8078VALIGN="TOP"
8079>the resulting document tree</TD
8080></TR
8081></TABLE
8082><P
8083></P
8084></DIV
8085></DIV
8086><HR><DIV
8087CLASS="REFSECT2"
8088><A
8089NAME="AEN1931"
8090></A
8091><H3
8092><A
8093NAME="XMLSAXPARSEENTITY"
8094></A
8095>xmlSAXParseEntity ()</H3
8096><TABLE
8097BORDER="0"
8098BGCOLOR="#D6E8FF"
8099WIDTH="100%"
8100CELLPADDING="6"
8101><TR
8102><TD
8103><PRE
8104CLASS="PROGRAMLISTING"
8105><A
8106HREF="libxml-tree.html#XMLDOCPTR"
8107>xmlDocPtr</A
8108>   xmlSAXParseEntity               (<A
8109HREF="libxml-parser.html#XMLSAXHANDLERPTR"
8110>xmlSAXHandlerPtr</A
8111> sax,
8112                                             const char *filename);</PRE
8113></TD
8114></TR
8115></TABLE
8116><P
8117>parse an XML external entity out of context and build a tree.
8118It use the given SAX function block to handle the parsing callback.
8119If sax is NULL, fallback to the default DOM tree building routines.</P
8120><P
8121>[78] extParsedEnt ::= TextDecl? content</P
8122><P
8123>This correspond to a "Well Balanced" chunk</P
8124><P
8125></P
8126><DIV
8127CLASS="INFORMALTABLE"
8128><P
8129></P
8130><TABLE
8131BORDER="0"
8132WIDTH="100%"
8133BGCOLOR="#FFD0D0"
8134CELLSPACING="0"
8135CELLPADDING="4"
8136CLASS="CALSTABLE"
8137><TR
8138><TD
8139WIDTH="20%"
8140ALIGN="RIGHT"
8141VALIGN="TOP"
8142><TT
8143CLASS="PARAMETER"
8144><I
8145>sax</I
8146></TT
8147>&nbsp;:</TD
8148><TD
8149WIDTH="80%"
8150ALIGN="LEFT"
8151VALIGN="TOP"
8152>  the SAX handler block</TD
8153></TR
8154><TR
8155><TD
8156WIDTH="20%"
8157ALIGN="RIGHT"
8158VALIGN="TOP"
8159><TT
8160CLASS="PARAMETER"
8161><I
8162>filename</I
8163></TT
8164>&nbsp;:</TD
8165><TD
8166WIDTH="80%"
8167ALIGN="LEFT"
8168VALIGN="TOP"
8169>  the filename</TD
8170></TR
8171><TR
8172><TD
8173WIDTH="20%"
8174ALIGN="RIGHT"
8175VALIGN="TOP"
8176><I
8177CLASS="EMPHASIS"
8178>Returns</I
8179> :</TD
8180><TD
8181WIDTH="80%"
8182ALIGN="LEFT"
8183VALIGN="TOP"
8184>the resulting document tree</TD
8185></TR
8186></TABLE
8187><P
8188></P
8189></DIV
8190></DIV
8191><HR><DIV
8192CLASS="REFSECT2"
8193><A
8194NAME="AEN1958"
8195></A
8196><H3
8197><A
8198NAME="XMLPARSEENTITY"
8199></A
8200>xmlParseEntity ()</H3
8201><TABLE
8202BORDER="0"
8203BGCOLOR="#D6E8FF"
8204WIDTH="100%"
8205CELLPADDING="6"
8206><TR
8207><TD
8208><PRE
8209CLASS="PROGRAMLISTING"
8210><A
8211HREF="libxml-tree.html#XMLDOCPTR"
8212>xmlDocPtr</A
8213>   xmlParseEntity                  (const char *filename);</PRE
8214></TD
8215></TR
8216></TABLE
8217><P
8218>parse an XML external entity out of context and build a tree.</P
8219><P
8220>[78] extParsedEnt ::= TextDecl? content</P
8221><P
8222>This correspond to a "Well Balanced" chunk</P
8223><P
8224></P
8225><DIV
8226CLASS="INFORMALTABLE"
8227><P
8228></P
8229><TABLE
8230BORDER="0"
8231WIDTH="100%"
8232BGCOLOR="#FFD0D0"
8233CELLSPACING="0"
8234CELLPADDING="4"
8235CLASS="CALSTABLE"
8236><TR
8237><TD
8238WIDTH="20%"
8239ALIGN="RIGHT"
8240VALIGN="TOP"
8241><TT
8242CLASS="PARAMETER"
8243><I
8244>filename</I
8245></TT
8246>&nbsp;:</TD
8247><TD
8248WIDTH="80%"
8249ALIGN="LEFT"
8250VALIGN="TOP"
8251>  the filename</TD
8252></TR
8253><TR
8254><TD
8255WIDTH="20%"
8256ALIGN="RIGHT"
8257VALIGN="TOP"
8258><I
8259CLASS="EMPHASIS"
8260>Returns</I
8261> :</TD
8262><TD
8263WIDTH="80%"
8264ALIGN="LEFT"
8265VALIGN="TOP"
8266>the resulting document tree</TD
8267></TR
8268></TABLE
8269><P
8270></P
8271></DIV
8272></DIV
8273><HR><DIV
8274CLASS="REFSECT2"
8275><A
8276NAME="AEN1980"
8277></A
8278><H3
8279><A
8280NAME="XMLPARSEDTD"
8281></A
8282>xmlParseDTD ()</H3
8283><TABLE
8284BORDER="0"
8285BGCOLOR="#D6E8FF"
8286WIDTH="100%"
8287CELLPADDING="6"
8288><TR
8289><TD
8290><PRE
8291CLASS="PROGRAMLISTING"
8292><A
8293HREF="libxml-tree.html#XMLDTDPTR"
8294>xmlDtdPtr</A
8295>   xmlParseDTD                     (const <A
8296HREF="libxml-tree.html#XMLCHAR"
8297>xmlChar</A
8298> *ExternalID,
8299                                             const <A
8300HREF="libxml-tree.html#XMLCHAR"
8301>xmlChar</A
8302> *SystemID);</PRE
8303></TD
8304></TR
8305></TABLE
8306><P
8307>Load and parse an external subset.</P
8308><P
8309></P
8310><DIV
8311CLASS="INFORMALTABLE"
8312><P
8313></P
8314><TABLE
8315BORDER="0"
8316WIDTH="100%"
8317BGCOLOR="#FFD0D0"
8318CELLSPACING="0"
8319CELLPADDING="4"
8320CLASS="CALSTABLE"
8321><TR
8322><TD
8323WIDTH="20%"
8324ALIGN="RIGHT"
8325VALIGN="TOP"
8326><TT
8327CLASS="PARAMETER"
8328><I
8329>ExternalID</I
8330></TT
8331>&nbsp;:</TD
8332><TD
8333WIDTH="80%"
8334ALIGN="LEFT"
8335VALIGN="TOP"
8336>  a NAME* containing the External ID of the DTD</TD
8337></TR
8338><TR
8339><TD
8340WIDTH="20%"
8341ALIGN="RIGHT"
8342VALIGN="TOP"
8343><TT
8344CLASS="PARAMETER"
8345><I
8346>SystemID</I
8347></TT
8348>&nbsp;:</TD
8349><TD
8350WIDTH="80%"
8351ALIGN="LEFT"
8352VALIGN="TOP"
8353>  a NAME* containing the URL to the DTD</TD
8354></TR
8355><TR
8356><TD
8357WIDTH="20%"
8358ALIGN="RIGHT"
8359VALIGN="TOP"
8360><I
8361CLASS="EMPHASIS"
8362>Returns</I
8363> :</TD
8364><TD
8365WIDTH="80%"
8366ALIGN="LEFT"
8367VALIGN="TOP"
8368>the resulting xmlDtdPtr or NULL in case of error.</TD
8369></TR
8370></TABLE
8371><P
8372></P
8373></DIV
8374></DIV
8375><HR><DIV
8376CLASS="REFSECT2"
8377><A
8378NAME="AEN2006"
8379></A
8380><H3
8381><A
8382NAME="XMLSAXPARSEDTD"
8383></A
8384>xmlSAXParseDTD ()</H3
8385><TABLE
8386BORDER="0"
8387BGCOLOR="#D6E8FF"
8388WIDTH="100%"
8389CELLPADDING="6"
8390><TR
8391><TD
8392><PRE
8393CLASS="PROGRAMLISTING"
8394><A
8395HREF="libxml-tree.html#XMLDTDPTR"
8396>xmlDtdPtr</A
8397>   xmlSAXParseDTD                  (<A
8398HREF="libxml-parser.html#XMLSAXHANDLERPTR"
8399>xmlSAXHandlerPtr</A
8400> sax,
8401                                             const <A
8402HREF="libxml-tree.html#XMLCHAR"
8403>xmlChar</A
8404> *ExternalID,
8405                                             const <A
8406HREF="libxml-tree.html#XMLCHAR"
8407>xmlChar</A
8408> *SystemID);</PRE
8409></TD
8410></TR
8411></TABLE
8412><P
8413>Load and parse an external subset.</P
8414><P
8415></P
8416><DIV
8417CLASS="INFORMALTABLE"
8418><P
8419></P
8420><TABLE
8421BORDER="0"
8422WIDTH="100%"
8423BGCOLOR="#FFD0D0"
8424CELLSPACING="0"
8425CELLPADDING="4"
8426CLASS="CALSTABLE"
8427><TR
8428><TD
8429WIDTH="20%"
8430ALIGN="RIGHT"
8431VALIGN="TOP"
8432><TT
8433CLASS="PARAMETER"
8434><I
8435>sax</I
8436></TT
8437>&nbsp;:</TD
8438><TD
8439WIDTH="80%"
8440ALIGN="LEFT"
8441VALIGN="TOP"
8442>  the SAX handler block</TD
8443></TR
8444><TR
8445><TD
8446WIDTH="20%"
8447ALIGN="RIGHT"
8448VALIGN="TOP"
8449><TT
8450CLASS="PARAMETER"
8451><I
8452>ExternalID</I
8453></TT
8454>&nbsp;:</TD
8455><TD
8456WIDTH="80%"
8457ALIGN="LEFT"
8458VALIGN="TOP"
8459>  a NAME* containing the External ID of the DTD</TD
8460></TR
8461><TR
8462><TD
8463WIDTH="20%"
8464ALIGN="RIGHT"
8465VALIGN="TOP"
8466><TT
8467CLASS="PARAMETER"
8468><I
8469>SystemID</I
8470></TT
8471>&nbsp;:</TD
8472><TD
8473WIDTH="80%"
8474ALIGN="LEFT"
8475VALIGN="TOP"
8476>  a NAME* containing the URL to the DTD</TD
8477></TR
8478><TR
8479><TD
8480WIDTH="20%"
8481ALIGN="RIGHT"
8482VALIGN="TOP"
8483><I
8484CLASS="EMPHASIS"
8485>Returns</I
8486> :</TD
8487><TD
8488WIDTH="80%"
8489ALIGN="LEFT"
8490VALIGN="TOP"
8491>the resulting xmlDtdPtr or NULL in case of error.</TD
8492></TR
8493></TABLE
8494><P
8495></P
8496></DIV
8497></DIV
8498><HR><DIV
8499CLASS="REFSECT2"
8500><A
8501NAME="AEN2037"
8502></A
8503><H3
8504><A
8505NAME="XMLIOPARSEDTD"
8506></A
8507>xmlIOParseDTD ()</H3
8508><TABLE
8509BORDER="0"
8510BGCOLOR="#D6E8FF"
8511WIDTH="100%"
8512CELLPADDING="6"
8513><TR
8514><TD
8515><PRE
8516CLASS="PROGRAMLISTING"
8517><A
8518HREF="libxml-tree.html#XMLDTDPTR"
8519>xmlDtdPtr</A
8520>   xmlIOParseDTD                   (<A
8521HREF="libxml-parser.html#XMLSAXHANDLERPTR"
8522>xmlSAXHandlerPtr</A
8523> sax,
8524                                             <A
8525HREF="libxml-xmlio.html#XMLPARSERINPUTBUFFERPTR"
8526>xmlParserInputBufferPtr</A
8527> input,
8528                                             <A
8529HREF="libxml-encoding.html#XMLCHARENCODING"
8530>xmlCharEncoding</A
8531> enc);</PRE
8532></TD
8533></TR
8534></TABLE
8535><P
8536>Load and parse a DTD</P
8537><P
8538></P
8539><DIV
8540CLASS="INFORMALTABLE"
8541><P
8542></P
8543><TABLE
8544BORDER="0"
8545WIDTH="100%"
8546BGCOLOR="#FFD0D0"
8547CELLSPACING="0"
8548CELLPADDING="4"
8549CLASS="CALSTABLE"
8550><TR
8551><TD
8552WIDTH="20%"
8553ALIGN="RIGHT"
8554VALIGN="TOP"
8555><TT
8556CLASS="PARAMETER"
8557><I
8558>sax</I
8559></TT
8560>&nbsp;:</TD
8561><TD
8562WIDTH="80%"
8563ALIGN="LEFT"
8564VALIGN="TOP"
8565>  the SAX handler block or NULL</TD
8566></TR
8567><TR
8568><TD
8569WIDTH="20%"
8570ALIGN="RIGHT"
8571VALIGN="TOP"
8572><TT
8573CLASS="PARAMETER"
8574><I
8575>input</I
8576></TT
8577>&nbsp;:</TD
8578><TD
8579WIDTH="80%"
8580ALIGN="LEFT"
8581VALIGN="TOP"
8582>  an Input Buffer</TD
8583></TR
8584><TR
8585><TD
8586WIDTH="20%"
8587ALIGN="RIGHT"
8588VALIGN="TOP"
8589><TT
8590CLASS="PARAMETER"
8591><I
8592>enc</I
8593></TT
8594>&nbsp;:</TD
8595><TD
8596WIDTH="80%"
8597ALIGN="LEFT"
8598VALIGN="TOP"
8599>  the charset encoding if known</TD
8600></TR
8601><TR
8602><TD
8603WIDTH="20%"
8604ALIGN="RIGHT"
8605VALIGN="TOP"
8606><I
8607CLASS="EMPHASIS"
8608>Returns</I
8609> :</TD
8610><TD
8611WIDTH="80%"
8612ALIGN="LEFT"
8613VALIGN="TOP"
8614>the resulting xmlDtdPtr or NULL in case of error.
8615<TT
8616CLASS="PARAMETER"
8617><I
8618>input</I
8619></TT
8620> will be freed at parsing end.</TD
8621></TR
8622></TABLE
8623><P
8624></P
8625></DIV
8626></DIV
8627><HR><DIV
8628CLASS="REFSECT2"
8629><A
8630NAME="AEN2069"
8631></A
8632><H3
8633><A
8634NAME="XMLPARSEBALANCEDCHUNKMEMORY"
8635></A
8636>xmlParseBalancedChunkMemory ()</H3
8637><TABLE
8638BORDER="0"
8639BGCOLOR="#D6E8FF"
8640WIDTH="100%"
8641CELLPADDING="6"
8642><TR
8643><TD
8644><PRE
8645CLASS="PROGRAMLISTING"
8646>int         xmlParseBalancedChunkMemory     (<A
8647HREF="libxml-tree.html#XMLDOCPTR"
8648>xmlDocPtr</A
8649> doc,
8650                                             <A
8651HREF="libxml-parser.html#XMLSAXHANDLERPTR"
8652>xmlSAXHandlerPtr</A
8653> sax,
8654                                             void *user_data,
8655                                             int depth,
8656                                             const <A
8657HREF="libxml-tree.html#XMLCHAR"
8658>xmlChar</A
8659> *string,
8660                                             <A
8661HREF="libxml-tree.html#XMLNODEPTR"
8662>xmlNodePtr</A
8663> *list);</PRE
8664></TD
8665></TR
8666></TABLE
8667><P
8668></P
8669><DIV
8670CLASS="INFORMALTABLE"
8671><P
8672></P
8673><TABLE
8674BORDER="0"
8675WIDTH="100%"
8676BGCOLOR="#FFD0D0"
8677CELLSPACING="0"
8678CELLPADDING="4"
8679CLASS="CALSTABLE"
8680><TR
8681><TD
8682WIDTH="20%"
8683ALIGN="RIGHT"
8684VALIGN="TOP"
8685><TT
8686CLASS="PARAMETER"
8687><I
8688>doc</I
8689></TT
8690>&nbsp;:</TD
8691><TD
8692WIDTH="80%"
8693ALIGN="LEFT"
8694VALIGN="TOP"
8695>&nbsp;</TD
8696></TR
8697><TR
8698><TD
8699WIDTH="20%"
8700ALIGN="RIGHT"
8701VALIGN="TOP"
8702><TT
8703CLASS="PARAMETER"
8704><I
8705>sax</I
8706></TT
8707>&nbsp;:</TD
8708><TD
8709WIDTH="80%"
8710ALIGN="LEFT"
8711VALIGN="TOP"
8712>&nbsp;</TD
8713></TR
8714><TR
8715><TD
8716WIDTH="20%"
8717ALIGN="RIGHT"
8718VALIGN="TOP"
8719><TT
8720CLASS="PARAMETER"
8721><I
8722>user_data</I
8723></TT
8724>&nbsp;:</TD
8725><TD
8726WIDTH="80%"
8727ALIGN="LEFT"
8728VALIGN="TOP"
8729>&nbsp;</TD
8730></TR
8731><TR
8732><TD
8733WIDTH="20%"
8734ALIGN="RIGHT"
8735VALIGN="TOP"
8736><TT
8737CLASS="PARAMETER"
8738><I
8739>depth</I
8740></TT
8741>&nbsp;:</TD
8742><TD
8743WIDTH="80%"
8744ALIGN="LEFT"
8745VALIGN="TOP"
8746>&nbsp;</TD
8747></TR
8748><TR
8749><TD
8750WIDTH="20%"
8751ALIGN="RIGHT"
8752VALIGN="TOP"
8753><TT
8754CLASS="PARAMETER"
8755><I
8756>string</I
8757></TT
8758>&nbsp;:</TD
8759><TD
8760WIDTH="80%"
8761ALIGN="LEFT"
8762VALIGN="TOP"
8763>&nbsp;</TD
8764></TR
8765><TR
8766><TD
8767WIDTH="20%"
8768ALIGN="RIGHT"
8769VALIGN="TOP"
8770><TT
8771CLASS="PARAMETER"
8772><I
8773>list</I
8774></TT
8775>&nbsp;:</TD
8776><TD
8777WIDTH="80%"
8778ALIGN="LEFT"
8779VALIGN="TOP"
8780>&nbsp;</TD
8781></TR
8782><TR
8783><TD
8784WIDTH="20%"
8785ALIGN="RIGHT"
8786VALIGN="TOP"
8787><I
8788CLASS="EMPHASIS"
8789>Returns</I
8790> :</TD
8791><TD
8792WIDTH="80%"
8793ALIGN="LEFT"
8794VALIGN="TOP"
8795>&#13;</TD
8796></TR
8797></TABLE
8798><P
8799></P
8800></DIV
8801></DIV
8802><HR><DIV
8803CLASS="REFSECT2"
8804><A
8805NAME="AEN2111"
8806></A
8807><H3
8808><A
8809NAME="XMLPARSEEXTERNALENTITY"
8810></A
8811>xmlParseExternalEntity ()</H3
8812><TABLE
8813BORDER="0"
8814BGCOLOR="#D6E8FF"
8815WIDTH="100%"
8816CELLPADDING="6"
8817><TR
8818><TD
8819><PRE
8820CLASS="PROGRAMLISTING"
8821>int         xmlParseExternalEntity          (<A
8822HREF="libxml-tree.html#XMLDOCPTR"
8823>xmlDocPtr</A
8824> doc,
8825                                             <A
8826HREF="libxml-parser.html#XMLSAXHANDLERPTR"
8827>xmlSAXHandlerPtr</A
8828> sax,
8829                                             void *user_data,
8830                                             int depth,
8831                                             const <A
8832HREF="libxml-tree.html#XMLCHAR"
8833>xmlChar</A
8834> *URL,
8835                                             const <A
8836HREF="libxml-tree.html#XMLCHAR"
8837>xmlChar</A
8838> *ID,
8839                                             <A
8840HREF="libxml-tree.html#XMLNODEPTR"
8841>xmlNodePtr</A
8842> *list);</PRE
8843></TD
8844></TR
8845></TABLE
8846><P
8847>Parse an external general entity
8848An external general parsed entity is well-formed if it matches the
8849production labeled extParsedEnt.</P
8850><P
8851>[78] extParsedEnt ::= TextDecl? content</P
8852><P
8853></P
8854><DIV
8855CLASS="INFORMALTABLE"
8856><P
8857></P
8858><TABLE
8859BORDER="0"
8860WIDTH="100%"
8861BGCOLOR="#FFD0D0"
8862CELLSPACING="0"
8863CELLPADDING="4"
8864CLASS="CALSTABLE"
8865><TR
8866><TD
8867WIDTH="20%"
8868ALIGN="RIGHT"
8869VALIGN="TOP"
8870><TT
8871CLASS="PARAMETER"
8872><I
8873>doc</I
8874></TT
8875>&nbsp;:</TD
8876><TD
8877WIDTH="80%"
8878ALIGN="LEFT"
8879VALIGN="TOP"
8880>  the document the chunk pertains to</TD
8881></TR
8882><TR
8883><TD
8884WIDTH="20%"
8885ALIGN="RIGHT"
8886VALIGN="TOP"
8887><TT
8888CLASS="PARAMETER"
8889><I
8890>sax</I
8891></TT
8892>&nbsp;:</TD
8893><TD
8894WIDTH="80%"
8895ALIGN="LEFT"
8896VALIGN="TOP"
8897>  the SAX handler bloc (possibly NULL)</TD
8898></TR
8899><TR
8900><TD
8901WIDTH="20%"
8902ALIGN="RIGHT"
8903VALIGN="TOP"
8904><TT
8905CLASS="PARAMETER"
8906><I
8907>user_data</I
8908></TT
8909>&nbsp;:</TD
8910><TD
8911WIDTH="80%"
8912ALIGN="LEFT"
8913VALIGN="TOP"
8914>  The user data returned on SAX callbacks (possibly NULL)</TD
8915></TR
8916><TR
8917><TD
8918WIDTH="20%"
8919ALIGN="RIGHT"
8920VALIGN="TOP"
8921><TT
8922CLASS="PARAMETER"
8923><I
8924>depth</I
8925></TT
8926>&nbsp;:</TD
8927><TD
8928WIDTH="80%"
8929ALIGN="LEFT"
8930VALIGN="TOP"
8931>  Used for loop detection, use 0</TD
8932></TR
8933><TR
8934><TD
8935WIDTH="20%"
8936ALIGN="RIGHT"
8937VALIGN="TOP"
8938><TT
8939CLASS="PARAMETER"
8940><I
8941>URL</I
8942></TT
8943>&nbsp;:</TD
8944><TD
8945WIDTH="80%"
8946ALIGN="LEFT"
8947VALIGN="TOP"
8948>  the URL for the entity to load</TD
8949></TR
8950><TR
8951><TD
8952WIDTH="20%"
8953ALIGN="RIGHT"
8954VALIGN="TOP"
8955><TT
8956CLASS="PARAMETER"
8957><I
8958>ID</I
8959></TT
8960>&nbsp;:</TD
8961><TD
8962WIDTH="80%"
8963ALIGN="LEFT"
8964VALIGN="TOP"
8965>  the System ID for the entity to load</TD
8966></TR
8967><TR
8968><TD
8969WIDTH="20%"
8970ALIGN="RIGHT"
8971VALIGN="TOP"
8972><TT
8973CLASS="PARAMETER"
8974><I
8975>list</I
8976></TT
8977>&nbsp;:</TD
8978><TD
8979WIDTH="80%"
8980ALIGN="LEFT"
8981VALIGN="TOP"
8982>  the return value for the set of parsed nodes</TD
8983></TR
8984><TR
8985><TD
8986WIDTH="20%"
8987ALIGN="RIGHT"
8988VALIGN="TOP"
8989><I
8990CLASS="EMPHASIS"
8991>Returns</I
8992> :</TD
8993><TD
8994WIDTH="80%"
8995ALIGN="LEFT"
8996VALIGN="TOP"
8997>0 if the entity is well formed, -1 in case of args problem and
8998the parser error code otherwise</TD
8999></TR
9000></TABLE
9001><P
9002></P
9003></DIV
9004></DIV
9005><HR><DIV
9006CLASS="REFSECT2"
9007><A
9008NAME="AEN2160"
9009></A
9010><H3
9011><A
9012NAME="XMLPARSECTXTEXTERNALENTITY"
9013></A
9014>xmlParseCtxtExternalEntity ()</H3
9015><TABLE
9016BORDER="0"
9017BGCOLOR="#D6E8FF"
9018WIDTH="100%"
9019CELLPADDING="6"
9020><TR
9021><TD
9022><PRE
9023CLASS="PROGRAMLISTING"
9024>int         xmlParseCtxtExternalEntity      (<A
9025HREF="libxml-parser.html#XMLPARSERCTXTPTR"
9026>xmlParserCtxtPtr</A
9027> ctx,
9028                                             const <A
9029HREF="libxml-tree.html#XMLCHAR"
9030>xmlChar</A
9031> *URL,
9032                                             const <A
9033HREF="libxml-tree.html#XMLCHAR"
9034>xmlChar</A
9035> *ID,
9036                                             <A
9037HREF="libxml-tree.html#XMLNODEPTR"
9038>xmlNodePtr</A
9039> *list);</PRE
9040></TD
9041></TR
9042></TABLE
9043><P
9044>Parse an external general entity within an existing parsing context
9045An external general parsed entity is well-formed if it matches the
9046production labeled extParsedEnt.</P
9047><P
9048>[78] extParsedEnt ::= TextDecl? content</P
9049><P
9050></P
9051><DIV
9052CLASS="INFORMALTABLE"
9053><P
9054></P
9055><TABLE
9056BORDER="0"
9057WIDTH="100%"
9058BGCOLOR="#FFD0D0"
9059CELLSPACING="0"
9060CELLPADDING="4"
9061CLASS="CALSTABLE"
9062><TR
9063><TD
9064WIDTH="20%"
9065ALIGN="RIGHT"
9066VALIGN="TOP"
9067><TT
9068CLASS="PARAMETER"
9069><I
9070>ctx</I
9071></TT
9072>&nbsp;:</TD
9073><TD
9074WIDTH="80%"
9075ALIGN="LEFT"
9076VALIGN="TOP"
9077>  the existing parsing context</TD
9078></TR
9079><TR
9080><TD
9081WIDTH="20%"
9082ALIGN="RIGHT"
9083VALIGN="TOP"
9084><TT
9085CLASS="PARAMETER"
9086><I
9087>URL</I
9088></TT
9089>&nbsp;:</TD
9090><TD
9091WIDTH="80%"
9092ALIGN="LEFT"
9093VALIGN="TOP"
9094>  the URL for the entity to load</TD
9095></TR
9096><TR
9097><TD
9098WIDTH="20%"
9099ALIGN="RIGHT"
9100VALIGN="TOP"
9101><TT
9102CLASS="PARAMETER"
9103><I
9104>ID</I
9105></TT
9106>&nbsp;:</TD
9107><TD
9108WIDTH="80%"
9109ALIGN="LEFT"
9110VALIGN="TOP"
9111>  the System ID for the entity to load</TD
9112></TR
9113><TR
9114><TD
9115WIDTH="20%"
9116ALIGN="RIGHT"
9117VALIGN="TOP"
9118><TT
9119CLASS="PARAMETER"
9120><I
9121>list</I
9122></TT
9123>&nbsp;:</TD
9124><TD
9125WIDTH="80%"
9126ALIGN="LEFT"
9127VALIGN="TOP"
9128>  the return value for the set of parsed nodes</TD
9129></TR
9130><TR
9131><TD
9132WIDTH="20%"
9133ALIGN="RIGHT"
9134VALIGN="TOP"
9135><I
9136CLASS="EMPHASIS"
9137>Returns</I
9138> :</TD
9139><TD
9140WIDTH="80%"
9141ALIGN="LEFT"
9142VALIGN="TOP"
9143>0 if the entity is well formed, -1 in case of args problem and
9144the parser error code otherwise</TD
9145></TR
9146></TABLE
9147><P
9148></P
9149></DIV
9150></DIV
9151><HR><DIV
9152CLASS="REFSECT2"
9153><A
9154NAME="AEN2196"
9155></A
9156><H3
9157><A
9158NAME="XMLDEFAULTSAXHANDLERINIT"
9159></A
9160>xmlDefaultSAXHandlerInit ()</H3
9161><TABLE
9162BORDER="0"
9163BGCOLOR="#D6E8FF"
9164WIDTH="100%"
9165CELLPADDING="6"
9166><TR
9167><TD
9168><PRE
9169CLASS="PROGRAMLISTING"
9170>void        xmlDefaultSAXHandlerInit        (void);</PRE
9171></TD
9172></TR
9173></TABLE
9174><P
9175>Initialize the default SAX handler</P
9176><P
9177></P
9178></DIV
9179><HR><DIV
9180CLASS="REFSECT2"
9181><A
9182NAME="AEN2202"
9183></A
9184><H3
9185><A
9186NAME="HTMLDEFAULTSAXHANDLERINIT"
9187></A
9188>htmlDefaultSAXHandlerInit ()</H3
9189><TABLE
9190BORDER="0"
9191BGCOLOR="#D6E8FF"
9192WIDTH="100%"
9193CELLPADDING="6"
9194><TR
9195><TD
9196><PRE
9197CLASS="PROGRAMLISTING"
9198>void        htmlDefaultSAXHandlerInit       (void);</PRE
9199></TD
9200></TR
9201></TABLE
9202><P
9203>Initialize the default SAX handler</P
9204><P
9205></P
9206></DIV
9207><HR><DIV
9208CLASS="REFSECT2"
9209><A
9210NAME="AEN2208"
9211></A
9212><H3
9213><A
9214NAME="XMLINITPARSERCTXT"
9215></A
9216>xmlInitParserCtxt ()</H3
9217><TABLE
9218BORDER="0"
9219BGCOLOR="#D6E8FF"
9220WIDTH="100%"
9221CELLPADDING="6"
9222><TR
9223><TD
9224><PRE
9225CLASS="PROGRAMLISTING"
9226>void        xmlInitParserCtxt               (<A
9227HREF="libxml-parser.html#XMLPARSERCTXTPTR"
9228>xmlParserCtxtPtr</A
9229> ctxt);</PRE
9230></TD
9231></TR
9232></TABLE
9233><P
9234>Initialize a parser context</P
9235><P
9236></P
9237><DIV
9238CLASS="INFORMALTABLE"
9239><P
9240></P
9241><TABLE
9242BORDER="0"
9243WIDTH="100%"
9244BGCOLOR="#FFD0D0"
9245CELLSPACING="0"
9246CELLPADDING="4"
9247CLASS="CALSTABLE"
9248><TR
9249><TD
9250WIDTH="20%"
9251ALIGN="RIGHT"
9252VALIGN="TOP"
9253><TT
9254CLASS="PARAMETER"
9255><I
9256>ctxt</I
9257></TT
9258>&nbsp;:</TD
9259><TD
9260WIDTH="80%"
9261ALIGN="LEFT"
9262VALIGN="TOP"
9263>  an XML parser context</TD
9264></TR
9265></TABLE
9266><P
9267></P
9268></DIV
9269></DIV
9270><HR><DIV
9271CLASS="REFSECT2"
9272><A
9273NAME="AEN2224"
9274></A
9275><H3
9276><A
9277NAME="XMLCLEARPARSERCTXT"
9278></A
9279>xmlClearParserCtxt ()</H3
9280><TABLE
9281BORDER="0"
9282BGCOLOR="#D6E8FF"
9283WIDTH="100%"
9284CELLPADDING="6"
9285><TR
9286><TD
9287><PRE
9288CLASS="PROGRAMLISTING"
9289>void        xmlClearParserCtxt              (<A
9290HREF="libxml-parser.html#XMLPARSERCTXTPTR"
9291>xmlParserCtxtPtr</A
9292> ctxt);</PRE
9293></TD
9294></TR
9295></TABLE
9296><P
9297>Clear (release owned resources) and reinitialize a parser context</P
9298><P
9299></P
9300><DIV
9301CLASS="INFORMALTABLE"
9302><P
9303></P
9304><TABLE
9305BORDER="0"
9306WIDTH="100%"
9307BGCOLOR="#FFD0D0"
9308CELLSPACING="0"
9309CELLPADDING="4"
9310CLASS="CALSTABLE"
9311><TR
9312><TD
9313WIDTH="20%"
9314ALIGN="RIGHT"
9315VALIGN="TOP"
9316><TT
9317CLASS="PARAMETER"
9318><I
9319>ctxt</I
9320></TT
9321>&nbsp;:</TD
9322><TD
9323WIDTH="80%"
9324ALIGN="LEFT"
9325VALIGN="TOP"
9326>  an XML parser context</TD
9327></TR
9328></TABLE
9329><P
9330></P
9331></DIV
9332></DIV
9333><HR><DIV
9334CLASS="REFSECT2"
9335><A
9336NAME="AEN2240"
9337></A
9338><H3
9339><A
9340NAME="XMLFREEPARSERCTXT"
9341></A
9342>xmlFreeParserCtxt ()</H3
9343><TABLE
9344BORDER="0"
9345BGCOLOR="#D6E8FF"
9346WIDTH="100%"
9347CELLPADDING="6"
9348><TR
9349><TD
9350><PRE
9351CLASS="PROGRAMLISTING"
9352>void        xmlFreeParserCtxt               (<A
9353HREF="libxml-parser.html#XMLPARSERCTXTPTR"
9354>xmlParserCtxtPtr</A
9355> ctxt);</PRE
9356></TD
9357></TR
9358></TABLE
9359><P
9360>Free all the memory used by a parser context. However the parsed
9361document in ctxt-&gt;myDoc is not freed.</P
9362><P
9363></P
9364><DIV
9365CLASS="INFORMALTABLE"
9366><P
9367></P
9368><TABLE
9369BORDER="0"
9370WIDTH="100%"
9371BGCOLOR="#FFD0D0"
9372CELLSPACING="0"
9373CELLPADDING="4"
9374CLASS="CALSTABLE"
9375><TR
9376><TD
9377WIDTH="20%"
9378ALIGN="RIGHT"
9379VALIGN="TOP"
9380><TT
9381CLASS="PARAMETER"
9382><I
9383>ctxt</I
9384></TT
9385>&nbsp;:</TD
9386><TD
9387WIDTH="80%"
9388ALIGN="LEFT"
9389VALIGN="TOP"
9390>  an XML parser context</TD
9391></TR
9392></TABLE
9393><P
9394></P
9395></DIV
9396></DIV
9397><HR><DIV
9398CLASS="REFSECT2"
9399><A
9400NAME="AEN2256"
9401></A
9402><H3
9403><A
9404NAME="XMLSETUPPARSERFORBUFFER"
9405></A
9406>xmlSetupParserForBuffer ()</H3
9407><TABLE
9408BORDER="0"
9409BGCOLOR="#D6E8FF"
9410WIDTH="100%"
9411CELLPADDING="6"
9412><TR
9413><TD
9414><PRE
9415CLASS="PROGRAMLISTING"
9416>void        xmlSetupParserForBuffer         (<A
9417HREF="libxml-parser.html#XMLPARSERCTXTPTR"
9418>xmlParserCtxtPtr</A
9419> ctxt,
9420                                             const <A
9421HREF="libxml-tree.html#XMLCHAR"
9422>xmlChar</A
9423> *buffer,
9424                                             const char *filename);</PRE
9425></TD
9426></TR
9427></TABLE
9428><P
9429>Setup the parser context to parse a new buffer; Clears any prior
9430contents from the parser context. The buffer parameter must not be
9431NULL, but the filename parameter can be</P
9432><P
9433></P
9434><DIV
9435CLASS="INFORMALTABLE"
9436><P
9437></P
9438><TABLE
9439BORDER="0"
9440WIDTH="100%"
9441BGCOLOR="#FFD0D0"
9442CELLSPACING="0"
9443CELLPADDING="4"
9444CLASS="CALSTABLE"
9445><TR
9446><TD
9447WIDTH="20%"
9448ALIGN="RIGHT"
9449VALIGN="TOP"
9450><TT
9451CLASS="PARAMETER"
9452><I
9453>ctxt</I
9454></TT
9455>&nbsp;:</TD
9456><TD
9457WIDTH="80%"
9458ALIGN="LEFT"
9459VALIGN="TOP"
9460>  an XML parser context</TD
9461></TR
9462><TR
9463><TD
9464WIDTH="20%"
9465ALIGN="RIGHT"
9466VALIGN="TOP"
9467><TT
9468CLASS="PARAMETER"
9469><I
9470>buffer</I
9471></TT
9472>&nbsp;:</TD
9473><TD
9474WIDTH="80%"
9475ALIGN="LEFT"
9476VALIGN="TOP"
9477>  a xmlChar * buffer</TD
9478></TR
9479><TR
9480><TD
9481WIDTH="20%"
9482ALIGN="RIGHT"
9483VALIGN="TOP"
9484><TT
9485CLASS="PARAMETER"
9486><I
9487>filename</I
9488></TT
9489>&nbsp;:</TD
9490><TD
9491WIDTH="80%"
9492ALIGN="LEFT"
9493VALIGN="TOP"
9494>  a file name</TD
9495></TR
9496></TABLE
9497><P
9498></P
9499></DIV
9500></DIV
9501><HR><DIV
9502CLASS="REFSECT2"
9503><A
9504NAME="AEN2281"
9505></A
9506><H3
9507><A
9508NAME="XMLCREATEDOCPARSERCTXT"
9509></A
9510>xmlCreateDocParserCtxt ()</H3
9511><TABLE
9512BORDER="0"
9513BGCOLOR="#D6E8FF"
9514WIDTH="100%"
9515CELLPADDING="6"
9516><TR
9517><TD
9518><PRE
9519CLASS="PROGRAMLISTING"
9520><A
9521HREF="libxml-parser.html#XMLPARSERCTXTPTR"
9522>xmlParserCtxtPtr</A
9523> xmlCreateDocParserCtxt     (<A
9524HREF="libxml-tree.html#XMLCHAR"
9525>xmlChar</A
9526> *cur);</PRE
9527></TD
9528></TR
9529></TABLE
9530><P
9531>Creates a parser context for an XML in-memory document.</P
9532><P
9533></P
9534><DIV
9535CLASS="INFORMALTABLE"
9536><P
9537></P
9538><TABLE
9539BORDER="0"
9540WIDTH="100%"
9541BGCOLOR="#FFD0D0"
9542CELLSPACING="0"
9543CELLPADDING="4"
9544CLASS="CALSTABLE"
9545><TR
9546><TD
9547WIDTH="20%"
9548ALIGN="RIGHT"
9549VALIGN="TOP"
9550><TT
9551CLASS="PARAMETER"
9552><I
9553>cur</I
9554></TT
9555>&nbsp;:</TD
9556><TD
9557WIDTH="80%"
9558ALIGN="LEFT"
9559VALIGN="TOP"
9560>  a pointer to an array of xmlChar</TD
9561></TR
9562><TR
9563><TD
9564WIDTH="20%"
9565ALIGN="RIGHT"
9566VALIGN="TOP"
9567><I
9568CLASS="EMPHASIS"
9569>Returns</I
9570> :</TD
9571><TD
9572WIDTH="80%"
9573ALIGN="LEFT"
9574VALIGN="TOP"
9575>the new parser context or NULL</TD
9576></TR
9577></TABLE
9578><P
9579></P
9580></DIV
9581></DIV
9582><HR><DIV
9583CLASS="REFSECT2"
9584><A
9585NAME="AEN2302"
9586></A
9587><H3
9588><A
9589NAME="XMLGETFEATURESLIST"
9590></A
9591>xmlGetFeaturesList ()</H3
9592><TABLE
9593BORDER="0"
9594BGCOLOR="#D6E8FF"
9595WIDTH="100%"
9596CELLPADDING="6"
9597><TR
9598><TD
9599><PRE
9600CLASS="PROGRAMLISTING"
9601>int         xmlGetFeaturesList              (int *len,
9602                                             const char **result);</PRE
9603></TD
9604></TR
9605></TABLE
9606><P
9607></P
9608><DIV
9609CLASS="INFORMALTABLE"
9610><P
9611></P
9612><TABLE
9613BORDER="0"
9614WIDTH="100%"
9615BGCOLOR="#FFD0D0"
9616CELLSPACING="0"
9617CELLPADDING="4"
9618CLASS="CALSTABLE"
9619><TR
9620><TD
9621WIDTH="20%"
9622ALIGN="RIGHT"
9623VALIGN="TOP"
9624><TT
9625CLASS="PARAMETER"
9626><I
9627>len</I
9628></TT
9629>&nbsp;:</TD
9630><TD
9631WIDTH="80%"
9632ALIGN="LEFT"
9633VALIGN="TOP"
9634>&nbsp;</TD
9635></TR
9636><TR
9637><TD
9638WIDTH="20%"
9639ALIGN="RIGHT"
9640VALIGN="TOP"
9641><TT
9642CLASS="PARAMETER"
9643><I
9644>result</I
9645></TT
9646>&nbsp;:</TD
9647><TD
9648WIDTH="80%"
9649ALIGN="LEFT"
9650VALIGN="TOP"
9651>&nbsp;</TD
9652></TR
9653><TR
9654><TD
9655WIDTH="20%"
9656ALIGN="RIGHT"
9657VALIGN="TOP"
9658><I
9659CLASS="EMPHASIS"
9660>Returns</I
9661> :</TD
9662><TD
9663WIDTH="80%"
9664ALIGN="LEFT"
9665VALIGN="TOP"
9666>&#13;</TD
9667></TR
9668></TABLE
9669><P
9670></P
9671></DIV
9672></DIV
9673><HR><DIV
9674CLASS="REFSECT2"
9675><A
9676NAME="AEN2324"
9677></A
9678><H3
9679><A
9680NAME="XMLGETFEATURE"
9681></A
9682>xmlGetFeature ()</H3
9683><TABLE
9684BORDER="0"
9685BGCOLOR="#D6E8FF"
9686WIDTH="100%"
9687CELLPADDING="6"
9688><TR
9689><TD
9690><PRE
9691CLASS="PROGRAMLISTING"
9692>int         xmlGetFeature                   (<A
9693HREF="libxml-parser.html#XMLPARSERCTXTPTR"
9694>xmlParserCtxtPtr</A
9695> ctxt,
9696                                             const char *name,
9697                                             void *result);</PRE
9698></TD
9699></TR
9700></TABLE
9701><P
9702></P
9703><DIV
9704CLASS="INFORMALTABLE"
9705><P
9706></P
9707><TABLE
9708BORDER="0"
9709WIDTH="100%"
9710BGCOLOR="#FFD0D0"
9711CELLSPACING="0"
9712CELLPADDING="4"
9713CLASS="CALSTABLE"
9714><TR
9715><TD
9716WIDTH="20%"
9717ALIGN="RIGHT"
9718VALIGN="TOP"
9719><TT
9720CLASS="PARAMETER"
9721><I
9722>ctxt</I
9723></TT
9724>&nbsp;:</TD
9725><TD
9726WIDTH="80%"
9727ALIGN="LEFT"
9728VALIGN="TOP"
9729>&nbsp;</TD
9730></TR
9731><TR
9732><TD
9733WIDTH="20%"
9734ALIGN="RIGHT"
9735VALIGN="TOP"
9736><TT
9737CLASS="PARAMETER"
9738><I
9739>name</I
9740></TT
9741>&nbsp;:</TD
9742><TD
9743WIDTH="80%"
9744ALIGN="LEFT"
9745VALIGN="TOP"
9746>&nbsp;</TD
9747></TR
9748><TR
9749><TD
9750WIDTH="20%"
9751ALIGN="RIGHT"
9752VALIGN="TOP"
9753><TT
9754CLASS="PARAMETER"
9755><I
9756>result</I
9757></TT
9758>&nbsp;:</TD
9759><TD
9760WIDTH="80%"
9761ALIGN="LEFT"
9762VALIGN="TOP"
9763>&nbsp;</TD
9764></TR
9765><TR
9766><TD
9767WIDTH="20%"
9768ALIGN="RIGHT"
9769VALIGN="TOP"
9770><I
9771CLASS="EMPHASIS"
9772>Returns</I
9773> :</TD
9774><TD
9775WIDTH="80%"
9776ALIGN="LEFT"
9777VALIGN="TOP"
9778>&#13;</TD
9779></TR
9780></TABLE
9781><P
9782></P
9783></DIV
9784></DIV
9785><HR><DIV
9786CLASS="REFSECT2"
9787><A
9788NAME="AEN2351"
9789></A
9790><H3
9791><A
9792NAME="XMLSETFEATURE"
9793></A
9794>xmlSetFeature ()</H3
9795><TABLE
9796BORDER="0"
9797BGCOLOR="#D6E8FF"
9798WIDTH="100%"
9799CELLPADDING="6"
9800><TR
9801><TD
9802><PRE
9803CLASS="PROGRAMLISTING"
9804>int         xmlSetFeature                   (<A
9805HREF="libxml-parser.html#XMLPARSERCTXTPTR"
9806>xmlParserCtxtPtr</A
9807> ctxt,
9808                                             const char *name,
9809                                             void *value);</PRE
9810></TD
9811></TR
9812></TABLE
9813><P
9814></P
9815><DIV
9816CLASS="INFORMALTABLE"
9817><P
9818></P
9819><TABLE
9820BORDER="0"
9821WIDTH="100%"
9822BGCOLOR="#FFD0D0"
9823CELLSPACING="0"
9824CELLPADDING="4"
9825CLASS="CALSTABLE"
9826><TR
9827><TD
9828WIDTH="20%"
9829ALIGN="RIGHT"
9830VALIGN="TOP"
9831><TT
9832CLASS="PARAMETER"
9833><I
9834>ctxt</I
9835></TT
9836>&nbsp;:</TD
9837><TD
9838WIDTH="80%"
9839ALIGN="LEFT"
9840VALIGN="TOP"
9841>&nbsp;</TD
9842></TR
9843><TR
9844><TD
9845WIDTH="20%"
9846ALIGN="RIGHT"
9847VALIGN="TOP"
9848><TT
9849CLASS="PARAMETER"
9850><I
9851>name</I
9852></TT
9853>&nbsp;:</TD
9854><TD
9855WIDTH="80%"
9856ALIGN="LEFT"
9857VALIGN="TOP"
9858>&nbsp;</TD
9859></TR
9860><TR
9861><TD
9862WIDTH="20%"
9863ALIGN="RIGHT"
9864VALIGN="TOP"
9865><TT
9866CLASS="PARAMETER"
9867><I
9868>value</I
9869></TT
9870>&nbsp;:</TD
9871><TD
9872WIDTH="80%"
9873ALIGN="LEFT"
9874VALIGN="TOP"
9875>&nbsp;</TD
9876></TR
9877><TR
9878><TD
9879WIDTH="20%"
9880ALIGN="RIGHT"
9881VALIGN="TOP"
9882><I
9883CLASS="EMPHASIS"
9884>Returns</I
9885> :</TD
9886><TD
9887WIDTH="80%"
9888ALIGN="LEFT"
9889VALIGN="TOP"
9890>&#13;</TD
9891></TR
9892></TABLE
9893><P
9894></P
9895></DIV
9896></DIV
9897><HR><DIV
9898CLASS="REFSECT2"
9899><A
9900NAME="AEN2378"
9901></A
9902><H3
9903><A
9904NAME="XMLCREATEPUSHPARSERCTXT"
9905></A
9906>xmlCreatePushParserCtxt ()</H3
9907><TABLE
9908BORDER="0"
9909BGCOLOR="#D6E8FF"
9910WIDTH="100%"
9911CELLPADDING="6"
9912><TR
9913><TD
9914><PRE
9915CLASS="PROGRAMLISTING"
9916><A
9917HREF="libxml-parser.html#XMLPARSERCTXTPTR"
9918>xmlParserCtxtPtr</A
9919> xmlCreatePushParserCtxt    (<A
9920HREF="libxml-parser.html#XMLSAXHANDLERPTR"
9921>xmlSAXHandlerPtr</A
9922> sax,
9923                                             void *user_data,
9924                                             const char *chunk,
9925                                             int size,
9926                                             const char *filename);</PRE
9927></TD
9928></TR
9929></TABLE
9930><P
9931>Create a parser context for using the XML parser in push mode
9932To allow content encoding detection, <TT
9933CLASS="PARAMETER"
9934><I
9935>size</I
9936></TT
9937> should be &gt;= 4
9938The value of <TT
9939CLASS="PARAMETER"
9940><I
9941>filename</I
9942></TT
9943> is used for fetching external entities
9944and error/warning reports.</P
9945><P
9946></P
9947><DIV
9948CLASS="INFORMALTABLE"
9949><P
9950></P
9951><TABLE
9952BORDER="0"
9953WIDTH="100%"
9954BGCOLOR="#FFD0D0"
9955CELLSPACING="0"
9956CELLPADDING="4"
9957CLASS="CALSTABLE"
9958><TR
9959><TD
9960WIDTH="20%"
9961ALIGN="RIGHT"
9962VALIGN="TOP"
9963><TT
9964CLASS="PARAMETER"
9965><I
9966>sax</I
9967></TT
9968>&nbsp;:</TD
9969><TD
9970WIDTH="80%"
9971ALIGN="LEFT"
9972VALIGN="TOP"
9973>  a SAX handler</TD
9974></TR
9975><TR
9976><TD
9977WIDTH="20%"
9978ALIGN="RIGHT"
9979VALIGN="TOP"
9980><TT
9981CLASS="PARAMETER"
9982><I
9983>user_data</I
9984></TT
9985>&nbsp;:</TD
9986><TD
9987WIDTH="80%"
9988ALIGN="LEFT"
9989VALIGN="TOP"
9990>  The user data returned on SAX callbacks</TD
9991></TR
9992><TR
9993><TD
9994WIDTH="20%"
9995ALIGN="RIGHT"
9996VALIGN="TOP"
9997><TT
9998CLASS="PARAMETER"
9999><I
10000>chunk</I
10001></TT
10002>&nbsp;:</TD
10003><TD
10004WIDTH="80%"
10005ALIGN="LEFT"
10006VALIGN="TOP"
10007>  a pointer to an array of chars</TD
10008></TR
10009><TR
10010><TD
10011WIDTH="20%"
10012ALIGN="RIGHT"
10013VALIGN="TOP"
10014><TT
10015CLASS="PARAMETER"
10016><I
10017>size</I
10018></TT
10019>&nbsp;:</TD
10020><TD
10021WIDTH="80%"
10022ALIGN="LEFT"
10023VALIGN="TOP"
10024>  number of chars in the array</TD
10025></TR
10026><TR
10027><TD
10028WIDTH="20%"
10029ALIGN="RIGHT"
10030VALIGN="TOP"
10031><TT
10032CLASS="PARAMETER"
10033><I
10034>filename</I
10035></TT
10036>&nbsp;:</TD
10037><TD
10038WIDTH="80%"
10039ALIGN="LEFT"
10040VALIGN="TOP"
10041>  an optional file name or URI</TD
10042></TR
10043><TR
10044><TD
10045WIDTH="20%"
10046ALIGN="RIGHT"
10047VALIGN="TOP"
10048><I
10049CLASS="EMPHASIS"
10050>Returns</I
10051> :</TD
10052><TD
10053WIDTH="80%"
10054ALIGN="LEFT"
10055VALIGN="TOP"
10056>the new parser context or NULL</TD
10057></TR
10058></TABLE
10059><P
10060></P
10061></DIV
10062></DIV
10063><HR><DIV
10064CLASS="REFSECT2"
10065><A
10066NAME="AEN2417"
10067></A
10068><H3
10069><A
10070NAME="XMLPARSECHUNK"
10071></A
10072>xmlParseChunk ()</H3
10073><TABLE
10074BORDER="0"
10075BGCOLOR="#D6E8FF"
10076WIDTH="100%"
10077CELLPADDING="6"
10078><TR
10079><TD
10080><PRE
10081CLASS="PROGRAMLISTING"
10082>int         xmlParseChunk                   (<A
10083HREF="libxml-parser.html#XMLPARSERCTXTPTR"
10084>xmlParserCtxtPtr</A
10085> ctxt,
10086                                             const char *chunk,
10087                                             int size,
10088                                             int terminate);</PRE
10089></TD
10090></TR
10091></TABLE
10092><P
10093>Parse a Chunk of memory</P
10094><P
10095></P
10096><DIV
10097CLASS="INFORMALTABLE"
10098><P
10099></P
10100><TABLE
10101BORDER="0"
10102WIDTH="100%"
10103BGCOLOR="#FFD0D0"
10104CELLSPACING="0"
10105CELLPADDING="4"
10106CLASS="CALSTABLE"
10107><TR
10108><TD
10109WIDTH="20%"
10110ALIGN="RIGHT"
10111VALIGN="TOP"
10112><TT
10113CLASS="PARAMETER"
10114><I
10115>ctxt</I
10116></TT
10117>&nbsp;:</TD
10118><TD
10119WIDTH="80%"
10120ALIGN="LEFT"
10121VALIGN="TOP"
10122>  an XML parser context</TD
10123></TR
10124><TR
10125><TD
10126WIDTH="20%"
10127ALIGN="RIGHT"
10128VALIGN="TOP"
10129><TT
10130CLASS="PARAMETER"
10131><I
10132>chunk</I
10133></TT
10134>&nbsp;:</TD
10135><TD
10136WIDTH="80%"
10137ALIGN="LEFT"
10138VALIGN="TOP"
10139>  an char array</TD
10140></TR
10141><TR
10142><TD
10143WIDTH="20%"
10144ALIGN="RIGHT"
10145VALIGN="TOP"
10146><TT
10147CLASS="PARAMETER"
10148><I
10149>size</I
10150></TT
10151>&nbsp;:</TD
10152><TD
10153WIDTH="80%"
10154ALIGN="LEFT"
10155VALIGN="TOP"
10156>  the size in byte of the chunk</TD
10157></TR
10158><TR
10159><TD
10160WIDTH="20%"
10161ALIGN="RIGHT"
10162VALIGN="TOP"
10163><TT
10164CLASS="PARAMETER"
10165><I
10166>terminate</I
10167></TT
10168>&nbsp;:</TD
10169><TD
10170WIDTH="80%"
10171ALIGN="LEFT"
10172VALIGN="TOP"
10173>  last chunk indicator</TD
10174></TR
10175><TR
10176><TD
10177WIDTH="20%"
10178ALIGN="RIGHT"
10179VALIGN="TOP"
10180><I
10181CLASS="EMPHASIS"
10182>Returns</I
10183> :</TD
10184><TD
10185WIDTH="80%"
10186ALIGN="LEFT"
10187VALIGN="TOP"
10188>zero if no error, the xmlParserErrors otherwise.</TD
10189></TR
10190></TABLE
10191><P
10192></P
10193></DIV
10194></DIV
10195><HR><DIV
10196CLASS="REFSECT2"
10197><A
10198NAME="AEN2449"
10199></A
10200><H3
10201><A
10202NAME="XMLCREATEIOPARSERCTXT"
10203></A
10204>xmlCreateIOParserCtxt ()</H3
10205><TABLE
10206BORDER="0"
10207BGCOLOR="#D6E8FF"
10208WIDTH="100%"
10209CELLPADDING="6"
10210><TR
10211><TD
10212><PRE
10213CLASS="PROGRAMLISTING"
10214><A
10215HREF="libxml-parser.html#XMLPARSERCTXTPTR"
10216>xmlParserCtxtPtr</A
10217> xmlCreateIOParserCtxt      (<A
10218HREF="libxml-parser.html#XMLSAXHANDLERPTR"
10219>xmlSAXHandlerPtr</A
10220> sax,
10221                                             void *user_data,
10222                                             <A
10223HREF="libxml-xmlio.html#XMLINPUTREADCALLBACK"
10224>xmlInputReadCallback</A
10225> ioread,
10226                                             <A
10227HREF="libxml-xmlio.html#XMLINPUTCLOSECALLBACK"
10228>xmlInputCloseCallback</A
10229> ioclose,
10230                                             void *ioctx,
10231                                             <A
10232HREF="libxml-encoding.html#XMLCHARENCODING"
10233>xmlCharEncoding</A
10234> enc);</PRE
10235></TD
10236></TR
10237></TABLE
10238><P
10239>Create a parser context for using the XML parser with an existing
10240I/O stream</P
10241><P
10242></P
10243><DIV
10244CLASS="INFORMALTABLE"
10245><P
10246></P
10247><TABLE
10248BORDER="0"
10249WIDTH="100%"
10250BGCOLOR="#FFD0D0"
10251CELLSPACING="0"
10252CELLPADDING="4"
10253CLASS="CALSTABLE"
10254><TR
10255><TD
10256WIDTH="20%"
10257ALIGN="RIGHT"
10258VALIGN="TOP"
10259><TT
10260CLASS="PARAMETER"
10261><I
10262>sax</I
10263></TT
10264>&nbsp;:</TD
10265><TD
10266WIDTH="80%"
10267ALIGN="LEFT"
10268VALIGN="TOP"
10269>  a SAX handler</TD
10270></TR
10271><TR
10272><TD
10273WIDTH="20%"
10274ALIGN="RIGHT"
10275VALIGN="TOP"
10276><TT
10277CLASS="PARAMETER"
10278><I
10279>user_data</I
10280></TT
10281>&nbsp;:</TD
10282><TD
10283WIDTH="80%"
10284ALIGN="LEFT"
10285VALIGN="TOP"
10286>  The user data returned on SAX callbacks</TD
10287></TR
10288><TR
10289><TD
10290WIDTH="20%"
10291ALIGN="RIGHT"
10292VALIGN="TOP"
10293><TT
10294CLASS="PARAMETER"
10295><I
10296>ioread</I
10297></TT
10298>&nbsp;:</TD
10299><TD
10300WIDTH="80%"
10301ALIGN="LEFT"
10302VALIGN="TOP"
10303>  an I/O read function</TD
10304></TR
10305><TR
10306><TD
10307WIDTH="20%"
10308ALIGN="RIGHT"
10309VALIGN="TOP"
10310><TT
10311CLASS="PARAMETER"
10312><I
10313>ioclose</I
10314></TT
10315>&nbsp;:</TD
10316><TD
10317WIDTH="80%"
10318ALIGN="LEFT"
10319VALIGN="TOP"
10320>  an I/O close function</TD
10321></TR
10322><TR
10323><TD
10324WIDTH="20%"
10325ALIGN="RIGHT"
10326VALIGN="TOP"
10327><TT
10328CLASS="PARAMETER"
10329><I
10330>ioctx</I
10331></TT
10332>&nbsp;:</TD
10333><TD
10334WIDTH="80%"
10335ALIGN="LEFT"
10336VALIGN="TOP"
10337>  an I/O handler</TD
10338></TR
10339><TR
10340><TD
10341WIDTH="20%"
10342ALIGN="RIGHT"
10343VALIGN="TOP"
10344><TT
10345CLASS="PARAMETER"
10346><I
10347>enc</I
10348></TT
10349>&nbsp;:</TD
10350><TD
10351WIDTH="80%"
10352ALIGN="LEFT"
10353VALIGN="TOP"
10354>  the charset encoding if known</TD
10355></TR
10356><TR
10357><TD
10358WIDTH="20%"
10359ALIGN="RIGHT"
10360VALIGN="TOP"
10361><I
10362CLASS="EMPHASIS"
10363>Returns</I
10364> :</TD
10365><TD
10366WIDTH="80%"
10367ALIGN="LEFT"
10368VALIGN="TOP"
10369>the new parser context or NULL</TD
10370></TR
10371></TABLE
10372><P
10373></P
10374></DIV
10375></DIV
10376><HR><DIV
10377CLASS="REFSECT2"
10378><A
10379NAME="AEN2493"
10380></A
10381><H3
10382><A
10383NAME="XMLNEWIOINPUTSTREAM"
10384></A
10385>xmlNewIOInputStream ()</H3
10386><TABLE
10387BORDER="0"
10388BGCOLOR="#D6E8FF"
10389WIDTH="100%"
10390CELLPADDING="6"
10391><TR
10392><TD
10393><PRE
10394CLASS="PROGRAMLISTING"
10395><A
10396HREF="libxml-parser.html#XMLPARSERINPUTPTR"
10397>xmlParserInputPtr</A
10398> xmlNewIOInputStream       (<A
10399HREF="libxml-parser.html#XMLPARSERCTXTPTR"
10400>xmlParserCtxtPtr</A
10401> ctxt,
10402                                             <A
10403HREF="libxml-xmlio.html#XMLPARSERINPUTBUFFERPTR"
10404>xmlParserInputBufferPtr</A
10405> input,
10406                                             <A
10407HREF="libxml-encoding.html#XMLCHARENCODING"
10408>xmlCharEncoding</A
10409> enc);</PRE
10410></TD
10411></TR
10412></TABLE
10413><P
10414>Create a new input stream structure encapsulating the <TT
10415CLASS="PARAMETER"
10416><I
10417>input</I
10418></TT
10419> into
10420a stream suitable for the parser.</P
10421><P
10422></P
10423><DIV
10424CLASS="INFORMALTABLE"
10425><P
10426></P
10427><TABLE
10428BORDER="0"
10429WIDTH="100%"
10430BGCOLOR="#FFD0D0"
10431CELLSPACING="0"
10432CELLPADDING="4"
10433CLASS="CALSTABLE"
10434><TR
10435><TD
10436WIDTH="20%"
10437ALIGN="RIGHT"
10438VALIGN="TOP"
10439><TT
10440CLASS="PARAMETER"
10441><I
10442>ctxt</I
10443></TT
10444>&nbsp;:</TD
10445><TD
10446WIDTH="80%"
10447ALIGN="LEFT"
10448VALIGN="TOP"
10449>  an XML parser context</TD
10450></TR
10451><TR
10452><TD
10453WIDTH="20%"
10454ALIGN="RIGHT"
10455VALIGN="TOP"
10456><TT
10457CLASS="PARAMETER"
10458><I
10459>input</I
10460></TT
10461>&nbsp;:</TD
10462><TD
10463WIDTH="80%"
10464ALIGN="LEFT"
10465VALIGN="TOP"
10466>  an I/O Input</TD
10467></TR
10468><TR
10469><TD
10470WIDTH="20%"
10471ALIGN="RIGHT"
10472VALIGN="TOP"
10473><TT
10474CLASS="PARAMETER"
10475><I
10476>enc</I
10477></TT
10478>&nbsp;:</TD
10479><TD
10480WIDTH="80%"
10481ALIGN="LEFT"
10482VALIGN="TOP"
10483>  the charset encoding if known</TD
10484></TR
10485><TR
10486><TD
10487WIDTH="20%"
10488ALIGN="RIGHT"
10489VALIGN="TOP"
10490><I
10491CLASS="EMPHASIS"
10492>Returns</I
10493> :</TD
10494><TD
10495WIDTH="80%"
10496ALIGN="LEFT"
10497VALIGN="TOP"
10498>the new input stream or NULL</TD
10499></TR
10500></TABLE
10501><P
10502></P
10503></DIV
10504></DIV
10505><HR><DIV
10506CLASS="REFSECT2"
10507><A
10508NAME="AEN2525"
10509></A
10510><H3
10511><A
10512NAME="XMLPARSERFINDNODEINFO"
10513></A
10514>xmlParserFindNodeInfo ()</H3
10515><TABLE
10516BORDER="0"
10517BGCOLOR="#D6E8FF"
10518WIDTH="100%"
10519CELLPADDING="6"
10520><TR
10521><TD
10522><PRE
10523CLASS="PROGRAMLISTING"
10524>const <A
10525HREF="libxml-parser.html#XMLPARSERNODEINFO"
10526>xmlParserNodeInfo</A
10527>* xmlParserFindNodeInfo
10528                                            (const <A
10529HREF="libxml-parser.html#XMLPARSERCTXT"
10530>xmlParserCtxt</A
10531> *ctxt,
10532                                             const <A
10533HREF="libxml-tree.html#XMLNODE"
10534>xmlNode</A
10535> *node);</PRE
10536></TD
10537></TR
10538></TABLE
10539><P
10540>Find the parser node info struct for a given node</P
10541><P
10542></P
10543><DIV
10544CLASS="INFORMALTABLE"
10545><P
10546></P
10547><TABLE
10548BORDER="0"
10549WIDTH="100%"
10550BGCOLOR="#FFD0D0"
10551CELLSPACING="0"
10552CELLPADDING="4"
10553CLASS="CALSTABLE"
10554><TR
10555><TD
10556WIDTH="20%"
10557ALIGN="RIGHT"
10558VALIGN="TOP"
10559><TT
10560CLASS="PARAMETER"
10561><I
10562>ctxt</I
10563></TT
10564>&nbsp;:</TD
10565><TD
10566WIDTH="80%"
10567ALIGN="LEFT"
10568VALIGN="TOP"
10569>  an XML parser context</TD
10570></TR
10571><TR
10572><TD
10573WIDTH="20%"
10574ALIGN="RIGHT"
10575VALIGN="TOP"
10576><TT
10577CLASS="PARAMETER"
10578><I
10579>node</I
10580></TT
10581>&nbsp;:</TD
10582><TD
10583WIDTH="80%"
10584ALIGN="LEFT"
10585VALIGN="TOP"
10586>  an XML node within the tree</TD
10587></TR
10588><TR
10589><TD
10590WIDTH="20%"
10591ALIGN="RIGHT"
10592VALIGN="TOP"
10593><I
10594CLASS="EMPHASIS"
10595>Returns</I
10596> :</TD
10597><TD
10598WIDTH="80%"
10599ALIGN="LEFT"
10600VALIGN="TOP"
10601>an xmlParserNodeInfo block pointer or NULL</TD
10602></TR
10603></TABLE
10604><P
10605></P
10606></DIV
10607></DIV
10608><HR><DIV
10609CLASS="REFSECT2"
10610><A
10611NAME="AEN2551"
10612></A
10613><H3
10614><A
10615NAME="XMLINITNODEINFOSEQ"
10616></A
10617>xmlInitNodeInfoSeq ()</H3
10618><TABLE
10619BORDER="0"
10620BGCOLOR="#D6E8FF"
10621WIDTH="100%"
10622CELLPADDING="6"
10623><TR
10624><TD
10625><PRE
10626CLASS="PROGRAMLISTING"
10627>void        xmlInitNodeInfoSeq              (<A
10628HREF="libxml-parser.html#XMLPARSERNODEINFOSEQPTR"
10629>xmlParserNodeInfoSeqPtr</A
10630> seq);</PRE
10631></TD
10632></TR
10633></TABLE
10634><P
10635>-- Initialize (set to initial state) node info sequence</P
10636><P
10637></P
10638><DIV
10639CLASS="INFORMALTABLE"
10640><P
10641></P
10642><TABLE
10643BORDER="0"
10644WIDTH="100%"
10645BGCOLOR="#FFD0D0"
10646CELLSPACING="0"
10647CELLPADDING="4"
10648CLASS="CALSTABLE"
10649><TR
10650><TD
10651WIDTH="20%"
10652ALIGN="RIGHT"
10653VALIGN="TOP"
10654><TT
10655CLASS="PARAMETER"
10656><I
10657>seq</I
10658></TT
10659>&nbsp;:</TD
10660><TD
10661WIDTH="80%"
10662ALIGN="LEFT"
10663VALIGN="TOP"
10664>  a node info sequence pointer</TD
10665></TR
10666></TABLE
10667><P
10668></P
10669></DIV
10670></DIV
10671><HR><DIV
10672CLASS="REFSECT2"
10673><A
10674NAME="AEN2567"
10675></A
10676><H3
10677><A
10678NAME="XMLCLEARNODEINFOSEQ"
10679></A
10680>xmlClearNodeInfoSeq ()</H3
10681><TABLE
10682BORDER="0"
10683BGCOLOR="#D6E8FF"
10684WIDTH="100%"
10685CELLPADDING="6"
10686><TR
10687><TD
10688><PRE
10689CLASS="PROGRAMLISTING"
10690>void        xmlClearNodeInfoSeq             (<A
10691HREF="libxml-parser.html#XMLPARSERNODEINFOSEQPTR"
10692>xmlParserNodeInfoSeqPtr</A
10693> seq);</PRE
10694></TD
10695></TR
10696></TABLE
10697><P
10698>-- Clear (release memory and reinitialize) node
10699info sequence</P
10700><P
10701></P
10702><DIV
10703CLASS="INFORMALTABLE"
10704><P
10705></P
10706><TABLE
10707BORDER="0"
10708WIDTH="100%"
10709BGCOLOR="#FFD0D0"
10710CELLSPACING="0"
10711CELLPADDING="4"
10712CLASS="CALSTABLE"
10713><TR
10714><TD
10715WIDTH="20%"
10716ALIGN="RIGHT"
10717VALIGN="TOP"
10718><TT
10719CLASS="PARAMETER"
10720><I
10721>seq</I
10722></TT
10723>&nbsp;:</TD
10724><TD
10725WIDTH="80%"
10726ALIGN="LEFT"
10727VALIGN="TOP"
10728>  a node info sequence pointer</TD
10729></TR
10730></TABLE
10731><P
10732></P
10733></DIV
10734></DIV
10735><HR><DIV
10736CLASS="REFSECT2"
10737><A
10738NAME="AEN2583"
10739></A
10740><H3
10741><A
10742NAME="XMLPARSERFINDNODEINFOINDEX"
10743></A
10744>xmlParserFindNodeInfoIndex ()</H3
10745><TABLE
10746BORDER="0"
10747BGCOLOR="#D6E8FF"
10748WIDTH="100%"
10749CELLPADDING="6"
10750><TR
10751><TD
10752><PRE
10753CLASS="PROGRAMLISTING"
10754>unsigned <GTKDOCLINK
10755HREF="LONG"
10756>long</GTKDOCLINK
10757> xmlParserFindNodeInfoIndex    (const <A
10758HREF="libxml-parser.html#XMLPARSERNODEINFOSEQ"
10759>xmlParserNodeInfoSeq</A
10760> *seq,
10761                                             const <A
10762HREF="libxml-tree.html#XMLNODE"
10763>xmlNode</A
10764> *node);</PRE
10765></TD
10766></TR
10767></TABLE
10768><P
10769>xmlParserFindNodeInfoIndex : Find the index that the info record for
10770the given node is or should be at in a sorted sequence</P
10771><P
10772></P
10773><DIV
10774CLASS="INFORMALTABLE"
10775><P
10776></P
10777><TABLE
10778BORDER="0"
10779WIDTH="100%"
10780BGCOLOR="#FFD0D0"
10781CELLSPACING="0"
10782CELLPADDING="4"
10783CLASS="CALSTABLE"
10784><TR
10785><TD
10786WIDTH="20%"
10787ALIGN="RIGHT"
10788VALIGN="TOP"
10789><TT
10790CLASS="PARAMETER"
10791><I
10792>seq</I
10793></TT
10794>&nbsp;:</TD
10795><TD
10796WIDTH="80%"
10797ALIGN="LEFT"
10798VALIGN="TOP"
10799>  a node info sequence pointer</TD
10800></TR
10801><TR
10802><TD
10803WIDTH="20%"
10804ALIGN="RIGHT"
10805VALIGN="TOP"
10806><TT
10807CLASS="PARAMETER"
10808><I
10809>node</I
10810></TT
10811>&nbsp;:</TD
10812><TD
10813WIDTH="80%"
10814ALIGN="LEFT"
10815VALIGN="TOP"
10816>  an XML node pointer</TD
10817></TR
10818><TR
10819><TD
10820WIDTH="20%"
10821ALIGN="RIGHT"
10822VALIGN="TOP"
10823><I
10824CLASS="EMPHASIS"
10825>Returns</I
10826> :</TD
10827><TD
10828WIDTH="80%"
10829ALIGN="LEFT"
10830VALIGN="TOP"
10831>a long indicating the position of the record</TD
10832></TR
10833></TABLE
10834><P
10835></P
10836></DIV
10837></DIV
10838><HR><DIV
10839CLASS="REFSECT2"
10840><A
10841NAME="AEN2609"
10842></A
10843><H3
10844><A
10845NAME="XMLPARSERADDNODEINFO"
10846></A
10847>xmlParserAddNodeInfo ()</H3
10848><TABLE
10849BORDER="0"
10850BGCOLOR="#D6E8FF"
10851WIDTH="100%"
10852CELLPADDING="6"
10853><TR
10854><TD
10855><PRE
10856CLASS="PROGRAMLISTING"
10857>void        xmlParserAddNodeInfo            (<A
10858HREF="libxml-parser.html#XMLPARSERCTXTPTR"
10859>xmlParserCtxtPtr</A
10860> ctxt,
10861                                             const <A
10862HREF="libxml-parser.html#XMLPARSERNODEINFO"
10863>xmlParserNodeInfo</A
10864> *info);</PRE
10865></TD
10866></TR
10867></TABLE
10868><P
10869>Insert node info record into the sorted sequence</P
10870><P
10871></P
10872><DIV
10873CLASS="INFORMALTABLE"
10874><P
10875></P
10876><TABLE
10877BORDER="0"
10878WIDTH="100%"
10879BGCOLOR="#FFD0D0"
10880CELLSPACING="0"
10881CELLPADDING="4"
10882CLASS="CALSTABLE"
10883><TR
10884><TD
10885WIDTH="20%"
10886ALIGN="RIGHT"
10887VALIGN="TOP"
10888><TT
10889CLASS="PARAMETER"
10890><I
10891>ctxt</I
10892></TT
10893>&nbsp;:</TD
10894><TD
10895WIDTH="80%"
10896ALIGN="LEFT"
10897VALIGN="TOP"
10898>  an XML parser context</TD
10899></TR
10900><TR
10901><TD
10902WIDTH="20%"
10903ALIGN="RIGHT"
10904VALIGN="TOP"
10905><TT
10906CLASS="PARAMETER"
10907><I
10908>info</I
10909></TT
10910>&nbsp;:</TD
10911><TD
10912WIDTH="80%"
10913ALIGN="LEFT"
10914VALIGN="TOP"
10915>  a node info sequence pointer</TD
10916></TR
10917></TABLE
10918><P
10919></P
10920></DIV
10921></DIV
10922><HR><DIV
10923CLASS="REFSECT2"
10924><A
10925NAME="AEN2630"
10926></A
10927><H3
10928><A
10929NAME="XMLSETEXTERNALENTITYLOADER"
10930></A
10931>xmlSetExternalEntityLoader ()</H3
10932><TABLE
10933BORDER="0"
10934BGCOLOR="#D6E8FF"
10935WIDTH="100%"
10936CELLPADDING="6"
10937><TR
10938><TD
10939><PRE
10940CLASS="PROGRAMLISTING"
10941>void        xmlSetExternalEntityLoader      (<A
10942HREF="libxml-parser.html#XMLEXTERNALENTITYLOADER"
10943>xmlExternalEntityLoader</A
10944> f);</PRE
10945></TD
10946></TR
10947></TABLE
10948><P
10949></P
10950><DIV
10951CLASS="INFORMALTABLE"
10952><P
10953></P
10954><TABLE
10955BORDER="0"
10956WIDTH="100%"
10957BGCOLOR="#FFD0D0"
10958CELLSPACING="0"
10959CELLPADDING="4"
10960CLASS="CALSTABLE"
10961><TR
10962><TD
10963WIDTH="20%"
10964ALIGN="RIGHT"
10965VALIGN="TOP"
10966><TT
10967CLASS="PARAMETER"
10968><I
10969>f</I
10970></TT
10971>&nbsp;:</TD
10972><TD
10973WIDTH="80%"
10974ALIGN="LEFT"
10975VALIGN="TOP"
10976>&#13;</TD
10977></TR
10978></TABLE
10979><P
10980></P
10981></DIV
10982></DIV
10983><HR><DIV
10984CLASS="REFSECT2"
10985><A
10986NAME="AEN2645"
10987></A
10988><H3
10989><A
10990NAME="XMLGETEXTERNALENTITYLOADER"
10991></A
10992>xmlGetExternalEntityLoader ()</H3
10993><TABLE
10994BORDER="0"
10995BGCOLOR="#D6E8FF"
10996WIDTH="100%"
10997CELLPADDING="6"
10998><TR
10999><TD
11000><PRE
11001CLASS="PROGRAMLISTING"
11002><A
11003HREF="libxml-parser.html#XMLEXTERNALENTITYLOADER"
11004>xmlExternalEntityLoader</A
11005> xmlGetExternalEntityLoader
11006                                            (void);</PRE
11007></TD
11008></TR
11009></TABLE
11010><P
11011></P
11012><DIV
11013CLASS="INFORMALTABLE"
11014><P
11015></P
11016><TABLE
11017BORDER="0"
11018WIDTH="100%"
11019BGCOLOR="#FFD0D0"
11020CELLSPACING="0"
11021CELLPADDING="4"
11022CLASS="CALSTABLE"
11023><TR
11024><TD
11025WIDTH="20%"
11026ALIGN="RIGHT"
11027VALIGN="TOP"
11028><I
11029CLASS="EMPHASIS"
11030>Returns</I
11031> :</TD
11032><TD
11033WIDTH="80%"
11034ALIGN="LEFT"
11035VALIGN="TOP"
11036>&#13;</TD
11037></TR
11038></TABLE
11039><P
11040></P
11041></DIV
11042></DIV
11043><HR><DIV
11044CLASS="REFSECT2"
11045><A
11046NAME="AEN2660"
11047></A
11048><H3
11049><A
11050NAME="XMLLOADEXTERNALENTITY"
11051></A
11052>xmlLoadExternalEntity ()</H3
11053><TABLE
11054BORDER="0"
11055BGCOLOR="#D6E8FF"
11056WIDTH="100%"
11057CELLPADDING="6"
11058><TR
11059><TD
11060><PRE
11061CLASS="PROGRAMLISTING"
11062><A
11063HREF="libxml-parser.html#XMLPARSERINPUTPTR"
11064>xmlParserInputPtr</A
11065> xmlLoadExternalEntity     (const char *URL,
11066                                             const char *ID,
11067                                             <A
11068HREF="libxml-parser.html#XMLPARSERCTXTPTR"
11069>xmlParserCtxtPtr</A
11070> context);</PRE
11071></TD
11072></TR
11073></TABLE
11074><P
11075></P
11076><DIV
11077CLASS="INFORMALTABLE"
11078><P
11079></P
11080><TABLE
11081BORDER="0"
11082WIDTH="100%"
11083BGCOLOR="#FFD0D0"
11084CELLSPACING="0"
11085CELLPADDING="4"
11086CLASS="CALSTABLE"
11087><TR
11088><TD
11089WIDTH="20%"
11090ALIGN="RIGHT"
11091VALIGN="TOP"
11092><TT
11093CLASS="PARAMETER"
11094><I
11095>URL</I
11096></TT
11097>&nbsp;:</TD
11098><TD
11099WIDTH="80%"
11100ALIGN="LEFT"
11101VALIGN="TOP"
11102>&nbsp;</TD
11103></TR
11104><TR
11105><TD
11106WIDTH="20%"
11107ALIGN="RIGHT"
11108VALIGN="TOP"
11109><TT
11110CLASS="PARAMETER"
11111><I
11112>ID</I
11113></TT
11114>&nbsp;:</TD
11115><TD
11116WIDTH="80%"
11117ALIGN="LEFT"
11118VALIGN="TOP"
11119>&nbsp;</TD
11120></TR
11121><TR
11122><TD
11123WIDTH="20%"
11124ALIGN="RIGHT"
11125VALIGN="TOP"
11126><TT
11127CLASS="PARAMETER"
11128><I
11129>context</I
11130></TT
11131>&nbsp;:</TD
11132><TD
11133WIDTH="80%"
11134ALIGN="LEFT"
11135VALIGN="TOP"
11136>&nbsp;</TD
11137></TR
11138><TR
11139><TD
11140WIDTH="20%"
11141ALIGN="RIGHT"
11142VALIGN="TOP"
11143><I
11144CLASS="EMPHASIS"
11145>Returns</I
11146> :</TD
11147><TD
11148WIDTH="80%"
11149ALIGN="LEFT"
11150VALIGN="TOP"
11151>&#13;</TD
11152></TR
11153></TABLE
11154><P
11155></P
11156></DIV
11157></DIV
11158></DIV
11159><DIV
11160CLASS="NAVFOOTER"
11161><BR
11162CLEAR="all"><BR><TABLE
11163WIDTH="100%"
11164BORDER="0"
11165BGCOLOR="#000000"
11166CELLPADDING="1"
11167CELLSPACING="0"
11168><TR
11169><TD
11170WIDTH="25%"
11171BGCOLOR="#C00000"
11172ALIGN="left"
11173><A
11174HREF="libxml-lib.html"
11175><FONT
11176COLOR="#FFFFFF"
11177SIZE="3"
11178><B
11179>&#60;&#60;&#60; Previous Page</B
11180></FONT
11181></A
11182></TD
11183><TD
11184WIDTH="25%"
11185BGCOLOR="#0000C0"
11186ALIGN="center"
11187><FONT
11188COLOR="#FFFFFF"
11189SIZE="3"
11190><B
11191><A
11192HREF="book1.html"
11193><FONT
11194COLOR="#FFFFFF"
11195SIZE="3"
11196><B
11197>Home</B
11198></FONT
11199></A
11200></B
11201></FONT
11202></TD
11203><TD
11204WIDTH="25%"
11205BGCOLOR="#00C000"
11206ALIGN="center"
11207><FONT
11208COLOR="#FFFFFF"
11209SIZE="3"
11210><B
11211><A
11212HREF="libxml-lib.html"
11213><FONT
11214COLOR="#FFFFFF"
11215SIZE="3"
11216><B
11217>Up</B
11218></FONT
11219></A
11220></B
11221></FONT
11222></TD
11223><TD
11224WIDTH="25%"
11225BGCOLOR="#C00000"
11226ALIGN="right"
11227><A
11228HREF="libxml-sax.html"
11229><FONT
11230COLOR="#FFFFFF"
11231SIZE="3"
11232><B
11233>Next Page &#62;&#62;&#62;</B
11234></FONT
11235></A
11236></TD
11237></TR
11238><TR
11239><TD
11240COLSPAN="2"
11241ALIGN="left"
11242><FONT
11243COLOR="#FFFFFF"
11244SIZE="3"
11245><B
11246>Libxml Library Reference</B
11247></FONT
11248></TD
11249><TD
11250COLSPAN="2"
11251ALIGN="right"
11252><FONT
11253COLOR="#FFFFFF"
11254SIZE="3"
11255><B
11256>SAX</B
11257></FONT
11258></TD
11259></TR
11260></TABLE
11261></DIV
11262></BODY
11263></HTML
11264>