Lines Matching refs:reader
82 #define DUMP_READER xmlTextReaderDebug(reader);
191 #define CONSTSTR(str) xmlDictLookup(reader->dict, (str), -1)
192 #define CONSTQSTR(p, str) xmlDictQLookup(reader->dict, (p), (str))
194 static int xmlTextReaderReadTree(xmlTextReaderPtr reader);
195 static int xmlTextReaderNextTree(xmlTextReaderPtr reader);
214 static void xmlTextReaderFreeNode(xmlTextReaderPtr reader, xmlNodePtr cur);
215 static void xmlTextReaderFreeNodeList(xmlTextReaderPtr reader, xmlNodePtr cur);
273 * @reader: the xmlTextReaderPtr used
279 xmlTextReaderFreeProp(xmlTextReaderPtr reader, xmlAttrPtr cur) {
282 dict = reader->ctxt->dict;
296 xmlTextReaderFreeNodeList(reader, cur->children);
299 if ((reader != NULL) && (reader->ctxt != NULL) &&
300 (reader->ctxt->freeAttrsNr < 100)) {
301 cur->next = reader->ctxt->freeAttrs;
302 reader->ctxt->freeAttrs = cur;
303 reader->ctxt->freeAttrsNr++;
311 * @reader: the xmlTextReaderPtr used
317 xmlTextReaderFreePropList(xmlTextReaderPtr reader, xmlAttrPtr cur) {
322 xmlTextReaderFreeProp(reader, cur);
329 * @reader: the xmlTextReaderPtr used
336 xmlTextReaderFreeNodeList(xmlTextReaderPtr reader, xmlNodePtr cur) {
340 dict = reader->ctxt->dict;
359 xmlTextReaderFreeNodeList(reader, cur->children);
370 xmlTextReaderFreePropList(reader, cur->properties);
392 (reader != NULL) && (reader->ctxt != NULL) &&
393 (reader->ctxt->freeElemsNr < 100)) {
394 cur->next = reader->ctxt->freeElems;
395 reader->ctxt->freeElems = cur;
396 reader->ctxt->freeElemsNr++;
407 * @reader: the xmlTextReaderPtr used
414 xmlTextReaderFreeNode(xmlTextReaderPtr reader, xmlNodePtr cur) {
417 dict = reader->ctxt->dict;
427 xmlTextReaderFreeProp(reader, (xmlAttrPtr) cur);
434 xmlTextReaderFreeNodeList(reader, cur->children);
445 xmlTextReaderFreePropList(reader, cur->properties);
468 (reader != NULL) && (reader->ctxt != NULL) &&
469 (reader->ctxt->freeElemsNr < 100)) {
470 cur->next = reader->ctxt->freeElems;
471 reader->ctxt->freeElems = cur;
472 reader->ctxt->freeElemsNr++;
491 * @reader: the xmlTextReaderPtr used
497 xmlTextReaderFreeDoc(xmlTextReaderPtr reader, xmlDocPtr cur) {
527 if (cur->children != NULL) xmlTextReaderFreeNodeList(reader, cur->children);
541 * The reader core parser *
546 xmlTextReaderDebug(xmlTextReaderPtr reader) {
547 if ((reader == NULL) || (reader->ctxt == NULL)) {
552 reader->state, reader->depth);
553 if (reader->node == NULL) {
556 fprintf(stderr, "node %s\n", reader->node->name);
559 reader->base, reader->cur, reader->ctxt->nodeNr);
560 if (reader->input->buffer == NULL) {
565 &reader->input->buffer->content[reader->cur]);
574 * @reader: the xmlTextReaderPtr used
582 xmlTextReaderEntPush(xmlTextReaderPtr reader, xmlNodePtr value)
584 if (reader->entMax <= 0) {
585 reader->entMax = 10;
586 reader->entTab = (xmlNodePtr *) xmlMalloc(reader->entMax *
587 sizeof(reader->entTab[0]));
588 if (reader->entTab == NULL) {
593 if (reader->entNr >= reader->entMax) {
594 reader->entMax *= 2;
595 reader->entTab =
596 (xmlNodePtr *) xmlRealloc(reader->entTab,
597 reader->entMax *
598 sizeof(reader->entTab[0]));
599 if (reader->entTab == NULL) {
604 reader->entTab[reader->entNr] = value;
605 reader->ent = value;
606 return (reader->entNr++);
611 * @reader: the xmlTextReaderPtr used
618 xmlTextReaderEntPop(xmlTextReaderPtr reader)
622 if (reader->entNr <= 0)
624 reader->entNr--;
625 if (reader->entNr > 0)
626 reader->ent = reader->entTab[reader->entNr - 1];
628 reader->ent = NULL;
629 ret = reader->entTab[reader->entNr];
630 reader->entTab[reader->entNr] = NULL;
646 xmlTextReaderPtr reader = ctxt->_private;
651 if ((reader != NULL) && (reader->startElement != NULL)) {
652 reader->startElement(ctx, fullname, atts);
658 if (reader != NULL)
659 reader->state = XML_TEXTREADER_ELEMENT;
672 xmlTextReaderPtr reader = ctxt->_private;
677 if ((reader != NULL) && (reader->endElement != NULL)) {
678 reader->endElement(ctx, fullname);
709 xmlTextReaderPtr reader = ctxt->_private;
714 if ((reader != NULL) && (reader->startElementNs != NULL)) {
715 reader->startElementNs(ctx, localname, prefix, URI, nb_namespaces,
723 if (reader != NULL)
724 reader->state = XML_TEXTREADER_ELEMENT;
743 xmlTextReaderPtr reader = ctxt->_private;
748 if ((reader != NULL) && (reader->endElementNs != NULL)) {
749 reader->endElementNs(ctx, localname, prefix, URI);
766 xmlTextReaderPtr reader = ctxt->_private;
771 if ((reader != NULL) && (reader->characters != NULL)) {
772 reader->characters(ctx, ch, len);
788 xmlTextReaderPtr reader = ctxt->_private;
793 if ((reader != NULL) && (reader->cdataBlock != NULL)) {
794 reader->cdataBlock(ctx, ch, len);
800 * @reader: the xmlTextReaderPtr used
808 xmlTextReaderPushData(xmlTextReaderPtr reader) {
813 if ((reader->input == NULL) || (reader->input->buffer == NULL))
816 oldstate = reader->state;
817 reader->state = XML_TEXTREADER_NONE;
818 inbuf = reader->input->buffer;
820 while (reader->state == XML_TEXTREADER_NONE) {
821 if (inbuf->use < reader->cur + CHUNK_SIZE) {
825 if (reader->mode != XML_TEXTREADER_MODE_EOF) {
826 val = xmlParserInputBufferRead(reader->input, 4096);
829 if (inbuf->use == reader->cur) {
830 reader->mode = XML_TEXTREADER_MODE_EOF;
831 reader->state = oldstate;
834 reader->mode = XML_TEXTREADER_MODE_EOF;
835 reader->state = oldstate;
837 (reader->ctxt->myDoc != NULL))
841 reader->mode = XML_TEXTREADER_MODE_EOF;
852 if (inbuf->use >= reader->cur + CHUNK_SIZE) {
853 val = xmlParseChunk(reader->ctxt,
854 (const char *) &inbuf->content[reader->cur],
856 reader->cur += CHUNK_SIZE;
857 if ((val != 0) || (reader->ctxt->wellFormed == 0))
860 s = inbuf->use - reader->cur;
861 val = xmlParseChunk(reader->ctxt,
862 (const char *) &inbuf->content[reader->cur],
864 reader->cur += s;
865 if ((val != 0) || (reader->ctxt->wellFormed == 0))
874 if (reader->mode == XML_TEXTREADER_MODE_INTERACTIVE) {
876 if ((reader->cur >= 4096) &&
877 (inbuf->use - reader->cur <= CHUNK_SIZE)) {
878 val = xmlBufferShrink(inbuf, reader->cur);
880 reader->cur -= val;
890 else if (reader->mode == XML_TEXTREADER_MODE_EOF) {
891 if (reader->state != XML_TEXTREADER_DONE) {
892 s = inbuf->use - reader->cur;
893 val = xmlParseChunk(reader->ctxt,
894 (const char *) &inbuf->content[reader->cur],
896 reader->cur = inbuf->use;
897 reader->state = XML_TEXTREADER_DONE;
898 if ((val != 0) || (reader->ctxt->wellFormed == 0))
902 reader->state = oldstate;
909 * @reader: the xmlTextReaderPtr used
914 xmlTextReaderValidatePush(xmlTextReaderPtr reader ATTRIBUTE_UNUSED) {
915 xmlNodePtr node = reader->node;
918 if ((reader->validate == XML_TEXTREADER_VALIDATE_DTD) &&
919 (reader->ctxt != NULL) && (reader->ctxt->validate == 1)) {
921 reader->ctxt->valid &= xmlValidatePushElement(&reader->ctxt->vctxt,
922 reader->ctxt->myDoc, node, node->name);
930 reader->ctxt->valid &= xmlValidatePushElement(&reader->ctxt->vctxt,
931 reader->ctxt->myDoc, node, qname);
938 if ((reader->validate == XML_TEXTREADER_VALIDATE_RNG) &&
939 (reader->rngValidCtxt != NULL)) {
942 if (reader->rngFullNode != NULL) return;
943 ret = xmlRelaxNGValidatePushElement(reader->rngValidCtxt,
944 reader->ctxt->myDoc,
950 node = xmlTextReaderExpand(reader);
955 ret = xmlRelaxNGValidateFullElement(reader->rngValidCtxt,
956 reader->ctxt->myDoc,
958 reader->rngFullNode = node;
962 reader->rngValidErrors++;
969 * @reader: the xmlTextReaderPtr used
976 xmlTextReaderValidateCData(xmlTextReaderPtr reader,
979 if ((reader->validate == XML_TEXTREADER_VALIDATE_DTD) &&
980 (reader->ctxt != NULL) && (reader->ctxt->validate == 1)) {
981 reader->ctxt->valid &= xmlValidatePushCData(&reader->ctxt->vctxt,
986 if ((reader->validate == XML_TEXTREADER_VALIDATE_RNG) &&
987 (reader->rngValidCtxt != NULL)) {
990 if (reader->rngFullNode != NULL) return;
991 ret = xmlRelaxNGValidatePushCData(reader->rngValidCtxt, data, len);
993 reader->rngValidErrors++;
1000 * @reader: the xmlTextReaderPtr used
1005 xmlTextReaderValidatePop(xmlTextReaderPtr reader) {
1006 xmlNodePtr node = reader->node;
1009 if ((reader->validate == XML_TEXTREADER_VALIDATE_DTD) &&
1010 (reader->ctxt != NULL) && (reader->ctxt->validate == 1)) {
1012 reader->ctxt->valid &= xmlValidatePopElement(&reader->ctxt->vctxt,
1013 reader->ctxt->myDoc, node, node->name);
1021 reader->ctxt->valid &= xmlValidatePopElement(&reader->ctxt->vctxt,
1022 reader->ctxt->myDoc, node, qname);
1029 if ((reader->validate == XML_TEXTREADER_VALIDATE_RNG) &&
1030 (reader->rngValidCtxt != NULL)) {
1033 if (reader->rngFullNode != NULL) {
1034 if (node == reader->rngFullNode)
1035 reader->rngFullNode = NULL;
1038 ret = xmlRelaxNGValidatePopElement(reader->rngValidCtxt,
1039 reader->ctxt->myDoc,
1042 reader->rngValidErrors++;
1049 * @reader: the xmlTextReaderPtr used
1056 xmlTextReaderValidateEntity(xmlTextReaderPtr reader) {
1057 xmlNodePtr oldnode = reader->node;
1058 xmlNodePtr node = reader->node;
1059 xmlParserCtxtPtr ctxt = reader->ctxt;
1076 xmlTextReaderEntPush(reader, node);
1089 reader->node = node;
1090 xmlTextReaderValidatePush(reader);
1093 xmlTextReaderValidateCData(reader, node->content,
1105 xmlTextReaderValidatePop(reader);
1115 if (reader->entNr == 0) {
1119 xmlTextReaderFreeNode(reader, tmp);
1124 reader->node = node;
1125 xmlTextReaderValidatePop(reader);
1128 (reader->ent != NULL) && (reader->ent->children == node)) {
1129 node = xmlTextReaderEntPop(reader);
1139 reader->node = oldnode;
1166 * @reader: the xmlTextReaderPtr used
1176 xmlTextReaderDoExpand(xmlTextReaderPtr reader) {
1179 if ((reader == NULL) || (reader->node == NULL) || (reader->ctxt == NULL))
1182 if (reader->ctxt->instate == XML_PARSER_EOF) return(1);
1184 if (xmlTextReaderGetSuccessor(reader->node) != NULL)
1186 if (reader->ctxt->nodeNr < reader->depth)
1188 if (reader->mode == XML_TEXTREADER_MODE_EOF)
1190 val = xmlTextReaderPushData(reader);
1192 reader->mode = XML_TEXTREADER_MODE_ERROR;
1195 } while(reader->mode != XML_TEXTREADER_MODE_EOF);
1245 * @reader: the xmlTextReaderPtr used
1254 xmlTextReaderRead(xmlTextReaderPtr reader) {
1260 if (reader == NULL)
1262 reader->curnode = NULL;
1263 if (reader->doc != NULL)
1264 return(xmlTextReaderReadTree(reader));
1265 if (reader->ctxt == NULL)
1267 if (reader->ctxt->wellFormed != 1)
1274 if (reader->mode == XML_TEXTREADER_MODE_INITIAL) {
1275 reader->mode = XML_TEXTREADER_MODE_INTERACTIVE;
1280 val = xmlTextReaderPushData(reader);
1282 reader->mode = XML_TEXTREADER_MODE_ERROR;
1283 reader->state = XML_TEXTREADER_ERROR;
1286 } while ((reader->ctxt->node == NULL) &&
1287 ((reader->mode != XML_TEXTREADER_MODE_EOF) &&
1288 (reader->state != XML_TEXTREADER_DONE)));
1289 if (reader->ctxt->node == NULL) {
1290 if (reader->ctxt->myDoc != NULL) {
1291 reader->node = reader->ctxt->myDoc->children;
1293 if (reader->node == NULL){
1294 reader->mode = XML_TEXTREADER_MODE_ERROR;
1295 reader->state = XML_TEXTREADER_ERROR;
1298 reader->state = XML_TEXTREADER_ELEMENT;
1300 if (reader->ctxt->myDoc != NULL) {
1301 reader->node = reader->ctxt->myDoc->children;
1303 if (reader->node == NULL)
1304 reader->node = reader->ctxt->nodeTab[0];
1305 reader->state = XML_TEXTREADER_ELEMENT;
1307 reader->depth = 0;
1308 reader->ctxt->parseMode = XML_PARSE_READER;
1311 oldstate = reader->state;
1312 olddepth = reader->ctxt->nodeNr;
1313 oldnode = reader->node;
1316 if (reader->node == NULL) {
1317 if (reader->mode == XML_TEXTREADER_MODE_EOF)
1328 while ((reader->node != NULL) && (reader->node->next == NULL) &&
1329 (reader->ctxt->nodeNr == olddepth) &&
1331 (reader->node->children == NULL) ||
1332 (reader->node->type == XML_ENTITY_REF_NODE) ||
1333 ((reader->node->children != NULL) &&
1334 (reader->node->children->type == XML_TEXT_NODE) &&
1335 (reader->node->children->next == NULL)) ||
1336 (reader->node->type == XML_DTD_NODE) ||
1337 (reader->node->type == XML_DOCUMENT_NODE) ||
1338 (reader->node->type == XML_HTML_DOCUMENT_NODE)) &&
1339 ((reader->ctxt->node == NULL) ||
1340 (reader->ctxt->node == reader->node) ||
1341 (reader->ctxt->node == reader->node->parent)) &&
1342 (reader->ctxt->instate != XML_PARSER_EOF)) {
1343 val = xmlTextReaderPushData(reader);
1345 reader->mode = XML_TEXTREADER_MODE_ERROR;
1346 reader->state = XML_TEXTREADER_ERROR;
1349 if (reader->node == NULL)
1353 if ((reader->node->children != NULL) &&
1354 (reader->node->type != XML_ENTITY_REF_NODE) &&
1355 (reader->node->type != XML_XINCLUDE_START) &&
1356 (reader->node->type != XML_DTD_NODE)) {
1357 reader->node = reader->node->children;
1358 reader->depth++;
1359 reader->state = XML_TEXTREADER_ELEMENT;
1363 if (reader->node->next != NULL) {
1365 (reader->node->type == XML_ELEMENT_NODE) &&
1366 (reader->node->children == NULL) &&
1367 ((reader->node->extra & NODE_IS_EMPTY) == 0)
1369 && (reader->in_xinclude <= 0)
1372 reader->state = XML_TEXTREADER_END;
1376 if ((reader->validate) &&
1377 (reader->node->type == XML_ELEMENT_NODE))
1378 xmlTextReaderValidatePop(reader);
1380 if ((reader->preserves > 0) &&
1381 (reader->node->extra & NODE_IS_SPRESERVED))
1382 reader->preserves--;
1383 reader->node = reader->node->next;
1384 reader->state = XML_TEXTREADER_ELEMENT;
1389 if ((reader->preserves == 0) &&
1391 (reader->in_xinclude == 0) &&
1393 (reader->entNr == 0) &&
1394 (reader->node->prev != NULL) &&
1395 (reader->node->prev->type != XML_DTD_NODE)) {
1396 xmlNodePtr tmp = reader->node->prev;
1399 xmlTextReaderFreeNode(reader, tmp);
1406 (reader->node->type == XML_ELEMENT_NODE) &&
1407 (reader->node->children == NULL) &&
1408 ((reader->node->extra & NODE_IS_EMPTY) == 0)) {;
1409 reader->state = XML_TEXTREADER_END;
1413 if ((reader->validate) && (reader->node->type == XML_ELEMENT_NODE))
1414 xmlTextReaderValidatePop(reader);
1416 if ((reader->preserves > 0) &&
1417 (reader->node->extra & NODE_IS_SPRESERVED))
1418 reader->preserves--;
1419 reader->node = reader->node->parent;
1420 if ((reader->node == NULL) ||
1421 (reader->node->type == XML_DOCUMENT_NODE) ||
1423 (reader->node->type == XML_DOCB_DOCUMENT_NODE) ||
1425 (reader->node->type == XML_HTML_DOCUMENT_NODE)) {
1426 if (reader->mode != XML_TEXTREADER_MODE_EOF) {
1427 val = xmlParseChunk(reader->ctxt, "", 0, 1);
1428 reader->state = XML_TEXTREADER_DONE;
1432 reader->node = NULL;
1433 reader->depth = -1;
1438 if ((oldnode != NULL) && (reader->preserves == 0) &&
1440 (reader->in_xinclude == 0) &&
1442 (reader->entNr == 0) &&
1446 xmlTextReaderFreeNode(reader, oldnode);
1451 if ((reader->preserves == 0) &&
1453 (reader->in_xinclude == 0) &&
1455 (reader->entNr == 0) &&
1456 (reader->node->last != NULL) &&
1457 ((reader->node->last->extra & NODE_IS_PRESERVED) == 0)) {
1458 xmlNodePtr tmp = reader->node->last;
1460 xmlTextReaderFreeNode(reader, tmp);
1462 reader->depth--;
1463 reader->state = XML_TEXTREADER_BACKTRACK;
1471 if ((reader->node != NULL) &&
1472 (reader->node->next == NULL) &&
1473 ((reader->node->type == XML_TEXT_NODE) ||
1474 (reader->node->type == XML_CDATA_SECTION_NODE))) {
1475 if (xmlTextReaderExpand(reader) == NULL)
1483 if ((reader->xinclude) && (reader->node != NULL) &&
1484 (reader->node->type == XML_ELEMENT_NODE) &&
1485 (reader->node->ns != NULL) &&
1486 ((xmlStrEqual(reader->node->ns->href, XINCLUDE_NS)) ||
1487 (xmlStrEqual(reader->node->ns->href, XINCLUDE_OLD_NS)))) {
1488 if (reader->xincctxt == NULL) {
1489 reader->xincctxt = xmlXIncludeNewContext(reader->ctxt->myDoc);
1490 xmlXIncludeSetFlags(reader->xincctxt,
1491 reader->parserFlags & (~XML_PARSE_NOXINCNODE));
1496 if (xmlTextReaderExpand(reader) == NULL)
1498 xmlXIncludeProcessNode(reader->xincctxt, reader->node);
1500 if ((reader->node != NULL) && (reader->node->type == XML_XINCLUDE_START)) {
1501 reader->in_xinclude++;
1504 if ((reader->node != NULL) && (reader->node->type == XML_XINCLUDE_END)) {
1505 reader->in_xinclude--;
1512 if ((reader->node != NULL) &&
1513 (reader->node->type == XML_ENTITY_REF_NODE) &&
1514 (reader->ctxt != NULL) && (reader->ctxt->replaceEntities == 1)) {
1519 if ((reader->node->children == NULL) && (reader->ctxt->sax != NULL) &&
1520 (reader->ctxt->sax->getEntity != NULL)) {
1521 reader->node->children = (xmlNodePtr)
1522 reader->ctxt->sax->getEntity(reader->ctxt, reader->node->name);
1525 if ((reader->node->children != NULL) &&
1526 (reader->node->children->type == XML_ENTITY_DECL) &&
1527 (reader->node->children->children != NULL)) {
1528 xmlTextReaderEntPush(reader, reader->node);
1529 reader->node = reader->node->children->children;
1532 } else if ((reader->node != NULL) &&
1533 (reader->node->type == XML_ENTITY_REF_NODE) &&
1534 (reader->ctxt != NULL) && (reader->validate)) {
1535 xmlTextReaderValidateEntity(reader);
1538 if ((reader->node != NULL) &&
1539 (reader->node->type == XML_ENTITY_DECL) &&
1540 (reader->ent != NULL) && (reader->ent->children == reader->node)) {
1541 reader->node = xmlTextReaderEntPop(reader);
1542 reader->depth++;
1546 if ((reader->validate) && (reader->node != NULL)) {
1547 xmlNodePtr node = reader->node;
1550 ((reader->state != XML_TEXTREADER_END) &&
1551 (reader->state != XML_TEXTREADER_BACKTRACK))) {
1552 xmlTextReaderValidatePush(reader);
1555 xmlTextReaderValidateCData(reader, node->content,
1561 if ((reader->patternNr > 0) && (reader->state != XML_TEXTREADER_END) &&
1562 (reader->state != XML_TEXTREADER_BACKTRACK)) {
1564 for (i = 0;i < reader->patternNr;i++) {
1565 if (xmlPatternMatch(reader->patternTab[i], reader->node) == 1) {
1566 xmlTextReaderPreserve(reader);
1573 if ((reader->validate == XML_TEXTREADER_VALIDATE_XSD) &&
1574 (reader->xsdValidErrors == 0) &&
1575 (reader->xsdValidCtxt != NULL)) {
1576 reader->xsdValidErrors = !xmlSchemaIsValid(reader->xsdValidCtxt);
1581 reader->state = XML_TEXTREADER_DONE;
1587 * @reader: the xmlTextReaderPtr used
1589 * Gets the read state of the reader.
1594 xmlTextReaderReadState(xmlTextReaderPtr reader) {
1595 if (reader == NULL)
1597 return(reader->mode);
1602 * @reader: the xmlTextReaderPtr used
1611 xmlTextReaderExpand(xmlTextReaderPtr reader) {
1612 if ((reader == NULL) || (reader->node == NULL))
1614 if (reader->doc != NULL)
1615 return(reader->node);
1616 if (reader->ctxt == NULL)
1618 if (xmlTextReaderDoExpand(reader) < 0)
1620 return(reader->node);
1625 * @reader: the xmlTextReaderPtr used
1634 xmlTextReaderNext(xmlTextReaderPtr reader) {
1638 if (reader == NULL)
1640 if (reader->doc != NULL)
1641 return(xmlTextReaderNextTree(reader));
1642 cur = reader->node;
1644 return(xmlTextReaderRead(reader));
1645 if (reader->state == XML_TEXTREADER_END || reader->state == XML_TEXTREADER_BACKTRACK)
1646 return(xmlTextReaderRead(reader));
1648 return(xmlTextReaderRead(reader));
1650 ret = xmlTextReaderRead(reader);
1653 } while (reader->node != cur);
1654 return(xmlTextReaderRead(reader));
1660 * @reader: the xmlTextReaderPtr used
1669 xmlTextReaderReadInnerXml(xmlTextReaderPtr reader ATTRIBUTE_UNUSED)
1676 if (xmlTextReaderExpand(reader) == NULL) {
1679 doc = reader->doc;
1681 for (cur_node = reader->node->children; cur_node != NULL;
1706 * @reader: the xmlTextReaderPtr used
1715 xmlTextReaderReadOuterXml(xmlTextReaderPtr reader ATTRIBUTE_UNUSED)
1722 node = reader->node;
1723 doc = reader->doc;
1724 if (xmlTextReaderExpand(reader) == NULL) {
1746 * @reader: the xmlTextReaderPtr used
1751 * or NULL if the reader is positioned on any other type of node.
1755 xmlTextReaderReadString(xmlTextReaderPtr reader)
1759 if ((reader == NULL) || (reader->node == NULL))
1762 node = (reader->curnode != NULL) ? reader->curnode : reader->node;
1769 if (xmlTextReaderDoExpand(reader) != -1) {
1784 * @reader: the xmlTextReaderPtr used
1797 xmlTextReaderReadBase64(xmlTextReaderPtr reader,
1801 if ((reader == NULL) || (reader->ctxt == NULL))
1803 if (reader->ctxt->wellFormed != 1)
1806 if ((reader->node == NULL) || (reader->node->type == XML_ELEMENT_NODE))
1814 * @reader: the xmlTextReaderPtr used
1827 xmlTextReaderReadBinHex(xmlTextReaderPtr reader,
1831 if ((reader == NULL) || (reader->ctxt == NULL))
1833 if (reader->ctxt->wellFormed != 1)
1836 if ((reader->node == NULL) || (reader->node->type == XML_ELEMENT_NODE))
1849 xmlTextReaderNextTree(xmlTextReaderPtr reader)
1851 if (reader == NULL)
1854 if (reader->state == XML_TEXTREADER_END)
1857 if (reader->node == NULL) {
1858 if (reader->doc->children == NULL) {
1859 reader->state = XML_TEXTREADER_END;
1863 reader->node = reader->doc->children;
1864 reader->state = XML_TEXTREADER_START;
1868 if (reader->state != XML_TEXTREADER_BACKTRACK) {
1871 if (reader->node->next != 0) {
1873 reader->node = reader->node->next;
1874 reader->state = XML_TEXTREADER_START;
1878 /* if reader->node->next is NULL mean no subtree for current node,
1880 if ((reader->node->type == XML_ELEMENT_NODE) ||
1881 (reader->node->type == XML_ATTRIBUTE_NODE)) {
1882 reader->state = XML_TEXTREADER_BACKTRACK;
1884 xmlTextReaderRead(reader);
1888 if (reader->node->next != 0) {
1889 reader->node = reader->node->next;
1890 reader->state = XML_TEXTREADER_START;
1894 if (reader->node->parent != 0) {
1895 if (reader->node->parent->type == XML_DOCUMENT_NODE) {
1896 reader->state = XML_TEXTREADER_END;
1900 reader->node = reader->node->parent;
1901 reader->depth--;
1902 reader->state = XML_TEXTREADER_BACKTRACK;
1904 xmlTextReaderNextTree(reader);
1907 reader->state = XML_TEXTREADER_END;
1914 * @reader: the xmlTextReaderPtr used
1923 xmlTextReaderReadTree(xmlTextReaderPtr reader) {
1924 if (reader->state == XML_TEXTREADER_END)
1928 if (reader->node == NULL) {
1929 if (reader->doc->children == NULL) {
1930 reader->state = XML_TEXTREADER_END;
1934 reader->node = reader->doc->children;
1935 reader->state = XML_TEXTREADER_START;
1939 if ((reader->state != XML_TEXTREADER_BACKTRACK) &&
1940 (reader->node->type != XML_DTD_NODE) &&
1941 (reader->node->type != XML_XINCLUDE_START) &&
1942 (reader->node->type != XML_ENTITY_REF_NODE)) {
1943 if (reader->node->children != NULL) {
1944 reader->node = reader->node->children;
1945 reader->depth++;
1946 reader->state = XML_TEXTREADER_START;
1950 if (reader->node->type == XML_ATTRIBUTE_NODE) {
1951 reader->state = XML_TEXTREADER_BACKTRACK;
1956 if (reader->node->next != NULL) {
1957 reader->node = reader->node->next;
1958 reader->state = XML_TEXTREADER_START;
1962 if (reader->node->parent != NULL) {
1963 if ((reader->node->parent->type == XML_DOCUMENT_NODE) ||
1964 (reader->node->parent->type == XML_HTML_DOCUMENT_NODE)) {
1965 reader->state = XML_TEXTREADER_END;
1969 reader->node = reader->node->parent;
1970 reader->depth--;
1971 reader->state = XML_TEXTREADER_BACKTRACK;
1975 reader->state = XML_TEXTREADER_END;
1978 if ((reader->node->type == XML_XINCLUDE_START) ||
1979 (reader->node->type == XML_XINCLUDE_END))
1987 * @reader: the xmlTextReaderPtr used
1997 xmlTextReaderNextSibling(xmlTextReaderPtr reader) {
1998 if (reader == NULL)
2000 if (reader->doc == NULL) {
2005 if (reader->state == XML_TEXTREADER_END)
2008 if (reader->node == NULL)
2009 return(xmlTextReaderNextTree(reader));
2011 if (reader->node->next != NULL) {
2012 reader->node = reader->node->next;
2013 reader->state = XML_TEXTREADER_START;
2170 * @reader: the xmlTextReaderPtr
2172 * Deallocate all the resources associated to the reader
2175 xmlFreeTextReader(xmlTextReaderPtr reader) {
2176 if (reader == NULL)
2179 if (reader->rngSchemas != NULL) {
2180 xmlRelaxNGFree(reader->rngSchemas);
2181 reader->rngSchemas = NULL;
2183 if (reader->rngValidCtxt != NULL) {
2184 xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
2185 reader->rngValidCtxt = NULL;
2187 if (reader->xsdPlug != NULL) {
2188 xmlSchemaSAXUnplug(reader->xsdPlug);
2189 reader->xsdPlug = NULL;
2191 if (reader->xsdValidCtxt != NULL) {
2192 if (! reader->xsdPreserveCtxt)
2193 xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
2194 reader->xsdValidCtxt = NULL;
2196 if (reader->xsdSchemas != NULL) {
2197 xmlSchemaFree(reader->xsdSchemas);
2198 reader->xsdSchemas = NULL;
2202 if (reader->xincctxt != NULL)
2203 xmlXIncludeFreeContext(reader->xincctxt);
2206 if (reader->patternTab != NULL) {
2208 for (i = 0;i < reader->patternNr;i++) {
2209 if (reader->patternTab[i] != NULL)
2210 xmlFreePattern(reader->patternTab[i]);
2212 xmlFree(reader->patternTab);
2215 if (reader->faketext != NULL) {
2216 xmlFreeNode(reader->faketext);
2218 if (reader->ctxt != NULL) {
2219 if (reader->dict == reader->ctxt->dict)
2220 reader->dict = NULL;
2221 if (reader->ctxt->myDoc != NULL) {
2222 if (reader->preserve == 0)
2223 xmlTextReaderFreeDoc(reader, reader->ctxt->myDoc);
2224 reader->ctxt->myDoc = NULL;
2226 if ((reader->ctxt->vctxt.vstateTab != NULL) &&
2227 (reader->ctxt->vctxt.vstateMax > 0)){
2228 xmlFree(reader->ctxt->vctxt.vstateTab);
2229 reader->ctxt->vctxt.vstateTab = NULL;
2230 reader->ctxt->vctxt.vstateMax = 0;
2232 if (reader->allocs & XML_TEXTREADER_CTXT)
2233 xmlFreeParserCtxt(reader->ctxt);
2235 if (reader->sax != NULL)
2236 xmlFree(reader->sax);
2237 if ((reader->input != NULL) && (reader->allocs & XML_TEXTREADER_INPUT))
2238 xmlFreeParserInputBuffer(reader->input);
2239 if (reader->buffer != NULL)
2240 xmlBufferFree(reader->buffer);
2241 if (reader->entTab != NULL)
2242 xmlFree(reader->entTab);
2243 if (reader->dict != NULL)
2244 xmlDictFree(reader->dict);
2245 xmlFree(reader);
2255 * @reader: the xmlTextReaderPtr used
2263 xmlTextReaderClose(xmlTextReaderPtr reader) {
2264 if (reader == NULL)
2266 reader->node = NULL;
2267 reader->curnode = NULL;
2268 reader->mode = XML_TEXTREADER_MODE_CLOSED;
2269 if (reader->ctxt != NULL) {
2270 xmlStopParser(reader->ctxt);
2271 if (reader->ctxt->myDoc != NULL) {
2272 if (reader->preserve == 0)
2273 xmlTextReaderFreeDoc(reader, reader->ctxt->myDoc);
2274 reader->ctxt->myDoc = NULL;
2277 if ((reader->input != NULL) && (reader->allocs & XML_TEXTREADER_INPUT)) {
2278 xmlFreeParserInputBuffer(reader->input);
2279 reader->allocs -= XML_TEXTREADER_INPUT;
2286 * @reader: the xmlTextReaderPtr used
2296 xmlTextReaderGetAttributeNo(xmlTextReaderPtr reader, int no) {
2302 if (reader == NULL)
2304 if (reader->node == NULL)
2306 if (reader->curnode != NULL)
2309 if (reader->node->type != XML_ELEMENT_NODE)
2312 ns = reader->node->nsDef;
2319 cur = reader->node->properties;
2329 ret = xmlNodeListGetString(reader->node->doc, cur->children, 1);
2336 * @reader: the xmlTextReaderPtr used
2345 xmlTextReaderGetAttribute(xmlTextReaderPtr reader, const xmlChar *name) {
2351 if ((reader == NULL) || (name == NULL))
2353 if (reader->node == NULL)
2355 if (reader->curnode != NULL)
2359 if (reader->node->type != XML_ELEMENT_NODE)
2368 ns = reader->node->nsDef;
2377 return(xmlGetNoNsProp(reader->node, name));
2384 ns = reader->node->nsDef;
2393 ns = xmlSearchNs(reader->node->doc, reader->node, prefix);
2395 ret = xmlGetNsProp(reader->node, localname, ns->href);
2407 * @reader: the xmlTextReaderPtr used
2417 xmlTextReaderGetAttributeNs(xmlTextReaderPtr reader, const xmlChar *localName,
2422 if ((reader == NULL) || (localName == NULL))
2424 if (reader->node == NULL)
2426 if (reader->curnode != NULL)
2430 if (reader->node->type != XML_ELEMENT_NODE)
2437 ns = reader->node->nsDef;
2448 return(xmlGetNsProp(reader->node, localName, namespaceURI));
2453 * @reader: the xmlTextReaderPtr used
2460 * what's left in reader->input, and there is an allocation problem. Best
2467 xmlTextReaderGetRemainder(xmlTextReaderPtr reader) {
2470 if (reader == NULL)
2472 if (reader->node == NULL)
2475 reader->node = NULL;
2476 reader->curnode = NULL;
2477 reader->mode = XML_TEXTREADER_MODE_EOF;
2478 if (reader->ctxt != NULL) {
2479 xmlStopParser(reader->ctxt);
2480 if (reader->ctxt->myDoc != NULL) {
2481 if (reader->preserve == 0)
2482 xmlTextReaderFreeDoc(reader, reader->ctxt->myDoc);
2483 reader->ctxt->myDoc = NULL;
2486 if (reader->allocs & XML_TEXTREADER_INPUT) {
2487 ret = reader->input;
2488 reader->input = NULL;
2489 reader->allocs -= XML_TEXTREADER_INPUT;
2505 * @reader: the xmlTextReaderPtr used
2515 xmlTextReaderLookupNamespace(xmlTextReaderPtr reader, const xmlChar *prefix) {
2518 if (reader == NULL)
2520 if (reader->node == NULL)
2523 ns = xmlSearchNs(reader->node->doc, reader->node, prefix);
2531 * @reader: the xmlTextReaderPtr used
2541 xmlTextReaderMoveToAttributeNo(xmlTextReaderPtr reader, int no) {
2546 if (reader == NULL)
2548 if (reader->node == NULL)
2551 if (reader->node->type != XML_ELEMENT_NODE)
2554 reader->curnode = NULL;
2556 ns = reader->node->nsDef;
2561 reader->curnode = (xmlNodePtr) ns;
2565 cur = reader->node->properties;
2575 reader->curnode = (xmlNodePtr) cur;
2581 * @reader: the xmlTextReaderPtr used
2590 xmlTextReaderMoveToAttribute(xmlTextReaderPtr reader, const xmlChar *name) {
2596 if ((reader == NULL) || (name == NULL))
2598 if (reader->node == NULL)
2602 if (reader->node->type != XML_ELEMENT_NODE)
2611 ns = reader->node->nsDef;
2614 reader->curnode = (xmlNodePtr) ns;
2622 prop = reader->node->properties;
2631 reader->curnode = (xmlNodePtr) prop;
2643 ns = reader->node->nsDef;
2646 reader->curnode = (xmlNodePtr) ns;
2653 prop = reader->node->properties;
2662 reader->curnode = (xmlNodePtr) prop;
2684 * @reader: the xmlTextReaderPtr used
2694 xmlTextReaderMoveToAttributeNs(xmlTextReaderPtr reader,
2701 if ((reader == NULL) || (localName == NULL) || (namespaceURI == NULL))
2703 if (reader->node == NULL)
2705 if (reader->node->type != XML_ELEMENT_NODE)
2707 node = reader->node;
2713 ns = reader->node->nsDef;
2717 reader->curnode = (xmlNodePtr) ns;
2735 reader->curnode = (xmlNodePtr) prop;
2745 * @reader: the xmlTextReaderPtr used
2753 xmlTextReaderMoveToFirstAttribute(xmlTextReaderPtr reader) {
2754 if (reader == NULL)
2756 if (reader->node == NULL)
2758 if (reader->node->type != XML_ELEMENT_NODE)
2761 if (reader->node->nsDef != NULL) {
2762 reader->curnode = (xmlNodePtr) reader->node->nsDef;
2765 if (reader->node->properties != NULL) {
2766 reader->curnode = (xmlNodePtr) reader->node->properties;
2774 * @reader: the xmlTextReaderPtr used
2782 xmlTextReaderMoveToNextAttribute(xmlTextReaderPtr reader) {
2783 if (reader == NULL)
2785 if (reader->node == NULL)
2787 if (reader->node->type != XML_ELEMENT_NODE)
2789 if (reader->curnode == NULL)
2790 return(xmlTextReaderMoveToFirstAttribute(reader));
2792 if (reader->curnode->type == XML_NAMESPACE_DECL) {
2793 xmlNsPtr ns = (xmlNsPtr) reader->curnode;
2795 reader->curnode = (xmlNodePtr) ns->next;
2798 if (reader->node->properties != NULL) {
2799 reader->curnode = (xmlNodePtr) reader->node->properties;
2803 } else if ((reader->curnode->type == XML_ATTRIBUTE_NODE) &&
2804 (reader->curnode->next != NULL)) {
2805 reader->curnode = reader->curnode->next;
2813 * @reader: the xmlTextReaderPtr used
2821 xmlTextReaderMoveToElement(xmlTextReaderPtr reader) {
2822 if (reader == NULL)
2824 if (reader->node == NULL)
2826 if (reader->node->type != XML_ELEMENT_NODE)
2828 if (reader->curnode != NULL) {
2829 reader->curnode = NULL;
2837 * @reader: the xmlTextReaderPtr used
2841 * Returns 1 in case of success, 0 if the reader was not positionned on an
2846 xmlTextReaderReadAttributeValue(xmlTextReaderPtr reader) {
2847 if (reader == NULL)
2849 if (reader->node == NULL)
2851 if (reader->curnode == NULL)
2853 if (reader->curnode->type == XML_ATTRIBUTE_NODE) {
2854 if (reader->curnode->children == NULL)
2856 reader->curnode = reader->curnode->children;
2857 } else if (reader->curnode->type == XML_NAMESPACE_DECL) {
2858 xmlNsPtr ns = (xmlNsPtr) reader->curnode;
2860 if (reader->faketext == NULL) {
2861 reader->faketext = xmlNewDocText(reader->node->doc,
2864 if ((reader->faketext->content != NULL) &&
2865 (reader->faketext->content !=
2866 (xmlChar *) &(reader->faketext->properties)))
2867 xmlFree(reader->faketext->content);
2868 reader->faketext->content = xmlStrdup(ns->href);
2870 reader->curnode = reader->faketext;
2872 if (reader->curnode->next == NULL)
2874 reader->curnode = reader->curnode->next;
2881 * @reader: the xmlTextReaderPtr used
2886 * case of error. The string is deallocated with the reader.
2889 xmlTextReaderConstEncoding(xmlTextReaderPtr reader) {
2891 if (reader == NULL)
2893 if (reader->doc != NULL)
2894 doc = reader->doc;
2895 else if (reader->ctxt != NULL)
2896 doc = reader->ctxt->myDoc;
2914 * @reader: the xmlTextReaderPtr used
2921 xmlTextReaderAttributeCount(xmlTextReaderPtr reader) {
2927 if (reader == NULL)
2929 if (reader->node == NULL)
2932 if (reader->curnode != NULL)
2933 node = reader->curnode;
2935 node = reader->node;
2939 if ((reader->state == XML_TEXTREADER_END) ||
2940 (reader->state == XML_TEXTREADER_BACKTRACK))
2958 * @reader: the xmlTextReaderPtr used
2967 xmlTextReaderNodeType(xmlTextReaderPtr reader) {
2970 if (reader == NULL)
2972 if (reader->node == NULL)
2974 if (reader->curnode != NULL)
2975 node = reader->curnode;
2977 node = reader->node;
2980 if ((reader->state == XML_TEXTREADER_END) ||
2981 (reader->state == XML_TEXTREADER_BACKTRACK))
2988 if (xmlIsBlankNode(reader->node)) {
2989 if (xmlNodeGetSpacePreserve(reader->node))
3032 * @reader: the xmlTextReaderPtr used
3039 xmlTextReaderIsEmptyElement(xmlTextReaderPtr reader) {
3040 if ((reader == NULL) || (reader->node == NULL))
3042 if (reader->node->type != XML_ELEMENT_NODE)
3044 if (reader->curnode != NULL)
3046 if (reader->node->children != NULL)
3048 if (reader->state == XML_TEXTREADER_END)
3050 if (reader->doc != NULL)
3053 if (reader->in_xinclude > 0)
3056 return((reader->node->extra & NODE_IS_EMPTY) != 0);
3061 * @reader: the xmlTextReaderPtr used
3069 xmlTextReaderLocalName(xmlTextReaderPtr reader) {
3071 if ((reader == NULL) || (reader->node == NULL))
3073 if (reader->curnode != NULL)
3074 node = reader->curnode;
3076 node = reader->node;
3086 return(xmlTextReaderName(reader));
3092 * @reader: the xmlTextReaderPtr used
3097 * string will be deallocated with the reader.
3100 xmlTextReaderConstLocalName(xmlTextReaderPtr reader) {
3102 if ((reader == NULL) || (reader->node == NULL))
3104 if (reader->curnode != NULL)
3105 node = reader->curnode;
3107 node = reader->node;
3117 return(xmlTextReaderConstName(reader));
3123 * @reader: the xmlTextReaderPtr used
3131 xmlTextReaderName(xmlTextReaderPtr reader) {
3135 if ((reader == NULL) || (reader->node == NULL))
3137 if (reader->curnode != NULL)
3138 node = reader->curnode;
3140 node = reader->node;
3199 * @reader: the xmlTextReaderPtr used
3204 * deallocated with the reader.
3207 xmlTextReaderConstName(xmlTextReaderPtr reader) {
3210 if ((reader == NULL) || (reader->node == NULL))
3212 if (reader->curnode != NULL)
3213 node = reader->curnode;
3215 node = reader->node;
3267 * @reader: the xmlTextReaderPtr used
3275 xmlTextReaderPrefix(xmlTextReaderPtr reader) {
3277 if ((reader == NULL) || (reader->node == NULL))
3279 if (reader->curnode != NULL)
3280 node = reader->curnode;
3282 node = reader->node;
3299 * @reader: the xmlTextReaderPtr used
3304 * with the reader.
3307 xmlTextReaderConstPrefix(xmlTextReaderPtr reader) {
3309 if ((reader == NULL) || (reader->node == NULL))
3311 if (reader->curnode != NULL)
3312 node = reader->curnode;
3314 node = reader->node;
3331 * @reader: the xmlTextReaderPtr used
3339 xmlTextReaderNamespaceUri(xmlTextReaderPtr reader) {
3341 if ((reader == NULL) || (reader->node == NULL))
3343 if (reader->curnode != NULL)
3344 node = reader->curnode;
3346 node = reader->node;
3359 * @reader: the xmlTextReaderPtr used
3364 * will be deallocated with the reader
3367 xmlTextReaderConstNamespaceUri(xmlTextReaderPtr reader) {
3369 if ((reader == NULL) || (reader->node == NULL))
3371 if (reader->curnode != NULL)
3372 node = reader->curnode;
3374 node = reader->node;
3387 * @reader: the xmlTextReaderPtr used
3395 xmlTextReaderBaseUri(xmlTextReaderPtr reader) {
3396 if ((reader == NULL) || (reader->node == NULL))
3398 return(xmlNodeGetBase(NULL, reader->node));
3403 * @reader: the xmlTextReaderPtr used
3408 * will be deallocated with the reader
3411 xmlTextReaderConstBaseUri(xmlTextReaderPtr reader) {
3415 if ((reader == NULL) || (reader->node == NULL))
3417 tmp = xmlNodeGetBase(NULL, reader->node);
3427 * @reader: the xmlTextReaderPtr used
3434 xmlTextReaderDepth(xmlTextReaderPtr reader) {
3435 if (reader == NULL)
3437 if (reader->node == NULL)
3440 if (reader->curnode != NULL) {
3441 if ((reader->curnode->type == XML_ATTRIBUTE_NODE) ||
3442 (reader->curnode->type == XML_NAMESPACE_DECL))
3443 return(reader->depth + 1);
3444 return(reader->depth + 2);
3446 return(reader->depth);
3451 * @reader: the xmlTextReaderPtr used
3458 xmlTextReaderHasAttributes(xmlTextReaderPtr reader) {
3460 if (reader == NULL)
3462 if (reader->node == NULL)
3464 if (reader->curnode != NULL)
3465 node = reader->curnode;
3467 node = reader->node;
3478 * @reader: the xmlTextReaderPtr used
3485 xmlTextReaderHasValue(xmlTextReaderPtr reader) {
3487 if (reader == NULL)
3489 if (reader->node == NULL)
3491 if (reader->curnode != NULL)
3492 node = reader->curnode;
3494 node = reader->node;
3512 * @reader: the xmlTextReaderPtr used
3520 xmlTextReaderValue(xmlTextReaderPtr reader) {
3522 if (reader == NULL)
3524 if (reader->node == NULL)
3526 if (reader->curnode != NULL)
3527 node = reader->curnode;
3529 node = reader->node;
3558 * @reader: the xmlTextReaderPtr used
3566 xmlTextReaderConstValue(xmlTextReaderPtr reader) {
3568 if (reader == NULL)
3570 if (reader->node == NULL)
3572 if (reader->curnode != NULL)
3573 node = reader->curnode;
3575 node = reader->node;
3588 if (reader->buffer == NULL)
3589 reader->buffer = xmlBufferCreateSize(100);
3590 if (reader->buffer == NULL) {
3595 reader->buffer->use = 0;
3596 xmlNodeBufGetContent(reader->buffer, node);
3597 return(reader->buffer->content);
3614 * @reader: the xmlTextReaderPtr used
3622 xmlTextReaderIsDefault(xmlTextReaderPtr reader) {
3623 if (reader == NULL)
3630 * @reader: the xmlTextReaderPtr used
3637 xmlTextReaderQuoteChar(xmlTextReaderPtr reader) {
3638 if (reader == NULL)
3646 * @reader: the xmlTextReaderPtr used
3654 xmlTextReaderXmlLang(xmlTextReaderPtr reader) {
3655 if (reader == NULL)
3657 if (reader->node == NULL)
3659 return(xmlNodeGetLang(reader->node));
3664 * @reader: the xmlTextReaderPtr used
3671 xmlTextReaderConstXmlLang(xmlTextReaderPtr reader) {
3675 if (reader == NULL)
3677 if (reader->node == NULL)
3679 tmp = xmlNodeGetLang(reader->node);
3689 * @reader: the xmlTextReaderPtr used
3692 * Get an interned string from the reader, allows for example to
3696 * string will be deallocated with the reader.
3699 xmlTextReaderConstString(xmlTextReaderPtr reader, const xmlChar *str) {
3700 if (reader == NULL)
3707 * @reader: the xmlTextReaderPtr used
3718 xmlTextReaderNormalization(xmlTextReaderPtr reader) {
3719 if (reader == NULL)
3732 * @reader: the xmlTextReaderPtr used
3743 xmlTextReaderSetParserProp(xmlTextReaderPtr reader, int prop, int value) {
3747 if ((reader == NULL) || (reader->ctxt == NULL))
3749 ctxt = reader->ctxt;
3755 if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
3774 reader->validate = XML_TEXTREADER_VALIDATE_DTD;
3792 * @reader: the xmlTextReaderPtr used
3800 xmlTextReaderGetParserProp(xmlTextReaderPtr reader, int prop) {
3804 if ((reader == NULL) || (reader->ctxt == NULL))
3806 ctxt = reader->ctxt;
3818 return(reader->validate);
3828 * @reader: the user data (XML reader context)
3835 xmlTextReaderGetParserLineNumber(xmlTextReaderPtr reader)
3837 if ((reader == NULL) || (reader->ctxt == NULL) ||
3838 (reader->ctxt->input == NULL)) {
3841 return (reader->ctxt->input->line);
3846 * @reader: the user data (XML reader context)
3853 xmlTextReaderGetParserColumnNumber(xmlTextReaderPtr reader)
3855 if ((reader == NULL) || (reader->ctxt == NULL) ||
3856 (reader->ctxt->input == NULL)) {
3859 return (reader->ctxt->input->col);
3864 * @reader: the xmlTextReaderPtr used
3873 xmlTextReaderCurrentNode(xmlTextReaderPtr reader) {
3874 if (reader == NULL)
3877 if (reader->curnode != NULL)
3878 return(reader->curnode);
3879 return(reader->node);
3884 * @reader: the xmlTextReaderPtr used
3893 xmlTextReaderPreserve(xmlTextReaderPtr reader) {
3896 if (reader == NULL)
3899 if (reader->curnode != NULL)
3900 cur = reader->curnode;
3902 cur = reader->node;
3910 reader->preserves++;
3924 * @reader: the xmlTextReaderPtr used
3935 xmlTextReaderPreservePattern(xmlTextReaderPtr reader, const xmlChar *pattern,
3940 if ((reader == NULL) || (pattern == NULL))
3943 comp = xmlPatterncompile(pattern, reader->dict, 0, namespaces);
3947 if (reader->patternMax <= 0) {
3948 reader->patternMax = 4;
3949 reader->patternTab = (xmlPatternPtr *) xmlMalloc(reader->patternMax *
3950 sizeof(reader->patternTab[0]));
3951 if (reader->patternTab == NULL) {
3956 if (reader->patternNr >= reader->patternMax) {
3958 reader->patternMax *= 2;
3959 tmp = (xmlPatternPtr *) xmlRealloc(reader->patternTab,
3960 reader->patternMax *
3961 sizeof(reader->patternTab[0]));
3964 reader->patternMax /= 2;
3967 reader->patternTab = tmp;
3969 reader->patternTab[reader->patternNr] = comp;
3970 return(reader->patternNr++);
3976 * @reader: the xmlTextReaderPtr used
3980 * NOTE: as a result of this call, the reader will not destroy the
3982 * is needed once the reader parsing has finished.
3987 xmlTextReaderCurrentDoc(xmlTextReaderPtr reader) {
3988 if (reader == NULL)
3990 if (reader->doc != NULL)
3991 return(reader->doc);
3992 if ((reader->ctxt == NULL) || (reader->ctxt->myDoc == NULL))
3995 reader->preserve = 1;
3996 return(reader->ctxt->myDoc);
4011 xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx;
4019 if (!reader->errorFunc) {
4022 reader->errorFunc(reader->errorFuncArg, str,
4034 xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx;
4042 if (!reader->errorFunc) {
4045 reader->errorFunc(reader->errorFuncArg, str,
4060 xmlTextReaderPtr reader = (xmlTextReaderPtr) userData;
4062 if (reader->sErrorFunc) {
4063 reader->sErrorFunc(reader->errorFuncArg, error);
4065 xmlTextReaderStructuredError(reader, error);
4070 * @reader: the xmlTextReaderPtr used
4076 @ The @schema should not be freed until the reader is deallocated
4083 xmlTextReaderRelaxNGSetSchema(xmlTextReaderPtr reader, xmlRelaxNGPtr schema) {
4084 if (reader == NULL)
4087 if (reader->rngSchemas != NULL) {
4088 xmlRelaxNGFree(reader->rngSchemas);
4089 reader->rngSchemas = NULL;
4091 if (reader->rngValidCtxt != NULL) {
4092 xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
4093 reader->rngValidCtxt = NULL;
4097 if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
4099 if (reader->rngSchemas != NULL) {
4100 xmlRelaxNGFree(reader->rngSchemas);
4101 reader->rngSchemas = NULL;
4103 if (reader->rngValidCtxt != NULL) {
4104 xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
4105 reader->rngValidCtxt = NULL;
4107 reader->rngValidCtxt = xmlRelaxNGNewValidCtxt(schema);
4108 if (reader->rngValidCtxt == NULL)
4110 if (reader->errorFunc != NULL) {
4111 xmlRelaxNGSetValidErrors(reader->rngValidCtxt,
4114 reader);
4116 if (reader->sErrorFunc != NULL) {
4117 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
4119 reader);
4121 reader->rngValidErrors = 0;
4122 reader->rngFullNode = NULL;
4123 reader->validate = XML_TEXTREADER_VALIDATE_RNG;
4129 * @reader: the xmlTextReaderPtr used
4135 @ The @schema should not be freed until the reader is deallocated
4142 xmlTextReaderSetSchema(xmlTextReaderPtr reader, xmlSchemaPtr schema) {
4143 if (reader == NULL)
4146 if (reader->xsdPlug != NULL) {
4147 xmlSchemaSAXUnplug(reader->xsdPlug);
4148 reader->xsdPlug = NULL;
4150 if (reader->xsdValidCtxt != NULL) {
4151 if (! reader->xsdPreserveCtxt)
4152 xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
4153 reader->xsdValidCtxt = NULL;
4155 reader->xsdPreserveCtxt = 0;
4156 if (reader->xsdSchemas != NULL) {
4157 xmlSchemaFree(reader->xsdSchemas);
4158 reader->xsdSchemas = NULL;
4162 if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
4164 if (reader->xsdPlug != NULL) {
4165 xmlSchemaSAXUnplug(reader->xsdPlug);
4166 reader->xsdPlug = NULL;
4168 if (reader->xsdValidCtxt != NULL) {
4169 if (! reader->xsdPreserveCtxt)
4170 xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
4171 reader->xsdValidCtxt = NULL;
4173 reader->xsdPreserveCtxt = 0;
4174 if (reader->xsdSchemas != NULL) {
4175 xmlSchemaFree(reader->xsdSchemas);
4176 reader->xsdSchemas = NULL;
4178 reader->xsdValidCtxt = xmlSchemaNewValidCtxt(schema);
4179 if (reader->xsdValidCtxt == NULL) {
4180 xmlSchemaFree(reader->xsdSchemas);
4181 reader->xsdSchemas = NULL;
4184 reader->xsdPlug = xmlSchemaSAXPlug(reader->xsdValidCtxt,
4185 &(reader->ctxt->sax),
4186 &(reader->ctxt->userData));
4187 if (reader->xsdPlug == NULL) {
4188 xmlSchemaFree(reader->xsdSchemas);
4189 reader->xsdSchemas = NULL;
4190 xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
4191 reader->xsdValidCtxt = NULL;
4194 if (reader->errorFunc != NULL) {
4195 xmlSchemaSetValidErrors(reader->xsdValidCtxt,
4198 reader);
4200 if (reader->sErrorFunc != NULL) {
4201 xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt,
4203 reader);
4205 reader->xsdValidErrors = 0;
4206 reader->validate = XML_TEXTREADER_VALIDATE_XSD;
4212 * @reader: the xmlTextReaderPtr used
4223 xmlTextReaderRelaxNGValidate(xmlTextReaderPtr reader, const char *rng) {
4226 if (reader == NULL)
4230 if (reader->rngValidCtxt != NULL) {
4231 xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
4232 reader->rngValidCtxt = NULL;
4234 if (reader->rngSchemas != NULL) {
4235 xmlRelaxNGFree(reader->rngSchemas);
4236 reader->rngSchemas = NULL;
4240 if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
4242 if (reader->rngSchemas != NULL) {
4243 xmlRelaxNGFree(reader->rngSchemas);
4244 reader->rngSchemas = NULL;
4246 if (reader->rngValidCtxt != NULL) {
4247 xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
4248 reader->rngValidCtxt = NULL;
4251 if (reader->errorFunc != NULL) {
4255 reader);
4257 if (reader->sErrorFunc != NULL) {
4258 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
4260 reader);
4262 reader->rngSchemas = xmlRelaxNGParse(ctxt);
4264 if (reader->rngSchemas == NULL)
4266 reader->rngValidCtxt = xmlRelaxNGNewValidCtxt(reader->rngSchemas);
4267 if (reader->rngValidCtxt == NULL) {
4268 xmlRelaxNGFree(reader->rngSchemas);
4269 reader->rngSchemas = NULL;
4272 if (reader->errorFunc != NULL) {
4273 xmlRelaxNGSetValidErrors(reader->rngValidCtxt,
4276 reader);
4278 if (reader->sErrorFunc != NULL) {
4279 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
4281 reader);
4283 reader->rngValidErrors = 0;
4284 reader->rngFullNode = NULL;
4285 reader->validate = XML_TEXTREADER_VALIDATE_RNG;
4291 * @reader: the xmlTextReaderPtr used
4304 xmlTextReaderSchemaValidateInternal(xmlTextReaderPtr reader,
4309 if (reader == NULL)
4316 ((reader->mode != XML_TEXTREADER_MODE_INITIAL) ||
4317 (reader->ctxt == NULL)))
4321 if (reader->xsdPlug != NULL) {
4322 xmlSchemaSAXUnplug(reader->xsdPlug);
4323 reader->xsdPlug = NULL;
4325 if (reader->xsdValidCtxt != NULL) {
4326 if (! reader->xsdPreserveCtxt)
4327 xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
4328 reader->xsdValidCtxt = NULL;
4330 reader->xsdPreserveCtxt = 0;
4331 if (reader->xsdSchemas != NULL) {
4332 xmlSchemaFree(reader->xsdSchemas);
4333 reader->xsdSchemas = NULL;
4345 if (reader->errorFunc != NULL) {
4349 reader);
4351 reader->xsdSchemas = xmlSchemaParse(pctxt);
4353 if (reader->xsdSchemas == NULL)
4355 reader->xsdValidCtxt = xmlSchemaNewValidCtxt(reader->xsdSchemas);
4356 if (reader->xsdValidCtxt == NULL) {
4357 xmlSchemaFree(reader->xsdSchemas);
4358 reader->xsdSchemas = NULL;
4361 reader->xsdPlug = xmlSchemaSAXPlug(reader->xsdValidCtxt,
4362 &(reader->ctxt->sax),
4363 &(reader->ctxt->userData));
4364 if (reader->xsdPlug == NULL) {
4365 xmlSchemaFree(reader->xsdSchemas);
4366 reader->xsdSchemas = NULL;
4367 xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
4368 reader->xsdValidCtxt = NULL;
4373 reader->xsdValidCtxt = ctxt;
4374 reader->xsdPreserveCtxt = 1;
4375 reader->xsdPlug = xmlSchemaSAXPlug(reader->xsdValidCtxt,
4376 &(reader->ctxt->sax),
4377 &(reader->ctxt->userData));
4378 if (reader->xsdPlug == NULL) {
4379 reader->xsdValidCtxt = NULL;
4380 reader->xsdPreserveCtxt = 0;
4386 * the reader channels.
4390 if (reader->errorFunc != NULL) {
4391 xmlSchemaSetValidErrors(reader->xsdValidCtxt,
4394 reader);
4396 if (reader->sErrorFunc != NULL) {
4397 xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt,
4399 reader);
4401 reader->xsdValidErrors = 0;
4402 reader->validate = XML_TEXTREADER_VALIDATE_XSD;
4408 * @reader: the xmlTextReaderPtr used
4420 xmlTextReaderSchemaValidateCtxt(xmlTextReaderPtr reader,
4424 return(xmlTextReaderSchemaValidateInternal(reader, NULL, ctxt, options));
4429 * @reader: the xmlTextReaderPtr used
4440 xmlTextReaderSchemaValidate(xmlTextReaderPtr reader, const char *xsd)
4442 return(xmlTextReaderSchemaValidateInternal(reader, xsd, NULL, 0));
4448 * @reader: the xmlTextReaderPtr used
4458 xmlTextReaderIsNamespaceDecl(xmlTextReaderPtr reader) {
4460 if (reader == NULL)
4462 if (reader->node == NULL)
4464 if (reader->curnode != NULL)
4465 node = reader->curnode;
4467 node = reader->node;
4477 * @reader: the xmlTextReaderPtr used
4482 * in case of error. The string is deallocated with the reader.
4485 xmlTextReaderConstXmlVersion(xmlTextReaderPtr reader) {
4487 if (reader == NULL)
4489 if (reader->doc != NULL)
4490 doc = reader->doc;
4491 else if (reader->ctxt != NULL)
4492 doc = reader->ctxt->myDoc;
4504 * @reader: the xmlTextReaderPtr used
4513 xmlTextReaderStandalone(xmlTextReaderPtr reader) {
4515 if (reader == NULL)
4517 if (reader->doc != NULL)
4518 doc = reader->doc;
4519 else if (reader->ctxt != NULL)
4520 doc = reader->ctxt->myDoc;
4649 xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx->_private;
4652 if (reader->errorFunc)
4653 reader->errorFunc(reader->errorFuncArg, str, severity,
4664 xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx->_private;
4666 if (error && reader->sErrorFunc) {
4667 reader->sErrorFunc(reader->errorFuncArg, (xmlErrorPtr) error);
4738 * @reader: the xmlTextReaderPtr used
4747 xmlTextReaderSetErrorHandler(xmlTextReaderPtr reader,
4751 reader->ctxt->sax->error = xmlTextReaderError;
4752 reader->ctxt->sax->serror = NULL;
4753 reader->ctxt->vctxt.error = xmlTextReaderValidityError;
4754 reader->ctxt->sax->warning = xmlTextReaderWarning;
4755 reader->ctxt->vctxt.warning = xmlTextReaderValidityWarning;
4756 reader->errorFunc = f;
4757 reader->sErrorFunc = NULL;
4758 reader->errorFuncArg = arg;
4760 if (reader->rngValidCtxt) {
4761 xmlRelaxNGSetValidErrors(reader->rngValidCtxt,
4764 reader);
4765 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt, NULL,
4766 reader);
4768 if (reader->xsdValidCtxt) {
4769 xmlSchemaSetValidErrors(reader->xsdValidCtxt,
4772 reader);
4773 xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt, NULL,
4774 reader);
4779 reader->ctxt->sax->error = xmlParserError;
4780 reader->ctxt->vctxt.error = xmlParserValidityError;
4781 reader->ctxt->sax->warning = xmlParserWarning;
4782 reader->ctxt->vctxt.warning = xmlParserValidityWarning;
4783 reader->errorFunc = NULL;
4784 reader->sErrorFunc = NULL;
4785 reader->errorFuncArg = NULL;
4787 if (reader->rngValidCtxt) {
4788 xmlRelaxNGSetValidErrors(reader->rngValidCtxt, NULL, NULL,
4789 reader);
4790 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt, NULL,
4791 reader);
4793 if (reader->xsdValidCtxt) {
4794 xmlSchemaSetValidErrors(reader->xsdValidCtxt, NULL, NULL,
4795 reader);
4796 xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt, NULL,
4797 reader);
4805 * @reader: the xmlTextReaderPtr used
4814 xmlTextReaderSetStructuredErrorHandler(xmlTextReaderPtr reader,
4818 reader->ctxt->sax->error = NULL;
4819 reader->ctxt->sax->serror = xmlTextReaderStructuredError;
4820 reader->ctxt->vctxt.error = xmlTextReaderValidityError;
4821 reader->ctxt->sax->warning = xmlTextReaderWarning;
4822 reader->ctxt->vctxt.warning = xmlTextReaderValidityWarning;
4823 reader->sErrorFunc = f;
4824 reader->errorFunc = NULL;
4825 reader->errorFuncArg = arg;
4827 if (reader->rngValidCtxt) {
4828 xmlRelaxNGSetValidErrors(reader->rngValidCtxt, NULL, NULL,
4829 reader);
4830 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
4832 reader);
4834 if (reader->xsdValidCtxt) {
4835 xmlSchemaSetValidErrors(reader->xsdValidCtxt, NULL, NULL,
4836 reader);
4837 xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt,
4839 reader);
4844 reader->ctxt->sax->error = xmlParserError;
4845 reader->ctxt->sax->serror = NULL;
4846 reader->ctxt->vctxt.error = xmlParserValidityError;
4847 reader->ctxt->sax->warning = xmlParserWarning;
4848 reader->ctxt->vctxt.warning = xmlParserValidityWarning;
4849 reader->errorFunc = NULL;
4850 reader->sErrorFunc = NULL;
4851 reader->errorFuncArg = NULL;
4853 if (reader->rngValidCtxt) {
4854 xmlRelaxNGSetValidErrors(reader->rngValidCtxt, NULL, NULL,
4855 reader);
4856 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt, NULL,
4857 reader);
4859 if (reader->xsdValidCtxt) {
4860 xmlSchemaSetValidErrors(reader->xsdValidCtxt, NULL, NULL,
4861 reader);
4862 xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt, NULL,
4863 reader);
4871 * @reader: the xmlTextReaderPtr used
4878 xmlTextReaderIsValid(xmlTextReaderPtr reader)
4880 if (reader == NULL)
4883 if (reader->validate == XML_TEXTREADER_VALIDATE_RNG)
4884 return (reader->rngValidErrors == 0);
4885 if (reader->validate == XML_TEXTREADER_VALIDATE_XSD)
4886 return (reader->xsdValidErrors == 0);
4888 if ((reader->ctxt != NULL) && (reader->ctxt->validate == 1))
4889 return (reader->ctxt->valid);
4895 * @reader: the xmlTextReaderPtr used
4902 xmlTextReaderGetErrorHandler(xmlTextReaderPtr reader,
4906 *f = reader->errorFunc;
4908 *arg = reader->errorFuncArg;
4918 * @reader: an XML reader
4919 * @input: xmlParserInputBufferPtr used to feed the reader, will
4925 * Setup an XML reader with new options
4930 xmlTextReaderSetup(xmlTextReaderPtr reader,
4934 if (reader == NULL) {
4941 * we force the generation of compact text nodes on the reader
4946 reader->doc = NULL;
4947 reader->entNr = 0;
4948 reader->parserFlags = options;
4949 reader->validate = XML_TEXTREADER_NOT_VALIDATE;
4950 if ((input != NULL) && (reader->input != NULL) &&
4951 (reader->allocs & XML_TEXTREADER_INPUT)) {
4952 xmlFreeParserInputBuffer(reader->input);
4953 reader->input = NULL;
4954 reader->allocs -= XML_TEXTREADER_INPUT;
4957 reader->input = input;
4958 reader->allocs |= XML_TEXTREADER_INPUT;
4960 if (reader->buffer == NULL)
4961 reader->buffer = xmlBufferCreateSize(100);
4962 if (reader->buffer == NULL) {
4967 if (reader->sax == NULL)
4968 reader->sax = (xmlSAXHandler *) xmlMalloc(sizeof(xmlSAXHandler));
4969 if (reader->sax == NULL) {
4974 xmlSAXVersion(reader->sax, 2);
4975 reader->startElement = reader->sax->startElement;
4976 reader->sax->startElement = xmlTextReaderStartElement;
4977 reader->endElement = reader->sax->endElement;
4978 reader->sax->endElement = xmlTextReaderEndElement;
4980 if (reader->sax->initialized == XML_SAX2_MAGIC) {
4982 reader->startElementNs = reader->sax->startElementNs;
4983 reader->sax->startElementNs = xmlTextReaderStartElementNs;
4984 reader->endElementNs = reader->sax->endElementNs;
4985 reader->sax->endElementNs = xmlTextReaderEndElementNs;
4988 reader->startElementNs = NULL;
4989 reader->endElementNs = NULL;
4992 reader->characters = reader->sax->characters;
4993 reader->sax->characters = xmlTextReaderCharacters;
4994 reader->sax->ignorableWhitespace = xmlTextReaderCharacters;
4995 reader->cdataBlock = reader->sax->cdataBlock;
4996 reader->sax->cdataBlock = xmlTextReaderCDataBlock;
4998 reader->mode = XML_TEXTREADER_MODE_INITIAL;
4999 reader->node = NULL;
5000 reader->curnode = NULL;
5002 if (reader->input->buffer->use < 4) {
5005 if (reader->ctxt == NULL) {
5006 if (reader->input->buffer->use >= 4) {
5007 reader->ctxt = xmlCreatePushParserCtxt(reader->sax, NULL,
5008 (const char *) reader->input->buffer->content, 4, URL);
5009 reader->base = 0;
5010 reader->cur = 4;
5012 reader->ctxt =
5013 xmlCreatePushParserCtxt(reader->sax, NULL, NULL, 0, URL);
5014 reader->base = 0;
5015 reader->cur = 0;
5022 xmlCtxtReset(reader->ctxt);
5025 inputStream = xmlNewInputStream(reader->ctxt);
5042 inputPush(reader->ctxt, inputStream);
5043 reader->cur = 0;
5045 if (reader->ctxt == NULL) {
5051 if (reader->dict != NULL) {
5052 if (reader->ctxt->dict != NULL) {
5053 if (reader->dict != reader->ctxt->dict) {
5054 xmlDictFree(reader->dict);
5055 reader->dict = reader->ctxt->dict;
5058 reader->ctxt->dict = reader->dict;
5061 if (reader->ctxt->dict == NULL)
5062 reader->ctxt->dict = xmlDictCreate();
5063 reader->dict = reader->ctxt->dict;
5065 reader->ctxt->_private = reader;
5066 reader->ctxt->linenumbers = 1;
5067 reader->ctxt->dictNames = 1;
5071 reader->ctxt->docdict = 1;
5072 reader->ctxt->parseMode = XML_PARSE_READER;
5075 if (reader->xincctxt != NULL) {
5076 xmlXIncludeFreeContext(reader->xincctxt);
5077 reader->xincctxt = NULL;
5080 reader->xinclude = 1;
5081 reader->xinclude_name = xmlDictLookup(reader->dict, XINCLUDE_NODE, -1);
5084 reader->xinclude = 0;
5085 reader->in_xinclude = 0;
5088 if (reader->patternTab == NULL) {
5089 reader->patternNr = 0;
5090 reader->patternMax = 0;
5092 while (reader->patternNr > 0) {
5093 reader->patternNr--;
5094 if (reader->patternTab[reader->patternNr] != NULL) {
5095 xmlFreePattern(reader->patternTab[reader->patternNr]);
5096 reader->patternTab[reader->patternNr] = NULL;
5102 reader->validate = XML_TEXTREADER_VALIDATE_DTD;
5104 xmlCtxtUseOptions(reader->ctxt, options);
5110 xmlSwitchToEncoding(reader->ctxt, hdlr);
5112 if ((URL != NULL) && (reader->ctxt->input != NULL) &&
5113 (reader->ctxt->input->filename == NULL))
5114 reader->ctxt->input->filename = (char *)
5117 reader->doc = NULL;
5124 * @reader: an XML reader
5127 * by the reader, relative to the start of the current entity.
5129 * for the parser context associated with the reader.
5136 xmlTextReaderByteConsumed(xmlTextReaderPtr reader) {
5137 if ((reader == NULL) || (reader->ctxt == NULL))
5139 return(xmlByteConsumed(reader->ctxt));
5149 * Returns the new reader or NULL in case of error.
5190 * Returns the new reader or NULL in case of error.
5215 * Returns the new reader or NULL in case of error.
5220 xmlTextReaderPtr reader;
5222 reader = xmlNewTextReaderFilename(filename);
5223 if (reader == NULL)
5225 xmlTextReaderSetup(reader, NULL, NULL, encoding, options);
5226 return (reader);
5240 * Returns the new reader or NULL in case of error.
5246 xmlTextReaderPtr reader;
5254 reader = xmlNewTextReader(buf, URL);
5255 if (reader == NULL) {
5259 reader->allocs |= XML_TEXTREADER_INPUT;
5260 xmlTextReaderSetup(reader, NULL, URL, encoding, options);
5261 return (reader);
5274 * reader is closed or reset.
5276 * Returns the new reader or NULL in case of error.
5281 xmlTextReaderPtr reader;
5291 reader = xmlNewTextReader(input, URL);
5292 if (reader == NULL) {
5296 reader->allocs |= XML_TEXTREADER_INPUT;
5297 xmlTextReaderSetup(reader, NULL, URL, encoding, options);
5298 return (reader);
5313 * Returns the new reader or NULL in case of error.
5320 xmlTextReaderPtr reader;
5330 reader = xmlNewTextReader(input, URL);
5331 if (reader == NULL) {
5335 reader->allocs |= XML_TEXTREADER_INPUT;
5336 xmlTextReaderSetup(reader, NULL, URL, encoding, options);
5337 return (reader);
5342 * @reader: an XML reader
5346 * This reuses the existing @reader xmlTextReader.
5351 xmlReaderNewWalker(xmlTextReaderPtr reader, xmlDocPtr doc)
5355 if (reader == NULL)
5358 if (reader->input != NULL) {
5359 xmlFreeParserInputBuffer(reader->input);
5361 if (reader->ctxt != NULL) {
5362 xmlCtxtReset(reader->ctxt);
5365 reader->entNr = 0;
5366 reader->input = NULL;
5367 reader->mode = XML_TEXTREADER_MODE_INITIAL;
5368 reader->node = NULL;
5369 reader->curnode = NULL;
5370 reader->base = 0;
5371 reader->cur = 0;
5372 reader->allocs = XML_TEXTREADER_CTXT;
5373 reader->doc = doc;
5374 reader->state = XML_TEXTREADER_START;
5375 if (reader->dict == NULL) {
5376 if ((reader->ctxt != NULL) && (reader->ctxt->dict != NULL))
5377 reader->dict = reader->ctxt->dict;
5379 reader->dict = xmlDictCreate();
5386 * @reader: an XML reader
5394 * This reuses the existing @reader xmlTextReader.
5399 xmlReaderNewDoc(xmlTextReaderPtr reader, const xmlChar * cur,
5407 if (reader == NULL)
5411 return (xmlReaderNewMemory(reader, (const char *)cur, len,
5417 * @reader: an XML reader
5424 * This reuses the existing @reader xmlTextReader.
5429 xmlReaderNewFile(xmlTextReaderPtr reader, const char *filename,
5436 if (reader == NULL)
5444 return (xmlTextReaderSetup(reader, input, filename, encoding, options));
5449 * @reader: an XML reader
5458 * This reuses the existing @reader xmlTextReader.
5463 xmlReaderNewMemory(xmlTextReaderPtr reader, const char *buffer, int size,
5468 if (reader == NULL)
5478 return (xmlTextReaderSetup(reader, input, URL, encoding, options));
5483 * @reader: an XML reader
5491 * reader is closed or reset.
5493 * This reuses the existing @reader xmlTextReader.
5498 xmlReaderNewFd(xmlTextReaderPtr reader, int fd,
5505 if (reader == NULL)
5512 return (xmlTextReaderSetup(reader, input, URL, encoding, options));
5517 * @reader: an XML reader
5528 * This reuses the existing @reader xmlTextReader.
5533 xmlReaderNewIO(xmlTextReaderPtr reader, xmlInputReadCallback ioread,
5541 if (reader == NULL)
5548 return (xmlTextReaderSetup(reader, input, URL, encoding, options));