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