Lines Matching defs: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 (reader->entNr == 0)) {
1397 xmlNodePtr tmp = reader->node->prev;
1400 xmlTextReaderFreeNode(reader, tmp);
1407 (reader->node->type == XML_ELEMENT_NODE) &&
1408 (reader->node->children == NULL) &&
1409 ((reader->node->extra & NODE_IS_EMPTY) == 0)) {;
1410 reader->state = XML_TEXTREADER_END;
1414 if ((reader->validate) && (reader->node->type == XML_ELEMENT_NODE))
1415 xmlTextReaderValidatePop(reader);
1417 if ((reader->preserves > 0) &&
1418 (reader->node->extra & NODE_IS_SPRESERVED))
1419 reader->preserves--;
1420 reader->node = reader->node->parent;
1421 if ((reader->node == NULL) ||
1422 (reader->node->type == XML_DOCUMENT_NODE) ||
1424 (reader->node->type == XML_DOCB_DOCUMENT_NODE) ||
1426 (reader->node->type == XML_HTML_DOCUMENT_NODE)) {
1427 if (reader->mode != XML_TEXTREADER_MODE_EOF) {
1428 val = xmlParseChunk(reader->ctxt, "", 0, 1);
1429 reader->state = XML_TEXTREADER_DONE;
1433 reader->node = NULL;
1434 reader->depth = -1;
1439 if ((reader->preserves == 0) &&
1441 (reader->in_xinclude == 0) &&
1443 (reader->entNr == 0) &&
1446 (reader->entNr == 0)) {
1448 xmlTextReaderFreeNode(reader, oldnode);
1453 if ((reader->preserves == 0) &&
1455 (reader->in_xinclude == 0) &&
1457 (reader->entNr == 0) &&
1458 (reader->node->last != NULL) &&
1459 ((reader->node->last->extra & NODE_IS_PRESERVED) == 0)) {
1460 xmlNodePtr tmp = reader->node->last;
1462 xmlTextReaderFreeNode(reader, tmp);
1464 reader->depth--;
1465 reader->state = XML_TEXTREADER_BACKTRACK;
1473 if ((reader->node != NULL) &&
1474 (reader->node->next == NULL) &&
1475 ((reader->node->type == XML_TEXT_NODE) ||
1476 (reader->node->type == XML_CDATA_SECTION_NODE))) {
1477 if (xmlTextReaderExpand(reader) == NULL)
1485 if ((reader->xinclude) && (reader->node != NULL) &&
1486 (reader->node->type == XML_ELEMENT_NODE) &&
1487 (reader->node->ns != NULL) &&
1488 ((xmlStrEqual(reader->node->ns->href, XINCLUDE_NS)) ||
1489 (xmlStrEqual(reader->node->ns->href, XINCLUDE_OLD_NS)))) {
1490 if (reader->xincctxt == NULL) {
1491 reader->xincctxt = xmlXIncludeNewContext(reader->ctxt->myDoc);
1492 xmlXIncludeSetFlags(reader->xincctxt,
1493 reader->parserFlags & (~XML_PARSE_NOXINCNODE));
1498 if (xmlTextReaderExpand(reader) == NULL)
1500 xmlXIncludeProcessNode(reader->xincctxt, reader->node);
1502 if ((reader->node != NULL) && (reader->node->type == XML_XINCLUDE_START)) {
1503 reader->in_xinclude++;
1506 if ((reader->node != NULL) && (reader->node->type == XML_XINCLUDE_END)) {
1507 reader->in_xinclude--;
1514 if ((reader->node != NULL) &&
1515 (reader->node->type == XML_ENTITY_REF_NODE) &&
1516 (reader->ctxt != NULL) && (reader->ctxt->replaceEntities == 1)) {
1521 if ((reader->node->children == NULL) && (reader->ctxt->sax != NULL) &&
1522 (reader->ctxt->sax->getEntity != NULL)) {
1523 reader->node->children = (xmlNodePtr)
1524 reader->ctxt->sax->getEntity(reader->ctxt, reader->node->name);
1527 if ((reader->node->children != NULL) &&
1528 (reader->node->children->type == XML_ENTITY_DECL) &&
1529 (reader->node->children->children != NULL)) {
1530 xmlTextReaderEntPush(reader, reader->node);
1531 reader->node = reader->node->children->children;
1534 } else if ((reader->node != NULL) &&
1535 (reader->node->type == XML_ENTITY_REF_NODE) &&
1536 (reader->ctxt != NULL) && (reader->validate)) {
1537 xmlTextReaderValidateEntity(reader);
1540 if ((reader->node != NULL) &&
1541 (reader->node->type == XML_ENTITY_DECL) &&
1542 (reader->ent != NULL) && (reader->ent->children == reader->node)) {
1543 reader->node = xmlTextReaderEntPop(reader);
1544 reader->depth++;
1548 if ((reader->validate) && (reader->node != NULL)) {
1549 xmlNodePtr node = reader->node;
1552 ((reader->state != XML_TEXTREADER_END) &&
1553 (reader->state != XML_TEXTREADER_BACKTRACK))) {
1554 xmlTextReaderValidatePush(reader);
1557 xmlTextReaderValidateCData(reader, node->content,
1563 if ((reader->patternNr > 0) && (reader->state != XML_TEXTREADER_END) &&
1564 (reader->state != XML_TEXTREADER_BACKTRACK)) {
1566 for (i = 0;i < reader->patternNr;i++) {
1567 if (xmlPatternMatch(reader->patternTab[i], reader->node) == 1) {
1568 xmlTextReaderPreserve(reader);
1575 if ((reader->validate == XML_TEXTREADER_VALIDATE_XSD) &&
1576 (reader->xsdValidErrors == 0) &&
1577 (reader->xsdValidCtxt != NULL)) {
1578 reader->xsdValidErrors = !xmlSchemaIsValid(reader->xsdValidCtxt);
1583 reader->state = XML_TEXTREADER_DONE;
1589 * @reader: the xmlTextReaderPtr used
1591 * Gets the read state of the reader.
1596 xmlTextReaderReadState(xmlTextReaderPtr reader) {
1597 if (reader == NULL)
1599 return(reader->mode);
1604 * @reader: the xmlTextReaderPtr used
1613 xmlTextReaderExpand(xmlTextReaderPtr reader) {
1614 if ((reader == NULL) || (reader->node == NULL))
1616 if (reader->doc != NULL)
1617 return(reader->node);
1618 if (reader->ctxt == NULL)
1620 if (xmlTextReaderDoExpand(reader) < 0)
1622 return(reader->node);
1627 * @reader: the xmlTextReaderPtr used
1636 xmlTextReaderNext(xmlTextReaderPtr reader) {
1640 if (reader == NULL)
1642 if (reader->doc != NULL)
1643 return(xmlTextReaderNextTree(reader));
1644 cur = reader->node;
1646 return(xmlTextReaderRead(reader));
1647 if (reader->state == XML_TEXTREADER_END || reader->state == XML_TEXTREADER_BACKTRACK)
1648 return(xmlTextReaderRead(reader));
1650 return(xmlTextReaderRead(reader));
1652 ret = xmlTextReaderRead(reader);
1655 } while (reader->node != cur);
1656 return(xmlTextReaderRead(reader));
1662 * @reader: the xmlTextReaderPtr used
1671 xmlTextReaderReadInnerXml(xmlTextReaderPtr reader ATTRIBUTE_UNUSED)
1678 if (xmlTextReaderExpand(reader) == NULL) {
1681 doc = reader->doc;
1683 for (cur_node = reader->node->children; cur_node != NULL;
1708 * @reader: the xmlTextReaderPtr used
1717 xmlTextReaderReadOuterXml(xmlTextReaderPtr reader ATTRIBUTE_UNUSED)
1724 node = reader->node;
1725 doc = reader->doc;
1726 if (xmlTextReaderExpand(reader) == NULL) {
1748 * @reader: the xmlTextReaderPtr used
1753 * or NULL if the reader is positioned on any other type of node.
1757 xmlTextReaderReadString(xmlTextReaderPtr reader)
1761 if ((reader == NULL) || (reader->node == NULL))
1764 node = (reader->curnode != NULL) ? reader->curnode : reader->node;
1771 if (xmlTextReaderDoExpand(reader) != -1) {
1786 * @reader: the xmlTextReaderPtr used
1799 xmlTextReaderReadBase64(xmlTextReaderPtr reader,
1803 if ((reader == NULL) || (reader->ctxt == NULL))
1805 if (reader->ctxt->wellFormed != 1)
1808 if ((reader->node == NULL) || (reader->node->type == XML_ELEMENT_NODE))
1816 * @reader: the xmlTextReaderPtr used
1829 xmlTextReaderReadBinHex(xmlTextReaderPtr reader,
1833 if ((reader == NULL) || (reader->ctxt == NULL))
1835 if (reader->ctxt->wellFormed != 1)
1838 if ((reader->node == NULL) || (reader->node->type == XML_ELEMENT_NODE))
1851 xmlTextReaderNextTree(xmlTextReaderPtr reader)
1853 if (reader == NULL)
1856 if (reader->state == XML_TEXTREADER_END)
1859 if (reader->node == NULL) {
1860 if (reader->doc->children == NULL) {
1861 reader->state = XML_TEXTREADER_END;
1865 reader->node = reader->doc->children;
1866 reader->state = XML_TEXTREADER_START;
1870 if (reader->state != XML_TEXTREADER_BACKTRACK) {
1873 if (reader->node->next != 0) {
1875 reader->node = reader->node->next;
1876 reader->state = XML_TEXTREADER_START;
1880 /* if reader->node->next is NULL mean no subtree for current node,
1882 if ((reader->node->type == XML_ELEMENT_NODE) ||
1883 (reader->node->type == XML_ATTRIBUTE_NODE)) {
1884 reader->state = XML_TEXTREADER_BACKTRACK;
1886 xmlTextReaderRead(reader);
1890 if (reader->node->next != 0) {
1891 reader->node = reader->node->next;
1892 reader->state = XML_TEXTREADER_START;
1896 if (reader->node->parent != 0) {
1897 if (reader->node->parent->type == XML_DOCUMENT_NODE) {
1898 reader->state = XML_TEXTREADER_END;
1902 reader->node = reader->node->parent;
1903 reader->depth--;
1904 reader->state = XML_TEXTREADER_BACKTRACK;
1906 xmlTextReaderNextTree(reader);
1909 reader->state = XML_TEXTREADER_END;
1916 * @reader: the xmlTextReaderPtr used
1925 xmlTextReaderReadTree(xmlTextReaderPtr reader) {
1926 if (reader->state == XML_TEXTREADER_END)
1930 if (reader->node == NULL) {
1931 if (reader->doc->children == NULL) {
1932 reader->state = XML_TEXTREADER_END;
1936 reader->node = reader->doc->children;
1937 reader->state = XML_TEXTREADER_START;
1941 if ((reader->state != XML_TEXTREADER_BACKTRACK) &&
1942 (reader->node->type != XML_DTD_NODE) &&
1943 (reader->node->type != XML_XINCLUDE_START) &&
1944 (reader->node->type != XML_ENTITY_REF_NODE)) {
1945 if (reader->node->children != NULL) {
1946 reader->node = reader->node->children;
1947 reader->depth++;
1948 reader->state = XML_TEXTREADER_START;
1952 if (reader->node->type == XML_ATTRIBUTE_NODE) {
1953 reader->state = XML_TEXTREADER_BACKTRACK;
1958 if (reader->node->next != NULL) {
1959 reader->node = reader->node->next;
1960 reader->state = XML_TEXTREADER_START;
1964 if (reader->node->parent != NULL) {
1965 if ((reader->node->parent->type == XML_DOCUMENT_NODE) ||
1966 (reader->node->parent->type == XML_HTML_DOCUMENT_NODE)) {
1967 reader->state = XML_TEXTREADER_END;
1971 reader->node = reader->node->parent;
1972 reader->depth--;
1973 reader->state = XML_TEXTREADER_BACKTRACK;
1977 reader->state = XML_TEXTREADER_END;
1980 if ((reader->node->type == XML_XINCLUDE_START) ||
1981 (reader->node->type == XML_XINCLUDE_END))
1989 * @reader: the xmlTextReaderPtr used
1999 xmlTextReaderNextSibling(xmlTextReaderPtr reader) {
2000 if (reader == NULL)
2002 if (reader->doc == NULL) {
2007 if (reader->state == XML_TEXTREADER_END)
2010 if (reader->node == NULL)
2011 return(xmlTextReaderNextTree(reader));
2013 if (reader->node->next != NULL) {
2014 reader->node = reader->node->next;
2015 reader->state = XML_TEXTREADER_START;
2172 * @reader: the xmlTextReaderPtr
2174 * Deallocate all the resources associated to the reader
2177 xmlFreeTextReader(xmlTextReaderPtr reader) {
2178 if (reader == NULL)
2181 if (reader->rngSchemas != NULL) {
2182 xmlRelaxNGFree(reader->rngSchemas);
2183 reader->rngSchemas = NULL;
2185 if (reader->rngValidCtxt != NULL) {
2186 xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
2187 reader->rngValidCtxt = NULL;
2189 if (reader->xsdPlug != NULL) {
2190 xmlSchemaSAXUnplug(reader->xsdPlug);
2191 reader->xsdPlug = NULL;
2193 if (reader->xsdValidCtxt != NULL) {
2194 if (! reader->xsdPreserveCtxt)
2195 xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
2196 reader->xsdValidCtxt = NULL;
2198 if (reader->xsdSchemas != NULL) {
2199 xmlSchemaFree(reader->xsdSchemas);
2200 reader->xsdSchemas = NULL;
2204 if (reader->xincctxt != NULL)
2205 xmlXIncludeFreeContext(reader->xincctxt);
2208 if (reader->patternTab != NULL) {
2210 for (i = 0;i < reader->patternNr;i++) {
2211 if (reader->patternTab[i] != NULL)
2212 xmlFreePattern(reader->patternTab[i]);
2214 xmlFree(reader->patternTab);
2217 if (reader->ctxt != NULL) {
2218 if (reader->dict == reader->ctxt->dict)
2219 reader->dict = NULL;
2220 if (reader->ctxt->myDoc != NULL) {
2221 if (reader->preserve == 0)
2222 xmlTextReaderFreeDoc(reader, reader->ctxt->myDoc);
2223 reader->ctxt->myDoc = NULL;
2225 if ((reader->ctxt->vctxt.vstateTab != NULL) &&
2226 (reader->ctxt->vctxt.vstateMax > 0)){
2227 xmlFree(reader->ctxt->vctxt.vstateTab);
2228 reader->ctxt->vctxt.vstateTab = NULL;
2229 reader->ctxt->vctxt.vstateMax = 0;
2231 if (reader->allocs & XML_TEXTREADER_CTXT)
2232 xmlFreeParserCtxt(reader->ctxt);
2234 if (reader->sax != NULL)
2235 xmlFree(reader->sax);
2236 if ((reader->input != NULL) && (reader->allocs & XML_TEXTREADER_INPUT))
2237 xmlFreeParserInputBuffer(reader->input);
2238 if (reader->faketext != NULL) {
2239 xmlFreeNode(reader->faketext);
2241 if (reader->buffer != NULL)
2242 xmlBufferFree(reader->buffer);
2243 if (reader->entTab != NULL)
2244 xmlFree(reader->entTab);
2245 if (reader->dict != NULL)
2246 xmlDictFree(reader->dict);
2247 xmlFree(reader);
2257 * @reader: the xmlTextReaderPtr used
2265 xmlTextReaderClose(xmlTextReaderPtr reader) {
2266 if (reader == NULL)
2268 reader->node = NULL;
2269 reader->curnode = NULL;
2270 reader->mode = XML_TEXTREADER_MODE_CLOSED;
2271 if (reader->ctxt != NULL) {
2272 xmlStopParser(reader->ctxt);
2273 if (reader->ctxt->myDoc != NULL) {
2274 if (reader->preserve == 0)
2275 xmlTextReaderFreeDoc(reader, reader->ctxt->myDoc);
2276 reader->ctxt->myDoc = NULL;
2279 if ((reader->input != NULL) && (reader->allocs & XML_TEXTREADER_INPUT)) {
2280 xmlFreeParserInputBuffer(reader->input);
2281 reader->allocs -= XML_TEXTREADER_INPUT;
2288 * @reader: the xmlTextReaderPtr used
2298 xmlTextReaderGetAttributeNo(xmlTextReaderPtr reader, int no) {
2304 if (reader == NULL)
2306 if (reader->node == NULL)
2308 if (reader->curnode != NULL)
2311 if (reader->node->type != XML_ELEMENT_NODE)
2314 ns = reader->node->nsDef;
2321 cur = reader->node->properties;
2331 ret = xmlNodeListGetString(reader->node->doc, cur->children, 1);
2338 * @reader: the xmlTextReaderPtr used
2347 xmlTextReaderGetAttribute(xmlTextReaderPtr reader, const xmlChar *name) {
2353 if ((reader == NULL) || (name == NULL))
2355 if (reader->node == NULL)
2357 if (reader->curnode != NULL)
2361 if (reader->node->type != XML_ELEMENT_NODE)
2370 ns = reader->node->nsDef;
2379 return(xmlGetNoNsProp(reader->node, name));
2386 ns = reader->node->nsDef;
2395 ns = xmlSearchNs(reader->node->doc, reader->node, prefix);
2397 ret = xmlGetNsProp(reader->node, localname, ns->href);
2409 * @reader: the xmlTextReaderPtr used
2419 xmlTextReaderGetAttributeNs(xmlTextReaderPtr reader, const xmlChar *localName,
2424 if ((reader == NULL) || (localName == NULL))
2426 if (reader->node == NULL)
2428 if (reader->curnode != NULL)
2432 if (reader->node->type != XML_ELEMENT_NODE)
2439 ns = reader->node->nsDef;
2450 return(xmlGetNsProp(reader->node, localName, namespaceURI));
2455 * @reader: the xmlTextReaderPtr used
2462 * what's left in reader->input, and there is an allocation problem. Best
2469 xmlTextReaderGetRemainder(xmlTextReaderPtr reader) {
2472 if (reader == NULL)
2474 if (reader->node == NULL)
2477 reader->node = NULL;
2478 reader->curnode = NULL;
2479 reader->mode = XML_TEXTREADER_MODE_EOF;
2480 if (reader->ctxt != NULL) {
2481 xmlStopParser(reader->ctxt);
2482 if (reader->ctxt->myDoc != NULL) {
2483 if (reader->preserve == 0)
2484 xmlTextReaderFreeDoc(reader, reader->ctxt->myDoc);
2485 reader->ctxt->myDoc = NULL;
2488 if (reader->allocs & XML_TEXTREADER_INPUT) {
2489 ret = reader->input;
2490 reader->input = NULL;
2491 reader->allocs -= XML_TEXTREADER_INPUT;
2507 * @reader: the xmlTextReaderPtr used
2517 xmlTextReaderLookupNamespace(xmlTextReaderPtr reader, const xmlChar *prefix) {
2520 if (reader == NULL)
2522 if (reader->node == NULL)
2525 ns = xmlSearchNs(reader->node->doc, reader->node, prefix);
2533 * @reader: the xmlTextReaderPtr used
2543 xmlTextReaderMoveToAttributeNo(xmlTextReaderPtr reader, int no) {
2548 if (reader == NULL)
2550 if (reader->node == NULL)
2553 if (reader->node->type != XML_ELEMENT_NODE)
2556 reader->curnode = NULL;
2558 ns = reader->node->nsDef;
2563 reader->curnode = (xmlNodePtr) ns;
2567 cur = reader->node->properties;
2577 reader->curnode = (xmlNodePtr) cur;
2583 * @reader: the xmlTextReaderPtr used
2592 xmlTextReaderMoveToAttribute(xmlTextReaderPtr reader, const xmlChar *name) {
2598 if ((reader == NULL) || (name == NULL))
2600 if (reader->node == NULL)
2604 if (reader->node->type != XML_ELEMENT_NODE)
2613 ns = reader->node->nsDef;
2616 reader->curnode = (xmlNodePtr) ns;
2624 prop = reader->node->properties;
2633 reader->curnode = (xmlNodePtr) prop;
2645 ns = reader->node->nsDef;
2648 reader->curnode = (xmlNodePtr) ns;
2655 prop = reader->node->properties;
2664 reader->curnode = (xmlNodePtr) prop;
2686 * @reader: the xmlTextReaderPtr used
2696 xmlTextReaderMoveToAttributeNs(xmlTextReaderPtr reader,
2703 if ((reader == NULL) || (localName == NULL) || (namespaceURI == NULL))
2705 if (reader->node == NULL)
2707 if (reader->node->type != XML_ELEMENT_NODE)
2709 node = reader->node;
2715 ns = reader->node->nsDef;
2719 reader->curnode = (xmlNodePtr) ns;
2737 reader->curnode = (xmlNodePtr) prop;
2747 * @reader: the xmlTextReaderPtr used
2755 xmlTextReaderMoveToFirstAttribute(xmlTextReaderPtr reader) {
2756 if (reader == NULL)
2758 if (reader->node == NULL)
2760 if (reader->node->type != XML_ELEMENT_NODE)
2763 if (reader->node->nsDef != NULL) {
2764 reader->curnode = (xmlNodePtr) reader->node->nsDef;
2767 if (reader->node->properties != NULL) {
2768 reader->curnode = (xmlNodePtr) reader->node->properties;
2776 * @reader: the xmlTextReaderPtr used
2784 xmlTextReaderMoveToNextAttribute(xmlTextReaderPtr reader) {
2785 if (reader == NULL)
2787 if (reader->node == NULL)
2789 if (reader->node->type != XML_ELEMENT_NODE)
2791 if (reader->curnode == NULL)
2792 return(xmlTextReaderMoveToFirstAttribute(reader));
2794 if (reader->curnode->type == XML_NAMESPACE_DECL) {
2795 xmlNsPtr ns = (xmlNsPtr) reader->curnode;
2797 reader->curnode = (xmlNodePtr) ns->next;
2800 if (reader->node->properties != NULL) {
2801 reader->curnode = (xmlNodePtr) reader->node->properties;
2805 } else if ((reader->curnode->type == XML_ATTRIBUTE_NODE) &&
2806 (reader->curnode->next != NULL)) {
2807 reader->curnode = reader->curnode->next;
2815 * @reader: the xmlTextReaderPtr used
2823 xmlTextReaderMoveToElement(xmlTextReaderPtr reader) {
2824 if (reader == NULL)
2826 if (reader->node == NULL)
2828 if (reader->node->type != XML_ELEMENT_NODE)
2830 if (reader->curnode != NULL) {
2831 reader->curnode = NULL;
2839 * @reader: the xmlTextReaderPtr used
2843 * Returns 1 in case of success, 0 if the reader was not positionned on an
2848 xmlTextReaderReadAttributeValue(xmlTextReaderPtr reader) {
2849 if (reader == NULL)
2851 if (reader->node == NULL)
2853 if (reader->curnode == NULL)
2855 if (reader->curnode->type == XML_ATTRIBUTE_NODE) {
2856 if (reader->curnode->children == NULL)
2858 reader->curnode = reader->curnode->children;
2859 } else if (reader->curnode->type == XML_NAMESPACE_DECL) {
2860 xmlNsPtr ns = (xmlNsPtr) reader->curnode;
2862 if (reader->faketext == NULL) {
2863 reader->faketext = xmlNewDocText(reader->node->doc,
2866 if ((reader->faketext->content != NULL) &&
2867 (reader->faketext->content !=
2868 (xmlChar *) &(reader->faketext->properties)))
2869 xmlFree(reader->faketext->content);
2870 reader->faketext->content = xmlStrdup(ns->href);
2872 reader->curnode = reader->faketext;
2874 if (reader->curnode->next == NULL)
2876 reader->curnode = reader->curnode->next;
2883 * @reader: the xmlTextReaderPtr used
2888 * case of error. The string is deallocated with the reader.
2891 xmlTextReaderConstEncoding(xmlTextReaderPtr reader) {
2893 if (reader == NULL)
2895 if (reader->doc != NULL)
2896 doc = reader->doc;
2897 else if (reader->ctxt != NULL)
2898 doc = reader->ctxt->myDoc;
2916 * @reader: the xmlTextReaderPtr used
2923 xmlTextReaderAttributeCount(xmlTextReaderPtr reader) {
2929 if (reader == NULL)
2931 if (reader->node == NULL)
2934 if (reader->curnode != NULL)
2935 node = reader->curnode;
2937 node = reader->node;
2941 if ((reader->state == XML_TEXTREADER_END) ||
2942 (reader->state == XML_TEXTREADER_BACKTRACK))
2960 * @reader: the xmlTextReaderPtr used
2969 xmlTextReaderNodeType(xmlTextReaderPtr reader) {
2972 if (reader == NULL)
2974 if (reader->node == NULL)
2976 if (reader->curnode != NULL)
2977 node = reader->curnode;
2979 node = reader->node;
2982 if ((reader->state == XML_TEXTREADER_END) ||
2983 (reader->state == XML_TEXTREADER_BACKTRACK))
2990 if (xmlIsBlankNode(reader->node)) {
2991 if (xmlNodeGetSpacePreserve(reader->node))
3034 * @reader: the xmlTextReaderPtr used
3041 xmlTextReaderIsEmptyElement(xmlTextReaderPtr reader) {
3042 if ((reader == NULL) || (reader->node == NULL))
3044 if (reader->node->type != XML_ELEMENT_NODE)
3046 if (reader->curnode != NULL)
3048 if (reader->node->children != NULL)
3050 if (reader->state == XML_TEXTREADER_END)
3052 if (reader->doc != NULL)
3055 if (reader->in_xinclude > 0)
3058 return((reader->node->extra & NODE_IS_EMPTY) != 0);
3063 * @reader: the xmlTextReaderPtr used
3070 xmlTextReaderLocalName(xmlTextReaderPtr reader) {
3072 if ((reader == NULL) || (reader->node == NULL))
3074 if (reader->curnode != NULL)
3075 node = reader->curnode;
3077 node = reader->node;
3087 return(xmlTextReaderName(reader));
3093 * @reader: the xmlTextReaderPtr used
3098 * string will be deallocated with the reader.
3101 xmlTextReaderConstLocalName(xmlTextReaderPtr reader) {
3103 if ((reader == NULL) || (reader->node == NULL))
3105 if (reader->curnode != NULL)
3106 node = reader->curnode;
3108 node = reader->node;
3118 return(xmlTextReaderConstName(reader));
3124 * @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
3274 xmlTextReaderPrefix(xmlTextReaderPtr reader) {
3276 if ((reader == NULL) || (reader->node == NULL))
3278 if (reader->curnode != NULL)
3279 node = reader->curnode;
3281 node = reader->node;
3298 * @reader: the xmlTextReaderPtr used
3303 * with the reader.
3306 xmlTextReaderConstPrefix(xmlTextReaderPtr reader) {
3308 if ((reader == NULL) || (reader->node == NULL))
3310 if (reader->curnode != NULL)
3311 node = reader->curnode;
3313 node = reader->node;
3330 * @reader: the xmlTextReaderPtr used
3337 xmlTextReaderNamespaceUri(xmlTextReaderPtr reader) {
3339 if ((reader == NULL) || (reader->node == NULL))
3341 if (reader->curnode != NULL)
3342 node = reader->curnode;
3344 node = reader->node;
3357 * @reader: the xmlTextReaderPtr used
3362 * will be deallocated with the reader
3365 xmlTextReaderConstNamespaceUri(xmlTextReaderPtr reader) {
3367 if ((reader == NULL) || (reader->node == NULL))
3369 if (reader->curnode != NULL)
3370 node = reader->curnode;
3372 node = reader->node;
3385 * @reader: the xmlTextReaderPtr used
3392 xmlTextReaderBaseUri(xmlTextReaderPtr reader) {
3393 if ((reader == NULL) || (reader->node == NULL))
3395 return(xmlNodeGetBase(NULL, reader->node));
3400 * @reader: the xmlTextReaderPtr used
3405 * will be deallocated with the reader
3408 xmlTextReaderConstBaseUri(xmlTextReaderPtr reader) {
3412 if ((reader == NULL) || (reader->node == NULL))
3414 tmp = xmlNodeGetBase(NULL, reader->node);
3424 * @reader: the xmlTextReaderPtr used
3431 xmlTextReaderDepth(xmlTextReaderPtr reader) {
3432 if (reader == NULL)
3434 if (reader->node == NULL)
3437 if (reader->curnode != NULL) {
3438 if ((reader->curnode->type == XML_ATTRIBUTE_NODE) ||
3439 (reader->curnode->type == XML_NAMESPACE_DECL))
3440 return(reader->depth + 1);
3441 return(reader->depth + 2);
3443 return(reader->depth);
3448 * @reader: the xmlTextReaderPtr used
3455 xmlTextReaderHasAttributes(xmlTextReaderPtr reader) {
3457 if (reader == NULL)
3459 if (reader->node == NULL)
3461 if (reader->curnode != NULL)
3462 node = reader->curnode;
3464 node = reader->node;
3475 * @reader: the xmlTextReaderPtr used
3482 xmlTextReaderHasValue(xmlTextReaderPtr reader) {
3484 if (reader == NULL)
3486 if (reader->node == NULL)
3488 if (reader->curnode != NULL)
3489 node = reader->curnode;
3491 node = reader->node;
3509 * @reader: the xmlTextReaderPtr used
3517 xmlTextReaderValue(xmlTextReaderPtr reader) {
3519 if (reader == NULL)
3521 if (reader->node == NULL)
3523 if (reader->curnode != NULL)
3524 node = reader->curnode;
3526 node = reader->node;
3555 * @reader: the xmlTextReaderPtr used
3563 xmlTextReaderConstValue(xmlTextReaderPtr reader) {
3565 if (reader == NULL)
3567 if (reader->node == NULL)
3569 if (reader->curnode != NULL)
3570 node = reader->curnode;
3572 node = reader->node;
3585 if (reader->buffer == NULL)
3586 reader->buffer = xmlBufferCreateSize(100);
3587 if (reader->buffer == NULL) {
3592 reader->buffer->use = 0;
3593 xmlNodeBufGetContent(reader->buffer, node);
3594 return(reader->buffer->content);
3611 * @reader: the xmlTextReaderPtr used
3619 xmlTextReaderIsDefault(xmlTextReaderPtr reader) {
3620 if (reader == NULL)
3627 * @reader: the xmlTextReaderPtr used
3634 xmlTextReaderQuoteChar(xmlTextReaderPtr reader) {
3635 if (reader == NULL)
3643 * @reader: the xmlTextReaderPtr used
3650 xmlTextReaderXmlLang(xmlTextReaderPtr reader) {
3651 if (reader == NULL)
3653 if (reader->node == NULL)
3655 return(xmlNodeGetLang(reader->node));
3660 * @reader: the xmlTextReaderPtr used
3667 xmlTextReaderConstXmlLang(xmlTextReaderPtr reader) {
3671 if (reader == NULL)
3673 if (reader->node == NULL)
3675 tmp = xmlNodeGetLang(reader->node);
3685 * @reader: the xmlTextReaderPtr used
3688 * Get an interned string from the reader, allows for example to
3692 * string will be deallocated with the reader.
3695 xmlTextReaderConstString(xmlTextReaderPtr reader, const xmlChar *str) {
3696 if (reader == NULL)
3703 * @reader: the xmlTextReaderPtr used
3714 xmlTextReaderNormalization(xmlTextReaderPtr reader) {
3715 if (reader == NULL)
3728 * @reader: the xmlTextReaderPtr used
3739 xmlTextReaderSetParserProp(xmlTextReaderPtr reader, int prop, int value) {
3743 if ((reader == NULL) || (reader->ctxt == NULL))
3745 ctxt = reader->ctxt;
3751 if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
3770 reader->validate = XML_TEXTREADER_VALIDATE_DTD;
3788 * @reader: the xmlTextReaderPtr used
3796 xmlTextReaderGetParserProp(xmlTextReaderPtr reader, int prop) {
3800 if ((reader == NULL) || (reader->ctxt == NULL))
3802 ctxt = reader->ctxt;
3814 return(reader->validate);
3824 * @reader: the user data (XML reader context)
3831 xmlTextReaderGetParserLineNumber(xmlTextReaderPtr reader)
3833 if ((reader == NULL) || (reader->ctxt == NULL) ||
3834 (reader->ctxt->input == NULL)) {
3837 return (reader->ctxt->input->line);
3842 * @reader: the user data (XML reader context)
3849 xmlTextReaderGetParserColumnNumber(xmlTextReaderPtr reader)
3851 if ((reader == NULL) || (reader->ctxt == NULL) ||
3852 (reader->ctxt->input == NULL)) {
3855 return (reader->ctxt->input->col);
3860 * @reader: the xmlTextReaderPtr used
3869 xmlTextReaderCurrentNode(xmlTextReaderPtr reader) {
3870 if (reader == NULL)
3873 if (reader->curnode != NULL)
3874 return(reader->curnode);
3875 return(reader->node);
3880 * @reader: the xmlTextReaderPtr used
3889 xmlTextReaderPreserve(xmlTextReaderPtr reader) {
3892 if (reader == NULL)
3895 if (reader->curnode != NULL)
3896 cur = reader->curnode;
3898 cur = reader->node;
3906 reader->preserves++;
3920 * @reader: the xmlTextReaderPtr used
3931 xmlTextReaderPreservePattern(xmlTextReaderPtr reader, const xmlChar *pattern,
3936 if ((reader == NULL) || (pattern == NULL))
3939 comp = xmlPatterncompile(pattern, reader->dict, 0, namespaces);
3943 if (reader->patternMax <= 0) {
3944 reader->patternMax = 4;
3945 reader->patternTab = (xmlPatternPtr *) xmlMalloc(reader->patternMax *
3946 sizeof(reader->patternTab[0]));
3947 if (reader->patternTab == NULL) {
3952 if (reader->patternNr >= reader->patternMax) {
3954 reader->patternMax *= 2;
3955 tmp = (xmlPatternPtr *) xmlRealloc(reader->patternTab,
3956 reader->patternMax *
3957 sizeof(reader->patternTab[0]));
3960 reader->patternMax /= 2;
3963 reader->patternTab = tmp;
3965 reader->patternTab[reader->patternNr] = comp;
3966 return(reader->patternNr++);
3972 * @reader: the xmlTextReaderPtr used
3976 * NOTE: as a result of this call, the reader will not destroy the
3978 * is needed once the reader parsing has finished.
3983 xmlTextReaderCurrentDoc(xmlTextReaderPtr reader) {
3984 if (reader == NULL)
3986 if (reader->doc != NULL)
3987 return(reader->doc);
3988 if ((reader->ctxt == NULL) || (reader->ctxt->myDoc == NULL))
3991 reader->preserve = 1;
3992 return(reader->ctxt->myDoc);
4008 xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx;
4014 if (!reader->errorFunc) {
4017 reader->errorFunc(reader->errorFuncArg, str, XML_PARSER_SEVERITY_VALIDITY_ERROR, NULL /* locator */);
4026 xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx;
4032 if (!reader->errorFunc) {
4035 reader->errorFunc(reader->errorFuncArg, str, XML_PARSER_SEVERITY_VALIDITY_WARNING, NULL /* locator */);
4047 xmlTextReaderPtr reader = (xmlTextReaderPtr) userData;
4049 if (reader->sErrorFunc) {
4050 reader->sErrorFunc(reader->errorFuncArg, error);
4052 xmlTextReaderStructuredError(reader, error);
4058 * @reader: the xmlTextReaderPtr used
4064 @ The @schema should not be freed until the reader is deallocated
4071 xmlTextReaderRelaxNGSetSchema(xmlTextReaderPtr reader, xmlRelaxNGPtr schema) {
4072 if (reader == NULL)
4075 if (reader->rngSchemas != NULL) {
4076 xmlRelaxNGFree(reader->rngSchemas);
4077 reader->rngSchemas = NULL;
4079 if (reader->rngValidCtxt != NULL) {
4080 xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
4081 reader->rngValidCtxt = NULL;
4085 if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
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;
4095 reader->rngValidCtxt = xmlRelaxNGNewValidCtxt(schema);
4096 if (reader->rngValidCtxt == NULL)
4098 if (reader->errorFunc != NULL) {
4099 xmlRelaxNGSetValidErrors(reader->rngValidCtxt,
4102 reader);
4104 if (reader->sErrorFunc != NULL) {
4105 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
4107 reader);
4109 reader->rngValidErrors = 0;
4110 reader->rngFullNode = NULL;
4111 reader->validate = XML_TEXTREADER_VALIDATE_RNG;
4117 * @reader: the xmlTextReaderPtr used
4123 @ The @schema should not be freed until the reader is deallocated
4130 xmlTextReaderSetSchema(xmlTextReaderPtr reader, xmlSchemaPtr schema) {
4131 if (reader == NULL)
4134 if (reader->xsdPlug != NULL) {
4135 xmlSchemaSAXUnplug(reader->xsdPlug);
4136 reader->xsdPlug = NULL;
4138 if (reader->xsdValidCtxt != NULL) {
4139 if (! reader->xsdPreserveCtxt)
4140 xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
4141 reader->xsdValidCtxt = NULL;
4143 reader->xsdPreserveCtxt = 0;
4144 if (reader->xsdSchemas != NULL) {
4145 xmlSchemaFree(reader->xsdSchemas);
4146 reader->xsdSchemas = NULL;
4150 if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
4152 if (reader->xsdPlug != NULL) {
4153 xmlSchemaSAXUnplug(reader->xsdPlug);
4154 reader->xsdPlug = NULL;
4156 if (reader->xsdValidCtxt != NULL) {
4157 if (! reader->xsdPreserveCtxt)
4158 xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
4159 reader->xsdValidCtxt = NULL;
4161 reader->xsdPreserveCtxt = 0;
4162 if (reader->xsdSchemas != NULL) {
4163 xmlSchemaFree(reader->xsdSchemas);
4164 reader->xsdSchemas = NULL;
4166 reader->xsdValidCtxt = xmlSchemaNewValidCtxt(schema);
4167 if (reader->xsdValidCtxt == NULL) {
4168 xmlSchemaFree(reader->xsdSchemas);
4169 reader->xsdSchemas = NULL;
4172 reader->xsdPlug = xmlSchemaSAXPlug(reader->xsdValidCtxt,
4173 &(reader->ctxt->sax),
4174 &(reader->ctxt->userData));
4175 if (reader->xsdPlug == NULL) {
4176 xmlSchemaFree(reader->xsdSchemas);
4177 reader->xsdSchemas = NULL;
4178 xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
4179 reader->xsdValidCtxt = NULL;
4182 if (reader->errorFunc != NULL) {
4183 xmlSchemaSetValidErrors(reader->xsdValidCtxt,
4186 reader);
4188 if (reader->sErrorFunc != NULL) {
4189 xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt,
4191 reader);
4193 reader->xsdValidErrors = 0;
4194 reader->validate = XML_TEXTREADER_VALIDATE_XSD;
4200 * @reader: the xmlTextReaderPtr used
4211 xmlTextReaderRelaxNGValidate(xmlTextReaderPtr reader, const char *rng) {
4214 if (reader == NULL)
4218 if (reader->rngValidCtxt != NULL) {
4219 xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
4220 reader->rngValidCtxt = NULL;
4222 if (reader->rngSchemas != NULL) {
4223 xmlRelaxNGFree(reader->rngSchemas);
4224 reader->rngSchemas = NULL;
4228 if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
4230 if (reader->rngSchemas != NULL) {
4231 xmlRelaxNGFree(reader->rngSchemas);
4232 reader->rngSchemas = NULL;
4234 if (reader->rngValidCtxt != NULL) {
4235 xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
4236 reader->rngValidCtxt = NULL;
4239 if (reader->errorFunc != NULL) {
4243 reader);
4245 if (reader->sErrorFunc != NULL) {
4246 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
4248 reader);
4250 reader->rngSchemas = xmlRelaxNGParse(ctxt);
4252 if (reader->rngSchemas == NULL)
4254 reader->rngValidCtxt = xmlRelaxNGNewValidCtxt(reader->rngSchemas);
4255 if (reader->rngValidCtxt == NULL) {
4256 xmlRelaxNGFree(reader->rngSchemas);
4257 reader->rngSchemas = NULL;
4260 if (reader->errorFunc != NULL) {
4261 xmlRelaxNGSetValidErrors(reader->rngValidCtxt,
4264 reader);
4266 if (reader->sErrorFunc != NULL) {
4267 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
4269 reader);
4271 reader->rngValidErrors = 0;
4272 reader->rngFullNode = NULL;
4273 reader->validate = XML_TEXTREADER_VALIDATE_RNG;
4279 * @reader: the xmlTextReaderPtr used
4292 xmlTextReaderSchemaValidateInternal(xmlTextReaderPtr reader,
4297 if (reader == NULL)
4304 ((reader->mode != XML_TEXTREADER_MODE_INITIAL) ||
4305 (reader->ctxt == NULL)))
4309 if (reader->xsdPlug != NULL) {
4310 xmlSchemaSAXUnplug(reader->xsdPlug);
4311 reader->xsdPlug = NULL;
4313 if (reader->xsdValidCtxt != NULL) {
4314 if (! reader->xsdPreserveCtxt)
4315 xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
4316 reader->xsdValidCtxt = NULL;
4318 reader->xsdPreserveCtxt = 0;
4319 if (reader->xsdSchemas != NULL) {
4320 xmlSchemaFree(reader->xsdSchemas);
4321 reader->xsdSchemas = NULL;
4333 if (reader->errorFunc != NULL) {
4337 reader);
4339 reader->xsdSchemas = xmlSchemaParse(pctxt);
4341 if (reader->xsdSchemas == NULL)
4343 reader->xsdValidCtxt = xmlSchemaNewValidCtxt(reader->xsdSchemas);
4344 if (reader->xsdValidCtxt == NULL) {
4345 xmlSchemaFree(reader->xsdSchemas);
4346 reader->xsdSchemas = NULL;
4349 reader->xsdPlug = xmlSchemaSAXPlug(reader->xsdValidCtxt,
4350 &(reader->ctxt->sax),
4351 &(reader->ctxt->userData));
4352 if (reader->xsdPlug == NULL) {
4353 xmlSchemaFree(reader->xsdSchemas);
4354 reader->xsdSchemas = NULL;
4355 xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
4356 reader->xsdValidCtxt = NULL;
4361 reader->xsdValidCtxt = ctxt;
4362 reader->xsdPreserveCtxt = 1;
4363 reader->xsdPlug = xmlSchemaSAXPlug(reader->xsdValidCtxt,
4364 &(reader->ctxt->sax),
4365 &(reader->ctxt->userData));
4366 if (reader->xsdPlug == NULL) {
4367 reader->xsdValidCtxt = NULL;
4368 reader->xsdPreserveCtxt = 0;
4374 * the reader channels.
4378 if (reader->errorFunc != NULL) {
4379 xmlSchemaSetValidErrors(reader->xsdValidCtxt,
4382 reader);
4384 if (reader->sErrorFunc != NULL) {
4385 xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt,
4387 reader);
4389 reader->xsdValidErrors = 0;
4390 reader->validate = XML_TEXTREADER_VALIDATE_XSD;
4396 * @reader: the xmlTextReaderPtr used
4408 xmlTextReaderSchemaValidateCtxt(xmlTextReaderPtr reader,
4412 return(xmlTextReaderSchemaValidateInternal(reader, NULL, ctxt, options));
4417 * @reader: the xmlTextReaderPtr used
4428 xmlTextReaderSchemaValidate(xmlTextReaderPtr reader, const char *xsd)
4430 return(xmlTextReaderSchemaValidateInternal(reader, xsd, NULL, 0));
4436 * @reader: the xmlTextReaderPtr used
4446 xmlTextReaderIsNamespaceDecl(xmlTextReaderPtr reader) {
4448 if (reader == NULL)
4450 if (reader->node == NULL)
4452 if (reader->curnode != NULL)
4453 node = reader->curnode;
4455 node = reader->node;
4465 * @reader: the xmlTextReaderPtr used
4470 * in case of error. The string is deallocated with the reader.
4473 xmlTextReaderConstXmlVersion(xmlTextReaderPtr reader) {
4475 if (reader == NULL)
4477 if (reader->doc != NULL)
4478 doc = reader->doc;
4479 else if (reader->ctxt != NULL)
4480 doc = reader->ctxt->myDoc;
4492 * @reader: the xmlTextReaderPtr used
4501 xmlTextReaderStandalone(xmlTextReaderPtr reader) {
4503 if (reader == NULL)
4505 if (reader->doc != NULL)
4506 doc = reader->doc;
4507 else if (reader->ctxt != NULL)
4508 doc = reader->ctxt->myDoc;
4633 xmlTextReaderPtr reader = (xmlTextReaderPtr)ctx->_private;
4636 if (reader->errorFunc)
4637 reader->errorFunc(reader->errorFuncArg,
4648 xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx->_private;
4650 if (error && reader->sErrorFunc) {
4651 reader->sErrorFunc(reader->errorFuncArg,
4717 * @reader: the xmlTextReaderPtr used
4726 xmlTextReaderSetErrorHandler(xmlTextReaderPtr reader,
4730 reader->ctxt->sax->error = xmlTextReaderError;
4731 reader->ctxt->sax->serror = NULL;
4732 reader->ctxt->vctxt.error = xmlTextReaderValidityError;
4733 reader->ctxt->sax->warning = xmlTextReaderWarning;
4734 reader->ctxt->vctxt.warning = xmlTextReaderValidityWarning;
4735 reader->errorFunc = f;
4736 reader->sErrorFunc = NULL;
4737 reader->errorFuncArg = arg;
4739 if (reader->rngValidCtxt) {
4740 xmlRelaxNGSetValidErrors(reader->rngValidCtxt,
4743 reader);
4744 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt, NULL, reader);
4746 if (reader->xsdValidCtxt) {
4747 xmlSchemaSetValidErrors(reader->xsdValidCtxt,
4750 reader);
4751 xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt, NULL, reader);
4757 reader->ctxt->sax->error = xmlParserError;
4758 reader->ctxt->vctxt.error = xmlParserValidityError;
4759 reader->ctxt->sax->warning = xmlParserWarning;
4760 reader->ctxt->vctxt.warning = xmlParserValidityWarning;
4761 reader->errorFunc = NULL;
4762 reader->sErrorFunc = NULL;
4763 reader->errorFuncArg = NULL;
4765 if (reader->rngValidCtxt) {
4766 xmlRelaxNGSetValidErrors(reader->rngValidCtxt, NULL, NULL, reader);
4767 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt, NULL, reader);
4769 if (reader->xsdValidCtxt) {
4770 xmlSchemaSetValidErrors(reader->xsdValidCtxt, NULL, NULL, reader);
4771 xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt, NULL, reader);
4779 * @reader: the xmlTextReaderPtr used
4788 xmlTextReaderSetStructuredErrorHandler(xmlTextReaderPtr reader,
4792 reader->ctxt->sax->error = NULL;
4793 reader->ctxt->sax->serror = xmlTextReaderStructuredError;
4794 reader->ctxt->vctxt.error = xmlTextReaderValidityError;
4795 reader->ctxt->sax->warning = xmlTextReaderWarning;
4796 reader->ctxt->vctxt.warning = xmlTextReaderValidityWarning;
4797 reader->sErrorFunc = f;
4798 reader->errorFunc = NULL;
4799 reader->errorFuncArg = arg;
4801 if (reader->rngValidCtxt) {
4802 xmlRelaxNGSetValidErrors(reader->rngValidCtxt, NULL, NULL, reader);
4803 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
4805 reader);
4807 if (reader->xsdValidCtxt) {
4808 xmlSchemaSetValidErrors(reader->xsdValidCtxt, NULL, NULL, reader);
4809 xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt,
4811 reader);
4817 reader->ctxt->sax->error = xmlParserError;
4818 reader->ctxt->sax->serror = NULL;
4819 reader->ctxt->vctxt.error = xmlParserValidityError;
4820 reader->ctxt->sax->warning = xmlParserWarning;
4821 reader->ctxt->vctxt.warning = xmlParserValidityWarning;
4822 reader->errorFunc = NULL;
4823 reader->sErrorFunc = NULL;
4824 reader->errorFuncArg = NULL;
4826 if (reader->rngValidCtxt) {
4827 xmlRelaxNGSetValidErrors(reader->rngValidCtxt, NULL, NULL, reader);
4828 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt, NULL, reader);
4830 if (reader->xsdValidCtxt) {
4831 xmlSchemaSetValidErrors(reader->xsdValidCtxt, NULL, NULL, reader);
4832 xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt, NULL, reader);
4840 * @reader: the xmlTextReaderPtr used
4847 xmlTextReaderIsValid(xmlTextReaderPtr reader) {
4848 if (reader == NULL) return(-1);
4850 if (reader->validate == XML_TEXTREADER_VALIDATE_RNG)
4851 return(reader->rngValidErrors == 0);
4852 if (reader->validate == XML_TEXTREADER_VALIDATE_XSD)
4853 return(reader->xsdValidErrors == 0);
4855 if ((reader->ctxt != NULL) && (reader->ctxt->validate == 1))
4856 return(reader->ctxt->valid);
4862 * @reader: the xmlTextReaderPtr used
4869 xmlTextReaderGetErrorHandler(xmlTextReaderPtr reader,
4872 if (f != NULL) *f = reader->errorFunc;
4873 if (arg != NULL) *arg = reader->errorFuncArg;
4885 * @reader: an XML reader
4886 * @input: xmlParserInputBufferPtr used to feed the reader, will
4892 * Setup an XML reader with new options
4897 xmlTextReaderSetup(xmlTextReaderPtr reader,
4901 if (reader == NULL) {
4908 * we force the generation of compact text nodes on the reader
4913 reader->doc = NULL;
4914 reader->entNr = 0;
4915 reader->parserFlags = options;
4916 reader->validate = XML_TEXTREADER_NOT_VALIDATE;
4917 if ((input != NULL) && (reader->input != NULL) &&
4918 (reader->allocs & XML_TEXTREADER_INPUT)) {
4919 xmlFreeParserInputBuffer(reader->input);
4920 reader->input = NULL;
4921 reader->allocs -= XML_TEXTREADER_INPUT;
4924 reader->input = input;
4925 reader->allocs |= XML_TEXTREADER_INPUT;
4927 if (reader->buffer == NULL)
4928 reader->buffer = xmlBufferCreateSize(100);
4929 if (reader->buffer == NULL) {
4934 if (reader->sax == NULL)
4935 reader->sax = (xmlSAXHandler *) xmlMalloc(sizeof(xmlSAXHandler));
4936 if (reader->sax == NULL) {
4941 xmlSAXVersion(reader->sax, 2);
4942 reader->startElement = reader->sax->startElement;
4943 reader->sax->startElement = xmlTextReaderStartElement;
4944 reader->endElement = reader->sax->endElement;
4945 reader->sax->endElement = xmlTextReaderEndElement;
4947 if (reader->sax->initialized == XML_SAX2_MAGIC) {
4949 reader->startElementNs = reader->sax->startElementNs;
4950 reader->sax->startElementNs = xmlTextReaderStartElementNs;
4951 reader->endElementNs = reader->sax->endElementNs;
4952 reader->sax->endElementNs = xmlTextReaderEndElementNs;
4955 reader->startElementNs = NULL;
4956 reader->endElementNs = NULL;
4959 reader->characters = reader->sax->characters;
4960 reader->sax->characters = xmlTextReaderCharacters;
4961 reader->sax->ignorableWhitespace = xmlTextReaderCharacters;
4962 reader->cdataBlock = reader->sax->cdataBlock;
4963 reader->sax->cdataBlock = xmlTextReaderCDataBlock;
4965 reader->mode = XML_TEXTREADER_MODE_INITIAL;
4966 reader->node = NULL;
4967 reader->curnode = NULL;
4969 if (reader->input->buffer->use < 4) {
4972 if (reader->ctxt == NULL) {
4973 if (reader->input->buffer->use >= 4) {
4974 reader->ctxt = xmlCreatePushParserCtxt(reader->sax, NULL,
4975 (const char *) reader->input->buffer->content, 4, URL);
4976 reader->base = 0;
4977 reader->cur = 4;
4979 reader->ctxt =
4980 xmlCreatePushParserCtxt(reader->sax, NULL, NULL, 0, URL);
4981 reader->base = 0;
4982 reader->cur = 0;
4989 xmlCtxtReset(reader->ctxt);
4992 inputStream = xmlNewInputStream(reader->ctxt);
5009 inputPush(reader->ctxt, inputStream);
5010 reader->cur = 0;
5012 if (reader->ctxt == NULL) {
5018 if (reader->dict != NULL) {
5019 if (reader->ctxt->dict != NULL) {
5020 if (reader->dict != reader->ctxt->dict) {
5021 xmlDictFree(reader->dict);
5022 reader->dict = reader->ctxt->dict;
5025 reader->ctxt->dict = reader->dict;
5028 if (reader->ctxt->dict == NULL)
5029 reader->ctxt->dict = xmlDictCreate();
5030 reader->dict = reader->ctxt->dict;
5032 reader->ctxt->_private = reader;
5033 reader->ctxt->linenumbers = 1;
5034 reader->ctxt->dictNames = 1;
5038 reader->ctxt->docdict = 1;
5039 reader->ctxt->parseMode = XML_PARSE_READER;
5042 if (reader->xincctxt != NULL) {
5043 xmlXIncludeFreeContext(reader->xincctxt);
5044 reader->xincctxt = NULL;
5047 reader->xinclude = 1;
5048 reader->xinclude_name = xmlDictLookup(reader->dict, XINCLUDE_NODE, -1);
5051 reader->xinclude = 0;
5052 reader->in_xinclude = 0;
5055 if (reader->patternTab == NULL) {
5056 reader->patternNr = 0;
5057 reader->patternMax = 0;
5059 while (reader->patternNr > 0) {
5060 reader->patternNr--;
5061 if (reader->patternTab[reader->patternNr] != NULL) {
5062 xmlFreePattern(reader->patternTab[reader->patternNr]);
5063 reader->patternTab[reader->patternNr] = NULL;
5069 reader->validate = XML_TEXTREADER_VALIDATE_DTD;
5071 xmlCtxtUseOptions(reader->ctxt, options);
5077 xmlSwitchToEncoding(reader->ctxt, hdlr);
5079 if ((URL != NULL) && (reader->ctxt->input != NULL) &&
5080 (reader->ctxt->input->filename == NULL))
5081 reader->ctxt->input->filename = (char *)
5084 reader->doc = NULL;
5091 * @reader: an XML reader
5094 * by the reader, relative to the start of the current entity.
5096 * for the parser context associated with the reader.
5103 xmlTextReaderByteConsumed(xmlTextReaderPtr reader) {
5104 if ((reader == NULL) || (reader->ctxt == NULL))
5106 return(xmlByteConsumed(reader->ctxt));
5116 * Returns the new reader or NULL in case of error.
5157 * Returns the new reader or NULL in case of error.
5182 * Returns the new reader or NULL in case of error.
5187 xmlTextReaderPtr reader;
5189 reader = xmlNewTextReaderFilename(filename);
5190 if (reader == NULL)
5192 xmlTextReaderSetup(reader, NULL, NULL, encoding, options);
5193 return (reader);
5207 * Returns the new reader or NULL in case of error.
5213 xmlTextReaderPtr reader;
5221 reader = xmlNewTextReader(buf, URL);
5222 if (reader == NULL) {
5226 reader->allocs |= XML_TEXTREADER_INPUT;
5227 xmlTextReaderSetup(reader, NULL, URL, encoding, options);
5228 return (reader);
5241 * reader is closed or reset.
5243 * Returns the new reader or NULL in case of error.
5248 xmlTextReaderPtr reader;
5258 reader = xmlNewTextReader(input, URL);
5259 if (reader == NULL) {
5263 reader->allocs |= XML_TEXTREADER_INPUT;
5264 xmlTextReaderSetup(reader, NULL, URL, encoding, options);
5265 return (reader);
5280 * Returns the new reader or NULL in case of error.
5287 xmlTextReaderPtr reader;
5297 reader = xmlNewTextReader(input, URL);
5298 if (reader == NULL) {
5302 reader->allocs |= XML_TEXTREADER_INPUT;
5303 xmlTextReaderSetup(reader, NULL, URL, encoding, options);
5304 return (reader);
5309 * @reader: an XML reader
5313 * This reuses the existing @reader xmlTextReader.
5318 xmlReaderNewWalker(xmlTextReaderPtr reader, xmlDocPtr doc)
5322 if (reader == NULL)
5325 if (reader->input != NULL) {
5326 xmlFreeParserInputBuffer(reader->input);
5328 if (reader->ctxt != NULL) {
5329 xmlCtxtReset(reader->ctxt);
5332 reader->entNr = 0;
5333 reader->input = NULL;
5334 reader->mode = XML_TEXTREADER_MODE_INITIAL;
5335 reader->node = NULL;
5336 reader->curnode = NULL;
5337 reader->base = 0;
5338 reader->cur = 0;
5339 reader->allocs = XML_TEXTREADER_CTXT;
5340 reader->doc = doc;
5341 reader->state = XML_TEXTREADER_START;
5342 if (reader->dict == NULL) {
5343 if ((reader->ctxt != NULL) && (reader->ctxt->dict != NULL))
5344 reader->dict = reader->ctxt->dict;
5346 reader->dict = xmlDictCreate();
5353 * @reader: an XML reader
5361 * This reuses the existing @reader xmlTextReader.
5366 xmlReaderNewDoc(xmlTextReaderPtr reader, const xmlChar * cur,
5374 if (reader == NULL)
5378 return (xmlReaderNewMemory(reader, (const char *)cur, len,
5384 * @reader: an XML reader
5391 * This reuses the existing @reader xmlTextReader.
5396 xmlReaderNewFile(xmlTextReaderPtr reader, const char *filename,
5403 if (reader == NULL)
5411 return (xmlTextReaderSetup(reader, input, filename, encoding, options));
5416 * @reader: an XML reader
5425 * This reuses the existing @reader xmlTextReader.
5430 xmlReaderNewMemory(xmlTextReaderPtr reader, const char *buffer, int size,
5435 if (reader == NULL)
5445 return (xmlTextReaderSetup(reader, input, URL, encoding, options));
5450 * @reader: an XML reader
5458 * reader is closed or reset.
5460 * This reuses the existing @reader xmlTextReader.
5465 xmlReaderNewFd(xmlTextReaderPtr reader, int fd,
5472 if (reader == NULL)
5479 return (xmlTextReaderSetup(reader, input, URL, encoding, options));
5484 * @reader: an XML reader
5495 * This reuses the existing @reader xmlTextReader.
5500 xmlReaderNewIO(xmlTextReaderPtr reader, xmlInputReadCallback ioread,
5508 if (reader == NULL)
5515 return (xmlTextReaderSetup(reader, input, URL, encoding, options));