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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 手机WAP编程 > 查看源码
decompile.c
资源名称：gateway-1.2.1　[点击查看]
上传用户：gzpyjq
上传日期：2013-01-31
资源大小：1852k
文件大小：41k
源码类别：

手机WAP编程

开发平台：

WINDOWS

decompile.c：源码内容
  1. /*
  2.  * decompile.c - A program to test the WML compiler. This tool was written
  3.  *               from the WBXML 1.2 and WML 1.1 specs.
  4.  *
  5.  * Author: Chris Wulff, Vanteon (cwulff@vanteon.com)
  6.  *
  7.  */
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #include <memory.h>
  12. #include <string.h>
  14. #include "decompile.h"
  16. const WBXML_MB_U_INT32 ZERO_WBXML_MB_U_INT32 = {0,0,0,0};
  17. long dtd_id;
  19. #define INDENT_SIZE 4
  21. DTD_TYPE_LIST DTDTypeList[] =
  22. {
  23. {1, "UNKNOWN"},
  24. {2, "-//WAPFORUM//DTD WML 1.0//EN"n"
  25.  ""http://www.wapforum.org/DTD/wml.xml"},
  26. {3, "-//WAPFORUM//DTD WTA 1.0//EN"},
  27. {4, "-//WAPFORUM//DTD WML 1.1//EN"n"
  28.  ""http://www.wapforum.org/DTD/wml_1.1.xml"},
  29. {5, "-//WAPFORUM//DTD SI 1.0//EN"n"
  30.  ""http://www.wapforum.org/DTD/si.dtd"},
  31. {6, "-//WAPFORUM//DTD SL 1.0//EN"n"
  32.  ""http://www.wapforum.org/DTD/sl.dtd"},
  33. {7, "-//WAPFORUM//DTD CO 1.0//EN"},
  34. {8, "-//WAPFORUM//DTD CHANNEL 1.1//EN"},
  35. {9, "-//WAPFORUM//DTD WML 1.2//EN"n"
  36.  ""http://www.wapforum.org/DTD/wml12.dtd"},
  37. {0, NULL}
  38. };
  41. /**************************************
  42.  * DTD Public Type 4 (WML 1.1) Tables *
  43.  **************************************/
  45. CODEPAGE_TAG_NAME_LIST CodepageTagNames[] =
  46. {
  47. {4, "a",         0, 0x1c},
  48. {4, "anchor",    0, 0x22},
  49. {4, "access",    0, 0x23},
  50. {4, "b",         0, 0x24},
  51. {4, "big",       0, 0x25},
  52. {4, "br",        0, 0x26},
  53. {4, "card",      0, 0x27},
  54. {4, "do",        0, 0x28},
  55. {4, "em",        0, 0x29},
  56. {4, "fieldset",  0, 0x2a},
  57. {4, "go",        0, 0x2b},
  58. {4, "head",      0, 0x2c},
  59. {4, "i",         0, 0x2d},
  60. {4, "img",       0, 0x2e},
  61. {4, "input",     0, 0x2f},
  62. {4, "meta",      0, 0x30},
  63. {4, "noop",      0, 0x31},
  64. {4, "p",         0, 0x20},
  65. {4, "postfield", 0, 0x21},
  66. {4, "pre",       0, 0x1b},
  67. {4, "prev",      0, 0x32},
  68. {4, "onevent",   0, 0x33},
  69. {4, "optgroup",  0, 0x34},
  70. {4, "option",    0, 0x35},
  71. {4, "refresh",   0, 0x36},
  72. {4, "select",    0, 0x37},
  73. {4, "setvar",    0, 0x3e},
  74. {4, "small",     0, 0x38},
  75. {4, "strong",    0, 0x39},
  76. {4, "table",     0, 0x1f},
  77. {4, "td",        0, 0x1d},
  78. {4, "template",  0, 0x3b},
  79. {4, "timer",     0, 0x3c},
  80. {4, "tr",        0, 0x1e},
  81. {4, "u",         0, 0x3d},
  82. {4, "wml",       0, 0x3f},
  84. {6, "TAG_05",    1, 0x05},
  85. {6, "TAG_06",    1, 0x06},
  86. {6, "TAG_07",    1, 0x07},
  88. {0, NULL, 0, 0}
  89. };
  91. CODEPAGE_ATTRSTART_NAME_LIST CodepageAttrstartNames[] =
  92. {
  93. {4, "accept-charset",  NULL,                                0, 0x05},
  94. {4, "accesskey",       NULL,                                0, 0x5e},
  95. {4, "align",           NULL,                                0, 0x52},
  96. {4, "align",           "bottom",                            0, 0x06},
  97. {4, "align",           "center",                            0, 0x07},
  98. {4, "align",           "left",                              0, 0x08},
  99. {4, "align",           "middle",                            0, 0x09},
  100. {4, "align",           "right",                             0, 0x0a},
  101. {4, "align",           "top",                               0, 0x0b},
  102. {4, "alt",             NULL,                                0, 0x0c},
  103. {4, "class",           NULL,                                0, 0x54},
  104. {4, "columns",         NULL,                                0, 0x53},
  105. {4, "content",         NULL,                                0, 0x0d},
  106. {4, "content",         "application/vnd.wap.wmlc;charset=", 0, 0x5c},
  107. {4, "domain",          NULL,                                0, 0x0f},
  108. {4, "emptyok",         "false",                             0, 0x10},
  109. {4, "emptyok",         "true",                              0, 0x11},
  110. {4, "enctype",         NULL,                                0, 0x5f},
  111. {4, "enctype",         "application/x-www-form-urlencoded", 0, 0x60},
  112. {4, "enctype",         "multipart/form-data",               0, 0x61},
  113. {4, "format",          NULL,                                0, 0x12},
  114. {4, "forua",           "false",                             0, 0x56},
  115. {4, "forua",           "true",                              0, 0x57},
  116. {4, "height",          NULL,                                0, 0x13},
  117. {4, "href",            NULL,                                0, 0x4a},
  118. {4, "href",            "http://",                           0, 0x4b},
  119. {4, "href",            "https://",                          0, 0x4c},
  120. {4, "hspace",          NULL,                                0, 0x14},
  121. {4, "http-equiv",      NULL,                                0, 0x5a},
  122. {4, "http-equiv",      "Content-Type",                      0, 0x5b},
  123. {4, "http-equiv",      "Expires",                           0, 0x5d},
  124. {4, "id",              NULL,                                0, 0x55},
  125. {4, "ivalue",          NULL,                                0, 0x15},
  126. {4, "iname",           NULL,                                0, 0x16},
  127. {4, "label",           NULL,                                0, 0x18},
  128. {4, "localsrc",        NULL,                                0, 0x19},
  129. {4, "maxlength",       NULL,                                0, 0x1a},
  130. {4, "method",          "get",                               0, 0x1b},
  131. {4, "method",          "post",                              0, 0x1c},
  132. {4, "mode",            "nowrap",                            0, 0x1d},
  133. {4, "mode",            "wrap",                              0, 0x1e},
  134. {4, "multiple",        "false",                             0, 0x1f},
  135. {4, "multiple",        "true",                              0, 0x20},
  136. {4, "name",            NULL,                                0, 0x21},
  137. {4, "newcontext",      "false",                             0, 0x22},
  138. {4, "newcontext",      "true",                              0, 0x23},
  139. {4, "onenterbackward", NULL,                                0, 0x25},
  140. {4, "onenterforward",  NULL,                                0, 0x26},
  141. {4, "onpick",          NULL,                                0, 0x24},
  142. {4, "ontimer",         NULL,                                0, 0x27},
  143. {4, "optional",        "false",                             0, 0x28},
  144. {4, "optional",        "true",                              0, 0x29},
  145. {4, "path",            NULL,                                0, 0x2a},
  146. {4, "scheme",          NULL,                                0, 0x2e},
  147. {4, "sendreferer",     "false",                             0, 0x2f},
  148. {4, "sendreferer",     "true",                              0, 0x30},
  149. {4, "size",            NULL,                                0, 0x31},
  150. {4, "src",             NULL,                                0, 0x32},
  151. {4, "src",             "http://",                           0, 0x58},
  152. {4, "src",             "https://",                          0, 0x59},
  153. {4, "ordered",         "true",                              0, 0x33},
  154. {4, "ordered",         "false",                             0, 0x34},
  155. {4, "tabindex",        NULL,                                0, 0x35},
  156. {4, "title",           NULL,                                0, 0x36},
  157. {4, "type",            NULL,                                0, 0x37},
  158. {4, "type",            "accept",                            0, 0x38},
  159. {4, "type",            "delete",                            0, 0x39},
  160. {4, "type",            "help",                              0, 0x3a},
  161. {4, "type",            "password",                          0, 0x3b},
  162. {4, "type",            "onpick",                            0, 0x3c},
  163. {4, "type",            "onenterbackward",                   0, 0x3d},
  164. {4, "type",            "onenterforward",                    0, 0x3e},
  165. {4, "type",            "ontimer",                           0, 0x3f},
  166. {4, "type",            "options",                           0, 0x45},
  167. {4, "type",            "prev",                              0, 0x46},
  168. {4, "type",            "reset",                             0, 0x47},
  169. {4, "type",            "text",                              0, 0x48},
  170. {4, "type",            "vnd.",                              0, 0x49},
  171. {4, "value",           NULL,                                0, 0x4d},
  172. {4, "vspace",          NULL,                                0, 0x4e},
  173. {4, "width",           NULL,                                0, 0x4f},
  174. {4, "xml:lang",        NULL,                                0, 0x50},
  176. {6, "ATTR_06",         NULL,                                1, 0x06},
  177. {6, "ATTR_07",         NULL,                                1, 0x07},
  178. {6, "ATTR_08",         NULL,                                1, 0x08},
  179. {6, "ATTR_11",         NULL,                                1, 0x11},
  180. {6, "ATTR_12",         NULL,                                1, 0x12},
  181. {6, "ATTR_13",         NULL,                                1, 0x13},
  182. {6, "ATTR_14",         NULL,                                1, 0x14},
  183. {6, "ATTR_15",         NULL,                                1, 0x15},
  184. {6, "ATTR_21",         NULL,                                1, 0x21},
  185. {6, "ATTR_22",         NULL,                                1, 0x22},
  186. {6, "ATTR_23",         NULL,                                1, 0x23},
  187. {6, "ATTR_24",         NULL,                                1, 0x24},
  188. {6, "ATTR_28",         NULL,                                1, 0x28},
  189. {6, "ATTR_29",         NULL,                                1, 0x29},
  190. {6, "ATTR_45",         NULL,                                1, 0x45},
  191. {6, "ATTR_61",         NULL,                                1, 0x61},
  192. {6, "ATTR_62",         NULL,                                1, 0x62},
  193. {6, "ATTR_63",         NULL,                                1, 0x63},
  194. {6, "ATTR_64",         NULL,                                1, 0x64},
  195. {6, "ATTR_6A",         NULL,                                1, 0x6A},
  196. {6, "ATTR_6B",         NULL,                                1, 0x6B},
  197. {6, "ATTR_6C",         NULL,                                1, 0x6C},
  198. {6, "ATTR_70",         NULL,                                1, 0x70},
  199. {6, "ATTR_71",         NULL,                                1, 0x71},
  200. {6, "ATTR_73",         NULL,                                1, 0x73},
  201. {6, "ATTR_74",         NULL,                                1, 0x74},
  203. {0, NULL,              NULL,                                0, 0}
  204. };
  206. CODEPAGE_ATTRVALUE_NAME_LIST CodepageAttrvalueNames[] =
  207. {
  208. {4, ".com/",           0, 0x85},
  209. {4, ".edu/",           0, 0x86},
  210. {4, ".net/",           0, 0x87},
  211. {4, ".org/",           0, 0x88},
  212. {4, "accept",          0, 0x89},
  213. {4, "bottom",          0, 0x8a},
  214. {4, "clear",           0, 0x8b},
  215. {4, "delete",          0, 0x8c},
  216. {4, "help",            0, 0x8d},
  217. {4, "http://",         0, 0x8e},
  218. {4, "http://www.",     0, 0x8f},
  219. {4, "https://",        0, 0x90},
  220. {4, "https://www.",    0, 0x91},
  221. {4, "middle",          0, 0x93},
  222. {4, "nowrap",          0, 0x94},
  223. {4, "onenterbackward", 0, 0x96},
  224. {4, "onenterforward",  0, 0x97},
  225. {4, "onpick",          0, 0x95},
  226. {4, "ontimer",         0, 0x98},
  227. {4, "options",         0, 0x99},
  228. {4, "password",        0, 0x9a},
  229. {4, "reset",           0, 0x9b},
  230. {4, "text",            0, 0x9d},
  231. {4, "top",             0, 0x9e},
  232. {4, "unknown",         0, 0x9f},
  233. {4, "wrap",            0, 0xa0},
  234. {4, "www.",            0, 0xa1},
  235. {0, NULL, 0, 0}
  236. };
  239. /**************************
  240.  * Node Tree Construction *
  241.  **************************/
  243. /*
  244.  * Function: NewNode
  245.  *
  246.  * Description:
  247.  *
  248.  *  Allocate and initialize a new node. This links the new node
  249.  *  as the first child of the current node in the buffer. This causes
  250.  *  child nodes to be linked in reverse order. If there is no current
  251.  *  node, then the new node will be linked in as the first child at the
  252.  *  top of the tree.
  253.  *
  254.  * Parameters:
  255.  *
  256.  *  buffer - WBXML buffer to link the new node into
  257.  *  type   - Type of node to allocate
  258.  *
  259.  * Return value:
  260.  *
  261.  *  P_WBXML_NODE - A pointer to the newly allocated node.
  262.  *
  263.  */
  264. static P_WBXML_NODE NewNode(P_WBXML_INFO buffer, WBXML_NODE_TYPE type)
  265. {
  266. if (buffer)
  267. {
  268. P_WBXML_NODE newnode = malloc(sizeof(WBXML_NODE));
  270. if (newnode)
  271. {
  272. newnode->m_prev = NULL;
  273. newnode->m_child = NULL;
  275. if (buffer->m_curnode)
  276. {
  277. /* Insert this node as the first child of the current node */
  278. newnode->m_parent = buffer->m_curnode;
  279. newnode->m_next = buffer->m_curnode->m_child;
  281. if (buffer->m_curnode->m_child)
  282. {
  283. ((P_WBXML_NODE)buffer->m_curnode->m_child)->m_prev = newnode;
  284. }
  286. buffer->m_curnode->m_child = newnode;
  287. }
  288. else
  289. {
  290. /* Insert this node at the top of the tree */
  291. newnode->m_parent = NULL;
  292. newnode->m_next = buffer->m_tree;
  294. if (buffer->m_tree)
  295. {
  296. buffer->m_tree->m_prev = newnode;
  297. }
  299. buffer->m_tree = newnode;
  300. }
  302. newnode->m_page = buffer->m_curpage;
  303. newnode->m_type = type;
  304. newnode->m_data = NULL;
  305. }
  306. else
  307. {
  308. ParseError(ERR_NOT_ENOUGH_MEMORY);
  309. }
  311. return newnode;
  312. }
  313. else
  314. {
  315. ParseError(ERR_INTERNAL_BAD_PARAM);
  316. }
  318. return NULL;
  319. }
  321. /*
  322.  * Function: FreeNode
  323.  *
  324.  * Description:
  325.  *
  326.  *  Free a node, all its children and forward siblings.
  327.  *
  328.  * Parameters:
  329.  *
  330.  *  node - The node to free
  331.  *
  332.  */
  333. static void FreeNode(P_WBXML_NODE node)
  334. {
  335. if (node)
  336. {
  337. if (node->m_child)
  338. {
  339. FreeNode(node->m_child);
  340. }
  342. if (node->m_next)
  343. {
  344. FreeNode(node->m_next);
  345. }
  347. free(node);
  348. }
  349. }
  351. static void AddDTDNode(P_WBXML_INFO buffer, const WBXML_DTD_TYPE dtdnum, const WBXML_MB_U_INT32 index)
  352. {
  353. P_WBXML_NODE newnode = NewNode(buffer, NODE_DTD_TYPE);
  354. newnode->m_data = malloc(sizeof(DTD_NODE_DATA));
  355. memcpy( &( ((DTD_NODE_DATA*)newnode->m_data)->m_dtdnum ), &(dtdnum[0]), sizeof(WBXML_MB_U_INT32) );
  356. memcpy( &( ((DTD_NODE_DATA*)newnode->m_data)->m_index ), &(index[0]), sizeof(WBXML_MB_U_INT32) );
  357. dtd_id = (long) dtdnum[0];
  358. }
  360. static void AddStringTableNode(P_WBXML_INFO buffer, const P_WBXML_STRING_TABLE strings)
  361. {
  362. P_WBXML_NODE newnode = NewNode(buffer, NODE_STRING_TABLE);
  363. newnode->m_data = malloc(sizeof(WBXML_STRING_TABLE));
  364. memcpy( newnode->m_data, strings, sizeof(WBXML_STRING_TABLE) );
  365. }
  367. static void AddCodepageTagNode(P_WBXML_INFO buffer, WBXML_TAG tag)
  368. {
  369. P_WBXML_NODE newnode = NewNode(buffer, NODE_CODEPAGE_TAG);
  370. newnode->m_data = malloc(sizeof(WBXML_TAG));
  371. *((P_WBXML_TAG)newnode->m_data) = tag;
  372. }
  374. static void AddCodepageLiteralTagNode(P_WBXML_INFO buffer, WBXML_MB_U_INT32 index)
  375. {
  376. P_WBXML_NODE newnode = NewNode(buffer, NODE_CODEPAGE_LITERAL_TAG);
  377. newnode->m_data = malloc(sizeof(WBXML_MB_U_INT32));
  378. memcpy( ((P_WBXML_MB_U_INT32)newnode->m_data), &index, sizeof(WBXML_MB_U_INT32) );
  379. }
  381. static void AddAttrStartNode(P_WBXML_INFO buffer, WBXML_TAG tag)
  382. {
  383. P_WBXML_NODE newnode = NewNode(buffer, NODE_ATTRSTART);
  384. newnode->m_data = malloc(sizeof(WBXML_TAG));
  385. *((P_WBXML_TAG)newnode->m_data) = tag;
  386. }
  388. static void AddAttrStartLiteralNode(P_WBXML_INFO buffer, WBXML_MB_U_INT32 index)
  389. {
  390. P_WBXML_NODE newnode = NewNode(buffer, NODE_ATTRSTART_LITERAL);
  391. newnode->m_data = malloc(sizeof(WBXML_MB_U_INT32));
  392. memcpy( ((P_WBXML_MB_U_INT32)newnode->m_data), &index, sizeof(WBXML_MB_U_INT32) );
  393. }
  395. static void AddAttrValueNode(P_WBXML_INFO buffer, WBXML_TAG tag)
  396. {
  397. P_WBXML_NODE newnode = NewNode(buffer, NODE_ATTRVALUE);
  398. newnode->m_data = malloc(sizeof(WBXML_TAG));
  399. *((P_WBXML_TAG)newnode->m_data) = tag;
  400. }
  402. static void AddAttrEndNode(P_WBXML_INFO buffer)
  403. {
  404. P_WBXML_NODE newnode = NewNode(buffer, NODE_ATTREND);
  405. newnode->m_data = NULL;
  406. }
  408. static void AddStringNode(P_WBXML_INFO buffer, char* string)
  409. {
  410. P_WBXML_NODE newnode = NewNode(buffer, NODE_STRING);
  411. newnode->m_data = strdup(string);
  412. }
  414. static void AddVariableStringNode(P_WBXML_INFO buffer, char* string, WBXML_VARIABLE_TYPE type)
  415. {
  416. // TODO: add this node
  417. }
  419. static void AddVariableIndexNode(P_WBXML_INFO buffer, char* string, WBXML_VARIABLE_TYPE type)
  420. {
  421. // TODO: add this node
  422. }
  425. /****************
  426.  * Flow Control *
  427.  ****************/
  429. void Message(char* msg)
  430. {
  431.   printf("%sn", msg);
  432. }
  434. void ParseError(WBXML_PARSE_ERROR error)
  435. {
  436.   switch (error)
  437.   {
  438.     case ERR_END_OF_DATA:
  439.       Message("Input stream is incomplete (EOF).");
  440.       break;
  442.     case ERR_INTERNAL_BAD_PARAM:
  443.       Message("Internal error: Bad parameter.");
  444.       break;
  446. case ERR_TAG_NOT_FOUND:
  447.       Message("Tag not found.");
  448.       break;
  450. case ERR_FILE_NOT_FOUND:
  451.       Message("File not found.");
  452.       break;
  454. case ERR_FILE_NOT_READ:
  455.       Message("File read error.");
  456.       break;
  458. case ERR_NOT_ENOUGH_MEMORY:
  459.       Message("Not enough memory");
  460.       break;
  462.     default:
  463.       Message("Unknown error.");
  464.       break;
  465.   }
  467.   exit(error);
  468. }
  470. void ParseWarning(WBXML_PARSE_WARNING warning)
  471. {
  472.   switch (warning)
  473.   {
  474.     case WARN_FUTURE_EXPANSION_EXT_0:
  475.       Message("Token EXT_0 encountered. This token is reserved for future expansion.");
  476.       break;
  478.     case WARN_FUTURE_EXPANSION_EXT_1:
  479.       Message("Token EXT_1 encountered. This token is reserved for future expansion.");
  480.       break;
  482.     case WARN_FUTURE_EXPANSION_EXT_2:
  483.       Message("Token EXT_2 encountered. This token is reserved for future expansion.");
  484.       break;
  486.     default:
  487.       Message("Unknown warning.");
  488.       break;
  489.   }
  490. }
  492. WBXML_LENGTH BytesLeft(P_WBXML_INFO buffer)
  493. {
  494.   if (buffer)
  495.   {
  496.     WBXML_LENGTH bytesRead = (buffer->m_curpos - buffer->m_start);
  497.     if (bytesRead >= buffer->m_length)
  498.     {
  499.       return 0;
  500.     }
  501.     else
  502.     {
  503.       return (buffer->m_length - bytesRead);
  504.     }
  505.   }
  506.   else
  507.   {
  508.     ParseError(ERR_INTERNAL_BAD_PARAM);
  509.   }
  511.   return 0;
  512. }
  514. BOOL IsTag(P_WBXML_INFO buffer, WBXML_TAG tag)
  515. {
  516.   BOOL result = FALSE;
  518.   if (buffer)
  519.   {
  520.     if (BytesLeft(buffer) >= sizeof(WBXML_TAG))
  521.     {
  522.       result = ((*((WBXML_TAG*) buffer->m_curpos)) == tag);
  523.     }
  524.     else
  525.     {
  526. /* No more data, so nope, not this tag */
  527.       result = FALSE;
  528.     }
  529.   }
  530.   else
  531.   {
  532.     ParseError(ERR_INTERNAL_BAD_PARAM);
  533.   }
  535.   return result;
  536. }
  538. BOOL IsCodepageTag(P_WBXML_INFO buffer, CP_TAG_TYPE type)
  539. {
  540. WBXML_U_INT8 result = *(buffer->m_curpos);
  542. /* NOTE THAT THESE ARE NOT UNIQUE! */
  543. switch (type)
  544. {
  545. case CP_TAG_TAG:
  546. return TRUE;
  547. case CP_TAG_ATTRSTART:
  548. return ((result & 0x80) != 0x80);
  549. case CP_TAG_ATTRVALUE:
  550. return ((result & 0x80) == 0x80);
  551. default:
  552. return FALSE;
  553. }
  554. }
  556. BOOL Is_attrValue  (P_WBXML_INFO buffer)
  557. {
  558. WBXML_INFO tmpbuffer;
  559. memcpy(&tmpbuffer, buffer, sizeof(WBXML_INFO));
  560. tmpbuffer.m_curpos += SWITCHPAGE_SIZE;
  562. return ((Is_switchPage(buffer) && IsCodepageTag(&tmpbuffer, CP_TAG_ATTRVALUE)) ||
  563.     IsCodepageTag(buffer, CP_TAG_ATTRVALUE) ||
  564. Is_string(buffer) ||
  565. Is_extension(buffer) ||
  566. Is_entity(buffer) ||
  567. Is_pi(buffer) ||
  568. Is_opaque(buffer));
  569. }
  571. BOOL Is_extension  (P_WBXML_INFO buffer)
  572. {
  573. WBXML_INFO tmpbuffer;
  574. memcpy(&tmpbuffer, buffer, sizeof(WBXML_INFO));
  575. tmpbuffer.m_curpos += SWITCHPAGE_SIZE;
  577. return ((Is_switchPage(buffer) &&
  578.      (IsTag(&tmpbuffer, TAG_EXT_0) ||
  579.       IsTag(&tmpbuffer, TAG_EXT_1) ||
  580.       IsTag(&tmpbuffer, TAG_EXT_2) ||
  581.       IsTag(&tmpbuffer, TAG_EXT_T_0) ||
  582.       IsTag(&tmpbuffer, TAG_EXT_T_1) ||
  583.       IsTag(&tmpbuffer, TAG_EXT_T_2) ||
  584.       IsTag(&tmpbuffer, TAG_EXT_I_0) ||
  585.       IsTag(&tmpbuffer, TAG_EXT_I_1) ||
  586.       IsTag(&tmpbuffer, TAG_EXT_I_2))) ||
  587.     (IsTag(buffer, TAG_EXT_0) ||
  588.      IsTag(buffer, TAG_EXT_1) ||
  589.      IsTag(buffer, TAG_EXT_2) ||
  590.      IsTag(buffer, TAG_EXT_T_0) ||
  591.      IsTag(buffer, TAG_EXT_T_1) ||
  592.      IsTag(buffer, TAG_EXT_T_2) ||
  593.      IsTag(buffer, TAG_EXT_I_0) ||
  594.      IsTag(buffer, TAG_EXT_I_1) ||
  595.      IsTag(buffer, TAG_EXT_I_2)));
  596. }
  598. BOOL Is_string     (P_WBXML_INFO buffer)
  599. {
  600. return (Is_inline(buffer) ||
  601.     Is_tableref(buffer));
  602. }
  604. BOOL Is_switchPage (P_WBXML_INFO buffer)
  605. {
  606. return IsTag(buffer, TAG_SWITCH_PAGE);
  607. }
  609. BOOL Is_inline     (P_WBXML_INFO buffer)
  610. {
  611. return IsTag(buffer, TAG_STR_I);
  612. }
  614. BOOL Is_tableref   (P_WBXML_INFO buffer)
  615. {
  616. return IsTag(buffer, TAG_STR_T);
  617. }
  619. BOOL Is_entity     (P_WBXML_INFO buffer)
  620. {
  621. return IsTag(buffer, TAG_ENTITY);
  622. }
  624. BOOL Is_pi         (P_WBXML_INFO buffer)
  625. {
  626. return IsTag(buffer, TAG_PI);
  627. }
  629. BOOL Is_opaque     (P_WBXML_INFO buffer)
  630. {
  631. return IsTag(buffer, TAG_OPAQUE);
  632. }
  634. BOOL Is_zero(P_WBXML_INFO buffer)
  635. {
  636.   BOOL result = FALSE;
  638.   if (buffer) 
  639.   {
  640.     if (BytesLeft(buffer) >= 1) 
  641.     {
  642.       result = ((*buffer->m_curpos) == 0);
  643.     }
  644.     else
  645.     {
  646.       ParseError(ERR_END_OF_DATA);
  647.     }
  648.   }
  649.   else
  650.   {
  651.     ParseError(ERR_INTERNAL_BAD_PARAM);
  652.   }
  654.   return result;
  655. }
  658. /***********************
  659.  * Basic Type Decoders *
  660.  ***********************/
  662. void Read_u_int8(P_WBXML_INFO buffer, P_WBXML_U_INT8 result)
  663. {
  664.   if (buffer && result)
  665.   {
  666.     if (BytesLeft(buffer) >= 1) 
  667.     {
  668.       *result = *(buffer->m_curpos);
  669.       (buffer->m_curpos)++;
  670.     }
  671.     else
  672.     {
  673.       ParseError(ERR_END_OF_DATA);
  674.     }
  675.   }
  676.   else
  677.   {
  678.     ParseError(ERR_INTERNAL_BAD_PARAM);
  679.   }
  680. }
  682. void Read_mb_u_int32(P_WBXML_INFO buffer, P_WBXML_MB_U_INT32 result)
  683. {
  684.   if (buffer && result)
  685.   {
  686.     int i;
  687.     for (i = 0; i < MAX_MB_U_INT32_BYTES; i++)
  688.     {
  689.       if (BytesLeft(buffer) >= 1)
  690.       {
  691.         (*result)[i] = *(buffer->m_curpos);
  692.         (buffer->m_curpos)++;
  694.         if ( !( (*result)[i] & 0x80 ) )
  695.           break;
  696.       }
  697.       else
  698.       {
  699.         ParseError(ERR_END_OF_DATA);
  700.       }
  701.     }
  702.   }
  703.   else
  704.   {
  705.     ParseError(ERR_INTERNAL_BAD_PARAM);
  706.   }
  707. }
  709. void Read_bytes(P_WBXML_INFO buffer, WBXML_LENGTH length, P_WBXML_BYTES result)
  710. {
  711.   if (buffer && result)
  712.   {
  713.     if (BytesLeft(buffer) >= length) 
  714.     {
  715.       *result = (WBXML_BYTES) malloc(length*sizeof(unsigned char));
  716.       memcpy(*result, buffer->m_curpos, length);
  717.       buffer->m_curpos += length;
  718.     }
  719.     else
  720.     {
  721.       ParseError(ERR_END_OF_DATA);
  722.     }
  723.   }
  724.   else
  725.   {
  726.     ParseError(ERR_INTERNAL_BAD_PARAM);
  727.   }
  728. }
  730. void ReadFixedTag(P_WBXML_INFO buffer, WBXML_TAG tag)
  731. {
  732.   if (buffer)
  733.   {
  734.     if (BytesLeft(buffer) >= sizeof(WBXML_TAG))
  735.     {
  736.       if ((*((WBXML_TAG*) buffer->m_curpos)) == tag)
  737.       {
  738.         buffer->m_curpos += sizeof(WBXML_TAG);
  739.       }
  740.       else
  741.       {
  742.         ParseError(ERR_TAG_NOT_FOUND);
  743.       }
  744.     }
  745.     else
  746.     {
  747.       ParseError(ERR_END_OF_DATA);
  748.     }
  749.   }
  750.   else
  751.   {
  752.     ParseError(ERR_INTERNAL_BAD_PARAM);
  753.   }
  754. }
  756. WBXML_TAG ReadCodepageTag (P_WBXML_INFO buffer, CP_TAG_TYPE type)
  757. {
  758.   WBXML_TAG tag = 0;
  760.   if (buffer)
  761.   {
  762.     if (BytesLeft(buffer) >= sizeof(WBXML_TAG))
  763.     {
  764.       tag = *((WBXML_TAG*) buffer->m_curpos);
  766.   switch (type)
  767.   {
  768.     case CP_TAG_TAG:
  769.   buffer->m_curpos += sizeof(WBXML_TAG);
  770.   break;
  772. case CP_TAG_ATTRSTART:
  773.   if ((tag & 0x80) != 0x80)
  774.   {
  775.     buffer->m_curpos += sizeof(WBXML_TAG);
  776.   }
  777.   else
  778.   {
  779.   ParseError(ERR_TAG_NOT_FOUND);
  780.   }
  781.   break;
  783. case CP_TAG_ATTRVALUE:
  784.   if ((tag & 0x80) == 0x80)
  785.   {
  786.     buffer->m_curpos += sizeof(WBXML_TAG);
  787.   }
  788.   else
  789.   {
  790.   ParseError(ERR_TAG_NOT_FOUND);
  791.   }
  792.   break;
  794. default:
  795.   ParseError(ERR_TAG_NOT_FOUND);
  796.   break;
  797.       }
  798.     }
  799.     else
  800.     {
  801.       ParseError(ERR_END_OF_DATA);
  802.     }
  803.   }
  804.   else
  805.   {
  806.     ParseError(ERR_INTERNAL_BAD_PARAM);
  807.   }
  809.   return tag;
  810. }
  813. /**************************
  814.  * Basic Type Conversions *
  815.  **************************/
  817. long mb_u_int32_to_long(P_WBXML_MB_U_INT32 value)
  818. {
  819.   long result = 0;
  821.   if (value)
  822.   {
  823.     int i;
  824.     for (i = 0; i < MAX_MB_U_INT32_BYTES; i++)
  825.     {
  826.       result <<= 7;
  827.       result |= ((*value)[i] & 0x7f);
  829.       if ( !( (*value)[i] & 0x80 ) )
  830.         break;
  831.     }
  832.   }
  833.   else
  834.   {
  835.     ParseError(ERR_INTERNAL_BAD_PARAM);
  836.   }
  838.   return result;
  839. }
  841. static void OutputEncodedString(const unsigned char* str)
  842. {
  843. /* Work our way down the string looking for illegal chars */
  844. while (*str != 0)
  845. {
  846. if ((*str < 0x20) || (*str > 0x7F))
  847. {
  848. /* Out of range... encode */
  849. printf("&#x%02x;", *str);
  850. }
  851. else
  852. {
  853. switch (*str)
  854. {
  855. case '<':
  856. case '>':
  857. case '&':
  858. case ''':
  859. case '"':
  860. /* Special symbol... encode */
  861. printf("&#x%2x", *str);
  862. break;
  864. default:
  865. printf("%c", *str);
  866. break;
  867. }
  868. }
  870. str++;
  871. }
  872. }
  875. /*******************************
  876.  * Document Structure Decoders *
  877.  *******************************/
  879. void Read_start      (P_WBXML_INFO buffer)
  880. {
  881.   Read_version(buffer);
  882.   Read_publicid(buffer);
  883.   Read_charset(buffer);
  884.   Read_strtbl(buffer);
  885.   Read_body(buffer);
  886. }
  888. void Read_strtbl     (P_WBXML_INFO buffer)
  889. {
  890.   WBXML_STRING_TABLE result;
  891.   Read_mb_u_int32(buffer, &(result.m_length));
  892.   Read_bytes(buffer, mb_u_int32_to_long(&(result.m_length)), &(result.m_strings));
  894.   AddStringTableNode(buffer, &result);
  895. }
  897. void Read_body       (P_WBXML_INFO buffer)
  898. {
  899.   while (Is_pi(buffer))
  900.   {
  901.     Read_pi(buffer);
  902.   }
  904.   Read_element(buffer);
  906.   while (Is_pi(buffer))
  907.   {
  908.     Read_pi(buffer);
  909.   }
  910. }
  912. void Read_element    (P_WBXML_INFO buffer)
  913. {
  914.   WBXML_TAG stagvalue = 0;
  916.   if (Is_switchPage(buffer))
  917.   {
  918.     Read_switchPage(buffer);
  919.   }
  921.   stagvalue = Read_stag(buffer);
  923.   /* move the current node down to this one in the tree */
  924.   if (buffer->m_curnode)
  925.   buffer->m_curnode = buffer->m_curnode->m_child;
  926.   else buffer->m_curnode = buffer->m_tree;
  928.   if ((stagvalue & CODEPAGE_TAG_HAS_ATTRS) == CODEPAGE_TAG_HAS_ATTRS)
  929.   {
  930.     do
  931.     {
  932.       Read_attribute(buffer);
  934.     } while (!IsTag(buffer, TAG_END));
  936.     ReadFixedTag(buffer, TAG_END);
  938. AddAttrEndNode(buffer);
  939.   }
  941.   if ((stagvalue & CODEPAGE_TAG_HAS_CONTENT) == CODEPAGE_TAG_HAS_CONTENT)
  942.   {
  943.     while (!IsTag(buffer, TAG_END))
  944. {
  945.       Read_content(buffer);
  946. }
  948.     ReadFixedTag(buffer, TAG_END);
  949.   }
  951.   /* move the current node back up one */
  952.   buffer->m_curnode = buffer->m_curnode->m_parent;
  953. }
  955. void Read_content    (P_WBXML_INFO buffer)
  956. {
  957. if (Is_string(buffer))
  958. {
  959. Read_string(buffer);
  960. }
  961. else if (Is_extension(buffer))
  962. {
  963. Read_extension(buffer);
  964. }
  965. else if (Is_entity(buffer))
  966. {
  967. Read_entity(buffer);
  968. }
  969. else if (Is_pi(buffer))
  970. {
  971. Read_pi(buffer);
  972. }
  973. else if (Is_opaque(buffer))
  974. {
  975. Read_opaque(buffer);
  976. }
  977. else
  978. {
  979. /* Assume it is an element */
  980. Read_element(buffer);
  981. }
  982. }
  984. WBXML_TAG Read_stag       (P_WBXML_INFO buffer)
  985. {
  986. if (IsCodepageTag(buffer, CP_TAG_TAG))
  987. {
  988. WBXML_TAG tag = ReadCodepageTag(buffer, CP_TAG_TAG);
  990. AddCodepageTagNode(buffer, tag);
  992. return tag;
  993. }
  994. else if (IsTag(buffer, TAG_LITERAL))
  995. {
  996. WBXML_MB_U_INT32 index;
  998. ReadFixedTag(buffer, TAG_LITERAL);
  999. Read_index(buffer, &index);
  1001. AddCodepageLiteralTagNode(buffer, index);
  1002. }
  1003. else
  1004. {
  1005. ParseError(ERR_TAG_NOT_FOUND);
  1006. }
  1008. return 0;
  1009. }
  1011. void Read_attribute  (P_WBXML_INFO buffer)
  1012. {
  1013. Read_attrStart(buffer);
  1015. while (Is_attrValue(buffer))
  1016. {
  1017. Read_attrValue(buffer);
  1018. }
  1019. }
  1021. void Read_attrStart  (P_WBXML_INFO buffer)
  1022. {
  1023.   if (Is_switchPage(buffer))
  1024.   {
  1025. WBXML_TAG tag;
  1026.     Read_switchPage(buffer);
  1027.     tag = ReadCodepageTag(buffer, CP_TAG_ATTRSTART);
  1029. AddAttrStartNode(buffer, tag);
  1030.   }
  1031.   else if (IsCodepageTag(buffer, CP_TAG_ATTRSTART))
  1032.   {
  1033. WBXML_TAG tag;
  1034.     tag = ReadCodepageTag(buffer, CP_TAG_ATTRSTART);
  1036. AddAttrStartNode(buffer, tag);
  1037.   }
  1038.   else if (IsTag(buffer, TAG_LITERAL))
  1039.   {
  1040.     WBXML_MB_U_INT32 index;
  1042.     ReadFixedTag(buffer, TAG_LITERAL);
  1043.     Read_index(buffer, &index);
  1045. AddAttrStartLiteralNode(buffer, index);
  1046.   }
  1047.   else
  1048.   {
  1049.     ParseError(ERR_TAG_NOT_FOUND);
  1050.   }
  1051. }
  1053. void Read_attrValue  (P_WBXML_INFO buffer)
  1054. {
  1055.   if (Is_switchPage(buffer))
  1056.   {
  1057. WBXML_TAG tag;
  1058.     Read_switchPage(buffer);
  1059.     tag = ReadCodepageTag(buffer, CP_TAG_ATTRVALUE);
  1060. AddAttrValueNode(buffer, tag);
  1061.   }
  1062.   else if (IsCodepageTag(buffer, CP_TAG_ATTRVALUE))
  1063.   {
  1064. WBXML_TAG tag;
  1065.     tag = ReadCodepageTag(buffer, CP_TAG_ATTRVALUE);
  1066. AddAttrValueNode(buffer, tag);
  1067.   }
  1068.   else if (Is_string(buffer))
  1069.   {
  1070.     Read_string(buffer);
  1071.   }
  1072.   else if (Is_extension(buffer))
  1073.   {
  1074.     Read_extension(buffer);
  1075.   }
  1076.   else if (Is_entity(buffer))
  1077.   {
  1078.     Read_entity(buffer);
  1079.   }
  1080.   else if (Is_opaque(buffer))
  1081.   {
  1082.     Read_opaque(buffer);
  1083.   }
  1084.   else
  1085.   {
  1086.     ParseError(ERR_TAG_NOT_FOUND);
  1087.   }
  1088. }
  1090. void Read_extension  (P_WBXML_INFO buffer)
  1091. {
  1092. if (Is_switchPage(buffer))
  1093. {
  1094. Read_switchPage(buffer);
  1095. }
  1097. if (IsTag(buffer, TAG_EXT_I_0))
  1098. {
  1099. char* str = NULL;
  1101. ReadFixedTag(buffer, TAG_EXT_I_0);
  1102. Read_termstr_rtn(buffer, &str);
  1104. AddVariableStringNode(buffer, str, VAR_ESCAPED); 
  1105. }
  1106. else if (IsTag(buffer, TAG_EXT_I_1))
  1107. {
  1108. char* str = NULL;
  1110. ReadFixedTag(buffer, TAG_EXT_I_1);
  1111. Read_termstr_rtn(buffer, &str);
  1113. AddVariableStringNode(buffer, str, VAR_UNESCAPED); 
  1114. }
  1115. else if (IsTag(buffer, TAG_EXT_I_2))
  1116. {
  1117. char* str = NULL;
  1119. ReadFixedTag(buffer, TAG_EXT_I_2);
  1120. Read_termstr_rtn(buffer, &str);
  1122. AddVariableStringNode(buffer, str, VAR_UNCHANGED); 
  1123. }
  1124. else if (IsTag(buffer, TAG_EXT_T_0))
  1125. {
  1126. WBXML_MB_U_INT32 index;
  1128. ReadFixedTag(buffer, TAG_EXT_T_0);
  1129. Read_index(buffer, &index);
  1131. AddVariableIndexNode(buffer, index, VAR_ESCAPED);
  1132. }
  1133. else if (IsTag(buffer, TAG_EXT_T_1))
  1134. {
  1135. WBXML_MB_U_INT32 index;
  1137. ReadFixedTag(buffer, TAG_EXT_T_1);
  1138. Read_index(buffer, &index);
  1140. AddVariableIndexNode(buffer, index, VAR_UNESCAPED);
  1141. }
  1142. else if (IsTag(buffer, TAG_EXT_T_2))
  1143. {
  1144. WBXML_MB_U_INT32 index;
  1146. ReadFixedTag(buffer, TAG_EXT_T_2);
  1147. Read_index(buffer, &index);
  1149. AddVariableIndexNode(buffer, index, VAR_UNCHANGED);
  1150. }
  1151. else if (IsTag(buffer, TAG_EXT_0))
  1152. {
  1153. ReadFixedTag(buffer, TAG_EXT_0);
  1155. ParseWarning(WARN_FUTURE_EXPANSION_EXT_0);
  1156. }
  1157. else if (IsTag(buffer, TAG_EXT_1))
  1158. {
  1159. ReadFixedTag(buffer, TAG_EXT_1);
  1161. ParseWarning(WARN_FUTURE_EXPANSION_EXT_1);
  1162. }
  1163. else if (IsTag(buffer, TAG_EXT_2))
  1164. {
  1165. ReadFixedTag(buffer, TAG_EXT_2);
  1167. ParseWarning(WARN_FUTURE_EXPANSION_EXT_2);
  1168. }
  1169. else
  1170. {
  1171. ParseError(ERR_TAG_NOT_FOUND);
  1172. }
  1173. }
  1175. void Read_string     (P_WBXML_INFO buffer)
  1176. {
  1177. if (Is_inline(buffer))
  1178. {
  1179. Read_inline(buffer);
  1180. }
  1181. else if (Is_tableref(buffer))
  1182. {
  1183. Read_tableref(buffer);
  1184. }
  1185. else
  1186. {
  1187. ParseError(ERR_TAG_NOT_FOUND);
  1188. }
  1189. }
  1191. void Read_switchPage (P_WBXML_INFO buffer)
  1192. {
  1193.   WBXML_U_INT8 pageindex;
  1195.   ReadFixedTag(buffer, TAG_SWITCH_PAGE);
  1196.   Read_pageindex(buffer, &pageindex);
  1198.   /* Use the new codepage */
  1199.   buffer->m_curpage = pageindex;
  1200. }
  1202. void Read_inline     (P_WBXML_INFO buffer)
  1203. {
  1204. ReadFixedTag(buffer, TAG_STR_I);
  1205. Read_termstr(buffer);
  1206. }
  1208. void Read_tableref   (P_WBXML_INFO buffer)
  1209. {
  1210.   WBXML_MB_U_INT32 index;
  1212.   ReadFixedTag(buffer, TAG_STR_T);
  1213.   Read_index(buffer, &index);
  1214. }
  1216. void Read_entity     (P_WBXML_INFO buffer)
  1217. {
  1218. ReadFixedTag(buffer, TAG_ENTITY);
  1219. Read_entcode(buffer);
  1220. }
  1222. void Read_entcode    (P_WBXML_INFO buffer)
  1223. {
  1224. WBXML_MB_U_INT32 result;
  1225. Read_mb_u_int32(buffer, &result);
  1226. }
  1228. void Read_pi         (P_WBXML_INFO buffer)
  1229. {
  1230.   ReadFixedTag(buffer, TAG_PI);
  1231.   Read_attrStart(buffer);
  1232.   
  1233.   while (Is_attrValue(buffer))
  1234.   {
  1235.     Read_attrValue(buffer);
  1236.   }
  1238.   ReadFixedTag(buffer, TAG_END);
  1239. }
  1241. void Read_opaque     (P_WBXML_INFO buffer)
  1242. {
  1243.   WBXML_MB_U_INT32 length;
  1244.   WBXML_BYTES      data;
  1246.   ReadFixedTag(buffer, TAG_OPAQUE);
  1247.   Read_length(buffer, &length);
  1248.   Read_bytes(buffer, mb_u_int32_to_long(&length), &data);
  1249. }
  1251. void Read_version    (P_WBXML_INFO buffer)
  1252. {
  1253.   WBXML_U_INT8 result;
  1255.   Read_u_int8(buffer, &result);
  1256. }
  1258. void Read_publicid   (P_WBXML_INFO buffer)
  1259. {
  1260.   if (Is_zero(buffer))
  1261.   {
  1262.     WBXML_MB_U_INT32 index;
  1264.     Read_index(buffer, &index);
  1266. AddDTDNode(buffer, ZERO_WBXML_MB_U_INT32, index);
  1267.   }
  1268.   else
  1269.   {
  1270.     WBXML_MB_U_INT32 result;
  1272.     Read_mb_u_int32(buffer, &result);
  1274. AddDTDNode(buffer, result, ZERO_WBXML_MB_U_INT32);
  1275.   }
  1276. }
  1278. void Read_charset    (P_WBXML_INFO buffer)
  1279. {
  1280.   WBXML_MB_U_INT32 result;
  1282.   Read_mb_u_int32(buffer, &result);
  1283. }
  1285. void Read_termstr_rtn(P_WBXML_INFO buffer, char** result)
  1286. {
  1288. #define STRING_BLOCK_SIZE 256
  1290. int buflen = STRING_BLOCK_SIZE;
  1291. char* strbuf = (char*) malloc(buflen);
  1292. BOOL doubled = FALSE;
  1293. int i = 0;
  1295. if (!result)
  1296. ParseError(ERR_INTERNAL_BAD_PARAM);
  1298. while ( (BytesLeft(buffer) >= 1) && (*(buffer->m_curpos) != 0) )
  1299. {
  1300. if (i>=buflen)
  1301. {
  1302. buflen += STRING_BLOCK_SIZE;
  1303. strbuf = realloc(strbuf, buflen);
  1304. }
  1306. if (*(buffer->m_curpos) != '$' || doubled == TRUE)
  1307. {
  1308. strbuf[i] = *(buffer->m_curpos);
  1309. buffer->m_curpos++;
  1310. i++;
  1311. if (doubled == TRUE)
  1312. doubled = FALSE;
  1313. }
  1314. else
  1315. {
  1316. strbuf[i] = *(buffer->m_curpos);
  1317. i++;
  1318. doubled = TRUE;
  1319. }
  1320. }
  1322. strbuf[i] = 0;
  1323. buffer->m_curpos++;
  1325. if (*result)
  1326. free(*result);
  1328. *result = strbuf;
  1329. }
  1331. void Read_termstr    (P_WBXML_INFO buffer)
  1332. {
  1333. char* strbuf = NULL;
  1335. Read_termstr_rtn(buffer, &strbuf);
  1337. AddStringNode(buffer, strbuf);
  1339. free(strbuf);
  1340. }
  1342. void Read_index      (P_WBXML_INFO buffer, P_WBXML_MB_U_INT32 result)
  1343. {
  1344.   Read_mb_u_int32(buffer, result);
  1345. }
  1347. void Read_length     (P_WBXML_INFO buffer, P_WBXML_MB_U_INT32 result)
  1348. {
  1349.   Read_mb_u_int32(buffer, result);
  1350. }
  1352. void Read_zero       (P_WBXML_INFO buffer)
  1353. {
  1354.   WBXML_U_INT8 result;
  1356.   Read_u_int8(buffer, &result);
  1358.   if (result != (WBXML_U_INT8) 0)
  1359.   {
  1360.     ParseError(ERR_TAG_NOT_FOUND);
  1361.   }
  1362. }
  1364. void Read_pageindex  (P_WBXML_INFO buffer, P_WBXML_U_INT8 result)
  1365. {
  1366.   Read_u_int8(buffer, result);
  1367. }
  1369. static void Init(P_WBXML_INFO buffer)
  1370. {
  1371. buffer->m_start = NULL;
  1372. buffer->m_curpos = NULL;
  1373. buffer->m_length = 0;
  1374. buffer->m_tree = NULL;
  1375. buffer->m_curnode = NULL;
  1376. buffer->m_curpage = 0;
  1377. }
  1379. static size_t BufferLength(P_WBXML_INFO buffer)
  1380. {
  1381. size_t ret;
  1383. while (buffer->m_curpos != '')
  1384. buffer->m_curpos++;
  1386. ret = buffer->m_curpos - buffer->m_start;
  1387. buffer->m_curpos = buffer->m_start;
  1388. return ret;
  1389. }
  1391. static void Free(P_WBXML_INFO buffer)
  1392. {
  1393. if (buffer->m_start)
  1394. {
  1395. free(buffer->m_start);
  1396. buffer->m_start = NULL;
  1397. }
  1399. buffer->m_curpos = NULL;
  1400. buffer->m_length = 0;
  1402. FreeNode(buffer->m_tree);
  1403. buffer->m_tree = NULL;
  1404. }
  1406. static long FileSize(FILE* file)
  1407. {
  1408. long curpos = ftell(file);
  1409. long endpos;
  1410. fseek(file, 0, SEEK_END);
  1411. endpos = ftell(file);
  1412. fseek(file, curpos, SEEK_SET);
  1414. return endpos;
  1415. }
  1417. static void ReadBinary(P_WBXML_INFO buffer, FILE* file)
  1418. {
  1419. char buf[4096];
  1420. int m = 1;
  1421. long n;
  1423. if (buffer && file)
  1424. {
  1425. if (file != stdin)
  1426. {
  1427. buffer->m_length = FileSize(file);
  1428. buffer->m_start = (P_WBXML) malloc(buffer->m_length);
  1429. buffer->m_curpos = buffer->m_start;
  1431. if (!buffer->m_start)
  1432. {
  1433. fclose(file);
  1434. ParseError(ERR_NOT_ENOUGH_MEMORY);
  1435. }
  1437. if (fread(buffer->m_start, 1, buffer->m_length, file) != buffer->m_length)
  1438. {
  1439. fclose(file);
  1440. ParseError(ERR_FILE_NOT_READ);
  1441. }
  1442. else
  1443. {
  1444. fclose(file);
  1445. }
  1446. }
  1447. else
  1448. {
  1449. while ((n = fread(buf, 1, sizeof(buf), file)) > 0)
  1450. {
  1451. buffer->m_start = (P_WBXML) realloc(buffer->m_start, sizeof(buf) * m);
  1452. memcpy(buffer->m_start + (sizeof(buf) * (m - 1)), buf, sizeof(buf));
  1453. m++;
  1454. }
  1455. buffer->m_length = BufferLength(buffer);
  1456. buffer->m_curpos = buffer->m_start;
  1457. }
  1459. }
  1460. else
  1461. {
  1462. ParseError(ERR_INTERNAL_BAD_PARAM);
  1463. }
  1464. }
  1466. static const char* DTDTypeName(long dtdnum)
  1467. {
  1468. int i = 0;
  1470. /* Search the DTD list for a match */
  1471. while (DTDTypeList[i].m_name)
  1472. {
  1473. if (DTDTypeList[i].m_id == dtdnum)
  1474. {
  1475. break;
  1476. }
  1478. i++;
  1479. }
  1481. return DTDTypeList[i].m_name;
  1482. }
  1484. static const char* CodepageTagName(WBXML_CODEPAGE page, WBXML_TAG tag)
  1485. {
  1486. int i = 0;
  1488. /* Strip flags off of the tag */
  1489. tag = (WBXML_TAG) (tag & CODEPAGE_TAG_MASK);
  1491. /* Search the tag list for a match */
  1492. while (CodepageTagNames[i].m_name)
  1493. {
  1494. if ((CodepageTagNames[i].m_dtd_id == dtd_id) &&
  1495. (CodepageTagNames[i].m_page == page) &&
  1496. (CodepageTagNames[i].m_tag == tag))
  1497. {
  1498. break;
  1499. }
  1501. i++;
  1502. }
  1504. return CodepageTagNames[i].m_name;
  1505. }
  1507. static const char* CodepageAttrstartName(WBXML_CODEPAGE page, WBXML_TAG tag, char** value)
  1508. {
  1509. int i = 0;
  1511. /* Check Parameters */
  1512. if (!value)
  1513. {
  1514. ParseError(ERR_INTERNAL_BAD_PARAM);
  1515. }
  1517. /* Search the tag list for a match */
  1518. while (CodepageAttrstartNames[i].m_name)
  1519. {
  1520. if ((CodepageAttrstartNames[i].m_dtd_id == dtd_id) &&
  1521. (CodepageAttrstartNames[i].m_page == page) &&
  1522. (CodepageAttrstartNames[i].m_tag == tag))
  1523. {
  1524. break;
  1525. }
  1527. i++;
  1528. }
  1530. /* Duplicate the value because it may be concatenated to */
  1531. if (CodepageAttrstartNames[i].m_valueprefix)
  1532. {
  1533. *value = strdup(CodepageAttrstartNames[i].m_valueprefix);
  1534. }
  1535. else
  1536. {
  1537. *value = NULL;
  1538. }
  1540. /* Return the tag name */
  1541. return CodepageAttrstartNames[i].m_name;
  1542. }
  1544. static void CodepageAttrvalueName(WBXML_CODEPAGE page, WBXML_TAG tag, char** value)
  1545. {
  1546. int i = 0;
  1548. /* Check Parameters */
  1549. if (!value)
  1550. {
  1551. ParseError(ERR_INTERNAL_BAD_PARAM);
  1552. }
  1554. /* Search the tag list for a match */
  1555. while (CodepageAttrvalueNames[i].m_name)
  1556. {
  1557. if ((CodepageAttrvalueNames[i].m_dtd_id == dtd_id) &&
  1558. (CodepageAttrvalueNames[i].m_page == page) &&
  1559. (CodepageAttrvalueNames[i].m_tag == tag))
  1560. {
  1561. break;
  1562. }
  1564. i++;
  1565. }
  1567. /* concatenate the value */
  1568. if (CodepageAttrvalueNames[i].m_name)
  1569. {
  1570. if (*value)
  1571. {
  1572. *value = realloc(*value, strlen(*value) + strlen(CodepageAttrvalueNames[i].m_name) + 1);
  1573. strcat(*value, CodepageAttrvalueNames[i].m_name);
  1574. }
  1575. else
  1576. {
  1577. *value = strdup(CodepageAttrvalueNames[i].m_name);
  1578. }
  1579. }
  1580. }
  1582. static const char* GetStringTableString(P_WBXML_NODE node, long index)
  1583. {
  1584. /* Find the string table node */
  1586. P_WBXML_NODE pStringsNode = node;
  1588. while (pStringsNode->m_parent)
  1589. {
  1590. pStringsNode = pStringsNode->m_parent;
  1591. }
  1593. while (pStringsNode->m_next)
  1594. {
  1595. pStringsNode = pStringsNode->m_next;
  1596. }
  1598. while (pStringsNode->m_prev && pStringsNode->m_type != NODE_STRING_TABLE)
  1599. {
  1600. pStringsNode = pStringsNode->m_prev;
  1601. }
  1603. if (pStringsNode->m_type != NODE_STRING_TABLE)
  1604. {
  1605. return "!!NO STRING TABLE!!";
  1606. }
  1608. /* Find the indexed string */
  1610. if ((index >= 0) && (index < mb_u_int32_to_long(&((P_WBXML_STRING_TABLE)pStringsNode->m_data)->m_length)))
  1611. {
  1612. return (const char*) &(((P_WBXML_STRING_TABLE)pStringsNode->m_data)->m_strings[index]);
  1613. }
  1614. else
  1615. {
  1616. return "!!STRING TABLE INDEX TOO LARGE!!";
  1617. }
  1618. }
  1620. static void DumpNode(P_WBXML_NODE node, int indent, BOOL *inattrs, BOOL hascontent, char** value)
  1621. {
  1622. P_WBXML_NODE curnode = node->m_child;
  1624. WBXML_TAG nodetype = 0;
  1625. long dtdnum = 0;
  1627. BOOL bAttributesFollow = FALSE;
  1628. BOOL bHasContent = FALSE;
  1630. int i;
  1632. if (!(*inattrs))
  1633. {
  1634. for (i=0; i<indent; i++)
  1635. {
  1636. printf(" ");
  1637. }
  1638. }
  1639. else
  1640. {
  1641. if ((node->m_type != NODE_ATTRVALUE) && (*value))
  1642. {
  1643. printf("="");
  1644. OutputEncodedString((unsigned char*) *value);
  1645. printf(""");
  1646. free(*value);
  1647. *value = NULL;
  1648. }
  1649. }
  1651. switch (node->m_type)
  1652. {
  1653. case NODE_DTD_TYPE:
  1654. printf("<?xml version="1.0"?>n<!DOCTYPE wml PUBLIC ");
  1656. dtdnum = mb_u_int32_to_long( &((DTD_NODE_DATA*)node->m_data)->m_dtdnum );
  1657. if ( dtdnum == 0)
  1658. {
  1659. printf(""%s">nn", GetStringTableString(node, mb_u_int32_to_long(&((DTD_NODE_DATA*)node->m_data)->m_index)) );
  1660. }
  1661. else
  1662. {
  1663. printf(""%s">nn", DTDTypeName(dtdnum) );
  1664. }
  1665. break;
  1667. case NODE_CODEPAGE_TAG:
  1668. nodetype = *((P_WBXML_TAG)node->m_data);
  1669. if ((nodetype & CODEPAGE_TAG_MASK) == nodetype)
  1670. {
  1671. printf("<%s/>n", CodepageTagName(node->m_page, nodetype));
  1672. }
  1673. else
  1674. {
  1675. if ((nodetype & CODEPAGE_TAG_HAS_CONTENT) == CODEPAGE_TAG_HAS_CONTENT)
  1676. {
  1677. bHasContent = TRUE;
  1678. }
  1680. if ((nodetype & CODEPAGE_TAG_HAS_ATTRS) == CODEPAGE_TAG_HAS_ATTRS)
  1681. {
  1682. printf("<%s", CodepageTagName(node->m_page, nodetype));
  1683. bAttributesFollow = TRUE;
  1684. }
  1685. else
  1686. {
  1687. printf("<%s>n", CodepageTagName(node->m_page, nodetype));
  1688. }
  1689. }
  1690. break;
  1692. case NODE_CODEPAGE_LITERAL_TAG:
  1693. printf("<%s>n", GetStringTableString(node, mb_u_int32_to_long(((P_WBXML_MB_U_INT32)node->m_data))) );
  1694. break;
  1696. case NODE_ATTRSTART:
  1697. printf(" %s", CodepageAttrstartName(node->m_page, *((P_WBXML_TAG)node->m_data), value) );
  1698. break;
  1700. case NODE_ATTRSTART_LITERAL:
  1701. printf(" %s", GetStringTableString(node, mb_u_int32_to_long(((P_WBXML_MB_U_INT32)node->m_data))) );
  1702. break;
  1704. case NODE_ATTRVALUE:
  1705. CodepageAttrvalueName(node->m_page, *((P_WBXML_TAG)node->m_data), value);
  1706. break;
  1708. case NODE_ATTREND:
  1709. if (!hascontent)
  1710. {
  1711. printf("/");
  1712. }
  1713. printf(">n");
  1714. *inattrs = FALSE;
  1715. break;
  1717. case NODE_STRING:
  1718. if (*inattrs)
  1719. {
  1720. /* concatenate the value */
  1721. if (*value)
  1722. {
  1723. if (node->m_data)
  1724. {
  1725. *value = realloc(*value, strlen(*value) + strlen((char*) node->m_data) + 1);
  1726. strcat(*value, (char*) node->m_data);
  1727. }
  1728. }
  1729. else
  1730. {
  1731. if (node->m_data)
  1732. {
  1733. *value = strdup((char*) node->m_data);
  1734. }
  1735. }
  1736. }
  1737. else
  1738. {
  1739. OutputEncodedString((unsigned char*) node->m_data);
  1740. printf("n");
  1741. }
  1742. break;
  1744. case NODE_VARIABLE_STRING:
  1745. // TODO: output variable string
  1746. break;
  1748. case NODE_VARIABLE_INDEX:
  1749. // TODO: output variable string
  1750. break;
  1752. default:
  1753. break;
  1754. }
  1756. indent += INDENT_SIZE;
  1758. if (curnode)
  1759. {
  1760. while (curnode->m_next) curnode = curnode->m_next;
  1762. while (curnode)
  1763. {
  1764. DumpNode(curnode, indent, &bAttributesFollow, bHasContent, value);
  1765. curnode = curnode->m_prev;
  1766. }
  1767. }
  1769. indent -= INDENT_SIZE;
  1771. /* Output the element end if we have one */
  1772. if ((nodetype & CODEPAGE_TAG_HAS_CONTENT) == CODEPAGE_TAG_HAS_CONTENT)
  1773. {
  1774. for (i=0; i<indent; i++)
  1775. {
  1776. printf(" ");
  1777. }
  1779. switch (node->m_type)
  1780. {
  1781. case NODE_CODEPAGE_TAG:
  1782. printf("</%s>n", CodepageTagName(node->m_page, *((P_WBXML_TAG)node->m_data)) );
  1783. break;
  1785. case NODE_CODEPAGE_LITERAL_TAG:
  1786. printf("</%s>n", GetStringTableString(node, mb_u_int32_to_long(((P_WBXML_MB_U_INT32)node->m_data))) );
  1787. break;
  1789. default:
  1790. break;
  1791. }
  1792. }
  1793. }
  1795. static void DumpNodes(P_WBXML_INFO buffer)
  1796. {
  1797. P_WBXML_NODE curnode = buffer->m_tree;
  1798. BOOL bAttrsFollow = FALSE;
  1799. char* value = NULL;
  1801. if (curnode)
  1802. {
  1803. while (curnode->m_next) curnode = curnode->m_next;
  1805. while (curnode)
  1806. {
  1807. DumpNode(curnode, 0, &bAttrsFollow, FALSE, &value);
  1808. curnode = curnode->m_prev;
  1809. }
  1810. }
  1811. }
  1813. int main(int argc, char** argv)
  1814. {
  1815. WBXML_INFO buffer;
  1816. FILE* file;
  1818. if (argc < 2)
  1819. {
  1820. file = stdin;
  1821. }
  1822. else
  1823. {
  1824.         file = fopen(argv[1], "r");
  1825. if (!file)
  1826. {
  1827. ParseError(ERR_FILE_NOT_FOUND);
  1828. }
  1829. }
  1831.     Init(&buffer);
  1832. ReadBinary(&buffer, file);
  1833. Read_start(&buffer);
  1834. DumpNodes(&buffer);
  1835. Free(&buffer);
  1837. return 0;
  1838. }