/Modules/expat/xmlparse.c

http://unladen-swallow.googlecode.com/ · C · 6268 lines · 5616 code · 340 blank · 312 comment · 1247 complexity · 26b29043af5e2a1b99cb05d74184f45b MD5 · raw file

Large files are truncated click here to view the full file

  1. /* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
  2. See the file COPYING for copying permission.
  3. */
  4. #define XML_BUILDING_EXPAT 1
  5. #ifdef COMPILED_FROM_DSP
  6. #include "winconfig.h"
  7. #elif defined(MACOS_CLASSIC)
  8. #include "macconfig.h"
  9. #elif defined(__amigaos4__)
  10. #include "amigaconfig.h"
  11. #elif defined(HAVE_EXPAT_CONFIG_H)
  12. #include <expat_config.h>
  13. #endif /* ndef COMPILED_FROM_DSP */
  14. #include <stddef.h>
  15. #include <string.h> /* memset(), memcpy() */
  16. #include <assert.h>
  17. #include "expat.h"
  18. #ifdef XML_UNICODE
  19. #define XML_ENCODE_MAX XML_UTF16_ENCODE_MAX
  20. #define XmlConvert XmlUtf16Convert
  21. #define XmlGetInternalEncoding XmlGetUtf16InternalEncoding
  22. #define XmlGetInternalEncodingNS XmlGetUtf16InternalEncodingNS
  23. #define XmlEncode XmlUtf16Encode
  24. #define MUST_CONVERT(enc, s) (!(enc)->isUtf16 || (((unsigned long)s) & 1))
  25. typedef unsigned short ICHAR;
  26. #else
  27. #define XML_ENCODE_MAX XML_UTF8_ENCODE_MAX
  28. #define XmlConvert XmlUtf8Convert
  29. #define XmlGetInternalEncoding XmlGetUtf8InternalEncoding
  30. #define XmlGetInternalEncodingNS XmlGetUtf8InternalEncodingNS
  31. #define XmlEncode XmlUtf8Encode
  32. #define MUST_CONVERT(enc, s) (!(enc)->isUtf8)
  33. typedef char ICHAR;
  34. #endif
  35. #ifndef XML_NS
  36. #define XmlInitEncodingNS XmlInitEncoding
  37. #define XmlInitUnknownEncodingNS XmlInitUnknownEncoding
  38. #undef XmlGetInternalEncodingNS
  39. #define XmlGetInternalEncodingNS XmlGetInternalEncoding
  40. #define XmlParseXmlDeclNS XmlParseXmlDecl
  41. #endif
  42. #ifdef XML_UNICODE
  43. #ifdef XML_UNICODE_WCHAR_T
  44. #define XML_T(x) (const wchar_t)x
  45. #define XML_L(x) L ## x
  46. #else
  47. #define XML_T(x) (const unsigned short)x
  48. #define XML_L(x) x
  49. #endif
  50. #else
  51. #define XML_T(x) x
  52. #define XML_L(x) x
  53. #endif
  54. /* Round up n to be a multiple of sz, where sz is a power of 2. */
  55. #define ROUND_UP(n, sz) (((n) + ((sz) - 1)) & ~((sz) - 1))
  56. /* Handle the case where memmove() doesn't exist. */
  57. #ifndef HAVE_MEMMOVE
  58. #ifdef HAVE_BCOPY
  59. #define memmove(d,s,l) bcopy((s),(d),(l))
  60. #else
  61. #error memmove does not exist on this platform, nor is a substitute available
  62. #endif /* HAVE_BCOPY */
  63. #endif /* HAVE_MEMMOVE */
  64. #include "internal.h"
  65. #include "xmltok.h"
  66. #include "xmlrole.h"
  67. typedef const XML_Char *KEY;
  68. typedef struct {
  69. KEY name;
  70. } NAMED;
  71. typedef struct {
  72. NAMED **v;
  73. unsigned char power;
  74. size_t size;
  75. size_t used;
  76. const XML_Memory_Handling_Suite *mem;
  77. } HASH_TABLE;
  78. /* Basic character hash algorithm, taken from Python's string hash:
  79. h = h * 1000003 ^ character, the constant being a prime number.
  80. */
  81. #ifdef XML_UNICODE
  82. #define CHAR_HASH(h, c) \
  83. (((h) * 0xF4243) ^ (unsigned short)(c))
  84. #else
  85. #define CHAR_HASH(h, c) \
  86. (((h) * 0xF4243) ^ (unsigned char)(c))
  87. #endif
  88. /* For probing (after a collision) we need a step size relative prime
  89. to the hash table size, which is a power of 2. We use double-hashing,
  90. since we can calculate a second hash value cheaply by taking those bits
  91. of the first hash value that were discarded (masked out) when the table
  92. index was calculated: index = hash & mask, where mask = table->size - 1.
  93. We limit the maximum step size to table->size / 4 (mask >> 2) and make
  94. it odd, since odd numbers are always relative prime to a power of 2.
  95. */
  96. #define SECOND_HASH(hash, mask, power) \
  97. ((((hash) & ~(mask)) >> ((power) - 1)) & ((mask) >> 2))
  98. #define PROBE_STEP(hash, mask, power) \
  99. ((unsigned char)((SECOND_HASH(hash, mask, power)) | 1))
  100. typedef struct {
  101. NAMED **p;
  102. NAMED **end;
  103. } HASH_TABLE_ITER;
  104. #define INIT_TAG_BUF_SIZE 32 /* must be a multiple of sizeof(XML_Char) */
  105. #define INIT_DATA_BUF_SIZE 1024
  106. #define INIT_ATTS_SIZE 16
  107. #define INIT_ATTS_VERSION 0xFFFFFFFF
  108. #define INIT_BLOCK_SIZE 1024
  109. #define INIT_BUFFER_SIZE 1024
  110. #define EXPAND_SPARE 24
  111. typedef struct binding {
  112. struct prefix *prefix;
  113. struct binding *nextTagBinding;
  114. struct binding *prevPrefixBinding;
  115. const struct attribute_id *attId;
  116. XML_Char *uri;
  117. int uriLen;
  118. int uriAlloc;
  119. } BINDING;
  120. typedef struct prefix {
  121. const XML_Char *name;
  122. BINDING *binding;
  123. } PREFIX;
  124. typedef struct {
  125. const XML_Char *str;
  126. const XML_Char *localPart;
  127. const XML_Char *prefix;
  128. int strLen;
  129. int uriLen;
  130. int prefixLen;
  131. } TAG_NAME;
  132. /* TAG represents an open element.
  133. The name of the element is stored in both the document and API
  134. encodings. The memory buffer 'buf' is a separately-allocated
  135. memory area which stores the name. During the XML_Parse()/
  136. XMLParseBuffer() when the element is open, the memory for the 'raw'
  137. version of the name (in the document encoding) is shared with the
  138. document buffer. If the element is open across calls to
  139. XML_Parse()/XML_ParseBuffer(), the buffer is re-allocated to
  140. contain the 'raw' name as well.
  141. A parser re-uses these structures, maintaining a list of allocated
  142. TAG objects in a free list.
  143. */
  144. typedef struct tag {
  145. struct tag *parent; /* parent of this element */
  146. const char *rawName; /* tagName in the original encoding */
  147. int rawNameLength;
  148. TAG_NAME name; /* tagName in the API encoding */
  149. char *buf; /* buffer for name components */
  150. char *bufEnd; /* end of the buffer */
  151. BINDING *bindings;
  152. } TAG;
  153. typedef struct {
  154. const XML_Char *name;
  155. const XML_Char *textPtr;
  156. int textLen; /* length in XML_Chars */
  157. int processed; /* # of processed bytes - when suspended */
  158. const XML_Char *systemId;
  159. const XML_Char *base;
  160. const XML_Char *publicId;
  161. const XML_Char *notation;
  162. XML_Bool open;
  163. XML_Bool is_param;
  164. XML_Bool is_internal; /* true if declared in internal subset outside PE */
  165. } ENTITY;
  166. typedef struct {
  167. enum XML_Content_Type type;
  168. enum XML_Content_Quant quant;
  169. const XML_Char * name;
  170. int firstchild;
  171. int lastchild;
  172. int childcnt;
  173. int nextsib;
  174. } CONTENT_SCAFFOLD;
  175. #define INIT_SCAFFOLD_ELEMENTS 32
  176. typedef struct block {
  177. struct block *next;
  178. int size;
  179. XML_Char s[1];
  180. } BLOCK;
  181. typedef struct {
  182. BLOCK *blocks;
  183. BLOCK *freeBlocks;
  184. const XML_Char *end;
  185. XML_Char *ptr;
  186. XML_Char *start;
  187. const XML_Memory_Handling_Suite *mem;
  188. } STRING_POOL;
  189. /* The XML_Char before the name is used to determine whether
  190. an attribute has been specified. */
  191. typedef struct attribute_id {
  192. XML_Char *name;
  193. PREFIX *prefix;
  194. XML_Bool maybeTokenized;
  195. XML_Bool xmlns;
  196. } ATTRIBUTE_ID;
  197. typedef struct {
  198. const ATTRIBUTE_ID *id;
  199. XML_Bool isCdata;
  200. const XML_Char *value;
  201. } DEFAULT_ATTRIBUTE;
  202. typedef struct {
  203. unsigned long version;
  204. unsigned long hash;
  205. const XML_Char *uriName;
  206. } NS_ATT;
  207. typedef struct {
  208. const XML_Char *name;
  209. PREFIX *prefix;
  210. const ATTRIBUTE_ID *idAtt;
  211. int nDefaultAtts;
  212. int allocDefaultAtts;
  213. DEFAULT_ATTRIBUTE *defaultAtts;
  214. } ELEMENT_TYPE;
  215. typedef struct {
  216. HASH_TABLE generalEntities;
  217. HASH_TABLE elementTypes;
  218. HASH_TABLE attributeIds;
  219. HASH_TABLE prefixes;
  220. STRING_POOL pool;
  221. STRING_POOL entityValuePool;
  222. /* false once a parameter entity reference has been skipped */
  223. XML_Bool keepProcessing;
  224. /* true once an internal or external PE reference has been encountered;
  225. this includes the reference to an external subset */
  226. XML_Bool hasParamEntityRefs;
  227. XML_Bool standalone;
  228. #ifdef XML_DTD
  229. /* indicates if external PE has been read */
  230. XML_Bool paramEntityRead;
  231. HASH_TABLE paramEntities;
  232. #endif /* XML_DTD */
  233. PREFIX defaultPrefix;
  234. /* === scaffolding for building content model === */
  235. XML_Bool in_eldecl;
  236. CONTENT_SCAFFOLD *scaffold;
  237. unsigned contentStringLen;
  238. unsigned scaffSize;
  239. unsigned scaffCount;
  240. int scaffLevel;
  241. int *scaffIndex;
  242. } DTD;
  243. typedef struct open_internal_entity {
  244. const char *internalEventPtr;
  245. const char *internalEventEndPtr;
  246. struct open_internal_entity *next;
  247. ENTITY *entity;
  248. int startTagLevel;
  249. XML_Bool betweenDecl; /* WFC: PE Between Declarations */
  250. } OPEN_INTERNAL_ENTITY;
  251. typedef enum XML_Error PTRCALL Processor(XML_Parser parser,
  252. const char *start,
  253. const char *end,
  254. const char **endPtr);
  255. static Processor prologProcessor;
  256. static Processor prologInitProcessor;
  257. static Processor contentProcessor;
  258. static Processor cdataSectionProcessor;
  259. #ifdef XML_DTD
  260. static Processor ignoreSectionProcessor;
  261. static Processor externalParEntProcessor;
  262. static Processor externalParEntInitProcessor;
  263. static Processor entityValueProcessor;
  264. static Processor entityValueInitProcessor;
  265. #endif /* XML_DTD */
  266. static Processor epilogProcessor;
  267. static Processor errorProcessor;
  268. static Processor externalEntityInitProcessor;
  269. static Processor externalEntityInitProcessor2;
  270. static Processor externalEntityInitProcessor3;
  271. static Processor externalEntityContentProcessor;
  272. static Processor internalEntityProcessor;
  273. static enum XML_Error
  274. handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName);
  275. static enum XML_Error
  276. processXmlDecl(XML_Parser parser, int isGeneralTextEntity,
  277. const char *s, const char *next);
  278. static enum XML_Error
  279. initializeEncoding(XML_Parser parser);
  280. static enum XML_Error
  281. doProlog(XML_Parser parser, const ENCODING *enc, const char *s,
  282. const char *end, int tok, const char *next, const char **nextPtr,
  283. XML_Bool haveMore);
  284. static enum XML_Error
  285. processInternalEntity(XML_Parser parser, ENTITY *entity,
  286. XML_Bool betweenDecl);
  287. static enum XML_Error
  288. doContent(XML_Parser parser, int startTagLevel, const ENCODING *enc,
  289. const char *start, const char *end, const char **endPtr,
  290. XML_Bool haveMore);
  291. static enum XML_Error
  292. doCdataSection(XML_Parser parser, const ENCODING *, const char **startPtr,
  293. const char *end, const char **nextPtr, XML_Bool haveMore);
  294. #ifdef XML_DTD
  295. static enum XML_Error
  296. doIgnoreSection(XML_Parser parser, const ENCODING *, const char **startPtr,
  297. const char *end, const char **nextPtr, XML_Bool haveMore);
  298. #endif /* XML_DTD */
  299. static enum XML_Error
  300. storeAtts(XML_Parser parser, const ENCODING *, const char *s,
  301. TAG_NAME *tagNamePtr, BINDING **bindingsPtr);
  302. static enum XML_Error
  303. addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,
  304. const XML_Char *uri, BINDING **bindingsPtr);
  305. static int
  306. defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *, XML_Bool isCdata,
  307. XML_Bool isId, const XML_Char *dfltValue, XML_Parser parser);
  308. static enum XML_Error
  309. storeAttributeValue(XML_Parser parser, const ENCODING *, XML_Bool isCdata,
  310. const char *, const char *, STRING_POOL *);
  311. static enum XML_Error
  312. appendAttributeValue(XML_Parser parser, const ENCODING *, XML_Bool isCdata,
  313. const char *, const char *, STRING_POOL *);
  314. static ATTRIBUTE_ID *
  315. getAttributeId(XML_Parser parser, const ENCODING *enc, const char *start,
  316. const char *end);
  317. static int
  318. setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *);
  319. static enum XML_Error
  320. storeEntityValue(XML_Parser parser, const ENCODING *enc, const char *start,
  321. const char *end);
  322. static int
  323. reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,
  324. const char *start, const char *end);
  325. static int
  326. reportComment(XML_Parser parser, const ENCODING *enc, const char *start,
  327. const char *end);
  328. static void
  329. reportDefault(XML_Parser parser, const ENCODING *enc, const char *start,
  330. const char *end);
  331. static const XML_Char * getContext(XML_Parser parser);
  332. static XML_Bool
  333. setContext(XML_Parser parser, const XML_Char *context);
  334. static void FASTCALL normalizePublicId(XML_Char *s);
  335. static DTD * dtdCreate(const XML_Memory_Handling_Suite *ms);
  336. /* do not call if parentParser != NULL */
  337. static void dtdReset(DTD *p, const XML_Memory_Handling_Suite *ms);
  338. static void
  339. dtdDestroy(DTD *p, XML_Bool isDocEntity, const XML_Memory_Handling_Suite *ms);
  340. static int
  341. dtdCopy(DTD *newDtd, const DTD *oldDtd, const XML_Memory_Handling_Suite *ms);
  342. static int
  343. copyEntityTable(HASH_TABLE *, STRING_POOL *, const HASH_TABLE *);
  344. static NAMED *
  345. lookup(HASH_TABLE *table, KEY name, size_t createSize);
  346. static void FASTCALL
  347. hashTableInit(HASH_TABLE *, const XML_Memory_Handling_Suite *ms);
  348. static void FASTCALL hashTableClear(HASH_TABLE *);
  349. static void FASTCALL hashTableDestroy(HASH_TABLE *);
  350. static void FASTCALL
  351. hashTableIterInit(HASH_TABLE_ITER *, const HASH_TABLE *);
  352. static NAMED * FASTCALL hashTableIterNext(HASH_TABLE_ITER *);
  353. static void FASTCALL
  354. poolInit(STRING_POOL *, const XML_Memory_Handling_Suite *ms);
  355. static void FASTCALL poolClear(STRING_POOL *);
  356. static void FASTCALL poolDestroy(STRING_POOL *);
  357. static XML_Char *
  358. poolAppend(STRING_POOL *pool, const ENCODING *enc,
  359. const char *ptr, const char *end);
  360. static XML_Char *
  361. poolStoreString(STRING_POOL *pool, const ENCODING *enc,
  362. const char *ptr, const char *end);
  363. static XML_Bool FASTCALL poolGrow(STRING_POOL *pool);
  364. static const XML_Char * FASTCALL
  365. poolCopyString(STRING_POOL *pool, const XML_Char *s);
  366. static const XML_Char *
  367. poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n);
  368. static const XML_Char * FASTCALL
  369. poolAppendString(STRING_POOL *pool, const XML_Char *s);
  370. static int FASTCALL nextScaffoldPart(XML_Parser parser);
  371. static XML_Content * build_model(XML_Parser parser);
  372. static ELEMENT_TYPE *
  373. getElementType(XML_Parser parser, const ENCODING *enc,
  374. const char *ptr, const char *end);
  375. static XML_Parser
  376. parserCreate(const XML_Char *encodingName,
  377. const XML_Memory_Handling_Suite *memsuite,
  378. const XML_Char *nameSep,
  379. DTD *dtd);
  380. static void
  381. parserInit(XML_Parser parser, const XML_Char *encodingName);
  382. #define poolStart(pool) ((pool)->start)
  383. #define poolEnd(pool) ((pool)->ptr)
  384. #define poolLength(pool) ((pool)->ptr - (pool)->start)
  385. #define poolChop(pool) ((void)--(pool->ptr))
  386. #define poolLastChar(pool) (((pool)->ptr)[-1])
  387. #define poolDiscard(pool) ((pool)->ptr = (pool)->start)
  388. #define poolFinish(pool) ((pool)->start = (pool)->ptr)
  389. #define poolAppendChar(pool, c) \
  390. (((pool)->ptr == (pool)->end && !poolGrow(pool)) \
  391. ? 0 \
  392. : ((*((pool)->ptr)++ = c), 1))
  393. struct XML_ParserStruct {
  394. /* The first member must be userData so that the XML_GetUserData
  395. macro works. */
  396. void *m_userData;
  397. void *m_handlerArg;
  398. char *m_buffer;
  399. const XML_Memory_Handling_Suite m_mem;
  400. /* first character to be parsed */
  401. const char *m_bufferPtr;
  402. /* past last character to be parsed */
  403. char *m_bufferEnd;
  404. /* allocated end of buffer */
  405. const char *m_bufferLim;
  406. XML_Index m_parseEndByteIndex;
  407. const char *m_parseEndPtr;
  408. XML_Char *m_dataBuf;
  409. XML_Char *m_dataBufEnd;
  410. XML_StartElementHandler m_startElementHandler;
  411. XML_EndElementHandler m_endElementHandler;
  412. XML_CharacterDataHandler m_characterDataHandler;
  413. XML_ProcessingInstructionHandler m_processingInstructionHandler;
  414. XML_CommentHandler m_commentHandler;
  415. XML_StartCdataSectionHandler m_startCdataSectionHandler;
  416. XML_EndCdataSectionHandler m_endCdataSectionHandler;
  417. XML_DefaultHandler m_defaultHandler;
  418. XML_StartDoctypeDeclHandler m_startDoctypeDeclHandler;
  419. XML_EndDoctypeDeclHandler m_endDoctypeDeclHandler;
  420. XML_UnparsedEntityDeclHandler m_unparsedEntityDeclHandler;
  421. XML_NotationDeclHandler m_notationDeclHandler;
  422. XML_StartNamespaceDeclHandler m_startNamespaceDeclHandler;
  423. XML_EndNamespaceDeclHandler m_endNamespaceDeclHandler;
  424. XML_NotStandaloneHandler m_notStandaloneHandler;
  425. XML_ExternalEntityRefHandler m_externalEntityRefHandler;
  426. XML_Parser m_externalEntityRefHandlerArg;
  427. XML_SkippedEntityHandler m_skippedEntityHandler;
  428. XML_UnknownEncodingHandler m_unknownEncodingHandler;
  429. XML_ElementDeclHandler m_elementDeclHandler;
  430. XML_AttlistDeclHandler m_attlistDeclHandler;
  431. XML_EntityDeclHandler m_entityDeclHandler;
  432. XML_XmlDeclHandler m_xmlDeclHandler;
  433. const ENCODING *m_encoding;
  434. INIT_ENCODING m_initEncoding;
  435. const ENCODING *m_internalEncoding;
  436. const XML_Char *m_protocolEncodingName;
  437. XML_Bool m_ns;
  438. XML_Bool m_ns_triplets;
  439. void *m_unknownEncodingMem;
  440. void *m_unknownEncodingData;
  441. void *m_unknownEncodingHandlerData;
  442. void (XMLCALL *m_unknownEncodingRelease)(void *);
  443. PROLOG_STATE m_prologState;
  444. Processor *m_processor;
  445. enum XML_Error m_errorCode;
  446. const char *m_eventPtr;
  447. const char *m_eventEndPtr;
  448. const char *m_positionPtr;
  449. OPEN_INTERNAL_ENTITY *m_openInternalEntities;
  450. OPEN_INTERNAL_ENTITY *m_freeInternalEntities;
  451. XML_Bool m_defaultExpandInternalEntities;
  452. int m_tagLevel;
  453. ENTITY *m_declEntity;
  454. const XML_Char *m_doctypeName;
  455. const XML_Char *m_doctypeSysid;
  456. const XML_Char *m_doctypePubid;
  457. const XML_Char *m_declAttributeType;
  458. const XML_Char *m_declNotationName;
  459. const XML_Char *m_declNotationPublicId;
  460. ELEMENT_TYPE *m_declElementType;
  461. ATTRIBUTE_ID *m_declAttributeId;
  462. XML_Bool m_declAttributeIsCdata;
  463. XML_Bool m_declAttributeIsId;
  464. DTD *m_dtd;
  465. const XML_Char *m_curBase;
  466. TAG *m_tagStack;
  467. TAG *m_freeTagList;
  468. BINDING *m_inheritedBindings;
  469. BINDING *m_freeBindingList;
  470. int m_attsSize;
  471. int m_nSpecifiedAtts;
  472. int m_idAttIndex;
  473. ATTRIBUTE *m_atts;
  474. NS_ATT *m_nsAtts;
  475. unsigned long m_nsAttsVersion;
  476. unsigned char m_nsAttsPower;
  477. POSITION m_position;
  478. STRING_POOL m_tempPool;
  479. STRING_POOL m_temp2Pool;
  480. char *m_groupConnector;
  481. unsigned int m_groupSize;
  482. XML_Char m_namespaceSeparator;
  483. XML_Parser m_parentParser;
  484. XML_ParsingStatus m_parsingStatus;
  485. #ifdef XML_DTD
  486. XML_Bool m_isParamEntity;
  487. XML_Bool m_useForeignDTD;
  488. enum XML_ParamEntityParsing m_paramEntityParsing;
  489. #endif
  490. };
  491. #define MALLOC(s) (parser->m_mem.malloc_fcn((s)))
  492. #define REALLOC(p,s) (parser->m_mem.realloc_fcn((p),(s)))
  493. #define FREE(p) (parser->m_mem.free_fcn((p)))
  494. #define userData (parser->m_userData)
  495. #define handlerArg (parser->m_handlerArg)
  496. #define startElementHandler (parser->m_startElementHandler)
  497. #define endElementHandler (parser->m_endElementHandler)
  498. #define characterDataHandler (parser->m_characterDataHandler)
  499. #define processingInstructionHandler \
  500. (parser->m_processingInstructionHandler)
  501. #define commentHandler (parser->m_commentHandler)
  502. #define startCdataSectionHandler \
  503. (parser->m_startCdataSectionHandler)
  504. #define endCdataSectionHandler (parser->m_endCdataSectionHandler)
  505. #define defaultHandler (parser->m_defaultHandler)
  506. #define startDoctypeDeclHandler (parser->m_startDoctypeDeclHandler)
  507. #define endDoctypeDeclHandler (parser->m_endDoctypeDeclHandler)
  508. #define unparsedEntityDeclHandler \
  509. (parser->m_unparsedEntityDeclHandler)
  510. #define notationDeclHandler (parser->m_notationDeclHandler)
  511. #define startNamespaceDeclHandler \
  512. (parser->m_startNamespaceDeclHandler)
  513. #define endNamespaceDeclHandler (parser->m_endNamespaceDeclHandler)
  514. #define notStandaloneHandler (parser->m_notStandaloneHandler)
  515. #define externalEntityRefHandler \
  516. (parser->m_externalEntityRefHandler)
  517. #define externalEntityRefHandlerArg \
  518. (parser->m_externalEntityRefHandlerArg)
  519. #define internalEntityRefHandler \
  520. (parser->m_internalEntityRefHandler)
  521. #define skippedEntityHandler (parser->m_skippedEntityHandler)
  522. #define unknownEncodingHandler (parser->m_unknownEncodingHandler)
  523. #define elementDeclHandler (parser->m_elementDeclHandler)
  524. #define attlistDeclHandler (parser->m_attlistDeclHandler)
  525. #define entityDeclHandler (parser->m_entityDeclHandler)
  526. #define xmlDeclHandler (parser->m_xmlDeclHandler)
  527. #define encoding (parser->m_encoding)
  528. #define initEncoding (parser->m_initEncoding)
  529. #define internalEncoding (parser->m_internalEncoding)
  530. #define unknownEncodingMem (parser->m_unknownEncodingMem)
  531. #define unknownEncodingData (parser->m_unknownEncodingData)
  532. #define unknownEncodingHandlerData \
  533. (parser->m_unknownEncodingHandlerData)
  534. #define unknownEncodingRelease (parser->m_unknownEncodingRelease)
  535. #define protocolEncodingName (parser->m_protocolEncodingName)
  536. #define ns (parser->m_ns)
  537. #define ns_triplets (parser->m_ns_triplets)
  538. #define prologState (parser->m_prologState)
  539. #define processor (parser->m_processor)
  540. #define errorCode (parser->m_errorCode)
  541. #define eventPtr (parser->m_eventPtr)
  542. #define eventEndPtr (parser->m_eventEndPtr)
  543. #define positionPtr (parser->m_positionPtr)
  544. #define position (parser->m_position)
  545. #define openInternalEntities (parser->m_openInternalEntities)
  546. #define freeInternalEntities (parser->m_freeInternalEntities)
  547. #define defaultExpandInternalEntities \
  548. (parser->m_defaultExpandInternalEntities)
  549. #define tagLevel (parser->m_tagLevel)
  550. #define buffer (parser->m_buffer)
  551. #define bufferPtr (parser->m_bufferPtr)
  552. #define bufferEnd (parser->m_bufferEnd)
  553. #define parseEndByteIndex (parser->m_parseEndByteIndex)
  554. #define parseEndPtr (parser->m_parseEndPtr)
  555. #define bufferLim (parser->m_bufferLim)
  556. #define dataBuf (parser->m_dataBuf)
  557. #define dataBufEnd (parser->m_dataBufEnd)
  558. #define _dtd (parser->m_dtd)
  559. #define curBase (parser->m_curBase)
  560. #define declEntity (parser->m_declEntity)
  561. #define doctypeName (parser->m_doctypeName)
  562. #define doctypeSysid (parser->m_doctypeSysid)
  563. #define doctypePubid (parser->m_doctypePubid)
  564. #define declAttributeType (parser->m_declAttributeType)
  565. #define declNotationName (parser->m_declNotationName)
  566. #define declNotationPublicId (parser->m_declNotationPublicId)
  567. #define declElementType (parser->m_declElementType)
  568. #define declAttributeId (parser->m_declAttributeId)
  569. #define declAttributeIsCdata (parser->m_declAttributeIsCdata)
  570. #define declAttributeIsId (parser->m_declAttributeIsId)
  571. #define freeTagList (parser->m_freeTagList)
  572. #define freeBindingList (parser->m_freeBindingList)
  573. #define inheritedBindings (parser->m_inheritedBindings)
  574. #define tagStack (parser->m_tagStack)
  575. #define atts (parser->m_atts)
  576. #define attsSize (parser->m_attsSize)
  577. #define nSpecifiedAtts (parser->m_nSpecifiedAtts)
  578. #define idAttIndex (parser->m_idAttIndex)
  579. #define nsAtts (parser->m_nsAtts)
  580. #define nsAttsVersion (parser->m_nsAttsVersion)
  581. #define nsAttsPower (parser->m_nsAttsPower)
  582. #define tempPool (parser->m_tempPool)
  583. #define temp2Pool (parser->m_temp2Pool)
  584. #define groupConnector (parser->m_groupConnector)
  585. #define groupSize (parser->m_groupSize)
  586. #define namespaceSeparator (parser->m_namespaceSeparator)
  587. #define parentParser (parser->m_parentParser)
  588. #define ps_parsing (parser->m_parsingStatus.parsing)
  589. #define ps_finalBuffer (parser->m_parsingStatus.finalBuffer)
  590. #ifdef XML_DTD
  591. #define isParamEntity (parser->m_isParamEntity)
  592. #define useForeignDTD (parser->m_useForeignDTD)
  593. #define paramEntityParsing (parser->m_paramEntityParsing)
  594. #endif /* XML_DTD */
  595. XML_Parser XMLCALL
  596. XML_ParserCreate(const XML_Char *encodingName)
  597. {
  598. return XML_ParserCreate_MM(encodingName, NULL, NULL);
  599. }
  600. XML_Parser XMLCALL
  601. XML_ParserCreateNS(const XML_Char *encodingName, XML_Char nsSep)
  602. {
  603. XML_Char tmp[2];
  604. *tmp = nsSep;
  605. return XML_ParserCreate_MM(encodingName, NULL, tmp);
  606. }
  607. static const XML_Char implicitContext[] = {
  608. 'x', 'm', 'l', '=', 'h', 't', 't', 'p', ':', '/', '/',
  609. 'w', 'w', 'w', '.', 'w', '3', '.', 'o', 'r', 'g', '/',
  610. 'X', 'M', 'L', '/', '1', '9', '9', '8', '/',
  611. 'n', 'a', 'm', 'e', 's', 'p', 'a', 'c', 'e', '\0'
  612. };
  613. XML_Parser XMLCALL
  614. XML_ParserCreate_MM(const XML_Char *encodingName,
  615. const XML_Memory_Handling_Suite *memsuite,
  616. const XML_Char *nameSep)
  617. {
  618. XML_Parser parser = parserCreate(encodingName, memsuite, nameSep, NULL);
  619. if (parser != NULL && ns) {
  620. /* implicit context only set for root parser, since child
  621. parsers (i.e. external entity parsers) will inherit it
  622. */
  623. if (!setContext(parser, implicitContext)) {
  624. XML_ParserFree(parser);
  625. return NULL;
  626. }
  627. }
  628. return parser;
  629. }
  630. static XML_Parser
  631. parserCreate(const XML_Char *encodingName,
  632. const XML_Memory_Handling_Suite *memsuite,
  633. const XML_Char *nameSep,
  634. DTD *dtd)
  635. {
  636. XML_Parser parser;
  637. if (memsuite) {
  638. XML_Memory_Handling_Suite *mtemp;
  639. parser = (XML_Parser)
  640. memsuite->malloc_fcn(sizeof(struct XML_ParserStruct));
  641. if (parser != NULL) {
  642. mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);
  643. mtemp->malloc_fcn = memsuite->malloc_fcn;
  644. mtemp->realloc_fcn = memsuite->realloc_fcn;
  645. mtemp->free_fcn = memsuite->free_fcn;
  646. }
  647. }
  648. else {
  649. XML_Memory_Handling_Suite *mtemp;
  650. parser = (XML_Parser)malloc(sizeof(struct XML_ParserStruct));
  651. if (parser != NULL) {
  652. mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);
  653. mtemp->malloc_fcn = malloc;
  654. mtemp->realloc_fcn = realloc;
  655. mtemp->free_fcn = free;
  656. }
  657. }
  658. if (!parser)
  659. return parser;
  660. buffer = NULL;
  661. bufferLim = NULL;
  662. attsSize = INIT_ATTS_SIZE;
  663. atts = (ATTRIBUTE *)MALLOC(attsSize * sizeof(ATTRIBUTE));
  664. if (atts == NULL) {
  665. FREE(parser);
  666. return NULL;
  667. }
  668. dataBuf = (XML_Char *)MALLOC(INIT_DATA_BUF_SIZE * sizeof(XML_Char));
  669. if (dataBuf == NULL) {
  670. FREE(atts);
  671. FREE(parser);
  672. return NULL;
  673. }
  674. dataBufEnd = dataBuf + INIT_DATA_BUF_SIZE;
  675. if (dtd)
  676. _dtd = dtd;
  677. else {
  678. _dtd = dtdCreate(&parser->m_mem);
  679. if (_dtd == NULL) {
  680. FREE(dataBuf);
  681. FREE(atts);
  682. FREE(parser);
  683. return NULL;
  684. }
  685. }
  686. freeBindingList = NULL;
  687. freeTagList = NULL;
  688. freeInternalEntities = NULL;
  689. groupSize = 0;
  690. groupConnector = NULL;
  691. unknownEncodingHandler = NULL;
  692. unknownEncodingHandlerData = NULL;
  693. namespaceSeparator = '!';
  694. ns = XML_FALSE;
  695. ns_triplets = XML_FALSE;
  696. nsAtts = NULL;
  697. nsAttsVersion = 0;
  698. nsAttsPower = 0;
  699. poolInit(&tempPool, &(parser->m_mem));
  700. poolInit(&temp2Pool, &(parser->m_mem));
  701. parserInit(parser, encodingName);
  702. if (encodingName && !protocolEncodingName) {
  703. XML_ParserFree(parser);
  704. return NULL;
  705. }
  706. if (nameSep) {
  707. ns = XML_TRUE;
  708. internalEncoding = XmlGetInternalEncodingNS();
  709. namespaceSeparator = *nameSep;
  710. }
  711. else {
  712. internalEncoding = XmlGetInternalEncoding();
  713. }
  714. return parser;
  715. }
  716. static void
  717. parserInit(XML_Parser parser, const XML_Char *encodingName)
  718. {
  719. processor = prologInitProcessor;
  720. XmlPrologStateInit(&prologState);
  721. protocolEncodingName = (encodingName != NULL
  722. ? poolCopyString(&tempPool, encodingName)
  723. : NULL);
  724. curBase = NULL;
  725. XmlInitEncoding(&initEncoding, &encoding, 0);
  726. userData = NULL;
  727. handlerArg = NULL;
  728. startElementHandler = NULL;
  729. endElementHandler = NULL;
  730. characterDataHandler = NULL;
  731. processingInstructionHandler = NULL;
  732. commentHandler = NULL;
  733. startCdataSectionHandler = NULL;
  734. endCdataSectionHandler = NULL;
  735. defaultHandler = NULL;
  736. startDoctypeDeclHandler = NULL;
  737. endDoctypeDeclHandler = NULL;
  738. unparsedEntityDeclHandler = NULL;
  739. notationDeclHandler = NULL;
  740. startNamespaceDeclHandler = NULL;
  741. endNamespaceDeclHandler = NULL;
  742. notStandaloneHandler = NULL;
  743. externalEntityRefHandler = NULL;
  744. externalEntityRefHandlerArg = parser;
  745. skippedEntityHandler = NULL;
  746. elementDeclHandler = NULL;
  747. attlistDeclHandler = NULL;
  748. entityDeclHandler = NULL;
  749. xmlDeclHandler = NULL;
  750. bufferPtr = buffer;
  751. bufferEnd = buffer;
  752. parseEndByteIndex = 0;
  753. parseEndPtr = NULL;
  754. declElementType = NULL;
  755. declAttributeId = NULL;
  756. declEntity = NULL;
  757. doctypeName = NULL;
  758. doctypeSysid = NULL;
  759. doctypePubid = NULL;
  760. declAttributeType = NULL;
  761. declNotationName = NULL;
  762. declNotationPublicId = NULL;
  763. declAttributeIsCdata = XML_FALSE;
  764. declAttributeIsId = XML_FALSE;
  765. memset(&position, 0, sizeof(POSITION));
  766. errorCode = XML_ERROR_NONE;
  767. eventPtr = NULL;
  768. eventEndPtr = NULL;
  769. positionPtr = NULL;
  770. openInternalEntities = NULL;
  771. defaultExpandInternalEntities = XML_TRUE;
  772. tagLevel = 0;
  773. tagStack = NULL;
  774. inheritedBindings = NULL;
  775. nSpecifiedAtts = 0;
  776. unknownEncodingMem = NULL;
  777. unknownEncodingRelease = NULL;
  778. unknownEncodingData = NULL;
  779. parentParser = NULL;
  780. ps_parsing = XML_INITIALIZED;
  781. #ifdef XML_DTD
  782. isParamEntity = XML_FALSE;
  783. useForeignDTD = XML_FALSE;
  784. paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
  785. #endif
  786. }
  787. /* moves list of bindings to freeBindingList */
  788. static void FASTCALL
  789. moveToFreeBindingList(XML_Parser parser, BINDING *bindings)
  790. {
  791. while (bindings) {
  792. BINDING *b = bindings;
  793. bindings = bindings->nextTagBinding;
  794. b->nextTagBinding = freeBindingList;
  795. freeBindingList = b;
  796. }
  797. }
  798. XML_Bool XMLCALL
  799. XML_ParserReset(XML_Parser parser, const XML_Char *encodingName)
  800. {
  801. TAG *tStk;
  802. OPEN_INTERNAL_ENTITY *openEntityList;
  803. if (parentParser)
  804. return XML_FALSE;
  805. /* move tagStack to freeTagList */
  806. tStk = tagStack;
  807. while (tStk) {
  808. TAG *tag = tStk;
  809. tStk = tStk->parent;
  810. tag->parent = freeTagList;
  811. moveToFreeBindingList(parser, tag->bindings);
  812. tag->bindings = NULL;
  813. freeTagList = tag;
  814. }
  815. /* move openInternalEntities to freeInternalEntities */
  816. openEntityList = openInternalEntities;
  817. while (openEntityList) {
  818. OPEN_INTERNAL_ENTITY *openEntity = openEntityList;
  819. openEntityList = openEntity->next;
  820. openEntity->next = freeInternalEntities;
  821. freeInternalEntities = openEntity;
  822. }
  823. moveToFreeBindingList(parser, inheritedBindings);
  824. FREE(unknownEncodingMem);
  825. if (unknownEncodingRelease)
  826. unknownEncodingRelease(unknownEncodingData);
  827. poolClear(&tempPool);
  828. poolClear(&temp2Pool);
  829. parserInit(parser, encodingName);
  830. dtdReset(_dtd, &parser->m_mem);
  831. return setContext(parser, implicitContext);
  832. }
  833. enum XML_Status XMLCALL
  834. XML_SetEncoding(XML_Parser parser, const XML_Char *encodingName)
  835. {
  836. /* Block after XML_Parse()/XML_ParseBuffer() has been called.
  837. XXX There's no way for the caller to determine which of the
  838. XXX possible error cases caused the XML_STATUS_ERROR return.
  839. */
  840. if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)
  841. return XML_STATUS_ERROR;
  842. if (encodingName == NULL)
  843. protocolEncodingName = NULL;
  844. else {
  845. protocolEncodingName = poolCopyString(&tempPool, encodingName);
  846. if (!protocolEncodingName)
  847. return XML_STATUS_ERROR;
  848. }
  849. return XML_STATUS_OK;
  850. }
  851. XML_Parser XMLCALL
  852. XML_ExternalEntityParserCreate(XML_Parser oldParser,
  853. const XML_Char *context,
  854. const XML_Char *encodingName)
  855. {
  856. XML_Parser parser = oldParser;
  857. DTD *newDtd = NULL;
  858. DTD *oldDtd = _dtd;
  859. XML_StartElementHandler oldStartElementHandler = startElementHandler;
  860. XML_EndElementHandler oldEndElementHandler = endElementHandler;
  861. XML_CharacterDataHandler oldCharacterDataHandler = characterDataHandler;
  862. XML_ProcessingInstructionHandler oldProcessingInstructionHandler
  863. = processingInstructionHandler;
  864. XML_CommentHandler oldCommentHandler = commentHandler;
  865. XML_StartCdataSectionHandler oldStartCdataSectionHandler
  866. = startCdataSectionHandler;
  867. XML_EndCdataSectionHandler oldEndCdataSectionHandler
  868. = endCdataSectionHandler;
  869. XML_DefaultHandler oldDefaultHandler = defaultHandler;
  870. XML_UnparsedEntityDeclHandler oldUnparsedEntityDeclHandler
  871. = unparsedEntityDeclHandler;
  872. XML_NotationDeclHandler oldNotationDeclHandler = notationDeclHandler;
  873. XML_StartNamespaceDeclHandler oldStartNamespaceDeclHandler
  874. = startNamespaceDeclHandler;
  875. XML_EndNamespaceDeclHandler oldEndNamespaceDeclHandler
  876. = endNamespaceDeclHandler;
  877. XML_NotStandaloneHandler oldNotStandaloneHandler = notStandaloneHandler;
  878. XML_ExternalEntityRefHandler oldExternalEntityRefHandler
  879. = externalEntityRefHandler;
  880. XML_SkippedEntityHandler oldSkippedEntityHandler = skippedEntityHandler;
  881. XML_UnknownEncodingHandler oldUnknownEncodingHandler
  882. = unknownEncodingHandler;
  883. XML_ElementDeclHandler oldElementDeclHandler = elementDeclHandler;
  884. XML_AttlistDeclHandler oldAttlistDeclHandler = attlistDeclHandler;
  885. XML_EntityDeclHandler oldEntityDeclHandler = entityDeclHandler;
  886. XML_XmlDeclHandler oldXmlDeclHandler = xmlDeclHandler;
  887. ELEMENT_TYPE * oldDeclElementType = declElementType;
  888. void *oldUserData = userData;
  889. void *oldHandlerArg = handlerArg;
  890. XML_Bool oldDefaultExpandInternalEntities = defaultExpandInternalEntities;
  891. XML_Parser oldExternalEntityRefHandlerArg = externalEntityRefHandlerArg;
  892. #ifdef XML_DTD
  893. enum XML_ParamEntityParsing oldParamEntityParsing = paramEntityParsing;
  894. int oldInEntityValue = prologState.inEntityValue;
  895. #endif
  896. XML_Bool oldns_triplets = ns_triplets;
  897. #ifdef XML_DTD
  898. if (!context)
  899. newDtd = oldDtd;
  900. #endif /* XML_DTD */
  901. /* Note that the magical uses of the pre-processor to make field
  902. access look more like C++ require that `parser' be overwritten
  903. here. This makes this function more painful to follow than it
  904. would be otherwise.
  905. */
  906. if (ns) {
  907. XML_Char tmp[2];
  908. *tmp = namespaceSeparator;
  909. parser = parserCreate(encodingName, &parser->m_mem, tmp, newDtd);
  910. }
  911. else {
  912. parser = parserCreate(encodingName, &parser->m_mem, NULL, newDtd);
  913. }
  914. if (!parser)
  915. return NULL;
  916. startElementHandler = oldStartElementHandler;
  917. endElementHandler = oldEndElementHandler;
  918. characterDataHandler = oldCharacterDataHandler;
  919. processingInstructionHandler = oldProcessingInstructionHandler;
  920. commentHandler = oldCommentHandler;
  921. startCdataSectionHandler = oldStartCdataSectionHandler;
  922. endCdataSectionHandler = oldEndCdataSectionHandler;
  923. defaultHandler = oldDefaultHandler;
  924. unparsedEntityDeclHandler = oldUnparsedEntityDeclHandler;
  925. notationDeclHandler = oldNotationDeclHandler;
  926. startNamespaceDeclHandler = oldStartNamespaceDeclHandler;
  927. endNamespaceDeclHandler = oldEndNamespaceDeclHandler;
  928. notStandaloneHandler = oldNotStandaloneHandler;
  929. externalEntityRefHandler = oldExternalEntityRefHandler;
  930. skippedEntityHandler = oldSkippedEntityHandler;
  931. unknownEncodingHandler = oldUnknownEncodingHandler;
  932. elementDeclHandler = oldElementDeclHandler;
  933. attlistDeclHandler = oldAttlistDeclHandler;
  934. entityDeclHandler = oldEntityDeclHandler;
  935. xmlDeclHandler = oldXmlDeclHandler;
  936. declElementType = oldDeclElementType;
  937. userData = oldUserData;
  938. if (oldUserData == oldHandlerArg)
  939. handlerArg = userData;
  940. else
  941. handlerArg = parser;
  942. if (oldExternalEntityRefHandlerArg != oldParser)
  943. externalEntityRefHandlerArg = oldExternalEntityRefHandlerArg;
  944. defaultExpandInternalEntities = oldDefaultExpandInternalEntities;
  945. ns_triplets = oldns_triplets;
  946. parentParser = oldParser;
  947. #ifdef XML_DTD
  948. paramEntityParsing = oldParamEntityParsing;
  949. prologState.inEntityValue = oldInEntityValue;
  950. if (context) {
  951. #endif /* XML_DTD */
  952. if (!dtdCopy(_dtd, oldDtd, &parser->m_mem)
  953. || !setContext(parser, context)) {
  954. XML_ParserFree(parser);
  955. return NULL;
  956. }
  957. processor = externalEntityInitProcessor;
  958. #ifdef XML_DTD
  959. }
  960. else {
  961. /* The DTD instance referenced by _dtd is shared between the document's
  962. root parser and external PE parsers, therefore one does not need to
  963. call setContext. In addition, one also *must* not call setContext,
  964. because this would overwrite existing prefix->binding pointers in
  965. _dtd with ones that get destroyed with the external PE parser.
  966. This would leave those prefixes with dangling pointers.
  967. */
  968. isParamEntity = XML_TRUE;
  969. XmlPrologStateInitExternalEntity(&prologState);
  970. processor = externalParEntInitProcessor;
  971. }
  972. #endif /* XML_DTD */
  973. return parser;
  974. }
  975. static void FASTCALL
  976. destroyBindings(BINDING *bindings, XML_Parser parser)
  977. {
  978. for (;;) {
  979. BINDING *b = bindings;
  980. if (!b)
  981. break;
  982. bindings = b->nextTagBinding;
  983. FREE(b->uri);
  984. FREE(b);
  985. }
  986. }
  987. void XMLCALL
  988. XML_ParserFree(XML_Parser parser)
  989. {
  990. TAG *tagList;
  991. OPEN_INTERNAL_ENTITY *entityList;
  992. if (parser == NULL)
  993. return;
  994. /* free tagStack and freeTagList */
  995. tagList = tagStack;
  996. for (;;) {
  997. TAG *p;
  998. if (tagList == NULL) {
  999. if (freeTagList == NULL)
  1000. break;
  1001. tagList = freeTagList;
  1002. freeTagList = NULL;
  1003. }
  1004. p = tagList;
  1005. tagList = tagList->parent;
  1006. FREE(p->buf);
  1007. destroyBindings(p->bindings, parser);
  1008. FREE(p);
  1009. }
  1010. /* free openInternalEntities and freeInternalEntities */
  1011. entityList = openInternalEntities;
  1012. for (;;) {
  1013. OPEN_INTERNAL_ENTITY *openEntity;
  1014. if (entityList == NULL) {
  1015. if (freeInternalEntities == NULL)
  1016. break;
  1017. entityList = freeInternalEntities;
  1018. freeInternalEntities = NULL;
  1019. }
  1020. openEntity = entityList;
  1021. entityList = entityList->next;
  1022. FREE(openEntity);
  1023. }
  1024. destroyBindings(freeBindingList, parser);
  1025. destroyBindings(inheritedBindings, parser);
  1026. poolDestroy(&tempPool);
  1027. poolDestroy(&temp2Pool);
  1028. #ifdef XML_DTD
  1029. /* external parameter entity parsers share the DTD structure
  1030. parser->m_dtd with the root parser, so we must not destroy it
  1031. */
  1032. if (!isParamEntity && _dtd)
  1033. #else
  1034. if (_dtd)
  1035. #endif /* XML_DTD */
  1036. dtdDestroy(_dtd, (XML_Bool)!parentParser, &parser->m_mem);
  1037. FREE((void *)atts);
  1038. FREE(groupConnector);
  1039. FREE(buffer);
  1040. FREE(dataBuf);
  1041. FREE(nsAtts);
  1042. FREE(unknownEncodingMem);
  1043. if (unknownEncodingRelease)
  1044. unknownEncodingRelease(unknownEncodingData);
  1045. FREE(parser);
  1046. }
  1047. void XMLCALL
  1048. XML_UseParserAsHandlerArg(XML_Parser parser)
  1049. {
  1050. handlerArg = parser;
  1051. }
  1052. enum XML_Error XMLCALL
  1053. XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD)
  1054. {
  1055. #ifdef XML_DTD
  1056. /* block after XML_Parse()/XML_ParseBuffer() has been called */
  1057. if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)
  1058. return XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING;
  1059. useForeignDTD = useDTD;
  1060. return XML_ERROR_NONE;
  1061. #else
  1062. return XML_ERROR_FEATURE_REQUIRES_XML_DTD;
  1063. #endif
  1064. }
  1065. void XMLCALL
  1066. XML_SetReturnNSTriplet(XML_Parser parser, int do_nst)
  1067. {
  1068. /* block after XML_Parse()/XML_ParseBuffer() has been called */
  1069. if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)
  1070. return;
  1071. ns_triplets = do_nst ? XML_TRUE : XML_FALSE;
  1072. }
  1073. void XMLCALL
  1074. XML_SetUserData(XML_Parser parser, void *p)
  1075. {
  1076. if (handlerArg == userData)
  1077. handlerArg = userData = p;
  1078. else
  1079. userData = p;
  1080. }
  1081. enum XML_Status XMLCALL
  1082. XML_SetBase(XML_Parser parser, const XML_Char *p)
  1083. {
  1084. if (p) {
  1085. p = poolCopyString(&_dtd->pool, p);
  1086. if (!p)
  1087. return XML_STATUS_ERROR;
  1088. curBase = p;
  1089. }
  1090. else
  1091. curBase = NULL;
  1092. return XML_STATUS_OK;
  1093. }
  1094. const XML_Char * XMLCALL
  1095. XML_GetBase(XML_Parser parser)
  1096. {
  1097. return curBase;
  1098. }
  1099. int XMLCALL
  1100. XML_GetSpecifiedAttributeCount(XML_Parser parser)
  1101. {
  1102. return nSpecifiedAtts;
  1103. }
  1104. int XMLCALL
  1105. XML_GetIdAttributeIndex(XML_Parser parser)
  1106. {
  1107. return idAttIndex;
  1108. }
  1109. void XMLCALL
  1110. XML_SetElementHandler(XML_Parser parser,
  1111. XML_StartElementHandler start,
  1112. XML_EndElementHandler end)
  1113. {
  1114. startElementHandler = start;
  1115. endElementHandler = end;
  1116. }
  1117. void XMLCALL
  1118. XML_SetStartElementHandler(XML_Parser parser,
  1119. XML_StartElementHandler start) {
  1120. startElementHandler = start;
  1121. }
  1122. void XMLCALL
  1123. XML_SetEndElementHandler(XML_Parser parser,
  1124. XML_EndElementHandler end) {
  1125. endElementHandler = end;
  1126. }
  1127. void XMLCALL
  1128. XML_SetCharacterDataHandler(XML_Parser parser,
  1129. XML_CharacterDataHandler handler)
  1130. {
  1131. characterDataHandler = handler;
  1132. }
  1133. void XMLCALL
  1134. XML_SetProcessingInstructionHandler(XML_Parser parser,
  1135. XML_ProcessingInstructionHandler handler)
  1136. {
  1137. processingInstructionHandler = handler;
  1138. }
  1139. void XMLCALL
  1140. XML_SetCommentHandler(XML_Parser parser,
  1141. XML_CommentHandler handler)
  1142. {
  1143. commentHandler = handler;
  1144. }
  1145. void XMLCALL
  1146. XML_SetCdataSectionHandler(XML_Parser parser,
  1147. XML_StartCdataSectionHandler start,
  1148. XML_EndCdataSectionHandler end)
  1149. {
  1150. startCdataSectionHandler = start;
  1151. endCdataSectionHandler = end;
  1152. }
  1153. void XMLCALL
  1154. XML_SetStartCdataSectionHandler(XML_Parser parser,
  1155. XML_StartCdataSectionHandler start) {
  1156. startCdataSectionHandler = start;
  1157. }
  1158. void XMLCALL
  1159. XML_SetEndCdataSectionHandler(XML_Parser parser,
  1160. XML_EndCdataSectionHandler end) {
  1161. endCdataSectionHandler = end;
  1162. }
  1163. void XMLCALL
  1164. XML_SetDefaultHandler(XML_Parser parser,
  1165. XML_DefaultHandler handler)
  1166. {
  1167. defaultHandler = handler;
  1168. defaultExpandInternalEntities = XML_FALSE;
  1169. }
  1170. void XMLCALL
  1171. XML_SetDefaultHandlerExpand(XML_Parser parser,
  1172. XML_DefaultHandler handler)
  1173. {
  1174. defaultHandler = handler;
  1175. defaultExpandInternalEntities = XML_TRUE;
  1176. }
  1177. void XMLCALL
  1178. XML_SetDoctypeDeclHandler(XML_Parser parser,
  1179. XML_StartDoctypeDeclHandler start,
  1180. XML_EndDoctypeDeclHandler end)
  1181. {
  1182. startDoctypeDeclHandler = start;
  1183. endDoctypeDeclHandler = end;
  1184. }
  1185. void XMLCALL
  1186. XML_SetStartDoctypeDeclHandler(XML_Parser parser,
  1187. XML_StartDoctypeDeclHandler start) {
  1188. startDoctypeDeclHandler = start;
  1189. }
  1190. void XMLCALL
  1191. XML_SetEndDoctypeDeclHandler(XML_Parser parser,
  1192. XML_EndDoctypeDeclHandler end) {
  1193. endDoctypeDeclHandler = end;
  1194. }
  1195. void XMLCALL
  1196. XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
  1197. XML_UnparsedEntityDeclHandler handler)
  1198. {
  1199. unparsedEntityDeclHandler = handler;
  1200. }
  1201. void XMLCALL
  1202. XML_SetNotationDeclHandler(XML_Parser parser,
  1203. XML_NotationDeclHandler handler)
  1204. {
  1205. notationDeclHandler = handler;
  1206. }
  1207. void XMLCALL
  1208. XML_SetNamespaceDeclHandler(XML_Parser parser,
  1209. XML_StartNamespaceDeclHandler start,
  1210. XML_EndNamespaceDeclHandler end)
  1211. {
  1212. startNamespaceDeclHandler = start;
  1213. endNamespaceDeclHandler = end;
  1214. }
  1215. void XMLCALL
  1216. XML_SetStartNamespaceDeclHandler(XML_Parser parser,
  1217. XML_StartNamespaceDeclHandler start) {
  1218. startNamespaceDeclHandler = start;
  1219. }
  1220. void XMLCALL
  1221. XML_SetEndNamespaceDeclHandler(XML_Parser parser,
  1222. XML_EndNamespaceDeclHandler end) {
  1223. endNamespaceDeclHandler = end;
  1224. }
  1225. void XMLCALL
  1226. XML_SetNotStandaloneHandler(XML_Parser parser,
  1227. XML_NotStandaloneHandler handler)
  1228. {
  1229. notStandaloneHandler = handler;
  1230. }
  1231. void XMLCALL
  1232. XML_SetExternalEntityRefHandler(XML_Parser parser,
  1233. XML_ExternalEntityRefHandler handler)
  1234. {
  1235. externalEntityRefHandler = handler;
  1236. }
  1237. void XMLCALL
  1238. XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg)
  1239. {
  1240. if (arg)
  1241. externalEntityRefHandlerArg = (XML_Parser)arg;
  1242. else
  1243. externalEntityRefHandlerArg = parser;
  1244. }
  1245. void XMLCALL
  1246. XML_SetSkippedEntityHandler(XML_Parser parser,
  1247. XML_SkippedEntityHandler handler)
  1248. {
  1249. skippedEntityHandler = handler;
  1250. }
  1251. void XMLCALL
  1252. XML_SetUnknownEncodingHandler(XML_Parser parser,
  1253. XML_UnknownEncodingHandler handler,
  1254. void *data)
  1255. {
  1256. unknownEncodingHandler = handler;
  1257. unknownEncodingHandlerData = data;
  1258. }
  1259. void XMLCALL
  1260. XML_SetElementDeclHandler(XML_Parser parser,
  1261. XML_ElementDeclHandler eldecl)
  1262. {
  1263. elementDeclHandler = eldecl;
  1264. }
  1265. void XMLCALL
  1266. XML_SetAttlistDeclHandler(XML_Parser parser,
  1267. XML_AttlistDeclHandler attdecl)
  1268. {
  1269. attlistDeclHandler = attdecl;
  1270. }
  1271. void XMLCALL
  1272. XML_SetEntityDeclHandler(XML_Parser parser,
  1273. XML_EntityDeclHandler handler)
  1274. {
  1275. entityDeclHandler = handler;
  1276. }
  1277. void XMLCALL
  1278. XML_SetXmlDeclHandler(XML_Parser parser,
  1279. XML_XmlDeclHandler handler) {
  1280. xmlDeclHandler = handler;
  1281. }
  1282. int XMLCALL
  1283. XML_SetParamEntityParsing(XML_Parser parser,
  1284. enum XML_ParamEntityParsing peParsing)
  1285. {
  1286. /* block after XML_Parse()/XML_ParseBuffer() has been called */
  1287. if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)
  1288. return 0;
  1289. #ifdef XML_DTD
  1290. paramEntityParsing = peParsing;
  1291. return 1;
  1292. #else
  1293. return peParsing == XML_PARAM_ENTITY_PARSING_NEVER;
  1294. #endif
  1295. }
  1296. enum XML_Status XMLCALL
  1297. XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
  1298. {
  1299. switch (ps_parsing) {
  1300. case XML_SUSPENDED:
  1301. errorCode = XML_ERROR_SUSPENDED;
  1302. return XML_STATUS_ERROR;
  1303. case XML_FINISHED:
  1304. errorCode = XML_ERROR_FINISHED;
  1305. return XML_STATUS_ERROR;
  1306. default:
  1307. ps_parsing = XML_PARSING;
  1308. }
  1309. if (len == 0) {
  1310. ps_finalBuffer = (XML_Bool)isFinal;
  1311. if (!isFinal)
  1312. return XML_STATUS_OK;
  1313. positionPtr = bufferPtr;
  1314. parseEndPtr = bufferEnd;
  1315. /* If data are left over from last buffer, and we now know that these
  1316. data are the final chunk of input, then we have to check them again
  1317. to detect errors based on that fact.
  1318. */
  1319. errorCode = processor(parser, bufferPtr, parseEndPtr, &bufferPtr);
  1320. if (errorCode == XML_ERROR_NONE) {
  1321. switch (ps_parsing) {
  1322. case XML_SUSPENDED:
  1323. XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);
  1324. positionPtr = bufferPtr;
  1325. return XML_STATUS_SUSPENDED;
  1326. case XML_INITIALIZED:
  1327. case XML_PARSING:
  1328. ps_parsing = XML_FINISHED;
  1329. /* fall through */
  1330. default:
  1331. return XML_STATUS_OK;
  1332. }
  1333. }
  1334. eventEndPtr = eventPtr;
  1335. processor = errorProcessor;
  1336. return XML_STATUS_ERROR;
  1337. }
  1338. #ifndef XML_CONTEXT_BYTES
  1339. else if (bufferPtr == bufferEnd) {
  1340. const char *end;
  1341. int nLeftOver;
  1342. enum XML_Error result;
  1343. parseEndByteIndex += len;
  1344. positionPtr = s;
  1345. ps_finalBuffer = (XML_Bool)isFinal;
  1346. errorCode = processor(parser, s, parseEndPtr = s + len, &end);
  1347. if (errorCode != XML_ERROR_NONE) {
  1348. eventEndPtr = eventPtr;
  1349. processor = errorProcessor;
  1350. return XML_STATUS_ERROR;
  1351. }
  1352. else {
  1353. switch (ps_parsing) {
  1354. case XML_SUSPENDED:
  1355. result = XML_STATUS_SUSPENDED;
  1356. break;
  1357. case XML_INITIALIZED:
  1358. case XML_PARSING:
  1359. result = XML_STATUS_OK;
  1360. if (isFinal) {
  1361. ps_parsing = XML_FINISHED;
  1362. return result;
  1363. }
  1364. }
  1365. }
  1366. XmlUpdatePosition(encoding, positionPtr, end, &position);
  1367. nLeftOver = s + len - end;
  1368. if (nLeftOver) {
  1369. if (buffer == NULL || nLeftOver > bufferLim - buffer) {
  1370. /* FIXME avoid integer overflow */
  1371. char *temp;
  1372. temp = (buffer == NULL
  1373. ? (char *)MALLOC(len * 2)
  1374. : (char *)REALLOC(buffer, len * 2));
  1375. if (temp == NULL) {
  1376. errorCode = XML_ERROR_NO_MEMORY;
  1377. return XML_STATUS_ERROR;
  1378. }
  1379. buffer = temp;
  1380. if (!buffer) {
  1381. errorCode = XML_ERROR_NO_MEMORY;
  1382. eventPtr = eventEndPtr = NULL;
  1383. processor = errorProcessor;
  1384. return XML_STATUS_ERROR;
  1385. }
  1386. bufferLim = buffer + len * 2;
  1387. }
  1388. memcpy(buffer, end, nLeftOver);
  1389. }
  1390. bufferPtr = buffer;
  1391. bufferEnd = buffer + nLeftOver;
  1392. positionPtr = bufferPtr;
  1393. parseEndPtr = bufferEnd;
  1394. eventPtr = bufferPtr;
  1395. eventEndPtr = bufferPtr;
  1396. return result;
  1397. }
  1398. #endif /* not defined XML_CONTEXT_BYTES */
  1399. else {
  1400. void *buff = XML_GetBuffer(parser, len);
  1401. if (buff == NULL)
  1402. return XML_STATUS_ERROR;
  1403. else {
  1404. memcpy(buff, s, len);
  1405. return XML_ParseBuffer(parser, len, isFinal);
  1406. }
  1407. }
  1408. }
  1409. enum XML_Status XMLCALL
  1410. XML_ParseBuffer(XML_Parser parser, int len, int isFinal)
  1411. {
  1412. const char *start;
  1413. enum XML_Status result = XML_STATUS_OK;
  1414. switch (ps_parsing) {
  1415. case XML_SUSPENDED:
  1416. errorCode = XML_ERROR_SUSPENDED;
  1417. return XML_STATUS_ERROR;
  1418. case XML_FINISHED:
  1419. errorCode = XML_ERROR_FINISHED;
  1420. return XML_STATUS_ERROR;
  1421. default:
  1422. ps_parsing = XML_PARSING;
  1423. }
  1424. start = bufferPtr;
  1425. positionPtr = start;
  1426. bufferEnd += len;
  1427. parseEndPtr = bufferEnd;
  1428. parseEndByteIndex += len;
  1429. ps_finalBuffer = (XML_Bool)isFinal;
  1430. errorCode = processor(parser, start, parseEndPtr, &bufferPtr);
  1431. if (errorCode != XML_ERROR_NONE) {
  1432. eventEndPtr = eventPtr;
  1433. processor = errorProcessor;
  1434. return XML_STATUS_ERROR;
  1435. }
  1436. else {
  1437. switch (ps_parsing) {
  1438. case XML_SUSPENDED:
  1439. result = XML_STATUS_SUSPENDED;
  1440. break;
  1441. case XML_INITIALIZED:
  1442. case XML_PARSING:
  1443. if (isFinal) {
  1444. ps_parsing = XML_FINISHED;
  1445. return result;
  1446. }
  1447. default: ; /* should not happen */
  1448. }
  1449. }
  1450. XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);
  1451. positionPtr = bufferPtr;
  1452. return result;
  1453. }
  1454. void * XMLCALL
  1455. XML_GetBuffer(XML_Parser parser, int len)
  1456. {
  1457. switch (ps_parsing) {
  1458. case XML_SUSPENDED:
  1459. errorCode = XML_ERROR_SUSPENDED;
  1460. return NULL;
  1461. case XML_FINISHED:
  1462. errorCode = XML_ERROR_FINISHED;
  1463. return NULL;
  1464. default: ;
  1465. }
  1466. if (len > bufferLim - bufferEnd) {
  1467. /* FIXME avoid integer overflow */
  1468. int neededSize = len + (int)(bufferEnd - bufferPtr);
  1469. #ifdef XML_CONTEXT_BYTES
  1470. int keep = (int)(bufferPtr - buffer);
  1471. if (keep > XML_CONTEXT_BYTES)
  1472. keep = XML_CONTEXT_BYTES;
  1473. neededSize += keep;
  1474. #endif /* defined XML_CONTEXT_BYTES */
  1475. if (neededSize <= bufferLim - buffer) {
  1476. #ifdef XML_CONTEXT_BYTES
  1477. if (keep < bufferPtr - buffer) {
  1478. int offset = (int)(bufferPtr - buffer) - keep;
  1479. memmove(buffer, &buffer[offset], bufferEnd - bufferPtr + keep);
  1480. bufferEnd -= offset;
  1481. bufferPtr -= offset;
  1482. }
  1483. #else
  1484. memmove(buffer, bufferPtr, bufferEnd - bufferPtr);
  1485. bufferEnd = buffer + (bufferEnd - bufferPtr);
  1486. bufferPtr = buffer;
  1487. #endif /* not defined XML_CONTEXT_BYTES */
  1488. }
  1489. else {
  1490. char *newBuf;
  1491. int bufferSize = (int)(bufferLim - bufferPtr);
  1492. if (bufferSize == 0)
  1493. bufferSize = INIT_BUFFER_SIZE;
  1494. do {
  1495. bufferSize *= 2;
  1496. } while (bufferSize < neededSize);
  1497. newBuf = (char *)MALLOC(bufferSize);
  1498. if (newBuf == 0) {
  1499. errorCode = XML_ERROR_NO_MEMORY;
  1500. return NULL;
  1501. }
  1502. bufferLim = newBuf + bufferSize;
  1503. #ifdef XML_CONTEXT_BYTES
  1504. if (bufferPtr) {
  1505. int keep = (int)(bufferPtr - buffer);
  1506. if (keep > XML_CONTEXT_BYTES)
  1507. keep = XML_CONTEXT_BYTES;
  1508. memcpy(newBuf, &bufferPtr[-keep], bufferEnd - bufferPtr + keep);
  1509. FREE(buffer);
  1510. buffer = newBuf;
  1511. bufferEnd = buffer + (bufferEnd - bufferPtr) + keep;
  1512. buffer