PageRenderTime 52ms CodeModel.GetById 18ms RepoModel.GetById 1ms app.codeStats 0ms

/amaya/html2thot.c

https://github.com/pffy/Amaya-Editor
C | 7618 lines | 6067 code | 333 blank | 1218 comment | 1612 complexity | 29dab6b5f25c8433321a1eb755e2bd6a MD5 | raw file

Large files files are truncated, but you can click here to view the full file

    

  1. /*
    2. 

  2.  *
    3. 

  3.  *  (c) COPYRIGHT INRIA and W3C, 1996-2009
    4. 

  4.  *  Please first read the full copyright statement in file COPYRIGHT.
    5. 

  5.  *
    6. 

  6.  */
    7. 

  7. 

  8. /*
    9. 

  9.  *
    10. 

  10.  * html2thot parses a HTML file and builds the corresponding abstract tree
    11. 

  11.  * for a Thot document of type HTML.
    12. 

  12.  *
    13. 

  13.  * Author: V. Quint
    14. 

  14.  *         I. Vatton (W3C/INRIA): XML extension and Unicode
    15. 

  15.  */
    16. 

  16. 

  17. #define THOT_EXPORT extern
    18. 

  18. #include "amaya.h"
    19. 

  19. #include "css.h"
    20. 

  20. #include "fetchHTMLname.h"
    21. 

  21. #include "parser.h"
    22. 

  22. #include "zlib.h"
    23. 

  23. 

  24. #include "AHTURLTools_f.h"
    25. 

  25. #include "css_f.h"
    26. 

  26. #include "EDITstyle_f.h"
    27. 

  27. #include "fetchHTMLname_f.h"
    28. 

  28. #include "fetchXMLname_f.h"
    29. 

  29. #include "html2thot_f.h"
    30. 

  30. #include "HTMLactions_f.h"
    31. 

  31. #include "HTMLedit_f.h"
    32. 

  32. #include "HTMLimage_f.h"
    33. 

  33. #include "HTMLtable_f.h"
    34. 

  34. #include "HTMLsave_f.h"
    35. 

  35. #include "init_f.h"
    36. 

  36. #include "styleparser_f.h"
    37. 

  37. #include "UIcss_f.h"
    38. 

  38. #include "XHTMLbuilder_f.h"
    39. 

  39. #include "Xml2thot_f.h"
    40. 

  40. 

  41. #ifdef ANNOTATIONS
    42. 

  42. #include "annotlib.h"
    43. 

  43. #include "ANNOTtools_f.h"
    44. 

  44. #endif /* ANNOTATIONS */
    45. 

  45. 

  46. /* tables defined in XHTMLbuilder.c */
    47. 

  47. extern AttrValueMapping XhtmlAttrValueMappingTable[]; 
    48. 

  48. extern XmlEntity      XhtmlEntityTable[];
    49. 

  49. 

  50. typedef struct _UnicodeFallbackEntry
    51. 

  51. {
    52. 

  52.   int	unicodeVal;	/* the Unicode code */
    53. 

  53.   int	EightbitCode;   /* the corresponding glyph to be used from
    54. 

  54.                          the ISO Latin-1 or Symbol character set.
    55. 

  55.                          if 0 < EightbitCode < 255, it's the Symbol code for the correct glyph
    56. 

  56.                          if 1000 < EightbitCode < 1256, it's the ISO Latin-1 code + 1000 of an
    57. 

  57.                          approaching glyph
    58. 

  58.                          if 2000 < EightbitCode < 2256, it's the Symbol code + 2000 of an
    59. 

  59.                          approaching glyph */
    60. 

  60. }
    61. 

  61. UnicodeFallbackEntry;
    62. 

  62. 

  63. UnicodeFallbackEntry	UnicodeFallbackTable[] =
    64. 

  64.   {
    65. 

  65.     /* This table MUST be ordered according to the first field of each
    66. 

  66.        entry (Unicode code) */
    67. 

  67. 

  68.     /* OElig    */ {338, 1079}, /* latin capital ligature OE, U+0152 ISOlat2 */
    69. 

  69.     /* oelig    */ {339, 1111}, /* latin small ligature oe, U+0153 ISOlat2 */
    70. 

  70.     /* Scaron   */ {352, 1083}, /* latin capital letter S with caron, U+0160 ISOlat2 */
    71. 

  71.     /* scaron   */ {353, 1115}, /* latin small letter s with caron, U+0161 ISOlat2 */
    72. 

  72.     /* Yuml     */ {376, 1089}, /* latin capital letter Y with diaeresis, U+0178 ISOlat2 */
    73. 

  73.     /* fnof     */ {402, 166},  /* latin small f with hook = function = florin, U+0192 ISOtech */
    74. 

  74.     /* epsilon  */ {603, 101}, /* greek small letter epsilon, U+03B5 ISOgrk3 */
    75. 

  75.     /* circ     */ {710, 2217}, /* modifier letter circumflex accent, U+02C6 ISOpub */
    76. 

  76.     /* tilde    */ {732, 1126}, /* small tilde, U+02DC ISOdia */
    77. 

  77.     /* hat      */ {770, 1094}, /* small tilde, U+02DC ISOdia */
    78. 

  78.     /* UnderBar */ {818, 45}, /* U+0332 */
    79. 

  79.     /* Alpha    */ {913, 65}, /* greek capital letter alpha, U+0391 */
    80. 

  80.     /* Beta     */ {914, 66}, /* greek capital letter beta, U+0392 */
    81. 

  81.     /* Gamma    */ {915, 71}, /* greek capital letter gamma, U+0393 ISOgrk3 */
    82. 

  82.     /* Delta    */ {916, 68}, /* greek capital letter delta, U+0394 ISOgrk3 */
    83. 

  83.     /* Epsilon  */ {917, 69}, /* greek capital letter epsilon, U+0395 */
    84. 

  84.     /* Zeta     */ {918, 90}, /* greek capital letter zeta, U+0396 */
    85. 

  85.     /* Eta      */ {919, 72}, /* greek capital letter eta, U+0397 */
    86. 

  86.     /* Theta    */ {920, 81}, /* greek capital letter theta, U+0398 ISOgrk3 */
    87. 

  87.     /* Iota     */ {921, 73}, /* greek capital letter iota, U+0399 */
    88. 

  88.     /* Kappa    */ {922, 75}, /* greek capital letter kappa, U+039A */
    89. 

  89.     /* Lambda   */ {923, 76}, /* greek capital letter lambda, U+039B ISOgrk3 */
    90. 

  90.     /* Mu       */ {924, 77}, /* greek capital letter mu, U+039C */
    91. 

  91.     /* Nu       */ {925, 78}, /* greek capital letter nu, U+039D */
    92. 

  92.     /* Xi       */ {926, 88}, /* greek capital letter xi, U+039E ISOgrk3 */
    93. 

  93.     /* Omicron  */ {927, 79}, /* greek capital letter omicron, U+039F */
    94. 

  94.     /* Pi       */ {928, 80}, /* greek capital letter pi, U+03A0 ISOgrk3 */
    95. 

  95.     /* Rho      */ {929, 82}, /* greek capital letter rho, U+03A1 */
    96. 

  96.     /* Sigma    */ {931, 83}, /* greek capital letter sigma, U+03A3 ISOgrk3 */
    97. 

  97.     /* Tau      */ {932, 84}, /* greek capital letter tau, U+03A4 */
    98. 

  98.     /* Upsilon  */ {933, 85}, /* greek capital letter upsilon, U+03A5 ISOgrk3 */
    99. 

  99.     /* Phi      */ {934, 70}, /* greek capital letter phi, U+03A6 ISOgrk3 */
    100. 

  100.     /* Chi      */ {935, 67}, /* greek capital letter chi, U+03A7 */
    101. 

  101.     /* Psi      */ {936, 89}, /* greek capital letter psi, U+03A8 ISOgrk3 */
    102. 

  102.     /* Omega    */ {937, 87}, /* greek capital letter omega, U+03A9 ISOgrk3 */
    103. 

  103.     /* alpha    */ {945, 97}, /* greek small letter alpha, U+03B1 ISOgrk3 */
    104. 

  104.     /* beta     */ {946, 98}, /* greek small letter beta, U+03B2 ISOgrk3 */
    105. 

  105.     /* gamma    */ {947, 103}, /* greek small letter gamma, U+03B3 ISOgrk3 */
    106. 

  106.     /* delta    */ {948, 100}, /* greek small letter delta, U+03B4 ISOgrk3 */
    107. 

  107.     /* epsilon  */ {949, 101}, /* greek small letter epsilon, U+03B5 ISOgrk3 */
    108. 

  108.     /* zeta     */ {950, 122}, /* greek small letter zeta, U+03B6 ISOgrk3 */
    109. 

  109.     /* eta      */ {951, 104}, /* greek small letter eta, U+03B7 ISOgrk3 */
    110. 

  110.     /* theta    */ {952, 113}, /* greek small letter theta, U+03B8 ISOgrk3 */
    111. 

  111.     /* iota     */ {953, 105}, /* greek small letter iota, U+03B9 ISOgrk3 */
    112. 

  112.     /* kappa    */ {954, 107}, /* greek small letter kappa, U+03BA ISOgrk3 */
    113. 

  113.     /* lambda   */ {955, 108}, /* greek small letter lambda, U+03BB ISOgrk3 */
    114. 

  114.     /* mu       */ {956, 109}, /* greek small letter mu, U+03BC ISOgrk3 */
    115. 

  115.     /* nu       */ {957, 110}, /* greek small letter nu, U+03BD ISOgrk3 */
    116. 

  116.     /* xi       */ {958, 120}, /* greek small letter xi, U+03BE ISOgrk3 */
    117. 

  117.     /* omicron  */ {959, 111}, /* greek small letter omicron, U+03BF NEW */
    118. 

  118.     /* pi       */ {960, 112}, /* greek small letter pi, U+03C0 ISOgrk3 */
    119. 

  119.     /* rho      */ {961, 114}, /* greek small letter rho, U+03C1 ISOgrk3 */
    120. 

  120.     /* sigmaf   */ {962, 86},  /* greek small letter final sigma, U+03C2 ISOgrk3 */
    121. 

  121.     /* sigma    */ {963, 115}, /* greek small letter sigma, U+03C3 ISOgrk3 */
    122. 

  122.     /* tau      */ {964, 116}, /* greek small letter tau, U+03C4 ISOgrk3 */
    123. 

  123.     /* upsilon  */ {965, 117}, /* greek small letter upsilon, U+03C5 ISOgrk3 */
    124. 

  124.     /* phi      */ {966, 106}, /* greek small letter phi, U+03C6 ISOgrk3 */
    125. 

  125.     /* chi      */ {967, 99},  /* greek small letter chi, U+03C7 ISOgrk3 */
    126. 

  126.     /* psi      */ {968, 121}, /* greek small letter psi, U+03C8 ISOgrk3 */
    127. 

  127.     /* omega    */ {969, 119}, /* greek small letter omega, U+03C9 ISOgrk3 */
    128. 

  128.     /* thetasym */ {977, 74},  /* greek small letter theta symbol, U+03D1 NEW */
    129. 

  129.     /* upsih    */ {978, 161}, /* greek upsilon with hook symbol, U+03D2 NEW */
    130. 

  130.     /* phiv     */ {981, 102}, /* greek U+03D5 ISOgrk3 */
    131. 

  131.     /* piv      */ {982, 118}, /* greek pi symbol, U+03D6 ISOgrk3 */
    132. 

  132.     /* ensp     */ {8194, 1130}, /* en space, U+2002 ISOpub */
    133. 

  133.     /* emsp     */ {8195, 1160}, /* em space, U+2003 ISOpub */
    134. 

  134.     /* thinsp   */ {8201, 1129}, /* thin space, U+2009 ISOpub */
    135. 

  135.     /* zwnj     */ {8204, 1063}, /* zero width non-joiner, U+200C NEW RFC 2070 */
    136. 

  136.     /* zwj      */ {8205, 1063}, /* zero width joiner, U+200D NEW RFC 2070 */
    137. 

  137.     /* lrm      */ {8206, 1063}, /* left-to-right mark, U+200E NEW RFC 2070 */
    138. 

  138.     /* rlm      */ {8207, 1063}, /* right-to-left mark, U+200F NEW RFC 2070 */
    139. 

  139.     /* ndash    */ {8211, 2045}, /* en dash, U+2013 ISOpub */
    140. 

  140.     /* mdash    */ {8212, 2190}, /* em dash, U+2014 ISOpub */
    141. 

  141.     /* horbar   */ {8213, 190},  /* U+2015 */
    142. 

  142.     /* Verbar   */ {8214, 189},  /* U+2016 */
    143. 

  143.     /* lsquo    */ {8216, 1096}, /* left single quotation mark, U+2018 ISOnum */
    144. 

  144.     /* rsquo    */ {8217, 1039}, /* right single quotation mark, U+2019 ISOnum */
    145. 

  145.     /* sbquo    */ {8218, 1044}, /* single low-9 quotation mark, U+201A NEW */
    146. 

  146.     /* ldquo    */ {8220, 1096}, /* left double quotation mark, U+201C ISOnum */
    147. 

  147.     /* rdquo    */ {8221, 1039}, /* right double quotation mark, U+201D ISOnum */
    148. 

  148.     /* bdquo    */ {8222, 1044}, /* double low-9 quotation mark, U+201E NEW */
    149. 

  149.     /* dagger   */ {8224, 2042}, /* dagger, U+2020 ISOpub */
    150. 

  150.     /* Dagger   */ {8225, 2042}, /* double dagger, U+2021 ISOpub */
    151. 

  151.     /* bull     */ {8226, 183},  /* bullet = black small circle,  U+2022 ISOpub  */
    152. 

  152.     /* hellip   */ {8230, 188},  /* horizontal ellipsis = three dot leader,  U+2026 ISOpub  */
    153. 

  153.     /* lre      */ {8234, 1063}, /* left-to-right embed, U+202A NEW RFC 2070 */
    154. 

  154.     /* rle      */ {8235, 1063}, /* right-to-left embed, U+202B NEW RFC 2070 */
    155. 

  155.     /* pdf      */ {8236, 1063}, /* pop directional format, U+202C NEW RFC 2070 */
    156. 

  156.     /* lro      */ {8237, 1063}, /* left-to-right override, U+202D NEW RFC 2070 */
    157. 

  157.     /* rlo      */ {8238, 1063}, /* right-to-left override, U+202E NEW RFC 2070 */
    158. 

  158.     /* permil   */ {8240, 2037}, /* per mille sign, U+2030 ISOtech */
    159. 

  159.     /* prime    */ {8242, 162},  /* prime = minutes = feet, U+2032 ISOtech */
    160. 

  160.     /* Prime    */ {8243, 178},  /* double prime = seconds = inches,  U+2033 ISOtech */
    161. 

  161.     /* lsaquo   */ {8249, 1060}, /* single left-pointing angle quotation mark, U+2039 ISO proposed */
    162. 

  162.     /* rsaquo   */ {8250, 1062}, /* single right-pointing angle quotation mark, U+203A ISO proposed */
    163. 

  163.     /* oline    */ {8254, 1175}, /* overline = spacing overscore,  U+203E NEW */
    164. 

  164.     /* frasl    */ {8260, 164},  /* fraction slash, U+2044 NEW */
    165. 

  165.     /*ApplyFunction*/ {8289, 1129}, /* thin space, U+2009 ISOpub */
    166. 

  166.     /*InvisibleTimes*/ {8290, 1129}, /* thin space, U+2009 ISOpub */
    167. 

  167.     /*InvisibleComa*/ {8291, 1129}, /* thin space, U+2009 ISOpub */
    168. 

  168.     /* euro     */ {8364, 2206}, /* euro sign, U+20AC NEW */
    169. 

  169.     /*TripleDot */ {8411, 188},  /* tdot, U+20DB ISOtech */
    170. 

  170.     /* image    */ {8465, 193},  /* blackletter capital I = imaginary part,  U+2111 ISOamso */
    171. 

  171.     /* copysf   */ {8471, 211}, /* U+2117 */
    172. 

  172.     /* weierp   */ {8472, 195}, /* script capital P = power set  = Weierstrass p, U+2118 ISOamso */
    173. 

  173.     /* real     */ {8476, 194}, /* blackletter capital R = real part symbol,  U+211C ISOamso */
    174. 

  174.     /* trade    */ {8482, 212}, /* trade mark sign, U+2122 ISOnum */
    175. 

  175.     /* alefsym  */ {8501, 192}, /* alef symbol = first transfinite cardinal,  U+2135 NEW */
    176. 

  176.     /*DifferentialD*/{8518, 1100}, /* U+2146 */
    177. 

  177.     /*ExponentialE*/{8519, 1101},/* */
    178. 

  178.     /*ImaginaryI*/ {8520, 1105},/* */
    179. 

  179.     /* larr     */ {8592, 172}, /* leftwards arrow, U+2190 ISOnum */
    180. 

  180.     /* uarr     */ {8593, 173}, /* upwards arrow, U+2191 ISOnum*/
    181. 

  181.     /* rarr     */ {8594, 174}, /* rightwards arrow, U+2192 ISOnum */
    182. 

  182.     /* darr     */ {8595, 175}, /* downwards arrow, U+2193 ISOnum */
    183. 

  183.     /* harr     */ {8596, 171}, /* left right arrow, U+2194 ISOamsa */
    184. 

  184.     /* crarr    */ {8629, 191}, /* downwards arrow with corner leftwards  = carriage return, U+21B5 NEW */
    185. 

  185.     /* lrarr    */ {8646, 171}, /* U+21C6 */
    186. 

  186.     /* lArr     */ {8656, 220}, /* leftwards double arrow, U+21D0 ISOtech */
    187. 

  187.     /* uArr     */ {8657, 221}, /* upwards double arrow, U+21D1 ISOamsa */
    188. 

  188.     /* rArr     */ {8658, 222}, /* rightwards double arrow,  U+21D2 ISOtech */
    189. 

  189.     /* dArr     */ {8659, 223}, /* downwards double arrow, U+21D3 ISOamsa */
    190. 

  190.     /* hArr     */ {8660, 219}, /* left right double arrow,  U+21D4 ISOamsa */
    191. 

  191.     /* forall   */ {8704, 34},  /* for all, U+2200 ISOtech */
    192. 

  192.     /* part     */ {8706, 182}, /* partial differential, U+2202 ISOtech  */
    193. 

  193.     /* exist    */ {8707, 36},  /* there exists, U+2203 ISOtech */
    194. 

  194.     /* empty    */ {8709, 198}, /* empty set = null set = diameter,  U+2205 ISOamso */
    195. 

  195.     /* nabla    */ {8711, 209}, /* nabla = backward difference,  U+2207 ISOtech */
    196. 

  196.     /* isin     */ {8712, 206}, /* element of, U+2208 ISOtech */
    197. 

  197.     /* notin    */ {8713, 207}, /* not an element of, U+2209 ISOtech */
    198. 

  198.     /* ni       */ {8715, 39},  /* contains as member, U+220B ISOtech */
    199. 

  199.     /* prod     */ {8719, 213}, /* n-ary product = product sign,  U+220F ISOamsb */
    200. 

  200.     /* sum      */ {8721, 229}, /* n-ary sumation, U+2211 ISOamsb */
    201. 

  201.     /* minus    */ {8722, 45},  /* minus sign, U+2212 ISOtech */
    202. 

  202.     /* Backslash*/ {8726, 1092},/* U+8726 */
    203. 

  203.     /* lowast   */ {8727, 42},  /* asterisk operator, U+2217 ISOtech */
    204. 

  204.     /* radic    */ {8730, 214}, /* square root = radical sign,  U+221A ISOtech */
    205. 

  205.     /* prop     */ {8733, 181}, /* proportional to, U+221D ISOtech */
    206. 

  206.     /* infin    */ {8734, 165}, /* infinity, U+221E ISOtech */
    207. 

  207.     /* ang      */ {8736, 208}, /* angle, U+2220 ISOamso */
    208. 

  208.     /* VerticalBar*/ {8739, 1124}, /*  */
    209. 

  209.     /* parallel */ {8741, 1124}, /* parallel, U+2225 ISOtech */
    210. 

  210.     /* and      */ {8743, 217}, /* logical and = wedge, U+2227 ISOtech */
    211. 

  211.     /* or       */ {8744, 218}, /* logical or = vee, U+2228 ISOtech */
    212. 

  212.     /* cap      */ {8745, 199}, /* intersection = cap, U+2229 ISOtech */
    213. 

  213.     /* cup      */ {8746, 200}, /* union = cup, U+222A ISOtech */
    214. 

  214.     /* int      */ {8747, 242}, /* integral, U+222B ISOtech */
    215. 

  215.     /* there4   */ {8756, 92},  /* therefore, U+2234 ISOtech */
    216. 

  216.     /* Colon    */ {8759, 58},  /* Colon, U+2237 */
    217. 

  217.     /* sim      */ {8764, 126}, /* tilde operator = varies with = similar to,  U+223C ISOtech */
    218. 

  218.     /*EqualTilde*/ {8770, 64},  /* U+2242 ISOamsr */
    219. 

  219.     /* cong     */ {8773, 64},  /* approximately equal to, U+2245 ISOtech */
    220. 

  220.     /* asymp    */ {8776, 187}, /* almost equal to = asymptotic to,  U+2248 ISOamsr */
    221. 

  221.     /* ne       */ {8800, 185}, /* not equal to, U+2260 ISOtech */
    222. 

  222.     /* equiv    */ {8801, 186}, /* identical to, U+2261 ISOtech */
    223. 

  223.     /* le       */ {8804, 163}, /* less-than or equal to, U+2264 ISOtech */
    224. 

  224.     /* ge       */ {8805, 179}, /* greater-than or equal to,  U+2265 ISOtech */
    225. 

  225.     /* sub      */ {8834, 204}, /* subset of, U+2282 ISOtech */
    226. 

  226.     /* sup      */ {8835, 201}, /* superset of, U+2283 ISOtech */
    227. 

  227.     /* nsub     */ {8836, 203}, /* not a subset of, U+2284 ISOamsn */
    228. 

  228.     /* sube     */ {8838, 205}, /* subset of or equal to, U+2286 ISOtech */
    229. 

  229.     /* supe     */ {8839, 202}, /* superset of or equal to,  U+2287 ISOtech */
    230. 

  230.     /* subne    */ {8842, 203}, /* U+228A */
    231. 

  231.     /* oplus    */ {8853, 197}, /* circled plus = direct sum,  U+2295 ISOamsb */
    232. 

  232.     /* otimes   */ {8855, 196}, /* circled times = vector product,  U+2297 ISOamsb */
    233. 

  233.     /* DownTee  */ {8868, 94},  /* U+22A4 ISOtech */
    234. 

  234.     /* perp     */ {8869, 94},  /* up tack = orthogonal to = perpendicular,  U+22A5 ISOtech */
    235. 

  235.     /* Vee      */ {8897, 218},  /* U+22C1 ISOamsb */
    236. 

  236.     /*Intersection*/ {8898, 199},  /* U+22C2 ISOamsb */
    237. 

  237.     /*Intersection*/ {8899, 200},  /* U+22C3 ISOamsb */
    238. 

  238.     /* Diamond  */ {8900, 168}, /* diamond operator, U+22C4 ISOamsb */
    239. 

  239.     /* sdot     */ {8901, 215}, /* dot operator, U+22C5 ISOamsb */
    240. 

  240.     /* star     */ {8902, 1042},/* */
    241. 

  241.     /* Subset   */ {8912, 204}, /* U+22D0 */
    242. 

  242.     /* Cap      */ {8914, 199}, /* U+22D2 */
    243. 

  243.     /* Cup      */ {8915, 199}, /* U+22D3 */
    244. 

  244.     /* lceil    */ {8968, 233}, /* left ceiling = apl upstile,  U+2308 ISOamsc  */
    245. 

  245.     /* rceil    */ {8969, 249}, /* right ceiling, U+2309 ISOamsc  */
    246. 

  246.     /* lfloor   */ {8970, 235}, /* left floor = apl downstile,  U+230A ISOamsc  */
    247. 

  247.     /* rfloor   */ {8971, 251}, /* right floor, U+230B ISOamsc  */
    248. 

  248.     /* lang     */ {9001, 225}, /* left-pointing angle bracket = bra,  U+2329 ISOtech */
    249. 

  249.     /* rang     */ {9002, 241}, /* right-pointing angle bracket = ket,  U+232A ISOtech */
    250. 

  250.     /* dtri     */ {9663, 209}, /* lozenge, U+25BF */
    251. 

  251.     /* loz      */ {9674, 224}, /* lozenge, U+25CA ISOpub */
    252. 

  252.     /* spades   */ {9824, 170}, /* black spade suit, U+2660 ISOpub */
    253. 

  253.     /* clubs    */ {9827, 167}, /* black club suit = shamrock,  U+2663 ISOpub */
    254. 

  254.     /* hearts   */ {9829, 169}, /* black heart suit = valentine,  U+2665 ISOpub */
    255. 

  255.     /* diams    */ {9830, 168}, /* black diamond suit, U+2666 ISOpub */
    256. 

  256.     /* lang     */ {0x27E8, 225},/* U+27E8 Mathematical left angle bracket */
    257. 

  257.     /* rang     */ {0x27E9, 241},/* U+27E9 Mathematical right angle bracket */
    258. 

  258.     /* And      */ {10835, 217}, /* U+2A53 */
    259. 

  259.     /* Or       */ {10836, 218}, /* U+2A54 */
    260. 

  260.     /* Equal    */ {10869, 1061},/*  */
    261. 

  261.     /* Not      */ {10988, 216}, /* U+2AEC */
    262. 

  262.     /* OverBrace*/ {65079, 132}, /* U+FE37 */
    263. 

  263.     /*UnderBrace*/ {65080, 133}, /* U+FE38 */
    264. 

  264. 

  265.     /* THE END  */ {0, 0}	    /* last entry (required) */
    266. 

  266.   };
    267. 

  267. 

  268. typedef struct _ElemToBeChecked *PtrElemToBeChecked;
    269. 

  269. typedef struct _ElemToBeChecked
    270. 

  270. {
    271. 

  271.   Element               Elem;	/* the element to be checked */
    272. 

  272.   PtrElemToBeChecked    nextElemToBeChecked;
    273. 

  273. }
    274. 

  274. ElemToBeChecked;
    275. 

  275. 

  276. /* empty elements */
    277. 

  277. static int          EmptyElement[] =
    278. 

  278.   {
    279. 

  279.     HTML_EL_AREA,
    280. 

  280.     HTML_EL_BASE,
    281. 

  281.     HTML_EL_BaseFont,
    282. 

  282.     HTML_EL_BR,
    283. 

  283.     HTML_EL_COL,
    284. 

  284.     HTML_EL_FRAME,
    285. 

  285.     HTML_EL_Horizontal_Rule,
    286. 

  286.     HTML_EL_IMG,
    287. 

  287.     HTML_EL_Input,
    288. 

  288.     HTML_EL_ISINDEX,
    289. 

  289.     HTML_EL_LINK,
    290. 

  290.     HTML_EL_META,
    291. 

  291.     HTML_EL_Parameter,
    292. 

  292.     HTML_EL_PICTURE_UNIT,
    293. 

  293.     0};
    294. 

  294. 

  295. /* character level elements */
    296. 

  296. static int          CharLevelElement[] =
    297. 

  297.   {
    298. 

  298.     HTML_EL_TEXT_UNIT, HTML_EL_PICTURE_UNIT, HTML_EL_SYMBOL_UNIT,
    299. 

  299.     HTML_EL_Anchor,
    300. 

  300.     HTML_EL_Teletype_text, HTML_EL_Italic_text, HTML_EL_Bold_text,
    301. 

  301.     HTML_EL_Underlined_text, HTML_EL_Struck_text, HTML_EL_Big_text,
    302. 

  302.     HTML_EL_Small_text,
    303. 

  303.     HTML_EL_Emphasis, HTML_EL_Strong, HTML_EL_Def, HTML_EL_Code, HTML_EL_Sample,
    304. 

  304.     HTML_EL_Keyboard, HTML_EL_Variable_, HTML_EL_Cite, HTML_EL_ABBR,
    305. 

  305.     HTML_EL_ACRONYM,
    306. 

  306.     HTML_EL_Font_, HTML_EL_Quotation, HTML_EL_Subscript, HTML_EL_Superscript,
    307. 

  307.     HTML_EL_Span, HTML_EL_BDO, HTML_EL_ins, HTML_EL_del,
    308. 

  308.     HTML_EL_IMG, HTML_EL_Input,
    309. 

  309.     HTML_EL_Option, HTML_EL_OptGroup, HTML_EL_Option_Menu,
    310. 

  310.     HTML_EL_Text_Input, HTML_EL_Password_Input, HTML_EL_File_Input,
    311. 

  311.     HTML_EL_Checkbox_Input, HTML_EL_Radio_Input, HTML_EL_Submit_Input,
    312. 

  312.     HTML_EL_Reset_Input, HTML_EL_Hidden_Input, HTML_EL_Inserted_Text,
    313. 

  313.     HTML_EL_Button_Input, HTML_EL_BUTTON_,
    314. 

  314.     HTML_EL_LABEL,
    315. 

  315.     HTML_EL_BR, HTML_EL_ruby,
    316. 

  316.     HTML_EL_Object, HTML_EL_Basic_Elem,
    317. 

  317.     0};
    318. 

  318. 

  319. /* block level elements, i.e. elements having a Line rule in the presentation
    320. 

  320.    schema fo the main view */
    321. 

  321. static int          BlockLevelElement[] =
    322. 

  322.   {
    323. 

  323.     HTML_EL_H1, HTML_EL_H2, HTML_EL_H3, HTML_EL_H4, HTML_EL_H5, HTML_EL_H6,
    324. 

  324.     HTML_EL_Paragraph, HTML_EL_Pseudo_paragraph, HTML_EL_Text_Area,
    325. 

  325.     HTML_EL_Term, HTML_EL_Address, HTML_EL_LEGEND, HTML_EL_CAPTION,
    326. 

  326.     HTML_EL_INS, HTML_EL_DEL, HTML_EL_Division,
    327. 

  327.     0};
    328. 

  328. 

  329. /* start tags that imply the end of a current element */
    330. 

  330. /* any tag of each line implies the end of the current element if the type of
    331. 

  331.    that element is in the same line */
    332. 

  332. typedef char        oneLine[100];
    333. 

  333. static oneLine      EquivEndingElem[] =
    334. 

  334.   {
    335. 

  335.     "dt dd li option",
    336. 

  336.     "h1 h2 h3 h4 h5 h6",
    337. 

  337.     "address pre listing xmp",
    338. 

  338.     ""
    339. 

  339.   };
    340. 

  340. /* acording the HTML DTD, HR should be added to the 2nd line above, as it */
    341. 

  341. /* is not allowed within a H1, H2, H3, etc. But we should tolerate that case */
    342. 

  342. /* because many documents contain rules in headings... */
    343. 

  343. 

  344. /* start tags that imply the end of current element */
    345. 

  345. static oneLine      StartTagEndingElem[] =
    346. 

  346.   {
    347. 

  347.     "form closes form p p* hr h1 h2 h3 h4 h5 h6 dl ul ol menu dir address pre listing xmp head",
    348. 

  348.     "head closes p p*",
    349. 

  349.     "title closes p p*",
    350. 

  350.     "body closes head style script title p p*",
    351. 

  351.     "li closes p p* h1 h2 h3 h4 h5 h6 dl address pre listing xmp head",
    352. 

  352.     "hr closes p p* head",
    353. 

  353.     "h1 closes p p* head",
    354. 

  354.     "h2 closes p p* head",
    355. 

  355.     "h3 closes p p* head",
    356. 

  356.     "h4 closes p p* head",
    357. 

  357.     "h5 closes p p* head",
    358. 

  358.     "h6 closes p p* head",
    359. 

  359.     "dir closes p p* head",
    360. 

  360.     "address closes p p* head ul",
    361. 

  361.     "pre closes p p* head ul",
    362. 

  362.     "listing closes p p* head",
    363. 

  363.     "xmp closes p p* head",
    364. 

  364.     "blockquote closes p p* head",
    365. 

  365.     "dl closes p p* dt menu dir address pre listing xmp head",
    366. 

  366.     "dt closes p p* menu dir address pre listing xmp head",
    367. 

  367.     "dd closes p p* menu dir address pre listing xmp head",
    368. 

  368.     "ul closes p p* head ol menu dir address pre listing xmp",
    369. 

  369.     "ol closes p p* head ul",
    370. 

  370.     "menu closes p p* head ul",
    371. 

  371.     "p closes p p* head h1 h2 h3 h4 h5 h6",
    372. 

  372.     "p* closes p p* head",
    373. 

  373.     "div closes p p* head",
    374. 

  374.     "noscript closes p p* head",
    375. 

  375.     "center closes font b i p p* head",
    376. 

  376.     "a closes a",
    377. 

  377.     "caption closes p p*",
    378. 

  378.     "colgroup closes caption colgroup col p p*",
    379. 

  379.     "col closes caption col p p*",
    380. 

  380.     "table closes p p* head h1 h2 h3 h4 h5 h6 pre listing xmp a",
    381. 

  381.     "th closes th td",
    382. 

  382.     "td closes th td",
    383. 

  383.     "tr closes th td tr caption col colgroup",
    384. 

  384.     "thead closes caption col colgroup",
    385. 

  385.     "tfoot closes th td tr caption col colgroup thead tbody",
    386. 

  386.     "tbody closes th td tr caption col colgroup thead tfoot tbody",
    387. 

  387.     "optgroup closes option",
    388. 

  388.     "fieldset closes legend p p* head h1 h2 h3 h4 h5 h6 pre listing xmp a",
    389. 

  389.     ""
    390. 

  390.   };
    391. 

  391. 

  392. 

  393. typedef int         State;	/* a state of the automaton */
    394. 

  394. 

  395. extern int               HTML_ENTRIES;
    396. 

  396. static PtrClosedElement *FirstClosedElem;
    397. 

  397. 

  398. /* ---------------------- static variables ---------------------- */
    399. 

  399. /* parser stack */
    400. 

  400. #define MaxStack 200		/* maximum stack height */
    401. 

  401. static int          GINumberStack[MaxStack]; /* entry of pHTMLGIMapping */
    402. 

  402. static Element      ElementStack[MaxStack];  /* element in the Thot abstract
    403. 

  403.                                                 tree */
    404. 

  404. static int          ThotLevel[MaxStack];     /* level of element in the Thot
    405. 

  405.                                                 tree */
    406. 

  406. static Language	    LanguageStack[MaxStack]; /* element language */
    407. 

  407. static int          StackLevel = 0;	     /* first free element on the
    408. 

  408.                                             stack */
    409. 

  409. /* information about the input file */
    410. 

  410. #define INPUT_FILE_BUFFER_SIZE 2000
    411. 

  411. #define PREV_READ_CHARS 30
    412. 

  412. static char         FileBuffer[INPUT_FILE_BUFFER_SIZE+1];
    413. 

  413. static char         PreviousRead[PREV_READ_CHARS+1];
    414. 

  414. static char        *WorkBuffer = FileBuffer;
    415. 

  415. static int	        LastCharInWorkBuffer = 0; /* last char. in the buffer */
    416. 

  416. static int	        LastCharInPreviousRead = 0;
    417. 

  417. static int          CurrentBufChar = 0;           /* current character read */
    418. 

  418. static int          StartOfTagIndx = 0;           /* last "<" read */
    419. 

  419. static int          StartOfRead = 0;
    420. 

  420. static char	        PreviousBufChar = EOS;    /* previous character read */
    421. 

  421. static char        *InputText = NULL;
    422. 

  422. static gzFile       stream = 0;
    423. 

  423. static int          NumberOfLinesRead = 0;/* number of lines read in the
    424. 

  424.                                              file */
    425. 

  425. static int          NumberOfCharRead = 0; /* number of characters read in the
    426. 

  426.                                              current line */
    427. 

  427. static ThotBool     EmptyLine = TRUE;	  /* no printable character encountered
    428. 

  428.                                            yet in the current line */
    429. 

  429. static ThotBool     StartOfFile = TRUE;	  /* no printable character encountered
    430. 

  430.                                              yet in the file */
    431. 

  431. static ThotBool     AfterTagPRE = FALSE;  /* <PRE> has just been read */
    432. 

  432. static char*        docURL = NULL;	  /* path or URL of the document */
    433. 

  433. static char        *docURL2 = NULL;       /* save the docURL for some cases of parsing errors */
    434. 

  434. 

  435. /* Static variables used for the call to the XML parser */
    436. 

  436. static ThotBool     NotToReadFile = FALSE;
    437. 

  437. static int          PreviousNumberOfLinesRead = 0;
    438. 

  438. static int          PreviousNumberOfCharRead = 0;
    439. 

  439. 

  440. /* Boolean that indicates the end of a HTML file */
    441. 

  441. /* It is a static variable because it is used in parameter */
    442. 

  442. /* for the call of the new XML parser (EndOfStartGI) */
    443. 

  443. static ThotBool     EndOfHtmlFile;
    444. 

  444. 

  445. /* input buffer */
    446. 

  446. #define MaxBufferLength 1000
    447. 

  447. #define AllmostFullBuffer 700
    448. 

  448. #define MaxMsgLength 300	/* maximum size of error messages */
    449. 

  449. static  unsigned char     inputBuffer[MaxBufferLength];
    450. 

  450. static int          LgBuffer = 0;	  /* actual length of text in input
    451. 

  451.                                        buffer */
    452. 

  452. static int	    BufferLineNumber = 0; /* line number in the source file of
    453. 

  453.                                          the beginning of the text
    454. 

  454.                                          contained in the buffer */
    455. 

  455. 

  456. /* information about the Thot document under construction */
    457. 

  457. /* global data used by the HTML parser */
    458. 

  458. static ParserData   HTMLcontext = {0, ISO_8859_1, 0, NULL, 0,
    459. 

  459.                                    FALSE, FALSE, FALSE, FALSE, FALSE, FALSE};
    460. 

  460. 

  461. static SSchema      DocumentSSchema = NULL;  /* the HTML structure schema */
    462. 

  462. static Element      rootElement = NULL;	  /* root element of the document */
    463. 

  463. static int          lastElemEntry = 0;	  /* index in the pHTMLGIMapping of the
    464. 

  464.                                              element being created */
    465. 

  465. static Attribute    lastAttribute = NULL; /* last attribute created */
    466. 

  466. static Attribute    lastAttrElement = NULL;/* element with which the last
    467. 

  467.                                               attribute has been associated */
    468. 

  468. static AttributeMapping *lastAttrEntry = NULL; /* entry in the AttributeMappingTable
    469. 

  469.                                                   of the attribute being created */
    470. 

  470. static ThotBool     UnknownAttr = FALSE;  /* the last attribute encountered is
    471. 

  471.                                              invalid */
    472. 

  472. static ThotBool     ReadingAnAttrValue = FALSE;
    473. 

  473. static ThotBool     TruncatedAttrValue = FALSE;
    474. 

  474. static char        *BufferAttrValue = NULL;
    475. 

  475. static int          LgBufferAttrValue = 0;
    476. 

  476. static Element      CommentText = NULL;	  /* TEXT element of the current
    477. 

  477.                                              Comment element */
    478. 

  478. static Element      ASPText = NULL;	     /* TEXT element of the current
    479. 

  479.                                             ASP element */
    480. 

  480. static Element      PIText = NULL;	     /* TEXT element of the current
    481. 

  481.                                             ASP element */
    482. 

  482. static ThotBool     UnknownTag = FALSE;	  /* the last start tag encountered is
    483. 

  483.                                              invalid */
    484. 

  484. static ThotBool     HTMLrootClosed = FALSE;
    485. 

  485. static char        *HTMLrootClosingTag = NULL;
    486. 

  486. 

  487. static PtrElemToBeChecked FirstElemToBeChecked = NULL;
    488. 

  488. static PtrElemToBeChecked LastElemToBeChecked = NULL;
    489. 

  489. 

  490. /* automaton */
    491. 

  491. static State        currentState;	  /* current state of the automaton */
    492. 

  492. static State        returnState;	  /* return state from subautomaton */
    493. 

  493. static ThotBool     NormalTransition;
    494. 

  494. static ThotBool     CharProcessed;
    495. 

  495. 

  496. 

  497. /* information about an entity being read */
    498. 

  498. static char         EntityName[MaxEntityLength];/* name of entity being read */
    499. 

  499. static int          LgEntityName = 0;	  /* length of entity name read so
    500. 

  500.                                            far */
    501. 

  501. static int          EntityTableEntry = 0; /* entry of the entity table that
    502. 

  502.                                              matches the entity read so far */
    503. 

  503. static int          CharRank = 0;	  /* rank of the last matching
    504. 

  504.                                        character in that entry */
    505. 

  505. /* second char of an UTF-8 string */
    506. 

  506. static unsigned char SecondByte[6] = {EOS, EOS, EOS, EOS, EOS, EOS};
    507. 

  507. static void         ProcessStartGI (const char* GIname);
    508. 

  508. static void         EndOfAttrValue (char c);
    509. 

  509. 

  510. /*----------------------------------------------------------------------
    511. 

  511.   ----------------------------------------------------------------------*/
    512. 

  512. static const char *StrCaseStr (const char *str1, const char *str2)
    513. 

  513. {
    514. 

  514.   char        c;
    515. 

  515.   const char *ptr;
    516. 

  516.   int         len;
    517. 

  517. 

  518.   if (str1 == NULL || str2 == NULL)
    519. 

  519.     return NULL;
    520. 

  520.   c = *str2;
    521. 

  521.   len = strlen ((char *)str2);
    522. 

  522.   ptr = str1;
    523. 

  523.   while (*ptr != EOS)
    524. 

  524.     {
    525. 

  525.       if (tolower(*ptr) == c && !strncasecmp ((char *)str2, ptr, len))
    526. 

  526.         return ptr;
    527. 

  527.       else
    528. 

  528.         ptr++;
    529. 

  529.     }
    530. 

  530.   return NULL;
    531. 

  531. }
    532. 

  532. 

  533. /*----------------------------------------------------------------------
    534. 

  534.   ----------------------------------------------------------------------*/
    535. 

  535. char *SkipSep (char *ptr)
    536. 

  536. {
    537. 

  537.   while (*ptr == SPACE || *ptr == ',')
    538. 

  538.     ptr++;
    539. 

  539.   return (ptr);
    540. 

  540. }
    541. 

  541. 

  542. /*----------------------------------------------------------------------
    543. 

  543.   ----------------------------------------------------------------------*/
    544. 

  544. char *SkipInt (char *ptr)
    545. 

  545. {
    546. 

  546.   while (*ptr != EOS && *ptr != SPACE && *ptr != ',')
    547. 

  547.     ptr++;
    548. 

  548.   return (ptr);
    549. 

  549. }
    550. 

  550. 

  551. /*----------------------------------------------------------------------
    552. 

  552.   ParseAreaCoords 
    553. 

  553.   Computes x, y, width and height of the box from the coords attribute value.
    554. 

  554.   ----------------------------------------------------------------------*/
    555. 

  555. void ParseAreaCoords (Element element, Document document)
    556. 

  556. {
    557. 

  557.   ElementType      elType;
    558. 

  558.   AttributeType    attrType;
    559. 

  559.   Attribute        attrCoords, attrX, attrY;
    560. 

  560.   Attribute        attrW, attrH, attrShape;
    561. 

  561.   char            *ptr3, *text;
    562. 

  562.   int              x1, y1, x2, y2;
    563. 

  563.   int              length, shape, r;
    564. 

  564. 

  565.   /* Is it an AREA element */
    566. 

  566.   elType = TtaGetElementType (element);
    567. 

  567.   if (elType.ElTypeNum != HTML_EL_AREA)
    568. 

  568.     return;
    569. 

  569. 

  570.   /* Search the coords attribute */
    571. 

  571.   attrType.AttrSSchema = elType.ElSSchema;
    572. 

  572.   attrType.AttrTypeNum = HTML_ATTR_coords;
    573. 

  573.   attrCoords = TtaGetAttribute (element, attrType);
    574. 

  574.   if (attrCoords == NULL)
    575. 

  575.     return;
    576. 

  576. 

  577.   /* Search the shape attribute */
    578. 

  578.   attrType.AttrTypeNum = HTML_ATTR_shape;
    579. 

  579.   attrShape = TtaGetAttribute (element, attrType);
    580. 

  580.   if (attrShape == NULL)
    581. 

  581.     /* no shape attribute. Create one with value rectangle */
    582. 

  582.     {
    583. 

  583.       attrShape = TtaNewAttribute (attrType);
    584. 

  584.       TtaAttachAttribute (element, attrShape, document);
    585. 

  585.       shape = HTML_ATTR_shape_VAL_rectangle;
    586. 

  586.       TtaSetAttributeValue (attrShape, shape, element, document);
    587. 

  587.     }
    588. 

  588.   else
    589. 

  589.     shape = TtaGetAttributeValue (attrShape);
    590. 

  590.   length = TtaGetTextAttributeLength (attrCoords);
    591. 

  591.   text = (char*)TtaGetMemory (length + 1);
    592. 

  592.   TtaGiveTextAttributeValue (attrCoords, text, &length);
    593. 

  593. 

  594.   if (shape == HTML_ATTR_shape_VAL_rectangle ||
    595. 

  595.       shape == HTML_ATTR_shape_VAL_circle)
    596. 

  596.     {
    597. 

  597.       /* Search the x_coord attribute */
    598. 

  598.       attrType.AttrTypeNum = HTML_ATTR_x_coord;
    599. 

  599.       attrX = TtaGetAttribute (element, attrType);
    600. 

  600.       if (attrX == NULL)
    601. 

  601.         {
    602. 

  602.           /* create it */
    603. 

  603.           attrX = TtaNewAttribute (attrType);
    604. 

  604.           TtaAttachAttribute (element, attrX, document);
    605. 

  605.         }
    606. 

  606.       /* Search the y_coord attribute */
    607. 

  607.       attrType.AttrTypeNum = HTML_ATTR_y_coord;
    608. 

  608.       attrY = TtaGetAttribute (element, attrType);
    609. 

  609.       if (attrY == NULL)
    610. 

  610.         {
    611. 

  611.           /* create it */
    612. 

  612.           attrY = TtaNewAttribute (attrType);
    613. 

  613.           TtaAttachAttribute (element, attrY, document);
    614. 

  614.         }
    615. 

  615.       /* Search the width attribute */
    616. 

  616.       attrType.AttrTypeNum = HTML_ATTR_IntWidthPxl;
    617. 

  617.       attrW = TtaGetAttribute (element, attrType);
    618. 

  618.       if (attrW == NULL)
    619. 

  619.         {
    620. 

  620.           /* create it */
    621. 

  621.           attrW = TtaNewAttribute (attrType);
    622. 

  622.           TtaAttachAttribute (element, attrW, document);
    623. 

  623.         }
    624. 

  624.       /* Search the height attribute */
    625. 

  625.       attrType.AttrTypeNum = HTML_ATTR_IntHeightPxl;
    626. 

  626.       attrH = TtaGetAttribute (element, attrType);
    627. 

  627.       if (attrH == NULL)
    628. 

  628.         {
    629. 

  629.           /* create it */
    630. 

  630.           attrH = TtaNewAttribute (attrType);
    631. 

  631.           TtaAttachAttribute (element, attrH, document);
    632. 

  632.         }
    633. 

  633.       if (shape == HTML_ATTR_shape_VAL_rectangle)
    634. 

  634.         {
    635. 

  635.           x1 = x2 = y1 = y2 = 0;
    636. 

  636.           ptr3 = text;
    637. 

  637.           if (ptr3)
    638. 

  638.             sscanf (ptr3, "%d", &x1);
    639. 

  639.           ptr3 = SkipInt (ptr3);
    640. 

  640.           ptr3 = SkipSep (ptr3);
    641. 

  641.           if (ptr3)
    642. 

  642.             sscanf (ptr3, "%d", &y1);
    643. 

  643.           ptr3 = SkipInt (ptr3);
    644. 

  644.           ptr3 = SkipSep (ptr3);
    645. 

  645.           if (ptr3)
    646. 

  646.             sscanf (ptr3, "%d", &x2);
    647. 

  647.           ptr3 = SkipInt (ptr3);
    648. 

  648.           ptr3 = SkipSep (ptr3);
    649. 

  649.           sscanf (ptr3, "%d", &y2);
    650. 

  650.           TtaSetAttributeValue (attrX, x1, element, document);
    651. 

  651.           TtaSetAttributeValue (attrY, y1, element, document);
    652. 

  652.           TtaSetAttributeValue (attrW, x2 - x1, element, document);
    653. 

  653.           TtaSetAttributeValue (attrH, y2 - y1, element, document);
    654. 

  654.         }
    655. 

  655.       else
    656. 

  656.         {
    657. 

  657.           x1 = y1 = r = 0;
    658. 

  658.           ptr3 = text;
    659. 

  659.           if (ptr3)
    660. 

  660.             sscanf (ptr3, "%d", &x1);
    661. 

  661.           ptr3 = SkipInt (ptr3);
    662. 

  662.           ptr3 = SkipSep (ptr3);
    663. 

  663.           if (ptr3)
    664. 

  664.             sscanf (ptr3, "%d", &y1);
    665. 

  665.           ptr3 = SkipInt (ptr3);
    666. 

  666.           ptr3 = SkipSep (ptr3);
    667. 

  667.           if (ptr3)
    668. 

  668.             sscanf (ptr3, "%d", &r);
    669. 

  669.           TtaSetAttributeValue (attrX, x1 - r, element, document);
    670. 

  670.           TtaSetAttributeValue (attrY, y1 - r, element, document);
    671. 

  671.           TtaSetAttributeValue (attrW, 2 * r, element, document);
    672. 

  672.           TtaSetAttributeValue (attrH, 2 * r, element, document);
    673. 

  673.         }
    674. 

  674.     }
    675. 

  675.   else if (shape == HTML_ATTR_shape_VAL_polygon)
    676. 

  676.     {
    677. 

  677.       element = TtaGetFirstChild (element);
    678. 

  678.       length = TtaGetPolylineLength (element);
    679. 

  679.       /* remove previous points */
    680. 

  680.       while (length > 1)
    681. 

  681.         {
    682. 

  682.           TtaDeletePointInPolyline (element, length, document);
    683. 

  683.           length--;
    684. 

  684.         }
    685. 

  685.       length = 1;
    686. 

  686.       ptr3 = text;
    687. 

  687.       /* add new points */
    688. 

  688.       while (*ptr3 != EOS)
    689. 

  689.         {
    690. 

  690.           x1 = y1 = 0;
    691. 

  691.           sscanf (ptr3, "%d", &x1);
    692. 

  692.           ptr3 = SkipInt (ptr3);
    693. 

  693.           ptr3 = SkipSep (ptr3);
    694. 

  694.           if (ptr3)
    695. 

  695.             sscanf (ptr3, "%d", &y1);
    696. 

  696.           ptr3 = SkipInt (ptr3);
    697. 

  697.           ptr3 = SkipSep (ptr3);
    698. 

  698.           TtaAddPointInPolyline (element, length, UnPixel, x1, y1,document,
    699. 

  699. 				 FALSE);
    700. 

  700.           length++;
    701. 

  701.         }
    702. 

  702.     }
    703. 

  703.   TtaFreeMemory (text);
    704. 

  704. }
    705. 

  705. 

  706. /*----------------------------------------------------------------------
    707. 

  707.   SetLanguagInHTMLStack
    708. 

  708.   Sets the value of the language.
    709. 

  709.   ----------------------------------------------------------------------*/
    710. 

  710. void  SetLanguagInHTMLStack (Language lang)
    711. 

  711. {
    712. 

  712.   LanguageStack[StackLevel - 1] = lang;
    713. 

  713. }
    714. 

  714. 

  715. /*----------------------------------------------------------------------
    716. 

  716.   IsHtmlParsingCSS 
    717. 

  717.   Returns the value of ParsingCSS boolean.
    718. 

  718.   ----------------------------------------------------------------------*/
    719. 

  719. ThotBool  IsHtmlParsingCSS ()
    720. 

  720. {
    721. 

  721.   return HTMLcontext.parsingCSS;
    722. 

  722. }
    723. 

  723. 

  724. /*----------------------------------------------------------------------
    725. 

  725.   SetHtmlParsingCSS 
    726. 

  726.   Sets the value of ParsingCSS boolean.
    727. 

  727.   ----------------------------------------------------------------------*/
    728. 

  728. void  SetHtmlParsingCSS (ThotBool value)
    729. 

  729. {
    730. 

  730.   HTMLcontext.parsingCSS = value;
    731. 

  731. }
    732. 

  732. 

  733. /*----------------------------------------------------------------------
    734. 

  734.   SetHtmlParsingTextArea
    735. 

  735.   Sets the value of ParsingTextArea boolean.
    736. 

  736.   ----------------------------------------------------------------------*/
    737. 

  737. void  SetHtmlParsingTextArea (ThotBool value)
    738. 

  738. {
    739. 

  739.   HTMLcontext.parsingTextArea = value;
    740. 

  740. }
    741. 

  741. 

  742. /*----------------------------------------------------------------------
    743. 

  743.   SetHtmlParsingScript
    744. 

  744.   Sets the value of ParsingScript boolean.
    745. 

  745.   ----------------------------------------------------------------------*/
    746. 

  746. void  SetHtmlParsingScript (ThotBool value)
    747. 

  747. {
    748. 

  748.   HTMLcontext.parsingScript = value;
    749. 

  749. }
    750. 

  750. 

  751. /*----------------------------------------------------------------------
    752. 

  752.   SetHtmlElemLineNumber
    753. 

  753.   Assigns the current line number
    754. 

  754.   ----------------------------------------------------------------------*/
    755. 

  755. void SetHtmlElemLineNumber (Element el)
    756. 

  756. {
    757. 

  757.   TtaSetElementLineNumber (el, NumberOfLinesRead);
    758. 

  758. }
    759. 

  759. 

  760. /*----------------------------------------------------------------------
    761. 

  761.   IsWithinHtmlTable 
    762. 

  762.   Returns the value of WithinTable integer.
    763. 

  763.   ----------------------------------------------------------------------*/
    764. 

  764. int  IsWithinHtmlTable ()
    765. 

  765. {
    766. 

  766.   return HTMLcontext.withinTable;
    767. 

  767. }
    768. 

  768. 

  769. /*----------------------------------------------------------------------
    770. 

  770.   copyCEstring    create a copy of the string of elements pointed
    771. 

  771.   by first and return a pointer on the first
    772. 

  772.   element of the copy.
    773. 

  773.   ----------------------------------------------------------------------*/
    774. 

  774. static PtrClosedElement copyCEstring (PtrClosedElement first)
    775. 

  775. {
    776. 

  776.   PtrClosedElement     ret, cur, next, prev;
    777. 

  777.  
    778. 

  778.   ret = NULL;
    779. 

  779.   cur = first;
    780. 

  780.   prev = NULL;
    781. 

  781.   while (cur != NULL)
    782. 

  782.     {
    783. 

  783.       next = (PtrClosedElement) TtaGetMemory (sizeof (ClosedElement));
    784. 

  784.       next->nextClosedElem = NULL;
    785. 

  785.       next->tagNum = cur->tagNum;
    786. 

  786.       if (ret == NULL)
    787. 

  787.         ret = next;
    788. 

  788.       else
    789. 

  789.         prev->nextClosedElem = next;
    790. 

  790.       prev = next;
    791. 

  791.       cur = cur->nextClosedElem;
    792. 

  792.     }
    793. 

  793.   return ret;
    794. 

  794. }
    795. 

  795. 

  796. /*----------------------------------------------------------------------
    797. 

  797.   InitMapping     intialise the list of the elements closed by
    798. 

  798.   each start tag.
    799. 

  799.   ----------------------------------------------------------------------*/
    800. 

  800. void InitMapping (void)
    801. 

  801. {
    802. 

  802.   int                 line;
    803. 

  803.   int                 entry;
    804. 

  804.   int                 ptr;
    805. 

  805.   int                 i;
    806. 

  806.   typeName            name;
    807. 

  807.   PtrClosedElement    newCE, lastCE, firstCE, curCE;
    808. 

  808.   SSchema	       schema;
    809. 

  809. 

  810.   /* building the table */
    811. 

  811.   FirstClosedElem = (PtrClosedElement *)TtaGetMemory (HTML_ENTRIES * sizeof(PtrClosedElement));
    812. 

  812.   for (entry = 0; entry < HTML_ENTRIES; entry++)
    813. 

  813.     FirstClosedElem[entry] = NULL;
    814. 

  814. 

  815.   /* read table EquivEndingElem */
    816. 

  816.   line = 0;
    817. 

  817.   do
    818. 

  818.     /* read one line of EquivEndingElem */
    819. 

  819.     {
    820. 

  820.       ptr = 0;
    821. 

  821.       lastCE = NULL;
    822. 

  822.       firstCE = NULL; 
    823. 

  823.       do
    824. 

  824.         {
    825. 

  825.           /* read one identifier */
    826. 

  826.           i = 0;
    827. 

  827.           while (EquivEndingElem[line][ptr] != SPACE &&
    828. 

  828.                  EquivEndingElem[line][ptr] != EOS)
    829. 

  829.             name[i++] = EquivEndingElem[line][ptr++];
    830. 

  830.           name[i] = EOS;
    831. 

  831.           ptr++;
    832. 

  832.           if (i > 0)
    833. 

  833.             /* a identifier has been read */
    834. 

  834.             {
    835. 

  835.               schema = DocumentSSchema;
    836. 

  836.               entry = MapGI ((char *)name, &schema, HTMLcontext.doc);
    837. 

  837. #ifdef DEBUG
    838. 

  838.               if (entry < 0)
    839. 

  839.                 fprintf (stderr, "error in EquivEndingElem: tag %s unknown in line\n%s\n", name, EquivEndingElem[line]);
    840. 

  840.               else
    841. 

  841. #endif
    842. 

  842.                 {
    843. 

  843.                   newCE = (PtrClosedElement) TtaGetMemory (sizeof (ClosedElement));
    844. 

  844.                   newCE->nextClosedElem = NULL;
    845. 

  845.                   newCE->tagNum = entry;
    846. 

  846.                   if (firstCE == NULL)
    847. 

  847.                     firstCE = newCE;
    848. 

  848.                   else
    849. 

  849.                     lastCE->nextClosedElem = newCE;
    850. 

  850.                   lastCE = newCE;
    851. 

  851.                 }
    852. 

  852.             }
    853. 

  853.         }
    854. 

  854.       while (EquivEndingElem[line][ptr] != EOS);
    855. 

  855. 

  856.       /* one line has been read */
    857. 

  857.       curCE = firstCE;
    858. 

  858.       while (curCE != NULL)
    859. 

  859.         {
    860. 

  860.           if (curCE->nextClosedElem == NULL)
    861. 

  861.             newCE = firstCE;
    862. 

  862.           else
    863. 

  863.             newCE = copyCEstring (firstCE);
    864. 

  864.           if (FirstClosedElem[curCE->tagNum] == NULL)
    865. 

  865.             FirstClosedElem[curCE->tagNum] = newCE;
    866. 

  866.           else
    867. 

  867.             {
    868. 

  868.               lastCE = FirstClosedElem[curCE->tagNum];
    869. 

  869.               while (lastCE->nextClosedElem != NULL)
    870. 

  870.                 lastCE = lastCE->nextClosedElem;
    871. 

  871.               lastCE->nextClosedElem = newCE;
    872. 

  872.             }
    873. 

  873.           curCE = curCE->nextClosedElem;
    874. 

  874.         }
    875. 

  875. 

  876.       line++;
    877. 

  877.     }
    878. 

  878.   while (strcmp (EquivEndingElem[line], "") != 0);
    879. 

  879. 

  880.   /* read table StartTagEndingElem */
    881. 

  881.   line = 0;
    882. 

  882.   do
    883. 

  883.     /* read one line of StartTagEndingElem */
    884. 

  884.     {
    885. 

  885.       ptr = 0;
    886. 

  886.       i = 0;
    887. 

  887.       /* read the first tag name of the line */
    888. 

  888.       while (StartTagEndingElem[line][ptr] != SPACE &&
    889. 

  889.              StartTagEndingElem[line][ptr] != EOS)
    890. 

  890.         name[i++] = StartTagEndingElem[line][ptr++];
    891. 

  891.       name[i] = EOS;
    892. 

  892.       i = 0;
    893. 

  893.       ptr++;
    894. 

  894.       schema = DocumentSSchema;
    895. 

  895.       entry = MapGI ((char *)name, &schema, HTMLcontext.doc);
    896. 

  896. #ifdef DEBUG
    897. 

  897.       if (entry < 0)
    898. 

  898.         fprintf (stderr, "error in StartTagEndingElem: tag %s unknown in line\n%s\n", name, StartTagEndingElem[line]);
    899. 

  899. #endif
    900. 

  900.       /* read the keyword "closes" */
    901. 

  901.       while (StartTagEndingElem[line][ptr] != SPACE &&
    902. 

  902.              StartTagEndingElem[line][ptr] != EOS)
    903. 

  903.         name[i++] = StartTagEndingElem[line][ptr++];
    904. 

  904.       name[i] = EOS;
    905. 

  905.       i = 0;
    906. 

  906.       ptr++;
    907. 

  907. #ifdef DEBUG
    908. 

  908.       if (strcmp (name, "closes") != 0)
    909. 

  909.         fprintf (stderr, "error in StartTagEndingElem: \"%s\" instead of \"closes\" in line\n%s\n", name, StartTagEndingElem[line]);
    910. 

  910. #endif
    911. 

  911.       lastCE = FirstClosedElem[entry];
    912. 

  912.       if (lastCE != NULL)
    913. 

  913.         while (lastCE->nextClosedElem != NULL)
    914. 

  914.           lastCE = lastCE->nextClosedElem;
    915. 

  915.       do
    916. 

  916.         {
    917. 

  917.           while (StartTagEndingElem[line][ptr] != SPACE &&
    918. 

  918.                  StartTagEndingElem[line][ptr] != EOS)
    919. 

  919.             name[i++] = StartTagEndingElem[line][ptr++];
    920. 

  920.           name[i] = EOS;
    921. 

  921.           ptr++;
    922. 

  922.           if (i > 0)
    923. 

  923.             {
    924. 

  924.               i = 0;
    925. 

  925.               newCE = (PtrClosedElement) TtaGetMemory (sizeof (ClosedElement));
    926. 

  926.               newCE->nextClosedElem = NULL;
    927. 

  927.               schema = DocumentSSchema;
    928. 

  928.               newCE->tagNum = MapGI ((char *)name, &schema, HTMLcontext.doc);
    929. 

  929. #ifdef DEBUG
    930. 

  930.               if (newCE->tagNum < 0)
    931. 

  931.                 fprintf (stderr, "error in StartTagEndingElem: tag %s unknown in line\n%s\n", name, StartTagEndingElem[line]);
    932. 

  932. #endif
    933. 

  933.               if (lastCE == NULL)
    934. 

  934.                 FirstClosedElem[entry] = newCE;
    935. 

  935.               else
    936. 

  936.                 lastCE->nextClosedElem = newCE;
    937. 

  937.               lastCE = newCE;
    938. 

  938.             }
    939. 

  939.         }
    940. 

  940.       while (StartTagEndingElem[line][ptr] != EOS);
    941. 

  941.       line++;
    942. 

  942.     }
    943. 

  943.   while (strcmp (StartTagEndingElem[line], "") != 0);
    944. 

  944. }
    945. 

  945. 

  946. /*----------------------------------------------------------------------
    947. 

  947.   Within  checks if an element of type ThotType is in the stack.
    948. 

  948.   ----------------------------------------------------------------------*/
    949. 

  949. static ThotBool Within (int ThotType, SSchema ThotSSchema)
    950. 

  950. {
    951. 

  951.   ThotBool         ret;
    952. 

  952.   int              i;
    953. 

  953.   ElementType      elType;
    954. 

  954. 

  955.   ret = FALSE;
    956. 

  956.   i = StackLevel - 1;
    957. 

  957.   while (i >= 0 && !ret)
    958. 

  958.     {
    959. 

  959.       if (ElementStack[i] != NULL)
    960. 

  960.         {
    961. 

  961.           elType = TtaGetElementType (ElementStack[i]);
    962. 

  962.           if (elType.ElTypeNum == ThotType &&
    963. 

  963.               elType.ElSSchema == ThotSSchema)
    964. 

  964.             ret = TRUE;
    965. 

  965.         }
    966. 

  966.       i--;
    967. 

  967.     }
    968. 

  968.   return ret;
    969. 

  969. }
    970. 

  970. 

  971. /*----------------------------------------------------------------------
    972. 

  972.   HTMLParseError  print the error message msg on stderr.
    973. 

  973.   If lineNumber = 0, print the current line number in the source file,
    974. 

  974.   otherwise print the line number provided.
    975. 

  975.   ----------------------------------------------------------------------*/
    976. 

  976. void HTMLParseError (Document doc, const char* msg, int lineNumber)
    977. 

  977. {
    978. 

  978.   if (IgnoreErrors)
    979. 

  979.     return;
    980. 

  980. 

  981.   HTMLErrorsFound = TRUE;
    982. 

  982.   if (!ErrFile)
    983. 

  983.     if (OpenParsingErrors (doc) == FALSE)
    984. 

  984.       return;
    985. 

  985.    
    986. 

  986.   if (doc == HTMLcontext.doc)
    987. 

  987.     {
    988. 

  988.       /* the error message is related to the document being parsed */
    989. 

  989.       if (docURL != NULL)
    990. 

  990.         {
    991. 

  991.           if (!XMLErrorsFound)
    992. 

  992.             fprintf (ErrFile, "\n*** Errors/warnings in %s\n", docURL);
    993. 

  993.           TtaFreeMemory (docURL);
    994. 

  994.           docURL = NULL;
    995. 

  995.         }
    996. 

  996.       else
    997. 

  997.         {
    998. 

  998.           if (CSSErrorsFound && docURL2)
    999. 

  999.             {
    1000. 

  1000.               fprintf (ErrFile, "\n*** Errors/warnings in %s\n", docURL2);
    1001. 

  1001.               TtaFreeMemory (docURL2);
    1002. 

  1002.               docURL2 = NULL;
    1003. 

  1003.             }
    1004. 

  1004.         }
    1005. 

  1005. 

  1006.       if (lineNumber <= 0)
    1007. 

  1007.         /* print the line number and character number before the message */
    1008. 

  1008.         fprintf (ErrFile, "@   line %d, char %d: %s\n", NumberOfLinesRead,
    1009. 

  1009.                  NumberOfCharRead, msg);
    1010. 

  1010.       else
    1011. 

  1011.         fprintf (ErrFile, "@   line %d, char 0: %s\n", lineNumber, msg);
    1012. 

  1012.     }
    1013. 

  1013.   else
    1014. 

  1014.     /* print only the error message */
    1015. 

  1015.     fprintf (ErrFile, "%s\n", msg);
    1016. 

  1016. }
    1017. 

  1017. 

  1018. /*----------------------------------------------------------------------
    1019. 

  1019.   CloseBuffer     close the input buffer.
    1020. 

  1020.   ----------------------------------------------------------------------*/
    1021. 

  1021. static void CloseBuffer ()
    1022. 

  1022. {
    1023. 

  1023.   inputBuffer[LgBuffer] = EOS;
    1024. 

  1024. }
    1025. 

  1025. 

  1026. /*----------------------------------------------------------------------
    1027. 

  1027.   InitBuffer      initialize the input buffer.
    1028. 

  1028.   ----------------------------------------------------------------------*/
    1029. 

  1029. static void InitBuffer ()
    1030. 

  1030. {
    1031. 

  1031.   LgBuffer = 0;
    1032. 

  1032. }
    1033. 

  1033. 

  1034. static ThotBool InsertElement (Element * el);
    1035. 

  1035. 

  1036. /*----------------------------------------------------------------------
    1037. 

  1037.   InsertSibling   return TRUE if the new element must be inserted
    1038. 

  1038.   in the Thot document as a sibling of lastElement;
    1039. 

  1039.   return FALSE it it must be inserted as a child.
    1040. 

  1040.   ----------------------------------------------------------------------*/
    1041. 

  1041. static ThotBool InsertSibling ()
    1042. 

  1042. {
    1043. 

  1043.   if (StackLevel == 0)
    1044. 

  1044.     return FALSE;
    1045. 

  1045.   else if (HTMLcontext.lastElementClosed ||
    1046. 

  1046.            TtaIsLeaf (TtaGetElementType (HTMLcontext.lastElement)) ||
    1047. 

  1047.            (GINumberStack[StackLevel - 1] >= 0 &&
    1048. 

  1048.             pHTMLGIMapping[GINumberStack[StackLevel - 1]].XMLcontents == 'E'))
    1049. 

  1049.     return TRUE;
    1050. 

  1050.   else
    1051. 

  1051.     return FALSE;
    1052. 

  1052. }
    1053. 

  1053. 

  1054. /*----------------------------------------------------------------------
    1055. 

  1055.   IsEmptyElement return TRUE if element el is defined as an empty element.
    1056. 

  1056.   ----------------------------------------------------------------------*/
    1057. 

  1057. static ThotBool IsEmptyElement (Element el)
    1058. 

  1058. {
    1059. 

  1059.   ElementType         elType;
    1060. 

  1060.   int                 i;
    1061. 

  1061.   ThotBool            ret;
    1062. 

  1062. 

  1063.   ret = FALSE;
    1064. 

  1064.   elType = TtaGetElementType (el);
    1065. 

  1065.   if (strcmp (TtaGetSSchemaName (elType.ElSSchema), "HTML") != 0)
    1066. 

  1066.     return ret;
    1067. 

  1067.   i = 0;
    1068. 

  1068.   while (EmptyElement[i] > 0 && EmptyElement[i] != elType.ElTypeNum)
    1069. 

  1069.     i++;
    1070. 

  1070.   if (EmptyElement[i] == elType.ElTypeNum)
    1071. 

  1071.     ret = TRUE;
    1072. 

  1072.   return ret;
    1073. 

  1073. }
    1074. 

  1074. 

  1075. /*----------------------------------------------------------------------
    1076. 

  1076.   IsCharacterLevelType return TRUE if element type is a
    1077. 

  1077.   character level element, FALSE if not.
    1078. 

  1078.   ----------------------------------------------------------------------*/
    1079. 

  1079. ThotBool IsCharacterLevelType (ElementType elType)
    1080. 

  1080. {
    1081. 

  1081.   int              i;
    1082. 

  1082.   ThotBool         ret;
    1083. 

  1083. 

  1084.   ret = FALSE;
    1085. 

  1085.   if (strcmp (TtaGetSSchemaName (elType.ElSSchema), "HTML") != 0)
    1086. 

  1086.     return ret;
    1087. 

  1087.   i = 0;
    1088. 

  1088.   while (CharLevelElement[i] > 0 &&
    1089. 

  1089.          CharLevelElement[i] != elType.ElTypeNum)
    1090. 

  1090.     i++;
    1091. 

  1091.   if (CharLevelElement[i] == elType.ElTypeNum)
    1092. 

  1092.     ret = TRUE;
    1093. 

  1093.   return ret;
    1094. 

  1094. }
    1095. 

  1095. 

  1096. /*----------------------------------------------------------------------
    1097. 

  1097.   IsCharacterLevelElement return TRUE if element el is a
    1098. 

  1098.   character level element, FALSE if not.
    1099. 

  1099.   ----------------------------------------------------------------------*/
    1100. 

  1100. ThotBool IsCharacterLevelElement (Element el)
    1101. 

  1101. {
    1102. 

  1102.   ElementType      elType;
    1103. 

  1103. 

  1104.   elType = TtaGetElementType (el);
    1105. 

  1105.   return IsCharacterLevelType (elType);
    1106. 

  1106. }
    1107. 

  1107. 

  1108. /*----------------------------------------------------------------------
    1109. 

  1109.   IsBlockElementType  return TRUE if element type is a block element.
    1110. 

  1110.   Same as IsBlockElement but just with the element type.
    1111. 

  1111.   ----------------------------------------------------------------------*/
    1112. 

  1112. ThotBool IsBlockElementType (ElementType elType)
    1113. 

  1113. {
    1114. 

  1114.   int           i;
    1115. 

  1115.   ThotBool      ret;
    1116. 

  1116. 

  1117.   ret = FALSE;
    1118. 

  1118.   if (strcmp (TtaGetSSchemaName (elType.ElSSchema), "HTML") != 0)
    1119. 

  1119.     return ret;
    1120. 

  1120.   i = 0;
    1121. 

  1121.   while (BlockLevelElement[i] > 0 &&
    1122. 

  1122.          BlockLevelElement[i] != elType.ElTypeNum)
    1123. 

  1123.     i++;
    1124. 

  1124.   if (BlockLevelElement[i] == elType.ElTypeNum)
    1125. 

  1125.     ret = TRUE;
    1126. 

  1126.   return ret;
    1127. 

  1127. }
    1128. 

  1128. 

  1129. /*----------------------------------------------------------------------
    1130. 

  1130.   IsBlockElement  return TRUE if element el is a block element.
    1131. 

  1131.   ----------------------------------------------------------------------*/
    1132. 

  1132. ThotBool IsBlockElement (Element el)
    1133. 

  1133. {
    1134. 

  1134.   ElementType   elType;
    1135. 

  1135. 

  1136.   elType = TtaGetElementType (el);
    1137. 

  1137.   return IsBlockElementType (elType);
    1138. 

  1138. }
    1139. 

  1139. 

  1140.  
    1141. 

  1141. /*----------------------------------------------------------------------
    1142. 

  1142.   TextToDocument  Put the content of input buffer in the document.
    1143. 

  1143.   ----------------------------------------------------------------------*/
    1144. 

  1144. static void TextToDocument ()
    1145. 

  1145. {
    1146. 

  1146.   ElementType      elType;
    1147. 

  1147.   Element          elText, parent;
    1148. 

  1148.   int              i;
    1149. 

  1149.   ThotBool         ignoreLeadingSpaces;
    1150. 

  1150.   ThotBool         insSibling, ok;
    1151. 

  1151. 

  1152.   CloseBuffer ();
    1153. 

  1153.   if (HTMLcontext.lastElement)
    1154. 

  1154.     {
    1155. 

  1155.       i = 0;
    1156. 

  1156.       insSibling = InsertSibling ();
    1157. 

  1157.       ignoreLeadingSpaces = IsLeadingSpaceUseless (HTMLcontext.lastElement,
    1158. 

  1158.                                                    HTMLcontext.doc, insSibling, FALSE);
    1159. 

  1159.       if (ignoreLeadingSpaces &&
    1160. 

  1160.           !Within (HTML_EL_Preformatted, DocumentSSchema) &&
    1161. 

  1161.           !Within (HTML_EL_STYLE_, DocumentSSchema) &&
    1162. 

  1162.           !Within (HTML_EL_SCRIPT_, DocumentSSchema))
    1163. 

  1163.         /* suppress leading spaces */
    1164. 

  1164.         while (inputBuffer[i] <= SPACE && inputBuffer[i] != EOS)
    1165. 

  1165.           i++;
    1166. 

  1166.       if (inputBuffer[i] != EOS)
    1167. 

  1167.         {
    1168. 

  1168.           elType = TtaGetElementType (HTMLcontext.lastElement);
    1169. 

  1169.           if (elType.ElTypeNum == HTML_EL_TEXT_UNIT && HTMLcontext.mergeText)
    1170. 

  1170.             TtaAppendTextContent (HTMLcontext.lastElement, (unsigned char *)&(inputBuffer[i]),
    1171. 

  1171.                                   HTMLcontext.doc);
    1172. 

  1172.           else
    1173. 

  1173.             {
    1174. 

  1174.               if (inputBuffer[i] == SPACE && LgBuffer == 1)
    1175. 

  1175.                 {
    1176. 

  1176.                   // avoid to generate an empty pseudo paragraph
    1177. 

  1177.                   ok = FALSE;
    1178. 

  1178.                   if (InsertSibling ())
    1179. 

  1179.                     parent = TtaGetParent (HTMLcontext.lastElement);
    1180. 

  1180.                   else
    1181. 

  1181.                     parent = HTMLcontext.lastElement;
    1182. 

  1182.                   if (parent)
    1183. 

  1183.                     {
    1184. 

  1184.                       elType = TtaGetElementType (parent);
    1185. 

  1185.                       if (IsCharacterLevelElement (parent) ||
    1186. 

  1186.                           !XhtmlCannotContainText (elType))
    1187. 

  1187.                         ok = TRUE; // generate the TEXT element
    1188. 

  1188.                     }
    1189. 

  1189.                 }
    1190. 

  1190.               else
    1191. 

  1191.                 ok = TRUE;
    1192. 

  1192.               if (ok)
    1193. 

  1193.                 {
    1194. 

  1194.                   /* create a TEXT element */
    1195. 

  1195.                   elType.ElSSchema = DocumentSSchema;
    1196. 

  1196.                   elType.ElTypeNum = HTML_EL_TEXT_UNIT;
    1197. 

  1197.                   elText = TtaNewElement (HTMLcontext.doc, elType);
    1198. 

  1198.                   TtaSetElementLineNumber (elText, BufferLineNumber);
    1199. 

  1199.                   InsertElement (&elText);
    1200. 

  1200.                   HTMLcontext.lastElementClosed = TRUE;
    1201. 

  1201.                   HTMLcontext.mergeText = TRUE;
    1202. 

  1202.                   /* put the content of the input buffer into the TEXT element */
    1203. 

  1203.                   if (elText)
    1204. 

  1204.                     TtaSetTextContent (elText, (unsigned char *)&(inputBuffer[i]),
    1205. 

  1205.                                        HTMLcontext.language, HTMLcontext.doc);
    1206. 

  1206.                 }
    1207. 

  1207.             }
    1208. 

  1208.         }
    1209. 

  1209.     }
    1210. 

  1210.   InitBuffer ();
    1211. 

  1211. }
    1212. 

  1212. 

  1213. 

  1214. /*----------------------------------------------------------------------
    1215. 

  1215.   StartOfTag      Beginning of a HTML tag (start or end tag).
    1216. 

  1216.   Put the preceding text into the Thot document.
    1217. 

  1217.   ----------------------------------------------------------------------*/
    1218. 

  1218. static void StartOfTag (char c)
    1219. 

  1219. {
    1220. 

  1220.   if (LgBuffer > 0)
    1221. 

  1221.     TextToDocument ();
    1222. 

  1222.   HTMLcontext.mergeText = FALSE;
    1223. 

  1223.   StartOfT…
    1224.

Large files files are truncated, but you can click here to view the full file