开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
HTMLparser.c
资源名称：rtsp-1.0.1.tar.gz　[点击查看]
上传用户：sy_wanhua
上传日期：2013-07-25
资源大小：3048k
文件大小：112k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

C/C++

HTMLparser.c：源码内容
  1. /*
  2.  * HTMLparser.c : an HTML 4.0 non-verifying parser
  3.  *
  4.  * See Copyright for the status of this software.
  5.  *
  6.  * Daniel.Veillard@w3.org
  7.  */
  9. #ifdef WIN32
  10. #include "win32config.h"
  11. #else
  12. #include "config.h"
  13. #endif
  15. #include "xmlversion.h"
  16. #ifdef LIBXML_HTML_ENABLED
  18. #include <stdio.h>
  19. #include <string.h> /* for memset() only */
  20. #ifdef HAVE_CTYPE_H
  21. #include <ctype.h>
  22. #endif
  23. #ifdef HAVE_STDLIB_H
  24. #include <stdlib.h>
  25. #endif
  26. #ifdef HAVE_SYS_STAT_H
  27. #include <sys/stat.h>
  28. #endif
  29. #ifdef HAVE_FCNTL_H
  30. #include <fcntl.h>
  31. #endif
  32. #ifdef HAVE_UNISTD_H
  33. #include <unistd.h>
  34. #endif
  35. #ifdef HAVE_ZLIB_H
  36. #include <zlib.h>
  37. #endif
  39. #include <libxml/xmlmemory.h>
  40. #include <libxml/tree.h>
  41. #include <libxml/HTMLparser.h>
  42. #include <libxml/entities.h>
  43. #include <libxml/encoding.h>
  44. #include <libxml/valid.h>
  45. #include <libxml/parserInternals.h>
  46. #include <libxml/xmlIO.h>
  47. #include "xml-error.h"
  49. #define HTML_MAX_NAMELEN 1000
  50. #define INPUT_CHUNK     50
  51. #define HTML_PARSER_BIG_BUFFER_SIZE 1024
  52. #define HTML_PARSER_BUFFER_SIZE 100
  54. /* #define DEBUG */
  55. /* #define DEBUG_PUSH */
  57. /************************************************************************
  58.  * *
  59.  *  Parser stacks related functions and macros *
  60.  * *
  61.  ************************************************************************/
  63. /*
  64.  * Generic function for accessing stacks in the Parser Context
  65.  */
  67. #define PUSH_AND_POP(scope, type, name)
  68. scope int html##name##Push(htmlParserCtxtPtr ctxt, type value) {
  69.     if (ctxt->name##Nr >= ctxt->name##Max) {
  70. ctxt->name##Max *= 2;
  71.         ctxt->name##Tab = (void *) xmlRealloc(ctxt->name##Tab,
  72.              ctxt->name##Max * sizeof(ctxt->name##Tab[0]));
  73.         if (ctxt->name##Tab == NULL) {
  74.     fprintf(stderr, "realloc failed !n");
  75.     return(0);
  76. }
  77.     }
  78.     ctxt->name##Tab[ctxt->name##Nr] = value;
  79.     ctxt->name = value;
  80.     return(ctxt->name##Nr++);
  81. }
  82. scope type html##name##Pop(htmlParserCtxtPtr ctxt) {
  83.     type ret;
  84.     if (ctxt->name##Nr < 0) return(0);
  85.     ctxt->name##Nr--;
  86.     if (ctxt->name##Nr < 0) return(0);
  87.     if (ctxt->name##Nr > 0)
  88. ctxt->name = ctxt->name##Tab[ctxt->name##Nr - 1];
  89.     else
  90.         ctxt->name = NULL;
  91.     ret = ctxt->name##Tab[ctxt->name##Nr];
  92.     ctxt->name##Tab[ctxt->name##Nr] = 0;
  93.     return(ret);
  94. }
  96. PUSH_AND_POP(extern, xmlNodePtr, node)
  97. PUSH_AND_POP(extern, xmlChar*, name)
  99. /*
  100.  * Macros for accessing the content. Those should be used only by the parser,
  101.  * and not exported.
  102.  *
  103.  * Dirty macros, i.e. one need to make assumption on the context to use them
  104.  *
  105.  *   CUR_PTR return the current pointer to the xmlChar to be parsed.
  106.  *   CUR     returns the current xmlChar value, i.e. a 8 bit value if compiled
  107.  *           in ISO-Latin or UTF-8, and the current 16 bit value if compiled
  108.  *           in UNICODE mode. This should be used internally by the parser
  109.  *           only to compare to ASCII values otherwise it would break when
  110.  *           running with UTF-8 encoding.
  111.  *   NXT(n)  returns the n'th next xmlChar. Same as CUR is should be used only
  112.  *           to compare on ASCII based substring.
  113.  *   UPP(n)  returns the n'th next xmlChar converted to uppercase. Same as CUR
  114.  *           it should be used only to compare on ASCII based substring.
  115.  *   SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined
  116.  *           strings within the parser.
  117.  *
  118.  * Clean macros, not dependent of an ASCII context, expect UTF-8 encoding
  119.  *
  120.  *   CURRENT Returns the current char value, with the full decoding of
  121.  *           UTF-8 if we are using this mode. It returns an int.
  122.  *   NEXT    Skip to the next character, this does the proper decoding
  123.  *           in UTF-8 mode. It also pop-up unfinished entities on the fly.
  124.  *   COPY(to) copy one char to *to, increment CUR_PTR and to accordingly
  125.  */
  127. #define CUR ((int) (*ctxt->input->cur))
  128.     
  129. #define UPPER (toupper(*ctxt->input->cur))
  131. #define SKIP(val) ctxt->nbChars += (val),ctxt->input->cur += (val)
  133. #define NXT(val) ctxt->input->cur[(val)]
  135. #define UPP(val) (toupper(ctxt->input->cur[(val)]))
  137. #define CUR_PTR ctxt->input->cur
  139. #define SHRINK  xmlParserInputShrink(ctxt->input)
  141. #define GROW  xmlParserInputGrow(ctxt->input, INPUT_CHUNK)
  143. #define CURRENT ((int) (*ctxt->input->cur))
  145. #define NEXT htmlNextChar(ctxt);
  147. #define SKIP_BLANKS htmlSkipBlankChars(ctxt);
  149. /**
  150.  * htmlNextChar:
  151.  * @ctxt:  the HTML parser context
  152.  *
  153.  * Skip to the next char input char.
  154.  */
  156. void
  157. htmlNextChar(htmlParserCtxtPtr ctxt) {
  158.     if ((*ctxt->input->cur == 0) &&
  159.         (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) {
  160.     xmlPopInput(ctxt);
  161.     } else {
  162.         if (*(ctxt->input->cur) == 'n') {
  163.     ctxt->input->line++; ctxt->input->col = 1;
  164. } else ctxt->input->col++;
  165. ctxt->input->cur++;
  166. ctxt->nbChars++;
  167.         if (*ctxt->input->cur == 0)
  168.     xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
  169.     }
  170. }
  172. /**
  173.  * htmlSkipBlankChars:
  174.  * @ctxt:  the HTML parser context
  175.  *
  176.  * skip all blanks character found at that point in the input streams.
  177.  *
  178.  * Returns the number of space chars skipped
  179.  */
  181. int
  182. htmlSkipBlankChars(xmlParserCtxtPtr ctxt) {
  183.     int res = 0;
  185.     while (IS_BLANK(*(ctxt->input->cur))) {
  186. if ((*ctxt->input->cur == 0) &&
  187.     (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) {
  188. xmlPopInput(ctxt);
  189. } else {
  190.     if (*(ctxt->input->cur) == 'n') {
  191. ctxt->input->line++; ctxt->input->col = 1;
  192.     } else ctxt->input->col++;
  193.     ctxt->input->cur++;
  194.     ctxt->nbChars++;
  195.     if (*ctxt->input->cur == 0)
  196. xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
  197. }
  198. res++;
  199.     }
  200.     return(res);
  201. }
  205. /************************************************************************
  206.  * *
  207.  *  The list of HTML elements and their properties *
  208.  * *
  209.  ************************************************************************/
  211. /*
  212.  *  Start Tag: 1 means the start tag can be ommited
  213.  *  End Tag:   1 means the end tag can be ommited
  214.  *             2 means it's forbidden (empty elements)
  215.  *  Depr:      this element is deprecated
  216.  *  DTD:       1 means that this element is valid only in the Loose DTD
  217.  *             2 means that this element is valid only in the Frameset DTD
  218.  *
  219.  * Name,Start Tag,End Tag,  Empty,  Depr.,    DTD, Description
  220.  */
  221. htmlElemDesc  html40ElementTable[] = {
  222. { "a", 0, 0, 0, 0, 0, "anchor " },
  223. { "abbr", 0, 0, 0, 0, 0, "abbreviated form" },
  224. { "acronym", 0, 0, 0, 0, 0, "" },
  225. { "address", 0, 0, 0, 0, 0, "information on author " },
  226. { "applet", 0, 0, 0, 1, 1, "java applet " },
  227. { "area", 0, 2, 1, 0, 0, "client-side image map area " },
  228. { "b", 0, 0, 0, 0, 0, "bold text style" },
  229. { "base", 0, 2, 1, 0, 0, "document base uri " },
  230. { "basefont", 0, 2, 1, 1, 1, "base font size " },
  231. { "bdo", 0, 0, 0, 0, 0, "i18n bidi over-ride " },
  232. { "big", 0, 0, 0, 0, 0, "large text style" },
  233. { "blockquote", 0, 0, 0, 0, 0, "long quotation " },
  234. { "body", 1, 1, 0, 0, 0, "document body " },
  235. { "br", 0, 2, 1, 0, 0, "forced line break " },
  236. { "button", 0, 0, 0, 0, 0, "push button " },
  237. { "caption", 0, 0, 0, 0, 0, "table caption " },
  238. { "center", 0, 0, 0, 1, 1, "shorthand for div align=center " },
  239. { "cite", 0, 0, 0, 0, 0, "citation" },
  240. { "code", 0, 0, 0, 0, 0, "computer code fragment" },
  241. { "col", 0, 2, 1, 0, 0, "table column " },
  242. { "colgroup", 0, 1, 0, 0, 0, "table column group " },
  243. { "dd", 0, 1, 0, 0, 0, "definition description " },
  244. { "del", 0, 0, 0, 0, 0, "deleted text " },
  245. { "dfn", 0, 0, 0, 0, 0, "instance definition" },
  246. { "dir", 0, 0, 0, 1, 1, "directory list" },
  247. { "div", 0, 0, 0, 0, 0, "generic language/style container"},
  248. { "dl", 0, 0, 0, 0, 0, "definition list " },
  249. { "dt", 0, 1, 0, 0, 0, "definition term " },
  250. { "em", 0, 0, 0, 0, 0, "emphasis" },
  251. { "fieldset", 0, 0, 0, 0, 0, "form control group " },
  252. { "font", 0, 0, 0, 1, 1, "local change to font " },
  253. { "form", 0, 0, 0, 0, 0, "interactive form " },
  254. { "frame", 0, 2, 1, 0, 2, "subwindow " },
  255. { "frameset", 0, 0, 0, 0, 2, "window subdivision" },
  256. { "h1", 0, 0, 0, 0, 0, "heading " },
  257. { "h2", 0, 0, 0, 0, 0, "heading " },
  258. { "h3", 0, 0, 0, 0, 0, "heading " },
  259. { "h4", 0, 0, 0, 0, 0, "heading " },
  260. { "h5", 0, 0, 0, 0, 0, "heading " },
  261. { "h6", 0, 0, 0, 0, 0, "heading " },
  262. { "head", 1, 1, 0, 0, 0, "document head " },
  263. { "hr", 0, 2, 1, 0, 0, "horizontal rule " },
  264. { "html", 1, 1, 0, 0, 0, "document root element " },
  265. { "i", 0, 0, 0, 0, 0, "italic text style" },
  266. { "iframe", 0, 0, 0, 0, 1, "inline subwindow " },
  267. { "img", 0, 2, 1, 0, 0, "embedded image " },
  268. { "input", 0, 2, 1, 0, 0, "form control " },
  269. { "ins", 0, 0, 0, 0, 0, "inserted text" },
  270. { "isindex", 0, 2, 1, 1, 1, "single line prompt " },
  271. { "kbd", 0, 0, 0, 0, 0, "text to be entered by the user" },
  272. { "label", 0, 0, 0, 0, 0, "form field label text " },
  273. { "legend", 0, 0, 0, 0, 0, "fieldset legend " },
  274. { "li", 0, 1, 0, 0, 0, "list item " },
  275. { "link", 0, 2, 1, 0, 0, "a media-independent link " },
  276. { "map", 0, 0, 0, 0, 0, "client-side image map " },
  277. { "menu", 0, 0, 0, 1, 1, "menu list " },
  278. { "meta", 0, 2, 1, 0, 0, "generic metainformation " },
  279. { "noframes", 0, 0, 0, 0, 2, "alternate content container for non frame-based rendering " },
  280. { "noscript", 0, 0, 0, 0, 0, "alternate content container for non script-based rendering " },
  281. { "object", 0, 0, 0, 0, 0, "generic embedded object " },
  282. { "ol", 0, 0, 0, 0, 0, "ordered list " },
  283. { "optgroup", 0, 0, 0, 0, 0, "option group " },
  284. { "option", 0, 1, 0, 0, 0, "selectable choice " },
  285. { "p", 0, 1, 0, 0, 0, "paragraph " },
  286. { "param", 0, 2, 1, 0, 0, "named property value " },
  287. { "pre", 0, 0, 0, 0, 0, "preformatted text " },
  288. { "q", 0, 0, 0, 0, 0, "short inline quotation " },
  289. { "s", 0, 0, 0, 1, 1, "strike-through text style" },
  290. { "samp", 0, 0, 0, 0, 0, "sample program output, scripts, etc." },
  291. { "script", 0, 0, 0, 0, 0, "script statements " },
  292. { "select", 0, 0, 0, 0, 0, "option selector " },
  293. { "small", 0, 0, 0, 0, 0, "small text style" },
  294. { "span", 0, 0, 0, 0, 0, "generic language/style container " },
  295. { "strike", 0, 0, 0, 1, 1, "strike-through text" },
  296. { "strong", 0, 0, 0, 0, 0, "strong emphasis" },
  297. { "style", 0, 0, 0, 0, 0, "style info " },
  298. { "sub", 0, 0, 0, 0, 0, "subscript" },
  299. { "sup", 0, 0, 0, 0, 0, "superscript " },
  300. { "table", 0, 0, 0, 0, 0, "&#160;" },
  301. { "tbody", 1, 1, 0, 0, 0, "table body " },
  302. { "td", 0, 1, 0, 0, 0, "table data cell" },
  303. { "textarea", 0, 0, 0, 0, 0, "multi-line text field " },
  304. { "tfoot", 0, 1, 0, 0, 0, "table footer " },
  305. { "th", 0, 1, 0, 0, 0, "table header cell" },
  306. { "thead", 0, 1, 0, 0, 0, "table header " },
  307. { "title", 0, 0, 0, 0, 0, "document title " },
  308. { "tr", 0, 1, 0, 0, 0, "table row " },
  309. { "tt", 0, 0, 0, 0, 0, "teletype or monospaced text style" },
  310. { "u", 0, 0, 0, 1, 1, "underlined text style" },
  311. { "ul", 0, 0, 0, 0, 0, "unordered list " },
  312. { "var", 0, 0, 0, 0, 0, "instance of a variable or program argument" },
  313. };
  315. /*
  316.  * start tags that imply the end of a current element
  317.  * any tag of each line implies the end of the current element if the type of
  318.  * that element is in the same line
  319.  */
  320. char *htmlEquEnd[] = {
  321. "dt", "dd", "li", "option", NULL,
  322. "h1", "h2", "h3", "h4", "h5", "h6", NULL,
  323. "ol", "menu", "dir", "address", "pre", "listing", "xmp", NULL,
  324. NULL
  325. };
  326. /*
  327.  * acording the HTML DTD, HR should be added to the 2nd line above, as it
  328.  * is not allowed within a H1, H2, H3, etc. But we should tolerate that case
  329.  * because many documents contain rules in headings...
  330.  */
  332. /*
  333.  * start tags that imply the end of current element
  334.  */
  335. char *htmlStartClose[] = {
  336. "form", "form", "p", "hr", "h1", "h2", "h3", "h4", "h5", "h6",
  337. "dl", "ul", "ol", "menu", "dir", "address", "pre",
  338. "listing", "xmp", "head", NULL,
  339. "head", "p", NULL,
  340. "title", "p", NULL,
  341. "body", "head", "style", "link", "title", "p", NULL,
  342. "li", "p", "h1", "h2", "h3", "h4", "h5", "h6", "dl", "address",
  343. "pre", "listing", "xmp", "head", "li", NULL,
  344. "hr", "p", "head", NULL,
  345. "h1", "p", "head", NULL,
  346. "h2", "p", "head", NULL,
  347. "h3", "p", "head", NULL,
  348. "h4", "p", "head", NULL,
  349. "h5", "p", "head", NULL,
  350. "h6", "p", "head", NULL,
  351. "dir", "p", "head", NULL,
  352. "address", "p", "head", "ul", NULL,
  353. "pre", "p", "head", "ul", NULL,
  354. "listing", "p", "head", NULL,
  355. "xmp", "p", "head", NULL,
  356. "blockquote", "p", "head", NULL,
  357. "dl", "p", "dt", "menu", "dir", "address", "pre", "listing",
  358. "xmp", "head", NULL,
  359. "dt", "p", "menu", "dir", "address", "pre", "listing", "xmp",
  360.                 "head", "dd", NULL,
  361. "dd", "p", "menu", "dir", "address", "pre", "listing", "xmp",
  362.                 "head", "dt", NULL,
  363. "ul", "p", "head", "ol", "menu", "dir", "address", "pre",
  364. "listing", "xmp", NULL,
  365. "ol", "p", "head", "ul", NULL,
  366. "menu", "p", "head", "ul", NULL,
  367. "p", "p", "head", "h1", "h2", "h3", "h4", "h5", "h6", NULL,
  368. "div", "p", "head", NULL,
  369. "noscript", "p", "head", NULL,
  370. "center", "font", "b", "i", "p", "head", NULL,
  371. "a", "a", NULL,
  372. "caption", "p", NULL,
  373. "colgroup", "caption", "colgroup", "col", "p", NULL,
  374. "col", "caption", "col", "p", NULL,
  375. "table", "p", "head", "h1", "h2", "h3", "h4", "h5", "h6", "pre",
  376. "listing", "xmp", "a", NULL,
  377. "th", "th", "td", NULL,
  378. "td", "th", "td", "p", NULL,
  379. "tr", "th", "td", "tr", "caption", "col", "colgroup", "p", NULL,
  380. "thead", "caption", "col", "colgroup", NULL,
  381. "tfoot", "th", "td", "tr", "caption", "col", "colgroup", "thead",
  382. "tbody", "p", NULL,
  383. "tbody", "th", "td", "tr", "caption", "col", "colgroup", "thead",
  384. "tfoot", "tbody", "p", NULL,
  385. "optgroup", "option", NULL,
  386. "fieldset", "legend", "p", "head", "h1", "h2", "h3", "h4", "h5", "h6",
  387. "pre", "listing", "xmp", "a", NULL,
  388. NULL
  389. };
  391. static char** htmlStartCloseIndex[100];
  392. static int htmlStartCloseIndexinitialized = 0;
  394. /************************************************************************
  395.  * *
  396.  *  functions to handle HTML specific data *
  397.  * *
  398.  ************************************************************************/
  400. /**
  401.  * htmlInitAutoClose:
  402.  *
  403.  * Initialize the htmlStartCloseIndex for fast lookup of closing tags names.
  404.  *
  405.  */
  406. void
  407. htmlInitAutoClose(void) {
  408.     int index, i = 0;
  410.     if (htmlStartCloseIndexinitialized) return;
  412.     for (index = 0;index < 100;index ++) htmlStartCloseIndex[index] = NULL;
  413.     index = 0;
  414.     while ((htmlStartClose[i] != NULL) && (index < 100 - 1)) {
  415.         htmlStartCloseIndex[index++] = &htmlStartClose[i];
  416. while (htmlStartClose[i] != NULL) i++;
  417. i++;
  418.     }
  419. }
  421. /**
  422.  * htmlTagLookup:
  423.  * @tag:  The tag name
  424.  *
  425.  * Lookup the HTML tag in the ElementTable
  426.  *
  427.  * Returns the related htmlElemDescPtr or NULL if not found.
  428.  */
  429. htmlElemDescPtr
  430. htmlTagLookup(const xmlChar *tag) {
  431.     int i = 0;
  433.     for (i = 0; i < (sizeof(html40ElementTable) /
  434.                      sizeof(html40ElementTable[0]));i++) {
  435.         if (!xmlStrcmp(tag, BAD_CAST html40ElementTable[i].name))
  436.     return(&html40ElementTable[i]);
  437.     }
  438.     return(NULL);
  439. }
  441. /**
  442.  * htmlCheckAutoClose:
  443.  * @new:  The new tag name
  444.  * @old:  The old tag name
  445.  *
  446.  * Checks wether the new tag is one of the registered valid tags for closing old.
  447.  * Initialize the htmlStartCloseIndex for fast lookup of closing tags names.
  448.  *
  449.  * Returns 0 if no, 1 if yes.
  450.  */
  451. int
  452. htmlCheckAutoClose(const xmlChar *new, const xmlChar *old) {
  453.     int i, index;
  454.     char **close;
  456.     if (htmlStartCloseIndexinitialized == 0) htmlInitAutoClose();
  458.     /* inefficient, but not a big deal */
  459.     for (index = 0; index < 100;index++) {
  460.         close = htmlStartCloseIndex[index];
  461. if (close == NULL) return(0);
  462. if (!xmlStrcmp(BAD_CAST *close, new)) break;
  463.     }
  465.     i = close - htmlStartClose;
  466.     i++;
  467.     while (htmlStartClose[i] != NULL) {
  468.         if (!xmlStrcmp(BAD_CAST htmlStartClose[i], old)) {
  469.     return(1);
  470. }
  471. i++;
  472.     }
  473.     return(0);
  474. }
  476. /**
  477.  * htmlAutoClose:
  478.  * @ctxt:  an HTML parser context
  479.  * @new:  The new tag name
  480.  *
  481.  * The HTmL DtD allows a tag to implicitely close other tags.
  482.  * The list is kept in htmlStartClose array. This function is
  483.  * called when a new tag has been detected and generates the
  484.  * appropriates closes if possible/needed.
  485.  */
  486. void
  487. htmlAutoClose(htmlParserCtxtPtr ctxt, const xmlChar *new) {
  488.     xmlChar *oldname;
  489.     while ((ctxt->name != NULL) && 
  490.            (htmlCheckAutoClose(new, ctxt->name))) {
  491. #ifdef DEBUG
  492. fprintf(stderr,"htmlAutoClose: %s closes %sn", new, ctxt->name);
  493. #endif
  494. if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
  495.     ctxt->sax->endElement(ctxt->userData, ctxt->name);
  496. oldname = htmlnamePop(ctxt);
  497. if (oldname != NULL) {
  498. #ifdef DEBUG
  499.     fprintf(stderr,"htmlAutoClose: popped %sn", oldname);
  500. #endif
  501.     xmlFree(oldname);
  502.         }
  503.     }
  504. }
  506. /**
  507.  * htmlAutoCloseTag:
  508.  * @doc:  the HTML document
  509.  * @name:  The tag name
  510.  * @elem:  the HTML element
  511.  *
  512.  * The HTmL DtD allows a tag to implicitely close other tags.
  513.  * The list is kept in htmlStartClose array. This function checks
  514.  * if the element or one of it's children would autoclose the
  515.  * given tag.
  516.  *
  517.  * Returns 1 if autoclose, 0 otherwise
  518.  */
  519. int
  520. htmlAutoCloseTag(htmlDocPtr doc, const xmlChar *name, htmlNodePtr elem) {
  521.     htmlNodePtr child;
  523.     if (elem == NULL) return(1);
  524.     if (!xmlStrcmp(name, elem->name)) return(0);
  525.     if (htmlCheckAutoClose(elem->name, name)) return(1);
  526.     child = elem->children;
  527.     while (child != NULL) {
  528.         if (htmlAutoCloseTag(doc, name, child)) return(1);
  529. child = child->next;
  530.     }
  531.     return(0);
  532. }
  534. /**
  535.  * htmlIsAutoClosed:
  536.  * @doc:  the HTML document
  537.  * @elem:  the HTML element
  538.  *
  539.  * The HTmL DtD allows a tag to implicitely close other tags.
  540.  * The list is kept in htmlStartClose array. This function checks
  541.  * if a tag is autoclosed by one of it's child
  542.  *
  543.  * Returns 1 if autoclosed, 0 otherwise
  544.  */
  545. int
  546. htmlIsAutoClosed(htmlDocPtr doc, htmlNodePtr elem) {
  547.     htmlNodePtr child;
  549.     if (elem == NULL) return(1);
  550.     child = elem->children;
  551.     while (child != NULL) {
  552. if (htmlAutoCloseTag(doc, elem->name, child)) return(1);
  553. child = child->next;
  554.     }
  555.     return(0);
  556. }
  558. /**
  559.  * htmlAutoCloseOnClose:
  560.  * @ctxt:  an HTML parser context
  561.  * @new:  The new tag name
  562.  *
  563.  * The HTmL DtD allows an ending tag to implicitely close other tags.
  564.  */
  565. void
  566. htmlAutoCloseOnClose(htmlParserCtxtPtr ctxt, const xmlChar *new) {
  567.     htmlElemDescPtr info;
  568.     xmlChar *oldname;
  569.     int i;
  571. #ifdef DEBUG
  572.     fprintf(stderr,"Close of %s stack: %d elementsn", new, ctxt->nameNr);
  573.     for (i = 0;i < ctxt->nameNr;i++) 
  574.         fprintf(stderr,"%d : %sn", i, ctxt->nameTab[i]);
  575. #endif
  577.     for (i = (ctxt->nameNr - 1);i >= 0;i--) {
  578.         if (!xmlStrcmp(new, ctxt->nameTab[i])) break;
  579.     }
  580.     if (i < 0) return;
  582.     while (xmlStrcmp(new, ctxt->name)) {
  583. info = htmlTagLookup(ctxt->name);
  584. if ((info == NULL) || (info->endTag == 1)) {
  585. #ifdef DEBUG
  586.     fprintf(stderr,"htmlAutoCloseOnClose: %s closes %sn", new, ctxt->name);
  587. #endif
  588.         } else {
  589.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  590. ctxt->sax->error(ctxt->userData,
  591.  "Opening and ending tag mismatch: %s and %sn",
  592.                  new, ctxt->name);
  593.     ctxt->wellFormed = 0;
  594. }
  595. if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
  596.     ctxt->sax->endElement(ctxt->userData, ctxt->name);
  597. oldname = htmlnamePop(ctxt);
  598. if (oldname != NULL) {
  599. #ifdef DEBUG
  600.     fprintf(stderr,"htmlAutoCloseOnClose: popped %sn", oldname);
  601. #endif
  602.     xmlFree(oldname);
  603. }
  604.     }
  605. }
  607. /************************************************************************
  608.  * *
  609.  *  The list of HTML predefined entities *
  610.  * *
  611.  ************************************************************************/
  614. htmlEntityDesc  html40EntitiesTable[] = {
  615. /*
  616.  * the 4 absolute ones,
  617.  */
  618. { 34, "quot", "quotation mark = APL quote, U+0022 ISOnum" },
  619. { 38, "amp", "ampersand, U+0026 ISOnum" },
  620. { 60, "lt", "less-than sign, U+003C ISOnum" },
  621. { 62, "gt", "greater-than sign, U+003E ISOnum" },
  623. /*
  624.  * A bunch still in the 128-255 range
  625.  * Replacing them depend really on the charset used.
  626.  */
  627. { 39, "apos", "single quote" },
  628. { 160, "nbsp", "no-break space = non-breaking space, U+00A0 ISOnum" },
  629. { 161, "iexcl","inverted exclamation mark, U+00A1 ISOnum" },
  630. { 162, "cent", "cent sign, U+00A2 ISOnum" },
  631. { 163, "pound","pound sign, U+00A3 ISOnum" },
  632. { 164, "curren","currency sign, U+00A4 ISOnum" },
  633. { 165, "yen", "yen sign = yuan sign, U+00A5 ISOnum" },
  634. { 166, "brvbar","broken bar = broken vertical bar, U+00A6 ISOnum" },
  635. { 167, "sect", "section sign, U+00A7 ISOnum" },
  636. { 168, "uml", "diaeresis = spacing diaeresis, U+00A8 ISOdia" },
  637. { 169, "copy", "copyright sign, U+00A9 ISOnum" },
  638. { 170, "ordf", "feminine ordinal indicator, U+00AA ISOnum" },
  639. { 171, "laquo","left-pointing double angle quotation mark = left pointing guillemet, U+00AB ISOnum" },
  640. { 172, "not", "not sign, U+00AC ISOnum" },
  641. { 173, "shy", "soft hyphen = discretionary hyphen, U+00AD ISOnum" },
  642. { 174, "reg", "registered sign = registered trade mark sign, U+00AE ISOnum" },
  643. { 175, "macr", "macron = spacing macron = overline = APL overbar, U+00AF ISOdia" },
  644. { 176, "deg", "degree sign, U+00B0 ISOnum" },
  645. { 177, "plusmn","plus-minus sign = plus-or-minus sign, U+00B1 ISOnum" },
  646. { 178, "sup2", "superscript two = superscript digit two = squared, U+00B2 ISOnum" },
  647. { 179, "sup3", "superscript three = superscript digit three = cubed, U+00B3 ISOnum" },
  648. { 180, "acute","acute accent = spacing acute, U+00B4 ISOdia" },
  649. { 181, "micro","micro sign, U+00B5 ISOnum" },
  650. { 182, "para", "pilcrow sign = paragraph sign, U+00B6 ISOnum" },
  651. { 183, "middot","middle dot = Georgian comma Greek middle dot, U+00B7 ISOnum" },
  652. { 184, "cedil","cedilla = spacing cedilla, U+00B8 ISOdia" },
  653. { 185, "sup1", "superscript one = superscript digit one, U+00B9 ISOnum" },
  654. { 186, "ordm", "masculine ordinal indicator, U+00BA ISOnum" },
  655. { 187, "raquo","right-pointing double angle quotation mark right pointing guillemet, U+00BB ISOnum" },
  656. { 188, "frac14","vulgar fraction one quarter = fraction one quarter, U+00BC ISOnum" },
  657. { 189, "frac12","vulgar fraction one half = fraction one half, U+00BD ISOnum" },
  658. { 190, "frac34","vulgar fraction three quarters = fraction three quarters, U+00BE ISOnum" },
  659. { 191, "iquest","inverted question mark = turned question mark, U+00BF ISOnum" },
  660. { 192, "Agrave","latin capital letter A with grave = latin capital letter A grave, U+00C0 ISOlat1" },
  661. { 193, "Aacute","latin capital letter A with acute, U+00C1 ISOlat1" },
  662. { 194, "Acirc","latin capital letter A with circumflex, U+00C2 ISOlat1" },
  663. { 195, "Atilde","latin capital letter A with tilde, U+00C3 ISOlat1" },
  664. { 196, "Auml", "latin capital letter A with diaeresis, U+00C4 ISOlat1" },
  665. { 197, "Aring","latin capital letter A with ring above = latin capital letter A ring, U+00C5 ISOlat1" },
  666. { 198, "AElig","latin capital letter AE = latin capital ligature AE, U+00C6 ISOlat1" },
  667. { 199, "Ccedil","latin capital letter C with cedilla, U+00C7 ISOlat1" },
  668. { 200, "Egrave","latin capital letter E with grave, U+00C8 ISOlat1" },
  669. { 201, "Eacute","latin capital letter E with acute, U+00C9 ISOlat1" },
  670. { 202, "Ecirc","latin capital letter E with circumflex, U+00CA ISOlat1" },
  671. { 203, "Euml", "latin capital letter E with diaeresis, U+00CB ISOlat1" },
  672. { 204, "Igrave","latin capital letter I with grave, U+00CC ISOlat1" },
  673. { 205, "Iacute","latin capital letter I with acute, U+00CD ISOlat1" },
  674. { 206, "Icirc","latin capital letter I with circumflex, U+00CE ISOlat1" },
  675. { 207, "Iuml", "latin capital letter I with diaeresis, U+00CF ISOlat1" },
  676. { 208, "ETH", "latin capital letter ETH, U+00D0 ISOlat1" },
  677. { 209, "Ntilde","latin capital letter N with tilde, U+00D1 ISOlat1" },
  678. { 210, "Ograve","latin capital letter O with grave, U+00D2 ISOlat1" },
  679. { 211, "Oacute","latin capital letter O with acute, U+00D3 ISOlat1" },
  680. { 212, "Ocirc","latin capital letter O with circumflex, U+00D4 ISOlat1" },
  681. { 213, "Otilde","latin capital letter O with tilde, U+00D5 ISOlat1" },
  682. { 214, "Ouml", "latin capital letter O with diaeresis, U+00D6 ISOlat1" },
  683. { 215, "times","multiplication sign, U+00D7 ISOnum" },
  684. { 216, "Oslash","latin capital letter O with stroke latin capital letter O slash, U+00D8 ISOlat1" },
  685. { 217, "Ugrave","latin capital letter U with grave, U+00D9 ISOlat1" },
  686. { 218, "Uacute","latin capital letter U with acute, U+00DA ISOlat1" },
  687. { 219, "Ucirc","latin capital letter U with circumflex, U+00DB ISOlat1" },
  688. { 220, "Uuml", "latin capital letter U with diaeresis, U+00DC ISOlat1" },
  689. { 221, "Yacute","latin capital letter Y with acute, U+00DD ISOlat1" },
  690. { 222, "THORN","latin capital letter THORN, U+00DE ISOlat1" },
  691. { 223, "szlig","latin small letter sharp s = ess-zed, U+00DF ISOlat1" },
  692. { 224, "agrave","latin small letter a with grave = latin small letter a grave, U+00E0 ISOlat1" },
  693. { 225, "aacute","latin small letter a with acute, U+00E1 ISOlat1" },
  694. { 226, "acirc","latin small letter a with circumflex, U+00E2 ISOlat1" },
  695. { 227, "atilde","latin small letter a with tilde, U+00E3 ISOlat1" },
  696. { 228, "auml", "latin small letter a with diaeresis, U+00E4 ISOlat1" },
  697. { 229, "aring","latin small letter a with ring above = latin small letter a ring, U+00E5 ISOlat1" },
  698. { 230, "aelig","latin small letter ae = latin small ligature ae, U+00E6 ISOlat1" },
  699. { 231, "ccedil","latin small letter c with cedilla, U+00E7 ISOlat1" },
  700. { 232, "egrave","latin small letter e with grave, U+00E8 ISOlat1" },
  701. { 233, "eacute","latin small letter e with acute, U+00E9 ISOlat1" },
  702. { 234, "ecirc","latin small letter e with circumflex, U+00EA ISOlat1" },
  703. { 235, "euml", "latin small letter e with diaeresis, U+00EB ISOlat1" },
  704. { 236, "igrave","latin small letter i with grave, U+00EC ISOlat1" },
  705. { 237, "iacute","latin small letter i with acute, U+00ED ISOlat1" },
  706. { 238, "icirc","latin small letter i with circumflex, U+00EE ISOlat1" },
  707. { 239, "iuml", "latin small letter i with diaeresis, U+00EF ISOlat1" },
  708. { 240, "eth", "latin small letter eth, U+00F0 ISOlat1" },
  709. { 241, "ntilde","latin small letter n with tilde, U+00F1 ISOlat1" },
  710. { 242, "ograve","latin small letter o with grave, U+00F2 ISOlat1" },
  711. { 243, "oacute","latin small letter o with acute, U+00F3 ISOlat1" },
  712. { 244, "ocirc","latin small letter o with circumflex, U+00F4 ISOlat1" },
  713. { 245, "otilde","latin small letter o with tilde, U+00F5 ISOlat1" },
  714. { 246, "ouml", "latin small letter o with diaeresis, U+00F6 ISOlat1" },
  715. { 247, "divide","division sign, U+00F7 ISOnum" },
  716. { 248, "oslash","latin small letter o with stroke, = latin small letter o slash, U+00F8 ISOlat1" },
  717. { 249, "ugrave","latin small letter u with grave, U+00F9 ISOlat1" },
  718. { 250, "uacute","latin small letter u with acute, U+00FA ISOlat1" },
  719. { 251, "ucirc","latin small letter u with circumflex, U+00FB ISOlat1" },
  720. { 252, "uuml", "latin small letter u with diaeresis, U+00FC ISOlat1" },
  721. { 253, "yacute","latin small letter y with acute, U+00FD ISOlat1" },
  722. { 254, "thorn","latin small letter thorn with, U+00FE ISOlat1" },
  723. { 255, "yuml", "latin small letter y with diaeresis, U+00FF ISOlat1" },
  725. /*
  726.  * Anything below should really be kept as entities references
  727.  */
  728. { 402, "fnof", "latin small f with hook = function = florin, U+0192 ISOtech" },
  730. { 913, "Alpha","greek capital letter alpha, U+0391" },
  731. { 914, "Beta", "greek capital letter beta, U+0392" },
  732. { 915, "Gamma","greek capital letter gamma, U+0393 ISOgrk3" },
  733. { 916, "Delta","greek capital letter delta, U+0394 ISOgrk3" },
  734. { 917, "Epsilon","greek capital letter epsilon, U+0395" },
  735. { 918, "Zeta", "greek capital letter zeta, U+0396" },
  736. { 919, "Eta", "greek capital letter eta, U+0397" },
  737. { 920, "Theta","greek capital letter theta, U+0398 ISOgrk3" },
  738. { 921, "Iota", "greek capital letter iota, U+0399" },
  739. { 922, "Kappa","greek capital letter kappa, U+039A" },
  740. { 923, "Lambda""greek capital letter lambda, U+039B ISOgrk3" },
  741. { 924, "Mu", "greek capital letter mu, U+039C" },
  742. { 925, "Nu", "greek capital letter nu, U+039D" },
  743. { 926, "Xi", "greek capital letter xi, U+039E ISOgrk3" },
  744. { 927, "Omicron","greek capital letter omicron, U+039F" },
  745. { 928, "Pi", "greek capital letter pi, U+03A0 ISOgrk3" },
  746. { 929, "Rho", "greek capital letter rho, U+03A1" },
  747. { 931, "Sigma","greek capital letter sigma, U+03A3 ISOgrk3" },
  748. { 932, "Tau", "greek capital letter tau, U+03A4" },
  749. { 933, "Upsilon","greek capital letter upsilon, U+03A5 ISOgrk3" },
  750. { 934, "Phi", "greek capital letter phi, U+03A6 ISOgrk3" },
  751. { 935, "Chi", "greek capital letter chi, U+03A7" },
  752. { 936, "Psi", "greek capital letter psi, U+03A8 ISOgrk3" },
  753. { 937, "Omega","greek capital letter omega, U+03A9 ISOgrk3" },
  755. { 945, "alpha","greek small letter alpha, U+03B1 ISOgrk3" },
  756. { 946, "beta", "greek small letter beta, U+03B2 ISOgrk3" },
  757. { 947, "gamma","greek small letter gamma, U+03B3 ISOgrk3" },
  758. { 948, "delta","greek small letter delta, U+03B4 ISOgrk3" },
  759. { 949, "epsilon","greek small letter epsilon, U+03B5 ISOgrk3" },
  760. { 950, "zeta", "greek small letter zeta, U+03B6 ISOgrk3" },
  761. { 951, "eta", "greek small letter eta, U+03B7 ISOgrk3" },
  762. { 952, "theta","greek small letter theta, U+03B8 ISOgrk3" },
  763. { 953, "iota", "greek small letter iota, U+03B9 ISOgrk3" },
  764. { 954, "kappa","greek small letter kappa, U+03BA ISOgrk3" },
  765. { 955, "lambda","greek small letter lambda, U+03BB ISOgrk3" },
  766. { 956, "mu", "greek small letter mu, U+03BC ISOgrk3" },
  767. { 957, "nu", "greek small letter nu, U+03BD ISOgrk3" },
  768. { 958, "xi", "greek small letter xi, U+03BE ISOgrk3" },
  769. { 959, "omicron","greek small letter omicron, U+03BF NEW" },
  770. { 960, "pi", "greek small letter pi, U+03C0 ISOgrk3" },
  771. { 961, "rho", "greek small letter rho, U+03C1 ISOgrk3" },
  772. { 962, "sigmaf","greek small letter final sigma, U+03C2 ISOgrk3" },
  773. { 963, "sigma","greek small letter sigma, U+03C3 ISOgrk3" },
  774. { 964, "tau", "greek small letter tau, U+03C4 ISOgrk3" },
  775. { 965, "upsilon","greek small letter upsilon, U+03C5 ISOgrk3" },
  776. { 966, "phi", "greek small letter phi, U+03C6 ISOgrk3" },
  777. { 967, "chi", "greek small letter chi, U+03C7 ISOgrk3" },
  778. { 968, "psi", "greek small letter psi, U+03C8 ISOgrk3" },
  779. { 969, "omega","greek small letter omega, U+03C9 ISOgrk3" },
  780. { 977, "thetasym","greek small letter theta symbol, U+03D1 NEW" },
  781. { 978, "upsih","greek upsilon with hook symbol, U+03D2 NEW" },
  782. { 982, "piv", "greek pi symbol, U+03D6 ISOgrk3" },
  784. { 8226, "bull", "bullet = black small circle, U+2022 ISOpub" },
  785. { 8230, "hellip","horizontal ellipsis = three dot leader, U+2026 ISOpub" },
  786. { 8242, "prime","prime = minutes = feet, U+2032 ISOtech" },
  787. { 8243, "Prime","double prime = seconds = inches, U+2033 ISOtech" },
  788. { 8254, "oline","overline = spacing overscore, U+203E NEW" },
  789. { 8260, "frasl","fraction slash, U+2044 NEW" },
  791. { 8472, "weierp","script capital P = power set = Weierstrass p, U+2118 ISOamso" },
  792. { 8465, "image","blackletter capital I = imaginary part, U+2111 ISOamso" },
  793. { 8476, "real", "blackletter capital R = real part symbol, U+211C ISOamso" },
  794. { 8482, "trade","trade mark sign, U+2122 ISOnum" },
  795. { 8501, "alefsym","alef symbol = first transfinite cardinal, U+2135 NEW" },
  796. { 8592, "larr", "leftwards arrow, U+2190 ISOnum" },
  797. { 8593, "uarr", "upwards arrow, U+2191 ISOnum" },
  798. { 8594, "rarr", "rightwards arrow, U+2192 ISOnum" },
  799. { 8595, "darr", "downwards arrow, U+2193 ISOnum" },
  800. { 8596, "harr", "left right arrow, U+2194 ISOamsa" },
  801. { 8629, "crarr","downwards arrow with corner leftwards = carriage return, U+21B5 NEW" },
  802. { 8656, "lArr", "leftwards double arrow, U+21D0 ISOtech" },
  803. { 8657, "uArr", "upwards double arrow, U+21D1 ISOamsa" },
  804. { 8658, "rArr", "rightwards double arrow, U+21D2 ISOtech" },
  805. { 8659, "dArr", "downwards double arrow, U+21D3 ISOamsa" },
  806. { 8660, "hArr", "left right double arrow, U+21D4 ISOamsa" },
  809. { 8704, "forall","for all, U+2200 ISOtech" },
  810. { 8706, "part", "partial differential, U+2202 ISOtech" },
  811. { 8707, "exist","there exists, U+2203 ISOtech" },
  812. { 8709, "empty","empty set = null set = diameter, U+2205 ISOamso" },
  813. { 8711, "nabla","nabla = backward difference, U+2207 ISOtech" },
  814. { 8712, "isin", "element of, U+2208 ISOtech" },
  815. { 8713, "notin","not an element of, U+2209 ISOtech" },
  816. { 8715, "ni", "contains as member, U+220B ISOtech" },
  817. { 8719, "prod", "n-ary product = product sign, U+220F ISOamsb" },
  818. { 8721, "sum", "n-ary sumation, U+2211 ISOamsb" },
  819. { 8722, "minus","minus sign, U+2212 ISOtech" },
  820. { 8727, "lowast","asterisk operator, U+2217 ISOtech" },
  821. { 8730, "radic","square root = radical sign, U+221A ISOtech" },
  822. { 8733, "prop", "proportional to, U+221D ISOtech" },
  823. { 8734, "infin","infinity, U+221E ISOtech" },
  824. { 8736, "ang", "angle, U+2220 ISOamso" },
  825. { 8743, "and", "logical and = wedge, U+2227 ISOtech" },
  826. { 8744, "or", "logical or = vee, U+2228 ISOtech" },
  827. { 8745, "cap", "intersection = cap, U+2229 ISOtech" },
  828. { 8746, "cup", "union = cup, U+222A ISOtech" },
  829. { 8747, "int", "integral, U+222B ISOtech" },
  830. { 8756, "there4","therefore, U+2234 ISOtech" },
  831. { 8764, "sim", "tilde operator = varies with = similar to, U+223C ISOtech" },
  832. { 8773, "cong", "approximately equal to, U+2245 ISOtech" },
  833. { 8776, "asymp","almost equal to = asymptotic to, U+2248 ISOamsr" },
  834. { 8800, "ne", "not equal to, U+2260 ISOtech" },
  835. { 8801, "equiv","identical to, U+2261 ISOtech" },
  836. { 8804, "le", "less-than or equal to, U+2264 ISOtech" },
  837. { 8805, "ge", "greater-than or equal to, U+2265 ISOtech" },
  838. { 8834, "sub", "subset of, U+2282 ISOtech" },
  839. { 8835, "sup", "superset of, U+2283 ISOtech" },
  840. { 8836, "nsub", "not a subset of, U+2284 ISOamsn" },
  841. { 8838, "sube", "subset of or equal to, U+2286 ISOtech" },
  842. { 8839, "supe", "superset of or equal to, U+2287 ISOtech" },
  843. { 8853, "oplus","circled plus = direct sum, U+2295 ISOamsb" },
  844. { 8855, "otimes","circled times = vector product, U+2297 ISOamsb" },
  845. { 8869, "perp", "up tack = orthogonal to = perpendicular, U+22A5 ISOtech" },
  846. { 8901, "sdot", "dot operator, U+22C5 ISOamsb" },
  847. { 8968, "lceil","left ceiling = apl upstile, U+2308 ISOamsc" },
  848. { 8969, "rceil","right ceiling, U+2309 ISOamsc" },
  849. { 8970, "lfloor","left floor = apl downstile, U+230A ISOamsc" },
  850. { 8971, "rfloor","right floor, U+230B ISOamsc" },
  851. { 9001, "lang", "left-pointing angle bracket = bra, U+2329 ISOtech" },
  852. { 9002, "rang", "right-pointing angle bracket = ket, U+232A ISOtech" },
  853. { 9674, "loz", "lozenge, U+25CA ISOpub" },
  855. { 9824, "spades","black spade suit, U+2660 ISOpub" },
  856. { 9827, "clubs","black club suit = shamrock, U+2663 ISOpub" },
  857. { 9829, "hearts","black heart suit = valentine, U+2665 ISOpub" },
  858. { 9830, "diams","black diamond suit, U+2666 ISOpub" },
  860. { 338, "OElig","latin capital ligature OE, U+0152 ISOlat2" },
  861. { 339, "oelig","latin small ligature oe, U+0153 ISOlat2" },
  862. { 352, "Scaron","latin capital letter S with caron, U+0160 ISOlat2" },
  863. { 353, "scaron","latin small letter s with caron, U+0161 ISOlat2" },
  864. { 376, "Yuml", "latin capital letter Y with diaeresis, U+0178 ISOlat2" },
  865. { 710, "circ", "modifier letter circumflex accent, U+02C6 ISOpub" },
  866. { 732, "tilde","small tilde, U+02DC ISOdia" },
  868. { 8194, "ensp", "en space, U+2002 ISOpub" },
  869. { 8195, "emsp", "em space, U+2003 ISOpub" },
  870. { 8201, "thinsp","thin space, U+2009 ISOpub" },
  871. { 8204, "zwnj", "zero width non-joiner, U+200C NEW RFC 2070" },
  872. { 8205, "zwj", "zero width joiner, U+200D NEW RFC 2070" },
  873. { 8206, "lrm", "left-to-right mark, U+200E NEW RFC 2070" },
  874. { 8207, "rlm", "right-to-left mark, U+200F NEW RFC 2070" },
  875. { 8211, "ndash","en dash, U+2013 ISOpub" },
  876. { 8212, "mdash","em dash, U+2014 ISOpub" },
  877. { 8216, "lsquo","left single quotation mark, U+2018 ISOnum" },
  878. { 8217, "rsquo","right single quotation mark, U+2019 ISOnum" },
  879. { 8218, "sbquo","single low-9 quotation mark, U+201A NEW" },
  880. { 8220, "ldquo","left double quotation mark, U+201C ISOnum" },
  881. { 8221, "rdquo","right double quotation mark, U+201D ISOnum" },
  882. { 8222, "bdquo","double low-9 quotation mark, U+201E NEW" },
  883. { 8224, "dagger","dagger, U+2020 ISOpub" },
  884. { 8225, "Dagger","double dagger, U+2021 ISOpub" },
  885. { 8240, "permil","per mille sign, U+2030 ISOtech" },
  886. { 8249, "lsaquo","single left-pointing angle quotation mark, U+2039 ISO proposed" },
  887. { 8250, "rsaquo","single right-pointing angle quotation mark, U+203A ISO proposed" },
  888. { 8364, "euro", "euro sign, U+20AC NEW" }
  889. };
  891. /************************************************************************
  892.  * *
  893.  * Commodity functions to handle entities *
  894.  * *
  895.  ************************************************************************/
  897. /*
  898.  * Macro used to grow the current buffer.
  899.  */
  900. #define growBuffer(buffer) {
  901.     buffer##_size *= 2;
  902.     buffer = (xmlChar *) xmlRealloc(buffer, buffer##_size * sizeof(xmlChar));
  903.     if (buffer == NULL) {
  904. perror("realloc failed");
  905. return(NULL);
  906.     }
  907. }
  909. /**
  910.  * htmlEntityLookup:
  911.  * @name: the entity name
  912.  *
  913.  * Lookup the given entity in EntitiesTable
  914.  *
  915.  * TODO: the linear scan is really ugly, an hash table is really needed.
  916.  *
  917.  * Returns the associated htmlEntityDescPtr if found, NULL otherwise.
  918.  */
  919. htmlEntityDescPtr
  920. htmlEntityLookup(const xmlChar *name) {
  921.     int i;
  923.     for (i = 0;i < (sizeof(html40EntitiesTable)/
  924.                     sizeof(html40EntitiesTable[0]));i++) {
  925.         if (!xmlStrcmp(name, BAD_CAST html40EntitiesTable[i].name)) {
  926. #ifdef DEBUG
  927.             fprintf(stderr,"Found entity %sn", name);
  928. #endif
  929.             return(&html40EntitiesTable[i]);
  930. }
  931.     }
  932.     return(NULL);
  933. }
  936. /**
  937.  * htmlDecodeEntities:
  938.  * @ctxt:  the parser context
  939.  * @len:  the len to decode (in bytes !), -1 for no size limit
  940.  * @end:  an end marker xmlChar, 0 if none
  941.  * @end2:  an end marker xmlChar, 0 if none
  942.  * @end3:  an end marker xmlChar, 0 if none
  943.  *
  944.  * Subtitute the HTML entities by their value
  945.  *
  946.  * DEPRECATED !!!!
  947.  *
  948.  * Returns A newly allocated string with the substitution done. The caller
  949.  *      must deallocate it !
  950.  */
  951. xmlChar *
  952. htmlDecodeEntities(htmlParserCtxtPtr ctxt, int len,
  953.                   xmlChar end, xmlChar  end2, xmlChar end3) {
  954.     xmlChar *buffer = NULL;
  955.     int buffer_size = 0;
  956.     xmlChar *out = NULL;
  957.     xmlChar *name = NULL;
  959.     xmlChar *cur = NULL;
  960.     htmlEntityDescPtr ent;
  961.     int nbchars = 0;
  962.     unsigned int max = (unsigned int) len;
  964.     /*
  965.      * allocate a translation buffer.
  966.      */
  967.     buffer_size = HTML_PARSER_BIG_BUFFER_SIZE;
  968.     buffer = (xmlChar *) xmlMalloc(buffer_size * sizeof(xmlChar));
  969.     if (buffer == NULL) {
  970. perror("htmlDecodeEntities: malloc failed");
  971. return(NULL);
  972.     }
  973.     out = buffer;
  975.     /*
  976.      * Ok loop until we reach one of the ending char or a size limit.
  977.      */
  978.     while ((nbchars < max) && (CUR != end) &&
  979.            (CUR != end2) && (CUR != end3)) {
  981.         if (CUR == '&') {
  982.     if (NXT(1) == '#') {
  983. int val = htmlParseCharRef(ctxt);
  984. /* invalid for UTF-8 variable encoding !!!!! */
  985. *out++ = val;
  986. nbchars += 3; /* !!!! */
  987.     } else {
  988. ent = htmlParseEntityRef(ctxt, &name);
  989. if (name != NULL) {
  990.     if ((ent == NULL) || (ent->value <= 0) ||
  991.         (ent->value >= 255)) {
  992.         *out++ = '&';
  993.         cur = name;
  994. while (*cur != 0) {
  995.     if (out - buffer > buffer_size - 100) {
  996. int index = out - buffer;
  998. growBuffer(buffer);
  999. out = &buffer[index];
  1000.     }
  1001.     *out++ = *cur++;
  1002. }
  1003.         *out++ = ';';
  1004.     } else {
  1005. /* invalid for UTF-8 variable encoding !!!!! */
  1006. *out++ = (xmlChar)ent->value;
  1007. if (out - buffer > buffer_size - 100) {
  1008.     int index = out - buffer;
  1010.     growBuffer(buffer);
  1011.     out = &buffer[index];
  1012. }
  1013.     }
  1014.     nbchars += 2 + xmlStrlen(name);
  1015.     xmlFree(name);
  1016. }
  1017.     }
  1018. } else {
  1019.     /*  invalid for UTF-8 , use COPY(out); !!!!! */
  1020.     *out++ = CUR;
  1021.     nbchars++;
  1022.     if (out - buffer > buffer_size - 100) {
  1023.       int index = out - buffer;
  1024.       
  1025.       growBuffer(buffer);
  1026.       out = &buffer[index];
  1027.     }
  1028.     NEXT;
  1029. }
  1030.     }
  1031.     *out++ = 0;
  1032.     return(buffer);
  1033. }
  1036. /************************************************************************
  1037.  * *
  1038.  * Commodity functions to handle encodings *
  1039.  * *
  1040.  ************************************************************************/
  1042. /**
  1043.  * htmlSwitchEncoding:
  1044.  * @ctxt:  the parser context
  1045.  * @len:  the len of @cur
  1046.  *
  1047.  * change the input functions when discovering the character encoding
  1048.  * of a given entity.
  1049.  *
  1050.  */
  1051. void
  1052. htmlSwitchEncoding(htmlParserCtxtPtr ctxt, xmlCharEncoding enc)
  1053. {
  1054.     switch (enc) {
  1055.         case XML_CHAR_ENCODING_ERROR:
  1056.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1057.         ctxt->sax->error(ctxt->userData, "encoding unknownn");
  1058.     ctxt->wellFormed = 0;
  1059.             break;
  1060.         case XML_CHAR_ENCODING_NONE:
  1061.     /* let's assume it's UTF-8 without the XML decl */
  1062.             return;
  1063.         case XML_CHAR_ENCODING_UTF8:
  1064.     /* default encoding, no conversion should be needed */
  1065.             return;
  1066.         case XML_CHAR_ENCODING_UTF16LE:
  1067.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1068.                 ctxt->sax->error(ctxt->userData,
  1069.   "char encoding UTF16 little endian not supportedn");
  1070.             break;
  1071.         case XML_CHAR_ENCODING_UTF16BE:
  1072.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1073.                 ctxt->sax->error(ctxt->userData,
  1074.   "char encoding UTF16 big endian not supportedn");
  1075.             break;
  1076.         case XML_CHAR_ENCODING_UCS4LE:
  1077.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1078.                 ctxt->sax->error(ctxt->userData,
  1079.   "char encoding USC4 little endian not supportedn");
  1080.             break;
  1081.         case XML_CHAR_ENCODING_UCS4BE:
  1082.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1083.                 ctxt->sax->error(ctxt->userData,
  1084.   "char encoding USC4 big endian not supportedn");
  1085.             break;
  1086.         case XML_CHAR_ENCODING_EBCDIC:
  1087.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1088.                 ctxt->sax->error(ctxt->userData,
  1089.   "char encoding EBCDIC not supportedn");
  1090.             break;
  1091.         case XML_CHAR_ENCODING_UCS4_2143:
  1092.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1093.                 ctxt->sax->error(ctxt->userData,
  1094.   "char encoding UCS4 2143 not supportedn");
  1095.             break;
  1096.         case XML_CHAR_ENCODING_UCS4_3412:
  1097.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1098.                 ctxt->sax->error(ctxt->userData,
  1099.   "char encoding UCS4 3412 not supportedn");
  1100.             break;
  1101.         case XML_CHAR_ENCODING_UCS2:
  1102.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1103.                 ctxt->sax->error(ctxt->userData,
  1104.   "char encoding UCS2 not supportedn");
  1105.             break;
  1106.         case XML_CHAR_ENCODING_8859_1:
  1107.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1108.                 ctxt->sax->error(ctxt->userData,
  1109.   "char encoding ISO_8859_1 ISO Latin 1 not supportedn");
  1110.             break;
  1111.         case XML_CHAR_ENCODING_8859_2:
  1112.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1113.                 ctxt->sax->error(ctxt->userData,
  1114.   "char encoding ISO_8859_2 ISO Latin 2 not supportedn");
  1115.             break;
  1116.         case XML_CHAR_ENCODING_8859_3:
  1117.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1118.                 ctxt->sax->error(ctxt->userData,
  1119.   "char encoding ISO_8859_3 not supportedn");
  1120.             break;
  1121.         case XML_CHAR_ENCODING_8859_4:
  1122.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1123.                 ctxt->sax->error(ctxt->userData,
  1124.   "char encoding ISO_8859_4 not supportedn");
  1125.             break;
  1126.         case XML_CHAR_ENCODING_8859_5:
  1127.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1128.                 ctxt->sax->error(ctxt->userData,
  1129.   "char encoding ISO_8859_5 not supportedn");
  1130.             break;
  1131.         case XML_CHAR_ENCODING_8859_6:
  1132.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1133.                 ctxt->sax->error(ctxt->userData,
  1134.   "char encoding ISO_8859_6 not supportedn");
  1135.             break;
  1136.         case XML_CHAR_ENCODING_8859_7:
  1137.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1138.                 ctxt->sax->error(ctxt->userData,
  1139.   "char encoding ISO_8859_7 not supportedn");
  1140.             break;
  1141.         case XML_CHAR_ENCODING_8859_8:
  1142.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1143.                 ctxt->sax->error(ctxt->userData,
  1144.   "char encoding ISO_8859_8 not supportedn");
  1145.             break;
  1146.         case XML_CHAR_ENCODING_8859_9:
  1147.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1148.                 ctxt->sax->error(ctxt->userData,
  1149.   "char encoding ISO_8859_9 not supportedn");
  1150.             break;
  1151.         case XML_CHAR_ENCODING_2022_JP:
  1152.             if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1153.                 ctxt->sax->error(ctxt->userData,
  1154.                   "char encoding ISO-2022-JPnot supportedn");
  1155.             break;
  1156.         case XML_CHAR_ENCODING_SHIFT_JIS:
  1157.             if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1158.                 ctxt->sax->error(ctxt->userData,
  1159.                   "char encoding Shift_JISnot supportedn");
  1160.             break;
  1161.         case XML_CHAR_ENCODING_EUC_JP:
  1162.             if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1163.                 ctxt->sax->error(ctxt->userData,
  1164.                   "char encoding EUC-JPnot supportedn");
  1165.             break;
  1166.     }
  1167. }
  1169. /************************************************************************
  1170.  * *
  1171.  * Commodity functions to handle streams *
  1172.  * *
  1173.  ************************************************************************/
  1175. /**
  1176.  * htmlFreeInputStream:
  1177.  * @input:  an htmlParserInputPtr
  1178.  *
  1179.  * Free up an input stream.
  1180.  */
  1181. void
  1182. htmlFreeInputStream(htmlParserInputPtr input) {
  1183.     if (input == NULL) return;
  1185.     if (input->filename != NULL) xmlFree((char *) input->filename);
  1186.     if (input->directory != NULL) xmlFree((char *) input->directory);
  1187.     if ((input->free != NULL) && (input->base != NULL))
  1188.         input->free((xmlChar *) input->base);
  1189.     if (input->buf != NULL) 
  1190.         xmlFreeParserInputBuffer(input->buf);
  1191.     memset(input, -1, sizeof(htmlParserInput));
  1192.     xmlFree(input);
  1193. }
  1195. /**
  1196.  * htmlNewInputStream:
  1197.  * @ctxt:  an HTML parser context
  1198.  *
  1199.  * Create a new input stream structure
  1200.  * Returns the new input stream or NULL
  1201.  */
  1202. htmlParserInputPtr
  1203. htmlNewInputStream(htmlParserCtxtPtr ctxt) {
  1204.     htmlParserInputPtr input;
  1206.     input = (xmlParserInputPtr) xmlMalloc(sizeof(htmlParserInput));
  1207.     if (input == NULL) {
  1208.         ctxt->errNo = XML_ERR_NO_MEMORY;
  1209. if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1210.     ctxt->sax->error(ctxt->userData, 
  1211.                      "malloc: couldn't allocate a new input streamn");
  1212. ctxt->errNo = XML_ERR_NO_MEMORY;
  1213. return(NULL);
  1214.     }
  1215.     input->filename = NULL;
  1216.     input->directory = NULL;
  1217.     input->base = NULL;
  1218.     input->cur = NULL;
  1219.     input->buf = NULL;
  1220.     input->line = 1;
  1221.     input->col = 1;
  1222.     input->buf = NULL;
  1223.     input->free = NULL;
  1224.     input->consumed = 0;
  1225.     input->length = 0;
  1226.     return(input);
  1227. }
  1230. /************************************************************************
  1231.  * *
  1232.  * Commodity functions, cleanup needed ? *
  1233.  * *
  1234.  ************************************************************************/
  1236. /**
  1237.  * areBlanks:
  1238.  * @ctxt:  an HTML parser context
  1239.  * @str:  a xmlChar *
  1240.  * @len:  the size of @str
  1241.  *
  1242.  * Is this a sequence of blank chars that one can ignore ?
  1243.  *
  1244.  * Returns 1 if ignorable 0 otherwise.
  1245.  */
  1247. static int areBlanks(htmlParserCtxtPtr ctxt, const xmlChar *str, int len) {
  1248.     int i;
  1249.     xmlNodePtr lastChild;
  1251.     for (i = 0;i < len;i++)
  1252.         if (!(IS_BLANK(str[i]))) return(0);
  1254.     if (CUR != '<') return(0);
  1255.     if (ctxt->node == NULL) return(0);
  1256.     lastChild = xmlGetLastChild(ctxt->node);
  1257.     if (lastChild == NULL) {
  1258.         if (ctxt->node->content != NULL) return(0);
  1259.     } else if (xmlNodeIsText(lastChild))
  1260.         return(0);
  1261.     return(1);
  1262. }
  1264. /**
  1265.  * htmlHandleEntity:
  1266.  * @ctxt:  an HTML parser context
  1267.  * @entity:  an XML entity pointer.
  1268.  *
  1269.  * Default handling of an HTML entity, call the parser with the
  1270.  * substitution string
  1271.  */
  1273. void
  1274. htmlHandleEntity(htmlParserCtxtPtr ctxt, xmlEntityPtr entity) {
  1275.     int len;
  1277.     if (entity->content == NULL) {
  1278.         if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1279.     ctxt->sax->error(ctxt->userData, "htmlHandleEntity %s: content == NULLn",
  1280.                entity->name);
  1281. ctxt->wellFormed = 0;
  1282.         return;
  1283.     }
  1284.     len = xmlStrlen(entity->content);
  1286.     /*
  1287.      * Just handle the content as a set of chars.
  1288.      */
  1289.     if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL))
  1290. ctxt->sax->characters(ctxt->userData, entity->content, len);
  1292. }
  1294. /**
  1295.  * htmlNewDoc:
  1296.  * @URI:  URI for the dtd, or NULL
  1297.  * @ExternalID:  the external ID of the DTD, or NULL
  1298.  *
  1299.  * Returns a new document
  1300.  */
  1301. htmlDocPtr
  1302. htmlNewDoc(const xmlChar *URI, const xmlChar *ExternalID) {
  1303.     xmlDocPtr cur;
  1305.     /*
  1306.      * Allocate a new document and fill the fields.
  1307.      */
  1308.     cur = (xmlDocPtr) xmlMalloc(sizeof(xmlDoc));
  1309.     if (cur == NULL) {
  1310.         fprintf(stderr, "xmlNewDoc : malloc failedn");
  1311. return(NULL);
  1312.     }
  1313.     memset(cur, 0, sizeof(xmlDoc));
  1315.     cur->type = XML_HTML_DOCUMENT_NODE;
  1316.     cur->version = NULL;
  1317.     cur->intSubset = NULL;
  1318.     if ((ExternalID == NULL) &&
  1319. (URI == NULL))
  1320. xmlCreateIntSubset(cur, BAD_CAST "HTML",
  1321.     BAD_CAST "-//W3C//DTD HTML 4.0 Transitional//EN",
  1322.     BAD_CAST "http://www.w3.org/TR/REC-html40/loose.dtd");
  1323.     else
  1324. xmlCreateIntSubset(cur, BAD_CAST "HTML", ExternalID, URI);
  1325.     cur->name = NULL;
  1326.     cur->children = NULL; 
  1327.     cur->extSubset = NULL;
  1328.     cur->oldNs = NULL;
  1329.     cur->encoding = NULL;
  1330.     cur->standalone = 1;
  1331.     cur->compression = 0;
  1332.     cur->ids = NULL;
  1333.     cur->refs = NULL;
  1334. #ifndef XML_WITHOUT_CORBA
  1335.     cur->_private = NULL;
  1336. #endif
  1337.     return(cur);
  1338. }
  1341. /************************************************************************
  1342.  * *
  1343.  * The parser itself *
  1344.  * Relates to http://www.w3.org/TR/html40 *
  1345.  * *
  1346.  ************************************************************************/
  1348. /************************************************************************
  1349.  * *
  1350.  * The parser itself *
  1351.  * *
  1352.  ************************************************************************/
  1354. /**
  1355.  * htmlParseHTMLName:
  1356.  * @ctxt:  an HTML parser context
  1357.  *
  1358.  * parse an HTML tag or attribute name, note that we convert it to lowercase
  1359.  * since HTML names are not case-sensitive.
  1360.  *
  1361.  * Returns the Tag Name parsed or NULL
  1362.  */
  1364. xmlChar *
  1365. htmlParseHTMLName(htmlParserCtxtPtr ctxt) {
  1366.     xmlChar *ret = NULL;
  1367.     int i = 0;
  1368.     xmlChar loc[HTML_PARSER_BUFFER_SIZE];
  1370.     if (!IS_LETTER(CUR) && (CUR != '_') &&
  1371.         (CUR != ':')) return(NULL);
  1373.     while ((i < HTML_PARSER_BUFFER_SIZE) &&
  1374.            ((IS_LETTER(CUR)) || (IS_DIGIT(CUR)))) {
  1375. if ((CUR >= 'A') && (CUR <= 'Z')) loc[i] = CUR + 0x20;
  1376.         else loc[i] = CUR;
  1377. i++;
  1379. NEXT;
  1380.     }
  1381.     
  1382.     ret = xmlStrndup(loc, i);
  1384.     return(ret);
  1385. }
  1387. /**
  1388.  * htmlParseName:
  1389.  * @ctxt:  an HTML parser context
  1390.  *
  1391.  * parse an HTML name, this routine is case sensistive.
  1392.  *
  1393.  * Returns the Name parsed or NULL
  1394.  */
  1396. xmlChar *
  1397. htmlParseName(htmlParserCtxtPtr ctxt) {
  1398.     xmlChar buf[HTML_MAX_NAMELEN];
  1399.     int len = 0;
  1401.     GROW;
  1402.     if (!IS_LETTER(CUR) && (CUR != '_')) {
  1403. return(NULL);
  1404.     }
  1406.     while ((IS_LETTER(CUR)) || (IS_DIGIT(CUR)) ||
  1407.            (CUR == '.') || (CUR == '-') ||
  1408.    (CUR == '_') || (CUR == ':') || 
  1409.    (IS_COMBINING(CUR)) ||
  1410.    (IS_EXTENDER(CUR))) {
  1411. buf[len++] = CUR;
  1412. NEXT;
  1413. if (len >= HTML_MAX_NAMELEN) {
  1414.     fprintf(stderr, 
  1415.        "htmlParseName: reached HTML_MAX_NAMELEN limitn");
  1416.     while ((IS_LETTER(CUR)) || (IS_DIGIT(CUR)) ||
  1417.    (CUR == '.') || (CUR == '-') ||
  1418.    (CUR == '_') || (CUR == ':') || 
  1419.    (IS_COMBINING(CUR)) ||
  1420.    (IS_EXTENDER(CUR)))
  1421.  NEXT;
  1422.     break;
  1423. }
  1424.     }
  1425.     return(xmlStrndup(buf, len));
  1426. }
  1428. /**
  1429.  * htmlParseHTMLAttribute:
  1430.  * @ctxt:  an HTML parser context
  1431.  * @stop:  a char stop value
  1432.  * 
  1433.  * parse an HTML attribute value till the stop (quote), if
  1434.  * stop is 0 then it stops at the first space
  1435.  *
  1436.  * Returns the attribute parsed or NULL
  1437.  */
  1439. xmlChar *
  1440. htmlParseHTMLAttribute(htmlParserCtxtPtr ctxt, const xmlChar stop) {
  1441. #if 0
  1442.     xmlChar buf[HTML_MAX_NAMELEN];
  1443.     int len = 0;
  1445.     GROW;
  1446.     while ((CUR != 0) && (CUR != stop) && (CUR != '>')) {
  1447. if ((stop == 0) && (IS_BLANK(CUR))) break;
  1448. buf[len++] = CUR;
  1449. NEXT;
  1450. if (len >= HTML_MAX_NAMELEN) {
  1451.     fprintf(stderr, 
  1452.        "htmlParseHTMLAttribute: reached HTML_MAX_NAMELEN limitn");
  1453.     while ((!IS_BLANK(CUR)) && (CUR != '<') &&
  1454.    (CUR != '>') &&
  1455.    (CUR != ''') && (CUR != '"'))
  1456.  NEXT;
  1457.     break;
  1458. }
  1459.     }
  1460.     return(xmlStrndup(buf, len));
  1461. #else    
  1462.     xmlChar *buffer = NULL;
  1463.     int buffer_size = 0;
  1464.     xmlChar *out = NULL;
  1465.     xmlChar *name = NULL;
  1467.     xmlChar *cur = NULL;
  1468.     htmlEntityDescPtr ent;
  1470.     /*
  1471.      * allocate a translation buffer.
  1472.      */
  1473.     buffer_size = HTML_PARSER_BIG_BUFFER_SIZE;
  1474.     buffer = (xmlChar *) xmlMalloc(buffer_size * sizeof(xmlChar));
  1475.     if (buffer == NULL) {
  1476. perror("htmlParseHTMLAttribute: malloc failed");
  1477. return(NULL);
  1478.     }
  1479.     out = buffer;
  1481.     /*
  1482.      * Ok loop until we reach one of the ending chars
  1483.      */
  1484.     while ((CUR != 0) && (CUR != stop) && (CUR != '>')) {
  1485. if ((stop == 0) && (IS_BLANK(CUR))) break;
  1486.         if (CUR == '&') {
  1487.     if (NXT(1) == '#') {
  1488. int val = htmlParseCharRef(ctxt);
  1489. *out++ = val;
  1490.     } else {
  1491. ent = htmlParseEntityRef(ctxt, &name);
  1492. if (name == NULL) {
  1493.     *out++ = '&';
  1494.     if (out - buffer > buffer_size - 100) {
  1495. int index = out - buffer;
  1497. growBuffer(buffer);
  1498. out = &buffer[index];
  1499.     }
  1500. } else if ((ent == NULL) || (ent->value <= 0) ||
  1501.            (ent->value >= 255)) {
  1502.     *out++ = '&';
  1503.     cur = name;
  1504.     while (*cur != 0) {
  1505. if (out - buffer > buffer_size - 100) {
  1506.     int index = out - buffer;
  1508.     growBuffer(buffer);
  1509.     out = &buffer[index];
  1510. }
  1511. *out++ = *cur++;
  1512.     }
  1513.     xmlFree(name);
  1514. } else {
  1515.     *out++ = ent->value;
  1516.     if (out - buffer > buffer_size - 100) {
  1517. int index = out - buffer;
  1519. growBuffer(buffer);
  1520. out = &buffer[index];
  1521.     }
  1522.     xmlFree(name);
  1523. }
  1524.     }
  1525. } else {
  1526.     *out++ = CUR;
  1527.     if (out - buffer > buffer_size - 100) {
  1528.       int index = out - buffer;
  1529.       
  1530.       growBuffer(buffer);
  1531.       out = &buffer[index];
  1532.     }
  1533.     NEXT;
  1534. }
  1535.     }
  1536.     *out++ = 0;
  1537.     return(buffer);
  1538. #endif
  1539. }
  1541. /**
  1542.  * htmlParseNmtoken:
  1543.  * @ctxt:  an HTML parser context
  1544.  * 
  1545.  * parse an HTML Nmtoken.
  1546.  *
  1547.  * Returns the Nmtoken parsed or NULL
  1548.  */
  1550. xmlChar *
  1551. htmlParseNmtoken(htmlParserCtxtPtr ctxt) {
  1552.     xmlChar buf[HTML_MAX_NAMELEN];
  1553.     int len = 0;
  1555.     GROW;
  1556.     while ((IS_LETTER(CUR)) || (IS_DIGIT(CUR)) ||
  1557.            (CUR == '.') || (CUR == '-') ||
  1558.    (CUR == '_') || (CUR == ':') || 
  1559.    (IS_COMBINING(CUR)) ||
  1560.    (IS_EXTENDER(CUR))) {
  1561. buf[len++] = CUR;
  1562. NEXT;
  1563. if (len >= HTML_MAX_NAMELEN) {
  1564.     fprintf(stderr, 
  1565.        "htmlParseNmtoken: reached HTML_MAX_NAMELEN limitn");
  1566.     while ((IS_LETTER(CUR)) || (IS_DIGIT(CUR)) ||
  1567.    (CUR == '.') || (CUR == '-') ||
  1568.    (CUR == '_') || (CUR == ':') || 
  1569.    (IS_COMBINING(CUR)) ||
  1570.    (IS_EXTENDER(CUR)))
  1571.  NEXT;
  1572.     break;
  1573. }
  1574.     }
  1575.     return(xmlStrndup(buf, len));
  1576. }
  1578. /**
  1579.  * htmlParseEntityRef:
  1580.  * @ctxt:  an HTML parser context
  1581.  * @str:  location to store the entity name
  1582.  *
  1583.  * parse an HTML ENTITY references
  1584.  *
  1585.  * [68] EntityRef ::= '&' Name ';'
  1586.  *
  1587.  * Returns the associated htmlEntityDescPtr if found, or NULL otherwise,
  1588.  *         if non-NULL *str will have to be freed by the caller.
  1589.  */
  1590. htmlEntityDescPtr
  1591. htmlParseEntityRef(htmlParserCtxtPtr ctxt, xmlChar **str) {
  1592.     xmlChar *name;
  1593.     htmlEntityDescPtr ent = NULL;
  1594.     *str = NULL;
  1596.     if (CUR == '&') {
  1597.         NEXT;
  1598.         name = htmlParseName(ctxt);
  1599. if (name == NULL) {
  1600.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1601.         ctxt->sax->error(ctxt->userData, "htmlParseEntityRef: no namen");
  1602.     ctxt->wellFormed = 0;
  1603. } else {
  1604.     GROW;
  1605.     if (CUR == ';') {
  1606. *str = name;
  1608. /*
  1609.  * Lookup the entity in the table.
  1610.  */
  1611. ent = htmlEntityLookup(name);
  1612. if (ent != NULL) /* OK that's ugly !!! */
  1613.     NEXT;
  1614.     } else {
  1615. if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1616.     ctxt->sax->error(ctxt->userData,
  1617.                      "htmlParseEntityRef: expecting ';'n");
  1618. *str = name;
  1619.     }
  1620. }
  1621.     }
  1622.     return(ent);
  1623. }
  1625. /**
  1626.  * htmlParseAttValue:
  1627.  * @ctxt:  an HTML parser context
  1628.  *
  1629.  * parse a value for an attribute
  1630.  * Note: the parser won't do substitution of entities here, this
  1631.  * will be handled later in xmlStringGetNodeList, unless it was
  1632.  * asked for ctxt->replaceEntities != 0 
  1633.  *
  1634.  * Returns the AttValue parsed or NULL.
  1635.  */
  1637. xmlChar *
  1638. htmlParseAttValue(htmlParserCtxtPtr ctxt) {
  1639.     xmlChar *ret = NULL;
  1641.     if (CUR == '"') {
  1642.         NEXT;
  1643. ret = htmlParseHTMLAttribute(ctxt, '"');
  1644.         if (CUR != '"') {
  1645.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1646. ctxt->sax->error(ctxt->userData, "AttValue: ' expectedn");
  1647.     ctxt->wellFormed = 0;
  1648. } else
  1649.     NEXT;
  1650.     } else if (CUR == ''') {
  1651.         NEXT;
  1652. ret = htmlParseHTMLAttribute(ctxt, ''');
  1653.         if (CUR != ''') {
  1654.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1655. ctxt->sax->error(ctxt->userData, "AttValue: ' expectedn");
  1656.     ctxt->wellFormed = 0;
  1657. } else
  1658.     NEXT;
  1659.     } else {
  1660.         /*
  1661.  * That's an HTMLism, the attribute value may not be quoted
  1662.  */
  1663. ret = htmlParseHTMLAttribute(ctxt, 0);
  1664. if (ret == NULL) {
  1665.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1666. ctxt->sax->error(ctxt->userData, "AttValue: no value foundn");
  1667.     ctxt->wellFormed = 0;
  1668. }
  1669.     }
  1670.     return(ret);
  1671. }
  1673. /**
  1674.  * htmlParseSystemLiteral:
  1675.  * @ctxt:  an HTML parser context
  1676.  * 
  1677.  * parse an HTML Literal
  1678.  *
  1679.  * [11] SystemLiteral ::= ('"' [^"]* '"') | ("'" [^']* "'")
  1680.  *
  1681.  * Returns the SystemLiteral parsed or NULL
  1682.  */
  1684. xmlChar *
  1685. htmlParseSystemLiteral(htmlParserCtxtPtr ctxt) {
  1686.     const xmlChar *q;
  1687.     xmlChar *ret = NULL;
  1689.     if (CUR == '"') {
  1690.         NEXT;
  1691. q = CUR_PTR;
  1692. while ((IS_CHAR(CUR)) && (CUR != '"'))
  1693.     NEXT;
  1694. if (!IS_CHAR(CUR)) {
  1695.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1696.         ctxt->sax->error(ctxt->userData, "Unfinished SystemLiteraln");
  1697.     ctxt->wellFormed = 0;
  1698. } else {
  1699.     ret = xmlStrndup(q, CUR_PTR - q);
  1700.     NEXT;
  1701.         }
  1702.     } else if (CUR == ''') {
  1703.         NEXT;
  1704. q = CUR_PTR;
  1705. while ((IS_CHAR(CUR)) && (CUR != '''))
  1706.     NEXT;
  1707. if (!IS_CHAR(CUR)) {
  1708.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1709.         ctxt->sax->error(ctxt->userData, "Unfinished SystemLiteraln");
  1710.     ctxt->wellFormed = 0;
  1711. } else {
  1712.     ret = xmlStrndup(q, CUR_PTR - q);
  1713.     NEXT;
  1714.         }
  1715.     } else {
  1716. if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1717.     ctxt->sax->error(ctxt->userData,
  1718.                      "SystemLiteral " or ' expectedn");
  1719. ctxt->wellFormed = 0;
  1720.     }
  1721.     
  1722.     return(ret);
  1723. }
  1725. /**
  1726.  * htmlParsePubidLiteral:
  1727.  * @ctxt:  an HTML parser context
  1728.  *
  1729.  * parse an HTML public literal
  1730.  *
  1731.  * [12] PubidLiteral ::= '"' PubidChar* '"' | "'" (PubidChar - "'")* "'"
  1732.  *
  1733.  * Returns the PubidLiteral parsed or NULL.
  1734.  */
  1736. xmlChar *
  1737. htmlParsePubidLiteral(htmlParserCtxtPtr ctxt) {
  1738.     const xmlChar *q;
  1739.     xmlChar *ret = NULL;
  1740.     /*
  1741.      * Name ::= (Letter | '_') (NameChar)*
  1742.      */
  1743.     if (CUR == '"') {
  1744.         NEXT;
  1745. q = CUR_PTR;
  1746. while (IS_PUBIDCHAR(CUR)) NEXT;
  1747. if (CUR != '"') {
  1748.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1749.         ctxt->sax->error(ctxt->userData, "Unfinished PubidLiteraln");
  1750.     ctxt->wellFormed = 0;
  1751. } else {
  1752.     ret = xmlStrndup(q, CUR_PTR - q);
  1753.     NEXT;
  1754. }
  1755.     } else if (CUR == ''') {
  1756.         NEXT;
  1757. q = CUR_PTR;
  1758. while ((IS_LETTER(CUR)) && (CUR != '''))
  1759.     NEXT;
  1760. if (!IS_LETTER(CUR)) {
  1761.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1762.         ctxt->sax->error(ctxt->userData, "Unfinished PubidLiteraln");
  1763.     ctxt->wellFormed = 0;
  1764. } else {
  1765.     ret = xmlStrndup(q, CUR_PTR - q);
  1766.     NEXT;
  1767. }
  1768.     } else {
  1769. if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1770.     ctxt->sax->error(ctxt->userData, "SystemLiteral " or ' expectedn");
  1771. ctxt->wellFormed = 0;
  1772.     }
  1773.     
  1774.     return(ret);
  1775. }
  1777. /**
  1778.  * htmlParseCharData:
  1779.  * @ctxt:  an HTML parser context
  1780.  * @cdata:  int indicating whether we are within a CDATA section
  1781.  *
  1782.  * parse a CharData section.
  1783.  * if we are within a CDATA section ']]>' marks an end of section.
  1784.  *
  1785.  * [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*)
  1786.  */
  1788. void
  1789. htmlParseCharData(htmlParserCtxtPtr ctxt, int cdata) {
  1790.     xmlChar *buf = NULL;
  1791.     int len = 0;
  1792.     int size = HTML_PARSER_BUFFER_SIZE;
  1793.     xmlChar q;
  1795.     buf = (xmlChar *) xmlMalloc(size * sizeof(xmlChar));
  1796.     if (buf == NULL) {
  1797. fprintf(stderr, "malloc of %d byte failedn", size);
  1798. return;
  1799.     }
  1801.     q = CUR;
  1802.     while ((IS_CHAR(q)) && (q != '<') &&
  1803.            (q != '&')) {
  1804. if ((q == ']') && (NXT(1) == ']') &&
  1805.     (NXT(2) == '>')) {
  1806.     if (cdata) break;
  1807.     else {
  1808. if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1809.     ctxt->sax->error(ctxt->userData,
  1810.        "Sequence ']]>' not allowed in contentn");
  1811. ctxt->wellFormed = 0;
  1812.     }
  1813. }
  1814. if (len + 1 >= size) {
  1815.     size *= 2;
  1816.     buf = xmlRealloc(buf, size * sizeof(xmlChar));
  1817.     if (buf == NULL) {
  1818. fprintf(stderr, "realloc of %d byte failedn", size);
  1819. return;
  1820.     }
  1821. }
  1822. buf[len++] = q;
  1823.         NEXT;
  1824. q = CUR;
  1825.     }
  1826.     if (len == 0) {
  1827. xmlFree(buf);
  1828. return;
  1829.     }
  1831.     /*
  1832.      * Ok the buffer is to be consumed as chars.
  1833.      */
  1834.     if (ctxt->sax != NULL) {
  1835. if (areBlanks(ctxt, buf, len)) {
  1836.     if (ctxt->sax->ignorableWhitespace != NULL)
  1837. ctxt->sax->ignorableWhitespace(ctxt->userData, buf, len);
  1838. } else {
  1839.     if (ctxt->sax->characters != NULL)
  1840. ctxt->sax->characters(ctxt->userData, buf, len);
  1841.         }
  1842.     }
  1843.     xmlFree(buf);
  1844. }
  1846. /**
  1847.  * htmlParseExternalID:
  1848.  * @ctxt:  an HTML parser context
  1849.  * @publicID:  a xmlChar** receiving PubidLiteral
  1850.  * @strict: indicate whether we should restrict parsing to only
  1851.  *          production [75], see NOTE below
  1852.  *
  1853.  * Parse an External ID or a Public ID
  1854.  *
  1855.  * NOTE: Productions [75] and [83] interract badly since [75] can generate
  1856.  *       'PUBLIC' S PubidLiteral S SystemLiteral
  1857.  *
  1858.  * [75] ExternalID ::= 'SYSTEM' S SystemLiteral
  1859.  *                   | 'PUBLIC' S PubidLiteral S SystemLiteral
  1860.  *
  1861.  * [83] PublicID ::= 'PUBLIC' S PubidLiteral
  1862.  *
  1863.  * Returns the function returns SystemLiteral and in the second
  1864.  *                case publicID receives PubidLiteral, is strict is off
  1865.  *                it is possible to return NULL and have publicID set.
  1866.  */
  1868. xmlChar *
  1869. htmlParseExternalID(htmlParserCtxtPtr ctxt, xmlChar **publicID, int strict) {
  1870.     xmlChar *URI = NULL;
  1872.     if ((UPPER == 'S') && (UPP(1) == 'Y') &&
  1873.          (UPP(2) == 'S') && (UPP(3) == 'T') &&
  1874.  (UPP(4) == 'E') && (UPP(5) == 'M')) {
  1875.         SKIP(6);
  1876. if (!IS_BLANK(CUR)) {
  1877.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1878. ctxt->sax->error(ctxt->userData,
  1879.     "Space required after 'SYSTEM'n");
  1880.     ctxt->wellFormed = 0;
  1881. }
  1882.         SKIP_BLANKS;
  1883. URI = htmlParseSystemLiteral(ctxt);
  1884. if (URI == NULL) {
  1885.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1886.         ctxt->sax->error(ctxt->userData,
  1887.           "htmlParseExternalID: SYSTEM, no URIn");
  1888.     ctxt->wellFormed = 0;
  1889.         }
  1890.     } else if ((UPPER == 'P') && (UPP(1) == 'U') &&
  1891.        (UPP(2) == 'B') && (UPP(3) == 'L') &&
  1892.        (UPP(4) == 'I') && (UPP(5) == 'C')) {
  1893.         SKIP(6);
  1894. if (!IS_BLANK(CUR)) {
  1895.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1896. ctxt->sax->error(ctxt->userData,
  1897.     "Space required after 'PUBLIC'n");
  1898.     ctxt->wellFormed = 0;
  1899. }
  1900.         SKIP_BLANKS;
  1901. *publicID = htmlParsePubidLiteral(ctxt);
  1902. if (*publicID == NULL) {
  1903.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1904.         ctxt->sax->error(ctxt->userData, 
  1905.           "htmlParseExternalID: PUBLIC, no Public Identifiern");
  1906.     ctxt->wellFormed = 0;
  1907. }
  1908.         SKIP_BLANKS;
  1909.         if ((CUR == '"') || (CUR == ''')) {
  1910.     URI = htmlParseSystemLiteral(ctxt);
  1911. }
  1912.     }
  1913.     return(URI);
  1914. }
  1916. /**
  1917.  * htmlParseComment:
  1918.  * @ctxt:  an HTML parser context
  1919.  *
  1920.  * Parse an XML (SGML) comment <!-- .... -->
  1921.  *
  1922.  * [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'
  1923.  */
  1924. void
  1925. htmlParseComment(htmlParserCtxtPtr ctxt) {
  1926.     xmlChar *buf = NULL;
  1927.     int len = 0;
  1928.     int size = HTML_PARSER_BUFFER_SIZE;
  1929.     register xmlChar s, r, q;
  1931.     /*
  1932.      * Check that there is a comment right here.
  1933.      */
  1934.     if ((CUR != '<') || (NXT(1) != '!') ||
  1935.         (NXT(2) != '-') || (NXT(3) != '-')) return;
  1937.     buf = (xmlChar *) xmlMalloc(size * sizeof(xmlChar));
  1938.     if (buf == NULL) {
  1939. fprintf(stderr, "malloc of %d byte failedn", size);
  1940. return;
  1941.     }
  1942.     q = r = '-'; /* 0 or '-' to cover our ass against <!--> and <!---> ? !!! */
  1943.     SKIP(4);
  1944.     s = CUR;
  1945.     
  1946.     while (IS_CHAR(s) &&
  1947.            ((s != '>') || (r != '-') || (q != '-'))) {
  1948. if (len + 1 >= size) {
  1949.     size *= 2;
  1950.     buf = xmlRealloc(buf, size * sizeof(xmlChar));
  1951.     if (buf == NULL) {
  1952. fprintf(stderr, "realloc of %d byte failedn", size);
  1953. return;
  1954.     }
  1955. }
  1956. buf[len++] = s;
  1957.         NEXT;
  1958. q = r;
  1959. r = s;
  1960. s = CUR;
  1961.     }
  1962.     buf[len - 2] = 0;
  1963.     if (!IS_CHAR(s)) {
  1964. if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1965.     ctxt->sax->error(ctxt->userData, "Comment not terminated n<!--%.50sn", buf);
  1966. ctxt->wellFormed = 0;
  1967.     } else {
  1968.         NEXT;
  1969. if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL)) {
  1970.     ctxt->sax->comment(ctxt->userData, buf);
  1971. }
  1972.     }
  1973.     xmlFree(buf);
  1974. }
  1976. /**
  1977.  * htmlParseCharRef:
  1978.  * @ctxt:  an HTML parser context
  1979.  *
  1980.  * parse Reference declarations
  1981.  *
  1982.  * [66] CharRef ::= '&#' [0-9]+ ';' |
  1983.  *                  '&#x' [0-9a-fA-F]+ ';'
  1984.  *
  1985.  * Returns the value parsed (as an int)
  1986.  */
  1987. int
  1988. htmlParseCharRef(htmlParserCtxtPtr ctxt) {
  1989.     int val = 0;
  1991.     if ((CUR == '&') && (NXT(1) == '#') &&
  1992.         (NXT(2) == 'x')) {
  1993. SKIP(3);
  1994. while (CUR != ';') {
  1995.     if ((CUR >= '0') && (CUR <= '9')) 
  1996.         val = val * 16 + (CUR - '0');
  1997.     else if ((CUR >= 'a') && (CUR <= 'f'))
  1998.         val = val * 16 + (CUR - 'a') + 10;
  1999.     else if ((CUR >= 'A') && (CUR <= 'F'))
  2000.         val = val * 16 + (CUR - 'A') + 10;
  2001.     else {
  2002.         if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  2003.     ctxt->sax->error(ctxt->userData, 
  2004.          "htmlParseCharRef: invalid hexadecimal valuen");
  2005. ctxt->wellFormed = 0;
  2006. val = 0;
  2007. break;
  2008.     }
  2009.     NEXT;
  2010. }
  2011. if (CUR == ';')
  2012.     NEXT;
  2013.     } else if  ((CUR == '&') && (NXT(1) == '#')) {
  2014. SKIP(2);
  2015. while (CUR != ';') {
  2016.     if ((CUR >= '0') && (CUR <= '9')) 
  2017.         val = val * 10 + (CUR - '0');
  2018.     else {
  2019.         if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  2020.     ctxt->sax->error(ctxt->userData, 
  2021.          "htmlParseCharRef: invalid decimal valuen");
  2022. ctxt->wellFormed = 0;
  2023. val = 0;
  2024. break;
  2025.     }
  2026.     NEXT;
  2027. }
  2028. if (CUR == ';')
  2029.     NEXT;
  2030.     } else {
  2031. if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  2032.     ctxt->sax->error(ctxt->userData, "htmlParseCharRef: invalid valuen");
  2033. ctxt->wellFormed = 0;
  2034.     }
  2035.     /*
  2036.      * Check the value IS_CHAR ...
  2037.      */
  2038.     if (IS_CHAR(val)) {
  2039.         return(val);
  2040.     } else {
  2041. if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  2042.     ctxt->sax->error(ctxt->userData, "htmlParseCharRef: invalid xmlChar value %dn",
  2043.                      val);
  2044. ctxt->wellFormed = 0;
  2045.     }
  2046.     return(0);
  2047. }
  2050. /**
  2051.  * htmlParseDocTypeDecl :
  2052.  * @ctxt:  an HTML parser context
  2053.  *
  2054.  * parse a DOCTYPE declaration
  2055.  *
  2056.  * [28] doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S? 
  2057.  *                      ('[' (markupdecl | PEReference | S)* ']' S?)? '>'
  2058.  */
  2060. void
  2061. htmlParseDocTypeDecl(htmlParserCtxtPtr ctxt) {
  2062.     xmlChar *name;
  2063.     xmlChar *ExternalID = NULL;
  2064.     xmlChar *URI = NULL;
  2066.     /*
  2067.      * We know that '<!DOCTYPE' has been detected.
  2068.      */
  2069.     SKIP(9);
  2071.     SKIP_BLANKS;
  2073.     /*
  2074.      * Parse the DOCTYPE name.
  2075.      */
  2076.     name = htmlParseName(ctxt);
  2077.     if (name == NULL) {
  2078. if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  2079.     ctxt->sax->error(ctxt->userData, "htmlParseDocTypeDecl : no DOCTYPE name !n");
  2080. ctxt->wellFormed = 0;
  2081.     }
  2082.     /*
  2083.      * Check that upper(name) == "HTML" !!!!!!!!!!!!!
  2084.      */
  2086.     SKIP_BLANKS;
  2088.     /*
  2089.      * Check for SystemID and ExternalID
  2090.      */
  2091.     URI = htmlParseExternalID(ctxt, &ExternalID, 0);
  2092.     SKIP_BLANKS;
  2094.     /*
  2095.      * We should be at the end of the DOCTYPE declaration.
  2096.      */
  2097.     if (CUR != '>') {
  2098. if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  2099.     ctxt->sax->error(ctxt->userData, "DOCTYPE unproperly terminatedn");
  2100. ctxt->wellFormed = 0;
  2101.         /* We shouldn't try to resynchronize ... */
  2102.     } else {
  2103.     }
  2104.     NEXT;
  2106.     /*
  2107.      * Create the document accordingly to the DOCTYPE
  2108.      */
  2109.     if (ctxt->myDoc != NULL)
  2110.         xmlFreeDoc(ctxt->myDoc);
  2111.     
  2112.     ctxt->myDoc = htmlNewDoc(URI, ExternalID);
  2114.     /*
  2115.      * Cleanup, since we don't use all those identifiers
  2116.      */
  2117.     if (URI != NULL) xmlFree(URI);
  2118.     if (ExternalID != NULL) xmlFree(ExternalID);
  2119.     if (name != NULL) xmlFree(name);
  2120. }
  2122. /**
  2123.  * htmlParseAttribute:
  2124.  * @ctxt:  an HTML parser context
  2125.  * @value:  a xmlChar ** used to store the value of the attribute
  2126.  *
  2127.  * parse an attribute
  2128.  *
  2129.  * [41] Attribute ::= Name Eq AttValue
  2130.  *
  2131.  * [25] Eq ::= S? '=' S?
  2132.  *
  2133.  * With namespace:
  2134.  *
  2135.  * [NS 11] Attribute ::= QName Eq AttValue
  2136.  *
  2137.  * Also the case QName == xmlns:??? is handled independently as a namespace
  2138.  * definition.
  2139.  *
  2140.  * Returns the attribute name, and the value in *value.
  2141.  */
  2143. xmlChar *
  2144. htmlParseAttribute(htmlParserCtxtPtr ctxt, xmlChar **value) {
  2145.     xmlChar *name, *val = NULL;
  2147.     *value = NULL;
  2148.     name = htmlParseName(ctxt);
  2149.     if (name == NULL) {
  2150. if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  2151.     ctxt->sax->error(ctxt->userData, "error parsing attribute namen");
  2152. ctxt->wellFormed = 0;
  2153.         return(NULL);
  2154.     }
  2156.     /*
  2157.      * read the value
  2158.      */
  2159.     SKIP_BLANKS;
  2160.     if (CUR == '=') {
  2161.         NEXT;
  2162. SKIP_BLANKS;
  2163. val = htmlParseAttValue(ctxt);
  2164.     } else {
  2165.         /* TODO : some attribute must have values, some may not */
  2166. if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  2167.     ctxt->sax->warning(ctxt->userData,
  2168.        "No value for attribute %sn", name);
  2169.     }
  2171.     *value = val;
  2172.     return(name);
  2173. }
  2175. /**
  2176.  * htmlParseStartTag:
  2177.  * @ctxt:  an HTML parser context
  2178.  * 
  2179.  * parse a start of tag either for rule element or
  2180.  * EmptyElement. In both case we don't parse the tag closing chars.
  2181.  *
  2182.  * [40] STag ::= '<' Name (S Attribute)* S? '>'
  2183.  *
  2184.  * [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
  2185.  *
  2186.  * With namespace:
  2187.  *
  2188.  * [NS 8] STag ::= '<' QName (S Attribute)* S? '>'
  2189.  *
  2190.  * [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>'
  2191.  *
  2192.  */
  2194. void
  2195. htmlParseStartTag(htmlParserCtxtPtr ctxt) {
  2196.     xmlChar *name;
  2197.     xmlChar *attname;
  2198.     xmlChar *attvalue;
  2199.     const xmlChar **atts = NULL;
  2200.     int nbatts = 0;
  2201.     int maxatts = 0;
  2202.     int i;
  2204.     if (CUR != '<') return;
  2205.     NEXT;
  2207.     GROW;
  2208.     name = htmlParseHTMLName(ctxt);
  2209.     if (name == NULL) {
  2210. if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  2211.     ctxt->sax->error(ctxt->userData, 
  2212.      "htmlParseStartTag: invalid element namen");
  2213. ctxt->wellFormed = 0;
  2214.         return;
  2215.     }
  2217.     /*
  2218.      * Check for auto-closure of HTML elements.
  2219.      */
  2220.     htmlAutoClose(ctxt, name);
  2222.     /*
  2223.      * Now parse the attributes, it ends up with the ending
  2224.      *
  2225.      * (S Attribute)* S?
  2226.      */
  2227.     SKIP_BLANKS;
  2228.     while ((IS_CHAR(CUR)) &&
  2229.            (CUR != '>') && 
  2230.    ((CUR != '/') || (NXT(1) != '>'))) {
  2231. long cons = ctxt->nbChars;
  2233. GROW;
  2234. attname = htmlParseAttribute(ctxt, &attvalue);
  2235.         if (attname != NULL) {
  2236.     /*
  2237.      * Well formedness requires at most one declaration of an attribute
  2238.      */
  2239.     for (i = 0; i < nbatts;i += 2) {
  2240.         if (!xmlStrcmp(atts[i], attname)) {
  2241.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  2242. ctxt->sax->error(ctxt->userData,
  2243.                  "Attribute %s redefinedn",
  2244.                  attname);
  2245.     ctxt->wellFormed = 0;
  2246.     xmlFree(attname);
  2247.     if (attvalue != NULL)
  2248. xmlFree(attvalue);
  2249.     goto failed;
  2250. }
  2251.     }
  2253.     /*
  2254.      * Add the pair to atts
  2255.      */
  2256.     if (atts == NULL) {
  2257.         maxatts = 10;
  2258.         atts = (const xmlChar **) xmlMalloc(maxatts * sizeof(xmlChar *));
  2259. if (atts == NULL) {
  2260.     fprintf(stderr, "malloc of %ld byte failedn",
  2261.     maxatts * (long)sizeof(xmlChar *));
  2262.     if (name != NULL) xmlFree(name);
  2263.     return;
  2264. }
  2265.     } else if (nbatts + 4 > maxatts) {
  2266.         maxatts *= 2;
  2267.         atts = (const xmlChar **) xmlRealloc(atts, maxatts * sizeof(xmlChar *));
  2268. if (atts == NULL) {
  2269.     fprintf(stderr, "realloc of %ld byte failedn",
  2270.     maxatts * (long)sizeof(xmlChar *));
  2271.     if (name != NULL) xmlFree(name);
  2272.     return;
  2273. }
  2274.     }
  2275.     atts[nbatts++] = attname;
  2276.     atts[nbatts++] = attvalue;
  2277.     atts[nbatts] = NULL;
  2278.     atts[nbatts + 1] = NULL;
  2279. }
  2281. failed:
  2282. SKIP_BLANKS;
  2283.         if (cons == ctxt->nbChars) {
  2284.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  2285.         ctxt->sax->error(ctxt->userData, 
  2286.          "htmlParseStartTag: problem parsing attributesn");
  2287.     ctxt->wellFormed = 0;
  2288.     break;
  2289. }
  2290.     }
  2292.     /*
  2293.      * SAX: Start of Element !
  2294.      */
  2295.     htmlnamePush(ctxt, xmlStrdup(name));
  2296. #ifdef DEBUG
  2297.     fprintf(stderr,"Start of element %s: pushed %sn", name, ctxt->name);
  2298. #endif    
  2299.     if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL))
  2300.         ctxt->sax->startElement(ctxt->userData, name, atts);
  2302.     if (atts != NULL) {
  2303.         for (i = 0;i < nbatts;i++) {
  2304.     if (atts[i] != NULL)
  2305. xmlFree((xmlChar *) atts[i]);
  2306. }
  2307. xmlFree(atts);
  2308.     }
  2309.     if (name != NULL) xmlFree(name);
  2310. }
  2312. /**
  2313.  * htmlParseEndTag:
  2314.  * @ctxt:  an HTML parser context
  2315.  *
  2316.  * parse an end of tag
  2317.  *
  2318.  * [42] ETag ::= '</' Name S? '>'
  2319.  *
  2320.  * With namespace
  2321.  *
  2322.  * [NS 9] ETag ::= '</' QName S? '>'
  2323.  */
  2325. void
  2326. htmlParseEndTag(htmlParserCtxtPtr ctxt) {
  2327.     xmlChar *name;
  2328.     xmlChar *oldname;
  2329.     int i;
  2331.     if ((CUR != '<') || (NXT(1) != '/')) {
  2332. if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  2333.     ctxt->sax->error(ctxt->userData, "htmlParseEndTag: '</' not foundn");
  2334. ctxt->wellFormed = 0;
  2335. return;
  2336.     }
  2337.     SKIP(2);
  2339.     name = htmlParseHTMLName(ctxt);
  2340.     if (name == NULL) return;
  2342.     /*
  2343.      * We should definitely be at the ending "S? '>'" part
  2344.      */
  2345.     SKIP_BLANKS;
  2346.     if ((!IS_CHAR(CUR)) || (CUR != '>')) {
  2347. if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  2348.     ctxt->sax->error(ctxt->userData, "End tag : expected '>'n");
  2349. ctxt->wellFormed = 0;
  2350.     } else
  2351. NEXT;
  2353.     /*
  2354.      * If the name read is not one of the element in the parsing stack
  2355.      * then return, it's just an error.
  2356.      */
  2357.     for (i = (ctxt->nameNr - 1);i >= 0;i--) {
  2358.         if (!xmlStrcmp(name, ctxt->nameTab[i])) break;
  2359.     }
  2360.     if (i < 0) {
  2361. if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  2362.     ctxt->sax->error(ctxt->userData,
  2363.      "Unexpected end tag : %sn", name);
  2364. xmlFree(name);
  2365. ctxt->wellFormed = 0;
  2366. return;
  2367.     }
  2370.     /*
  2371.      * Check for auto-closure of HTML elements.
  2372.      */
  2374.     htmlAutoCloseOnClose(ctxt, name);
  2376.     /*
  2377.      * Well formedness constraints, opening and closing must match.
  2378.      * With the exception that the autoclose may have popped stuff out
  2379.      * of the stack.
  2380.      */
  2381.     if (xmlStrcmp(name, ctxt->name)) {
  2382. #ifdef DEBUG
  2383. fprintf(stderr,"End of tag %s: expecting %sn", name, ctxt->name);
  2384. #endif
  2385.         if ((ctxt->name != NULL) && 
  2386.     (xmlStrcmp(ctxt->name, name))) {
  2387.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  2388. ctxt->sax->error(ctxt->userData,
  2389.  "Opening and ending tag mismatch: %s and %sn",
  2390.                  name, ctxt->name);
  2391.     ctxt->wellFormed = 0;
  2392.         }
  2393.     }
  2395.     /*
  2396.      * SAX: End of Tag
  2397.      */
  2398.     oldname = ctxt->name;
  2399.     if ((oldname != NULL) && (!xmlStrcmp(oldname, name))) {
  2400. if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
  2401.     ctxt->sax->endElement(ctxt->userData, name);
  2402. oldname = htmlnamePop(ctxt);
  2403. if (oldname != NULL) {
  2404. #ifdef DEBUG
  2405.     fprintf(stderr,"End of tag %s: popping out %sn", name, oldname);
  2406. #endif
  2407.     xmlFree(oldname);
  2408. #ifdef DEBUG
  2409. } else {
  2410.     fprintf(stderr,"End of tag %s: stack empty !!!n", name);
  2411. #endif
  2412. }
  2413.     }
  2415.     if (name != NULL)
  2416. xmlFree(name);
  2418.     return;
  2419. }
  2422. /**
  2423.  * htmlParseReference:
  2424.  * @ctxt:  an HTML parser context
  2425.  * 
  2426.  * parse and handle entity references in content,
  2427.  * this will end-up in a call to character() since this is either a
  2428.  * CharRef, or a predefined entity.
  2429.  */
  2430. void
  2431. htmlParseReference(htmlParserCtxtPtr ctxt) {
  2432.     htmlEntityDescPtr ent;
  2433.     xmlChar out[2];
  2434.     xmlChar *name;
  2435.     int val;
  2436.     if (CUR != '&') return;
  2438.     if (NXT(1) == '#') {
  2439. val = htmlParseCharRef(ctxt);
  2440. /* invalid for UTF-8 variable encoding !!!!! */
  2441. out[0] = val;
  2442. out[1] = 0;
  2443. if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL))
  2444.     ctxt->sax->characters(ctxt->userData, out, 1);
  2445.     } else {
  2446. ent = htmlParseEntityRef(ctxt, &name);
  2447. if (name == NULL) {
  2448.     ctxt->sax->characters(ctxt->userData, BAD_CAST "&", 1);
  2449.     return;
  2450. }
  2451. if ((ent == NULL) || (ent->value <= 0) || (ent->value >= 255)) {
  2452.     if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL)) {
  2453. ctxt->sax->characters(ctxt->userData, BAD_CAST "&", 1);
  2454. ctxt->sax->characters(ctxt->userData, name, xmlStrlen(name));
  2455. /* ctxt->sax->characters(ctxt->userData, BAD_CAST ";", 1); */
  2456.     }
  2457. } else {
  2458.     /* invalid for UTF-8 variable encoding !!!!! */
  2459.     out[0] = ent->value;
  2460.     out[1] = 0;
  2461.     if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL))
  2462. ctxt->sax->characters(ctxt->userData, out, 1);
  2463. }
  2464. xmlFree(name);
  2465.     }
  2466. }
  2468. /**
  2469.  * htmlParseContent:
  2470.  * @ctxt:  an HTML parser context
  2471.  * @name:  the node name
  2472.  *
  2473.  * Parse a content: comment, sub-element, reference or text.
  2474.  *
  2475.  */
  2477. void
  2478. htmlParseContent(htmlParserCtxtPtr ctxt) {
  2479.     xmlChar *currentNode;
  2480.     int depth;
  2482.     currentNode = xmlStrdup(ctxt->name);
  2483.     depth = ctxt->nameNr;
  2484.     while (1) {
  2485. long cons = ctxt->nbChars;
  2487.         GROW;
  2488. /*
  2489.  * Our tag or one of it's parent or children is ending.
  2490.  */
  2491.         if ((CUR == '<') && (NXT(1) == '/')) {
  2492.     htmlParseEndTag(ctxt);
  2493.     if (currentNode != NULL) xmlFree(currentNode);
  2494.     return;
  2495.         }
  2497. /*
  2498.  * Has this node been popped out during parsing of
  2499.  * the next element
  2500.  */
  2501.         if ((xmlStrcmp(currentNode, ctxt->name)) &&
  2502.     (depth >= ctxt->nameNr)) {
  2503.     if (currentNode != NULL) xmlFree(currentNode);
  2504.     return;
  2505. }
  2507. /*
  2508.  * First case :  a comment
  2509.  */
  2510. if ((CUR == '<') && (NXT(1) == '!') &&
  2511.  (NXT(2) == '-') && (NXT(3) == '-')) {
  2512.     htmlParseComment(ctxt);
  2513. }
  2515. /*
  2516.  * Second case :  a sub-element.
  2517.  */
  2518. else if (CUR == '<') {
  2519.     htmlParseElement(ctxt);
  2520. }
  2522. /*
  2523.  * Third case : a reference. If if has not been resolved,
  2524.  *    parsing returns it's Name, create the node 
  2525.  */
  2526. else if (CUR == '&') {
  2527.     htmlParseReference(ctxt);
  2528. }
  2530. /*
  2531.  * Last case, text. Note that References are handled directly.
  2532.  */
  2533. else {
  2534.     htmlParseCharData(ctxt, 0);
  2535. }
  2537. if (cons == ctxt->nbChars) {
  2538.     if (ctxt->node != NULL) {
  2539. if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  2540.     ctxt->sax->error(ctxt->userData,
  2541.  "detected an error in element contentn");
  2542. ctxt->wellFormed = 0;
  2543.     }
  2544.             break;
  2545. }
  2547.         GROW;
  2548.     }
  2549.     if (currentNode != NULL) xmlFree(currentNode);
  2550. }
  2552. /**
  2553.  * htmlParseElement:
  2554.  * @ctxt:  an HTML parser context
  2555.  *
  2556.  * parse an HTML element, this is highly recursive
  2557.  *
  2558.  * [39] element ::= EmptyElemTag | STag content ETag
  2559.  *
  2560.  * [41] Attribute ::= Name Eq AttValue
  2561.  */
  2563. void
  2564. htmlParseElement(htmlParserCtxtPtr ctxt) {
  2565.     const xmlChar *openTag = CUR_PTR;
  2566.     xmlChar *name;
  2567.     xmlChar *currentNode = NULL;
  2568.     htmlElemDescPtr info;
  2569.     htmlParserNodeInfo node_info;
  2570.     xmlChar *oldname;
  2571.     int depth = ctxt->nameNr;
  2573.     /* Capture start position */
  2574.     if (ctxt->record_info) {
  2575.         node_info.begin_pos = ctxt->input->consumed +
  2576.                           (CUR_PTR - ctxt->input->base);
  2577. node_info.begin_line = ctxt->input->line;
  2578.     }
  2580.     oldname = xmlStrdup(ctxt->name);
  2581.     htmlParseStartTag(ctxt);
  2582.     name = ctxt->name;
  2583. #ifdef DEBUG
  2584.     if (oldname == NULL)
  2585. fprintf(stderr, "Start of element %sn", name);
  2586.     else if (name == NULL)
  2587. fprintf(stderr, "Start of element failed, was %sn", oldname);
  2588.     else
  2589. fprintf(stderr, "Start of element %s, was %sn", name, oldname);
  2590. #endif
  2591.     if (((depth == ctxt->nameNr) && (!xmlStrcmp(oldname, ctxt->name))) ||
  2592.         (name == NULL)) {
  2593. if (CUR == '>')
  2594.     NEXT;
  2595. if (oldname != NULL)
  2596.     xmlFree(oldname);
  2597.         return;
  2598.     }
  2599.     if (oldname != NULL)
  2600. xmlFree(oldname);
  2602.     /*
  2603.      * Lookup the info for that element.
  2604.      */
  2605.     info = htmlTagLookup(name);
  2606.     if (info == NULL) {
  2607. if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  2608.     ctxt->sax->error(ctxt->userData, "Tag %s invalidn",
  2609.      name);
  2610. ctxt->wellFormed = 0;
  2611.     } else if (info->depr) {
  2612. /***************************
  2613. if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
  2614.     ctxt->sax->warning(ctxt->userData, "Tag %s is deprecatedn",
  2615.        name);
  2616.  ***************************/
  2617.     }
  2619.     /*
  2620.      * Check for an Empty Element labelled the XML/SGML way
  2621.      */
  2622.     if ((CUR == '/') && (NXT(1) == '>')) {
  2623.         SKIP(2);
  2624. if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
  2625.     ctxt->sax->endElement(ctxt->userData, name);
  2626. oldname = htmlnamePop(ctxt);
  2627. #ifdef DEBUG
  2628.         fprintf(stderr,"End of tag the XML way: popping out %sn", oldname);
  2629. #endif
  2630. if (oldname != NULL)
  2631.     xmlFree(oldname);
  2632. return;
  2633.     }
  2635.     if (CUR == '>') {
  2636.         NEXT;
  2637.     } else {
  2638. if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  2639.     ctxt->sax->error(ctxt->userData, "Couldn't find end of Start Tagn%.30sn",
  2640.                      openTag);
  2641. ctxt->wellFormed = 0;
  2643. /*
  2644.  * end of parsing of this node.
  2645.  */
  2646. if (!xmlStrcmp(name, ctxt->name)) { 
  2647.     nodePop(ctxt);
  2648.     oldname = htmlnamePop(ctxt);
  2649. #ifdef DEBUG
  2650.     fprintf(stderr,"End of start tag problem: popping out %sn", oldname);
  2651. #endif
  2652.     if (oldname != NULL)
  2653. xmlFree(oldname);
  2654. }    
  2656. /*
  2657.  * Capture end position and add node
  2658.  */
  2659. if ( currentNode != NULL && ctxt->record_info ) {
  2660.    node_info.end_pos = ctxt->input->consumed +
  2661.       (CUR_PTR - ctxt->input->base);
  2662.    node_info.end_line = ctxt->input->line;
  2663.    node_info.node = ctxt->node;
  2664.    xmlParserAddNodeInfo(ctxt, &node_info);
  2665. }
  2666. return;
  2667.     }
  2669.     /*
  2670.      * Check for an Empty Element from DTD definition
  2671.      */
  2672.     if ((info != NULL) && (info->empty)) {
  2673. if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
  2674.     ctxt->sax->endElement(ctxt->userData, name);
  2675. oldname = htmlnamePop(ctxt);
  2676. #ifdef DEBUG
  2677. fprintf(stderr,"End of empty tag %s : popping out %sn", name, oldname);
  2678. #endif
  2679. if (oldname != NULL)
  2680.     xmlFree(oldname);
  2681. return;
  2682.     }
  2684.     /*
  2685.      * Parse the content of the element:
  2686.      */
  2687.     currentNode = xmlStrdup(ctxt->name);
  2688.     depth = ctxt->nameNr;
  2689.     while (IS_CHAR(CUR)) {
  2690. htmlParseContent(ctxt);
  2691. if (ctxt->nameNr < depth) break; 
  2692.     }
  2694.     if (!IS_CHAR(CUR)) {
  2695. if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  2696.     ctxt->sax->error(ctxt->userData,
  2697.          "Premature end of data in tag %sn", currentNode);
  2698. ctxt->wellFormed = 0;
  2700. /*
  2701.  * end of parsing of this node.
  2702.  */
  2703. nodePop(ctxt);
  2704. oldname = htmlnamePop(ctxt);
  2705. #ifdef DEBUG
  2706. fprintf(stderr,"Premature end of tag %s : popping out %sn", name, oldname);
  2707. #endif
  2708. if (oldname != NULL)
  2709.     xmlFree(oldname);
  2710. if (currentNode != NULL)
  2711.     xmlFree(currentNode);
  2712. return;
  2713.     }
  2715.     /*
  2716.      * Capture end position and add node
  2717.      */
  2718.     if ( currentNode != NULL && ctxt->record_info ) {
  2719.        node_info.end_pos = ctxt->input->consumed +
  2720.                           (CUR_PTR - ctxt->input->base);
  2721.        node_info.end_line = ctxt->input->line;
  2722.        node_info.node = ctxt->node;
  2723.        xmlParserAddNodeInfo(ctxt, &node_info);
  2724.     }
  2725.     if (currentNode != NULL)
  2726. xmlFree(currentNode);
  2727. }
  2729. /**
  2730.  * htmlParseDocument :
  2731.  * @ctxt:  an HTML parser context
  2732.  * 
  2733.  * parse an HTML document (and build a tree if using the standard SAX
  2734.  * interface).
  2735.  *
  2736.  * Returns 0, -1 in case of error. the parser context is augmented
  2737.  *                as a result of the parsing.
  2738.  */
  2740. int
  2741. htmlParseDocument(htmlParserCtxtPtr ctxt) {
  2742.     htmlDefaultSAXHandlerInit();
  2743.     ctxt->html = 1;
  2745.     GROW;
  2746.     /*
  2747.      * SAX: beginning of the document processing.
  2748.      */
  2749.     if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
  2750.         ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
  2752.     /*
  2753.      * Wipe out everything which is before the first '<'
  2754.      */
  2755.     SKIP_BLANKS;
  2756.     if (CUR == 0) {
  2757. if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  2758.     ctxt->sax->error(ctxt->userData, "Document is emptyn");
  2759. ctxt->wellFormed = 0;
  2760.     }
  2762.     /*
  2763.      * Parse possible comments before any content
  2764.      */
  2765.     while ((CUR == '<') && (NXT(1) == '!') &&
  2766.            (NXT(2) == '-') && (NXT(3) == '-')) {
  2767. if (ctxt->myDoc == NULL)
  2768.     ctxt->myDoc = htmlNewDoc(NULL, NULL);
  2769.         htmlParseComment(ctxt);    
  2770. SKIP_BLANKS;
  2771.     }    
  2774.     /*
  2775.      * Then possibly doc type declaration(s) and more Misc
  2776.      * (doctypedecl Misc*)?
  2777.      */
  2778.     if ((CUR == '<') && (NXT(1) == '!') &&
  2779. (UPP(2) == 'D') && (UPP(3) == 'O') &&
  2780. (UPP(4) == 'C') && (UPP(5) == 'T') &&
  2781. (UPP(6) == 'Y') && (UPP(7) == 'P') &&
  2782. (UPP(8) == 'E')) {
  2783. htmlParseDocTypeDecl(ctxt);
  2784.     }
  2785.     SKIP_BLANKS;
  2787.     /*
  2788.      * Create the document if not done already.
  2789.      */
  2790.     if (ctxt->myDoc == NULL) {
  2791.         ctxt->myDoc = htmlNewDoc(NULL, NULL);
  2792.     }
  2794.     /*
  2795.      * Time to start parsing the tree itself
  2796.      */
  2797.     htmlParseContent(ctxt);
  2799.     /*
  2800.      * SAX: end of the document processing.
  2801.      */
  2802.     if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
  2803.         ctxt->sax->endDocument(ctxt->userData);
  2804.     if (! ctxt->wellFormed) return(-1);
  2805.     return(0);
  2806. }
  2809. /************************************************************************
  2810.  * *
  2811.  * Parser contexts handling *
  2812.  * *
  2813.  ************************************************************************/
  2815. /**
  2816.  * xmlInitParserCtxt:
  2817.  * @ctxt:  an HTML parser context
  2818.  *
  2819.  * Initialize a parser context
  2820.  */
  2822. void
  2823. htmlInitParserCtxt(htmlParserCtxtPtr ctxt)
  2824. {
  2825.     htmlSAXHandler *sax;
  2827.     if (ctxt == NULL) return;
  2828.     memset(ctxt, 0, sizeof(htmlParserCtxt));
  2830.     sax = (htmlSAXHandler *) xmlMalloc(sizeof(htmlSAXHandler));
  2831.     if (sax == NULL) {
  2832.         fprintf(stderr, "htmlInitParserCtxt: out of memoryn");
  2833.     }
  2834.     memset(sax, 0, sizeof(htmlSAXHandler));
  2836.     /* Allocate the Input stack */
  2837.     ctxt->inputTab = (htmlParserInputPtr *) 
  2838.                       xmlMalloc(5 * sizeof(htmlParserInputPtr));
  2839.     if (ctxt->inputTab == NULL) {
  2840.         fprintf(stderr, "htmlInitParserCtxt: out of memoryn");
  2841.     }
  2842.     ctxt->inputNr = 0;
  2843.     ctxt->inputMax = 5;
  2844.     ctxt->input = NULL;
  2845.     ctxt->version = NULL;
  2846.     ctxt->encoding = NULL;
  2847.     ctxt->standalone = -1;
  2848.     ctxt->instate = XML_PARSER_START;
  2850.     /* Allocate the Node stack */
  2851.     ctxt->nodeTab = (htmlNodePtr *) xmlMalloc(10 * sizeof(htmlNodePtr));
  2852.     ctxt->nodeNr = 0;
  2853.     ctxt->nodeMax = 10;
  2854.     ctxt->node = NULL;
  2856.     /* Allocate the Name stack */
  2857.     ctxt->nameTab = (xmlChar **) xmlMalloc(10 * sizeof(xmlChar *));
  2858.     ctxt->nameNr = 0;
  2859.     ctxt->nameMax = 10;
  2860.     ctxt->name = NULL;
  2862.     if (sax == NULL) ctxt->sax = &htmlDefaultSAXHandler;
  2863.     else {
  2864.         ctxt->sax = sax;
  2865. memcpy(sax, &htmlDefaultSAXHandler, sizeof(htmlSAXHandler));
  2866.     }
  2867.     ctxt->userData = ctxt;
  2868.     ctxt->myDoc = NULL;
  2869.     ctxt->wellFormed = 1;
  2870.     ctxt->replaceEntities = 0;
  2871.     ctxt->html = 1;
  2872.     ctxt->record_info = 0;
  2873.     ctxt->validate = 0;
  2874.     ctxt->nbChars = 0;
  2875.     ctxt->checkIndex = 0;
  2876.     xmlInitNodeInfoSeq(&ctxt->node_seq);
  2877. }
  2879. /**
  2880.  * htmlFreeParserCtxt:
  2881.  * @ctxt:  an HTML parser context
  2882.  *
  2883.  * Free all the memory used by a parser context. However the parsed
  2884.  * document in ctxt->myDoc is not freed.
  2885.  */
  2887. void
  2888. htmlFreeParserCtxt(htmlParserCtxtPtr ctxt)
  2889. {
  2890.     htmlParserInputPtr input;
  2891.     xmlChar *oldname;
  2893.     if (ctxt == NULL) return;
  2895.     while ((input = inputPop(ctxt)) != NULL) {
  2896.         xmlFreeInputStream(input);
  2897.     }
  2899.     if (ctxt->nodeTab != NULL) xmlFree(ctxt->nodeTab);
  2900.     while ((oldname = htmlnamePop(ctxt)) != NULL) {
  2901. xmlFree(oldname);
  2902.     }
  2903.     if (ctxt->nameTab != NULL) xmlFree(ctxt->nameTab);
  2904.     if (ctxt->directory != NULL) xmlFree(ctxt->directory);
  2905.     if (ctxt->inputTab != NULL) xmlFree(ctxt->inputTab);
  2906.     if (ctxt->version != NULL) xmlFree((char *) ctxt->version);
  2907.     if ((ctxt->sax != NULL) && (ctxt->sax != &htmlDefaultSAXHandler))
  2908.         xmlFree(ctxt->sax);
  2909.     xmlFree(ctxt);
  2910. }
  2912. /**
  2913.  * htmlCreateDocParserCtxt :
  2914.  * @cur:  a pointer to an array of xmlChar
  2915.  * @encoding:  a free form C string describing the HTML document encoding, or NULL
  2916.  *
  2917.  * Create a parser context for an HTML document.
  2918.  *
  2919.  * Returns the new parser context or NULL
  2920.  */
  2921. htmlParserCtxtPtr
  2922. htmlCreateDocParserCtxt(xmlChar *cur, const char *encoding) {
  2923.     htmlParserCtxtPtr ctxt;
  2924.     htmlParserInputPtr input;
  2925.     /* htmlCharEncoding enc; */
  2927.     ctxt = (htmlParserCtxtPtr) xmlMalloc(sizeof(htmlParserCtxt));
  2928.     if (ctxt == NULL) {
  2929.         perror("malloc");
  2930. return(NULL);
  2931.     }
  2932.     htmlInitParserCtxt(ctxt);
  2933.     input = (htmlParserInputPtr) xmlMalloc(sizeof(htmlParserInput));
  2934.     if (input == NULL) {
  2935.         perror("malloc");
  2936. xmlFree(ctxt);
  2937. return(NULL);
  2938.     }
  2939.     memset(input, 0, sizeof(htmlParserInput));
  2941.     input->line = 1;
  2942.     input->col = 1;
  2943.     input->base = cur;
  2944.     input->cur = cur;
  2946.     inputPush(ctxt, input);
  2947.     return(ctxt);
  2948. }
  2950. /************************************************************************
  2951.  * *
  2952.  *  Progressive parsing interfaces *
  2953.  * *
  2954.  ************************************************************************/
  2956. /**
  2957.  * htmlParseLookupSequence:
  2958.  * @ctxt:  an HTML parser context
  2959.  * @first:  the first char to lookup
  2960.  * @next:  the next char to lookup or zero
  2961.  * @third:  the next char to lookup or zero
  2962.  *
  2963.  * Try to find if a sequence (first, next, third) or  just (first next) or
  2964.  * (first) is available in the input stream.
  2965.  * This function has a side effect of (possibly) incrementing ctxt->checkIndex
  2966.  * to avoid rescanning sequences of bytes, it DOES change the state of the
  2967.  * parser, do not use liberally.
  2968.  * This is basically similar to xmlParseLookupSequence()
  2969.  *
  2970.  * Returns the index to the current parsing point if the full sequence
  2971.  *      is available, -1 otherwise.
  2972.  */
  2973. int
  2974. htmlParseLookupSequence(htmlParserCtxtPtr ctxt, xmlChar first,
  2975.                        xmlChar next, xmlChar third) {
  2976.     int base, len;
  2977.     htmlParserInputPtr in;
  2978.     const xmlChar *buf;
  2980.     in = ctxt->input;
  2981.     if (in == NULL) return(-1);
  2982.     base = in->cur - in->base;
  2983.     if (base < 0) return(-1);
  2984.     if (ctxt->checkIndex > base)
  2985.         base = ctxt->checkIndex;
  2986.     if (in->buf == NULL) {
  2987. buf = in->base;
  2988. len = in->length;
  2989.     } else {
  2990. buf = in->buf->buffer->content;
  2991. len = in->buf->buffer->use;
  2992.     }
  2993.     /* take into account the sequence length */
  2994.     if (third) len -= 2;
  2995.     else if (next) len --;
  2996.     for (;base < len;base++) {
  2997.         if (buf[base] == first) {
  2998.     if (third != 0) {
  2999. if ((buf[base + 1] != next) ||
  3000.     (buf[base + 2] != third)) continue;
  3001.     } else if (next != 0) {
  3002. if (buf[base + 1] != next) continue;
  3003.     }
  3004.     ctxt->checkIndex = 0;
  3005. #ifdef DEBUG_PUSH
  3006.     if (next == 0)
  3007. fprintf(stderr, "HPP: lookup '%c' found at %dn",
  3008. first, base);
  3009.     else if (third == 0)
  3010. fprintf(stderr, "HPP: lookup '%c%c' found at %dn",
  3011. first, next, base);
  3012.     else 
  3013. fprintf(stderr, "HPP: lookup '%c%c%c' found at %dn",
  3014. first, next, third, base);
  3015. #endif
  3016.     return(base - (in->cur - in->base));
  3017. }
  3018.     }
  3019.     ctxt->checkIndex = base;
  3020. #ifdef DEBUG_PUSH
  3021.     if (next == 0)
  3022. fprintf(stderr, "HPP: lookup '%c' failedn", first);
  3023.     else if (third == 0)
  3024. fprintf(stderr, "HPP: lookup '%c%c' failedn", first, next);
  3025.     else
  3026. fprintf(stderr, "HPP: lookup '%c%c%c' failedn", first, next, third);
  3027. #endif
  3028.     return(-1);
  3029. }
  3031. /**
  3032.  * htmlParseTryOrFinish:
  3033.  * @ctxt:  an HTML parser context
  3034.  * @terminate:  last chunk indicator
  3035.  *
  3036.  * Try to progress on parsing
  3037.  *
  3038.  * Returns zero if no parsing was possible
  3039.  */
  3040. int
  3041. htmlParseTryOrFinish(htmlParserCtxtPtr ctxt, int terminate) {
  3042.     int ret = 0;
  3043.     htmlParserInputPtr in;
  3044.     int avail;
  3045.     xmlChar cur, next;
  3047. #ifdef DEBUG_PUSH
  3048.     switch (ctxt->instate) {
  3049. case XML_PARSER_EOF:
  3050.     fprintf(stderr, "HPP: try EOFn"); break;
  3051. case XML_PARSER_START:
  3052.     fprintf(stderr, "HPP: try STARTn"); break;
  3053. case XML_PARSER_MISC:
  3054.     fprintf(stderr, "HPP: try MISCn");break;
  3055. case XML_PARSER_COMMENT:
  3056.     fprintf(stderr, "HPP: try COMMENTn");break;
  3057. case XML_PARSER_PROLOG:
  3058.     fprintf(stderr, "HPP: try PROLOGn");break;
  3059. case XML_PARSER_START_TAG:
  3060.     fprintf(stderr, "HPP: try START_TAGn");break;
  3061. case XML_PARSER_CONTENT:
  3062.     fprintf(stderr, "HPP: try CONTENTn");break;
  3063. case XML_PARSER_CDATA_SECTION:
  3064.     fprintf(stderr, "HPP: try CDATA_SECTIONn");break;
  3065. case XML_PARSER_END_TAG:
  3066.     fprintf(stderr, "HPP: try END_TAGn");break;
  3067. case XML_PARSER_ENTITY_DECL:
  3068.     fprintf(stderr, "HPP: try ENTITY_DECLn");break;
  3069. case XML_PARSER_ENTITY_VALUE:
  3070.     fprintf(stderr, "HPP: try ENTITY_VALUEn");break;
  3071. case XML_PARSER_ATTRIBUTE_VALUE:
  3072.     fprintf(stderr, "HPP: try ATTRIBUTE_VALUEn");break;
  3073. case XML_PARSER_DTD:
  3074.     fprintf(stderr, "HPP: try DTDn");break;
  3075. case XML_PARSER_EPILOG:
  3076.     fprintf(stderr, "HPP: try EPILOGn");break;
  3077. case XML_PARSER_PI:
  3078.     fprintf(stderr, "HPP: try PIn");break;
  3079.     }
  3080. #endif
  3082.     while (1) {
  3084. in = ctxt->input;
  3085. if (in == NULL) break;
  3086. if (in->buf == NULL)
  3087.     avail = in->length - (in->cur - in->base);
  3088. else
  3089.     avail = in->buf->buffer->use - (in->cur - in->base);
  3090.         if (avail < 1)
  3091.     goto done;
  3092.         switch (ctxt->instate) {
  3093.             case XML_PARSER_EOF:
  3094.         /*
  3095.  * Document parsing is done !
  3096.  */
  3097.         goto done;
  3098.             case XML_PARSER_START:
  3099.         /*
  3100.  * Very first chars read from the document flow.
  3101.  */
  3102. cur = in->cur[0];
  3103. if (IS_BLANK(cur)) {
  3104.     SKIP_BLANKS;
  3105.     if (in->buf == NULL)
  3106. avail = in->length - (in->cur - in->base);
  3107.     else
  3108. avail = in->buf->buffer->use - (in->cur - in->base);
  3109. }
  3110. if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
  3111.     ctxt->sax->setDocumentLocator(ctxt->userData,
  3112.   &xmlDefaultSAXLocator);
  3113. cur = in->cur[0];
  3114. next = in->cur[1];
  3115. if ((cur == '<') && (next == '!') &&
  3116.     (UPP(2) == 'D') && (UPP(3) == 'O') &&
  3117.     (UPP(4) == 'C') && (UPP(5) == 'T') &&
  3118.     (UPP(6) == 'Y') && (UPP(7) == 'P') &&
  3119.     (UPP(8) == 'E')) {
  3120.     if ((!terminate) &&
  3121.         (htmlParseLookupSequence(ctxt, '>', 0, 0) < 0))
  3122. goto done;
  3123. #ifdef DEBUG_PUSH
  3124.     fprintf(stderr, "HPP: Parsing internal subsetn");
  3125. #endif
  3126.     htmlParseDocTypeDecl(ctxt);
  3127.     ctxt->instate = XML_PARSER_PROLOG;
  3128. #ifdef DEBUG_PUSH
  3129.     fprintf(stderr, "HPP: entering PROLOGn");
  3130. #endif
  3131.                 } else {
  3132.     ctxt->myDoc = htmlNewDoc(NULL, NULL);
  3133.     ctxt->instate = XML_PARSER_MISC;
  3134. }
  3135. #ifdef DEBUG_PUSH
  3136. fprintf(stderr, "HPP: entering MISCn");
  3137. #endif
  3138. break;
  3139.             case XML_PARSER_MISC:
  3140. SKIP_BLANKS;
  3141. if (in->buf == NULL)
  3142.     avail = in->length - (in->cur - in->base);
  3143. else
  3144.     avail = in->buf->buffer->use - (in->cur - in->base);
  3145. if (avail < 2)
  3146.     goto done;
  3147. cur = in->cur[0];
  3148. next = in->cur[1];
  3149.         if ((cur == '<') && (next == '!') &&
  3150.     (in->cur[2] == '-') && (in->cur[3] == '-')) {
  3151.     if ((!terminate) &&
  3152.         (htmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
  3153. goto done;
  3154. #ifdef DEBUG_PUSH
  3155.     fprintf(stderr, "HPP: Parsing Commentn");
  3156. #endif
  3157.     htmlParseComment(ctxt);
  3158.     ctxt->instate = XML_PARSER_MISC;
  3159. } else if ((cur == '<') && (next == '!') &&
  3160.     (UPP(2) == 'D') && (UPP(3) == 'O') &&
  3161.     (UPP(4) == 'C') && (UPP(5) == 'T') &&
  3162.     (UPP(6) == 'Y') && (UPP(7) == 'P') &&
  3163.     (UPP(8) == 'E')) {
  3164.     if ((!terminate) &&
  3165.         (htmlParseLookupSequence(ctxt, '>', 0, 0) < 0))
  3166. goto done;
  3167. #ifdef DEBUG_PUSH
  3168.     fprintf(stderr, "HPP: Parsing internal subsetn");
  3169. #endif
  3170.     htmlParseDocTypeDecl(ctxt);
  3171.     ctxt->instate = XML_PARSER_PROLOG;
  3172. #ifdef DEBUG_PUSH
  3173.     fprintf(stderr, "HPP: entering PROLOGn");
  3174. #endif
  3175. } else if ((cur == '<') && (next == '!') &&
  3176.            (avail < 9)) {
  3177.     goto done;
  3178. } else {
  3179.     ctxt->instate = XML_PARSER_START_TAG;
  3180. #ifdef DEBUG_PUSH
  3181.     fprintf(stderr, "HPP: entering START_TAGn");
  3182. #endif
  3183. }
  3184. break;
  3185.             case XML_PARSER_PROLOG:
  3186. SKIP_BLANKS;
  3187. if (in->buf == NULL)
  3188.     avail = in->length - (in->cur - in->base);
  3189. else
  3190.     avail = in->buf->buffer->use - (in->cur - in->base);
  3191. if (avail < 2) 
  3192.     goto done;
  3193. cur = in->cur[0];
  3194. next = in->cur[1];
  3195. if ((cur == '<') && (next == '!') &&
  3196.     (in->cur[2] == '-') && (in->cur[3] == '-')) {
  3197.     if ((!terminate) &&
  3198.         (htmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
  3199. goto done;
  3200. #ifdef DEBUG_PUSH
  3201.     fprintf(stderr, "HPP: Parsing Commentn");
  3202. #endif
  3203.     htmlParseComment(ctxt);
  3204.     ctxt->instate = XML_PARSER_PROLOG;
  3205. } else if ((cur == '<') && (next == '!') &&
  3206.            (avail < 4)) {
  3207.     goto done;
  3208. } else {
  3209.     ctxt->instate = XML_PARSER_START_TAG;
  3210. #ifdef DEBUG_PUSH
  3211.     fprintf(stderr, "HPP: entering START_TAGn");
  3212. #endif
  3213. }
  3214. break;
  3215.             case XML_PARSER_EPILOG:
  3216. SKIP_BLANKS;
  3217. if (in->buf == NULL)
  3218.     avail = in->length - (in->cur - in->base);
  3219. else
  3220.     avail = in->buf->buffer->use - (in->cur - in->base);
  3221. if (avail < 2)
  3222.     goto done;
  3223. cur = in->cur[0];
  3224. next = in->cur[1];
  3225.         if ((cur == '<') && (next == '!') &&
  3226.     (in->cur[2] == '-') && (in->cur[3] == '-')) {
  3227.     if ((!terminate) &&
  3228.         (htmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
  3229. goto done;
  3230. #ifdef DEBUG_PUSH
  3231.     fprintf(stderr, "HPP: Parsing Commentn");
  3232. #endif
  3233.     htmlParseComment(ctxt);
  3234.     ctxt->instate = XML_PARSER_EPILOG;
  3235. } else if ((cur == '<') && (next == '!') &&
  3236.            (avail < 4)) {
  3237.     goto done;
  3238. } else {
  3239.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  3240. ctxt->sax->error(ctxt->userData,
  3241.     "Extra content at the end of the documentn");
  3242.     ctxt->wellFormed = 0;
  3243.     ctxt->errNo = XML_ERR_DOCUMENT_END;
  3244.     ctxt->instate = XML_PARSER_EOF;
  3245. #ifdef DEBUG_PUSH
  3246.     fprintf(stderr, "HPP: entering EOFn");
  3247. #endif
  3248.     if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
  3249. ctxt->sax->endDocument(ctxt->userData);
  3250.     goto done;
  3251. }
  3252. break;
  3253.             case XML_PARSER_START_TAG: {
  3254.         xmlChar *name, *oldname;
  3255. int depth = ctxt->nameNr;
  3256. htmlElemDescPtr info;
  3258. if (avail < 2)
  3259.     goto done;
  3260. cur = in->cur[0];
  3261.         if (cur != '<') {
  3262.     ctxt->instate = XML_PARSER_CONTENT;
  3263. #ifdef DEBUG_PUSH
  3264.     fprintf(stderr, "HPP: entering CONTENTn");
  3265. #endif
  3266.     break;
  3267. }
  3268. if ((!terminate) &&
  3269.     (htmlParseLookupSequence(ctxt, '>', 0, 0) < 0))
  3270.     goto done;
  3272. oldname = xmlStrdup(ctxt->name);
  3273. htmlParseStartTag(ctxt);
  3274. name = ctxt->name;
  3275. #ifdef DEBUG
  3276. if (oldname == NULL)
  3277.     fprintf(stderr, "Start of element %sn", name);
  3278. else if (name == NULL)
  3279.     fprintf(stderr, "Start of element failed, was %sn",
  3280.             oldname);
  3281. else
  3282.     fprintf(stderr, "Start of element %s, was %sn",
  3283.             name, oldname);
  3284. #endif
  3285. if (((depth == ctxt->nameNr) &&
  3286.      (!xmlStrcmp(oldname, ctxt->name))) ||
  3287.     (name == NULL)) {
  3288.     if (CUR == '>')
  3289. NEXT;
  3290.     if (oldname != NULL)
  3291. xmlFree(oldname);
  3292.     break;
  3293. }
  3294. if (oldname != NULL)
  3295.     xmlFree(oldname);
  3297. /*
  3298.  * Lookup the info for that element.
  3299.  */
  3300. info = htmlTagLookup(name);
  3301. if (info == NULL) {
  3302.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  3303. ctxt->sax->error(ctxt->userData, "Tag %s invalidn",
  3304.  name);
  3305.     ctxt->wellFormed = 0;
  3306. } else if (info->depr) {
  3307.     /***************************
  3308.     if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
  3309. ctxt->sax->warning(ctxt->userData,
  3310.                    "Tag %s is deprecatedn",
  3311.    name);
  3312.      ***************************/
  3313. }
  3315. /*
  3316.  * Check for an Empty Element labelled the XML/SGML way
  3317.  */
  3318. if ((CUR == '/') && (NXT(1) == '>')) {
  3319.     SKIP(2);
  3320.     if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
  3321. ctxt->sax->endElement(ctxt->userData, name);
  3322.     oldname = htmlnamePop(ctxt);
  3323. #ifdef DEBUG
  3324.     fprintf(stderr,"End of tag the XML way: popping out %sn",
  3325.             oldname);
  3326. #endif
  3327.     if (oldname != NULL)
  3328. xmlFree(oldname);
  3329.     ctxt->instate = XML_PARSER_CONTENT;
  3330. #ifdef DEBUG_PUSH
  3331.     fprintf(stderr, "HPP: entering CONTENTn");
  3332. #endif
  3333.     break;
  3334. }
  3336. if (CUR == '>') {
  3337.     NEXT;
  3338. } else {
  3339.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  3340. ctxt->sax->error(ctxt->userData, 
  3341.                  "Couldn't find end of Start Tag %sn",
  3342.  name);
  3343.     ctxt->wellFormed = 0;
  3345.     /*
  3346.      * end of parsing of this node.
  3347.      */
  3348.     if (!xmlStrcmp(name, ctxt->name)) { 
  3349. nodePop(ctxt);
  3350. oldname = htmlnamePop(ctxt);
  3351. #ifdef DEBUG
  3352. fprintf(stderr,
  3353.  "End of start tag problem: popping out %sn", oldname);
  3354. #endif
  3355. if (oldname != NULL)
  3356.     xmlFree(oldname);
  3357.     }    
  3359.     ctxt->instate = XML_PARSER_CONTENT;
  3360. #ifdef DEBUG_PUSH
  3361.     fprintf(stderr, "HPP: entering CONTENTn");
  3362. #endif
  3363.     break;
  3364. }
  3366. /*
  3367.  * Check for an Empty Element from DTD definition
  3368.  */
  3369. if ((info != NULL) && (info->empty)) {
  3370.     if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
  3371. ctxt->sax->endElement(ctxt->userData, name);
  3372.     oldname = htmlnamePop(ctxt);
  3373. #ifdef DEBUG
  3374.     fprintf(stderr,"End of empty tag %s : popping out %sn", name, oldname);
  3375. #endif
  3376.     if (oldname != NULL)
  3377. xmlFree(oldname);
  3378. }
  3379. ctxt->instate = XML_PARSER_CONTENT;
  3380. #ifdef DEBUG_PUSH
  3381. fprintf(stderr, "HPP: entering CONTENTn");
  3382. #endif
  3383.                 break;
  3384.     }
  3385.             case XML_PARSER_CONTENT:
  3386.                 /*
  3387.  * Handle preparsed entities and charRef
  3388.  */
  3389. if (ctxt->token != 0) {
  3390.     xmlChar cur[2] = { 0 , 0 } ;
  3392.     cur[0] = (xmlChar) ctxt->token;
  3393.     if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL))
  3394. ctxt->sax->characters(ctxt->userData, cur, 1);
  3395.     ctxt->token = 0;
  3396.     ctxt->checkIndex = 0;
  3397. }
  3398. if (avail < 2)
  3399.     goto done;
  3400. cur = in->cur[0];
  3401. next = in->cur[1];
  3402.         if ((cur == '<') && (next == '!') &&
  3403.     (in->cur[2] == '-') && (in->cur[3] == '-')) {
  3404.     if ((!terminate) &&
  3405.         (htmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
  3406. goto done;
  3407. #ifdef DEBUG_PUSH
  3408.     fprintf(stderr, "HPP: Parsing Commentn");
  3409. #endif
  3410.     htmlParseComment(ctxt);
  3411.     ctxt->instate = XML_PARSER_CONTENT;
  3412.         } else if ((cur == '<') && (next == '!') && (avail < 4)) {
  3413.     goto done;
  3414. } else if ((cur == '<') && (next == '/')) {
  3415.     ctxt->instate = XML_PARSER_END_TAG;
  3416.     ctxt->checkIndex = 0;
  3417. #ifdef DEBUG_PUSH
  3418.     fprintf(stderr, "HPP: entering END_TAGn");
  3419. #endif
  3420.     break;
  3421. } else if (cur == '<') {
  3422.     ctxt->instate = XML_PARSER_START_TAG;
  3423.     ctxt->checkIndex = 0;
  3424. #ifdef DEBUG_PUSH
  3425.     fprintf(stderr, "HPP: entering START_TAGn");
  3426. #endif
  3427.     break;
  3428. } else if (cur == '&') {
  3429.     if ((!terminate) &&
  3430.         (htmlParseLookupSequence(ctxt, ';', 0, 0) < 0))
  3431. goto done;
  3432. #ifdef DEBUG_PUSH
  3433.     fprintf(stderr, "HPP: Parsing Referencen");
  3434. #endif
  3435.     /* TODO: check generation of subtrees if noent !!! */
  3436.     htmlParseReference(ctxt);
  3437. } else {
  3438.     /* TODO Avoid the extra copy, handle directly !!!!!! */
  3439.     /*
  3440.      * Goal of the following test is :
  3441.      *  - minimize calls to the SAX 'character' callback
  3442.      *    when they are mergeable
  3443.      */
  3444.     if ((ctxt->inputNr == 1) &&
  3445.         (avail < HTML_PARSER_BIG_BUFFER_SIZE)) {
  3446. if ((!terminate) &&
  3447.     (htmlParseLookupSequence(ctxt, '<', 0, 0) < 0))
  3448.     goto done;
  3449.                     }
  3450.     ctxt->checkIndex = 0;
  3451. #ifdef DEBUG_PUSH
  3452.     fprintf(stderr, "HPP: Parsing char datan");
  3453. #endif
  3454.     htmlParseCharData(ctxt, 0);
  3455. }
  3456. break;
  3457.             case XML_PARSER_END_TAG:
  3458. if (avail < 2)
  3459.     goto done;
  3460. if ((!terminate) &&
  3461.     (htmlParseLookupSequence(ctxt, '>', 0, 0) < 0))
  3462.     goto done;
  3463. htmlParseEndTag(ctxt);
  3464. if (ctxt->nameNr == 0) {
  3465.     ctxt->instate = XML_PARSER_EPILOG;
  3466. } else {
  3467.     ctxt->instate = XML_PARSER_CONTENT;
  3468. }
  3469. ctxt->checkIndex = 0;
  3470. #ifdef DEBUG_PUSH
  3471. fprintf(stderr, "HPP: entering CONTENTn");
  3472. #endif
  3473.         break;
  3474.             case XML_PARSER_CDATA_SECTION:
  3475. fprintf(stderr, "HPP: internal error, state == CDATAn");
  3476. ctxt->instate = XML_PARSER_CONTENT;
  3477. ctxt->checkIndex = 0;
  3478. #ifdef DEBUG_PUSH
  3479. fprintf(stderr, "HPP: entering CONTENTn");
  3480. #endif
  3481. break;
  3482.             case XML_PARSER_DTD:
  3483. fprintf(stderr, "HPP: internal error, state == DTDn");
  3484. ctxt->instate = XML_PARSER_CONTENT;
  3485. ctxt->checkIndex = 0;
  3486. #ifdef DEBUG_PUSH
  3487. fprintf(stderr, "HPP: entering CONTENTn");
  3488. #endif
  3489. break;
  3490.             case XML_PARSER_COMMENT:
  3491. fprintf(stderr, "HPP: internal error, state == COMMENTn");
  3492. ctxt->instate = XML_PARSER_CONTENT;
  3493. ctxt->checkIndex = 0;
  3494. #ifdef DEBUG_PUSH
  3495. fprintf(stderr, "HPP: entering CONTENTn");
  3496. #endif
  3497. break;
  3498.             case XML_PARSER_PI:
  3499. fprintf(stderr, "HPP: internal error, state == PIn");
  3500. ctxt->instate = XML_PARSER_CONTENT;
  3501. ctxt->checkIndex = 0;
  3502. #ifdef DEBUG_PUSH
  3503. fprintf(stderr, "HPP: entering CONTENTn");
  3504. #endif
  3505. break;
  3506.             case XML_PARSER_ENTITY_DECL:
  3507. fprintf(stderr, "HPP: internal error, state == ENTITY_DECLn");
  3508. ctxt->instate = XML_PARSER_CONTENT;
  3509. ctxt->checkIndex = 0;
  3510. #ifdef DEBUG_PUSH
  3511. fprintf(stderr, "HPP: entering CONTENTn");
  3512. #endif
  3513. break;
  3514.             case XML_PARSER_ENTITY_VALUE:
  3515. fprintf(stderr, "HPP: internal error, state == ENTITY_VALUEn");
  3516. ctxt->instate = XML_PARSER_CONTENT;
  3517. ctxt->checkIndex = 0;
  3518. #ifdef DEBUG_PUSH
  3519. fprintf(stderr, "HPP: entering DTDn");
  3520. #endif
  3521. break;
  3522.             case XML_PARSER_ATTRIBUTE_VALUE:
  3523. fprintf(stderr, "HPP: internal error, state == ATTRIBUTE_VALUEn");
  3524. ctxt->instate = XML_PARSER_START_TAG;
  3525. ctxt->checkIndex = 0;
  3526. #ifdef DEBUG_PUSH
  3527. fprintf(stderr, "HPP: entering START_TAGn");
  3528. #endif
  3529. break;
  3530. }
  3531.     }
  3532. done:    
  3533. #ifdef DEBUG_PUSH
  3534.     fprintf(stderr, "HPP: done %dn", ret);
  3535. #endif
  3536.     return(ret);
  3537. }
  3539. /**
  3540.  * htmlParseTry:
  3541.  * @ctxt:  an HTML parser context
  3542.  *
  3543.  * Try to progress on parsing
  3544.  *
  3545.  * Returns zero if no parsing was possible
  3546.  */
  3547. int
  3548. htmlParseTry(htmlParserCtxtPtr ctxt) {
  3549.     return(htmlParseTryOrFinish(ctxt, 0));
  3550. }
  3552. /**
  3553.  * htmlParseChunk:
  3554.  * @ctxt:  an XML parser context
  3555.  * @chunk:  an char array
  3556.  * @size:  the size in byte of the chunk
  3557.  * @terminate:  last chunk indicator
  3558.  *
  3559.  * Parse a Chunk of memory
  3560.  *
  3561.  * Returns zero if no error, the xmlParserErrors otherwise.
  3562.  */
  3563. int
  3564. htmlParseChunk(htmlParserCtxtPtr ctxt, const char *chunk, int size,
  3565.               int terminate) {
  3566.     if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
  3567.         (ctxt->input->buf != NULL) && (ctxt->instate != XML_PARSER_EOF))  {
  3568. int base = ctxt->input->base - ctxt->input->buf->buffer->content;
  3569. int cur = ctxt->input->cur - ctxt->input->base;
  3571. xmlParserInputBufferPush(ctxt->input->buf, size, chunk);       
  3572. ctxt->input->base = ctxt->input->buf->buffer->content + base;
  3573. ctxt->input->cur = ctxt->input->base + cur;
  3574. #ifdef DEBUG_PUSH
  3575. fprintf(stderr, "HPP: pushed %dn", size);
  3576. #endif
  3578. if ((terminate) || (ctxt->input->buf->buffer->use > 80))
  3579.     htmlParseTryOrFinish(ctxt, terminate);
  3580.     } else if (ctxt->instate != XML_PARSER_EOF)
  3581.         htmlParseTryOrFinish(ctxt, terminate);
  3582.     if (terminate) {
  3583. if ((ctxt->instate != XML_PARSER_EOF) &&
  3584.     (ctxt->instate != XML_PARSER_EPILOG) &&
  3585.     (ctxt->instate != XML_PARSER_MISC)) {
  3586.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  3587. ctxt->sax->error(ctxt->userData,
  3588.     "Extra content at the end of the documentn");
  3589.     ctxt->wellFormed = 0;
  3590.     ctxt->errNo = XML_ERR_DOCUMENT_END;
  3591. } 
  3592. if (ctxt->instate != XML_PARSER_EOF) {
  3593.     if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
  3594. ctxt->sax->endDocument(ctxt->userData);
  3595. }
  3596. ctxt->instate = XML_PARSER_EOF;
  3597.     }
  3598.     return((xmlParserErrors) ctxt->errNo);       
  3599. }
  3601. /************************************************************************
  3602.  * *
  3603.  * User entry points *
  3604.  * *
  3605.  ************************************************************************/
  3607. /**
  3608.  * htmlCreatePushParserCtxt :
  3609.  * @sax:  a SAX handler
  3610.  * @user_data:  The user data returned on SAX callbacks
  3611.  * @chunk:  a pointer to an array of chars
  3612.  * @size:  number of chars in the array
  3613.  * @filename:  an optional file name or URI
  3614.  * @enc:  an optional encoding
  3615.  *
  3616.  * Create a parser context for using the HTML parser in push mode
  3617.  * To allow content encoding detection, @size should be >= 4
  3618.  * The value of @filename is used for fetching external entities
  3619.  * and error/warning reports.
  3620.  *
  3621.  * Returns the new parser context or NULL
  3622.  */
  3623. htmlParserCtxtPtr
  3624. htmlCreatePushParserCtxt(htmlSAXHandlerPtr sax, void *user_data, 
  3625.                          const char *chunk, int size, const char *filename,
  3626.  xmlCharEncoding enc) {
  3627.     htmlParserCtxtPtr ctxt;
  3628.     htmlParserInputPtr inputStream;
  3629.     xmlParserInputBufferPtr buf;
  3631.     buf = xmlAllocParserInputBuffer(enc);
  3632.     if (buf == NULL) return(NULL);
  3634.     ctxt = (htmlParserCtxtPtr) xmlMalloc(sizeof(htmlParserCtxt));
  3635.     if (ctxt == NULL) {
  3636. xmlFree(buf);
  3637. return(NULL);
  3638.     }
  3639.     memset(ctxt, 0, sizeof(htmlParserCtxt));
  3640.     htmlInitParserCtxt(ctxt);
  3641.     if (sax != NULL) {
  3642. if (ctxt->sax != &htmlDefaultSAXHandler)
  3643.     xmlFree(ctxt->sax);
  3644. ctxt->sax = (htmlSAXHandlerPtr) xmlMalloc(sizeof(htmlSAXHandler));
  3645. if (ctxt->sax == NULL) {
  3646.     xmlFree(buf);
  3647.     xmlFree(ctxt);
  3648.     return(NULL);
  3649. }
  3650. memcpy(ctxt->sax, sax, sizeof(htmlSAXHandler));
  3651. if (user_data != NULL)
  3652.     ctxt->userData = user_data;
  3653.     }
  3654.     if (filename == NULL) {
  3655. ctxt->directory = NULL;
  3656.     } else {
  3657.         ctxt->directory = xmlParserGetDirectory(filename);
  3658.     }
  3660.     inputStream = htmlNewInputStream(ctxt);
  3661.     if (inputStream == NULL) {
  3662. xmlFreeParserCtxt(ctxt);
  3663. return(NULL);
  3664.     }
  3666.     if (filename == NULL)
  3667. inputStream->filename = NULL;
  3668.     else
  3669. inputStream->filename = xmlMemStrdup(filename);
  3670.     inputStream->buf = buf;
  3671.     inputStream->base = inputStream->buf->buffer->content;
  3672.     inputStream->cur = inputStream->buf->buffer->content;
  3674.     inputPush(ctxt, inputStream);
  3676.     if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
  3677.         (ctxt->input->buf != NULL))  {       
  3678. xmlParserInputBufferPush(ctxt->input->buf, size, chunk);       
  3679. #ifdef DEBUG_PUSH
  3680. fprintf(stderr, "HPP: pushed %dn", size);
  3681. #endif
  3682.     }
  3684.     return(ctxt);
  3685. }
  3687. /**
  3688.  * htmlSAXParseDoc :
  3689.  * @cur:  a pointer to an array of xmlChar
  3690.  * @encoding:  a free form C string describing the HTML document encoding, or NULL
  3691.  * @sax:  the SAX handler block
  3692.  * @userData: if using SAX, this pointer will be provided on callbacks. 
  3693.  *
  3694.  * parse an HTML in-memory document and build a tree.
  3695.  * It use the given SAX function block to handle the parsing callback.
  3696.  * If sax is NULL, fallback to the default DOM tree building routines.
  3697.  * 
  3698.  * Returns the resulting document tree
  3699.  */
  3701. htmlDocPtr
  3702. htmlSAXParseDoc(xmlChar *cur, const char *encoding, htmlSAXHandlerPtr sax, void *userData) {
  3703.     htmlDocPtr ret;
  3704.     htmlParserCtxtPtr ctxt;
  3706.     if (cur == NULL) return(NULL);
  3709.     ctxt = htmlCreateDocParserCtxt(cur, encoding);
  3710.     if (ctxt == NULL) return(NULL);
  3711.     if (sax != NULL) { 
  3712.         ctxt->sax = sax;
  3713.         ctxt->userData = userData;
  3714.     }
  3716.     htmlParseDocument(ctxt);
  3717.     ret = ctxt->myDoc;
  3718.     if (sax != NULL) {
  3719. ctxt->sax = NULL;
  3720. ctxt->userData = NULL;
  3721.     }
  3722.     htmlFreeParserCtxt(ctxt);
  3723.     
  3724.     return(ret);
  3725. }
  3727. /**
  3728.  * htmlParseDoc :
  3729.  * @cur:  a pointer to an array of xmlChar
  3730.  * @encoding:  a free form C string describing the HTML document encoding, or NULL
  3731.  *
  3732.  * parse an HTML in-memory document and build a tree.
  3733.  * 
  3734.  * Returns the resulting document tree
  3735.  */
  3737. htmlDocPtr
  3738. htmlParseDoc(xmlChar *cur, const char *encoding) {
  3739.     return(htmlSAXParseDoc(cur, encoding, NULL, NULL));
  3740. }
  3743. /**
  3744.  * htmlCreateFileParserCtxt :
  3745.  * @filename:  the filename
  3746.  * @encoding:  a free form C string describing the HTML document encoding, or NULL
  3747.  *
  3748.  * Create a parser context for a file content. 
  3749.  * Automatic support for ZLIB/Compress compressed document is provided
  3750.  * by default if found at compile-time.
  3751.  *
  3752.  * Returns the new parser context or NULL
  3753.  */
  3754. htmlParserCtxtPtr
  3755. htmlCreateFileParserCtxt(const char *filename, const char *encoding)
  3756. {
  3757.     htmlParserCtxtPtr ctxt;
  3758.     htmlParserInputPtr inputStream;
  3759.     xmlParserInputBufferPtr buf;
  3760.     /* htmlCharEncoding enc; */
  3762.     buf = xmlParserInputBufferCreateFilename(filename, XML_CHAR_ENCODING_NONE);
  3763.     if (buf == NULL) return(NULL);
  3765.     ctxt = (htmlParserCtxtPtr) xmlMalloc(sizeof(htmlParserCtxt));
  3766.     if (ctxt == NULL) {
  3767.         perror("malloc");
  3768. return(NULL);
  3769.     }
  3770.     memset(ctxt, 0, sizeof(htmlParserCtxt));
  3771.     htmlInitParserCtxt(ctxt);
  3772.     inputStream = (htmlParserInputPtr) xmlMalloc(sizeof(htmlParserInput));
  3773.     if (inputStream == NULL) {
  3774.         perror("malloc");
  3775. xmlFree(ctxt);
  3776. return(NULL);
  3777.     }
  3778.     memset(inputStream, 0, sizeof(htmlParserInput));
  3780.     inputStream->filename = xmlMemStrdup(filename);
  3781.     inputStream->line = 1;
  3782.     inputStream->col = 1;
  3783.     inputStream->buf = buf;
  3784.     inputStream->directory = NULL;
  3786.     inputStream->base = inputStream->buf->buffer->content;
  3787.     inputStream->cur = inputStream->buf->buffer->content;
  3788.     inputStream->free = NULL;
  3790.     inputPush(ctxt, inputStream);
  3791.     return(ctxt);
  3792. }
  3794. /**
  3795.  * htmlSAXParseFile :
  3796.  * @filename:  the filename
  3797.  * @encoding:  a free form C string describing the HTML document encoding, or NULL
  3798.  * @sax:  the SAX handler block
  3799.  * @userData: if using SAX, this pointer will be provided on callbacks. 
  3800.  *
  3801.  * parse an HTML file and build a tree. Automatic support for ZLIB/Compress
  3802.  * compressed document is provided by default if found at compile-time.
  3803.  * It use the given SAX function block to handle the parsing callback.
  3804.  * If sax is NULL, fallback to the default DOM tree building routines.
  3805.  *
  3806.  * Returns the resulting document tree
  3807.  */
  3809. htmlDocPtr
  3810. htmlSAXParseFile(const char *filename, const char *encoding, htmlSAXHandlerPtr sax, 
  3811.                  void *userData) {
  3812.     htmlDocPtr ret;
  3813.     htmlParserCtxtPtr ctxt;
  3815.     ctxt = htmlCreateFileParserCtxt(filename, encoding);
  3816.     if (ctxt == NULL) return(NULL);
  3817.     if (sax != NULL) {
  3818.         ctxt->sax = sax;
  3819.         ctxt->userData = userData;
  3820.     }
  3822.     htmlParseDocument(ctxt);
  3824.     ret = ctxt->myDoc;
  3825.     if (sax != NULL) {
  3826.         ctxt->sax = NULL;
  3827.         ctxt->userData = NULL;
  3828.     }
  3829.     htmlFreeParserCtxt(ctxt);
  3830.     
  3831.     return(ret);
  3832. }
  3834. /**
  3835.  * htmlParseFile :
  3836.  * @filename:  the filename
  3837.  * @encoding:  a free form C string describing the HTML document encoding, or NULL
  3838.  *
  3839.  * parse an HTML file and build a tree. Automatic support for ZLIB/Compress
  3840.  * compressed document is provided by default if found at compile-time.
  3841.  *
  3842.  * Returns the resulting document tree
  3843.  */
  3845. htmlDocPtr
  3846. htmlParseFile(const char *filename, const char *encoding) {
  3847.     return(htmlSAXParseFile(filename, encoding, NULL, NULL));
  3848. }
  3850. #endif /* LIBXML_HTML_ENABLED */