Lines Matching +defs:val +defs:reader
61 #define DUMP_READER xmlTextReaderDebug(reader);
170 #define CONSTSTR(str) xmlDictLookup(reader->dict, (str), -1)
171 #define CONSTQSTR(p, str) xmlDictQLookup(reader->dict, (p), (str))
173 static int xmlTextReaderReadTree(xmlTextReaderPtr reader);
174 static int xmlTextReaderNextTree(xmlTextReaderPtr reader);
193 static void xmlTextReaderFreeNode(xmlTextReaderPtr reader, xmlNodePtr cur);
194 static void xmlTextReaderFreeNodeList(xmlTextReaderPtr reader, xmlNodePtr cur);
254 * @reader: the xmlTextReaderPtr used
260 xmlTextReaderFreeProp(xmlTextReaderPtr reader, xmlAttrPtr cur) {
263 dict = reader->ctxt->dict;
277 xmlTextReaderFreeNodeList(reader, cur->children);
280 if ((reader != NULL) && (reader->ctxt != NULL) &&
281 (reader->ctxt->freeAttrsNr < 100)) {
282 cur->next = reader->ctxt->freeAttrs;
283 reader->ctxt->freeAttrs = cur;
284 reader->ctxt->freeAttrsNr++;
292 * @reader: the xmlTextReaderPtr used
298 xmlTextReaderFreePropList(xmlTextReaderPtr reader, xmlAttrPtr cur) {
303 xmlTextReaderFreeProp(reader, cur);
310 * @reader: the xmlTextReaderPtr used
317 xmlTextReaderFreeNodeList(xmlTextReaderPtr reader, xmlNodePtr cur) {
321 dict = reader->ctxt->dict;
340 xmlTextReaderFreeNodeList(reader, cur->children);
351 xmlTextReaderFreePropList(reader, cur->properties);
373 (reader != NULL) && (reader->ctxt != NULL) &&
374 (reader->ctxt->freeElemsNr < 100)) {
375 cur->next = reader->ctxt->freeElems;
376 reader->ctxt->freeElems = cur;
377 reader->ctxt->freeElemsNr++;
388 * @reader: the xmlTextReaderPtr used
395 xmlTextReaderFreeNode(xmlTextReaderPtr reader, xmlNodePtr cur) {
398 dict = reader->ctxt->dict;
408 xmlTextReaderFreeProp(reader, (xmlAttrPtr) cur);
415 xmlTextReaderFreeNodeList(reader, cur->children);
426 xmlTextReaderFreePropList(reader, cur->properties);
449 (reader != NULL) && (reader->ctxt != NULL) &&
450 (reader->ctxt->freeElemsNr < 100)) {
451 cur->next = reader->ctxt->freeElems;
452 reader->ctxt->freeElems = cur;
453 reader->ctxt->freeElemsNr++;
472 * @reader: the xmlTextReaderPtr used
478 xmlTextReaderFreeDoc(xmlTextReaderPtr reader, xmlDocPtr cur) {
508 if (cur->children != NULL) xmlTextReaderFreeNodeList(reader, cur->children);
522 * The reader core parser *
527 xmlTextReaderDebug(xmlTextReaderPtr reader) {
528 if ((reader == NULL) || (reader->ctxt == NULL)) {
533 reader->state, reader->depth);
534 if (reader->node == NULL) {
537 fprintf(stderr, "node %s\n", reader->node->name);
540 reader->base, reader->cur, reader->ctxt->nodeNr);
541 if (reader->input->buffer == NULL) {
546 &reader->input->buffer->content[reader->cur]);
555 * @reader: the xmlTextReaderPtr used
563 xmlTextReaderEntPush(xmlTextReaderPtr reader, xmlNodePtr value)
565 if (reader->entMax <= 0) {
566 reader->entMax = 10;
567 reader->entTab = (xmlNodePtr *) xmlMalloc(reader->entMax *
568 sizeof(reader->entTab[0]));
569 if (reader->entTab == NULL) {
574 if (reader->entNr >= reader->entMax) {
575 reader->entMax *= 2;
576 reader->entTab =
577 (xmlNodePtr *) xmlRealloc(reader->entTab,
578 reader->entMax *
579 sizeof(reader->entTab[0]));
580 if (reader->entTab == NULL) {
585 reader->entTab[reader->entNr] = value;
586 reader->ent = value;
587 return (reader->entNr++);
592 * @reader: the xmlTextReaderPtr used
599 xmlTextReaderEntPop(xmlTextReaderPtr reader)
603 if (reader->entNr <= 0)
605 reader->entNr--;
606 if (reader->entNr > 0)
607 reader->ent = reader->entTab[reader->entNr - 1];
609 reader->ent = NULL;
610 ret = reader->entTab[reader->entNr];
611 reader->entTab[reader->entNr] = NULL;
627 xmlTextReaderPtr reader = ctxt->_private;
632 if ((reader != NULL) && (reader->startElement != NULL)) {
633 reader->startElement(ctx, fullname, atts);
639 if (reader != NULL)
640 reader->state = XML_TEXTREADER_ELEMENT;
653 xmlTextReaderPtr reader = ctxt->_private;
658 if ((reader != NULL) && (reader->endElement != NULL)) {
659 reader->endElement(ctx, fullname);
690 xmlTextReaderPtr reader = ctxt->_private;
695 if ((reader != NULL) && (reader->startElementNs != NULL)) {
696 reader->startElementNs(ctx, localname, prefix, URI, nb_namespaces,
704 if (reader != NULL)
705 reader->state = XML_TEXTREADER_ELEMENT;
724 xmlTextReaderPtr reader = ctxt->_private;
729 if ((reader != NULL) && (reader->endElementNs != NULL)) {
730 reader->endElementNs(ctx, localname, prefix, URI);
747 xmlTextReaderPtr reader = ctxt->_private;
752 if ((reader != NULL) && (reader->characters != NULL)) {
753 reader->characters(ctx, ch, len);
769 xmlTextReaderPtr reader = ctxt->_private;
774 if ((reader != NULL) && (reader->cdataBlock != NULL)) {
775 reader->cdataBlock(ctx, ch, len);
781 * @reader: the xmlTextReaderPtr used
789 xmlTextReaderPushData(xmlTextReaderPtr reader) {
791 int val, s;
794 if ((reader->input == NULL) || (reader->input->buffer == NULL))
797 oldstate = reader->state;
798 reader->state = XML_TEXTREADER_NONE;
799 inbuf = reader->input->buffer;
801 while (reader->state == XML_TEXTREADER_NONE) {
802 if (inbuf->use < reader->cur + CHUNK_SIZE) {
806 if (reader->mode != XML_TEXTREADER_MODE_EOF) {
807 val = xmlParserInputBufferRead(reader->input, 4096);
808 if ((val == 0) &&
810 if (inbuf->use == reader->cur) {
811 reader->mode = XML_TEXTREADER_MODE_EOF;
812 reader->state = oldstate;
814 } else if (val < 0) {
815 reader->mode = XML_TEXTREADER_MODE_EOF;
816 reader->state = oldstate;
818 (reader->ctxt->myDoc != NULL))
819 return(val);
820 } else if (val == 0) {
822 reader->mode = XML_TEXTREADER_MODE_EOF;
833 if (inbuf->use >= reader->cur + CHUNK_SIZE) {
834 val = xmlParseChunk(reader->ctxt,
835 (const char *) &inbuf->content[reader->cur],
837 reader->cur += CHUNK_SIZE;
838 if ((val != 0) || (reader->ctxt->wellFormed == 0))
841 s = inbuf->use - reader->cur;
842 val = xmlParseChunk(reader->ctxt,
843 (const char *) &inbuf->content[reader->cur],
845 reader->cur += s;
846 if ((val != 0) || (reader->ctxt->wellFormed == 0))
855 if (reader->mode == XML_TEXTREADER_MODE_INTERACTIVE) {
857 if ((reader->cur >= 4096) &&
858 (inbuf->use - reader->cur <= CHUNK_SIZE)) {
859 val = xmlBufferShrink(inbuf, reader->cur);
860 if (val >= 0) {
861 reader->cur -= val;
871 else if (reader->mode == XML_TEXTREADER_MODE_EOF) {
872 if (reader->state != XML_TEXTREADER_DONE) {
873 s = inbuf->use - reader->cur;
874 val = xmlParseChunk(reader->ctxt,
875 (const char *) &inbuf->content[reader->cur],
877 reader->cur = inbuf->use;
878 reader->state = XML_TEXTREADER_DONE;
879 if ((val != 0) || (reader->ctxt->wellFormed == 0))
883 reader->state = oldstate;
890 * @reader: the xmlTextReaderPtr used
895 xmlTextReaderValidatePush(xmlTextReaderPtr reader ATTRIBUTE_UNUSED) {
896 xmlNodePtr node = reader->node;
899 if ((reader->validate == XML_TEXTREADER_VALIDATE_DTD) &&
900 (reader->ctxt != NULL) && (reader->ctxt->validate == 1)) {
902 reader->ctxt->valid &= xmlValidatePushElement(&reader->ctxt->vctxt,
903 reader->ctxt->myDoc, node, node->name);
911 reader->ctxt->valid &= xmlValidatePushElement(&reader->ctxt->vctxt,
912 reader->ctxt->myDoc, node, qname);
919 if ((reader->validate == XML_TEXTREADER_VALIDATE_RNG) &&
920 (reader->rngValidCtxt != NULL)) {
923 if (reader->rngFullNode != NULL) return;
924 ret = xmlRelaxNGValidatePushElement(reader->rngValidCtxt,
925 reader->ctxt->myDoc,
931 node = xmlTextReaderExpand(reader);
936 ret = xmlRelaxNGValidateFullElement(reader->rngValidCtxt,
937 reader->ctxt->myDoc,
939 reader->rngFullNode = node;
943 reader->rngValidErrors++;
950 * @reader: the xmlTextReaderPtr used
957 xmlTextReaderValidateCData(xmlTextReaderPtr reader,
960 if ((reader->validate == XML_TEXTREADER_VALIDATE_DTD) &&
961 (reader->ctxt != NULL) && (reader->ctxt->validate == 1)) {
962 reader->ctxt->valid &= xmlValidatePushCData(&reader->ctxt->vctxt,
967 if ((reader->validate == XML_TEXTREADER_VALIDATE_RNG) &&
968 (reader->rngValidCtxt != NULL)) {
971 if (reader->rngFullNode != NULL) return;
972 ret = xmlRelaxNGValidatePushCData(reader->rngValidCtxt, data, len);
974 reader->rngValidErrors++;
981 * @reader: the xmlTextReaderPtr used
986 xmlTextReaderValidatePop(xmlTextReaderPtr reader) {
987 xmlNodePtr node = reader->node;
990 if ((reader->validate == XML_TEXTREADER_VALIDATE_DTD) &&
991 (reader->ctxt != NULL) && (reader->ctxt->validate == 1)) {
993 reader->ctxt->valid &= xmlValidatePopElement(&reader->ctxt->vctxt,
994 reader->ctxt->myDoc, node, node->name);
1002 reader->ctxt->valid &= xmlValidatePopElement(&reader->ctxt->vctxt,
1003 reader->ctxt->myDoc, node, qname);
1010 if ((reader->validate == XML_TEXTREADER_VALIDATE_RNG) &&
1011 (reader->rngValidCtxt != NULL)) {
1014 if (reader->rngFullNode != NULL) {
1015 if (node == reader->rngFullNode)
1016 reader->rngFullNode = NULL;
1019 ret = xmlRelaxNGValidatePopElement(reader->rngValidCtxt,
1020 reader->ctxt->myDoc,
1023 reader->rngValidErrors++;
1030 * @reader: the xmlTextReaderPtr used
1037 xmlTextReaderValidateEntity(xmlTextReaderPtr reader) {
1038 xmlNodePtr oldnode = reader->node;
1039 xmlNodePtr node = reader->node;
1040 xmlParserCtxtPtr ctxt = reader->ctxt;
1057 xmlTextReaderEntPush(reader, node);
1070 reader->node = node;
1071 xmlTextReaderValidatePush(reader);
1074 xmlTextReaderValidateCData(reader, node->content,
1086 xmlTextReaderValidatePop(reader);
1096 if (reader->entNr == 0) {
1100 xmlTextReaderFreeNode(reader, tmp);
1105 reader->node = node;
1106 xmlTextReaderValidatePop(reader);
1109 (reader->ent != NULL) && (reader->ent->children == node)) {
1110 node = xmlTextReaderEntPop(reader);
1120 reader->node = oldnode;
1147 * @reader: the xmlTextReaderPtr used
1157 xmlTextReaderDoExpand(xmlTextReaderPtr reader) {
1158 int val;
1160 if ((reader == NULL) || (reader->node == NULL) || (reader->ctxt == NULL))
1163 if (reader->ctxt->instate == XML_PARSER_EOF) return(1);
1165 if (xmlTextReaderGetSuccessor(reader->node) != NULL)
1167 if (reader->ctxt->nodeNr < reader->depth)
1169 if (reader->mode == XML_TEXTREADER_MODE_EOF)
1171 val = xmlTextReaderPushData(reader);
1172 if (val < 0){
1173 reader->mode = XML_TEXTREADER_MODE_ERROR;
1176 } while(reader->mode != XML_TEXTREADER_MODE_EOF);
1226 * @reader: the xmlTextReaderPtr used
1235 xmlTextReaderRead(xmlTextReaderPtr reader) {
1236 int val, olddepth = 0;
1241 if (reader == NULL)
1243 reader->curnode = NULL;
1244 if (reader->doc != NULL)
1245 return(xmlTextReaderReadTree(reader));
1246 if (reader->ctxt == NULL)
1248 if (reader->ctxt->wellFormed != 1)
1255 if (reader->mode == XML_TEXTREADER_MODE_INITIAL) {
1256 reader->mode = XML_TEXTREADER_MODE_INTERACTIVE;
1261 val = xmlTextReaderPushData(reader);
1262 if (val < 0){
1263 reader->mode = XML_TEXTREADER_MODE_ERROR;
1264 reader->state = XML_TEXTREADER_ERROR;
1267 } while ((reader->ctxt->node == NULL) &&
1268 ((reader->mode != XML_TEXTREADER_MODE_EOF) &&
1269 (reader->state != XML_TEXTREADER_DONE)));
1270 if (reader->ctxt->node == NULL) {
1271 if (reader->ctxt->myDoc != NULL) {
1272 reader->node = reader->ctxt->myDoc->children;
1274 if (reader->node == NULL){
1275 reader->mode = XML_TEXTREADER_MODE_ERROR;
1276 reader->state = XML_TEXTREADER_ERROR;
1279 reader->state = XML_TEXTREADER_ELEMENT;
1281 if (reader->ctxt->myDoc != NULL) {
1282 reader->node = reader->ctxt->myDoc->children;
1284 if (reader->node == NULL)
1285 reader->node = reader->ctxt->nodeTab[0];
1286 reader->state = XML_TEXTREADER_ELEMENT;
1288 reader->depth = 0;
1289 reader->ctxt->parseMode = XML_PARSE_READER;
1292 oldstate = reader->state;
1293 olddepth = reader->ctxt->nodeNr;
1294 oldnode = reader->node;
1297 if (reader->node == NULL) {
1298 if (reader->mode == XML_TEXTREADER_MODE_EOF)
1309 while ((reader->node != NULL) && (reader->node->next == NULL) &&
1310 (reader->ctxt->nodeNr == olddepth) &&
1312 (reader->node->children == NULL) ||
1313 (reader->node->type == XML_ENTITY_REF_NODE) ||
1314 ((reader->node->children != NULL) &&
1315 (reader->node->children->type == XML_TEXT_NODE) &&
1316 (reader->node->children->next == NULL)) ||
1317 (reader->node->type == XML_DTD_NODE) ||
1318 (reader->node->type == XML_DOCUMENT_NODE) ||
1319 (reader->node->type == XML_HTML_DOCUMENT_NODE)) &&
1320 ((reader->ctxt->node == NULL) ||
1321 (reader->ctxt->node == reader->node) ||
1322 (reader->ctxt->node == reader->node->parent)) &&
1323 (reader->ctxt->instate != XML_PARSER_EOF)) {
1324 val = xmlTextReaderPushData(reader);
1325 if (val < 0){
1326 reader->mode = XML_TEXTREADER_MODE_ERROR;
1327 reader->state = XML_TEXTREADER_ERROR;
1330 if (reader->node == NULL)
1334 if ((reader->node->children != NULL) &&
1335 (reader->node->type != XML_ENTITY_REF_NODE) &&
1336 (reader->node->type != XML_XINCLUDE_START) &&
1337 (reader->node->type != XML_DTD_NODE)) {
1338 reader->node = reader->node->children;
1339 reader->depth++;
1340 reader->state = XML_TEXTREADER_ELEMENT;
1344 if (reader->node->next != NULL) {
1346 (reader->node->type == XML_ELEMENT_NODE) &&
1347 (reader->node->children == NULL) &&
1348 ((reader->node->extra & NODE_IS_EMPTY) == 0)
1350 && (reader->in_xinclude <= 0)
1353 reader->state = XML_TEXTREADER_END;
1357 if ((reader->validate) &&
1358 (reader->node->type == XML_ELEMENT_NODE))
1359 xmlTextReaderValidatePop(reader);
1361 if ((reader->preserves > 0) &&
1362 (reader->node->extra & NODE_IS_SPRESERVED))
1363 reader->preserves--;
1364 reader->node = reader->node->next;
1365 reader->state = XML_TEXTREADER_ELEMENT;
1370 if ((reader->preserves == 0) &&
1372 (reader->in_xinclude == 0) &&
1374 (reader->entNr == 0) &&
1375 (reader->node->prev != NULL) &&
1376 (reader->node->prev->type != XML_DTD_NODE) &&
1377 (reader->entNr == 0)) {
1378 xmlNodePtr tmp = reader->node->prev;
1381 xmlTextReaderFreeNode(reader, tmp);
1388 (reader->node->type == XML_ELEMENT_NODE) &&
1389 (reader->node->children == NULL) &&
1390 ((reader->node->extra & NODE_IS_EMPTY) == 0)) {;
1391 reader->state = XML_TEXTREADER_END;
1395 if ((reader->validate) && (reader->node->type == XML_ELEMENT_NODE))
1396 xmlTextReaderValidatePop(reader);
1398 if ((reader->preserves > 0) &&
1399 (reader->node->extra & NODE_IS_SPRESERVED))
1400 reader->preserves--;
1401 reader->node = reader->node->parent;
1402 if ((reader->node == NULL) ||
1403 (reader->node->type == XML_DOCUMENT_NODE) ||
1405 (reader->node->type == XML_DOCB_DOCUMENT_NODE) ||
1407 (reader->node->type == XML_HTML_DOCUMENT_NODE)) {
1408 if (reader->mode != XML_TEXTREADER_MODE_EOF) {
1409 val = xmlParseChunk(reader->ctxt, "", 0, 1);
1410 reader->state = XML_TEXTREADER_DONE;
1411 if (val != 0)
1414 reader->node = NULL;
1415 reader->depth = -1;
1420 if ((reader->preserves == 0) &&
1422 (reader->in_xinclude == 0) &&
1424 (reader->entNr == 0) &&
1427 (reader->entNr == 0)) {
1429 xmlTextReaderFreeNode(reader, oldnode);
1434 if ((reader->preserves == 0) &&
1436 (reader->in_xinclude == 0) &&
1438 (reader->entNr == 0) &&
1439 (reader->node->last != NULL) &&
1440 ((reader->node->last->extra & NODE_IS_PRESERVED) == 0)) {
1441 xmlNodePtr tmp = reader->node->last;
1443 xmlTextReaderFreeNode(reader, tmp);
1445 reader->depth--;
1446 reader->state = XML_TEXTREADER_BACKTRACK;
1454 if ((reader->node != NULL) &&
1455 (reader->node->next == NULL) &&
1456 ((reader->node->type == XML_TEXT_NODE) ||
1457 (reader->node->type == XML_CDATA_SECTION_NODE))) {
1458 if (xmlTextReaderExpand(reader) == NULL)
1466 if ((reader->xinclude) && (reader->node != NULL) &&
1467 (reader->node->type == XML_ELEMENT_NODE) &&
1468 (reader->node->ns != NULL) &&
1469 ((xmlStrEqual(reader->node->ns->href, XINCLUDE_NS)) ||
1470 (xmlStrEqual(reader->node->ns->href, XINCLUDE_OLD_NS)))) {
1471 if (reader->xincctxt == NULL) {
1472 reader->xincctxt = xmlXIncludeNewContext(reader->ctxt->myDoc);
1473 xmlXIncludeSetFlags(reader->xincctxt,
1474 reader->parserFlags & (~XML_PARSE_NOXINCNODE));
1479 if (xmlTextReaderExpand(reader) == NULL)
1481 xmlXIncludeProcessNode(reader->xincctxt, reader->node);
1483 if ((reader->node != NULL) && (reader->node->type == XML_XINCLUDE_START)) {
1484 reader->in_xinclude++;
1487 if ((reader->node != NULL) && (reader->node->type == XML_XINCLUDE_END)) {
1488 reader->in_xinclude--;
1495 if ((reader->node != NULL) &&
1496 (reader->node->type == XML_ENTITY_REF_NODE) &&
1497 (reader->ctxt != NULL) && (reader->ctxt->replaceEntities == 1)) {
1502 if ((reader->node->children == NULL) && (reader->ctxt->sax != NULL) &&
1503 (reader->ctxt->sax->getEntity != NULL)) {
1504 reader->node->children = (xmlNodePtr)
1505 reader->ctxt->sax->getEntity(reader->ctxt, reader->node->name);
1508 if ((reader->node->children != NULL) &&
1509 (reader->node->children->type == XML_ENTITY_DECL) &&
1510 (reader->node->children->children != NULL)) {
1511 xmlTextReaderEntPush(reader, reader->node);
1512 reader->node = reader->node->children->children;
1515 } else if ((reader->node != NULL) &&
1516 (reader->node->type == XML_ENTITY_REF_NODE) &&
1517 (reader->ctxt != NULL) && (reader->validate)) {
1518 xmlTextReaderValidateEntity(reader);
1521 if ((reader->node != NULL) &&
1522 (reader->node->type == XML_ENTITY_DECL) &&
1523 (reader->ent != NULL) && (reader->ent->children == reader->node)) {
1524 reader->node = xmlTextReaderEntPop(reader);
1525 reader->depth++;
1529 if ((reader->validate) && (reader->node != NULL)) {
1530 xmlNodePtr node = reader->node;
1533 ((reader->state != XML_TEXTREADER_END) &&
1534 (reader->state != XML_TEXTREADER_BACKTRACK))) {
1535 xmlTextReaderValidatePush(reader);
1538 xmlTextReaderValidateCData(reader, node->content,
1544 if ((reader->patternNr > 0) && (reader->state != XML_TEXTREADER_END) &&
1545 (reader->state != XML_TEXTREADER_BACKTRACK)) {
1547 for (i = 0;i < reader->patternNr;i++) {
1548 if (xmlPatternMatch(reader->patternTab[i], reader->node) == 1) {
1549 xmlTextReaderPreserve(reader);
1556 if ((reader->validate == XML_TEXTREADER_VALIDATE_XSD) &&
1557 (reader->xsdValidErrors == 0) &&
1558 (reader->xsdValidCtxt != NULL)) {
1559 reader->xsdValidErrors = !xmlSchemaIsValid(reader->xsdValidCtxt);
1564 reader->state = XML_TEXTREADER_DONE;
1570 * @reader: the xmlTextReaderPtr used
1572 * Gets the read state of the reader.
1577 xmlTextReaderReadState(xmlTextReaderPtr reader) {
1578 if (reader == NULL)
1580 return(reader->mode);
1585 * @reader: the xmlTextReaderPtr used
1594 xmlTextReaderExpand(xmlTextReaderPtr reader) {
1595 if ((reader == NULL) || (reader->node == NULL))
1597 if (reader->doc != NULL)
1598 return(reader->node);
1599 if (reader->ctxt == NULL)
1601 if (xmlTextReaderDoExpand(reader) < 0)
1603 return(reader->node);
1608 * @reader: the xmlTextReaderPtr used
1617 xmlTextReaderNext(xmlTextReaderPtr reader) {
1621 if (reader == NULL)
1623 if (reader->doc != NULL)
1624 return(xmlTextReaderNextTree(reader));
1625 cur = reader->node;
1627 return(xmlTextReaderRead(reader));
1628 if (reader->state == XML_TEXTREADER_END || reader->state == XML_TEXTREADER_BACKTRACK)
1629 return(xmlTextReaderRead(reader));
1631 return(xmlTextReaderRead(reader));
1633 ret = xmlTextReaderRead(reader);
1636 } while (reader->node != cur);
1637 return(xmlTextReaderRead(reader));
1643 * @reader: the xmlTextReaderPtr used
1652 xmlTextReaderReadInnerXml(xmlTextReaderPtr reader ATTRIBUTE_UNUSED)
1659 if (xmlTextReaderExpand(reader) == NULL) {
1662 doc = reader->doc;
1664 for (cur_node = reader->node->children; cur_node != NULL;
1689 * @reader: the xmlTextReaderPtr used
1698 xmlTextReaderReadOuterXml(xmlTextReaderPtr reader ATTRIBUTE_UNUSED)
1705 node = reader->node;
1706 doc = reader->doc;
1707 if (xmlTextReaderExpand(reader) == NULL) {
1729 * @reader: the xmlTextReaderPtr used
1734 * or NULL if the reader is positioned on any other type of node.
1738 xmlTextReaderReadString(xmlTextReaderPtr reader)
1742 if ((reader == NULL) || (reader->node == NULL))
1745 node = (reader->curnode != NULL) ? reader->curnode : reader->node;
1752 if (xmlTextReaderDoExpand(reader) != -1) {
1767 * @reader: the xmlTextReaderPtr used
1780 xmlTextReaderReadBase64(xmlTextReaderPtr reader,
1784 if ((reader == NULL) || (reader->ctxt == NULL))
1786 if (reader->ctxt->wellFormed != 1)
1789 if ((reader->node == NULL) || (reader->node->type == XML_ELEMENT_NODE))
1797 * @reader: the xmlTextReaderPtr used
1810 xmlTextReaderReadBinHex(xmlTextReaderPtr reader,
1814 if ((reader == NULL) || (reader->ctxt == NULL))
1816 if (reader->ctxt->wellFormed != 1)
1819 if ((reader->node == NULL) || (reader->node->type == XML_ELEMENT_NODE))
1832 xmlTextReaderNextTree(xmlTextReaderPtr reader)
1834 if (reader == NULL)
1837 if (reader->state == XML_TEXTREADER_END)
1840 if (reader->node == NULL) {
1841 if (reader->doc->children == NULL) {
1842 reader->state = XML_TEXTREADER_END;
1846 reader->node = reader->doc->children;
1847 reader->state = XML_TEXTREADER_START;
1851 if (reader->state != XML_TEXTREADER_BACKTRACK) {
1852 if (reader->node->children != 0) {
1853 reader->node = reader->node->children;
1854 reader->depth++;
1855 reader->state = XML_TEXTREADER_START;
1859 if ((reader->node->type == XML_ELEMENT_NODE) ||
1860 (reader->node->type == XML_ATTRIBUTE_NODE)) {
1861 reader->state = XML_TEXTREADER_BACKTRACK;
1866 if (reader->node->next != 0) {
1867 reader->node = reader->node->next;
1868 reader->state = XML_TEXTREADER_START;
1872 if (reader->node->parent != 0) {
1873 if (reader->node->parent->type == XML_DOCUMENT_NODE) {
1874 reader->state = XML_TEXTREADER_END;
1878 reader->node = reader->node->parent;
1879 reader->depth--;
1880 reader->state = XML_TEXTREADER_BACKTRACK;
1884 reader->state = XML_TEXTREADER_END;
1891 * @reader: the xmlTextReaderPtr used
1900 xmlTextReaderReadTree(xmlTextReaderPtr reader) {
1901 if (reader->state == XML_TEXTREADER_END)
1905 if (reader->node == NULL) {
1906 if (reader->doc->children == NULL) {
1907 reader->state = XML_TEXTREADER_END;
1911 reader->node = reader->doc->children;
1912 reader->state = XML_TEXTREADER_START;
1916 if ((reader->state != XML_TEXTREADER_BACKTRACK) &&
1917 (reader->node->type != XML_DTD_NODE) &&
1918 (reader->node->type != XML_XINCLUDE_START) &&
1919 (reader->node->type != XML_ENTITY_REF_NODE)) {
1920 if (reader->node->children != NULL) {
1921 reader->node = reader->node->children;
1922 reader->depth++;
1923 reader->state = XML_TEXTREADER_START;
1927 if (reader->node->type == XML_ATTRIBUTE_NODE) {
1928 reader->state = XML_TEXTREADER_BACKTRACK;
1933 if (reader->node->next != NULL) {
1934 reader->node = reader->node->next;
1935 reader->state = XML_TEXTREADER_START;
1939 if (reader->node->parent != NULL) {
1940 if ((reader->node->parent->type == XML_DOCUMENT_NODE) ||
1941 (reader->node->parent->type == XML_HTML_DOCUMENT_NODE)) {
1942 reader->state = XML_TEXTREADER_END;
1946 reader->node = reader->node->parent;
1947 reader->depth--;
1948 reader->state = XML_TEXTREADER_BACKTRACK;
1952 reader->state = XML_TEXTREADER_END;
1955 if ((reader->node->type == XML_XINCLUDE_START) ||
1956 (reader->node->type == XML_XINCLUDE_END))
1964 * @reader: the xmlTextReaderPtr used
1974 xmlTextReaderNextSibling(xmlTextReaderPtr reader) {
1975 if (reader == NULL)
1977 if (reader->doc == NULL) {
1982 if (reader->state == XML_TEXTREADER_END)
1985 if (reader->node == NULL)
1986 return(xmlTextReaderNextTree(reader));
1988 if (reader->node->next != NULL) {
1989 reader->node = reader->node->next;
1990 reader->state = XML_TEXTREADER_START;
2147 * @reader: the xmlTextReaderPtr
2149 * Deallocate all the resources associated to the reader
2152 xmlFreeTextReader(xmlTextReaderPtr reader) {
2153 if (reader == NULL)
2156 if (reader->rngSchemas != NULL) {
2157 xmlRelaxNGFree(reader->rngSchemas);
2158 reader->rngSchemas = NULL;
2160 if (reader->rngValidCtxt != NULL) {
2161 xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
2162 reader->rngValidCtxt = NULL;
2164 if (reader->xsdPlug != NULL) {
2165 xmlSchemaSAXUnplug(reader->xsdPlug);
2166 reader->xsdPlug = NULL;
2168 if (reader->xsdValidCtxt != NULL) {
2169 if (! reader->xsdPreserveCtxt)
2170 xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
2171 reader->xsdValidCtxt = NULL;
2173 if (reader->xsdSchemas != NULL) {
2174 xmlSchemaFree(reader->xsdSchemas);
2175 reader->xsdSchemas = NULL;
2179 if (reader->xincctxt != NULL)
2180 xmlXIncludeFreeContext(reader->xincctxt);
2183 if (reader->patternTab != NULL) {
2185 for (i = 0;i < reader->patternNr;i++) {
2186 if (reader->patternTab[i] != NULL)
2187 xmlFreePattern(reader->patternTab[i]);
2189 xmlFree(reader->patternTab);
2192 if (reader->ctxt != NULL) {
2193 if (reader->dict == reader->ctxt->dict)
2194 reader->dict = NULL;
2195 if (reader->ctxt->myDoc != NULL) {
2196 if (reader->preserve == 0)
2197 xmlTextReaderFreeDoc(reader, reader->ctxt->myDoc);
2198 reader->ctxt->myDoc = NULL;
2200 if ((reader->ctxt->vctxt.vstateTab != NULL) &&
2201 (reader->ctxt->vctxt.vstateMax > 0)){
2202 xmlFree(reader->ctxt->vctxt.vstateTab);
2203 reader->ctxt->vctxt.vstateTab = NULL;
2204 reader->ctxt->vctxt.vstateMax = 0;
2206 if (reader->allocs & XML_TEXTREADER_CTXT)
2207 xmlFreeParserCtxt(reader->ctxt);
2209 if (reader->sax != NULL)
2210 xmlFree(reader->sax);
2211 if ((reader->input != NULL) && (reader->allocs & XML_TEXTREADER_INPUT))
2212 xmlFreeParserInputBuffer(reader->input);
2213 if (reader->faketext != NULL) {
2214 xmlFreeNode(reader->faketext);
2216 if (reader->buffer != NULL)
2217 xmlBufferFree(reader->buffer);
2218 if (reader->entTab != NULL)
2219 xmlFree(reader->entTab);
2220 if (reader->dict != NULL)
2221 xmlDictFree(reader->dict);
2222 xmlFree(reader);
2232 * @reader: the xmlTextReaderPtr used
2240 xmlTextReaderClose(xmlTextReaderPtr reader) {
2241 if (reader == NULL)
2243 reader->node = NULL;
2244 reader->curnode = NULL;
2245 reader->mode = XML_TEXTREADER_MODE_CLOSED;
2246 if (reader->ctxt != NULL) {
2247 xmlStopParser(reader->ctxt);
2248 if (reader->ctxt->myDoc != NULL) {
2249 if (reader->preserve == 0)
2250 xmlTextReaderFreeDoc(reader, reader->ctxt->myDoc);
2251 reader->ctxt->myDoc = NULL;
2254 if ((reader->input != NULL) && (reader->allocs & XML_TEXTREADER_INPUT)) {
2255 xmlFreeParserInputBuffer(reader->input);
2256 reader->allocs -= XML_TEXTREADER_INPUT;
2263 * @reader: the xmlTextReaderPtr used
2273 xmlTextReaderGetAttributeNo(xmlTextReaderPtr reader, int no) {
2279 if (reader == NULL)
2281 if (reader->node == NULL)
2283 if (reader->curnode != NULL)
2286 if (reader->node->type != XML_ELEMENT_NODE)
2289 ns = reader->node->nsDef;
2296 cur = reader->node->properties;
2306 ret = xmlNodeListGetString(reader->node->doc, cur->children, 1);
2313 * @reader: the xmlTextReaderPtr used
2322 xmlTextReaderGetAttribute(xmlTextReaderPtr reader, const xmlChar *name) {
2328 if ((reader == NULL) || (name == NULL))
2330 if (reader->node == NULL)
2332 if (reader->curnode != NULL)
2336 if (reader->node->type != XML_ELEMENT_NODE)
2345 ns = reader->node->nsDef;
2354 return(xmlGetNoNsProp(reader->node, name));
2361 ns = reader->node->nsDef;
2370 ns = xmlSearchNs(reader->node->doc, reader->node, prefix);
2372 ret = xmlGetNsProp(reader->node, localname, ns->href);
2384 * @reader: the xmlTextReaderPtr used
2394 xmlTextReaderGetAttributeNs(xmlTextReaderPtr reader, const xmlChar *localName,
2399 if ((reader == NULL) || (localName == NULL))
2401 if (reader->node == NULL)
2403 if (reader->curnode != NULL)
2407 if (reader->node->type != XML_ELEMENT_NODE)
2414 ns = reader->node->nsDef;
2425 return(xmlGetNsProp(reader->node, localName, namespaceURI));
2430 * @reader: the xmlTextReaderPtr used
2437 * what's left in reader->input, and there is an allocation problem. Best
2444 xmlTextReaderGetRemainder(xmlTextReaderPtr reader) {
2447 if (reader == NULL)
2449 if (reader->node == NULL)
2452 reader->node = NULL;
2453 reader->curnode = NULL;
2454 reader->mode = XML_TEXTREADER_MODE_EOF;
2455 if (reader->ctxt != NULL) {
2456 xmlStopParser(reader->ctxt);
2457 if (reader->ctxt->myDoc != NULL) {
2458 if (reader->preserve == 0)
2459 xmlTextReaderFreeDoc(reader, reader->ctxt->myDoc);
2460 reader->ctxt->myDoc = NULL;
2463 if (reader->allocs & XML_TEXTREADER_INPUT) {
2464 ret = reader->input;
2465 reader->input = NULL;
2466 reader->allocs -= XML_TEXTREADER_INPUT;
2482 * @reader: the xmlTextReaderPtr used
2492 xmlTextReaderLookupNamespace(xmlTextReaderPtr reader, const xmlChar *prefix) {
2495 if (reader == NULL)
2497 if (reader->node == NULL)
2500 ns = xmlSearchNs(reader->node->doc, reader->node, prefix);
2508 * @reader: the xmlTextReaderPtr used
2518 xmlTextReaderMoveToAttributeNo(xmlTextReaderPtr reader, int no) {
2523 if (reader == NULL)
2525 if (reader->node == NULL)
2528 if (reader->node->type != XML_ELEMENT_NODE)
2531 reader->curnode = NULL;
2533 ns = reader->node->nsDef;
2538 reader->curnode = (xmlNodePtr) ns;
2542 cur = reader->node->properties;
2552 reader->curnode = (xmlNodePtr) cur;
2558 * @reader: the xmlTextReaderPtr used
2567 xmlTextReaderMoveToAttribute(xmlTextReaderPtr reader, const xmlChar *name) {
2573 if ((reader == NULL) || (name == NULL))
2575 if (reader->node == NULL)
2579 if (reader->node->type != XML_ELEMENT_NODE)
2588 ns = reader->node->nsDef;
2591 reader->curnode = (xmlNodePtr) ns;
2599 prop = reader->node->properties;
2608 reader->curnode = (xmlNodePtr) prop;
2620 ns = reader->node->nsDef;
2623 reader->curnode = (xmlNodePtr) ns;
2630 prop = reader->node->properties;
2639 reader->curnode = (xmlNodePtr) prop;
2661 * @reader: the xmlTextReaderPtr used
2671 xmlTextReaderMoveToAttributeNs(xmlTextReaderPtr reader,
2678 if ((reader == NULL) || (localName == NULL) || (namespaceURI == NULL))
2680 if (reader->node == NULL)
2682 if (reader->node->type != XML_ELEMENT_NODE)
2684 node = reader->node;
2690 ns = reader->node->nsDef;
2694 reader->curnode = (xmlNodePtr) ns;
2712 reader->curnode = (xmlNodePtr) prop;
2722 * @reader: the xmlTextReaderPtr used
2730 xmlTextReaderMoveToFirstAttribute(xmlTextReaderPtr reader) {
2731 if (reader == NULL)
2733 if (reader->node == NULL)
2735 if (reader->node->type != XML_ELEMENT_NODE)
2738 if (reader->node->nsDef != NULL) {
2739 reader->curnode = (xmlNodePtr) reader->node->nsDef;
2742 if (reader->node->properties != NULL) {
2743 reader->curnode = (xmlNodePtr) reader->node->properties;
2751 * @reader: the xmlTextReaderPtr used
2759 xmlTextReaderMoveToNextAttribute(xmlTextReaderPtr reader) {
2760 if (reader == NULL)
2762 if (reader->node == NULL)
2764 if (reader->node->type != XML_ELEMENT_NODE)
2766 if (reader->curnode == NULL)
2767 return(xmlTextReaderMoveToFirstAttribute(reader));
2769 if (reader->curnode->type == XML_NAMESPACE_DECL) {
2770 xmlNsPtr ns = (xmlNsPtr) reader->curnode;
2772 reader->curnode = (xmlNodePtr) ns->next;
2775 if (reader->node->properties != NULL) {
2776 reader->curnode = (xmlNodePtr) reader->node->properties;
2780 } else if ((reader->curnode->type == XML_ATTRIBUTE_NODE) &&
2781 (reader->curnode->next != NULL)) {
2782 reader->curnode = reader->curnode->next;
2790 * @reader: the xmlTextReaderPtr used
2798 xmlTextReaderMoveToElement(xmlTextReaderPtr reader) {
2799 if (reader == NULL)
2801 if (reader->node == NULL)
2803 if (reader->node->type != XML_ELEMENT_NODE)
2805 if (reader->curnode != NULL) {
2806 reader->curnode = NULL;
2814 * @reader: the xmlTextReaderPtr used
2818 * Returns 1 in case of success, 0 if the reader was not positionned on an
2823 xmlTextReaderReadAttributeValue(xmlTextReaderPtr reader) {
2824 if (reader == NULL)
2826 if (reader->node == NULL)
2828 if (reader->curnode == NULL)
2830 if (reader->curnode->type == XML_ATTRIBUTE_NODE) {
2831 if (reader->curnode->children == NULL)
2833 reader->curnode = reader->curnode->children;
2834 } else if (reader->curnode->type == XML_NAMESPACE_DECL) {
2835 xmlNsPtr ns = (xmlNsPtr) reader->curnode;
2837 if (reader->faketext == NULL) {
2838 reader->faketext = xmlNewDocText(reader->node->doc,
2841 if ((reader->faketext->content != NULL) &&
2842 (reader->faketext->content !=
2843 (xmlChar *) &(reader->faketext->properties)))
2844 xmlFree(reader->faketext->content);
2845 reader->faketext->content = xmlStrdup(ns->href);
2847 reader->curnode = reader->faketext;
2849 if (reader->curnode->next == NULL)
2851 reader->curnode = reader->curnode->next;
2858 * @reader: the xmlTextReaderPtr used
2863 * case of error. The string is deallocated with the reader.
2866 xmlTextReaderConstEncoding(xmlTextReaderPtr reader) {
2868 if (reader == NULL)
2870 if (reader->doc != NULL)
2871 doc = reader->doc;
2872 else if (reader->ctxt != NULL)
2873 doc = reader->ctxt->myDoc;
2891 * @reader: the xmlTextReaderPtr used
2898 xmlTextReaderAttributeCount(xmlTextReaderPtr reader) {
2904 if (reader == NULL)
2906 if (reader->node == NULL)
2909 if (reader->curnode != NULL)
2910 node = reader->curnode;
2912 node = reader->node;
2916 if ((reader->state == XML_TEXTREADER_END) ||
2917 (reader->state == XML_TEXTREADER_BACKTRACK))
2935 * @reader: the xmlTextReaderPtr used
2944 xmlTextReaderNodeType(xmlTextReaderPtr reader) {
2947 if (reader == NULL)
2949 if (reader->node == NULL)
2951 if (reader->curnode != NULL)
2952 node = reader->curnode;
2954 node = reader->node;
2957 if ((reader->state == XML_TEXTREADER_END) ||
2958 (reader->state == XML_TEXTREADER_BACKTRACK))
2965 if (xmlIsBlankNode(reader->node)) {
2966 if (xmlNodeGetSpacePreserve(reader->node))
3009 * @reader: the xmlTextReaderPtr used
3016 xmlTextReaderIsEmptyElement(xmlTextReaderPtr reader) {
3017 if ((reader == NULL) || (reader->node == NULL))
3019 if (reader->node->type != XML_ELEMENT_NODE)
3021 if (reader->curnode != NULL)
3023 if (reader->node->children != NULL)
3025 if (reader->state == XML_TEXTREADER_END)
3027 if (reader->doc != NULL)
3030 if (reader->in_xinclude > 0)
3033 return((reader->node->extra & NODE_IS_EMPTY) != 0);
3038 * @reader: the xmlTextReaderPtr used
3045 xmlTextReaderLocalName(xmlTextReaderPtr reader) {
3047 if ((reader == NULL) || (reader->node == NULL))
3049 if (reader->curnode != NULL)
3050 node = reader->curnode;
3052 node = reader->node;
3062 return(xmlTextReaderName(reader));
3068 * @reader: the xmlTextReaderPtr used
3073 * string will be deallocated with the reader.
3076 xmlTextReaderConstLocalName(xmlTextReaderPtr reader) {
3078 if ((reader == NULL) || (reader->node == NULL))
3080 if (reader->curnode != NULL)
3081 node = reader->curnode;
3083 node = reader->node;
3093 return(xmlTextReaderConstName(reader));
3099 * @reader: the xmlTextReaderPtr used
3106 xmlTextReaderName(xmlTextReaderPtr reader) {
3110 if ((reader == NULL) || (reader->node == NULL))
3112 if (reader->curnode != NULL)
3113 node = reader->curnode;
3115 node = reader->node;
3174 * @reader: the xmlTextReaderPtr used
3179 * deallocated with the reader.
3182 xmlTextReaderConstName(xmlTextReaderPtr reader) {
3185 if ((reader == NULL) || (reader->node == NULL))
3187 if (reader->curnode != NULL)
3188 node = reader->curnode;
3190 node = reader->node;
3242 * @reader: the xmlTextReaderPtr used
3249 xmlTextReaderPrefix(xmlTextReaderPtr reader) {
3251 if ((reader == NULL) || (reader->node == NULL))
3253 if (reader->curnode != NULL)
3254 node = reader->curnode;
3256 node = reader->node;
3273 * @reader: the xmlTextReaderPtr used
3278 * with the reader.
3281 xmlTextReaderConstPrefix(xmlTextReaderPtr reader) {
3283 if ((reader == NULL) || (reader->node == NULL))
3285 if (reader->curnode != NULL)
3286 node = reader->curnode;
3288 node = reader->node;
3305 * @reader: the xmlTextReaderPtr used
3312 xmlTextReaderNamespaceUri(xmlTextReaderPtr reader) {
3314 if ((reader == NULL) || (reader->node == NULL))
3316 if (reader->curnode != NULL)
3317 node = reader->curnode;
3319 node = reader->node;
3332 * @reader: the xmlTextReaderPtr used
3337 * will be deallocated with the reader
3340 xmlTextReaderConstNamespaceUri(xmlTextReaderPtr reader) {
3342 if ((reader == NULL) || (reader->node == NULL))
3344 if (reader->curnode != NULL)
3345 node = reader->curnode;
3347 node = reader->node;
3360 * @reader: the xmlTextReaderPtr used
3367 xmlTextReaderBaseUri(xmlTextReaderPtr reader) {
3368 if ((reader == NULL) || (reader->node == NULL))
3370 return(xmlNodeGetBase(NULL, reader->node));
3375 * @reader: the xmlTextReaderPtr used
3380 * will be deallocated with the reader
3383 xmlTextReaderConstBaseUri(xmlTextReaderPtr reader) {
3387 if ((reader == NULL) || (reader->node == NULL))
3389 tmp = xmlNodeGetBase(NULL, reader->node);
3399 * @reader: the xmlTextReaderPtr used
3406 xmlTextReaderDepth(xmlTextReaderPtr reader) {
3407 if (reader == NULL)
3409 if (reader->node == NULL)
3412 if (reader->curnode != NULL) {
3413 if ((reader->curnode->type == XML_ATTRIBUTE_NODE) ||
3414 (reader->curnode->type == XML_NAMESPACE_DECL))
3415 return(reader->depth + 1);
3416 return(reader->depth + 2);
3418 return(reader->depth);
3423 * @reader: the xmlTextReaderPtr used
3430 xmlTextReaderHasAttributes(xmlTextReaderPtr reader) {
3432 if (reader == NULL)
3434 if (reader->node == NULL)
3436 if (reader->curnode != NULL)
3437 node = reader->curnode;
3439 node = reader->node;
3450 * @reader: the xmlTextReaderPtr used
3457 xmlTextReaderHasValue(xmlTextReaderPtr reader) {
3459 if (reader == NULL)
3461 if (reader->node == NULL)
3463 if (reader->curnode != NULL)
3464 node = reader->curnode;
3466 node = reader->node;
3484 * @reader: the xmlTextReaderPtr used
3492 xmlTextReaderValue(xmlTextReaderPtr reader) {
3494 if (reader == NULL)
3496 if (reader->node == NULL)
3498 if (reader->curnode != NULL)
3499 node = reader->curnode;
3501 node = reader->node;
3530 * @reader: the xmlTextReaderPtr used
3538 xmlTextReaderConstValue(xmlTextReaderPtr reader) {
3540 if (reader == NULL)
3542 if (reader->node == NULL)
3544 if (reader->curnode != NULL)
3545 node = reader->curnode;
3547 node = reader->node;
3560 if (reader->buffer == NULL)
3561 reader->buffer = xmlBufferCreateSize(100);
3562 if (reader->buffer == NULL) {
3567 reader->buffer->use = 0;
3568 xmlNodeBufGetContent(reader->buffer, node);
3569 return(reader->buffer->content);
3586 * @reader: the xmlTextReaderPtr used
3594 xmlTextReaderIsDefault(xmlTextReaderPtr reader) {
3595 if (reader == NULL)
3602 * @reader: the xmlTextReaderPtr used
3609 xmlTextReaderQuoteChar(xmlTextReaderPtr reader) {
3610 if (reader == NULL)
3618 * @reader: the xmlTextReaderPtr used
3625 xmlTextReaderXmlLang(xmlTextReaderPtr reader) {
3626 if (reader == NULL)
3628 if (reader->node == NULL)
3630 return(xmlNodeGetLang(reader->node));
3635 * @reader: the xmlTextReaderPtr used
3642 xmlTextReaderConstXmlLang(xmlTextReaderPtr reader) {
3646 if (reader == NULL)
3648 if (reader->node == NULL)
3650 tmp = xmlNodeGetLang(reader->node);
3660 * @reader: the xmlTextReaderPtr used
3663 * Get an interned string from the reader, allows for example to
3667 * string will be deallocated with the reader.
3670 xmlTextReaderConstString(xmlTextReaderPtr reader, const xmlChar *str) {
3671 if (reader == NULL)
3678 * @reader: the xmlTextReaderPtr used
3689 xmlTextReaderNormalization(xmlTextReaderPtr reader) {
3690 if (reader == NULL)
3703 * @reader: the xmlTextReaderPtr used
3714 xmlTextReaderSetParserProp(xmlTextReaderPtr reader, int prop, int value) {
3718 if ((reader == NULL) || (reader->ctxt == NULL))
3720 ctxt = reader->ctxt;
3726 if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
3745 reader->validate = XML_TEXTREADER_VALIDATE_DTD;
3763 * @reader: the xmlTextReaderPtr used
3771 xmlTextReaderGetParserProp(xmlTextReaderPtr reader, int prop) {
3775 if ((reader == NULL) || (reader->ctxt == NULL))
3777 ctxt = reader->ctxt;
3789 return(reader->validate);
3799 * @reader: the user data (XML reader context)
3806 xmlTextReaderGetParserLineNumber(xmlTextReaderPtr reader)
3808 if ((reader == NULL) || (reader->ctxt == NULL) ||
3809 (reader->ctxt->input == NULL)) {
3812 return (reader->ctxt->input->line);
3817 * @reader: the user data (XML reader context)
3824 xmlTextReaderGetParserColumnNumber(xmlTextReaderPtr reader)
3826 if ((reader == NULL) || (reader->ctxt == NULL) ||
3827 (reader->ctxt->input == NULL)) {
3830 return (reader->ctxt->input->col);
3835 * @reader: the xmlTextReaderPtr used
3844 xmlTextReaderCurrentNode(xmlTextReaderPtr reader) {
3845 if (reader == NULL)
3848 if (reader->curnode != NULL)
3849 return(reader->curnode);
3850 return(reader->node);
3855 * @reader: the xmlTextReaderPtr used
3864 xmlTextReaderPreserve(xmlTextReaderPtr reader) {
3867 if (reader == NULL)
3870 if (reader->curnode != NULL)
3871 cur = reader->curnode;
3873 cur = reader->node;
3881 reader->preserves++;
3895 * @reader: the xmlTextReaderPtr used
3906 xmlTextReaderPreservePattern(xmlTextReaderPtr reader, const xmlChar *pattern,
3911 if ((reader == NULL) || (pattern == NULL))
3914 comp = xmlPatterncompile(pattern, reader->dict, 0, namespaces);
3918 if (reader->patternMax <= 0) {
3919 reader->patternMax = 4;
3920 reader->patternTab = (xmlPatternPtr *) xmlMalloc(reader->patternMax *
3921 sizeof(reader->patternTab[0]));
3922 if (reader->patternTab == NULL) {
3927 if (reader->patternNr >= reader->patternMax) {
3929 reader->patternMax *= 2;
3930 tmp = (xmlPatternPtr *) xmlRealloc(reader->patternTab,
3931 reader->patternMax *
3932 sizeof(reader->patternTab[0]));
3935 reader->patternMax /= 2;
3938 reader->patternTab = tmp;
3940 reader->patternTab[reader->patternNr] = comp;
3941 return(reader->patternNr++);
3947 * @reader: the xmlTextReaderPtr used
3951 * NOTE: as a result of this call, the reader will not destroy the
3953 * is needed once the reader parsing has finished.
3958 xmlTextReaderCurrentDoc(xmlTextReaderPtr reader) {
3959 if (reader == NULL)
3961 if (reader->doc != NULL)
3962 return(reader->doc);
3963 if ((reader == NULL) || (reader->ctxt == NULL) ||
3964 (reader->ctxt->myDoc == NULL))
3967 reader->preserve = 1;
3968 return(reader->ctxt->myDoc);
3984 xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx;
3990 if (!reader->errorFunc) {
3993 reader->errorFunc(reader->errorFuncArg, str, XML_PARSER_SEVERITY_VALIDITY_ERROR, NULL /* locator */);
4002 xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx;
4008 if (!reader->errorFunc) {
4011 reader->errorFunc(reader->errorFuncArg, str, XML_PARSER_SEVERITY_VALIDITY_WARNING, NULL /* locator */);
4023 xmlTextReaderPtr reader = (xmlTextReaderPtr) userData;
4025 if (reader->sErrorFunc) {
4026 reader->sErrorFunc(reader->errorFuncArg, error);
4028 xmlTextReaderStructuredError(reader, error);
4034 * @reader: the xmlTextReaderPtr used
4040 @ The @schema should not be freed until the reader is deallocated
4047 xmlTextReaderRelaxNGSetSchema(xmlTextReaderPtr reader, xmlRelaxNGPtr schema) {
4048 if (reader == NULL)
4051 if (reader->rngSchemas != NULL) {
4052 xmlRelaxNGFree(reader->rngSchemas);
4053 reader->rngSchemas = NULL;
4055 if (reader->rngValidCtxt != NULL) {
4056 xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
4057 reader->rngValidCtxt = NULL;
4061 if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
4063 if (reader->rngSchemas != NULL) {
4064 xmlRelaxNGFree(reader->rngSchemas);
4065 reader->rngSchemas = NULL;
4067 if (reader->rngValidCtxt != NULL) {
4068 xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
4069 reader->rngValidCtxt = NULL;
4071 reader->rngValidCtxt = xmlRelaxNGNewValidCtxt(schema);
4072 if (reader->rngValidCtxt == NULL)
4074 if (reader->errorFunc != NULL) {
4075 xmlRelaxNGSetValidErrors(reader->rngValidCtxt,
4078 reader);
4080 if (reader->sErrorFunc != NULL) {
4081 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
4083 reader);
4085 reader->rngValidErrors = 0;
4086 reader->rngFullNode = NULL;
4087 reader->validate = XML_TEXTREADER_VALIDATE_RNG;
4093 * @reader: the xmlTextReaderPtr used
4099 @ The @schema should not be freed until the reader is deallocated
4106 xmlTextReaderSetSchema(xmlTextReaderPtr reader, xmlSchemaPtr schema) {
4107 if (reader == NULL)
4110 if (reader->xsdPlug != NULL) {
4111 xmlSchemaSAXUnplug(reader->xsdPlug);
4112 reader->xsdPlug = NULL;
4114 if (reader->xsdValidCtxt != NULL) {
4115 if (! reader->xsdPreserveCtxt)
4116 xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
4117 reader->xsdValidCtxt = NULL;
4119 reader->xsdPreserveCtxt = 0;
4120 if (reader->xsdSchemas != NULL) {
4121 xmlSchemaFree(reader->xsdSchemas);
4122 reader->xsdSchemas = NULL;
4126 if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
4128 if (reader->xsdPlug != NULL) {
4129 xmlSchemaSAXUnplug(reader->xsdPlug);
4130 reader->xsdPlug = NULL;
4132 if (reader->xsdValidCtxt != NULL) {
4133 if (! reader->xsdPreserveCtxt)
4134 xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
4135 reader->xsdValidCtxt = NULL;
4137 reader->xsdPreserveCtxt = 0;
4138 if (reader->xsdSchemas != NULL) {
4139 xmlSchemaFree(reader->xsdSchemas);
4140 reader->xsdSchemas = NULL;
4142 reader->xsdValidCtxt = xmlSchemaNewValidCtxt(schema);
4143 if (reader->xsdValidCtxt == NULL) {
4144 xmlSchemaFree(reader->xsdSchemas);
4145 reader->xsdSchemas = NULL;
4148 reader->xsdPlug = xmlSchemaSAXPlug(reader->xsdValidCtxt,
4149 &(reader->ctxt->sax),
4150 &(reader->ctxt->userData));
4151 if (reader->xsdPlug == NULL) {
4152 xmlSchemaFree(reader->xsdSchemas);
4153 reader->xsdSchemas = NULL;
4154 xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
4155 reader->xsdValidCtxt = NULL;
4158 if (reader->errorFunc != NULL) {
4159 xmlSchemaSetValidErrors(reader->xsdValidCtxt,
4162 reader);
4164 if (reader->sErrorFunc != NULL) {
4165 xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt,
4167 reader);
4169 reader->xsdValidErrors = 0;
4170 reader->validate = XML_TEXTREADER_VALIDATE_XSD;
4176 * @reader: the xmlTextReaderPtr used
4187 xmlTextReaderRelaxNGValidate(xmlTextReaderPtr reader, const char *rng) {
4190 if (reader == NULL)
4194 if (reader->rngValidCtxt != NULL) {
4195 xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
4196 reader->rngValidCtxt = NULL;
4198 if (reader->rngSchemas != NULL) {
4199 xmlRelaxNGFree(reader->rngSchemas);
4200 reader->rngSchemas = NULL;
4204 if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
4206 if (reader->rngSchemas != NULL) {
4207 xmlRelaxNGFree(reader->rngSchemas);
4208 reader->rngSchemas = NULL;
4210 if (reader->rngValidCtxt != NULL) {
4211 xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
4212 reader->rngValidCtxt = NULL;
4215 if (reader->errorFunc != NULL) {
4219 reader);
4221 if (reader->sErrorFunc != NULL) {
4222 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
4224 reader);
4226 reader->rngSchemas = xmlRelaxNGParse(ctxt);
4228 if (reader->rngSchemas == NULL)
4230 reader->rngValidCtxt = xmlRelaxNGNewValidCtxt(reader->rngSchemas);
4231 if (reader->rngValidCtxt == NULL) {
4232 xmlRelaxNGFree(reader->rngSchemas);
4233 reader->rngSchemas = NULL;
4236 if (reader->errorFunc != NULL) {
4237 xmlRelaxNGSetValidErrors(reader->rngValidCtxt,
4240 reader);
4242 if (reader->sErrorFunc != NULL) {
4243 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
4245 reader);
4247 reader->rngValidErrors = 0;
4248 reader->rngFullNode = NULL;
4249 reader->validate = XML_TEXTREADER_VALIDATE_RNG;
4255 * @reader: the xmlTextReaderPtr used
4268 xmlTextReaderSchemaValidateInternal(xmlTextReaderPtr reader,
4273 if (reader == NULL)
4280 ((reader->mode != XML_TEXTREADER_MODE_INITIAL) ||
4281 (reader->ctxt == NULL)))
4285 if (reader->xsdPlug != NULL) {
4286 xmlSchemaSAXUnplug(reader->xsdPlug);
4287 reader->xsdPlug = NULL;
4289 if (reader->xsdValidCtxt != NULL) {
4290 if (! reader->xsdPreserveCtxt)
4291 xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
4292 reader->xsdValidCtxt = NULL;
4294 reader->xsdPreserveCtxt = 0;
4295 if (reader->xsdSchemas != NULL) {
4296 xmlSchemaFree(reader->xsdSchemas);
4297 reader->xsdSchemas = NULL;
4309 if (reader->errorFunc != NULL) {
4313 reader);
4315 reader->xsdSchemas = xmlSchemaParse(pctxt);
4317 if (reader->xsdSchemas == NULL)
4319 reader->xsdValidCtxt = xmlSchemaNewValidCtxt(reader->xsdSchemas);
4320 if (reader->xsdValidCtxt == NULL) {
4321 xmlSchemaFree(reader->xsdSchemas);
4322 reader->xsdSchemas = NULL;
4325 reader->xsdPlug = xmlSchemaSAXPlug(reader->xsdValidCtxt,
4326 &(reader->ctxt->sax),
4327 &(reader->ctxt->userData));
4328 if (reader->xsdPlug == NULL) {
4329 xmlSchemaFree(reader->xsdSchemas);
4330 reader->xsdSchemas = NULL;
4331 xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
4332 reader->xsdValidCtxt = NULL;
4337 reader->xsdValidCtxt = ctxt;
4338 reader->xsdPreserveCtxt = 1;
4339 reader->xsdPlug = xmlSchemaSAXPlug(reader->xsdValidCtxt,
4340 &(reader->ctxt->sax),
4341 &(reader->ctxt->userData));
4342 if (reader->xsdPlug == NULL) {
4343 reader->xsdValidCtxt = NULL;
4344 reader->xsdPreserveCtxt = 0;
4350 * the reader channels.
4354 if (reader->errorFunc != NULL) {
4355 xmlSchemaSetValidErrors(reader->xsdValidCtxt,
4358 reader);
4360 if (reader->sErrorFunc != NULL) {
4361 xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt,
4363 reader);
4365 reader->xsdValidErrors = 0;
4366 reader->validate = XML_TEXTREADER_VALIDATE_XSD;
4372 * @reader: the xmlTextReaderPtr used
4384 xmlTextReaderSchemaValidateCtxt(xmlTextReaderPtr reader,
4388 return(xmlTextReaderSchemaValidateInternal(reader, NULL, ctxt, options));
4393 * @reader: the xmlTextReaderPtr used
4404 xmlTextReaderSchemaValidate(xmlTextReaderPtr reader, const char *xsd)
4406 return(xmlTextReaderSchemaValidateInternal(reader, xsd, NULL, 0));
4412 * @reader: the xmlTextReaderPtr used
4422 xmlTextReaderIsNamespaceDecl(xmlTextReaderPtr reader) {
4424 if (reader == NULL)
4426 if (reader->node == NULL)
4428 if (reader->curnode != NULL)
4429 node = reader->curnode;
4431 node = reader->node;
4441 * @reader: the xmlTextReaderPtr used
4446 * in case of error. The string is deallocated with the reader.
4449 xmlTextReaderConstXmlVersion(xmlTextReaderPtr reader) {
4451 if (reader == NULL)
4453 if (reader->doc != NULL)
4454 doc = reader->doc;
4455 else if (reader->ctxt != NULL)
4456 doc = reader->ctxt->myDoc;
4468 * @reader: the xmlTextReaderPtr used
4477 xmlTextReaderStandalone(xmlTextReaderPtr reader) {
4479 if (reader == NULL)
4481 if (reader->doc != NULL)
4482 doc = reader->doc;
4483 else if (reader->ctxt != NULL)
4484 doc = reader->ctxt->myDoc;
4607 xmlTextReaderPtr reader = (xmlTextReaderPtr)ctx->_private;
4610 if (reader->errorFunc)
4611 reader->errorFunc(reader->errorFuncArg,
4622 xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx->_private;
4624 if (error && reader->sErrorFunc) {
4625 reader->sErrorFunc(reader->errorFuncArg,
4691 * @reader: the xmlTextReaderPtr used
4700 xmlTextReaderSetErrorHandler(xmlTextReaderPtr reader,
4704 reader->ctxt->sax->error = xmlTextReaderError;
4705 reader->ctxt->sax->serror = NULL;
4706 reader->ctxt->vctxt.error = xmlTextReaderValidityError;
4707 reader->ctxt->sax->warning = xmlTextReaderWarning;
4708 reader->ctxt->vctxt.warning = xmlTextReaderValidityWarning;
4709 reader->errorFunc = f;
4710 reader->sErrorFunc = NULL;
4711 reader->errorFuncArg = arg;
4713 if (reader->rngValidCtxt) {
4714 xmlRelaxNGSetValidErrors(reader->rngValidCtxt,
4717 reader);
4718 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt, NULL, reader);
4720 if (reader->xsdValidCtxt) {
4721 xmlSchemaSetValidErrors(reader->xsdValidCtxt,
4724 reader);
4725 xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt, NULL, reader);
4731 reader->ctxt->sax->error = xmlParserError;
4732 reader->ctxt->vctxt.error = xmlParserValidityError;
4733 reader->ctxt->sax->warning = xmlParserWarning;
4734 reader->ctxt->vctxt.warning = xmlParserValidityWarning;
4735 reader->errorFunc = NULL;
4736 reader->sErrorFunc = NULL;
4737 reader->errorFuncArg = NULL;
4739 if (reader->rngValidCtxt) {
4740 xmlRelaxNGSetValidErrors(reader->rngValidCtxt, NULL, NULL, reader);
4741 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt, NULL, reader);
4743 if (reader->xsdValidCtxt) {
4744 xmlSchemaSetValidErrors(reader->xsdValidCtxt, NULL, NULL, reader);
4745 xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt, NULL, reader);
4753 * @reader: the xmlTextReaderPtr used
4762 xmlTextReaderSetStructuredErrorHandler(xmlTextReaderPtr reader,
4766 reader->ctxt->sax->error = NULL;
4767 reader->ctxt->sax->serror = xmlTextReaderStructuredError;
4768 reader->ctxt->vctxt.error = xmlTextReaderValidityError;
4769 reader->ctxt->sax->warning = xmlTextReaderWarning;
4770 reader->ctxt->vctxt.warning = xmlTextReaderValidityWarning;
4771 reader->sErrorFunc = f;
4772 reader->errorFunc = NULL;
4773 reader->errorFuncArg = arg;
4775 if (reader->rngValidCtxt) {
4776 xmlRelaxNGSetValidErrors(reader->rngValidCtxt, NULL, NULL, reader);
4777 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
4779 reader);
4781 if (reader->xsdValidCtxt) {
4782 xmlSchemaSetValidErrors(reader->xsdValidCtxt, NULL, NULL, reader);
4783 xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt,
4785 reader);
4791 reader->ctxt->sax->error = xmlParserError;
4792 reader->ctxt->sax->serror = NULL;
4793 reader->ctxt->vctxt.error = xmlParserValidityError;
4794 reader->ctxt->sax->warning = xmlParserWarning;
4795 reader->ctxt->vctxt.warning = xmlParserValidityWarning;
4796 reader->errorFunc = NULL;
4797 reader->sErrorFunc = NULL;
4798 reader->errorFuncArg = NULL;
4800 if (reader->rngValidCtxt) {
4801 xmlRelaxNGSetValidErrors(reader->rngValidCtxt, NULL, NULL, reader);
4802 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt, NULL, reader);
4804 if (reader->xsdValidCtxt) {
4805 xmlSchemaSetValidErrors(reader->xsdValidCtxt, NULL, NULL, reader);
4806 xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt, NULL, reader);
4814 * @reader: the xmlTextReaderPtr used
4821 xmlTextReaderIsValid(xmlTextReaderPtr reader) {
4822 if (reader == NULL) return(-1);
4824 if (reader->validate == XML_TEXTREADER_VALIDATE_RNG)
4825 return(reader->rngValidErrors == 0);
4826 if (reader->validate == XML_TEXTREADER_VALIDATE_XSD)
4827 return(reader->xsdValidErrors == 0);
4829 if ((reader->ctxt != NULL) && (reader->ctxt->validate == 1))
4830 return(reader->ctxt->valid);
4836 * @reader: the xmlTextReaderPtr used
4843 xmlTextReaderGetErrorHandler(xmlTextReaderPtr reader,
4846 if (f != NULL) *f = reader->errorFunc;
4847 if (arg != NULL) *arg = reader->errorFuncArg;
4859 * @reader: an XML reader
4860 * @input: xmlParserInputBufferPtr used to feed the reader, will
4866 * Setup an XML reader with new options
4871 xmlTextReaderSetup(xmlTextReaderPtr reader,
4875 if (reader == NULL) {
4882 * we force the generation of compact text nodes on the reader
4887 reader->doc = NULL;
4888 reader->entNr = 0;
4889 reader->parserFlags = options;
4890 reader->validate = XML_TEXTREADER_NOT_VALIDATE;
4891 if ((input != NULL) && (reader->input != NULL) &&
4892 (reader->allocs & XML_TEXTREADER_INPUT)) {
4893 xmlFreeParserInputBuffer(reader->input);
4894 reader->input = NULL;
4895 reader->allocs -= XML_TEXTREADER_INPUT;
4898 reader->input = input;
4899 reader->allocs |= XML_TEXTREADER_INPUT;
4901 if (reader->buffer == NULL)
4902 reader->buffer = xmlBufferCreateSize(100);
4903 if (reader->buffer == NULL) {
4908 if (reader->sax == NULL)
4909 reader->sax = (xmlSAXHandler *) xmlMalloc(sizeof(xmlSAXHandler));
4910 if (reader->sax == NULL) {
4915 xmlSAXVersion(reader->sax, 2);
4916 reader->startElement = reader->sax->startElement;
4917 reader->sax->startElement = xmlTextReaderStartElement;
4918 reader->endElement = reader->sax->endElement;
4919 reader->sax->endElement = xmlTextReaderEndElement;
4921 if (reader->sax->initialized == XML_SAX2_MAGIC) {
4923 reader->startElementNs = reader->sax->startElementNs;
4924 reader->sax->startElementNs = xmlTextReaderStartElementNs;
4925 reader->endElementNs = reader->sax->endElementNs;
4926 reader->sax->endElementNs = xmlTextReaderEndElementNs;
4929 reader->startElementNs = NULL;
4930 reader->endElementNs = NULL;
4933 reader->characters = reader->sax->characters;
4934 reader->sax->characters = xmlTextReaderCharacters;
4935 reader->sax->ignorableWhitespace = xmlTextReaderCharacters;
4936 reader->cdataBlock = reader->sax->cdataBlock;
4937 reader->sax->cdataBlock = xmlTextReaderCDataBlock;
4939 reader->mode = XML_TEXTREADER_MODE_INITIAL;
4940 reader->node = NULL;
4941 reader->curnode = NULL;
4943 if (reader->input->buffer->use < 4) {
4946 if (reader->ctxt == NULL) {
4947 if (reader->input->buffer->use >= 4) {
4948 reader->ctxt = xmlCreatePushParserCtxt(reader->sax, NULL,
4949 (const char *) reader->input->buffer->content, 4, URL);
4950 reader->base = 0;
4951 reader->cur = 4;
4953 reader->ctxt =
4954 xmlCreatePushParserCtxt(reader->sax, NULL, NULL, 0, URL);
4955 reader->base = 0;
4956 reader->cur = 0;
4963 xmlCtxtReset(reader->ctxt);
4966 inputStream = xmlNewInputStream(reader->ctxt);
4983 inputPush(reader->ctxt, inputStream);
4984 reader->cur = 0;
4986 if (reader->ctxt == NULL) {
4992 if (reader->dict != NULL) {
4993 if (reader->ctxt->dict != NULL) {
4994 if (reader->dict != reader->ctxt->dict) {
4995 xmlDictFree(reader->dict);
4996 reader->dict = reader->ctxt->dict;
4999 reader->ctxt->dict = reader->dict;
5002 if (reader->ctxt->dict == NULL)
5003 reader->ctxt->dict = xmlDictCreate();
5004 reader->dict = reader->ctxt->dict;
5006 reader->ctxt->_private = reader;
5007 reader->ctxt->linenumbers = 1;
5008 reader->ctxt->dictNames = 1;
5012 reader->ctxt->docdict = 1;
5013 reader->ctxt->parseMode = XML_PARSE_READER;
5016 if (reader->xincctxt != NULL) {
5017 xmlXIncludeFreeContext(reader->xincctxt);
5018 reader->xincctxt = NULL;
5021 reader->xinclude = 1;
5022 reader->xinclude_name = xmlDictLookup(reader->dict, XINCLUDE_NODE, -1);
5025 reader->xinclude = 0;
5026 reader->in_xinclude = 0;
5029 if (reader->patternTab == NULL) {
5030 reader->patternNr = 0;
5031 reader->patternMax = 0;
5033 while (reader->patternNr > 0) {
5034 reader->patternNr--;
5035 if (reader->patternTab[reader->patternNr] != NULL) {
5036 xmlFreePattern(reader->patternTab[reader->patternNr]);
5037 reader->patternTab[reader->patternNr] = NULL;
5043 reader->validate = XML_TEXTREADER_VALIDATE_DTD;
5045 xmlCtxtUseOptions(reader->ctxt, options);
5051 xmlSwitchToEncoding(reader->ctxt, hdlr);
5053 if ((URL != NULL) && (reader->ctxt->input != NULL) &&
5054 (reader->ctxt->input->filename == NULL))
5055 reader->ctxt->input->filename = (char *)
5058 reader->doc = NULL;
5065 * @reader: an XML reader
5068 * by the reader, relative to the start of the current entity.
5070 * for the parser context associated with the reader.
5077 xmlTextReaderByteConsumed(xmlTextReaderPtr reader) {
5078 if ((reader == NULL) || (reader->ctxt == NULL))
5080 return(xmlByteConsumed(reader->ctxt));
5090 * Returns the new reader or NULL in case of error.
5131 * Returns the new reader or NULL in case of error.
5156 * Returns the new reader or NULL in case of error.
5161 xmlTextReaderPtr reader;
5163 reader = xmlNewTextReaderFilename(filename);
5164 if (reader == NULL)
5166 xmlTextReaderSetup(reader, NULL, NULL, encoding, options);
5167 return (reader);
5181 * Returns the new reader or NULL in case of error.
5187 xmlTextReaderPtr reader;
5195 reader = xmlNewTextReader(buf, URL);
5196 if (reader == NULL) {
5200 reader->allocs |= XML_TEXTREADER_INPUT;
5201 xmlTextReaderSetup(reader, NULL, URL, encoding, options);
5202 return (reader);
5215 * reader is closed or reset.
5217 * Returns the new reader or NULL in case of error.
5222 xmlTextReaderPtr reader;
5232 reader = xmlNewTextReader(input, URL);
5233 if (reader == NULL) {
5237 reader->allocs |= XML_TEXTREADER_INPUT;
5238 xmlTextReaderSetup(reader, NULL, URL, encoding, options);
5239 return (reader);
5254 * Returns the new reader or NULL in case of error.
5261 xmlTextReaderPtr reader;
5271 reader = xmlNewTextReader(input, URL);
5272 if (reader == NULL) {
5276 reader->allocs |= XML_TEXTREADER_INPUT;
5277 xmlTextReaderSetup(reader, NULL, URL, encoding, options);
5278 return (reader);
5283 * @reader: an XML reader
5287 * This reuses the existing @reader xmlTextReader.
5292 xmlReaderNewWalker(xmlTextReaderPtr reader, xmlDocPtr doc)
5296 if (reader == NULL)
5299 if (reader->input != NULL) {
5300 xmlFreeParserInputBuffer(reader->input);
5302 if (reader->ctxt != NULL) {
5303 xmlCtxtReset(reader->ctxt);
5306 reader->entNr = 0;
5307 reader->input = NULL;
5308 reader->mode = XML_TEXTREADER_MODE_INITIAL;
5309 reader->node = NULL;
5310 reader->curnode = NULL;
5311 reader->base = 0;
5312 reader->cur = 0;
5313 reader->allocs = XML_TEXTREADER_CTXT;
5314 reader->doc = doc;
5315 reader->state = XML_TEXTREADER_START;
5316 if (reader->dict == NULL) {
5317 if ((reader->ctxt != NULL) && (reader->ctxt->dict != NULL))
5318 reader->dict = reader->ctxt->dict;
5320 reader->dict = xmlDictCreate();
5327 * @reader: an XML reader
5335 * This reuses the existing @reader xmlTextReader.
5340 xmlReaderNewDoc(xmlTextReaderPtr reader, const xmlChar * cur,
5348 if (reader == NULL)
5352 return (xmlReaderNewMemory(reader, (const char *)cur, len,
5358 * @reader: an XML reader
5365 * This reuses the existing @reader xmlTextReader.
5370 xmlReaderNewFile(xmlTextReaderPtr reader, const char *filename,
5377 if (reader == NULL)
5385 return (xmlTextReaderSetup(reader, input, filename, encoding, options));
5390 * @reader: an XML reader
5399 * This reuses the existing @reader xmlTextReader.
5404 xmlReaderNewMemory(xmlTextReaderPtr reader, const char *buffer, int size,
5409 if (reader == NULL)
5419 return (xmlTextReaderSetup(reader, input, URL, encoding, options));
5424 * @reader: an XML reader
5432 * reader is closed or reset.
5434 * This reuses the existing @reader xmlTextReader.
5439 xmlReaderNewFd(xmlTextReaderPtr reader, int fd,
5446 if (reader == NULL)
5453 return (xmlTextReaderSetup(reader, input, URL, encoding, options));
5458 * @reader: an XML reader
5469 * This reuses the existing @reader xmlTextReader.
5474 xmlReaderNewIO(xmlTextReaderPtr reader, xmlInputReadCallback ioread,
5482 if (reader == NULL)
5489 return (xmlTextReaderSetup(reader, input, URL, encoding, options));