PageRenderTime 51ms CodeModel.GetById 17ms RepoModel.GetById 0ms app.codeStats 1ms

/amaya/html2thot.c

https://github.com/pffy/Amaya-Editor
C | 7618 lines | 6067 code | 333 blank | 1218 comment | 1612 complexity | 29dab6b5f25c8433321a1eb755e2bd6a MD5 | raw 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.   StartOfTagIndx = CurrentBufChar - 1;
    1224. 

  1224.   PreviousNumberOfCharRead = NumberOfCharRead - 1;
    1225. 

  1225.   /* Is there an EOL or CR character inside tag ?? */
    1226. 

  1226.   PreviousNumberOfLinesRead = NumberOfLinesRead;
    1227. 

  1227. 

  1228. }
    1229. 

  1229. 

  1230. /*----------------------------------------------------------------------
    1231. 

  1231.   PutInBuffer     put character c in the input buffer.
    1232. 

  1232.   ----------------------------------------------------------------------*/
    1233. 

  1233. static void PutInBuffer (unsigned char c)
    1234. 

  1234. {
    1235. 

  1235.   int               len;
    1236. 

  1236. 

  1237.   /* put the character into the buffer if it is not an ignored char. */
    1238. 

  1238.   if ((int) c == TAB)		/* HT */
    1239. 

  1239.     len = 8;			/* HT = 8 spaces */
    1240. 

  1240.   else
    1241. 

  1241.     len = 1;
    1242. 

  1242.   if (c != EOS)
    1243. 

  1243.     {
    1244. 

  1244.       if (LgBuffer + len >= AllmostFullBuffer &&
    1245. 

  1245.           // simplete text or cdata
    1246. 

  1246.           (currentState == 0 || currentState == 24))
    1247. 

  1247.         TextToDocument ();
    1248. 

  1248.       if (LgBuffer + len >= MaxBufferLength)
    1249. 

  1249.         {
    1250. 

  1250.           if (currentState == 0)
    1251. 

  1251.             TextToDocument ();
    1252. 

  1252.           else if (currentState == 6)
    1253. 

  1253.             {
    1254. 

  1254.               TruncatedAttrValue = TRUE;
    1255. 

  1255.               EndOfAttrValue (c);
    1256. 

  1256.               TruncatedAttrValue = FALSE;
    1257. 

  1257.             }
    1258. 

  1258.           else
    1259. 

  1259.             HTMLParseError (HTMLcontext.doc, "Buffer overflow", 0);
    1260. 

  1260.           LgBuffer = 0;
    1261. 

  1261.         }
    1262. 

  1262. 

  1263.       if (LgBuffer == 0)
    1264. 

  1264.         BufferLineNumber = NumberOfLinesRead;
    1265. 

  1265. 

  1266.       if (len == 1)
    1267. 

  1267.         inputBuffer[LgBuffer++] = c;
    1268. 

  1268.       else
    1269. 

  1269.         /* HT */
    1270. 

  1270.         do
    1271. 

  1271.           {
    1272. 

  1272.             inputBuffer[LgBuffer++] = SPACE;
    1273. 

  1273.             len--;
    1274. 

  1274.           }
    1275. 

  1275.         while (len > 0);
    1276. 

  1276.     }
    1277. 

  1277. }
    1278. 

  1278. 

  1279. 

  1280. /*----------------------------------------------------------------------
    1281. 

  1281.   BlockInCharLevelElem
    1282. 

  1282.   Element el is a block-level element. If its parent is a character-level
    1283. 

  1283.   element, add a record in the list of block-level elements to be
    1284. 

  1284.   checked when the document is complete.
    1285. 

  1285.   ----------------------------------------------------------------------*/
    1286. 

  1286. void BlockInCharLevelElem (Element el)
    1287. 

  1287. {
    1288. 

  1288.   PtrElemToBeChecked  nextElTBC, elTBC;
    1289. 

  1289.   Element             parent;
    1290. 

  1290.   ElementType         elType, parentType;
    1291. 

  1291. 

  1292.   parent = TtaGetParent (el);
    1293. 

  1293.   elType = TtaGetElementType (el);
    1294. 

  1294.   /* a <div> within a <button> is allowed */
    1295. 

  1295.   if (elType.ElTypeNum == HTML_EL_Division)
    1296. 

  1296.     {
    1297. 

  1297.       parentType = TtaGetElementType (parent);
    1298. 

  1298.       if (parentType.ElTypeNum == HTML_EL_BUTTON_)
    1299. 

  1299. 	return;
    1300. 

  1300.     }
    1301. 

  1301.   if (LastElemToBeChecked != NULL)
    1302. 

  1302.     {
    1303. 

  1303.       nextElTBC = FirstElemToBeChecked;
    1304. 

  1304.       while (nextElTBC != NULL)
    1305. 

  1305.         {
    1306. 

  1306.           if (nextElTBC->Elem == el)
    1307. 

  1307.             /* this element is already in the queue */
    1308. 

  1308.             return;
    1309. 

  1309.           else
    1310. 

  1310.             nextElTBC = nextElTBC->nextElemToBeChecked;
    1311. 

  1311.         }
    1312. 

  1312.     }   
    1313. 

  1313.   if (parent != NULL)
    1314. 

  1314.     if (IsCharacterLevelElement (parent))
    1315. 

  1315.       {
    1316. 

  1316.         elTBC = (PtrElemToBeChecked) TtaGetMemory(sizeof(ElemToBeChecked));
    1317. 

  1317.         elTBC->Elem = el;
    1318. 

  1318.         elTBC->nextElemToBeChecked = NULL;
    1319. 

  1319.         if (LastElemToBeChecked == NULL)
    1320. 

  1320.           FirstElemToBeChecked = elTBC;
    1321. 

  1321.         else
    1322. 

  1322.           LastElemToBeChecked->nextElemToBeChecked = elTBC;
    1323. 

  1323.         LastElemToBeChecked = elTBC;
    1324. 

  1324.       }
    1325. 

  1325. }
    1326. 

  1326. 

  1327. /*----------------------------------------------------------------------
    1328. 

  1328.   CheckSurrounding
    1329. 

    1330. 

  1330.   inserts an element Pseudo_paragraph in the abstract tree of the Thot
    1331. 

  1331.   document if el is a leaf and is not allowed to be a child of element parent.
    1332. 

  1332.   Return TRUE if element *el has been inserted in the tree.
    1333. 

  1333.   ----------------------------------------------------------------------*/
    1334. 

  1334. static ThotBool CheckSurrounding (Element * el, Element parent)
    1335. 

  1335. {
    1336. 

  1336.   ElementType      parentType, newElType, elType, ancestorType;
    1337. 

  1337.   Element          newEl, ancestor, prev, prevprev;
    1338. 

  1338.   ThotBool         ret;
    1339. 

  1339. 

  1340.   if (parent == NULL)
    1341. 

  1341.     return(FALSE);
    1342. 

  1342.   ret = FALSE;
    1343. 

  1343.   elType = TtaGetElementType (*el);
    1344. 

  1344.   if (elType.ElTypeNum == HTML_EL_TEXT_UNIT || elType.ElTypeNum == HTML_EL_BR
    1345. 

  1345.       || elType.ElTypeNum == HTML_EL_PICTURE_UNIT
    1346. 

  1346.       || elType.ElTypeNum == HTML_EL_IFRAME
    1347. 

  1347.       || elType.ElTypeNum == HTML_EL_IMG
    1348. 

  1348.       || elType.ElTypeNum == HTML_EL_Input
    1349. 

  1349.       || elType.ElTypeNum == HTML_EL_Text_Area
    1350. 

  1350.       || IsCharacterLevelElement (*el))
    1351. 

  1351.     {
    1352. 

  1352.       /* the element to be inserted is a character string */
    1353. 

  1353.       /* Search the ancestor that is not a character level element */
    1354. 

  1354.       ancestor = parent;
    1355. 

  1355.       while (ancestor != NULL && 
    1356. 

  1356.              (IsCharacterLevelElement (ancestor) ||
    1357. 

  1357.               !strcmp (TtaGetSSchemaName (TtaGetElementType(ancestor).ElSSchema), "Template")))
    1358. 

  1358.         ancestor = TtaGetParent (ancestor);
    1359. 

  1359.       if (ancestor != NULL)
    1360. 

  1360.         {
    1361. 

  1361.           ancestorType = TtaGetElementType (ancestor);
    1362. 

  1362.           if (XhtmlCannotContainText (ancestorType) &&
    1363. 

  1363.               !Within (HTML_EL_Option_Menu, DocumentSSchema))
    1364. 

  1364.             /* Element ancestor cannot contain text directly. Create a */
    1365. 

  1365.             /* Pseudo_paragraph element as the parent of the text element */
    1366. 

  1366.             {
    1367. 

  1367.               newElType.ElSSchema = DocumentSSchema;
    1368. 

  1368.               newElType.ElTypeNum = HTML_EL_Pseudo_paragraph;
    1369. 

  1369.               newEl = TtaNewElement (HTMLcontext.doc, newElType);
    1370. 

  1370.               TtaSetElementLineNumber (newEl, NumberOfLinesRead);
    1371. 

  1371.               /* insert the new Pseudo_paragraph element */
    1372. 

  1372.               InsertElement (&newEl);
    1373. 

  1373.               if (newEl != NULL)
    1374. 

  1374.                 {
    1375. 

  1375.                   /* insert the Text element in the tree */
    1376. 

  1376.                   TtaInsertFirstChild (el, newEl, HTMLcontext.doc);
    1377. 

  1377.                   BlockInCharLevelElem (newEl);
    1378. 

  1378.                   ret = TRUE;
    1379. 

  1379. 

  1380.                   /* if previous siblings of the new Pseudo_paragraph element
    1381. 

  1381.                      are character level elements, move them within the new
    1382. 

  1382.                      Pseudo_paragraph element */
    1383. 

  1383.                   prev = newEl;
    1384. 

  1384.                   TtaPreviousSibling (&prev);
    1385. 

  1385.                   while (prev != NULL)
    1386. 

  1386.                     {
    1387. 

  1387.                       if (!IsCharacterLevelElement (prev))
    1388. 

  1388.                         prev = NULL;
    1389. 

  1389.                       else
    1390. 

  1390.                         {
    1391. 

  1391.                           prevprev = prev;  TtaPreviousSibling (&prevprev);
    1392. 

  1392.                           TtaRemoveTree (prev, HTMLcontext.doc);
    1393. 

  1393.                           TtaInsertFirstChild (&prev, newEl, HTMLcontext.doc);
    1394. 

  1394.                           prev = prevprev;
    1395. 

  1395.                         }
    1396. 

  1396.                     }
    1397. 

  1397.                 }
    1398. 

  1398.      	      }
    1399. 

  1399.         }
    1400. 

  1400.     }
    1401. 

  1401.   if (elType.ElTypeNum == HTML_EL_TEXT_UNIT ||
    1402. 

  1402.       (elType.ElTypeNum != HTML_EL_Inserted_Text &&
    1403. 

  1403.        IsCharacterLevelElement (*el)))
    1404. 

  1404.     /* it is a character level element */
    1405. 

  1405.     {
    1406. 

  1406.       parentType = TtaGetElementType (parent);
    1407. 

  1407.       if (parentType.ElTypeNum == HTML_EL_Text_Area)
    1408. 

  1408.         /* A basic element cannot be a child of a Text_Area */
    1409. 

  1409.         /* create a Inserted_Text element as a child of Text_Area */
    1410. 

  1410.         {
    1411. 

  1411.           newElType.ElSSchema = DocumentSSchema;
    1412. 

  1412.           newElType.ElTypeNum = HTML_EL_Inserted_Text;
    1413. 

  1413.           newEl = TtaNewElement (HTMLcontext.doc, newElType);
    1414. 

  1414.           TtaSetElementLineNumber (newEl, NumberOfLinesRead);
    1415. 

  1415.           InsertElement (&newEl);
    1416. 

  1416.           if (newEl != NULL)
    1417. 

  1417.             {
    1418. 

  1418.               TtaInsertFirstChild (el, newEl, HTMLcontext.doc);
    1419. 

  1419.               ret = TRUE;
    1420. 

  1420.             }
    1421. 

  1421.         }
    1422. 

  1422.     }
    1423. 

  1423.   return ret;
    1424. 

  1424. }
    1425. 

  1425. 

  1426. 

  1427. /*----------------------------------------------------------------------
    1428. 

  1428.   InsertElement   inserts element el in the abstract tree of the
    1429. 

  1429.   Thot document, at the current position.
    1430. 

  1430.   ----------------------------------------------------------------------*/
    1431. 

  1431. static ThotBool InsertElement (Element *el)
    1432. 

  1432. {
    1433. 

  1433.   ThotBool         ret;
    1434. 

  1434.   Element          parent;
    1435. 

  1435. 

  1436.   if (InsertSibling ())
    1437. 

  1437.     {
    1438. 

  1438.       if (HTMLcontext.lastElement == NULL)
    1439. 

  1439.         parent = NULL;
    1440. 

  1440.       else
    1441. 

  1441.         parent = TtaGetParent (HTMLcontext.lastElement);
    1442. 

  1442.       if (!CheckSurrounding (el, parent))
    1443. 

  1443.         {
    1444. 

  1444.           if (parent != NULL)
    1445. 

  1445.             TtaInsertSibling (*el, HTMLcontext.lastElement, FALSE, HTMLcontext.doc);
    1446. 

  1446.           else
    1447. 

  1447.             {
    1448. 

  1448.               TtaDeleteTree (*el, HTMLcontext.doc);
    1449. 

  1449.               *el = NULL;
    1450. 

  1450.             }
    1451. 

  1451.         }
    1452. 

  1452.       ret = TRUE;
    1453. 

  1453.     }
    1454. 

  1454.   else
    1455. 

  1455.     {
    1456. 

  1456.       if (!CheckSurrounding (el, HTMLcontext.lastElement))
    1457. 

  1457.         TtaInsertFirstChild (el, HTMLcontext.lastElement, HTMLcontext.doc);
    1458. 

  1458.       ret = FALSE;
    1459. 

  1459.     }
    1460. 

  1460.   if (*el != NULL)
    1461. 

  1461.     {
    1462. 

  1462.       HTMLcontext.lastElement = *el;
    1463. 

  1463.       HTMLcontext.lastElementClosed = FALSE;
    1464. 

  1464.     }
    1465. 

  1465.   return ret;
    1466. 

  1466. }
    1467. 

  1467. 

  1468. /*----------------------------------------------------------------------
    1469. 

  1469.   ProcessOptionElement
    1470. 

  1470.   If multiple is FALSE, remove the SELECTED attribute from the
    1471. 

  1471.   option element, except if it's element el.
    1472. 

  1472.   If parsing is TRUE, associate a DefaultSelected attribute with
    1473. 

  1473.   element option if it has a SELECTED attribute.
    1474. 

  1474.   ----------------------------------------------------------------------*/
    1475. 

  1475. static void ProcessOptionElement (Element option, Element el,
    1476. 

  1476.                                   Document doc, ThotBool multiple,
    1477. 

  1477.                                   ThotBool parsing)
    1478. 

  1478. {
    1479. 

  1479.   ElementType	   elType;
    1480. 

  1480.   AttributeType   attrType;
    1481. 

  1481.   Attribute	   attr;
    1482. 

  1482. 

  1483.   elType = TtaGetElementType (option);
    1484. 

  1484.   attrType.AttrSSchema = elType.ElSSchema;
    1485. 

  1485.   attrType.AttrTypeNum = HTML_ATTR_Selected;
    1486. 

  1486.   if (!multiple && option != el)
    1487. 

  1487.     {
    1488. 

  1488.       /* Search the SELECTED attribute */
    1489. 

  1489.       attr = TtaGetAttribute (option, attrType);
    1490. 

  1490.       /* remove it if it exists */
    1491. 

  1491.       if (attr)
    1492. 

  1492.         TtaRemoveAttribute (option, attr, doc);
    1493. 

  1493.     }
    1494. 

  1494.   if (parsing)
    1495. 

  1495.     {
    1496. 

  1496.       attr = TtaGetAttribute (option, attrType);
    1497. 

  1497.       if (attr != NULL)
    1498. 

  1498.         {
    1499. 

  1499.           attrType.AttrTypeNum = HTML_ATTR_DefaultSelected;
    1500. 

  1500.           attr = TtaGetAttribute (option, attrType);
    1501. 

  1501.           if (!attr)
    1502. 

  1502.             {
    1503. 

  1503.               /* create the DefaultSelected attribute */
    1504. 

  1504.               attr = TtaNewAttribute (attrType);
    1505. 

  1505.               TtaAttachAttribute (option, attr, doc);
    1506. 

  1506.               TtaSetAttributeValue (attr, HTML_ATTR_DefaultSelected_VAL_Yes_,
    1507. 

  1507.                                     option, doc);
    1508. 

  1508.             }
    1509. 

  1509.         }
    1510. 

  1510.     }
    1511. 

  1511. }
    1512. 

  1512. 

  1513. /*----------------------------------------------------------------------
    1514. 

  1514.   OnlyOneOptionSelected
    1515. 

  1515.   If the option menu el is a single-choice menu, check that only
    1516. 

  1516.   one option has an attribute Selected.
    1517. 

  1517.   If there is no option element with an attribute Selected, put an
    1518. 

  1518.   attribute ShowMe on the first option.
    1519. 

  1519.   If parsing is TRUE, associate an attribute DefaultSelected with
    1520. 

  1520.   each option having an attribute Selected.
    1521. 

  1521.   ----------------------------------------------------------------------*/
    1522. 

  1522. void OnlyOneOptionSelected (Element el, Document doc, ThotBool parsing)
    1523. 

  1523. {
    1524. 

  1524.   ElementType      elType, opType;
    1525. 

  1525.   Element          option, menu, child, firstOption;
    1526. 

  1526.   AttributeType    attrType, attrshowMeType;
    1527. 

  1527.   Attribute        attr, showMeAttr;
    1528. 

  1528.   ThotBool         multiple;
    1529. 

  1529. 

  1530.   if (el == NULL)
    1531. 

  1531.     return;
    1532. 

  1532. 

  1533.   menu = NULL;
    1534. 

  1534.   attr = NULL;
    1535. 

  1535.   firstOption = NULL;
    1536. 

  1536.   elType = TtaGetElementType (el);
    1537. 

  1537.   attrType.AttrSSchema = elType.ElSSchema;
    1538. 

  1538.   attrType.AttrTypeNum = HTML_ATTR_Selected;
    1539. 

  1539.   attrshowMeType.AttrSSchema = elType.ElSSchema;
    1540. 

  1540.   attrshowMeType.AttrTypeNum = HTML_ATTR_ShowMe;
    1541. 

  1541.   if (elType.ElTypeNum == HTML_EL_Option_Menu)
    1542. 

  1542.     {
    1543. 

  1543.       /* it's a menu (SELECT) */
    1544. 

  1544.       menu = el;
    1545. 

  1545.       /* search the first OPTION element having an attribute SELECTED */
    1546. 

  1546.       option = TtaGetFirstChild (el);
    1547. 

  1547.       while (option && !attr)
    1548. 

  1548.         {
    1549. 

  1549.           elType = TtaGetElementType (option);
    1550. 

  1550.           if (elType.ElTypeNum == HTML_EL_Option)
    1551. 

  1551.             {
    1552. 

  1552.               attr = TtaGetAttribute (option, attrType);
    1553. 

  1553.               if (!firstOption)
    1554. 

  1554.                 firstOption = option;
    1555. 

  1555.             }
    1556. 

  1556.           else if (elType.ElTypeNum == HTML_EL_OptGroup)
    1557. 

  1557.             {
    1558. 

  1558.               child = TtaGetFirstChild (option);
    1559. 

  1559.               while (child && !attr)
    1560. 

  1560.                 {
    1561. 

  1561.                   elType = TtaGetElementType (child);
    1562. 

  1562.                   if (elType.ElTypeNum == HTML_EL_Option)
    1563. 

  1563.                     {
    1564. 

  1564.                       attr = TtaGetAttribute (child, attrType);
    1565. 

  1565.                       if (!firstOption)
    1566. 

  1566.                         firstOption = child;
    1567. 

  1567.                     }
    1568. 

  1568.                   if (attr)
    1569. 

  1569.                     option = child;
    1570. 

  1570.                   else
    1571. 

  1571.                     TtaNextSibling (&child);
    1572. 

  1572.                 }
    1573. 

  1573.             }
    1574. 

  1574.           if (!attr)
    1575. 

  1575.             TtaNextSibling (&option);
    1576. 

  1576.         }
    1577. 

  1577.       el = option;
    1578. 

  1578.     }
    1579. 

  1579.   else
    1580. 

  1580.     {
    1581. 

  1581.       option = NULL;
    1582. 

  1582.       do
    1583. 

  1583.         {
    1584. 

  1584.           if (elType.ElTypeNum == HTML_EL_Option_Menu)
    1585. 

  1585.             menu = el;
    1586. 

  1586.           else
    1587. 

  1587.             {
    1588. 

  1588.               if (elType.ElTypeNum == HTML_EL_Option)
    1589. 

  1589.                 option = el;
    1590. 

  1590.               el = TtaGetParent (el);
    1591. 

  1591.               if (el)
    1592. 

  1592.                 elType = TtaGetElementType (el);
    1593. 

  1593.             }
    1594. 

  1594.         }
    1595. 

  1595.       while (el && !menu);
    1596. 

  1596.       el = option;
    1597. 

  1597.     }
    1598. 

  1598. 

  1599.   if (el)
    1600. 

  1600.     {
    1601. 

  1601.       if (menu)
    1602. 

  1602.         {
    1603. 

  1603.           /* Remove the SELECTED attribute from other options in the menu */
    1604. 

  1604.           /* if it's not a multiple-choices menu. */
    1605. 

  1605.           /* When parsing the HTML file, associate a DefaultSelected */
    1606. 

  1606.           /* attribute with each element having a SELECTED attribute */
    1607. 

  1607.           attrType.AttrTypeNum = HTML_ATTR_Multiple;
    1608. 

  1608.           multiple = (TtaGetAttribute (menu, attrType) != NULL);
    1609. 

  1609.           if (parsing || !multiple)
    1610. 

  1610.             {
    1611. 

  1611.               option = TtaGetFirstChild (menu);
    1612. 

  1612.               opType = TtaGetElementType (menu);
    1613. 

  1613.               opType.ElTypeNum = HTML_EL_Option;
    1614. 

  1614.               while (option)
    1615. 

  1615.                 {
    1616. 

  1616.                   elType = TtaGetElementType (option);
    1617. 

  1617.                   if (elType.ElTypeNum == HTML_EL_Option)
    1618. 

  1618.                     {
    1619. 

  1619.                       ProcessOptionElement (option, el, doc, multiple,
    1620. 

  1620.                                             parsing);
    1621. 

  1621.                       if (!firstOption)
    1622. 

  1622.                         firstOption = option;
    1623. 

  1623.                     }
    1624. 

  1624.                   else 
    1625. 

  1625.                     {
    1626. 

  1626.                       child = TtaSearchTypedElement (opType, SearchInTree, option);
    1627. 

  1627.                       while (child)
    1628. 

  1628.                         {
    1629. 

  1629.                           ProcessOptionElement (child, el, doc, multiple, parsing);
    1630. 

  1630.                           if (!firstOption)
    1631. 

  1631.                             firstOption = option;
    1632. 

  1632.                           // look for the next option
    1633. 

  1633.                           child = TtaSearchTypedElementInTree (opType, SearchForward, option, child);
    1634. 

  1634.                         }
    1635. 

  1635.                     }
    1636. 

  1636.                   TtaNextSibling (&option);
    1637. 

  1637.                 }
    1638. 

  1638.             }
    1639. 

  1639.         }
    1640. 

  1640. 

  1641.       /* set this option SELECTED */
    1642. 

  1642.       attrType.AttrTypeNum = HTML_ATTR_Selected;
    1643. 

  1643.       attr = TtaGetAttribute (el, attrType);
    1644. 

  1644.       if (attr == NULL)
    1645. 

  1645.         {
    1646. 

  1646.           /* create the SELECTED attribute */
    1647. 

  1647.           attr = TtaNewAttribute (attrType);
    1648. 

  1648.           TtaSetAttributeValue (attr, HTML_ATTR_Selected_VAL_Yes_, el,doc);
    1649. 

  1649.           TtaAttachAttribute (el, attr, doc);
    1650. 

  1650.         }
    1651. 

  1651.     }
    1652. 

  1652. 

  1653.   if (firstOption)
    1654. 

  1654.     {
    1655. 

  1655.       showMeAttr = TtaGetAttribute (firstOption, attrshowMeType);
    1656. 

  1656.       if (attr)
    1657. 

  1657.         /* there is at least one option element with a selected attribute.
    1658. 

  1658.            Remove the ShowMe attribute from the first option element */
    1659. 

  1659.         {
    1660. 

  1660.           if (showMeAttr)
    1661. 

  1661.             TtaRemoveAttribute (firstOption, showMeAttr, doc);
    1662. 

  1662.         }
    1663. 

  1663.       else
    1664. 

  1664.         /* there is no option element with a selected attribute. Put
    1665. 

  1665.            an attribute ShowMe on the first option element to display it
    1666. 

  1666.            in the main view */
    1667. 

  1667.         {
    1668. 

  1668.           if (!showMeAttr)
    1669. 

  1669.             {
    1670. 

  1670.               showMeAttr = TtaNewAttribute (attrType);
    1671. 

  1671.               TtaSetAttributeValue (showMeAttr, HTML_ATTR_ShowMe_VAL_Yes_,
    1672. 

  1672.                                     firstOption, doc);
    1673. 

  1673.               TtaAttachAttribute (firstOption, showMeAttr, doc);
    1674. 

  1674.             }
    1675. 

  1675.         }
    1676. 

  1676.     }
    1677. 

  1677. }
    1678. 

  1678. 

  1679. /*----------------------------------------------------------------------
    1680. 

  1680.   LastLeafInElement
    1681. 

  1681.   return the last leaf element in element el.
    1682. 

  1682.   ----------------------------------------------------------------------*/
    1683. 

  1683. static Element LastLeafInElement (Element el)
    1684. 

  1684. {
    1685. 

  1685.   Element          child, lastLeaf;
    1686. 

  1686. 

  1687.   child = el;
    1688. 

  1688.   lastLeaf = NULL;
    1689. 

  1689.   while (child != NULL)
    1690. 

  1690.     {
    1691. 

  1691.       child = TtaGetLastChild (child);
    1692. 

  1692.       if (child != NULL)
    1693. 

  1693.         lastLeaf = child;
    1694. 

  1694.     }
    1695. 

  1695.   return lastLeaf;
    1696. 

  1696. }
    1697. 

  1697. 

  1698. /*----------------------------------------------------------------------
    1699. 

  1699.   CheckIconLink
    1700. 

  1700.   The element is a HTML link.
    1701. 

  1701.   Check element attributes and load the style sheet if needed.
    1702. 

  1702.   ----------------------------------------------------------------------*/
    1703. 

  1703. void CheckIconLink (Element el, Document doc, SSchema schema)
    1704. 

  1704. {
    1705. 

  1705.   Attribute           attr;
    1706. 

  1706.   AttributeType       attrType;
    1707. 

  1707.   char               *buff, *ptr;
    1708. 

  1708.   int                 length;
    1709. 

  1709. 

  1710.   /* A LINK element is complete.
    1711. 

  1711.      If it is a link to an icon, add the icon to the page
    1712. 

  1712.   */
    1713. 

  1713.   attrType.AttrSSchema = schema;
    1714. 

  1714.   attrType.AttrTypeNum = HTML_ATTR_REL;
    1715. 

  1715.   attr = TtaGetAttribute (el, attrType);
    1716. 

  1716.   if (attr)
    1717. 

  1717.     {
    1718. 

  1718.       /* get a buffer for the attribute value */
    1719. 

  1719.       length = TtaGetTextAttributeLength (attr);
    1720. 

  1720.       buff = (char*)TtaGetMemory (length + 1);
    1721. 

  1721.       TtaGiveTextAttributeValue (attr, buff, &length);
    1722. 

  1722.       ptr = strstr (buff, "icon");
    1723. 

  1723.       if (ptr == NULL)
    1724. 

  1724.         ptr = strstr (buff, "ICON");
    1725. 

  1725.       if (ptr &&
    1726. 

  1726.           DocumentMeta[doc] && DocumentMeta[doc]->method != CE_MAKEBOOK &&
    1727. 

  1727.           DocumentMeta[doc]->link_icon == NULL)
    1728. 

  1728.         DocumentMeta[doc]->link_icon = el;
    1729. 

  1729.       TtaFreeMemory (buff);
    1730. 

  1730.     }
    1731. 

  1731. }
    1732. 

  1732. 

  1733. /*----------------------------------------------------------------------
    1734. 

  1734.   CheckCSSLink
    1735. 

  1735.   The element is a HTML link.
    1736. 

  1736.   Check element attributes and load the style sheet if needed.
    1737. 

  1737.   ----------------------------------------------------------------------*/
    1738. 

  1738. void CheckCSSLink (Element el, Document doc, SSchema schema)
    1739. 

  1739. {
    1740. 

  1740.   Attribute           attr;
    1741. 

  1741.   AttributeType       attrType;
    1742. 

  1742.   CSSmedia            media;
    1743. 

  1743.   char               *utf8path, *buff;
    1744. 

  1744.   int                 length;
    1745. 

  1745. 

  1746.   /* A LINK element is complete.
    1747. 

  1747.      If it is a link to a style sheet, load that style sheet.
    1748. 

  1748.   */
    1749. 

  1749.   if (IsCSSLink (el, doc))
    1750. 

  1750.     {
    1751. 

  1751.       /* it's a link to a style sheet */
    1752. 

  1752.       /* get the media specification */
    1753. 

  1753.       attrType.AttrSSchema = schema;
    1754. 

  1754.       attrType.AttrTypeNum = HTML_ATTR_media;
    1755. 

  1755.       attr = TtaGetAttribute (el, attrType);
    1756. 

  1756.       if (attr)
    1757. 

  1757.         {
    1758. 

  1758.           length = TtaGetTextAttributeLength (attr);
    1759. 

  1759.           buff = (char*)TtaGetMemory (length + 1);
    1760. 

  1760.           TtaGiveTextAttributeValue (attr, buff, &length);
    1761. 

  1761.           media = CheckMediaCSS (buff);
    1762. 

  1762.           TtaFreeMemory (buff);
    1763. 

  1763.         }
    1764. 

  1764.       else
    1765. 

  1765.         media = CSS_ALL;
    1766. 

  1766. 

  1767.       /* Load that style sheet */
    1768. 

  1768.       attrType.AttrTypeNum = HTML_ATTR_HREF_;
    1769. 

  1769.       attr = TtaGetAttribute (el, attrType);
    1770. 

  1770.       if (attr &&
    1771. 

  1771.           DocumentMeta[doc] && 
    1772. 

  1772.           DocumentMeta[doc]->method != CE_MAKEBOOK)
    1773. 

  1773.         {
    1774. 

  1774.           length = TtaGetTextAttributeLength (attr);
    1775. 

  1775.           utf8path = (char*)TtaGetMemory (length + 1);
    1776. 

  1776.           TtaGiveTextAttributeValue (attr, utf8path, &length);
    1777. 

  1777.           /* load the stylesheet file found here ! */
    1778. 

  1778.           buff = (char *)TtaConvertMbsToByte ((unsigned char *)utf8path,
    1779. 

  1779.                                               TtaGetDefaultCharset ());
    1780. 

  1780.           if (buff)
    1781. 

  1781.             {
    1782. 

  1782.               LoadStyleSheet (buff, doc, el, NULL, NULL, media, FALSE);
    1783. 

  1783.               TtaFreeMemory (buff);
    1784. 

  1784.               UpdateStyleList (doc, 1);
    1785. 

  1785.             }
    1786. 

  1786.           TtaFreeMemory (utf8path);
    1787. 

  1787.         }
    1788. 

  1788.     }
    1789. 

  1789. }
    1790. 

  1790. 

  1791. /*----------------------------------------------------------------------
    1792. 

  1792.   RemoveEndingSpaces
    1793. 

  1793.   If element el is a block-level element, remove all spaces contained
    1794. 

  1794.   at the end of that element.
    1795. 

  1795.   Return TRUE if spaces have been removed.
    1796. 

  1796.   ----------------------------------------------------------------------*/
    1797. 

  1797. static ThotBool RemoveEndingSpaces (Element el)
    1798. 

  1798. {
    1799. 

  1799.   int              length;
    1800. 

  1800.   ElementType      elType;
    1801. 

  1801.   Element          lastLeaf;
    1802. 

  1802.   ThotBool         endingSpacesDeleted;
    1803. 

  1803. 

  1804.   endingSpacesDeleted = FALSE;
    1805. 

  1805.   elType = TtaGetElementType (el);
    1806. 

  1806.   if (!TtaIsLeaf (elType))
    1807. 

  1807.     /* it's a block element. */
    1808. 

  1808.     {
    1809. 

  1809.       /* Search the last leaf in the element's tree */
    1810. 

  1810.       lastLeaf = LastLeafInElement (el);
    1811. 

  1811.       if (elType.ElTypeNum == HTML_EL_Preformatted)
    1812. 

  1812.         el = NULL;
    1813. 

  1813.       else
    1814. 

  1814.         {
    1815. 

  1815.           // check if the element is within a preformatted
    1816. 

  1816.           elType.ElTypeNum = HTML_EL_Preformatted;
    1817. 

  1817.           el = TtaGetTypedAncestor (el, elType);
    1818. 

  1818.         }
    1819. 

  1819.       if (el == NULL && lastLeaf)
    1820. 

  1820.         {
    1821. 

  1821.           elType = TtaGetElementType (lastLeaf);
    1822. 

  1822.           if (elType.ElTypeNum == HTML_EL_TEXT_UNIT)
    1823. 

  1823.             /* the las leaf is a TEXT element */
    1824. 

  1824.             {
    1825. 

  1825.               length = TtaGetTextLength (lastLeaf);
    1826. 

  1826.               if (length > 0)
    1827. 

  1827.                 TtaRemoveFinalSpaces (lastLeaf, HTMLcontext.doc, TRUE);
    1828. 

  1828.             }
    1829. 

  1829.         }
    1830. 

  1830.       endingSpacesDeleted = TRUE;
    1831. 

  1831.     }
    1832. 

  1832.   return endingSpacesDeleted;
    1833. 

  1833. }
    1834. 

  1834. 

  1835. /*----------------------------------------------------------------------
    1836. 

  1836.   CloseElement
    1837. 

  1837.   End of HTML element defined in entry entry of pHTMLGIMapping.
    1838. 

  1838.   Terminate all corresponding Thot elements.
    1839. 

  1839.   If start < 0, an explicit end tag has been encountered in the HTML file,
    1840. 

  1840.   else the end of element is implied by the beginning of an element
    1841. 

  1841.   described by entry start of pHTMLGIMapping.
    1842. 

  1842.   ----------------------------------------------------------------------*/
    1843. 

  1843. static ThotBool     CloseElement (int entry, int start, ThotBool onStartTag)
    1844. 

  1844. {
    1845. 

  1845.   int               i;
    1846. 

  1846.   ElementType       elType, parentType;
    1847. 

  1847.   Element           el, parent;
    1848. 

  1848.   ThotBool          ret, stop, spacesDeleted;
    1849. 

  1849.   int               error;
    1850. 

  1850. 

  1851.   ret = FALSE;
    1852. 

  1852.   /* the closed HTML element corresponds to a Thot element. */
    1853. 

  1853.   stop = FALSE;
    1854. 

  1854.   /* type of the element to be closed */
    1855. 

  1855.   elType.ElSSchema = DocumentSSchema;
    1856. 

  1856.   elType.ElTypeNum = pHTMLGIMapping[entry].ThotType;
    1857. 

  1857.   if (StackLevel > 0)
    1858. 

  1858.     {
    1859. 

  1859.       el = HTMLcontext.lastElement;
    1860. 

  1860.       if (HTMLcontext.lastElementClosed)
    1861. 

  1861.         el = TtaGetParent (el);
    1862. 

  1862.       i = StackLevel - 1;
    1863. 

  1863.       if (start < 0)
    1864. 

  1864.         /* Explicit close */
    1865. 

  1865.         {
    1866. 

  1866.           /* If we meet the end tag of a form, font or center
    1867. 

  1867.              looks for that element in the stack, but not at
    1868. 

  1868.              a higher level as a table element */
    1869. 

  1869.           if (!onStartTag &&
    1870. 

  1870.               (!strcmp (pHTMLGIMapping[entry].XMLname, "form") ||
    1871. 

  1871.                !strcmp (pHTMLGIMapping[entry].XMLname, "font") ||
    1872. 

  1872.                !strcmp (pHTMLGIMapping[entry].XMLname, "center")))
    1873. 

  1873.             while (i > 0 && entry != GINumberStack[i] && !stop)
    1874. 

  1874.               if (!strcmp (pHTMLGIMapping[GINumberStack[i]].XMLname, "tbody") ||
    1875. 

  1875.                   !strcmp (pHTMLGIMapping[GINumberStack[i]].XMLname, "tr")    ||
    1876. 

  1876.                   !strcmp (pHTMLGIMapping[GINumberStack[i]].XMLname, "th")    ||
    1877. 

  1877.                   !strcmp (pHTMLGIMapping[GINumberStack[i]].XMLname, "td"))
    1878. 

  1878.                 {
    1879. 

  1879.                   /* ignore this end tag */
    1880. 

  1880.                   ret = FALSE;
    1881. 

  1881.                   stop = TRUE;
    1882. 

  1882.                   i = -1;
    1883. 

  1883.                 }
    1884. 

  1884.               else
    1885. 

  1885.                 i--;
    1886. 

  1886.           else
    1887. 

  1887.             /* looks in the stack for the element to be closed */
    1888. 

  1888.             while (i >= 0 && entry != GINumberStack[i])
    1889. 

  1889.               i--;
    1890. 

  1890.         }
    1891. 

  1891.       else
    1892. 

  1892.         /* Implicit close */
    1893. 

  1893.         {
    1894. 

  1894.           /* If the element to be closed is a list item (or
    1895. 

  1895.              equivalent), looks for that element in the
    1896. 

  1896.              stack, but not at a higher level as the list (or
    1897. 

  1897.              equivalent) element */
    1898. 

  1898.           if (!strcmp (pHTMLGIMapping[start].XMLname, "li"))
    1899. 

  1899.             {
    1900. 

  1900.               while (i > 0 && entry != GINumberStack[i] && !stop)
    1901. 

  1901.                 if (!strcmp (pHTMLGIMapping[GINumberStack[i]].XMLname, "ol")  ||
    1902. 

  1902.                     !strcmp (pHTMLGIMapping[GINumberStack[i]].XMLname, "ul")  ||
    1903. 

  1903.                     !strcmp (pHTMLGIMapping[GINumberStack[i]].XMLname, "dir") ||
    1904. 

  1904.                     !strcmp (pHTMLGIMapping[GINumberStack[i]].XMLname, "menu"))
    1905. 

  1905.                   stop = TRUE;
    1906. 

  1906.                 else
    1907. 

  1907.                   i--;
    1908. 

  1908.             }
    1909. 

  1909.           else if (!strcmp (pHTMLGIMapping[start].XMLname, "option"))
    1910. 

  1910.             {
    1911. 

  1911.               while (i > 0 && entry != GINumberStack[i] && !stop)
    1912. 

  1912.                 if (!strcmp (pHTMLGIMapping[GINumberStack[i]].XMLname, "select"))
    1913. 

  1913.                   stop = TRUE;
    1914. 

  1914.                 else
    1915. 

  1915.                   i--;
    1916. 

  1916.             }
    1917. 

  1917.           else if (!strcmp (pHTMLGIMapping[start].XMLname, "dd") ||
    1918. 

  1918.                    !strcmp (pHTMLGIMapping[start].XMLname, "dt"))
    1919. 

  1919.             {
    1920. 

  1920.               while (i > 0 && entry != GINumberStack[i] && !stop)
    1921. 

  1921.                 if (!strcmp (pHTMLGIMapping[GINumberStack[i]].XMLname, "dl"))
    1922. 

  1922.                   stop = TRUE;
    1923. 

  1923.                 else
    1924. 

  1924.                   i--;
    1925. 

  1925.             }
    1926. 

  1926.           else if (!strcmp (pHTMLGIMapping[start].XMLname, "tr") ||
    1927. 

  1927.                    !strcmp (pHTMLGIMapping[start].XMLname, "td") ||
    1928. 

  1928.                    !strcmp (pHTMLGIMapping[start].XMLname, "th"))
    1929. 

  1929.             {
    1930. 

  1930.               while (i > 0 && entry != GINumberStack[i] && !stop)
    1931. 

  1931.                 if (!strcmp (pHTMLGIMapping[GINumberStack[i]].XMLname, "table"))
    1932. 

  1932.                   stop = TRUE;
    1933. 

  1933.                 else
    1934. 

  1934.                   i--;
    1935. 

  1935.             }
    1936. 

  1936.         }
    1937. 

  1937. 

  1938.       if (i >= 0 && entry == GINumberStack[i])
    1939. 

  1939.         /* element found in the stack */
    1940. 

  1940.         {
    1941. 

  1941.           /* This element and its whole subtree are closed */
    1942. 

  1942.           StackLevel = i;
    1943. 

  1943.           HTMLcontext.lastElement = ElementStack[i];
    1944. 

  1944.           HTMLcontext.lastElementClosed = TRUE;
    1945. 

  1945.           ret = TRUE;
    1946. 

  1946.         }
    1947. 

  1947.       else if (!stop)
    1948. 

  1948.         /* element not found in the stack */
    1949. 

  1949.         if (start >= 0 && HTMLcontext.lastElement != NULL)
    1950. 

  1950.           {
    1951. 

  1951.             /* implicit close. Check the parent of current element */
    1952. 

  1952.             if (InsertSibling ())
    1953. 

  1953.               parent = TtaGetParent (HTMLcontext.lastElement);
    1954. 

  1954.             else
    1955. 

  1955.               parent = HTMLcontext.lastElement;
    1956. 

  1956.             if (parent != NULL)
    1957. 

  1957.               {
    1958. 

  1958.                 parentType = TtaGetElementType (parent);
    1959. 

  1959.                 if (elType.ElTypeNum == parentType.ElTypeNum)
    1960. 

  1960.                   {
    1961. 

  1961.                     HTMLcontext.lastElement = parent;
    1962. 

  1962.                     HTMLcontext.lastElementClosed = TRUE;
    1963. 

  1963.                     ret = TRUE;
    1964. 

  1964.                   }
    1965. 

  1965.                 else if (TtaIsLeaf (TtaGetElementType (HTMLcontext.lastElement)))
    1966. 

  1966.                   {
    1967. 

  1967.                     parent = TtaGetParent (parent);
    1968. 

  1968.                     if (parent != NULL)
    1969. 

  1969.                       {
    1970. 

  1970.                         parentType = TtaGetElementType (parent);
    1971. 

  1971.                         if (elType.ElTypeNum == parentType.ElTypeNum)
    1972. 

  1972.                           {
    1973. 

  1973.                             HTMLcontext.lastElement = parent;
    1974. 

  1974.                             HTMLcontext.lastElementClosed = TRUE;
    1975. 

  1975.                             ret = TRUE;
    1976. 

  1976.                           }
    1977. 

  1977.                       }
    1978. 

  1978.                   }
    1979. 

  1979.               }
    1980. 

  1980.           }
    1981. 

  1981. 

  1982.       if (ret)
    1983. 

  1983.         /* successful close */
    1984. 

  1984.         {
    1985. 

  1985.           /* remove closed elements from the stack */
    1986. 

  1986.           while (i > 0)
    1987. 

  1987.             if (ElementStack[i] == HTMLcontext.lastElement)
    1988. 

  1988.               {
    1989. 

  1989.                 StackLevel = i;
    1990. 

  1990.                 i = 0;
    1991. 

  1991.               }
    1992. 

  1992.             else
    1993. 

  1993.               {
    1994. 

  1994.                 if (TtaIsAncestor (ElementStack[i], HTMLcontext.lastElement))
    1995. 

  1995.                   StackLevel = i;
    1996. 

  1996.                 i--;
    1997. 

  1997.               }
    1998. 

  1998.           if (StackLevel > 0)
    1999. 

  1999.             HTMLcontext.language = LanguageStack[StackLevel - 1];
    2000. 

  2000. 

  2001.           /* complete all closed elements */
    2002. 

  2002.           if (el != HTMLcontext.lastElement)
    2003. 

  2003.             if (!TtaIsAncestor(el, HTMLcontext.lastElement))
    2004. 

  2004.               el = NULL;
    2005. 

  2005.           spacesDeleted = FALSE;
    2006. 

  2006.           while (el != NULL)
    2007. 

  2007.             {
    2008. 

  2008.               XhtmlElementComplete (&HTMLcontext, el, &error);
    2009. 

  2009.               elType = TtaGetElementType (el);
    2010. 

  2010.               if (elType.ElTypeNum == HTML_EL_Table_)
    2011. 

  2011.                 HTMLcontext.withinTable--;
    2012. 

  2012.               if (!spacesDeleted)
    2013. 

  2013.                 /* If the element closed is a block-element, remove */
    2014. 

  2014.                 /* spaces contained at the end of that element */
    2015. 

  2015.                 spacesDeleted = RemoveEndingSpaces (el);
    2016. 

  2016.               if (el == HTMLcontext.lastElement)
    2017. 

  2017.                 el = NULL;
    2018. 

  2018.               else
    2019. 

  2019.                 el = TtaGetParent (el);
    2020. 

  2020.             }
    2021. 

  2021.         }
    2022. 

  2022.     }
    2023. 

  2023.    
    2024. 

  2024.   return ret;
    2025. 

  2025. }
    2026. 

  2026. 

  2027. 

  2028. /*----------------------------------------------------------------------
    2029. 

  2029.   MapAttrValue    search in AttrValueMappingTable the entry for
    2030. 

  2030.   the attribute thotAttr and its value attrVal. Returns the corresponding
    2031. 

  2031.   Thot value.
    2032. 

  2032.   ----------------------------------------------------------------------*/
    2033. 

  2033. int           MapAttrValue (int thotAttr, char* attrVal)
    2034. 

  2034. {
    2035. 

  2035.   int        i, value;
    2036. 

  2036. 

  2037.   value = -1;
    2038. 

  2038.   i = 0;
    2039. 

  2039.   while (XhtmlAttrValueMappingTable[i].ThotAttr != thotAttr &&
    2040. 

  2040.          XhtmlAttrValueMappingTable[i].ThotAttr != 0)
    2041. 

  2041.     i++;
    2042. 

  2042.   if (XhtmlAttrValueMappingTable[i].ThotAttr == thotAttr)
    2043. 

  2043.     do
    2044. 

  2044.       if (attrVal[1] == EOS && (thotAttr == HTML_ATTR_NumberStyle ||
    2045. 

  2045.                                 thotAttr == HTML_ATTR_ItemStyle))
    2046. 

  2046.         /* attributes NumberStyle (which is always 1 character long) */
    2047. 

  2047.         /* and ItemStyle (only when its length is 1) are */
    2048. 

  2048.         /* case sensistive. Compare their exact value */
    2049. 

  2049.         if (attrVal[0] == XhtmlAttrValueMappingTable[i].XMLattrValue[0])
    2050. 

  2050.           value = XhtmlAttrValueMappingTable[i].ThotAttrValue;
    2051. 

  2051.         else
    2052. 

  2052.           i++;
    2053. 

  2053.       else
    2054. 

  2054.         /* for other attributes, uppercase and lowercase are */
    2055. 

  2055.         /* equivalent */
    2056. 

  2056.         if (!strcasecmp ((char *)XhtmlAttrValueMappingTable[i].XMLattrValue, (char *)attrVal))
    2057. 

  2057.           value = XhtmlAttrValueMappingTable[i].ThotAttrValue;
    2058. 

  2058.         else
    2059. 

  2059.           i++;
    2060. 

  2060.     while (value < 0 && XhtmlAttrValueMappingTable[i].ThotAttr == thotAttr);
    2061. 

  2061.   return value;
    2062. 

  2062. }
    2063. 

  2063. 

  2064. /*----------------------------------------------------------------------
    2065. 

  2065.   StopParsing 
    2066. 

  2066.   Stops the document parsing when an unrecoverable error is found
    2067. 

  2067.   ----------------------------------------------------------------------*/
    2068. 

  2068. static void StopParsing (Document doc)
    2069. 

  2069. {
    2070. 

  2070.   NormalTransition = FALSE;
    2071. 

  2071.   HTMLrootClosed = TRUE;
    2072. 

  2072.   CurrentBufChar = 0;
    2073. 

  2073. }
    2074. 

  2074. 

  2075. /*----------------------------------------------------------------------
    2076. 

  2076.   InsertInvalidEl
    2077. 

  2077.   create an Invalid_element element or a Unknown element.
    2078. 

  2078.   badposition indicate whether the element type is unknown (FALSE) or the
    2079. 

  2079.   tag position is incorrect (TRUE).
    2080. 

  2080.   ----------------------------------------------------------------------*/
    2081. 

  2081. static void InsertInvalidEl (char* content, ThotBool badposition)
    2082. 

  2082. {
    2083. 

  2083.   ElementType       elType;
    2084. 

  2084.   Element           elInv, elText;
    2085. 

  2085. 

  2086.   elType.ElSSchema = DocumentSSchema;
    2087. 

  2087.   if (badposition)
    2088. 

  2088.     elType.ElTypeNum = HTML_EL_Invalid_element;
    2089. 

  2089.   else
    2090. 

  2090.     elType.ElTypeNum = HTML_EL_Unknown_namespace;
    2091. 

  2091.   elInv = TtaNewElement (HTMLcontext.doc, elType);
    2092. 

  2092.   TtaSetElementLineNumber (elInv, NumberOfLinesRead);
    2093. 

  2093.   InsertElement (&elInv);
    2094. 

  2094.   if (elInv)
    2095. 

  2095.     {
    2096. 

  2096.       HTMLcontext.lastElementClosed = TRUE;
    2097. 

  2097.       elType.ElTypeNum = HTML_EL_TEXT_UNIT;
    2098. 

  2098.       elText = TtaNewElement (HTMLcontext.doc, elType);
    2099. 

  2099.       TtaSetElementLineNumber (elText, NumberOfLinesRead);
    2100. 

  2100.       TtaInsertFirstChild (&elText, elInv, HTMLcontext.doc);
    2101. 

  2101.       TtaSetTextContent (elText, (unsigned char *)content, HTMLcontext.language, HTMLcontext.doc);
    2102. 

  2102.       InitBuffer ();
    2103. 

  2103.       if (!UnknownTag)
    2104. 

  2104.         /* close the end tag */
    2105. 

  2105.         TtaAppendTextContent (elText, (unsigned char *)">", HTMLcontext.doc);
    2106. 

  2106.       if (badposition)
    2107. 

  2107.         TtaSetAccessRight (elInv, ReadOnly, HTMLcontext.doc);
    2108. 

  2108.     }
    2109. 

  2109. }
    2110. 

  2110. 

  2111. /*----------------------------------------------------------------------
    2112. 

  2112.   EndOfStartTag   a ">" has been read. It indicates the end
    2113. 

  2113.   of a start tag.
    2114. 

  2114.   ----------------------------------------------------------------------*/
    2115. 

  2115. static void EndOfStartTag (char c)
    2116. 

  2116. {
    2117. 

  2117.   Element             elText;
    2118. 

  2118.   ElementType         elType;
    2119. 

  2119.   AttributeType       attrType;
    2120. 

  2120.   Attribute           attr;
    2121. 

  2121.   char               *text;
    2122. 

  2122.   int                 length, error;
    2123. 

  2123. 

  2124.   if (UnknownTag)
    2125. 

  2125.     {
    2126. 

  2126.       if (HTMLcontext.lastElement)
    2127. 

  2127.         {
    2128. 

  2128.           CloseBuffer ();
    2129. 

  2129.           elType = TtaGetElementType (HTMLcontext.lastElement);
    2130. 

  2130.           if (elType.ElTypeNum == HTML_EL_Invalid_element ||
    2131. 

  2131.               elType.ElTypeNum == HTML_EL_Unknown_namespace)
    2132. 

  2132.             {
    2133. 

  2133.               elText = TtaGetLastChild (HTMLcontext.lastElement);
    2134. 

  2134.               if (LgBuffer > 0)
    2135. 

  2135.                 TtaAppendTextContent (elText, (unsigned char *)inputBuffer,
    2136. 

  2136.                                       HTMLcontext.doc);
    2137. 

  2137.               TtaAppendTextContent (elText, (unsigned char *)">",
    2138. 

  2138.                                     HTMLcontext.doc);
    2139. 

  2139.             }
    2140. 

  2140.           InitBuffer ();
    2141. 

  2141.         }
    2142. 

  2142.       UnknownTag = FALSE;
    2143. 

  2143.     }
    2144. 

  2144.   if (HTMLcontext.lastElement && lastElemEntry != -1)
    2145. 

  2145.     {
    2146. 

  2146.       if (!strcmp (pHTMLGIMapping[lastElemEntry].XMLname, "pre") ||
    2147. 

  2147.           !strcmp (pHTMLGIMapping[lastElemEntry].XMLname, "style") ||
    2148. 

  2148.           !strcmp (pHTMLGIMapping[lastElemEntry].XMLname, "script"))
    2149. 

  2149.         /* a <PRE>, <STYLE> or <SCRIPT> tag has been read */
    2150. 

  2150.         AfterTagPRE = TRUE;
    2151. 

  2151.       else if (!strcmp (pHTMLGIMapping[lastElemEntry].XMLname, "table"))
    2152. 

  2152.         /* <TABLE> has been read */
    2153. 

  2153.         HTMLcontext.withinTable++;
    2154. 

  2154.       else if (pHTMLGIMapping[lastElemEntry].XMLcontents == 'E')
    2155. 

  2155.         /* this is an empty element. Do not expect an end tag */
    2156. 

  2156.         {
    2157. 

  2157.           CloseElement (lastElemEntry, -1, TRUE);
    2158. 

  2158.           XhtmlElementComplete (&HTMLcontext, HTMLcontext.lastElement, &error);
    2159. 

  2159.         }
    2160. 

  2160. 

  2161.       /* if it's an AREA element, computes its position and size */
    2162. 

  2162.       ParseAreaCoords (HTMLcontext.lastElement, HTMLcontext.doc);
    2163. 

  2163.       /* if it's a STYLE element in CSS notation, activate the CSS */
    2164. 

  2164.       /* parser for parsing the element content */
    2165. 

  2165.       elType = TtaGetElementType (HTMLcontext.lastElement);
    2166. 

  2166.       if (elType.ElTypeNum == HTML_EL_STYLE_)
    2167. 

  2167.         {
    2168. 

  2168.           /* Search the Notation attribute */
    2169. 

  2169.           attrType.AttrSSchema = elType.ElSSchema;
    2170. 

  2170.           attrType.AttrTypeNum = HTML_ATTR_Notation;
    2171. 

  2171.           attr = TtaGetAttribute (HTMLcontext.lastElement, attrType);
    2172. 

  2172.           if (attr == NULL)
    2173. 

  2173.             /* No Notation attribute. Assume CSS by default */
    2174. 

  2174.             HTMLcontext.parsingCSS = TRUE;
    2175. 

  2175.           else
    2176. 

  2176.             /* the STYLE element has a Notation attribute */
    2177. 

  2177.             /* get its value */
    2178. 

  2178.             {
    2179. 

  2179.               length = TtaGetTextAttributeLength (attr);
    2180. 

  2180.               text = (char*)TtaGetMemory (length + 1);
    2181. 

  2181.               TtaGiveTextAttributeValue (attr, text, &length);
    2182. 

  2182.               if (!strcasecmp ((char *)text, "text/css"))
    2183. 

  2183.                 HTMLcontext.parsingCSS = TRUE;
    2184. 

  2184.               TtaFreeMemory (text);
    2185. 

  2185.             }
    2186. 

  2186.         }
    2187. 

  2187.       else if (elType.ElTypeNum == HTML_EL_Text_Area)
    2188. 

  2188.         /* we have to read the content as a simple text unit */
    2189. 

  2189.         HTMLcontext.parsingTextArea = TRUE;
    2190. 

  2190.       else if (elType.ElTypeNum == HTML_EL_SCRIPT_)
    2191. 

  2191.         /* we have to read the content as a simple text unit */
    2192. 

  2192.         HTMLcontext.parsingScript = TRUE;
    2193. 

  2193.     }
    2194. 

  2194. 

  2195.   if (c == '<')
    2196. 

  2196.     {
    2197. 

  2197.       HTMLParseError (HTMLcontext.doc, "Syntax error", 0);
    2198. 

  2198.       StartOfTag (c);
    2199. 

  2199.     }
    2200. 

  2200. }
    2201. 

  2201. 

  2202. 

  2203. /*----------------------------------------------------------------------
    2204. 

  2204.   ContextOK       returns TRUE if the element at position entry
    2205. 

  2205.   in the mapping table is allowed to occur in the
    2206. 

  2206.   current structural context.
    2207. 

  2207.   ----------------------------------------------------------------------*/
    2208. 

  2208. static ThotBool     ContextOK (int entry)
    2209. 

  2209. {
    2210. 

  2210.   ThotBool         ok;
    2211. 

  2211.   int		    saveLastElemEntry;
    2212. 

  2212. 

  2213.   if (StackLevel == 0 || GINumberStack[StackLevel - 1] < 0)
    2214. 

  2214.     return TRUE;
    2215. 

  2215.   else
    2216. 

  2216.     {
    2217. 

  2217.       ok = TRUE;
    2218. 

  2218.       if (!strcmp (pHTMLGIMapping[GINumberStack[StackLevel - 1]].XMLname, "tr") &&
    2219. 

  2219.           strcmp (pHTMLGIMapping[entry].XMLname, "th") &&
    2220. 

  2220.           strcmp (pHTMLGIMapping[entry].XMLname, "td"))
    2221. 

  2221.         /* only TH and TD elements are allowed as children of a TR element */
    2222. 

  2222.         ok = FALSE;
    2223. 

  2223.       if (ok &&
    2224. 

  2224.           !strcmp (pHTMLGIMapping[GINumberStack[StackLevel - 1]].XMLname, "table") &&
    2225. 

  2225.           strcmp (pHTMLGIMapping[entry].XMLname, "caption")  &&
    2226. 

  2226.           strcmp (pHTMLGIMapping[entry].XMLname, "thead")    &&
    2227. 

  2227.           strcmp (pHTMLGIMapping[entry].XMLname, "tfoot")    &&
    2228. 

  2228.           strcmp (pHTMLGIMapping[entry].XMLname, "tbody")    &&
    2229. 

  2229.           strcmp (pHTMLGIMapping[entry].XMLname, "colgroup") &&
    2230. 

  2230.           strcmp (pHTMLGIMapping[entry].XMLname, "col")      &&
    2231. 

  2231.           strcmp (pHTMLGIMapping[entry].XMLname, "tr"))
    2232. 

  2232.         {
    2233. 

  2233.           /* only CAPTION, THEAD, TFOOT, TBODY, COLGROUP, COL and TR are */
    2234. 

  2234.           /* allowed as children of a TABLE element */
    2235. 

  2235.           if (!strcmp (pHTMLGIMapping[entry].XMLname, "td") ||
    2236. 

  2236.               !strcmp (pHTMLGIMapping[entry].XMLname, "th"))
    2237. 

  2237.             /* Table cell within a table, without a tr. Assume tr */
    2238. 

  2238.             {
    2239. 

  2239.               /* save the last last identifier read from the input file */
    2240. 

  2240.               saveLastElemEntry = lastElemEntry;
    2241. 

  2241.               /* simulate a <TR> tag */
    2242. 

  2242.               ProcessStartGI ("tr");
    2243. 

  2243.               /* restore the last tag that has actually been read */
    2244. 

  2244.               lastElemEntry = saveLastElemEntry;
    2245. 

  2245.             }
    2246. 

  2246.           else
    2247. 

  2247.             ok = FALSE;
    2248. 

  2248.         }
    2249. 

  2249.       if (ok &&
    2250. 

  2250.           (!strcmp (pHTMLGIMapping[entry].XMLname, "caption") ||
    2251. 

  2251.            !strcmp (pHTMLGIMapping[entry].XMLname, "thead") ||
    2252. 

  2252.            !strcmp (pHTMLGIMapping[entry].XMLname, "tfoot") ||
    2253. 

  2253.            !strcmp (pHTMLGIMapping[entry].XMLname, "tbody") ||
    2254. 

  2254.            !strcmp (pHTMLGIMapping[entry].XMLname, "colgroup")) &&
    2255. 

  2255.           strcmp (pHTMLGIMapping[GINumberStack[StackLevel - 1]].XMLname, "table"))
    2256. 

  2256.         /* CAPTION, THEAD, TFOOT, TBODY, COLGROUP are allowed only as
    2257. 

  2257.            children of a TABLE element */
    2258. 

  2258.         ok = FALSE;
    2259. 

  2259.       if (ok &&
    2260. 

  2260.           (!strcmp (pHTMLGIMapping[GINumberStack[StackLevel - 1]].XMLname, "thead") ||
    2261. 

  2261.            !strcmp (pHTMLGIMapping[GINumberStack[StackLevel - 1]].XMLname, "tfoot") ||
    2262. 

  2262.            !strcmp (pHTMLGIMapping[GINumberStack[StackLevel - 1]].XMLname, "tbody")) &&
    2263. 

  2263.           strcmp (pHTMLGIMapping[entry].XMLname, "tr"))
    2264. 

  2264.         /* only TR is allowed as a child of a THEAD, TFOOT or TBODY element */
    2265. 

  2265.         {
    2266. 

  2266.           if (!strcmp (pHTMLGIMapping[entry].XMLname, "td") ||
    2267. 

  2267.               !strcmp (pHTMLGIMapping[entry].XMLname, "th"))
    2268. 

  2268.             /* Table cell within a thead, tfoot or tbody without a tr. */
    2269. 

  2269.             /* Assume tr */
    2270. 

  2270.             {
    2271. 

  2271.               /* save the last last identifier read from the input file */
    2272. 

  2272.               saveLastElemEntry = lastElemEntry;
    2273. 

  2273.               /* simulate a <tr> tag */
    2274. 

  2274.               ProcessStartGI ("tr");
    2275. 

  2275.               /* restore the last tag that has actually been read */
    2276. 

  2276.               lastElemEntry = saveLastElemEntry;
    2277. 

  2277.             }
    2278. 

  2278.           else
    2279. 

  2279.             ok = FALSE;
    2280. 

  2280.         }
    2281. 

  2281.       if (ok)
    2282. 

  2282.         /* refuse HEAD within HEAD */
    2283. 

  2283.         if (strcmp (pHTMLGIMapping[entry].XMLname, "head") == 0)
    2284. 

  2284.           if (Within (HTML_EL_HEAD, DocumentSSchema))
    2285. 

  2285.             ok = FALSE;
    2286. 

  2286.       if (ok)
    2287. 

  2287.         /* refuse STYLE within STYLE */
    2288. 

  2288.         if (strcmp (pHTMLGIMapping[entry].XMLname, "style") == 0)
    2289. 

  2289.           if (Within (HTML_EL_STYLE_, DocumentSSchema))
    2290. 

  2290.             ok = FALSE;
    2291. 

  2291.       return ok;
    2292. 

  2292.     }
    2293. 

  2293. }
    2294. 

  2294. 

  2295. /*----------------------------------------------------------------------
    2296. 

  2296.   SpecialImplicitEnd
    2297. 

  2297.   ----------------------------------------------------------------------*/
    2298. 

  2298. static void SpecialImplicitEnd (int entry)
    2299. 

  2299. {
    2300. 

  2300.   ElementType      elType;
    2301. 

  2301. 

  2302.   /* if current element is DD, Hn closes that DD only when there is */
    2303. 

  2303.   /* no enclosing DL */
    2304. 

  2304.   if (pHTMLGIMapping[entry].XMLname[0] == 'H' &&
    2305. 

  2305.       pHTMLGIMapping[entry].XMLname[1] >= '1' &&
    2306. 

  2306.       pHTMLGIMapping[entry].XMLname[1] <= '6' &&
    2307. 

  2307.       pHTMLGIMapping[entry].XMLname[2] == EOS)
    2308. 

  2308.     /* the new element is a Hn */
    2309. 

  2309.     if (StackLevel > 1)
    2310. 

  2310.       if (ElementStack[StackLevel - 1] != NULL)
    2311. 

  2311.         {
    2312. 

  2312.           elType = TtaGetElementType (ElementStack[StackLevel - 1]);
    2313. 

  2313.           if (elType.ElTypeNum == HTML_EL_Definition)
    2314. 

  2314.             /* the current element is a DD */
    2315. 

  2315.             {
    2316. 

  2316.               elType = TtaGetElementType (ElementStack[StackLevel - 2]);
    2317. 

  2317.               if (elType.ElTypeNum != HTML_EL_Definition_List)
    2318. 

  2318.                 /* DD in not within a DL. Close the DD element */
    2319. 

  2319.                 CloseElement (GINumberStack[StackLevel - 1], entry, FALSE);
    2320. 

  2320.             }
    2321. 

  2321.         }
    2322. 

  2322. }
    2323. 

  2323. 

  2324. /*----------------------------------------------------------------------
    2325. 

  2325.   ProcessStartGI  An HTML GI has been read in a start tag.
    2326. 

  2326.   Create the corresponding Thot thing (element, attribute,
    2327. 

  2327.   or character), according to the mapping table.
    2328. 

  2328.   ----------------------------------------------------------------------*/
    2329. 

  2329. static void ProcessStartGI (const char* GIname)
    2330. 

  2330. {
    2331. 

  2331.   ElementType         elType;
    2332. 

  2332.   Element             el;
    2333. 

  2333.   int                 entry, i;
    2334. 

  2334.   char                msgBuffer[MaxMsgLength];
    2335. 

  2335.   PtrClosedElement    pClose;
    2336. 

  2336.   ThotBool            sameLevel, removed, error;
    2337. 

  2337.   SSchema	      schema;
    2338. 

  2338. 

  2339.   /* ignore tag <P> within PRE */
    2340. 

  2340.   if (Within (HTML_EL_Preformatted, DocumentSSchema))
    2341. 

  2341.     if (strcasecmp ((char *)GIname, "p") == 0)
    2342. 

  2342.       return;
    2343. 

  2343. 

  2344.   /* search the HTML element name in the mapping table */
    2345. 

  2345.   schema = DocumentSSchema;
    2346. 

  2346.   entry = MapGI ((char *)GIname, &schema, HTMLcontext.doc);
    2347. 

  2347.   lastElemEntry = entry;
    2348. 

  2348. 

  2349.   if (entry < 0)
    2350. 

  2350.     /* not found in the HTML DTD */
    2351. 

  2351.     {
    2352. 

  2352.       /* check if it's the math or svg tag with a namespace prefix */
    2353. 

  2353.       /* So, look for a colon in the element name */
    2354. 

  2354.       for (i = 0; GIname[i] != ':' && GIname[i] != EOS; i++);
    2355. 

  2355.       if (GIname[i] == ':' &&
    2356. 

  2356.           (strcasecmp ((char *)&GIname[i+1], "math") == 0 ||
    2357. 

  2357.            strcasecmp ((char *)&GIname[i+1], "xmlgraphics") == 0 ||
    2358. 

  2358.            strcasecmp ((char *)&GIname[i+1], "svg") == 0))
    2359. 

  2359.         /* it's a math or svg tag with a namespace prefix. OK */
    2360. 

  2360.         {
    2361. 

  2361.           entry = MapGI ((char *)&GIname[i+1], &schema, HTMLcontext.doc);
    2362. 

  2362.           lastElemEntry = entry;
    2363. 

  2363.         }
    2364. 

  2364.       else
    2365. 

  2365.         /* unknown tag */
    2366. 

  2366.         {
    2367. 

  2367.           UnknownTag = TRUE;
    2368. 

  2368.           if (DocumentMeta[HTMLcontext.doc] &&
    2369. 

  2369.               DocumentMeta[HTMLcontext.doc]->xmlformat)
    2370. 

  2370.             {
    2371. 

  2371.               snprintf (msgBuffer, MaxMsgLength,
    2372. 

  2372. 			"Invalid tag <%s> (removed when saving)", GIname);
    2373. 

  2373.               HTMLParseError (HTMLcontext.doc, msgBuffer, 0);
    2374. 

  2374.               removed = TRUE;
    2375. 

  2375.             }
    2376. 

  2376.           else
    2377. 

  2377.             {
    2378. 

  2378.               snprintf (msgBuffer, MaxMsgLength, "Warning - unknown tag <%s>",
    2379. 

  2379. 			GIname);
    2380. 

  2380.               HTMLParseError (HTMLcontext.doc, msgBuffer, 0);
    2381. 

  2381.               removed = FALSE;
    2382. 

  2382.             }
    2383. 

  2383.           /* create an Invalid_element */
    2384. 

  2384.           snprintf (msgBuffer, MaxMsgLength, "<%s", GIname);
    2385. 

  2385.           InsertInvalidEl (msgBuffer, removed);
    2386. 

  2386.         }
    2387. 

  2387.     }
    2388. 

  2388. 

  2389.   if (entry >= 0)
    2390. 

  2390.     {
    2391. 

  2391.       if (TtaGetDocumentProfile(HTMLcontext.doc) != L_Other &&
    2392. 

  2392.           !(pHTMLGIMapping[entry].Level &
    2393. 

  2393.             TtaGetDocumentProfile(HTMLcontext.doc))) 
    2394. 

  2394.         {
    2395. 

  2395.           /* Invalid element for the document profile */
    2396. 

  2396.           /* don't process that element */
    2397. 

  2397.           snprintf (msgBuffer, MaxMsgLength,
    2398. 

  2398.                    "Invalid element <%s> for the document profile", GIname);
    2399. 

  2399.           HTMLParseError (HTMLcontext.doc, msgBuffer, 0);
    2400. 

  2400.           XMLErrorsFoundInProfile = TRUE;
    2401. 

  2401.           UnknownTag = TRUE;
    2402. 

  2402.         }
    2403. 

  2403.       else
    2404. 

  2404.         {
    2405. 

  2405.           if (HTMLcontext.withinTable == 0 &&
    2406. 

  2406.               (!strcmp (pHTMLGIMapping[entry].XMLname, "td") ||
    2407. 

  2407.                !strcmp (pHTMLGIMapping[entry].XMLname, "th")))
    2408. 

  2408.             {
    2409. 

  2409.               sprintf (msgBuffer, "Tags <table>, <tbody> and <tr> added");
    2410. 

  2410.               HTMLParseError (HTMLcontext.doc, msgBuffer, 0);
    2411. 

  2411.               /* generate mandatory parent elements */ 
    2412. 

  2412.               ProcessStartGI ("table");
    2413. 

  2413.               HTMLcontext.withinTable = 1;
    2414. 

  2414.               ProcessStartGI ("tr");
    2415. 

  2415.             }
    2416. 

  2416.           else if (HTMLcontext.withinTable == 0 &&
    2417. 

  2417.                    !strcmp (pHTMLGIMapping[entry].XMLname, "tr"))
    2418. 

  2418.             {
    2419. 

  2419.               /* generate mandatory parent elements */ 
    2420. 

  2420.               sprintf (msgBuffer, "Tags <table> and <tbody> added");
    2421. 

  2421.               HTMLParseError (HTMLcontext.doc, msgBuffer, 0);
    2422. 

  2422.               ProcessStartGI ("table");
    2423. 

  2423.             }
    2424. 

  2424.           /* does this start tag also imply the end tag of some current elements?*/
    2425. 

  2425.           pClose = FirstClosedElem[entry];
    2426. 

  2426.           while (pClose != NULL)
    2427. 

  2427.             {
    2428. 

  2428.               CloseElement (pClose->tagNum, entry, TRUE);
    2429. 

  2429.               pClose = pClose->nextClosedElem;
    2430. 

  2430.             }
    2431. 

  2431.           /* process some special cases... */
    2432. 

  2432.           SpecialImplicitEnd (entry);
    2433. 

  2433.           error = !ContextOK (entry);
    2434. 

  2434.           if (error)
    2435. 

  2435.             /* element not allowed in the current structural context */
    2436. 

  2436.             {
    2437. 

  2437.               /* send an error message */
    2438. 

  2438.               snprintf (msgBuffer, MaxMsgLength,
    2439. 

  2439.                        "Tag <%s> is not allowed here (removed when saving)",
    2440. 

  2440.                        GIname);
    2441. 

  2441.               HTMLParseError (HTMLcontext.doc, msgBuffer, 0);
    2442. 

  2442.               /* if it's a <script> tag, process it normally to avoid its
    2443. 

  2443.                  content to be considered as plain text */
    2444. 

  2444.               if (!strcmp (pHTMLGIMapping[entry].XMLname, "script"))
    2445. 

  2445.                 error = FALSE;
    2446. 

  2446.             }
    2447. 

  2447.           if (error)
    2448. 

  2448.             {
    2449. 

  2449.               UnknownTag = TRUE;
    2450. 

  2450.               /* create an Invalid_element */
    2451. 

  2451.               snprintf (msgBuffer, MaxMsgLength, "<%s", GIname);
    2452. 

  2452.               InsertInvalidEl (msgBuffer, TRUE);
    2453. 

  2453.             }
    2454. 

  2454.           else
    2455. 

  2455.             {
    2456. 

  2456.               el = NULL;
    2457. 

  2457.               sameLevel = TRUE;
    2458. 

  2458.               if (pHTMLGIMapping[entry].ThotType > 0)
    2459. 

  2459.                 {
    2460. 

  2460.                   /* create a Thot element */
    2461. 

  2461.                   elType.ElSSchema = DocumentSSchema;
    2462. 

  2462.                   elType.ElTypeNum = pHTMLGIMapping[entry].ThotType;
    2463. 

  2463.                   if (pHTMLGIMapping[entry].XMLcontents == 'E')
    2464. 

  2464.                     /* empty HTML element. Create all children specified */
    2465. 

  2465.                     /* in the Thot structure schema */
    2466. 

  2466.                     el = TtaNewTree (HTMLcontext.doc, elType, "");
    2467. 

  2467.                   else
    2468. 

  2468.                     /* the HTML element may have children. Create only */
    2469. 

  2469.                     /* the corresponding Thot element, without any child */
    2470. 

  2470.                     el = TtaNewElement (HTMLcontext.doc, elType);
    2471. 

  2471.                   TtaSetElementLineNumber (el, NumberOfLinesRead);
    2472. 

  2472.                   sameLevel = InsertElement (&el);
    2473. 

  2473.                   if (el != NULL)
    2474. 

  2474.                     {
    2475. 

  2475.                       if (pHTMLGIMapping[entry].XMLcontents == 'E')
    2476. 

  2476.                         HTMLcontext.lastElementClosed = TRUE;
    2477. 

  2477.                       if (elType.ElTypeNum == HTML_EL_TEXT_UNIT)
    2478. 

  2478.                         /* an empty Text element has been created. The */
    2479. 

  2479.                         /* following character data must go to that elem. */
    2480. 

  2480.                         HTMLcontext.mergeText = TRUE;
    2481. 

  2481.                     }
    2482. 

  2482.                 }
    2483. 

  2483.               if (pHTMLGIMapping[entry].XMLcontents != 'E')
    2484. 

  2484.                 {
    2485. 

  2485.                   if (StackLevel >= MaxStack - 1)
    2486. 

  2486.                     HTMLParseError (HTMLcontext.doc, "Too many nested elements", 0);
    2487. 

  2487.                   else
    2488. 

  2488.                     {
    2489. 

  2489.                       ElementStack[StackLevel] = el;
    2490. 

  2490.                       if (sameLevel)
    2491. 

  2491.                         ThotLevel[StackLevel] = ThotLevel[StackLevel - 1];
    2492. 

  2492.                       else
    2493. 

  2493.                         ThotLevel[StackLevel] = ThotLevel[StackLevel - 1] + 1;
    2494. 

  2494.                       LanguageStack[StackLevel] = HTMLcontext.language;
    2495. 

  2495.                       GINumberStack[StackLevel++] = entry;
    2496. 

  2496.                     }
    2497. 

  2497.                 }
    2498. 

  2498.             }
    2499. 

  2499.         }
    2500. 

  2500.     }
    2501. 

  2501. }
    2502. 

  2502. 

  2503. 

  2504. /*----------------------------------------------------------------------
    2505. 

  2505.   EndOfStartGI    An HTML GI has been read in a start tag.
    2506. 

  2506.   ----------------------------------------------------------------------*/
    2507. 

  2507. static void     EndOfStartGI (char c)
    2508. 

  2508. {
    2509. 

  2509.   char        schemaName[20];
    2510. 

  2510.   char        theGI[MaxMsgLength];
    2511. 

  2511.   char        *tagName;
    2512. 

  2512.   int	      i;
    2513. 

  2513. 

  2514.   if (HTMLcontext.parsingTextArea || HTMLcontext.parsingScript)
    2515. 

  2515.     /* We are parsing the contents of a TEXTAREA or SCRIPT element. If a start
    2516. 

  2516.        tag appears, consider it as plain text */
    2517. 

  2517.     {
    2518. 

  2518.       /* next state is state 0, not the state computed by the automaton */
    2519. 

  2519.       NormalTransition = FALSE;
    2520. 

  2520.       currentState = 0; 
    2521. 

  2521.       /* put a '<' and the tagname (GI) in the input buffer */
    2522. 

  2522.       for (i = LgBuffer; i > 0; i--)
    2523. 

  2523.         inputBuffer[i] = inputBuffer[i - 1];
    2524. 

  2524.       LgBuffer++;
    2525. 

  2525.       inputBuffer[0] = '<';
    2526. 

  2526.       inputBuffer[LgBuffer] = EOS;
    2527. 

  2527.       /* copy the input buffer in the document */
    2528. 

  2528.       TextToDocument ();
    2529. 

  2529.     }
    2530. 

  2530.   else
    2531. 

  2531.     {
    2532. 

  2532.       /* if the last character in the GI is a '/', ignore it.  This is to
    2533. 

  2533.          accept the XML syntax for empty elements, for instance <br/> */
    2534. 

  2534.       if (LgBuffer > 0 && inputBuffer[LgBuffer-1] == '/')
    2535. 

  2535.         LgBuffer--;
    2536. 

  2536.       CloseBuffer ();
    2537. 

  2537.       strncpy ((char *)theGI, (char *)inputBuffer, MaxMsgLength - 1);
    2538. 

  2538.       theGI[MaxMsgLength - 1] = EOS;
    2539. 

  2539. 

  2540.       InitBuffer ();
    2541. 

  2541.       if (HTMLcontext.lastElementClosed &&
    2542. 

  2542.           HTMLcontext.lastElement == rootElement)
    2543. 

  2543.         /* an element after the tag </html>, ignore it */
    2544. 

  2544.         {
    2545. 

  2545.           HTMLParseError (HTMLcontext.doc, "Element after tag </html>. Ignored", 0);
    2546. 

  2546.           return;
    2547. 

  2547.         }
    2548. 

  2548. 

  2549.       /* if it's a "math" or "svg" tag, it may have a namespace name */
    2550. 

  2550.       tagName = theGI;
    2551. 

  2551.       for (i = 0; theGI[i] != ':' && theGI[i] != EOS; i++);
    2552. 

  2552.       if (theGI[i] == ':' &&
    2553. 

  2553.           (strcasecmp ((char *)&theGI[i+1], "math") == 0 ||
    2554. 

  2554.            strcasecmp ((char *)&theGI[i+1], "svg") == 0))
    2555. 

  2555.         /* it's a math or svg tag with a namespace prefix. ignore the prefix */
    2556. 

  2556. 	tagName = &theGI[i+1];
    2557. 

  2557. 

  2558.       if (!strcmp (tagName, "math") || !strcmp (tagName, "svg"))
    2559. 

  2559.         /* a <math> or <svg> tag has been read */
    2560. 

  2560.         {
    2561. 

  2561.           /* get back to the beginning of the tag in the input buffer */
    2562. 

  2562.           /* "NotToReadFile" boolean means that we get back in the */
    2563. 

  2563.           /* previous input buffer */	
    2564. 

  2564.           /* That case happens when the "<" and ">" characters for that */
    2565. 

  2565.           /* tag have not been read in the same input buffer */
    2566. 

  2566.           if (StartOfTagIndx <= 0 ||
    2567. 

  2567.               (StartOfTagIndx > CurrentBufChar && CurrentBufChar != 0))
    2568. 

  2568.             {
    2569. 

  2569.               NumberOfCharRead = PreviousNumberOfCharRead;
    2570. 

  2570.               NumberOfLinesRead = PreviousNumberOfLinesRead;
    2571. 

  2571.               NotToReadFile = TRUE;
    2572. 

  2572.               if (StartOfTagIndx < 0)
    2573. 

  2573.                 CurrentBufChar = LastCharInPreviousRead;
    2574. 

  2574.               else
    2575. 

  2575.                 CurrentBufChar = StartOfTagIndx;
    2576. 

  2576.             }
    2577. 

  2577.           else
    2578. 

  2578.             CurrentBufChar = StartOfTagIndx;
    2579. 

  2579. 	  
    2580. 

  2580.           if (!strcmp ((char *)tagName, (char *)"math"))
    2581. 

  2581.             strcpy ((char *)schemaName, (char *)"MathML");
    2582. 

  2582.           else
    2583. 

  2583.             strcpy ((char *)schemaName, (char *)"SVG");
    2584. 

  2584.           /* Parse the corresponding element with the XML parser */
    2585. 

  2585.           if (!ParseIncludedXml ((FILE *)stream, &WorkBuffer, INPUT_FILE_BUFFER_SIZE,
    2586. 

  2586.                                  &EndOfHtmlFile, &NotToReadFile,
    2587. 

  2587.                                  PreviousRead, &LastCharInWorkBuffer,
    2588. 

  2588.                                  InputText, &CurrentBufChar,
    2589. 

  2589.                                  &NumberOfLinesRead, &NumberOfCharRead,
    2590. 

  2590.                                  schemaName, HTMLcontext.doc,
    2591. 

  2591.                                  &HTMLcontext.lastElement,
    2592. 

  2592.                                  &HTMLcontext.lastElementClosed,
    2593. 

  2593.                                  HTMLcontext.language))
    2594. 

  2594.             StopParsing (HTMLcontext.doc);   /* the XML parser raised an error */
    2595. 

  2595.           /* the whole element has been read by the XML parser */
    2596. 

  2596.           /* reset the automaton state */
    2597. 

  2597.           NormalTransition = FALSE;
    2598. 

  2598.           currentState = 0;
    2599. 

  2599.           CharProcessed = TRUE;
    2600. 

  2600.         }
    2601. 

  2601.       else
    2602. 

  2602.         ProcessStartGI (tagName);
    2603. 

  2603.     }
    2604. 

  2604. }
    2605. 

  2605. 

  2606. /*----------------------------------------------------------------------
    2607. 

  2607.   EndOfStartGIandTag      a ">" has been read. It indicates the
    2608. 

  2608.   end of a GI and the end of a start tag.
    2609. 

  2609.   ----------------------------------------------------------------------*/
    2610. 

  2610. static void EndOfStartGIandTag (char c)
    2611. 

  2611. {
    2612. 

  2612.   EndOfStartGI (c);
    2613. 

  2613.   EndOfStartTag (c);
    2614. 

  2614.   if (c == '<')
    2615. 

  2615.     {
    2616. 

  2616.       HTMLParseError (HTMLcontext.doc, "Syntax error", 0);
    2617. 

  2617.       StartOfTag (c);
    2618. 

  2618.     }
    2619. 

  2619. }
    2620. 

  2620. 

  2621. /*----------------------------------------------------------------------
    2622. 

  2622.   StartCData  a new CDATA element (<![CDATA[)
    2623. 

  2623.   ----------------------------------------------------------------------*/
    2624. 

  2624. static void StartCData (char c)
    2625. 

  2625. {
    2626. 

  2626.   ElementType         elType;
    2627. 

  2627.   Element             el, child;
    2628. 

  2628. 

  2629.   CloseBuffer ();
    2630. 

  2630.   if (!strcasecmp ((char *)inputBuffer, "cdata"))
    2631. 

  2631.     {
    2632. 

  2632.       elType.ElSSchema = DocumentSSchema;
    2633. 

  2633.       elType.ElTypeNum = HTML_EL_CDATA;
    2634. 

  2634.       el = TtaNewElement (HTMLcontext.doc, elType);
    2635. 

  2635.       TtaSetElementLineNumber (el, NumberOfLinesRead);
    2636. 

  2636.       InsertElement (&el);
    2637. 

  2637.       elType.ElTypeNum = HTML_EL_CDATA_line;
    2638. 

  2638.       child = TtaNewTree (HTMLcontext.doc, elType, "");
    2639. 

  2639.       TtaSetElementLineNumber (child, NumberOfLinesRead);
    2640. 

  2640.       TtaInsertFirstChild (&child, el, HTMLcontext.doc);
    2641. 

  2641.       HTMLcontext.lastElement = TtaGetFirstChild (child);
    2642. 

  2642.       /* clear the input buffer */
    2643. 

  2643.       InitBuffer ();
    2644. 

  2644.     }
    2645. 

  2645. }
    2646. 

  2646. 

  2647. /*----------------------------------------------------------------------
    2648. 

  2648.   CloseCDataLine closes a CDATA line.
    2649. 

  2649.   ----------------------------------------------------------------------*/
    2650. 

  2650. static void CloseCDataLine (char c)
    2651. 

  2651. {
    2652. 

  2652. 

  2653.   CloseBuffer ();
    2654. 

  2654.   if (LgBuffer > 0 && inputBuffer[LgBuffer-1] == EOL)
    2655. 

  2655.     {
    2656. 

  2656.       LgBuffer--;
    2657. 

  2657.       inputBuffer[LgBuffer] = EOS;
    2658. 

  2658.     }
    2659. 

  2659.   if (LgBuffer > 0 && inputBuffer[LgBuffer-1] == ']')
    2660. 

  2660.     {
    2661. 

  2661.       LgBuffer--;
    2662. 

  2662.       inputBuffer[LgBuffer] = EOS;
    2663. 

  2663.     }
    2664. 

  2664.   if (LgBuffer > 0 && inputBuffer[LgBuffer-1] == ']')
    2665. 

  2665.     {
    2666. 

  2666.       LgBuffer--;
    2667. 

  2667.       inputBuffer[LgBuffer] = EOS;
    2668. 

  2668.     }
    2669. 

  2669.   /* copy the input buffer into the document */
    2670. 

  2670.   if (LgBuffer)
    2671. 

  2671.     TtaAppendTextContent (HTMLcontext.lastElement, (unsigned char *)inputBuffer,
    2672. 

  2672.                           HTMLcontext.doc);
    2673. 

  2673.   /* clear the input buffer */
    2674. 

  2674.   InitBuffer ();
    2675. 

  2675. }
    2676. 

  2676. 

  2677. /*----------------------------------------------------------------------
    2678. 

  2678.   EndOfCDataLine closes a CDATA line.
    2679. 

  2679.   ----------------------------------------------------------------------*/
    2680. 

  2680. static void EndOfCDataLine (char c)
    2681. 

  2681. {
    2682. 

  2682.   ElementType         elType;
    2683. 

  2683.   Element             el, child;
    2684. 

  2684. 

  2685.   CloseCDataLine (c);
    2686. 

  2686.   /* start a new CDATA line */
    2687. 

  2687.   elType.ElSSchema = DocumentSSchema;
    2688. 

  2688.   elType.ElTypeNum = HTML_EL_CDATA_line;
    2689. 

  2689.   child = TtaNewTree (HTMLcontext.doc, elType, "");
    2690. 

  2690.   TtaSetElementLineNumber (child, NumberOfLinesRead);
    2691. 

  2691.   elType = TtaGetElementType (HTMLcontext.lastElement);
    2692. 

  2692.   if (elType.ElTypeNum == HTML_EL_TEXT_UNIT)
    2693. 

  2693.     el = TtaGetParent (HTMLcontext.lastElement);
    2694. 

  2694.   else
    2695. 

  2695.     el = HTMLcontext.lastElement;
    2696. 

  2696.   TtaInsertSibling (child, el, FALSE, HTMLcontext.doc);
    2697. 

  2697.   HTMLcontext.lastElement = TtaGetFirstChild (child);
    2698. 

  2698. }
    2699. 

  2699. 

  2700. /*----------------------------------------------------------------------
    2701. 

  2701.   EndOfCdata closes a CDATA.
    2702. 

  2702.   ----------------------------------------------------------------------*/
    2703. 

  2703. static void EndOfCData (char c)
    2704. 

  2704. {
    2705. 

  2705.   ElementType         elType;
    2706. 

  2706. 

  2707.   CloseCDataLine (c);
    2708. 

  2708.   HTMLcontext.lastElementClosed = TRUE;
    2709. 

  2709.   elType.ElSSchema = DocumentSSchema;
    2710. 

  2710.   elType.ElTypeNum = HTML_EL_CDATA;
    2711. 

  2711.   HTMLcontext.lastElement = TtaGetTypedAncestor (HTMLcontext.lastElement, elType);
    2712. 

  2712. }
    2713. 

  2713. 

  2714. /*----------------------------------------------------------------------
    2715. 

  2715.   EndOfEndTag     An end tag has been read in the HTML file.
    2716. 

  2716.   Terminate all corresponding Thot elements.
    2717. 

  2717.   ----------------------------------------------------------------------*/
    2718. 

  2718. static void EndOfEndTag (char c)
    2719. 

  2719. {
    2720. 

  2720.   SSchema	   schema;
    2721. 

  2721.   char            msgBuffer[MaxMsgLength];
    2722. 

  2722.   int             entry;
    2723. 

  2723.   int             i, profile;
    2724. 

  2724.   ThotBool        ok, removed;
    2725. 

  2725. 

  2726.   CloseBuffer ();
    2727. 

  2727.   if ((HTMLcontext.parsingTextArea &&
    2728. 

  2728.        strcasecmp ((char *)inputBuffer, "textarea")) ||
    2729. 

  2729.       (HTMLcontext.parsingScript &&
    2730. 

  2730.        strcasecmp ((char *)inputBuffer, "script")))
    2731. 

  2731.     /* We are parsing the contents of a textarea or script element. The end
    2732. 

  2732.        tag is not the one closing the current textarea or script, consider it
    2733. 

  2733.        as plain text */
    2734. 

  2734.     {
    2735. 

  2735.       /* next state is state 0, not the state computed by the automaton */
    2736. 

  2736.       NormalTransition = FALSE;
    2737. 

  2737.       currentState = 0;
    2738. 

  2738.       /* put "</" and the tag name in the input buffer */
    2739. 

  2739.       for (i = LgBuffer; i > 0; i--)
    2740. 

  2740.         inputBuffer[i + 1] = inputBuffer[i - 1];
    2741. 

  2741.       LgBuffer += 2;
    2742. 

  2742.       inputBuffer[0] = '<';
    2743. 

  2743.       inputBuffer[1] = '/';
    2744. 

  2744.       inputBuffer[LgBuffer] = EOS;
    2745. 

  2745.       /* copy the input buffer into the document */
    2746. 

  2746.       TextToDocument ();
    2747. 

  2747.     }
    2748. 

  2748.   else
    2749. 

  2749.     {
    2750. 

  2750.       /* is it the end of the current HTML fragment ? */
    2751. 

  2751.       ok = FALSE;
    2752. 

  2752.       if (HTMLrootClosingTag != EOS)
    2753. 

  2753.         {
    2754. 

  2754.           /* look for a colon in the element name (namespaces) and ignore the
    2755. 

  2755.              prefix if there is one */
    2756. 

  2756.           for (i = 0; i < LgBuffer && inputBuffer[i] != ':'; i++);
    2757. 

  2757.           if (inputBuffer[i] == ':')
    2758. 

  2758.             i++;
    2759. 

  2759.           else
    2760. 

  2760.             i = 0;
    2761. 

  2761.           if (strcasecmp ((char *)&inputBuffer[i], (char *)HTMLrootClosingTag) == 0)
    2762. 

  2762.             {
    2763. 

  2763.               HTMLrootClosed = TRUE;
    2764. 

  2764.               ok = TRUE;
    2765. 

  2765.             }
    2766. 

  2766.         }
    2767. 

  2767. 

  2768.       //if (!strcasecmp ((char *)inputBuffer, "font"))
    2769. 

  2769.       //             printf ("font element\n");
    2770. 

  2770.       profile = TtaGetDocumentProfile(HTMLcontext.doc);
    2771. 

  2771.       if (!ok)
    2772. 

  2772.         {
    2773. 

  2773.           /* search the HTML tag in the mapping table */
    2774. 

  2774.           schema = DocumentSSchema;
    2775. 

  2775.           entry = MapGI ((char *)inputBuffer, &schema, HTMLcontext.doc);
    2776. 

  2776.           if (entry < 0)
    2777. 

  2777.             {
    2778. 

  2778.               if (strlen ((char *)inputBuffer) > MaxMsgLength - 20)
    2779. 

  2779.                 inputBuffer[MaxMsgLength - 20] = EOS;
    2780. 

  2780.               if (DocumentMeta[HTMLcontext.doc] &&
    2781. 

  2781.                   DocumentMeta[HTMLcontext.doc]->xmlformat)
    2782. 

  2782.                 {
    2783. 

  2783.                   snprintf (msgBuffer, MaxMsgLength,
    2784. 

  2784. 			    "Invalid tag <%s> (removed when saving)", inputBuffer);
    2785. 

  2785.                   HTMLParseError (HTMLcontext.doc, msgBuffer, 0);
    2786. 

  2786.                   removed = TRUE;
    2787. 

  2787.                 }
    2788. 

  2788.               else
    2789. 

  2789.                 {
    2790. 

  2790.                   snprintf (msgBuffer, MaxMsgLength,
    2791. 

  2791. 			    "Warning - unknown tag </%s>", inputBuffer);
    2792. 

  2792.                   HTMLParseError (HTMLcontext.doc, msgBuffer, 0);
    2793. 

  2793.                   removed = FALSE;
    2794. 

  2794.                 }
    2795. 

  2795.               /* create an Invalid_element */
    2796. 

  2796.               snprintf (msgBuffer, MaxMsgLength, "</%s", inputBuffer);
    2797. 

  2797.               InsertInvalidEl (msgBuffer, removed);
    2798. 

  2798.             }
    2799. 

  2799.           else if (entry >= 0 &&
    2800. 

  2800.                    profile != L_Other &&
    2801. 

  2801.                    !(pHTMLGIMapping[entry].Level & profile)) 
    2802. 

  2802.             {
    2803. 

  2803.               /* Invalid element for the document profile */
    2804. 

  2804.               if (strlen ((char *)inputBuffer) > MaxMsgLength - 20)
    2805. 

  2805.                 inputBuffer[MaxMsgLength - 20] = EOS;
    2806. 

  2806.               snprintf (msgBuffer, MaxMsgLength,
    2807. 

  2807. 			"Invalid end element <%s> for the document profile",
    2808. 

  2808. 			inputBuffer);
    2809. 

  2809.               HTMLParseError (HTMLcontext.doc, msgBuffer, 0);
    2810. 

  2810.               XMLErrorsFoundInProfile = TRUE;
    2811. 

  2811.             }
    2812. 

  2812.           else if (!CloseElement (entry, -1, FALSE))
    2813. 

  2813.             /* the end tag does not close any current element */
    2814. 

  2814.             {
    2815. 

  2815.               if (DocumentMeta[HTMLcontext.doc] &&
    2816. 

  2816.                   DocumentMeta[HTMLcontext.doc]->xmlformat)
    2817. 

  2817.                 {
    2818. 

  2818.                   snprintf (msgBuffer, MaxMsgLength,
    2819. 

  2819. 			    "Invalid end tag <%s>", inputBuffer);
    2820. 

  2820.                   HTMLParseError (HTMLcontext.doc, msgBuffer, 0);
    2821. 

  2821.                 }
    2822. 

  2822.               else
    2823. 

  2823.                 {
    2824. 

  2824.                   /* try to recover */
    2825. 

  2825.                   if ((inputBuffer[0] == 'H' || inputBuffer[0] == 'h') &&
    2826. 

  2826.                       inputBuffer[1] >= '1' && inputBuffer[1] <= '6' &&
    2827. 

  2827.                       inputBuffer[2] == EOS)
    2828. 

  2828.                     /* the end tag is </Hn>. Consider all Hn as equivalent. */
    2829. 

  2829.                     /* </H3> is considered as an end tag for <H2>, for instance */
    2830. 

  2830.                     {
    2831. 

  2831.                       strcpy ((char *)msgBuffer, (char *)inputBuffer);
    2832. 

  2832.                       msgBuffer[1] = '1';
    2833. 

  2833.                       i = 1;
    2834. 

  2834.                       do
    2835. 

  2835.                         {
    2836. 

  2836.                           schema = DocumentSSchema;
    2837. 

  2837.                           entry = MapGI ((char *)msgBuffer, &schema, HTMLcontext.doc);
    2838. 

  2838.                           ok = CloseElement (entry, -1, FALSE);
    2839. 

  2839.                           msgBuffer[1]++;
    2840. 

  2840.                           i++;
    2841. 

  2841.                         }
    2842. 

  2842.                       while (i <= 6 && !ok);
    2843. 

  2843.                     }
    2844. 

  2844.                   if (!ok &&
    2845. 

  2845.                       (!strcasecmp ((char *)inputBuffer, "ol")   ||
    2846. 

  2846.                        !strcasecmp ((char *)inputBuffer, "ul")   ||
    2847. 

  2847.                        !strcasecmp ((char *)inputBuffer, "menu") ||
    2848. 

  2848.                        !strcasecmp ((char *)inputBuffer, "dir")))
    2849. 

  2849.                     /* the end tag is supposed to close a list */
    2850. 

  2850.                     /* try to close another type of list */
    2851. 

  2851.                     {
    2852. 

  2852.                       ok = TRUE;
    2853. 

  2853.                       schema = DocumentSSchema;
    2854. 

  2854.                       if (!CloseElement (MapGI ((char *)"ol", &schema, HTMLcontext.doc), -1, FALSE) &&
    2855. 

  2855.                           !CloseElement (MapGI ((char *)"ul", &schema, HTMLcontext.doc), -1, FALSE) &&
    2856. 

  2856.                           !CloseElement (MapGI ((char *)"menu", &schema, HTMLcontext.doc), -1, FALSE) &&
    2857. 

  2857.                           !CloseElement (MapGI ((char *)"dir", &schema, HTMLcontext.doc), -1, FALSE))
    2858. 

  2858.                         ok = FALSE;
    2859. 

  2859.                     }
    2860. 

  2860.                   if (!ok)
    2861. 

  2861.                     /* unrecoverable error. Create an Invalid_element */
    2862. 

  2862.                     {
    2863. 

  2863.                       snprintf (msgBuffer, MaxMsgLength, "</%s", inputBuffer);
    2864. 

  2864.                       InsertInvalidEl (msgBuffer, TRUE);
    2865. 

  2865.                       /* print an error message... */
    2866. 

  2866.                       snprintf (msgBuffer, MaxMsgLength,
    2867. 

  2867. 				"Invalid end tag </%s> (removed when saving)",
    2868. 

  2868.                                inputBuffer);
    2869. 

  2869.                     }
    2870. 

  2870.                   else
    2871. 

  2871.                     /* print an error message... */
    2872. 

  2872.                     snprintf (msgBuffer, MaxMsgLength,
    2873. 

  2873. 			      "Warning - unexpected end tag </%s>",
    2874. 

  2874. 			      inputBuffer);
    2875. 

  2875.                   HTMLParseError (HTMLcontext.doc, msgBuffer, 0);
    2876. 

  2876.                 }
    2877. 

  2877.             }
    2878. 

  2878.         }
    2879. 

  2879.       InitBuffer ();
    2880. 

  2880.     }
    2881. 

  2881. 

  2882.   if (c == '<')
    2883. 

  2883.     {
    2884. 

  2884.       HTMLParseError (HTMLcontext.doc, "Syntax error", 0);
    2885. 

  2885.       StartOfTag (c);
    2886. 

  2886.     }
    2887. 

  2887. }
    2888. 

  2888. 

  2889. /*----------------------------------------------------------------------
    2890. 

  2890.   EndOfAttrName   A HTML attribute has been read. Create the
    2891. 

  2891.   corresponding Thot attribute.
    2892. 

  2892.   ----------------------------------------------------------------------*/
    2893. 

  2893. static void EndOfAttrName (char c)
    2894. 

  2894. {
    2895. 

  2895.   AttributeMapping*   tableEntry;
    2896. 

  2896.   AttributeType       attrType;
    2897. 

  2897.   Element             elText;
    2898. 

  2898.   ElementType         elType;
    2899. 

  2899.   Attribute           attr;
    2900. 

  2900.   SSchema             schema;
    2901. 

  2901.   char                translation;
    2902. 

  2902.   char                msgBuffer[MaxMsgLength];
    2903. 

  2903.   ThotBool            highEnoughLevel;
    2904. 

  2904. 

  2905.   CloseBuffer ();
    2906. 

  2906.   if (UnknownTag && HTMLcontext.lastElement)
    2907. 

  2907.     {
    2908. 

  2908.       elType = TtaGetElementType (HTMLcontext.lastElement);
    2909. 

  2909.       if (elType.ElTypeNum == HTML_EL_Invalid_element ||
    2910. 

  2910.           elType.ElTypeNum == HTML_EL_Unknown_namespace)
    2911. 

  2911.         {
    2912. 

  2912.           elText = TtaGetLastChild (HTMLcontext.lastElement);
    2913. 

  2913.           TtaAppendTextContent (elText, (unsigned char *)" ", HTMLcontext.doc);
    2914. 

  2914.           TtaAppendTextContent (elText, (unsigned char *)inputBuffer,
    2915. 

  2915.                                 HTMLcontext.doc);
    2916. 

  2916.         }
    2917. 

  2917.       InitBuffer ();
    2918. 

  2918.       lastAttrEntry = NULL;
    2919. 

  2919.       return;
    2920. 

  2920.     }
    2921. 

  2921. 

  2922.   /* if a single '/' or '?' has been read instead of an attribute name, ignore
    2923. 

  2923.      that character.  This is to accept the XML syntax for empty elements or
    2924. 

  2924.      processing instructions, such as <img src="SomeUrl" /> or
    2925. 

  2925.      <?xml version="1.0"?>  */
    2926. 

  2926.   if (LgBuffer == 1 &&
    2927. 

  2927.       (inputBuffer[0] == '/' || inputBuffer[0] == '?'))
    2928. 

  2928.     {
    2929. 

  2929.       InitBuffer ();
    2930. 

  2930.       return;
    2931. 

  2931.     }
    2932. 

  2932. 

  2933.   highEnoughLevel = TRUE;
    2934. 

  2934.   /* inputBuffer contains the attribute name */
    2935. 

  2935.   /* get the corresponding Thot attribute */
    2936. 

  2936.   if (UnknownTag)
    2937. 

  2937.     /* ignore attributes of unknown tags */
    2938. 

  2938.     tableEntry = NULL;
    2939. 

  2939.   else
    2940. 

  2940.     tableEntry = MapAttr ((char *)inputBuffer, &schema,
    2941. 

  2941.                           lastElemEntry, &highEnoughLevel, HTMLcontext.doc);
    2942. 

  2942. 

  2943.   if (tableEntry)
    2944. 

  2944.     /* this is a known attribute. Can it be associated with the current
    2945. 

  2945.        element ? */
    2946. 

  2946.     {
    2947. 

  2947.       /* reject attribute height on a table */
    2948. 

  2948.       if (tableEntry->ThotAttribute == HTML_ATTR_Height_)
    2949. 

  2949.         {
    2950. 

  2950.           elType = TtaGetElementType (HTMLcontext.lastElement);
    2951. 

  2951.           if (elType.ElTypeNum == HTML_EL_Table_)
    2952. 

  2952.             tableEntry = NULL;
    2953. 

  2953.         }
    2954. 

  2954.       else if (tableEntry->ThotAttribute == HTML_ATTR_xmlid)
    2955. 

  2955.         {
    2956. 

  2956.           snprintf (msgBuffer, MaxMsgLength,
    2957. 

  2957. 		   "Invalid attribute \"%s\"(removed when saving)",
    2958. 

  2958. 		   inputBuffer);
    2959. 

  2959.           HTMLParseError (HTMLcontext.doc, msgBuffer, 0);
    2960. 

  2960.           /* attach an Invalid_attribute to the current element */
    2961. 

  2961.           tableEntry = &pHTMLAttributeMapping[0];
    2962. 

  2962.           schema = DocumentSSchema;
    2963. 

  2963.           UnknownAttr = TRUE;
    2964. 

  2964.         }
    2965. 

  2965.     }
    2966. 

  2966.    
    2967. 

  2967.   if (!tableEntry)
    2968. 

  2968.     {
    2969. 

  2969.       if (highEnoughLevel)
    2970. 

  2970.         {
    2971. 

  2971.           /* this attribute is not in the HTML mapping table */
    2972. 

  2972.           if (strcasecmp ((char *)inputBuffer, "xmlns") == 0 ||
    2973. 

  2973.               strncasecmp ((char *)inputBuffer, "xmlns:", 6) == 0)
    2974. 

  2974.             /* this is a namespace declaration */
    2975. 

  2975.             {
    2976. 

  2976.               lastAttrEntry = NULL;
    2977. 

  2977.               /**** register this namespace ****/;
    2978. 

  2978.             }
    2979. 

  2979.           //else if (strcasecmp ((char *)inputBuffer, "xml:lang") == 0)
    2980. 

  2980.           /* attribute xml:lang is not considered as invalid, but it is
    2981. 

  2981.              ignored */
    2982. 

  2982.           //  lastAttrEntry = NULL;
    2983. 

  2983.           else
    2984. 

  2984.             {
    2985. 

  2985.               snprintf (msgBuffer, MaxMsgLength,
    2986. 

  2986. 			"Invalid attribute \"%s\"(removed when saving)",
    2987. 

  2987. 			inputBuffer);
    2988. 

  2988.               HTMLParseError (HTMLcontext.doc, msgBuffer, 0);
    2989. 

  2989.               /* attach an Invalid_attribute to the current element */
    2990. 

  2990.               tableEntry = &pHTMLAttributeMapping[0];
    2991. 

  2991.               schema = DocumentSSchema;
    2992. 

  2992.               UnknownAttr = TRUE;
    2993. 

  2993.             }
    2994. 

  2994.         }
    2995. 

  2995.       else
    2996. 

  2996.         {
    2997. 

  2997.           /* attribute invalid for the document profile */
    2998. 

  2998.           snprintf (msgBuffer, MaxMsgLength,
    2999. 

  2999.                    "Invalid attribute \"%s\" for the document profile",
    3000. 

  3000.                    inputBuffer);
    3001. 

  3001.           HTMLParseError (HTMLcontext.doc, msgBuffer, 0);
    3002. 

  3002.           XMLErrorsFoundInProfile = TRUE;
    3003. 

  3003.           UnknownAttr = TRUE;
    3004. 

  3004.           lastAttrEntry = NULL;
    3005. 

  3005.         }
    3006. 

  3006.     }
    3007. 

  3007.   else
    3008. 

  3008.     UnknownAttr = FALSE;
    3009. 

  3009. 

  3010.   if (tableEntry != NULL && HTMLcontext.lastElement != NULL &&
    3011. 

  3011.       (!HTMLcontext.lastElementClosed ||
    3012. 

  3012.        (HTMLcontext.lastElement != rootElement)))
    3013. 

  3013.     {
    3014. 

  3014.       lastAttrEntry = tableEntry;
    3015. 

  3015.       translation = lastAttrEntry->AttrOrContent;
    3016. 

  3016.       switch (translation)
    3017. 

  3017.         {
    3018. 

  3018.         case 'C':	/* Content */
    3019. 

  3019.           /* Nothing to do yet: wait for attribute value */
    3020. 

  3020.           break;
    3021. 

  3021.         case 'A':
    3022. 

  3022.           /* create an attribute for current element */
    3023. 

  3023.           attrType.AttrSSchema = schema;
    3024. 

  3024.           attrType.AttrTypeNum = tableEntry->ThotAttribute;
    3025. 

  3025.           CreateHTMLAttribute (HTMLcontext.lastElement, attrType, (char *)inputBuffer, 
    3026. 

  3026.                                (ThotBool)(tableEntry == &pHTMLAttributeMapping[0]),
    3027. 

  3027.                                HTMLcontext.doc, &lastAttribute, &lastAttrElement);
    3028. 

  3028.           if (attrType.AttrTypeNum == HTML_ATTR_HREF_)
    3029. 

  3029.             {
    3030. 

  3030.               elType = TtaGetElementType (HTMLcontext.lastElement);
    3031. 

  3031.               if (elType.ElTypeNum == HTML_EL_Anchor)
    3032. 

  3032.                 /* attribute HREF for element Anchor */
    3033. 

  3033.                 /* create attribute PseudoClass = link */
    3034. 

  3034.                 {
    3035. 

  3035.                   attrType.AttrTypeNum = HTML_ATTR_PseudoClass;
    3036. 

  3036.                   attr = TtaNewAttribute (attrType);
    3037. 

  3037.                   TtaAttachAttribute (HTMLcontext.lastElement, attr,
    3038. 

  3038.                                       HTMLcontext.doc);
    3039. 

  3039.                   TtaSetAttributeText (attr, "link",
    3040. 

  3040.                                        HTMLcontext.lastElement,
    3041. 

  3041.                                        HTMLcontext.doc);
    3042. 

  3042.                 }
    3043. 

  3043.             }
    3044. 

  3044.           else if (attrType.AttrTypeNum == HTML_ATTR_Checked)
    3045. 

  3045.             {
    3046. 

  3046.               /* create Default-Checked attribute */
    3047. 

  3047.               attrType.AttrSSchema = DocumentSSchema;
    3048. 

  3048.               attrType.AttrTypeNum = HTML_ATTR_DefaultChecked;
    3049. 

  3049.               attr = TtaNewAttribute (attrType);
    3050. 

  3050.               TtaAttachAttribute (HTMLcontext.lastElement, attr,
    3051. 

  3051.                                   HTMLcontext.doc);
    3052. 

  3052.               TtaSetAttributeValue (attr, HTML_ATTR_DefaultChecked_VAL_Yes_,
    3053. 

  3053.                                     HTMLcontext.lastElement, HTMLcontext.doc);
    3054. 

  3054.             }
    3055. 

  3055.           else if (attrType.AttrTypeNum == HTML_ATTR_Selected)
    3056. 

  3056.             {
    3057. 

  3057.               /* create Default-Selected attribute */
    3058. 

  3058.               attrType.AttrSSchema = DocumentSSchema;
    3059. 

  3059.               attrType.AttrTypeNum = HTML_ATTR_DefaultSelected;
    3060. 

  3060.               attr = TtaNewAttribute (attrType);
    3061. 

  3061.               TtaAttachAttribute (HTMLcontext.lastElement, attr,
    3062. 

  3062.                                   HTMLcontext.doc);
    3063. 

  3063.               TtaSetAttributeValue (attr, HTML_ATTR_DefaultSelected_VAL_Yes_,
    3064. 

  3064.                                     HTMLcontext.lastElement, HTMLcontext.doc);
    3065. 

  3065.             }
    3066. 

  3066.           break;
    3067. 

  3067.         case SPACE:
    3068. 

  3068.           /* nothing to do */
    3069. 

  3069.           break;
    3070. 

  3070.         default:
    3071. 

  3071.           break;
    3072. 

  3072.         }
    3073. 

  3073.     }
    3074. 

  3074.   InitBuffer ();
    3075. 

  3075. }
    3076. 

  3076. 

  3077. 

  3078. /*----------------------------------------------------------------------
    3079. 

  3079.   EndOfAttrNameAndTag     A ">" has been read. It indicates the
    3080. 

  3080.   end of an attribute name and the end of a start tag.
    3081. 

  3081.   ----------------------------------------------------------------------*/
    3082. 

  3082. static void         EndOfAttrNameAndTag (char c)
    3083. 

  3083. {
    3084. 

  3084.   EndOfAttrName (c);
    3085. 

  3085.   EndOfStartTag (c);
    3086. 

  3086.   if (c == '<')
    3087. 

  3087.     {
    3088. 

  3088.       HTMLParseError (HTMLcontext.doc, "Syntax error", 0);
    3089. 

  3089.       StartOfTag (c);
    3090. 

  3090.     }
    3091. 

  3091. }
    3092. 

  3092. 

  3093. /*----------------------------------------------------------------------
    3094. 

  3094.   StartOfQuotedAttrValue
    3095. 

  3095.   A quote (or double quote) starting an attribute value has been read.
    3096. 

  3096.   ----------------------------------------------------------------------*/
    3097. 

  3097. static void StartOfQuotedAttrValue (char c)
    3098. 

  3098. {
    3099. 

  3099.   ReadingAnAttrValue = TRUE;
    3100. 

  3100.   if (UnknownAttr)
    3101. 

  3101.     /* this is the value of an unknown attribute. keep the quote */
    3102. 

  3102.     /* in the input buffer for copying it in the current */
    3103. 

  3103.     /* Invalid_attribute */
    3104. 

  3104.     PutInBuffer (c);
    3105. 

  3105. }
    3106. 

  3106. 

  3107. /*----------------------------------------------------------------------
    3108. 

  3108.   StartOfUnquotedAttrValue
    3109. 

  3109.   The first character of an unquoted attribute value has been read.
    3110. 

  3110.   ----------------------------------------------------------------------*/
    3111. 

  3111. static void         StartOfUnquotedAttrValue (char c)
    3112. 

  3112. {
    3113. 

  3113.   ReadingAnAttrValue = TRUE;
    3114. 

  3114.   PutInBuffer (c);
    3115. 

  3115. }
    3116. 

  3116. 

  3117. static ThotBool   isAttrValueTruncated;
    3118. 

  3118. /*----------------------------------------------------------------------
    3119. 

  3119.   EndOfAttrValue
    3120. 

  3120.   An attribute value has been read from the HTML file.
    3121. 

  3121.   Put that value in the current Thot attribute.
    3122. 

  3122.   ----------------------------------------------------------------------*/
    3123. 

  3123. static void         EndOfAttrValue (char c)
    3124. 

  3124. {
    3125. 

  3125.   Element             elText;
    3126. 

  3126.   ElementType         elType;
    3127. 

  3127.   char               *newBufferAttrValue;
    3128. 

  3128.   int                 lg;
    3129. 

  3129. 

  3130.   if (TruncatedAttrValue)
    3131. 

  3131.     {
    3132. 

  3132.       isAttrValueTruncated = TRUE;
    3133. 

  3133.       if (BufferAttrValue == NULL)
    3134. 

  3134.         {
    3135. 

  3135.           lg = 2 * MaxBufferLength;
    3136. 

  3136.           BufferAttrValue = (char*)TtaGetMemory (lg + 1);
    3137. 

  3137.           strcpy ((char *)BufferAttrValue, (char *)inputBuffer);
    3138. 

  3138.           LgBufferAttrValue = lg;
    3139. 

  3139.         }
    3140. 

  3140.       else
    3141. 

  3141.         {
    3142. 

  3142.           LgBufferAttrValue += MaxBufferLength;
    3143. 

  3143.           newBufferAttrValue = (char*)TtaGetMemory (LgBufferAttrValue + 1);
    3144. 

  3144.           strcpy ((char *)newBufferAttrValue, (char *)BufferAttrValue);
    3145. 

  3145.           strcat ((char *)newBufferAttrValue, (char *)inputBuffer);
    3146. 

  3146.           TtaFreeMemory (BufferAttrValue);
    3147. 

  3147.           BufferAttrValue = newBufferAttrValue;
    3148. 

  3148.         }
    3149. 

  3149.     }
    3150. 

  3150.   else
    3151. 

  3151.     {
    3152. 

  3152.       ReadingAnAttrValue = FALSE;
    3153. 

  3153.       if (UnknownAttr)
    3154. 

  3154.         /* this is the end of value of an invalid attribute. Keep the */
    3155. 

  3155.         /* quote character that ends the value for copying it into the */
    3156. 

  3156.         /* Invalid_attribute. */
    3157. 

  3157.         if (c == '\'' || c == '\"')
    3158. 

  3158.           PutInBuffer (c);
    3159. 

  3159.       CloseBuffer ();
    3160. 

  3160.       /* inputBuffer contains the attribute value */
    3161. 

  3161.       
    3162. 

  3162.       if (UnknownTag && HTMLcontext.lastElement)
    3163. 

  3163.         {
    3164. 

  3164.           elType = TtaGetElementType (HTMLcontext.lastElement);
    3165. 

  3165.           if (elType.ElTypeNum == HTML_EL_Invalid_element ||
    3166. 

  3166.               elType.ElTypeNum == HTML_EL_Unknown_namespace)
    3167. 

  3167.             {
    3168. 

  3168.               elText = TtaGetLastChild (HTMLcontext.lastElement);
    3169. 

  3169.               TtaAppendTextContent (elText, (unsigned char *)"=",
    3170. 

  3170.                                     HTMLcontext.doc);
    3171. 

  3171.               TtaAppendTextContent (elText, (unsigned char *)inputBuffer,
    3172. 

  3172.                                     HTMLcontext.doc);
    3173. 

  3173.             }
    3174. 

  3174.           InitBuffer ();
    3175. 

  3175.           lastAttrEntry = NULL;
    3176. 

  3176.           return;
    3177. 

  3177.         }
    3178. 

  3178.       if (lastAttrEntry == NULL)
    3179. 

  3179.         {
    3180. 

  3180.           InitBuffer ();
    3181. 

  3181.           return;
    3182. 

  3182.         }
    3183. 

  3183.       
    3184. 

  3184.       if (HTMLcontext.lastElementClosed &&
    3185. 

  3185.           (HTMLcontext.lastElement == rootElement))
    3186. 

  3186.         {
    3187. 

  3187.           /* an attribute after the tag </html>, ignore it */
    3188. 

  3188.         }
    3189. 

  3189.       else
    3190. 

  3190.         {
    3191. 

  3191.           if (isAttrValueTruncated)
    3192. 

  3192.             {
    3193. 

  3193.               strcat ((char *)BufferAttrValue, (char *)inputBuffer);
    3194. 

  3194.               EndOfHTMLAttributeValue (BufferAttrValue, lastAttrEntry,
    3195. 

  3195.                                        lastAttribute, lastAttrElement,
    3196. 

  3196.                                        UnknownAttr, &HTMLcontext,
    3197. 

  3197.                                        FALSE/*HTML parser*/);
    3198. 

  3198.               TtaFreeMemory (BufferAttrValue);
    3199. 

  3199.               BufferAttrValue = NULL;
    3200. 

  3200.               LgBufferAttrValue = 0;
    3201. 

  3201.               isAttrValueTruncated = FALSE;
    3202. 

  3202.             }
    3203. 

  3203.           else
    3204. 

  3204.             {
    3205. 

  3205.               EndOfHTMLAttributeValue ((char *)inputBuffer, lastAttrEntry, lastAttribute,
    3206. 

  3206.                                        lastAttrElement, UnknownAttr, &HTMLcontext,
    3207. 

  3207.                                        FALSE/*HTML parser*/);
    3208. 

  3208.             }
    3209. 

  3209.         }
    3210. 

  3210.       
    3211. 

  3211.       InitBuffer ();
    3212. 

  3212.     }
    3213. 

  3213. }
    3214. 

  3214. 

  3215. /*----------------------------------------------------------------------
    3216. 

  3216.   EndOfAttrValueAndTag    A ">" has been read. It indicates the
    3217. 

  3217.   end of an attribute value and the end of a start tag.
    3218. 

  3218.   ----------------------------------------------------------------------*/
    3219. 

  3219. static void EndOfAttrValueAndTag (char c)
    3220. 

  3220. {
    3221. 

  3221.   EndOfAttrValue (c);
    3222. 

  3222.   EndOfStartTag (c);
    3223. 

  3223. }
    3224. 

  3224. 

  3225. /*----------------------------------------------------------------------
    3226. 

  3226.   StartOfEntity   A character '&' has been encountered in the text.
    3227. 

  3227.   ----------------------------------------------------------------------*/
    3228. 

  3228. static void StartOfEntity (char c)
    3229. 

  3229. {
    3230. 

  3230.   LgEntityName = 0;
    3231. 

  3231.   EntityTableEntry = 0;
    3232. 

  3232.   CharRank = 0;
    3233. 

  3233. }
    3234. 

  3234. 

  3235. /*----------------------------------------------------------------------
    3236. 

  3236.   GetFallbackCharacter
    3237. 

  3237.   Parameter lang gives the language of the enclosing element.
    3238. 

  3238.   Returns the fallback string and the language.
    3239. 

  3239.   ----------------------------------------------------------------------*/
    3240. 

  3240. void GetFallbackCharacter (int code, unsigned char *fallback, Language *lang)
    3241. 

  3241. {  
    3242. 

  3242.   unsigned char *ptr;
    3243. 

  3243.   int	         i;
    3244. 

  3244. 

  3245.   fallback[0] = EOS;
    3246. 

  3246.   fallback[1] = EOS;
    3247. 

  3247.   fallback[2] = EOS;
    3248. 

  3248.   /* get the UTF-8 string of the unicode character */
    3249. 

  3249.   ptr = fallback;
    3250. 

  3250.   i = TtaWCToMBstring ((wchar_t) code, &ptr);
    3251. 

  3251.   fallback[i] = EOS;
    3252. 

  3252. }
    3253. 

  3253. 

  3254. 

  3255. #ifdef LC
    3256. 

  3256. /*----------------------------------------------------------------------
    3257. 

  3257.   PutAmpersandInDoc
    3258. 

  3258.   Put an '&' character in the document tree with an attribute
    3259. 

  3259.   IntEntity.
    3260. 

  3260.   ----------------------------------------------------------------------*/
    3261. 

  3261. static void PutAmpersandInDoc ()
    3262. 

  3262. {
    3263. 

  3263.   ElementType      elType;
    3264. 

  3264.   Element          elText;
    3265. 

  3265.   AttributeType    attrType;
    3266. 

  3266.   Attribute        attr;
    3267. 

  3267. 

  3268.   TextToDocument ();
    3269. 

  3269.   /* create a TEXT element for '&'*/
    3270. 

  3270.   elType.ElSSchema = DocumentSSchema;
    3271. 

  3271.   elType.ElTypeNum = HTML_EL_TEXT_UNIT;
    3272. 

  3272.   elText = TtaNewElement (HTMLcontext.doc, elType);
    3273. 

  3273.   TtaSetElementLineNumber (elText, NumberOfLinesRead);
    3274. 

  3274.   InsertElement (&elText);
    3275. 

  3275.   HTMLcontext.lastElementClosed = TRUE;
    3276. 

  3276.   HTMLcontext.mergeText = FALSE;
    3277. 

  3277.   TtaSetTextContent (elText, (unsigned char *)"&", HTMLcontext.language, HTMLcontext.doc);
    3278. 

  3278.   attrType.AttrSSchema = DocumentSSchema;
    3279. 

  3279.   attrType.AttrTypeNum = HTML_ATTR_IntEntity;
    3280. 

  3280.   attr = TtaNewAttribute (attrType);
    3281. 

  3281.   TtaAttachAttribute (elText, attr, HTMLcontext.doc);
    3282. 

  3282.   TtaSetAttributeValue (attr, HTML_ATTR_IntEntity_VAL_Yes_, elText, HTMLcontext.doc);
    3283. 

  3283. }
    3284. 

  3284. #endif /* LC */
    3285. 

  3285. 

  3286. /*----------------------------------------------------------------------
    3287. 

  3287.   EndOfEntity     End of a HTML entity. Search that entity in the
    3288. 

  3288.   entity table and put the corresponding character in the input buffer.
    3289. 

  3289.   ----------------------------------------------------------------------*/
    3290. 

  3290. static void EndOfEntity (unsigned char c)
    3291. 

  3291. {
    3292. 

  3292.   unsigned char fallback[7], *ptr;
    3293. 

  3293.   int           len;
    3294. 

  3294.   int           i;
    3295. 

  3295.   unsigned char msgBuffer[MaxMsgLength];
    3296. 

  3296. 

  3297.   EntityName[LgEntityName] = EOS;
    3298. 

  3298.   if (XhtmlEntityTable[EntityTableEntry].charName[CharRank] == EOS)
    3299. 

  3299.     {
    3300. 

  3300.       /* the entity read matches the current entry of entity table */
    3301. 

  3301.       if (XhtmlEntityTable[EntityTableEntry].charCode > 127)
    3302. 

  3302.         {
    3303. 

  3303.           /* generate the UTF-8 string */
    3304. 

  3304.           ptr = fallback;
    3305. 

  3305.           len = TtaWCToMBstring ((wchar_t) (XhtmlEntityTable[EntityTableEntry].charCode), &ptr);
    3306. 

  3306.           for (i = 0; i < len; i++)
    3307. 

  3307.             PutInBuffer (fallback[i]);
    3308. 

  3308.         }
    3309. 

  3309.       else
    3310. 

  3310.         PutInBuffer ((char)XhtmlEntityTable[EntityTableEntry].charCode);
    3311. 

  3311.     }
    3312. 

  3312.   else
    3313. 

  3313.     {
    3314. 

  3314.       /* entity not in the table. Print an error message */
    3315. 

  3315.       PutInBuffer ('&');
    3316. 

  3316.       for (i = 0; i < LgEntityName; i++)
    3317. 

  3317.         PutInBuffer (EntityName[i]);
    3318. 

  3318.       PutInBuffer (';');
    3319. 

  3319.       /* print an error message */
    3320. 

  3320.       sprintf ((char *)msgBuffer, "Unknown entity");
    3321. 

  3321.       HTMLParseError (HTMLcontext.doc, (char *)msgBuffer, 0);
    3322. 

  3322.     }
    3323. 

  3323.   LgEntityName = 0;
    3324. 

  3324. }
    3325. 

  3325. 

  3326. /*----------------------------------------------------------------------
    3327. 

  3327.   EntityChar      A character belonging to a HTML entity has been
    3328. 

  3328.   read.
    3329. 

  3329.   ----------------------------------------------------------------------*/
    3330. 

  3330. static void EntityChar (unsigned char c)
    3331. 

  3331. {
    3332. 

  3332.   unsigned char fallback[7], *ptr;
    3333. 

  3333.   int           len;
    3334. 

  3334.   unsigned char msgBuffer[MaxMsgLength];
    3335. 

  3335.   int           i;
    3336. 

  3336.   ThotBool      OK, done, stop;
    3337. 

  3337. 

  3338.   done = FALSE;
    3339. 

  3339.   if (XhtmlEntityTable[EntityTableEntry].charName[CharRank] == EOS)
    3340. 

  3340.     /* the entity name read so far matches the current entry of */
    3341. 

  3341.     /* entity table */
    3342. 

  3342.     /* does it also match the next entry? */
    3343. 

  3343.     {
    3344. 

  3344.       OK = FALSE;
    3345. 

  3345.       i = EntityTableEntry+1;
    3346. 

  3346.       stop = FALSE;
    3347. 

  3347.       do
    3348. 

  3348.         {
    3349. 

  3349.           if (strncmp (EntityName, XhtmlEntityTable[i].charName, LgEntityName) != 0)
    3350. 

  3350.             stop = TRUE;
    3351. 

  3351.           else if (XhtmlEntityTable[i].charName[CharRank] < c)
    3352. 

  3352.             i++;
    3353. 

  3353.           else
    3354. 

  3354.             {
    3355. 

  3355.               stop = TRUE;
    3356. 

  3356.               if (XhtmlEntityTable[i].charName[CharRank] == c)
    3357. 

  3357.                 OK = TRUE;
    3358. 

  3358.             }
    3359. 

  3359.         }
    3360. 

  3360.       while (!stop);     
    3361. 

  3361.       if (!OK &&
    3362. 

  3362.           (c == SPACE || c == EOL || c == TAB || c == __CR__))
    3363. 

  3363.         {
    3364. 

  3364.           /* If we are not reading an attribute value, assume that semicolon is
    3365. 

  3365.              missing and put the corresponding char in the document content */
    3366. 

  3366.           EntityName[LgEntityName] = EOS;
    3367. 

  3367.           if (XhtmlEntityTable[EntityTableEntry].charCode > 127)
    3368. 

  3368.             {
    3369. 

  3369.               /* generate the UTF-8 string */
    3370. 

  3370.               ptr = fallback;
    3371. 

  3371.               len = TtaWCToMBstring ((wchar_t) (XhtmlEntityTable[EntityTableEntry].charCode), &ptr);
    3372. 

  3372.               for (i = 0; i < len; i++)
    3373. 

  3373.                 PutInBuffer (fallback[i]);
    3374. 

  3374.             }
    3375. 

  3375.           else
    3376. 

  3376.             PutInBuffer ((char)(XhtmlEntityTable[EntityTableEntry].charCode));
    3377. 

  3377.           if (c != SPACE)
    3378. 

  3378.             /* print an error message */
    3379. 

  3379.             HTMLParseError (HTMLcontext.doc, "Missing semicolon", 0);
    3380. 

  3380.           /* next state is the return state from the entity subautomaton, not
    3381. 

  3381.              the state computed by the automaton. In addition the character read
    3382. 

  3382.              has not been processed yet */
    3383. 

  3383.           NormalTransition = FALSE;
    3384. 

  3384.           currentState = returnState;
    3385. 

  3385.           /* end of entity */
    3386. 

  3386.           LgEntityName = 0;
    3387. 

  3387.           done = TRUE;
    3388. 

  3388.         }
    3389. 

  3389.     }
    3390. 

  3390.   
    3391. 

  3391.   if (!done)
    3392. 

  3392.     {
    3393. 

  3393.       while (XhtmlEntityTable[EntityTableEntry].charName[CharRank] < c
    3394. 

  3394.              && XhtmlEntityTable[EntityTableEntry].charCode != 0)
    3395. 

  3395.         EntityTableEntry++;
    3396. 

  3396.       if (XhtmlEntityTable[EntityTableEntry].charName[CharRank] != c)
    3397. 

  3397.         OK = FALSE;
    3398. 

  3398.       else
    3399. 

  3399.         {
    3400. 

  3400.           if (LgEntityName > 0 &&
    3401. 

  3401.               strncmp (EntityName,
    3402. 

  3402.                        XhtmlEntityTable[EntityTableEntry].charName,
    3403. 

  3403.                        LgEntityName) != 0)
    3404. 

  3404.             OK = FALSE;
    3405. 

  3405.           else
    3406. 

  3406.             {
    3407. 

  3407.               OK = TRUE;
    3408. 

  3408.               CharRank++;
    3409. 

  3409.               if (LgEntityName < MaxEntityLength - 1)
    3410. 

  3410.                 EntityName[LgEntityName++] = c;
    3411. 

  3411.             }
    3412. 

  3412.         }
    3413. 

  3413.       if (!OK)
    3414. 

  3414.         {
    3415. 

  3415.           /* the entity name read so far is not in the table */
    3416. 

  3416.           /* invalid entity */
    3417. 

  3417.           /* put the entity name in the buffer */
    3418. 

  3418.           PutInBuffer ('&');
    3419. 

  3419.           for (i = 0; i < LgEntityName; i++)
    3420. 

  3420.             PutInBuffer (EntityName[i]);
    3421. 

  3421.           /* print an error message only if it's not the first character
    3422. 

  3422.              after '&' or if it is a letter */
    3423. 

  3423.           if (LgEntityName > 0 ||
    3424. 

  3424.               ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
    3425. 

  3425.             {
    3426. 

  3426.               /* print an error message */
    3427. 

  3427.               EntityName[LgEntityName++] = c;
    3428. 

  3428.               EntityName[LgEntityName++] = EOS;
    3429. 

  3429.               sprintf ((char *)msgBuffer, "Unknown entity");
    3430. 

  3430.               HTMLParseError (HTMLcontext.doc, (char *)msgBuffer, 0);
    3431. 

  3431.             }
    3432. 

  3432.           /* next state is the return state from the entity subautomaton,
    3433. 

  3433.              not the state computed by the automaton.
    3434. 

  3434.              In addition the character read has not been processed yet */
    3435. 

  3435.           NormalTransition = FALSE;
    3436. 

  3436.           currentState = returnState;
    3437. 

  3437.           /* end of entity */
    3438. 

  3438.           LgEntityName = 0;
    3439. 

  3439.         }
    3440. 

  3440.     }
    3441. 

  3441. }
    3442. 

  3442. 

  3443. /*----------------------------------------------------------------------
    3444. 

  3444.   EndOfDecEntity  End of a decimal entity. Convert the
    3445. 

  3445.   string read into a number and put the character
    3446. 

  3446.   having that code in the input buffer.
    3447. 

  3447.   ----------------------------------------------------------------------*/
    3448. 

  3448. static void EndOfDecEntity (unsigned char c)
    3449. 

  3449. {
    3450. 

  3450.   unsigned char fallback[7], *ptr;
    3451. 

  3451.   int           len;
    3452. 

  3452.   int           code;
    3453. 

  3453.   int           i;
    3454. 

  3454. 

  3455.   EntityName[LgEntityName] = EOS;
    3456. 

  3456.   sscanf (EntityName, "%d", &code);
    3457. 

  3457.   if (code > 127)
    3458. 

  3458.     {
    3459. 

  3459.       /* generate the UTF-8 string */
    3460. 

  3460.       ptr = fallback;
    3461. 

  3461.       len = TtaWCToMBstring ((wchar_t) code, &ptr);
    3462. 

  3462.       for (i = 0; i < len; i++)
    3463. 

  3463.         PutInBuffer (fallback[i]);
    3464. 

  3464.     }
    3465. 

  3465.   else
    3466. 

  3466.     PutInBuffer ((char) code);
    3467. 

  3467.   LgEntityName = 0;
    3468. 

  3468. }
    3469. 

  3469. 

  3470. /*----------------------------------------------------------------------
    3471. 

  3471.   DecEntityChar   A character belonging to a decimal entity has been read.
    3472. 

  3472.   Put that character in the entity buffer.
    3473. 

  3473.   ----------------------------------------------------------------------*/
    3474. 

  3474. static void DecEntityChar (unsigned char c)
    3475. 

  3475. {
    3476. 

  3476.   int		i;
    3477. 

  3477. 

  3478.   if (LgEntityName < MaxEntityLength - 1)
    3479. 

  3479.     {
    3480. 

  3480.       /* the entity buffer is not full */
    3481. 

  3481.       if (c >= '0' && c <= '9')
    3482. 

  3482.         /* the character is a decimal digit */
    3483. 

  3483.         EntityName[LgEntityName++] = c;
    3484. 

  3484.       else
    3485. 

  3485.         /* not a decimal digit. assume end of entity */
    3486. 

  3486.         {
    3487. 

  3487.           if (c == '<')
    3488. 

  3488.             /* accept start of tag as an end of entity */
    3489. 

  3489.             EndOfDecEntity (c);
    3490. 

  3490.           else
    3491. 

  3491.             {
    3492. 

  3492.               PutInBuffer ('&');
    3493. 

  3493.               PutInBuffer ('#');
    3494. 

  3494.               for (i = 0; i < LgEntityName; i++)
    3495. 

  3495.                 PutInBuffer (EntityName[i]);
    3496. 

  3496.               LgEntityName = 0;
    3497. 

  3497.               /* error message */
    3498. 

  3498.               HTMLParseError (HTMLcontext.doc, "Invalid decimal entity", 0);
    3499. 

  3499.             }
    3500. 

  3500.           /* next state is state 0, not the state computed by the automaton */
    3501. 

  3501.           /* and the character read has not been processed yet */
    3502. 

  3502.           NormalTransition = FALSE;
    3503. 

  3503.           currentState = 0;
    3504. 

  3504.         }
    3505. 

  3505.     }
    3506. 

  3506. }
    3507. 

  3507. 

  3508. /*----------------------------------------------------------------------
    3509. 

  3509.   EndOfHexEntity  End of an hexadecimal entity. Convert the
    3510. 

  3510.   string read into a number and put the character
    3511. 

  3511.   having that code in the input buffer.
    3512. 

  3512.   ----------------------------------------------------------------------*/
    3513. 

  3513. static void EndOfHexEntity (unsigned char c)
    3514. 

  3514. {
    3515. 

  3515.   unsigned char fallback[7], *ptr;
    3516. 

  3516.   int           len;
    3517. 

  3517.   int           code;
    3518. 

  3518.   int           i;
    3519. 

  3519. 

  3520.   EntityName[LgEntityName] = EOS;
    3521. 

  3521.   sscanf (EntityName, "%x", &code);
    3522. 

  3522.   if (code > 127)
    3523. 

  3523.     {
    3524. 

  3524.       /* generate the UTF-8 string */
    3525. 

  3525.       ptr = fallback;
    3526. 

  3526.       len = TtaWCToMBstring ((wchar_t) code, &ptr);
    3527. 

  3527.       for (i = 0; i < len; i++)
    3528. 

  3528.         PutInBuffer (fallback[i]);
    3529. 

  3529.     }
    3530. 

  3530.   else
    3531. 

  3531.     PutInBuffer ((char) code);
    3532. 

  3532.   LgEntityName = 0;
    3533. 

  3533. }
    3534. 

  3534. 

  3535. /*----------------------------------------------------------------------
    3536. 

  3536.   HexEntityChar   A character belonging to an hexadecimal entity has been
    3537. 

  3537.   read. Put that character in the entity buffer.
    3538. 

  3538.   ----------------------------------------------------------------------*/
    3539. 

  3539. static void     HexEntityChar (char c)
    3540. 

  3540. {
    3541. 

  3541.   int		i;
    3542. 

  3542. 

  3543.   if (LgEntityName < MaxEntityLength - 1)
    3544. 

  3544.     {
    3545. 

  3545.       /* the entity buffer is not full */
    3546. 

  3546.       if ((c >= '0' && c <= '9') ||
    3547. 

  3547.           (c >= 'a' && c <= 'f') ||
    3548. 

  3548.           (c >= 'A' && c <= 'F'))
    3549. 

  3549.         /* the character is a valid hexadecimal digit */
    3550. 

  3550.         EntityName[LgEntityName++] = c;
    3551. 

  3551.       else
    3552. 

  3552.         {
    3553. 

  3553.           /* not an hexadecimal digit. Assume end of entity */
    3554. 

  3554.           if (c == '<')
    3555. 

  3555.             /* accept start of tag as the end of the entity */
    3556. 

  3556.             EndOfHexEntity (c);
    3557. 

  3557.           else
    3558. 

  3558.             /* error */
    3559. 

  3559.             {
    3560. 

  3560.               PutInBuffer ('&');
    3561. 

  3561.               PutInBuffer ('#');
    3562. 

  3562.               PutInBuffer ('x');
    3563. 

  3563.               for (i = 0; i < LgEntityName; i++)
    3564. 

  3564.                 PutInBuffer (EntityName[i]);
    3565. 

  3565.               LgEntityName = 0;
    3566. 

  3566.               /* error message */
    3567. 

  3567.               HTMLParseError (HTMLcontext.doc, "Invalid hexadecimal entity", 0);
    3568. 

  3568.             }
    3569. 

  3569.           /* next state is state 0, not the state computed by the automaton */
    3570. 

  3570.           /* and the character read has not been processed yet */
    3571. 

  3571.           NormalTransition = FALSE;
    3572. 

  3572.           currentState = 0;
    3573. 

  3573.         }
    3574. 

  3574.     }
    3575. 

  3575. }
    3576. 

  3576. 

  3577. /*----------------------------------------------------------------------
    3578. 

  3578.   EndOfDocument   End of the HTML file. Terminate the Thot
    3579. 

  3579.   document
    3580. 

  3580.   ----------------------------------------------------------------------*/
    3581. 

  3581. static void         EndOfDocument ()
    3582. 

  3582. {
    3583. 

  3583.   if (LgBuffer > 0)
    3584. 

  3584.     TextToDocument ();
    3585. 

  3585. }
    3586. 

  3586. 

  3587. /*----------------------------------------------------------------------
    3588. 

  3588.   PutLess put '<' in the input buffer
    3589. 

  3589.   ----------------------------------------------------------------------*/
    3590. 

  3590. static void         PutLess (char c)
    3591. 

  3591. {
    3592. 

  3592.   PutInBuffer ('<');
    3593. 

  3593. }
    3594. 

  3594. 

  3595. /*----------------------------------------------------------------------
    3596. 

  3596.   PutAmpersandSpace       put '& ' in the input buffer.
    3597. 

  3597.   ----------------------------------------------------------------------*/
    3598. 

  3598. static void         PutAmpersandSpace (char c)
    3599. 

  3599. {
    3600. 

  3600.   PutInBuffer ('&');
    3601. 

  3601.   PutInBuffer (SPACE);
    3602. 

  3602. }
    3603. 

  3603. 

  3604. /*----------------------------------------------------------------------
    3605. 

  3605.   PutLessAndSpace put '<' and the space read in the input buffer.
    3606. 

  3606.   ----------------------------------------------------------------------*/
    3607. 

  3607. static void         PutLessAndSpace (char c)
    3608. 

  3608. {
    3609. 

  3609.   PutInBuffer ('<');
    3610. 

  3610.   PutInBuffer (c);
    3611. 

  3611. }
    3612. 

  3612. 

  3613. 

  3614. /*----------------------------------------------------------------------
    3615. 

  3615.   StartOfComment  Beginning of a HTML comment.
    3616. 

  3616.   ----------------------------------------------------------------------*/
    3617. 

  3617. static void StartOfComment (char c)
    3618. 

  3618. {
    3619. 

  3619.   ElementType      elType;
    3620. 

  3620.   Element          elComment, elCommentLine;
    3621. 

  3621. 

  3622.   /* create a Thot element Comment */
    3623. 

  3623.   elType.ElSSchema = DocumentSSchema;
    3624. 

  3624.   elType.ElTypeNum = HTML_EL_Comment_;
    3625. 

  3625.   elComment = TtaNewElement (HTMLcontext.doc, elType);
    3626. 

  3626.   TtaSetElementLineNumber (elComment, NumberOfLinesRead);
    3627. 

  3627.   InsertElement (&elComment);
    3628. 

  3628.   /* create a Comment_line element as the first child of */
    3629. 

  3629.   /* element Comment */
    3630. 

  3630.   if (elComment != NULL)
    3631. 

  3631.     {
    3632. 

  3632.       elType.ElTypeNum = HTML_EL_Comment_line;
    3633. 

  3633.       elCommentLine = TtaNewElement (HTMLcontext.doc, elType);
    3634. 

  3634.       TtaSetElementLineNumber (elCommentLine, NumberOfLinesRead);
    3635. 

  3635.       TtaInsertFirstChild (&elCommentLine, elComment, HTMLcontext.doc);
    3636. 

  3636.       /* create a TEXT element as the first child of element Comment_line */
    3637. 

  3637.       elType.ElTypeNum = HTML_EL_TEXT_UNIT;
    3638. 

  3638.       CommentText = TtaNewElement (HTMLcontext.doc, elType);
    3639. 

  3639.       TtaSetElementLineNumber (CommentText, NumberOfLinesRead);
    3640. 

  3640.       TtaInsertFirstChild (&CommentText, elCommentLine, HTMLcontext.doc);
    3641. 

  3641.       TtaSetTextContent (CommentText, (unsigned char *)"", HTMLcontext.language,
    3642. 

  3642.                          HTMLcontext.doc);
    3643. 

  3643.     }
    3644. 

  3644.   InitBuffer ();
    3645. 

  3645. }
    3646. 

  3646. 

  3647. /*----------------------------------------------------------------------
    3648. 

  3648.   PutInComment    put character c in the current HTML comment.
    3649. 

  3649.   ----------------------------------------------------------------------*/
    3650. 

  3650. static void PutInComment (unsigned char c)
    3651. 

  3651. {
    3652. 

  3652.   ElementType       elType;
    3653. 

  3653.   Element           elCommentLine, prevElCommentLine;
    3654. 

  3654.   
    3655. 

  3655.   if (c != EOS)
    3656. 

  3656.     {
    3657. 

  3657.       if (!HTMLcontext.parsingCSS && ((int) c == EOL || (int) c == __CR__))
    3658. 

  3658.         /* new line in a comment */
    3659. 

  3659.         {
    3660. 

  3660.           /* put the content of the inputBuffer into the current */
    3661. 

  3661.           /* Comment_line element */
    3662. 

  3662.           CloseBuffer ();
    3663. 

  3663.           TtaAppendTextContent (CommentText, (unsigned char *)inputBuffer, HTMLcontext.doc);
    3664. 

  3664.           InitBuffer ();
    3665. 

  3665.           /* create a new Comment_line element */
    3666. 

  3666.           elType.ElSSchema = DocumentSSchema;
    3667. 

  3667.           elType.ElTypeNum = HTML_EL_Comment_line;
    3668. 

  3668.           elCommentLine = TtaNewElement (HTMLcontext.doc, elType);
    3669. 

  3669.           TtaSetElementLineNumber (elCommentLine, NumberOfLinesRead);
    3670. 

  3670.           /* inserts the new Comment_line element after the previous one */
    3671. 

  3671.           prevElCommentLine = TtaGetParent (CommentText);
    3672. 

  3672.           TtaInsertSibling (elCommentLine, prevElCommentLine, FALSE, HTMLcontext.doc);
    3673. 

  3673.           /* create a TEXT element as the first child of the new element
    3674. 

  3674.              Comment_line */
    3675. 

  3675.           elType.ElTypeNum = HTML_EL_TEXT_UNIT;
    3676. 

  3676.           CommentText = TtaNewElement (HTMLcontext.doc, elType);
    3677. 

  3677.           TtaSetElementLineNumber (CommentText, NumberOfLinesRead);
    3678. 

  3678.           TtaInsertFirstChild (&CommentText, elCommentLine, HTMLcontext.doc);
    3679. 

  3679.           TtaSetTextContent (CommentText, (unsigned char *)"", HTMLcontext.language, HTMLcontext.doc);
    3680. 

  3680.         }
    3681. 

  3681.       else
    3682. 

  3682.         {
    3683. 

  3683.           if (LgBuffer >= MaxBufferLength - 1)
    3684. 

  3684.             {
    3685. 

  3685.               CloseBuffer ();
    3686. 

  3686.               TtaAppendTextContent (CommentText, (unsigned char *)inputBuffer,
    3687. 

  3687.                                     HTMLcontext.doc);
    3688. 

  3688.               InitBuffer ();
    3689. 

  3689.             }
    3690. 

  3690.           inputBuffer[LgBuffer++] = c;
    3691. 

  3691.         }
    3692. 

  3692.     }
    3693. 

  3693. }
    3694. 

  3694. 

  3695. /*----------------------------------------------------------------------
    3696. 

  3696.   EndOfComment    End of a HTML comment.
    3697. 

  3697.   ----------------------------------------------------------------------*/
    3698. 

  3698. static void EndOfComment (char c)
    3699. 

  3699. {
    3700. 

  3700.   if (LgBuffer > 0)
    3701. 

  3701.     {
    3702. 

  3702.       CloseBuffer ();
    3703. 

  3703.       if (CommentText != NULL)
    3704. 

  3704.         TtaAppendTextContent (CommentText, (unsigned char *)inputBuffer,
    3705. 

  3705.                               HTMLcontext.doc);
    3706. 

  3706.     }
    3707. 

  3707.   CommentText = NULL;
    3708. 

  3708.   HTMLcontext.lastElementClosed = TRUE;
    3709. 

  3709.   InitBuffer ();
    3710. 

  3710. }
    3711. 

  3711. 

  3712. /*----------------------------------------------------------------------
    3713. 

  3713.   StartOfASP  Beginning of a HTML ASP
    3714. 

  3714.   ----------------------------------------------------------------------*/
    3715. 

  3715. static void StartOfASP (char c)
    3716. 

  3716. {
    3717. 

  3717.   ElementType      elType;
    3718. 

  3718.   Element          elASP, elASPLine;
    3719. 

  3719. 

  3720.   /* create a Thot element ASP */
    3721. 

  3721.   elType.ElSSchema = DocumentSSchema;
    3722. 

  3722.   elType.ElTypeNum = HTML_EL_ASP_element;
    3723. 

  3723.   elASP = TtaNewElement (HTMLcontext.doc, elType);
    3724. 

  3724.   TtaSetElementLineNumber (elASP, NumberOfLinesRead);
    3725. 

  3725.   InsertElement (&elASP);
    3726. 

  3726.   /* create a ASP_line element as the first child of */
    3727. 

  3727.   /* element ASP */
    3728. 

  3728.   if (elASP != NULL)
    3729. 

  3729.     {
    3730. 

  3730.       elType.ElTypeNum = HTML_EL_ASP_line;
    3731. 

  3731.       elASPLine = TtaNewElement (HTMLcontext.doc, elType);
    3732. 

  3732.       TtaSetElementLineNumber (elASPLine, NumberOfLinesRead);
    3733. 

  3733.       TtaInsertFirstChild (&elASPLine, elASP, HTMLcontext.doc);
    3734. 

  3734.       /* create a TEXT element as the first child of element ASP_line */
    3735. 

  3735.       elType.ElTypeNum = HTML_EL_TEXT_UNIT;
    3736. 

  3736.       ASPText = TtaNewElement (HTMLcontext.doc, elType);
    3737. 

  3737.       TtaSetElementLineNumber (ASPText, NumberOfLinesRead);
    3738. 

  3738.       TtaInsertFirstChild (&ASPText, elASPLine, HTMLcontext.doc);
    3739. 

  3739.       TtaSetTextContent (ASPText, (unsigned char *)"", HTMLcontext.language,
    3740. 

  3740.                          HTMLcontext.doc);
    3741. 

  3741.     }
    3742. 

  3742.   InitBuffer ();
    3743. 

  3743. }
    3744. 

  3744. 

  3745. /*----------------------------------------------------------------------
    3746. 

  3746.   PutInASP    put character c in the current HTML ASP
    3747. 

  3747.   ----------------------------------------------------------------------*/
    3748. 

  3748. static void PutInASP (unsigned char c)
    3749. 

  3749. {
    3750. 

  3750.   ElementType       elType;
    3751. 

  3751.   Element           elASPLine, prevElASPLine;
    3752. 

  3752.   
    3753. 

  3753.   if (c != EOS)
    3754. 

  3754.     {
    3755. 

  3755.       if (!HTMLcontext.parsingCSS && ((int) c == EOL || (int) c == __CR__))
    3756. 

  3756.         /* new line in a ASP */
    3757. 

  3757.         {
    3758. 

  3758.           /* put the content of the inputBuffer into the current */
    3759. 

  3759.           /* ASP_line element */
    3760. 

  3760.           CloseBuffer ();
    3761. 

  3761.           TtaAppendTextContent (ASPText, (unsigned char *)inputBuffer, HTMLcontext.doc);
    3762. 

  3762.           InitBuffer ();
    3763. 

  3763.           /* create a new ASP_line element */
    3764. 

  3764.           elType.ElSSchema = DocumentSSchema;
    3765. 

  3765.           elType.ElTypeNum = HTML_EL_ASP_line;
    3766. 

  3766.           elASPLine = TtaNewElement (HTMLcontext.doc, elType);
    3767. 

  3767.           TtaSetElementLineNumber (elASPLine, NumberOfLinesRead);
    3768. 

  3768.           /* inserts the new ASP_line element after the previous one */
    3769. 

  3769.           prevElASPLine = TtaGetParent (ASPText);
    3770. 

  3770.           TtaInsertSibling (elASPLine, prevElASPLine, FALSE, HTMLcontext.doc);
    3771. 

  3771.           /* create a TEXT element as the first child of the new element
    3772. 

  3772.              ASP_line */
    3773. 

  3773.           elType.ElTypeNum = HTML_EL_TEXT_UNIT;
    3774. 

  3774.           ASPText = TtaNewElement (HTMLcontext.doc, elType);
    3775. 

  3775.           TtaSetElementLineNumber (ASPText, NumberOfLinesRead);
    3776. 

  3776.           TtaInsertFirstChild (&ASPText, elASPLine, HTMLcontext.doc);
    3777. 

  3777.           TtaSetTextContent (ASPText, (unsigned char *)"", HTMLcontext.language, HTMLcontext.doc);
    3778. 

  3778.         }
    3779. 

  3779.       else
    3780. 

  3780.         {
    3781. 

  3781.           if (LgBuffer >= MaxBufferLength - 1)
    3782. 

  3782.             {
    3783. 

  3783.               CloseBuffer ();
    3784. 

  3784.               TtaAppendTextContent (ASPText, (unsigned char *)inputBuffer,
    3785. 

  3785.                                     HTMLcontext.doc);
    3786. 

  3786.               InitBuffer ();
    3787. 

  3787.             }
    3788. 

  3788.           inputBuffer[LgBuffer++] = c;
    3789. 

  3789.         }
    3790. 

  3790.     }
    3791. 

  3791. }
    3792. 

  3792. 

  3793. /*----------------------------------------------------------------------
    3794. 

  3794.   EndOfASP    End of a HTML ASP
    3795. 

  3795.   ----------------------------------------------------------------------*/
    3796. 

  3796. static void EndOfASP (char c)
    3797. 

  3797. {
    3798. 

  3798.   if (LgBuffer > 0)
    3799. 

  3799.     {
    3800. 

  3800.       CloseBuffer ();
    3801. 

  3801.       if (ASPText != NULL)
    3802. 

  3802.         TtaAppendTextContent (ASPText, (unsigned char *)inputBuffer,
    3803. 

  3803.                               HTMLcontext.doc);
    3804. 

  3804.     }
    3805. 

  3805.   ASPText = NULL;
    3806. 

  3806.   HTMLcontext.lastElementClosed = TRUE;
    3807. 

  3807.   InitBuffer ();
    3808. 

  3808. }
    3809. 

  3809. 

  3810. /*----------------------------------------------------------------------
    3811. 

  3811.   PutDash put a dash character in the current comment.
    3812. 

  3812.   ----------------------------------------------------------------------*/
    3813. 

  3813. static void PutDash (char c)
    3814. 

  3814. {
    3815. 

  3815.   PutInComment ('-');
    3816. 

  3816.   PutInComment (c);
    3817. 

  3817. }
    3818. 

  3818. 

  3819. /*----------------------------------------------------------------------
    3820. 

  3820.   PutDashDash     put 2 dash characters in the current comment.
    3821. 

  3821.   ----------------------------------------------------------------------*/
    3822. 

  3822. static void         PutDashDash (char c)
    3823. 

  3823. {
    3824. 

  3824.   PutInComment ('-');
    3825. 

  3825.   PutInComment ('-');
    3826. 

  3826.   PutInComment (c);
    3827. 

  3827. }
    3828. 

  3828. 

  3829. /*----------------------------------------------------------------------
    3830. 

  3830.   PutQuestionMark put a question mark in the current PI.
    3831. 

  3831.   ----------------------------------------------------------------------*/
    3832. 

  3832. static void PutQuestionMark (char c)
    3833. 

  3833. {
    3834. 

  3834.   PutInBuffer ('?');
    3835. 

  3835.   PutInBuffer (c);
    3836. 

  3836. }
    3837. 

  3837. 

  3838. /*----------------------------------------------------------------------
    3839. 

  3839.   EndOfDoctypeDecl	A Doctype declaration has been read
    3840. 

  3840.   ----------------------------------------------------------------------*/
    3841. 

  3841. static void EndOfDoctypeDecl (char c)
    3842. 

  3842. {
    3843. 

  3843.   int	          i, j;  
    3844. 

  3844.   Element         docEl, text, doctype, prev, doctypeLine;
    3845. 

  3845.   ElementType     elType;
    3846. 

  3846.   unsigned char  *buffer;
    3847. 

  3847. 

  3848.   CloseBuffer ();
    3849. 

  3849.   buffer = (unsigned char*)TtaGetMemory (strlen ((char *)inputBuffer) + 20);
    3850. 

  3850.   strcpy ((char *)buffer, (char *)"<!DOCTYPE ");
    3851. 

  3851.   j = strlen ((char *)buffer);
    3852. 

  3852.   /* process the Doctype declaration available in inputBuffer */
    3853. 

  3853.   if (!strncasecmp ((char *)inputBuffer, "doctype", 7))
    3854. 

  3854.     {
    3855. 

  3855.       for (i = 7; inputBuffer[i] <= SPACE && inputBuffer[i] != EOS; i++);
    3856. 

  3856.       if (!strncasecmp ((char *)&inputBuffer[i], "HTML", 4))
    3857. 

  3857.         /* it's a HTML document */
    3858. 

  3858.         {
    3859. 

  3859.           docEl = TtaGetMainRoot (HTMLcontext.doc);
    3860. 

  3860.           elType = TtaGetElementType (docEl);
    3861. 

  3861.           /* Create a DOCTYPE element */
    3862. 

  3862.           elType.ElTypeNum = HTML_EL_DOCTYPE;
    3863. 

  3863.           doctype = TtaNewElement (HTMLcontext.doc, elType);
    3864. 

  3864.           TtaSetElementLineNumber (doctype, NumberOfLinesRead);
    3865. 

  3865.           InsertElement (&doctype);
    3866. 

  3866.           /* Make the DOCTYPE element read-only */
    3867. 

  3867.           TtaSetAccessRight (doctype, ReadOnly, HTMLcontext.doc);
    3868. 

  3868.           HTMLcontext.lastElement = doctype;
    3869. 

  3869.           HTMLcontext.lastElementClosed = TRUE;
    3870. 

  3870.           /* Create a DOCTYPE_line element as first child */
    3871. 

  3871.           elType.ElTypeNum = HTML_EL_DOCTYPE_line;
    3872. 

  3872.           doctypeLine = TtaNewElement (HTMLcontext.doc, elType);
    3873. 

  3873.           TtaSetElementLineNumber (doctypeLine, NumberOfLinesRead);
    3874. 

  3874.           TtaInsertFirstChild (&doctypeLine, doctype, HTMLcontext.doc);
    3875. 

  3875.           /* Look for line breaks in the input buffer  and create */
    3876. 

  3876.           /* as many DOCTYPE_line elements as needed */
    3877. 

  3877.           while (inputBuffer[i] != EOS)
    3878. 

  3878.             {
    3879. 

  3879.               if (inputBuffer[i] != EOL && inputBuffer[i] != __CR__)
    3880. 

  3880.                 buffer[j++] = inputBuffer[i];
    3881. 

  3881.               else
    3882. 

  3882.                 {
    3883. 

  3883.                   buffer[j] = EOS;
    3884. 

  3884.                   j = 0;
    3885. 

  3885.                   elType.ElTypeNum = 1;
    3886. 

  3886.                   text = TtaNewElement (HTMLcontext.doc, elType);
    3887. 

  3887.                   if (text != NULL)
    3888. 

  3888.                     {
    3889. 

  3889.                       TtaSetElementLineNumber (text, NumberOfLinesRead);
    3890. 

  3890.                       /* get the position of the Doctype text */
    3891. 

  3891.                       TtaInsertFirstChild (&text, doctypeLine, HTMLcontext.doc);
    3892. 

  3892. 

  3893.                       /* We use the Latin_Script language to avoid the spell_checker */
    3894. 

  3894.                       /* the spell_chekcer to check the doctype */
    3895. 

  3895.                       TtaSetTextContent (text, (unsigned char *)buffer, Latin_Script, HTMLcontext.doc);
    3896. 

  3896.                     }
    3897. 

  3897.                   /* Create a new DOCTYPE_line element */
    3898. 

  3898.                   elType.ElTypeNum = HTML_EL_DOCTYPE_line;
    3899. 

  3899.                   prev = doctypeLine;
    3900. 

  3900.                   doctypeLine = TtaNewElement (HTMLcontext.doc, elType);
    3901. 

  3901.                   if (doctypeLine != NULL)
    3902. 

  3902.                     {
    3903. 

  3903.                       TtaSetElementLineNumber (doctypeLine, NumberOfLinesRead);
    3904. 

  3904.                       TtaInsertSibling (doctypeLine, prev, FALSE, HTMLcontext.doc);
    3905. 

  3905.                     }		   
    3906. 

  3906.                 }
    3907. 

  3907.               i++;
    3908. 

  3908.             }
    3909. 

  3909.           buffer [j++] = '>';
    3910. 

  3910.           buffer [j] = EOS;
    3911. 

  3911.           elType.ElTypeNum = 1;
    3912. 

  3912.           text = TtaNewElement (HTMLcontext.doc, elType);
    3913. 

  3913.           if (text)
    3914. 

  3914.             {
    3915. 

  3915.               TtaSetElementLineNumber (text, NumberOfLinesRead);
    3916. 

  3916.               /* get the position of the Doctype text */
    3917. 

  3917.               TtaInsertFirstChild (&text, doctypeLine, HTMLcontext.doc);
    3918. 

  3918.               /* We use the Latin_Script language to avoid the spell_chekcer */
    3919. 

  3919.               /* the spell_chekcer to check the doctype */
    3920. 

  3920.               TtaSetTextContent (text, (unsigned char *)buffer, Latin_Script, HTMLcontext.doc);
    3921. 

  3921.             }
    3922. 

  3922.         }
    3923. 

  3923.     }
    3924. 

  3924.    
    3925. 

  3925.   InitBuffer ();
    3926. 

  3926.   TtaFreeMemory (buffer);
    3927. 

  3927. }
    3928. 

  3928. 

  3929. 

  3930. /*----------------------------------------------------------------------
    3931. 

  3931.   StartOfPI  Beginning of a HTML comment.
    3932. 

  3932.   ----------------------------------------------------------------------*/
    3933. 

  3933. static void         StartOfPI (char c)
    3934. 

  3934. {
    3935. 

  3935.   ElementType      elType;
    3936. 

  3936.   Element          elPI, elPILine;
    3937. 

  3937. 

  3938.   /* create a Thot element PI */
    3939. 

  3939.   elType.ElSSchema = DocumentSSchema;
    3940. 

  3940.   elType.ElTypeNum = HTML_EL_XMLPI;
    3941. 

  3941.   elPI = TtaNewElement (HTMLcontext.doc, elType);
    3942. 

  3942.   TtaSetElementLineNumber (elPI, NumberOfLinesRead);
    3943. 

  3943.   InsertElement (&elPI);
    3944. 

  3944.   /* create a PI_line element as the first child of */
    3945. 

  3945.   /* element PI */
    3946. 

  3946.   if (elPI != NULL)
    3947. 

  3947.     {
    3948. 

  3948.       elType.ElTypeNum = HTML_EL_PI_line;
    3949. 

  3949.       elPILine = TtaNewElement (HTMLcontext.doc, elType);
    3950. 

  3950.       TtaSetElementLineNumber (elPILine, NumberOfLinesRead);
    3951. 

  3951.       TtaInsertFirstChild (&elPILine, elPI, HTMLcontext.doc);
    3952. 

  3952.       /* create a TEXT element as the first child of element PI_line */
    3953. 

  3953.       elType.ElTypeNum = HTML_EL_TEXT_UNIT;
    3954. 

  3954.       PIText = TtaNewElement (HTMLcontext.doc, elType);
    3955. 

  3955.       TtaSetElementLineNumber (PIText, NumberOfLinesRead);
    3956. 

  3956.       TtaInsertFirstChild (&PIText, elPILine, HTMLcontext.doc);
    3957. 

  3957.       TtaSetTextContent (PIText, (unsigned char *)"", HTMLcontext.language,
    3958. 

  3958.                          HTMLcontext.doc);
    3959. 

  3959.     }
    3960. 

  3960.   InitBuffer ();
    3961. 

  3961. }
    3962. 

  3962. 

  3963. /*----------------------------------------------------------------------
    3964. 

  3964.   PutInPI    put character c in the current HTML comment.
    3965. 

  3965.   ----------------------------------------------------------------------*/
    3966. 

  3966. static void         PutInPI (unsigned char c)
    3967. 

  3967. {
    3968. 

  3968.   ElementType       elType;
    3969. 

  3969.   Element           elPILine, prevElPILine;
    3970. 

  3970.   
    3971. 

  3971.   if (c != EOS)
    3972. 

  3972.     {
    3973. 

  3973.       if (!HTMLcontext.parsingCSS && ((int) c == EOL || (int) c == __CR__))
    3974. 

  3974.         /* new line in a comment */
    3975. 

  3975.         {
    3976. 

  3976.           /* put the content of the inputBuffer into the current */
    3977. 

  3977.           /* PI_line element */
    3978. 

  3978.           CloseBuffer ();
    3979. 

  3979.           TtaAppendTextContent (PIText, (unsigned char *)inputBuffer, HTMLcontext.doc);
    3980. 

  3980.           InitBuffer ();
    3981. 

  3981.           /* create a new PI_line element */
    3982. 

  3982.           elType.ElSSchema = DocumentSSchema;
    3983. 

  3983.           elType.ElTypeNum = HTML_EL_PI_line;
    3984. 

  3984.           elPILine = TtaNewElement (HTMLcontext.doc, elType);
    3985. 

  3985.           TtaSetElementLineNumber (elPILine, NumberOfLinesRead);
    3986. 

  3986.           /* inserts the new PI_line element after the previous one */
    3987. 

  3987.           prevElPILine = TtaGetParent (PIText);
    3988. 

  3988.           TtaInsertSibling (elPILine, prevElPILine, FALSE, HTMLcontext.doc);
    3989. 

  3989.           /* create a TEXT element as the first child of the new element
    3990. 

  3990.              PI_line */
    3991. 

  3991.           elType.ElTypeNum = HTML_EL_TEXT_UNIT;
    3992. 

  3992.           PIText = TtaNewElement (HTMLcontext.doc, elType);
    3993. 

  3993.           TtaSetElementLineNumber (PIText, NumberOfLinesRead);
    3994. 

  3994.           TtaInsertFirstChild (&PIText, elPILine, HTMLcontext.doc);
    3995. 

  3995.           TtaSetTextContent (PIText, (unsigned char *)"", HTMLcontext.language, HTMLcontext.doc);
    3996. 

  3996.         }
    3997. 

  3997.       else
    3998. 

  3998.         {
    3999. 

  3999.           if (LgBuffer >= MaxBufferLength - 1)
    4000. 

  4000.             {
    4001. 

  4001.               CloseBuffer ();
    4002. 

  4002.               TtaAppendTextContent (PIText, (unsigned char *)inputBuffer,
    4003. 

  4003.                                     HTMLcontext.doc);
    4004. 

  4004.               InitBuffer ();
    4005. 

  4005.             }
    4006. 

  4006.           inputBuffer[LgBuffer++] = c;
    4007. 

  4007.         }
    4008. 

  4008.     }
    4009. 

  4009. }
    4010. 

  4010. 

  4011. /*----------------------------------------------------------------------
    4012. 

  4012.   EndOfPI    End of a HTML PI
    4013. 

  4013.   ----------------------------------------------------------------------*/
    4014. 

  4014. static void         EndOfPI (char c)
    4015. 

  4015. {
    4016. 

  4016.   if (LgBuffer > 0)
    4017. 

  4017.     {
    4018. 

  4018.       CloseBuffer ();
    4019. 

  4019.       if (PIText != NULL)
    4020. 

  4020.         TtaAppendTextContent (PIText, (unsigned char *)inputBuffer,
    4021. 

  4021.                               HTMLcontext.doc);
    4022. 

  4022.     }
    4023. 

  4023.   PIText = NULL;
    4024. 

  4024.   HTMLcontext.lastElementClosed = TRUE;
    4025. 

  4025.   InitBuffer ();
    4026. 

  4026. }
    4027. 

  4027. 

  4028. 

  4029. /*----------------------------------------------------------------------
    4030. 

  4030.   Do_nothing does nothing.
    4031. 

  4031.   ----------------------------------------------------------------------*/
    4032. 

  4032. static void Do_nothing (char c)
    4033. 

  4033. {
    4034. 

  4034. }
    4035. 

  4035. 

  4036. /* some type definitions for the automaton */
    4037. 

  4037. typedef struct _Transition *PtrTransition;
    4038. 

  4038. typedef struct _Transition
    4039. 

  4039. {				/* a transition of the automaton in
    4040. 

  4040. 				   "executable" form */
    4041. 

  4041.   unsigned char       trigger;	/* the imput character that triggers
    4042. 

  4042.                                    the transition */
    4043. 

  4043.   Proc                action;	/* the procedure to be called when
    4044. 

  4044.                                  the transition occurs */
    4045. 

  4045.   State               newState;	/* the new state of the automaton
    4046. 

  4046.                                    after the transition */
    4047. 

  4047.   PtrTransition       nextTransition;	/* next transition from the same
    4048. 

  4048.                                          state */
    4049. 

  4049. } 
    4050. 

  4050. Transition;
    4051. 

  4051. 

  4052. typedef struct _StateDescr
    4053. 

  4053. {				/* a state of the automaton */
    4054. 

  4054.   State               automatonState;	/* the state */
    4055. 

  4055.   PtrTransition       firstTransition;	/* first transition from that state */
    4056. 

  4056. }
    4057. 

  4057. StateDescr;
    4058. 

  4058. 

  4059. /* the automaton that drives the HTML parser */
    4060. 

  4060. #define MaxState 40
    4061. 

  4061. static StateDescr        automaton[MaxState];
    4062. 

  4062. 

  4063. typedef struct _sourceTransition
    4064. 

  4064. {				/* a transition of the automaton in
    4065. 

  4065. 				   "source" form */
    4066. 

  4066.   State               initState;	/* initial state of transition */
    4067. 

  4067.   char                trigger;	/* the imput character that triggers
    4068. 

  4068.                                    the transition */
    4069. 

  4069.   Proc                transitionAction;	/* the procedure to be called when
    4070. 

  4070.                                            the transition occurs */
    4071. 

  4071.   State               newState;	/* final state of the transition */
    4072. 

  4072. }
    4073. 

  4073. sourceTransition;
    4074. 

  4074. 

  4075. /* the automaton in "source" form */
    4076. 

  4076. static sourceTransition sourceAutomaton[] =
    4077. 

  4077.   {
    4078. 

  4078.     /*
    4079. 

  4079.       state, trigger, action, new state
    4080. 

  4080.     */
    4081. 

  4081.     /* state 0: reading character data */
    4082. 

  4082.     {0, '<', (Proc) StartOfTag, 1},
    4083. 

  4083.     {0, '&', (Proc) StartOfEntity, -30},		/* call subautomaton 30 */
    4084. 

  4084.     {0, '*', (Proc) PutInBuffer, 0},	/*  * = any other character */
    4085. 

  4085.     /* state 1: '<' has been read */
    4086. 

  4086.     {1, '%', (Proc) StartOfASP, 35},
    4087. 

  4087.     {1, '/', (Proc) Do_nothing, 3},
    4088. 

  4088.     {1, '!', (Proc) Do_nothing, 10},
    4089. 

  4089.     {1, '?', (Proc) StartOfPI, 20},
    4090. 

  4090.     {1, '<', (Proc) Do_nothing, 18},
    4091. 

  4091.     {1, 'S', (Proc) PutLessAndSpace, 0},		/*   S = Space */
    4092. 

  4092.     {1, '*', (Proc) PutInBuffer, 2},
    4093. 

  4093.     /* state 2: reading a start tag */
    4094. 

  4094.     {2, '>', (Proc) EndOfStartGIandTag, 0},
    4095. 

  4095.     {2, '<', (Proc) EndOfStartGIandTag, 1},     /* Error: tag not closed */
    4096. 

  4096.     {2, '&', (Proc) StartOfEntity, -30},		/* call subautomaton 30 */
    4097. 

  4097.     {2, 'S', (Proc) EndOfStartGI, 16},	/*   S = Space */
    4098. 

  4098.     {2, '*', (Proc) PutInBuffer, 2},
    4099. 

  4099.     /* state 3: reading an end tag */
    4100. 

  4100.     {3, '>', (Proc) EndOfEndTag, 0},
    4101. 

  4101.     {3, '<', (Proc) EndOfEndTag, 1},             /* Error: tag not closed */
    4102. 

  4102.     {3, '&', (Proc) StartOfEntity, -30},		/* call subautomaton 30 */
    4103. 

  4103.     {3, 'S', (Proc) Do_nothing, 3},
    4104. 

  4104.     {3, '*', (Proc) PutInBuffer, 3},
    4105. 

  4105.     /* state 4: reading an attribute name */
    4106. 

  4106.     {4, '=', (Proc) EndOfAttrName, 5},
    4107. 

  4107.     {4, 'S', (Proc) EndOfAttrName, 17},
    4108. 

  4108.     {4, '&', (Proc) StartOfEntity, -30},		/* call subautomaton 30 */
    4109. 

  4109.     {4, '>', (Proc) EndOfAttrNameAndTag, 0},
    4110. 

  4110.     {4, '<', (Proc) EndOfAttrNameAndTag, 1},     /* Error: tag not closed */
    4111. 

  4111.     {4, '*', (Proc) PutInBuffer, 4},
    4112. 

  4112.     /* state 5: expecting an attribute value */
    4113. 

  4113.     {5, '\"', (Proc) StartOfQuotedAttrValue, 6},
    4114. 

  4114.     {5, '\'', (Proc) StartOfQuotedAttrValue, 9},
    4115. 

  4115.     {5, 'S', (Proc) Do_nothing, 5},
    4116. 

  4116.     {5, '>', (Proc) EndOfStartTag, 0},
    4117. 

  4117.     {5, '*', (Proc) StartOfUnquotedAttrValue, 7},
    4118. 

  4118.     /* state 6: reading an attribute value between double quotes */
    4119. 

  4119.     {6, '\"', (Proc) EndOfAttrValue, 8},
    4120. 

  4120.     {6, '&', (Proc) StartOfEntity, -30},		/* call subautomaton 30... */
    4121. 

  4121.     {6, '*', (Proc) PutInBuffer, 6},
    4122. 

  4122.     /* state 7: reading an attribute value without delimiting quotes */
    4123. 

  4123.     {7, '>', (Proc) EndOfAttrValueAndTag, 0},
    4124. 

  4124.     {7, 'S', (Proc) EndOfAttrValue, 16},
    4125. 

  4125.     {7, '&', (Proc) StartOfEntity, -30},		/* call subautomaton 30 */
    4126. 

  4126.     {7, '*', (Proc) PutInBuffer, 7},
    4127. 

  4127.     /* state 8: end of attribute value */
    4128. 

  4128.     {8, '>', (Proc) EndOfStartTag, 0},
    4129. 

  4129.     {8, '<', (Proc) EndOfStartTag, 1},     /* Error: tag not closed */
    4130. 

  4130.     {8, 'S', (Proc) Do_nothing, 16},
    4131. 

  4131.     {8, '*', (Proc) PutInBuffer, 4},
    4132. 

  4132.     /* state 9: reading an attribute value between simple quotes */
    4133. 

  4133.     {9, '\'', (Proc) EndOfAttrValue, 8},
    4134. 

  4134.     {9, '&', (Proc) StartOfEntity, -30},		/* call subautomaton 30 */
    4135. 

  4135.     {9, '*', (Proc) PutInBuffer, 9},
    4136. 

  4136.     /* state 10: "<!" has been read */
    4137. 

  4137.     {10, '-', (Proc) Do_nothing, 11},
    4138. 

  4138.     {10, '[', (Proc) Do_nothing, 23},		/* call subautomaton 23 */
    4139. 

  4139.     {10, 'S', (Proc) Do_nothing, 10},
    4140. 

  4140.     {10, '>', (Proc) Do_nothing, 0},            /* weird empty comment <!> */
    4141. 

  4141.     {10, '*', (Proc) PutInBuffer, 15},
    4142. 

  4142.     /* state 11: "<!-" has been read. Probably a comment */
    4143. 

  4143.     {11, '-', (Proc) StartOfComment, 12},
    4144. 

  4144.     {11, '*', (Proc) PutInBuffer, 15},	/* incorrect comment, expect */
    4145. 

  4145.     /* a closing '>' */
    4146. 

  4146.     /* state 12: reading a comment */
    4147. 

  4147.     {12, '-', (Proc) Do_nothing, 13},
    4148. 

  4148.     {12, '*', (Proc) PutInComment, 12},
    4149. 

  4149.     /* state 13: a dash "-" has been read within a comment */
    4150. 

  4150.     {13, '-', (Proc) Do_nothing, 14},
    4151. 

  4151.     {13, '*', (Proc) PutDash, 12},
    4152. 

  4152.     /* state 14: a double dash "--" has been read within a comment */
    4153. 

  4153.     {14, 'S', (Proc) Do_nothing, 14},
    4154. 

  4154.     {14, '>', (Proc) EndOfComment, 0},
    4155. 

  4155.     {14, '-', (Proc) PutInComment, 14},
    4156. 

  4156.     {14, '*', (Proc) PutDashDash, 12},
    4157. 

  4157.     /* state 15: '<!' has been read. It may be a doctype declaration */
    4158. 

  4158.     {15, '>', (Proc) EndOfDoctypeDecl, 0},
    4159. 

  4159.     {15, '*', (Proc) PutInBuffer, 15},
    4160. 

  4160.     /* state 16: expecting an attribute name or an end of start tag */
    4161. 

  4161.     {16, 'S', (Proc) Do_nothing, 16},
    4162. 

  4162.     {16, '>', (Proc) EndOfStartTag, 0},
    4163. 

  4163.     {16, '<', (Proc) EndOfStartTag, 1},     /* Error: tag not closed */
    4164. 

  4164.     {16, '*', (Proc) PutInBuffer, 4},
    4165. 

  4165.     /* state 17: expecting '=' after an attribute name */
    4166. 

  4166.     {17, 'S', (Proc) Do_nothing, 17},
    4167. 

  4167.     {17, '=', (Proc) Do_nothing, 5},
    4168. 

  4168.     {17, '>', (Proc) EndOfStartTag, 0},
    4169. 

  4169.     {17, '*', (Proc) PutInBuffer, 4},
    4170. 

  4170.     /* state 18: '<' has been read */
    4171. 

  4171.     {18, '!', (Proc) Do_nothing, 19},
    4172. 

  4172.     {18, '*', (Proc) Do_nothing, 0},
    4173. 

  4173.     /* state 19: '<!' has been read */
    4174. 

  4174.     {19, '>', (Proc) PutLess, 0},
    4175. 

  4175.     {19, '*', (Proc) Do_nothing, 0},
    4176. 

  4176.     /* state 20: "<?" has been read; beginning of a Processing Instruction */
    4177. 

  4177.     {20, '?', (Proc) Do_nothing, 21},
    4178. 

  4178.     {20, '*', (Proc) PutInPI, 20},
    4179. 

  4179.     /* state 21: reading the end of Processing Instruction? */
    4180. 

  4180.     {21, '>', (Proc) EndOfPI, 0},
    4181. 

  4181.     {21, '*', (Proc) PutQuestionMark, 20},
    4182. 

  4182.     /* state 22: a question mark has been read in a Processing Instruction */
    4183. 

  4183.     {22, '>', (Proc) EndOfPI, 0},
    4184. 

  4184.     {22, '*', (Proc) PutQuestionMark, 20},
    4185. 

  4185.     /* state 23: "<![*" has been read, wait for CDATA */
    4186. 

  4186.     {23, '[', (Proc) StartCData, 24},
    4187. 

  4187.     {23, 'C', (Proc) PutInBuffer, 23},
    4188. 

  4188.     {23, 'D', (Proc) PutInBuffer, 23},
    4189. 

  4189.     {23, 'A', (Proc) PutInBuffer, 23},
    4190. 

  4190.     {23, 'T', (Proc) PutInBuffer, 23},
    4191. 

  4191.     {23, ']', (Proc) PutInBuffer, -1},
    4192. 

  4192.     {23, '*', (Proc) PutInBuffer, 15},
    4193. 

  4193.     /* state 24: "<![CDATA[" has been read: read its contents */
    4194. 

  4194.     {24, ']', (Proc) PutInBuffer, 25},
    4195. 

  4195.     {24, '\n', (Proc) EndOfCDataLine, 24},
    4196. 

  4196.     {24, '*', (Proc) PutInBuffer, 24},
    4197. 

  4197.     /* state 25: "]" has been read: check the second "]" */
    4198. 

  4198.     {25, ']', (Proc) PutInBuffer, 26},
    4199. 

  4199.     {25, '*', (Proc) PutInBuffer, 24},
    4200. 

  4200.     /* state 26: "]]" has been read: check the end of CDATA */
    4201. 

  4201.     {26, ']', (Proc) PutInBuffer, 26},
    4202. 

  4202.     {26, '>', (Proc) EndOfCData, 0},
    4203. 

  4203.     {26, '*', (Proc) PutInBuffer, 24},
    4204. 

  4204. 

  4205.     /* sub automaton for reading entities in various contexts */
    4206. 

  4206.     /* state -1 means "return to calling state" */
    4207. 

  4207.     /* state 30: a '&' has been read */
    4208. 

  4208.     {30, '#', (Proc) Do_nothing, 32},
    4209. 

  4209.     {30, 'S', (Proc) PutAmpersandSpace, -1},	/* return to calling state */
    4210. 

  4210.     {30, '*', (Proc) EntityChar, 31},
    4211. 

  4211.     /* state 31: reading a string entity */
    4212. 

  4212.     {31, ';', (Proc) EndOfEntity, -1},	/* return to calling state */
    4213. 

  4213.     {31, '*', (Proc) EntityChar, 31},
    4214. 

  4214.     /* state 32: "&#" has been read: reading a numerical entity */
    4215. 

  4215.     {32, 'x', (Proc) Do_nothing, 34},
    4216. 

  4216.     {32, 'X', (Proc) Do_nothing, 34},
    4217. 

  4217.     {32, '*', (Proc) DecEntityChar, 33},
    4218. 

  4218.     /* state 33: "&#x" has been read: reading a decimal value */
    4219. 

  4219.     {33, ';', (Proc) EndOfDecEntity, -1},	/* return to calling state */
    4220. 

  4220.     {33, '*', (Proc) DecEntityChar, 33},
    4221. 

  4221.     /* state 34: "&#x" has been read: reading an hexadecimal value */
    4222. 

  4222.     {34, ';', (Proc) EndOfHexEntity, -1},	/* return to calling state */
    4223. 

  4223.     {34, '*', (Proc) HexEntityChar, 34},
    4224. 

  4224.     /* state 35: reading a ASP */
    4225. 

  4225.     {35, '%', (Proc) PutInASP, 36},
    4226. 

  4226.     {35, '*', (Proc) PutInASP, 35},
    4227. 

  4227.     /* state 36: reading a ASP */
    4228. 

  4228.     {36, '>', (Proc) EndOfASP, 0},
    4229. 

  4229.     {36, '*', (Proc) PutInASP, 35},
    4230. 

  4230. 

  4231.     /* state 1000: fake state. End of automaton table */
    4232. 

  4232.     /* the next line must be the last one in the automaton declaration */
    4233. 

  4233.     {1000, '*', (Proc) Do_nothing, 1000}
    4234. 

  4234.   };
    4235. 

  4235. 

  4236. /*----------------------------------------------------------------------
    4237. 

  4237.   InitAutomaton   read the "source" form of the automaton and
    4238. 

  4238.   build the "executable" form.
    4239. 

  4239.   ----------------------------------------------------------------------*/
    4240. 

  4240. void InitAutomaton (void)
    4241. 

  4241. {
    4242. 

  4242.   int                 entry;
    4243. 

  4243.   State               theState;
    4244. 

  4244.   State               curState;
    4245. 

  4245.   PtrTransition       trans;
    4246. 

  4246.   PtrTransition       prevTrans;
    4247. 

  4247. 

  4248.   for (entry = 0; entry < MaxState; entry++)
    4249. 

  4249.     automaton[entry].firstTransition = NULL;
    4250. 

  4250.   entry = 0;
    4251. 

  4251.   curState = 1000;
    4252. 

  4252.   prevTrans = NULL;
    4253. 

  4253.   do
    4254. 

  4254.     {
    4255. 

  4255.       theState = sourceAutomaton[entry].initState;
    4256. 

  4256.       if (theState < 1000)
    4257. 

  4257.         {
    4258. 

  4258.           trans = (PtrTransition) TtaGetMemory (sizeof (Transition));
    4259. 

  4259.           trans->nextTransition = NULL;
    4260. 

  4260.           trans->trigger = sourceAutomaton[entry].trigger;
    4261. 

  4261.           trans->action = sourceAutomaton[entry].transitionAction;
    4262. 

  4262.           trans->newState = sourceAutomaton[entry].newState;
    4263. 

  4263.           if (trans->trigger == 'S')		/* any spacing character */
    4264. 

  4264.             trans->trigger = SPACE;
    4265. 

  4265.           if (trans->trigger == '*')		/* any character */
    4266. 

  4266.             trans->trigger = EOS;
    4267. 

  4267.           if (theState != curState)
    4268. 

  4268.             {
    4269. 

  4269.               automaton[theState].automatonState = theState;
    4270. 

  4270.               automaton[theState].firstTransition = trans;
    4271. 

  4271.               curState = theState;
    4272. 

  4272.             }
    4273. 

  4273.           else
    4274. 

  4274.             prevTrans->nextTransition = trans;
    4275. 

  4275.           prevTrans = trans;
    4276. 

  4276.           entry++;
    4277. 

  4277.         }
    4278. 

  4278.     }
    4279. 

  4279.   while (theState < 1000);
    4280. 

  4280. }
    4281. 

  4281. 

  4282. /*----------------------------------------------------------------------
    4283. 

  4283.   FreeHTMLParser
    4284. 

  4284.   Frees all ressources associated with the HTML parser.
    4285. 

  4285.   ----------------------------------------------------------------------*/
    4286. 

  4286. void FreeHTMLParser (void)
    4287. 

  4287. {
    4288. 

  4288.   PtrTransition       trans, nextTrans;
    4289. 

  4289.   PtrClosedElement    pClose, nextClose;
    4290. 

  4290.   int		       entry;
    4291. 

  4291. 

  4292.   /* free the internal representation of the automaton */
    4293. 

  4293.   for (entry = 0; entry < MaxState; entry++)
    4294. 

  4294.     {
    4295. 

  4295.       trans = automaton[entry].firstTransition;
    4296. 

  4296.       while (trans != NULL)
    4297. 

  4297.         {
    4298. 

  4298.           nextTrans = trans->nextTransition;
    4299. 

  4299.           TtaFreeMemory (trans);
    4300. 

  4300.           trans = nextTrans;
    4301. 

  4301.         }
    4302. 

  4302.     }
    4303. 

  4303. 

  4304.   /* free descriptors of elements closed by a start tag */
    4305. 

  4305.   for (entry = 0; pHTMLGIMapping[entry].XMLname[0] != EOS; entry++)
    4306. 

  4306.     {
    4307. 

  4307.       pClose = FirstClosedElem[entry];
    4308. 

  4308.       while (pClose != NULL)
    4309. 

  4309.         {
    4310. 

  4310.           nextClose = pClose->nextClosedElem;
    4311. 

  4311.           TtaFreeMemory (pClose);
    4312. 

  4312.           pClose = nextClose;
    4313. 

  4313.         }
    4314. 

  4314.     }
    4315. 

  4315.   TtaFreeMemory (FirstClosedElem);
    4316. 

  4316.   FirstClosedElem = NULL;
    4317. 

  4317. }
    4318. 

  4318. 

  4319. 

  4320. 

  4321. /*----------------------------------------------------------------------
    4322. 

  4322.   GetNextHTMLbuffer returns the next buffer to be parsed and update
    4323. 

  4323.   global variables.
    4324. 

  4324.   ----------------------------------------------------------------------*/
    4325. 

  4325. void GetNextHTMLbuffer (FILE *infile, ThotBool *endOfFile,
    4326. 

  4326.                         char **buff, int *lastchar)
    4327. 

  4327. {
    4328. 

  4328.   CHARSET      charset =  TtaGetDocumentCharset (HTMLcontext.doc);
    4329. 

  4329.   int          res;
    4330. 

  4330. 

  4331.   // copy last treated characters
    4332. 

  4332.   if (StartOfTagIndx > 0)
    4333. 

  4333.     {
    4334. 

  4334.       strncpy (PreviousRead, &WorkBuffer[StartOfTagIndx], PREV_READ_CHARS);
    4335. 

  4335.       LastCharInPreviousRead = LastCharInWorkBuffer - StartOfTagIndx;
    4336. 

  4336.       StartOfTagIndx = 0;
    4337. 

  4337.     }
    4338. 

  4338.   else
    4339. 

  4339.     {
    4340. 

  4340.       PreviousRead[0] = EOS;
    4341. 

  4341.       LastCharInPreviousRead = 0;
    4342. 

  4342.     }
    4343. 

  4343. 

  4344.   *buff = NULL;
    4345. 

  4345.   // free previous translation buffer
    4346. 

  4346.   if (WorkBuffer !=  FileBuffer)
    4347. 

  4347.     {
    4348. 

  4348.       TtaFreeMemory (WorkBuffer);
    4349. 

  4349.       WorkBuffer = FileBuffer;
    4350. 

  4350.     }
    4351. 

  4351.   // need to read a new set of characters
    4352. 

  4352.   LastCharInWorkBuffer = gzread (infile, &FileBuffer[StartOfRead],
    4353. 

  4353.                                  INPUT_FILE_BUFFER_SIZE - StartOfRead);
    4354. 

  4354.   // add previous read characters not managed yet
    4355. 

  4355.   LastCharInWorkBuffer += StartOfRead;
    4356. 

  4356.   StartOfRead = 0;
    4357. 

  4357.   if (LastCharInWorkBuffer <= 0)
    4358. 

  4358.     {
    4359. 

  4359.       /* error or end of file */
    4360. 

  4360.       *endOfFile = TRUE;
    4361. 

  4361.       LastCharInWorkBuffer = 0;
    4362. 

  4362.     }
    4363. 

  4363.   else
    4364. 

  4364.     {
    4365. 

  4365.       FileBuffer[LastCharInWorkBuffer] = EOS;
    4366. 

  4366.       LastCharInWorkBuffer--;
    4367. 

  4367.       if (charset == ISO_8859_2   || charset == ISO_8859_3   ||
    4368. 

  4368.           charset == ISO_8859_4   || charset == ISO_8859_5   ||
    4369. 

  4369.           charset == ISO_8859_6   || charset == ISO_8859_7   ||
    4370. 

  4370.           charset == ISO_8859_8   || charset == ISO_8859_9   ||
    4371. 

  4371.           charset == ISO_8859_15  || charset == KOI8_R       ||
    4372. 

  4372.           charset == WINDOWS_1250 || charset == WINDOWS_1251 ||
    4373. 

  4373.           charset == WINDOWS_1252 || charset == WINDOWS_1253 ||
    4374. 

  4374.           charset == WINDOWS_1254 || charset == WINDOWS_1255 ||
    4375. 

  4375.           charset == WINDOWS_1256 || charset == WINDOWS_1257 ||
    4376. 

  4376.           charset == ISO_2022_JP  || charset == EUC_JP       ||
    4377. 

  4377.           charset == SHIFT_JIS    || charset == GB_2312)
    4378. 

  4378.         {
    4379. 

  4379.           /* convert the original stream into UTF-8 */
    4380. 

  4380.           *buff = (char *)TtaConvertByteToMbsWithCheck ((const unsigned char *)FileBuffer,
    4381. 

  4381.                                                         charset, &res);
    4382. 

  4382.           HTMLcontext.encoding = UTF_8;
    4383. 

  4383.           if (*buff)
    4384. 

  4384.             {
    4385. 

  4385.               WorkBuffer = *buff;
    4386. 

  4386.               if (res > 0 && res < INPUT_FILE_BUFFER_SIZE)
    4387. 

  4387.                 {
    4388. 

  4388.                   // keep last characters for the next read
    4389. 

  4389.                   StartOfRead = INPUT_FILE_BUFFER_SIZE - res;
    4390. 

  4390.                   strcpy (FileBuffer, &FileBuffer[res]);
    4391. 

  4391.                 }
    4392. 

  4392.               LastCharInWorkBuffer = strlen (*buff) - 1;
    4393. 

  4393.             }
    4394. 

  4394.         }
    4395. 

  4395.     }
    4396. 

  4396.   *lastchar = LastCharInWorkBuffer;
    4397. 

  4397. }
    4398. 

  4398. 

  4399. 

  4400. /*----------------------------------------------------------------------
    4401. 

  4401.   GetNextChar returns the next character in the imput file or buffer,
    4402. 

  4402.   whatever it is.
    4403. 

  4403.   ----------------------------------------------------------------------*/
    4404. 

  4404. static char GetNextChar (FILE *infile, char* buffer, int *index,
    4405. 

  4405.                          ThotBool *endOfFile)
    4406. 

  4406. {
    4407. 

  4407.   wchar_t        wcharRead = EOS;
    4408. 

  4408.   unsigned char  charRead;
    4409. 

  4409.   unsigned char  fallback[8];
    4410. 

  4410.   unsigned char *ptr;
    4411. 

  4411.   char          *buff;
    4412. 

  4412.   int            res = 0;
    4413. 

  4413. 

  4414.   charRead = EOS;
    4415. 

  4415.   *endOfFile = FALSE;
    4416. 

  4416. 

  4417.   if (buffer)
    4418. 

  4418.     {
    4419. 

  4419.       /* read from a buffer */
    4420. 

  4420.       if (SecondByte[0] != EOS)
    4421. 

  4421.         {
    4422. 

  4422.           /* return the second UTF-8 byte */
    4423. 

  4423.           charRead = SecondByte[0];
    4424. 

  4424.           /* shift */
    4425. 

  4425.           strncpy ((char *)SecondByte, (char *)&SecondByte[1], 4);
    4426. 

  4426.         }
    4427. 

  4427.       else
    4428. 

  4428.         {
    4429. 

  4429.           charRead = buffer[(*index)++];
    4430. 

  4430.           if (charRead == EOS)
    4431. 

  4431.             *endOfFile = TRUE;
    4432. 

  4432.           else
    4433. 

  4433.             {
    4434. 

  4434.               if (HTMLcontext.encoding != UTF_8)
    4435. 

  4435.                 {
    4436. 

  4436.                   /* translate ISO-latin characters into a UTF-8 string */
    4437. 

  4437.                   ptr = fallback;
    4438. 

  4438.                   wcharRead = TtaGetWCFromChar (charRead, HTMLcontext.encoding);
    4439. 

  4439.                   res = TtaWCToMBstring (wcharRead, &ptr);
    4440. 

  4440.                   /* handle the first character */
    4441. 

  4441.                   charRead = fallback[0];
    4442. 

  4442.                   if (res > 1)
    4443. 

  4443.                     {
    4444. 

  4444.                       /* store the second UTF-8 byte */
    4445. 

  4445.                       res--;
    4446. 

  4446.                       strncpy ((char *)SecondByte, (char *)&fallback[1], res);
    4447. 

  4447.                       SecondByte[res] = EOS;
    4448. 

  4448.                     }
    4449. 

  4449.                 }
    4450. 

  4450.             }
    4451. 

  4451.         }
    4452. 

  4452.     }
    4453. 

  4453.   else if (infile == NULL)
    4454. 

  4454.     *endOfFile = TRUE;
    4455. 

  4455.   else
    4456. 

  4456.     {
    4457. 

  4457.       /* read from a file */
    4458. 

  4458.       if (*index == 0 && SecondByte[0] == EOS)
    4459. 

  4459.         {
    4460. 

  4460.           if (NotToReadFile)
    4461. 

  4461.             NotToReadFile = FALSE;
    4462. 

  4462.           else
    4463. 

  4463.             {
    4464. 

  4464.               // read next characters
    4465. 

  4465.               GetNextHTMLbuffer (infile, endOfFile, &buff, &res);
    4466. 

  4466.               if (*endOfFile)
    4467. 

  4467.                 /* error or end of file */
    4468. 

  4468.                 charRead = EOS;
    4469. 

  4469.             }
    4470. 

  4470.         }
    4471. 

  4471. 	
    4472. 

  4472.       if (NotToReadFile)
    4473. 

  4473.         {
    4474. 

  4474.           charRead = PreviousRead[(*index)++];
    4475. 

  4475.           if (*index > LastCharInPreviousRead)
    4476. 

  4476.             *index = 0;
    4477. 

  4477.         }
    4478. 

  4478.       else if (*endOfFile == FALSE)
    4479. 

  4479.         {
    4480. 

  4480.           if (SecondByte[0] != EOS)
    4481. 

  4481.             {
    4482. 

  4482.               /* return the second UTF-8 byte */
    4483. 

  4483.               charRead = SecondByte[0];
    4484. 

  4484.               /* shift */
    4485. 

  4485.               strncpy ((char *)SecondByte, (char *)&SecondByte[1], 4);
    4486. 

  4486.             }
    4487. 

  4487.           else
    4488. 

  4488.             {
    4489. 

  4489.               charRead = WorkBuffer[(*index)++];
    4490. 

  4490.               if (charRead == EOS)
    4491. 

  4491.                 *endOfFile = TRUE;
    4492. 

  4492.               else
    4493. 

  4493.                 {
    4494. 

  4494.                   if (HTMLcontext.encoding == UTF_8)
    4495. 

  4495.                     {
    4496. 

  4496.                       /* Search for an UTF-8 BOM character (EF BB BF) */
    4497. 

  4497.                       /* Laurent Carcone 7/11/2002 */
    4498. 

  4498.                       if (*index == 1 && LastCharInWorkBuffer > 2 &&
    4499. 

  4499.                           (unsigned char) WorkBuffer[0] == 0xEF &&
    4500. 

  4500.                           (unsigned char) WorkBuffer[1] == 0xBB &&
    4501. 

  4501.                           (unsigned char) WorkBuffer[2] == 0xBF &&
    4502. 

  4502.                           PreviousRead[0] == EOS)
    4503. 

  4503.                         {
    4504. 

  4504.                           charRead = WorkBuffer[(*index)++];
    4505. 

  4505.                           charRead = WorkBuffer[(*index)++];
    4506. 

  4506.                           charRead = WorkBuffer[(*index)++];
    4507. 

  4507.                         }
    4508. 

  4508.                     }
    4509. 

  4509.                   else
    4510. 

  4510.                     {
    4511. 

  4511.                       /* translate the ISO-latin-1 character into a UTF-8 string */
    4512. 

  4512.                       ptr = fallback;
    4513. 

  4513.                       fallback[1] = EOS;
    4514. 

  4514.                       wcharRead = TtaGetWCFromChar (charRead, HTMLcontext.encoding);
    4515. 

  4515.                       res = TtaWCToMBstring (wcharRead, &ptr);
    4516. 

  4516.                       /* handle the first character */
    4517. 

  4517.                       charRead = fallback[0];
    4518. 

  4518.                       if (res > 1)
    4519. 

  4519.                         {
    4520. 

  4520.                           /* store the second UTF-8 byte */
    4521. 

  4521.                           res--;
    4522. 

  4522.                           strncpy ((char *)SecondByte, (char *)&fallback[1], res);
    4523. 

  4523.                           SecondByte[res] = EOS;
    4524. 

  4524.                         }
    4525. 

  4525.                     }
    4526. 

  4526.                 }
    4527. 

  4527.             }
    4528. 

  4528. 	  
    4529. 

  4529.           if (*index > LastCharInWorkBuffer)
    4530. 

  4530.             *index = 0;
    4531. 

  4531.         }
    4532. 

  4532.     }
    4533. 

  4533.   return charRead;
    4534. 

  4534. }
    4535. 

  4535. 

  4536. /*----------------------------------------------------------------------
    4537. 

  4537.   SetElemLineNumber
    4538. 

  4538.   assigns the current line number (number of latest line read from the
    4539. 

  4539.   input file) to element el.
    4540. 

  4540.   ----------------------------------------------------------------------*/
    4541. 

  4541. void SetElemLineNumber (Element el)
    4542. 

  4542. {
    4543. 

  4543.   TtaSetElementLineNumber (el, NumberOfLinesRead);
    4544. 

  4544. }
    4545. 

  4545. 

  4546. /*----------------------------------------------------------------------
    4547. 

  4547.   GetNextInputChar returns the next non-null character in the input
    4548. 

  4548.   file or buffer.
    4549. 

  4549.   ----------------------------------------------------------------------*/
    4550. 

  4550. char GetNextInputChar (FILE *infile, int *index, ThotBool *endOfFile)
    4551. 

  4551. {
    4552. 

  4552.   char    charRead;
    4553. 

  4553.   static  ThotBool beg_pair;
    4554. 

  4554. 

  4555.   charRead = EOS;
    4556. 

  4556.   *endOfFile = FALSE;
    4557. 

  4557.   if (PreviousBufChar != EOS)
    4558. 

  4558.     {
    4559. 

  4559.       charRead = PreviousBufChar;
    4560. 

  4560.       PreviousBufChar = EOS;
    4561. 

  4561.     }
    4562. 

  4562.   else 
    4563. 

  4563.     {
    4564. 

  4564.       charRead = GetNextChar (infile, InputText, index, endOfFile);
    4565. 

  4565.       if (InputText == NULL)
    4566. 

  4566.         NumberOfCharRead++;
    4567. 

  4567.       /* skip null characters*/
    4568. 

  4568.       while (charRead == EOS && !*endOfFile)
    4569. 

  4569.         {
    4570. 

  4570.           charRead = GetNextChar (infile, InputText, index, endOfFile);
    4571. 

  4571.           if (InputText == NULL)
    4572. 

  4572.             NumberOfCharRead++;
    4573. 

  4573.         }
    4574. 

  4574.     }
    4575. 

  4575.   if (*endOfFile == FALSE)
    4576. 

  4576.     {
    4577. 

  4577.       if ((int) charRead == __CR__)
    4578. 

  4578.         /* CR has been read */
    4579. 

  4579.         {
    4580. 

  4580.           /* Read next character */
    4581. 

  4581.           charRead = GetNextChar (infile, InputText, index, endOfFile);
    4582. 

  4582.           if ((int) charRead != EOL && (int) charRead != __CR__)
    4583. 

  4583.             /* next character is not LF. Store next character and return LF */
    4584. 

  4584.             {
    4585. 

  4585.               PreviousBufChar = charRead;
    4586. 

  4586.               charRead = EOL;
    4587. 

  4587.             }
    4588. 

  4588.         }
    4589. 

  4589.       /* update the counters of characters and lines read */
    4590. 

  4590.       if ((int) charRead == EOL || (int) charRead == __CR__)
    4591. 

  4591.         {
    4592. 

  4592.           if ((int) charRead == __CR__)
    4593. 

  4593.             {
    4594. 

  4594.               beg_pair = TRUE;
    4595. 

  4595.               if (InputText == NULL)
    4596. 

  4596.                 NumberOfLinesRead++;
    4597. 

  4597.               NumberOfCharRead = 0;
    4598. 

  4598.             }
    4599. 

  4599.           else
    4600. 

  4600.             {
    4601. 

  4601.               if (!beg_pair)
    4602. 

  4602.                 {
    4603. 

  4603.                   if (InputText == NULL)
    4604. 

  4604.                     NumberOfLinesRead++;
    4605. 

  4605.                   NumberOfCharRead = 0;
    4606. 

  4606.                 }
    4607. 

  4607.               else
    4608. 

  4608.                 beg_pair = FALSE;
    4609. 

  4609.             }
    4610. 

  4610.         }
    4611. 

  4611.       else
    4612. 

  4612.         beg_pair = FALSE;
    4613. 

  4613.     }
    4614. 

  4614.   return charRead;
    4615. 

  4615. }
    4616. 

  4616. 

  4617. /*----------------------------------------------------------------------
    4618. 

  4618.   HTMLparse       
    4619. 

  4619.   Parse either the HTML file infile or the text buffer HTMLbuf and
    4620. 

  4620.   build the equivalent Thot abstract tree.
    4621. 

  4621.   One parameter should be NULL.
    4622. 

  4622.   ----------------------------------------------------------------------*/
    4623. 

  4623. static void HTMLparse (FILE * infile, char* HTMLbuf)
    4624. 

  4624. {
    4625. 

  4625.   unsigned char         charRead;
    4626. 

  4626.   PtrTransition         trans;
    4627. 

  4627.   ThotBool              match;
    4628. 

  4628.   
    4629. 

  4629.   currentState = 0;
    4630. 

  4630.   if (HTMLbuf != NULL || infile != NULL)
    4631. 

  4631.     {
    4632. 

  4632.       InputText = HTMLbuf;
    4633. 

  4633.       EndOfHtmlFile = FALSE;
    4634. 

  4634.     }
    4635. 

  4635.   charRead = EOS;
    4636. 

  4636.   HTMLrootClosed = FALSE;
    4637. 

  4637.   
    4638. 

  4638.   /* read the HTML file sequentially */
    4639. 

  4639.   do
    4640. 

  4640.     {
    4641. 

  4641.       /* read one character from the source if the last character */
    4642. 

  4642.       /* read has been processed */
    4643. 

  4643.       if (charRead == EOS)
    4644. 

  4644.         charRead = GetNextInputChar (infile, &CurrentBufChar, &EndOfHtmlFile);
    4645. 

  4645.       if (charRead != EOS)
    4646. 

  4646.         {
    4647. 

  4647.           /* Check the character read */
    4648. 

  4648.           /* Consider LF and FF as the end of an input line. */
    4649. 

  4649.           /* Replace end of line by space, except in preformatted text. */
    4650. 

  4650.           /* Replace HT by space, except in preformatted text. */
    4651. 

  4651.           /* Ignore spaces at the beginning and at the end of input lines */
    4652. 

  4652.           /* Ignore non printable characters except HT, LF, FF. */
    4653. 

  4653.           if ((int) charRead == EOL || (int) charRead == __CR__)
    4654. 

  4654.             /* LF = end of input line */
    4655. 

  4655.             {
    4656. 

  4656.               /* don't replace end of line by space in a doctype declaration */
    4657. 

  4657.               if (currentState != 12 && currentState != 15 &&
    4658. 

  4658.                   currentState != 20 && currentState != 21 &&
    4659. 

  4659.                   currentState != 24 && currentState != 35)
    4660. 

  4660.                 {
    4661. 

  4661.                   /* don't change characters in comments */
    4662. 

  4662.                   if (currentState != 0)
    4663. 

  4663.                     /* not within a text element */
    4664. 

  4664.                     {
    4665. 

  4665.                       if (currentState == 6 || currentState == 9)
    4666. 

  4666.                         /* within an attribute value between quotes */
    4667. 

  4667.                         if (lastAttrEntry != NULL &&
    4668. 

  4668.                             !strcmp (lastAttrEntry->XMLattribute, "src"))
    4669. 

  4669.                           /* value of an SRC attribute */
    4670. 

  4670.                           /* consider new line as an empty char*/
    4671. 

  4671.                           charRead = EOS;
    4672. 

  4672.                       if (charRead != EOS)
    4673. 

  4673.                         {
    4674. 

  4674.                           /* Replace new line by a space, except if an entity is
    4675. 

  4675.                              being read */
    4676. 

  4676.                           if (currentState == 30 &&
    4677. 

  4677.                               Within (HTML_EL_Preformatted, DocumentSSchema) &&
    4678. 

  4678.                               !Within (HTML_EL_Option_Menu, DocumentSSchema))
    4679. 

  4679.                             charRead = EOL; /* new line character */
    4680. 

  4680.                           else
    4681. 

  4681.                             charRead = SPACE;
    4682. 

  4682.                         }
    4683. 

  4683.                     }
    4684. 

  4684.                   else if ((Within (HTML_EL_Preformatted, DocumentSSchema) &&
    4685. 

  4685.                             !Within (HTML_EL_Option_Menu, DocumentSSchema)) ||
    4686. 

  4686.                            Within (HTML_EL_Text_Area, DocumentSSchema) ||
    4687. 

  4687.                            Within (HTML_EL_SCRIPT_, DocumentSSchema) ||
    4688. 

  4688.                            Within (HTML_EL_STYLE_, DocumentSSchema))
    4689. 

  4689.                     /* new line in a text element */
    4690. 

  4690.                     {
    4691. 

  4691.                       /* within preformatted text */
    4692. 

  4692.                       if (AfterTagPRE)
    4693. 

  4693.                         /* ignore NL after a <PRE> tag */
    4694. 

  4694.                         charRead = EOS;
    4695. 

  4695.                       else
    4696. 

  4696.                         /* generate a new line character */
    4697. 

  4697.                         charRead = EOL;
    4698. 

  4698.                     }
    4699. 

  4699.                   else
    4700. 

  4700.                     /* new line in ordinary text */
    4701. 

  4701.                     {
    4702. 

  4702.                       /* suppress all spaces preceding the end of line */
    4703. 

  4703.                       while (LgBuffer > 0 &&
    4704. 

  4704.                              inputBuffer[LgBuffer - 1] == SPACE)
    4705. 

  4705.                         LgBuffer--;
    4706. 

  4706.                       /* new line is equivalent to space */
    4707. 

  4707.                       charRead = SPACE;
    4708. 

  4708.                       if (LgBuffer > 0)
    4709. 

  4709.                         TextToDocument ();
    4710. 

  4710.                     }
    4711. 

  4711.                 }
    4712. 

  4712.               /* beginning of a new input line */
    4713. 

  4713.               EmptyLine = TRUE;
    4714. 

  4714.             }
    4715. 

  4715.           else
    4716. 

  4716.             /* it's not an end of line */
    4717. 

  4717.             {
    4718. 

  4718.               if ((int) charRead == TAB)
    4719. 

  4719.                 /* HT = Horizontal tabulation */
    4720. 

  4720.                 {
    4721. 

  4721.                   if (currentState != 0)
    4722. 

  4722.                     /* not in a text element. Replace HT by space */
    4723. 

  4723.                     charRead = SPACE;
    4724. 

  4724.                   else
    4725. 

  4725.                     /* in a text element. Replace HT by space except in */
    4726. 

  4726.                     /* preformatted text */
    4727. 

  4727.                     if (!Within (HTML_EL_Preformatted, DocumentSSchema) &&
    4728. 

  4728.                         !Within (HTML_EL_STYLE_, DocumentSSchema) &&
    4729. 

  4729.                         !Within (HTML_EL_SCRIPT_, DocumentSSchema))
    4730. 

  4730.                       charRead = SPACE;
    4731. 

  4731.                 }
    4732. 

  4732.               if (charRead == SPACE)
    4733. 

  4733.                 /* space character */
    4734. 

  4734.                 {
    4735. 

  4735.                   if (currentState == 12 || currentState == 35 ||
    4736. 

  4736.                       currentState == 20 || currentState == 21 ||
    4737. 

  4737.                       (currentState == 0 &&
    4738. 

  4738.                        !Within (HTML_EL_Preformatted, DocumentSSchema) &&
    4739. 

  4739.                        !Within (HTML_EL_STYLE_, DocumentSSchema) &&
    4740. 

  4740.                        !Within (HTML_EL_SCRIPT_, DocumentSSchema) &&
    4741. 

  4741.                        !Within (HTML_EL_Text_Area, DocumentSSchema)))
    4742. 

  4742.                     {
    4743. 

  4743.                       if (EmptyLine)
    4744. 

  4744.                         /* ignore spaces at the beginning of an input line */
    4745. 

  4745.                         charRead = EOS;
    4746. 

  4746.                       else if (LgBuffer > 0 && inputBuffer[LgBuffer-1] == SPACE)
    4747. 

  4747.                         /* ignore multiple spaces */
    4748. 

  4748.                         charRead = EOS;
    4749. 

  4749.                     }
    4750. 

  4750.                 }
    4751. 

  4751.               else
    4752. 

  4752.                 /* it's a printable character. Keep it as it is and */
    4753. 

  4753.                 /* stop ignoring spaces */
    4754. 

  4754.                 {
    4755. 

  4755.                   EmptyLine = FALSE;
    4756. 

  4756.                   StartOfFile = FALSE;
    4757. 

  4757.                 }
    4758. 

  4758.             }
    4759. 

  4759.           AfterTagPRE = FALSE;
    4760. 

  4760.           
    4761. 

  4761.           if (charRead != EOS)
    4762. 

  4762.             /* a valid character has been read */
    4763. 

  4763.             {
    4764. 

  4764.               /* first transition of the automaton for the current state */
    4765. 

  4765.               trans = automaton[currentState].firstTransition;
    4766. 

  4766.               /* search a transition triggered by the character read */
    4767. 

  4767.               while (trans != NULL && !HTMLrootClosed)
    4768. 

  4768.                 {
    4769. 

  4769.                   match = FALSE;
    4770. 

  4770.                   if (charRead == trans->trigger)
    4771. 

  4771.                     /* the char is the trigger */
    4772. 

  4772.                     match = TRUE;
    4773. 

  4773.                   else if (trans->trigger == EOS)
    4774. 

  4774.                     /* any char is a trigger */
    4775. 

  4775.                     match = TRUE;
    4776. 

  4776.                   else if (trans->trigger == SPACE)
    4777. 

  4777.                     /* any space is a trigger */
    4778. 

  4778.                     if ((int) charRead == TAB ||
    4779. 

  4779.                         (int) charRead == EOL ||
    4780. 

  4780.                         (int) charRead == 12)
    4781. 

  4781.                       /* a delimiter has been read */
    4782. 

  4782.                       match = TRUE;
    4783. 

  4783.                   if (match)
    4784. 

  4784.                     /* transition found. Activate the transition */
    4785. 

  4785.                     {
    4786. 

  4786.                       NormalTransition = TRUE;
    4787. 

  4787.                       /* call the procedure associated with the transition */
    4788. 

  4788.                       CharProcessed = FALSE;
    4789. 

  4789.                       if (trans->action != NULL)
    4790. 

  4790.                         (*((Proc1)trans->action)) ((void *)(int)charRead);
    4791. 

  4791.                       if (NormalTransition || CharProcessed)
    4792. 

  4792.                         /* the input character has been processed */
    4793. 

  4793.                         charRead = EOS;
    4794. 

  4794.                       
    4795. 

  4795.                       if (NormalTransition)
    4796. 

  4796.                         {
    4797. 

  4797.                           /* the procedure associated with the transition has not */
    4798. 

  4798.                           /* changed state explicitely */
    4799. 

  4799.                           /* change current automaton state */
    4800. 

  4800.                           if (trans->newState >= 0)
    4801. 

  4801.                             currentState = trans->newState;
    4802. 

  4802.                           else if (trans->newState == -1)
    4803. 

  4803.                             /* return form subautomaton */
    4804. 

  4804.                             currentState = returnState;
    4805. 

  4805.                           else
    4806. 

  4806.                             /* calling a subautomaton */
    4807. 

  4807.                             {
    4808. 

  4808.                               returnState = currentState;
    4809. 

  4809.                               currentState = -trans->newState;
    4810. 

  4810.                             }
    4811. 

  4811.                         }
    4812. 

  4812.                       /* done */
    4813. 

  4813.                       trans = NULL;
    4814. 

  4814.                     }
    4815. 

  4815.                   else
    4816. 

  4816.                     /* access next transition from the same state */
    4817. 

  4817.                     {
    4818. 

  4818.                       trans = trans->nextTransition;
    4819. 

  4819.                       /* an exception: when reading the value of an HREF attribute,
    4820. 

  4820.                          SGML entities (&xxx;) should not be interpreted */
    4821. 

  4821.                       if (trans == NULL)
    4822. 

  4822.                         charRead = EOS;
    4823. 

  4823.                     }
    4824. 

  4824.                 }
    4825. 

  4825.             }
    4826. 

  4826.         }
    4827. 

  4827.     }
    4828. 

  4828.   while (!EndOfHtmlFile && !HTMLrootClosed);
    4829. 

  4829.   /* end of HTML file */
    4830. 

  4830.   
    4831. 

  4831.   if (!HTMLrootClosed)
    4832. 

  4832.     EndOfDocument ();
    4833. 

  4833.   HTMLrootClosingTag = NULL;
    4834. 

  4834.   HTMLrootClosed = FALSE;
    4835. 

  4835. }
    4836. 

  4836. 

  4837. /*----------------------------------------------------------------------
    4838. 

  4838.   GetANewText generates a new text element within a line.
    4839. 

  4839.   ----------------------------------------------------------------------*/
    4840. 

  4840. static Element GetANewText (Element el, ElementType elType, Document doc)
    4841. 

  4841. {
    4842. 

  4842.   Element             elLeaf;
    4843. 

  4843. 

  4844.   if (LgBuffer)
    4845. 

  4845.     {
    4846. 

  4846.       inputBuffer[LgBuffer] = EOS;
    4847. 

  4847.       TtaAppendTextContent (el, (unsigned char *)inputBuffer, doc);
    4848. 

  4848.       LgBuffer = 0;
    4849. 

  4849.       /* Create a new text leaf */
    4850. 

  4850.       elType.ElTypeNum = TextFile_EL_TEXT_UNIT;
    4851. 

  4851.       elLeaf = TtaNewElement (doc, elType);
    4852. 

  4852.       TtaSetElementLineNumber (elLeaf, NumberOfLinesRead);
    4853. 

  4853.       TtaInsertSibling (elLeaf, el,  FALSE, doc);
    4854. 

  4854.       el = elLeaf;
    4855. 

  4855.       HTMLcontext.lastElement = el;
    4856. 

  4856.     }
    4857. 

  4857.   return el;
    4858. 

  4858. }
    4859. 

  4859. 

  4860. /*----------------------------------------------------------------------
    4861. 

  4861.   ReadTextFile
    4862. 

  4862.   read plain text file into a TextFile document.
    4863. 

  4863.   input text comes from either the infile file or the text
    4864. 

  4864.   buffer textbuf. One parameter should be NULL.
    4865. 

  4865.   ----------------------------------------------------------------------*/
    4866. 

  4866. static void ReadTextFile (FILE *infile, char *textbuf, Document doc,
    4867. 

  4867.                           const char *pathURL)
    4868. 

  4868. {
    4869. 

  4869.   Element             parent, el, prev;
    4870. 

  4870.   Element             elLeaf;
    4871. 

  4871.   ElementType         elType;
    4872. 

  4872.   AttributeType       attrType;
    4873. 

  4873.   Attribute	      attr;
    4874. 

  4874.   unsigned char       charRead;
    4875. 

  4875.   int		      val;
    4876. 

  4876.   ThotBool            endOfTextFile, color_source;
    4877. 

  4877.   ThotBool            withinMarkup = FALSE;
    4878. 

  4878.   ThotBool            withinQuote = FALSE, withinString = FALSE;
    4879. 

  4879.   ThotBool            withinComment = FALSE;
    4880. 

  4880. 

  4881.   InputText = textbuf;
    4882. 

  4882.   LgBuffer = 0;
    4883. 

  4883.   endOfTextFile = FALSE;
    4884. 

  4884.   NumberOfCharRead = 0;
    4885. 

  4885.   NumberOfLinesRead = 1; 
    4886. 

  4886.   CurrentBufChar = 0;
    4887. 

  4887.   TtaGetEnvBoolean ("COLOR_SOURCE", &color_source);
    4888. 

  4888. 

  4889. #ifdef ANNOTATIONS
    4890. 

  4890.   if (DocumentTypes[doc] == docAnnot)
    4891. 

  4891.     /* we search the start of HTML document in the annotation struct */
    4892. 

  4892.     parent = ANNOT_GetHTMLRoot (doc, TRUE);
    4893. 

  4893.   else
    4894. 

  4894. #endif /* ANNOTATIONS */
    4895. 

  4895.     parent = TtaGetRootElement (doc);    /* the root element */
    4896. 

  4896. 

  4897.   elType = TtaGetElementType (parent);
    4898. 

  4898.   el = TtaGetFirstChild (parent);    /* first child of the root element */
    4899. 

  4899.   if (el == NULL)
    4900. 

  4900.     {
    4901. 

  4901.       /* insert the Document_URL element */
    4902. 

  4902.       elType.ElTypeNum = TextFile_EL_Document_URL;
    4903. 

  4903.       prev = TtaNewTree (doc, elType, "");
    4904. 

  4904.       TtaInsertFirstChild (&prev, parent, doc);
    4905. 

  4905.       /* prevent the user from editing this element */
    4906. 

  4906.       TtaSetAccessRight (prev, ReadOnly, doc);
    4907. 

  4907.       if (pathURL != NULL && prev != NULL)
    4908. 

  4908.         {
    4909. 

  4909.           el = TtaGetFirstChild (prev);
    4910. 

  4910.           TtaSetTextContent (el, (unsigned char *)pathURL,
    4911. 

  4911.                              HTMLcontext.language, doc);
    4912. 

  4912.         }
    4913. 

  4913.       /* insert the BODY element */
    4914. 

  4914.       elType.ElTypeNum = TextFile_EL_BODY;
    4915. 

  4915.       el = TtaNewElement (doc, elType);
    4916. 

  4916.       TtaSetElementLineNumber (el, NumberOfLinesRead);      
    4917. 

  4917.       if (prev != NULL)
    4918. 

  4918.         TtaInsertSibling (el, prev,  FALSE, doc);
    4919. 

  4919.       else
    4920. 

  4920.         TtaInsertFirstChild (&el, parent, doc);
    4921. 

  4921.       parent = el;
    4922. 

  4922.     }
    4923. 

  4923.   prev = el = NULL;
    4924. 

  4924.   /* initialize the context */
    4925. 

  4925.   HTMLcontext.encoding = TtaGetDocumentCharset (doc);
    4926. 

  4926.   HTMLcontext.lastElement = NULL;
    4927. 

  4927.   HTMLcontext.lastElementClosed = False;
    4928. 

  4928.   HTMLcontext.doc = doc;
    4929. 

  4929.   HTMLcontext.mergeText = FALSE;
    4930. 

  4930.   HTMLcontext.language = TtaGetDefaultLanguage ();
    4931. 

  4931.   attrType.AttrSSchema = TtaGetSSchema ("TextFile", doc);
    4932. 

  4932.   /* initialize input buffer */
    4933. 

  4933.   charRead = GetNextInputChar (infile, &CurrentBufChar, &endOfTextFile);
    4934. 

  4934.   /* read the text file sequentially */
    4935. 

  4935.   while (!endOfTextFile)
    4936. 

  4936.     {
    4937. 

  4937.       if (el == NULL)
    4938. 

  4938.         {
    4939. 

  4939.           /* create a new line */
    4940. 

  4940.           elType.ElTypeNum = TextFile_EL_Line_;
    4941. 

  4941.           el = TtaNewTree (doc, elType, "");
    4942. 

  4942.           TtaSetElementLineNumber (el, NumberOfLinesRead);      
    4943. 

  4943.           if (prev != NULL)
    4944. 

  4944.             /* new line after the previous */
    4945. 

  4945.             TtaInsertSibling (el, prev,  FALSE, doc);
    4946. 

  4946.           else
    4947. 

  4947.             /* first line */
    4948. 

  4948.             TtaInsertFirstChild (&el, parent, doc);
    4949. 

  4949.           prev = el;
    4950. 

  4950.           /* get the text element */
    4951. 

  4951.           el = TtaGetFirstChild (el);
    4952. 

  4952.           TtaSetElementLineNumber (el, NumberOfLinesRead);      
    4953. 

  4953.           HTMLcontext.lastElement = el;
    4954. 

  4954.         }
    4955. 

  4955.       else if (HTMLcontext.lastElement && HTMLcontext.lastElement != el)
    4956. 

  4956.         {
    4957. 

  4957.           /* one or more symbols were inserted */
    4958. 

  4958.           elType.ElTypeNum = TextFile_EL_TEXT_UNIT;
    4959. 

  4959.           el = TtaNewElement (doc, elType);
    4960. 

  4960.           TtaSetElementLineNumber (el, NumberOfLinesRead);      
    4961. 

  4961.           TtaInsertSibling (el, HTMLcontext.lastElement,  FALSE, doc);
    4962. 

  4962.           HTMLcontext.lastElement = el;
    4963. 

  4963.         }
    4964. 

  4964. 

  4965.       /* Check the character read */
    4966. 

  4966.       /* Consider LF and FF as the end of an input line. */
    4967. 

  4967.       if ((int) charRead == EOL || (int) charRead == 0)
    4968. 

  4968.         {
    4969. 

  4969.           /* LF = end of line */
    4970. 

  4970.           inputBuffer[LgBuffer] = EOS;
    4971. 

  4971.           if (LgBuffer > 0)
    4972. 

  4972.             {
    4973. 

  4973.               TtaAppendTextContent (el, (unsigned char *)inputBuffer, doc);
    4974. 

  4974.               LgBuffer = 0;
    4975. 

  4975.               attrType.AttrTypeNum = 0;
    4976. 

  4976.               if (withinMarkup)
    4977. 

  4977.                 {
    4978. 

  4978.                   /* attach the markup attribute */
    4979. 

  4979.                   attrType.AttrTypeNum = TextFile_ATTR_IsMarkup;
    4980. 

  4980.                   val = TextFile_ATTR_IsMarkup_VAL_Yes_;
    4981. 

  4981.                 }
    4982. 

  4982.               else if (withinComment)
    4983. 

  4983.                 {
    4984. 

  4984.                   /* attach the markup attribute */
    4985. 

  4985.                   attrType.AttrTypeNum = TextFile_ATTR_IsComment;
    4986. 

  4986.                   val = TextFile_ATTR_IsComment_VAL_Yes_;
    4987. 

  4987.                 }
    4988. 

  4988.               else if (withinString)
    4989. 

  4989.                 {
    4990. 

  4990.                   /* attach the markup attribute */
    4991. 

  4991.                   attrType.AttrTypeNum = TextFile_ATTR_IsString;
    4992. 

  4992.                   val = TextFile_ATTR_IsString_VAL_Yes_;
    4993. 

  4993.                 }
    4994. 

  4994.               if (withinMarkup || withinComment || withinString)
    4995. 

  4995.                 {
    4996. 

  4996.                   attr = TtaGetAttribute (el, attrType);
    4997. 

  4997.                   if (attr == NULL)
    4998. 

  4998.                     {
    4999. 

  4999.                       attr = TtaNewAttribute (attrType);
    5000. 

  5000.                       TtaAttachAttribute (el, attr, doc);
    5001. 

  5001.                       TtaSetAttributeValue (attr, val, el, doc);
    5002. 

  5002.                     }
    5003. 

  5003.                 }
    5004. 

  5004.             }
    5005. 

  5005.           el = NULL; /* generate a new line */
    5006. 

  5006.           charRead = EOS;
    5007. 

  5007.         }
    5008. 

  5008. 

  5009.       if (charRead != EOS)
    5010. 

  5010.         {
    5011. 

  5011.           /* a valid character has been read */
    5012. 

  5012.           if (!color_source)
    5013. 

  5013.             {
    5014. 

  5014.               if (LgBuffer + 1 >= AllmostFullBuffer)
    5015. 

  5015.                 {
    5016. 

  5016.                   /* store the current buffer contents and continue */
    5017. 

  5017.                   inputBuffer[LgBuffer] = EOS;
    5018. 

  5018.                   TtaAppendTextContent (el, (unsigned char *)inputBuffer, doc);
    5019. 

  5019.                   LgBuffer = 0;
    5020. 

  5020.                   inputBuffer[LgBuffer++] = charRead;
    5021. 

  5021.                 }
    5022. 

  5022.               else
    5023. 

  5023.                 inputBuffer[LgBuffer++] = charRead;
    5024. 

  5024.             }
    5025. 

  5025.           else if (charRead == '@' && DocumentTypes[doc] == docLog && LgBuffer == 0)
    5026. 

  5026.             {
    5027. 

  5027.               attrType.AttrTypeNum = TextFile_ATTR_IsLink;
    5028. 

  5028.               val = TextFile_ATTR_IsLink_VAL_Yes_;
    5029. 

  5029.               attr = TtaNewAttribute (attrType);
    5030. 

  5030.               TtaAttachAttribute (el, attr, doc);
    5031. 

  5031.               TtaSetAttributeValue (attr, val, el, doc);
    5032. 

  5032.             }
    5033. 

  5033.           else if (withinMarkup &&
    5034. 

  5034.                    DocumentTypes[doc] != docCSS &&
    5035. 

  5035.                    DocumentTypes[doc] != docLog &&
    5036. 

  5036.                    DocumentTypes[doc] != docText &&
    5037. 

  5037.                    charRead == '-' &&
    5038. 

  5038.                    !withinString &&
    5039. 

  5039.                    LgBuffer > 2 &&
    5040. 

  5040.                    inputBuffer[LgBuffer-1] == '-' &&
    5041. 

  5041.                    inputBuffer[LgBuffer-2] == '!' &&
    5042. 

  5042.                    inputBuffer[LgBuffer-3] == '<')
    5043. 

  5043.             {
    5044. 

  5044.               /* Start a XML comment */
    5045. 

  5045.               withinMarkup = FALSE;
    5046. 

  5046.               withinComment = TRUE;
    5047. 

  5047.               /* add the current character */
    5048. 

  5048.               inputBuffer[LgBuffer++] = charRead;
    5049. 

  5049.             }
    5050. 

  5050.           else if (withinComment &&
    5051. 

  5051.                    DocumentTypes[doc] != docCSS &&
    5052. 

  5052.                    DocumentTypes[doc] != docLog &&
    5053. 

  5053.                    DocumentTypes[doc] != docText &&
    5054. 

  5054.                    charRead == '>' &&
    5055. 

  5055.                    !withinString &&
    5056. 

  5056.                    LgBuffer > 1 &&
    5057. 

  5057.                    inputBuffer[LgBuffer-1] == '-' &&
    5058. 

  5058.                    inputBuffer[LgBuffer-2] == '-')
    5059. 

  5059.             {
    5060. 

  5060.               /* End a XML comment */
    5061. 

  5061.               withinComment = FALSE;
    5062. 

  5062.               /* add the current character */
    5063. 

  5063.               inputBuffer[LgBuffer++] = charRead;
    5064. 

  5064.               /* attach the markup attribute */
    5065. 

  5065.               attrType.AttrTypeNum = TextFile_ATTR_IsComment;
    5066. 

  5066.               attr = TtaGetAttribute (el, attrType);
    5067. 

  5067.               if (attr == NULL)
    5068. 

  5068.                 {
    5069. 

  5069.                   attr = TtaNewAttribute (attrType);
    5070. 

  5070.                   val = TextFile_ATTR_IsComment_VAL_Yes_;
    5071. 

  5071.                   TtaAttachAttribute (el, attr, doc);
    5072. 

  5072.                   TtaSetAttributeValue (attr, val, el, doc);
    5073. 

  5073.                 }
    5074. 

  5074.               /* generate a new IsString element */
    5075. 

  5075.               el = GetANewText (el, elType, doc);
    5076. 

  5076.             }
    5077. 

  5077.           else if (!withinQuote && !withinComment &&
    5078. 

  5078.                    DocumentTypes[doc] != docCSS &&
    5079. 

  5079.                    DocumentTypes[doc] != docLog &&
    5080. 

  5080.                    DocumentTypes[doc] != docText &&
    5081. 

  5081.                    ((charRead == '"' && withinString) ||
    5082. 

  5082.                     (charRead == '"' && !withinString &&
    5083. 

  5083.                      LgBuffer > 0 && inputBuffer[LgBuffer-1] == '=') ||
    5084. 

  5084.                     (LgBuffer == 0 && withinString)))
    5085. 

  5085.             {
    5086. 

  5086.               /* Start/end a string */
    5087. 

  5087.               if (charRead == '"')
    5088. 

  5088.                 withinString = !withinString;
    5089. 

  5089.               if (withinString)
    5090. 

  5090.                 {
    5091. 

  5091.                   if (withinMarkup)
    5092. 

  5092.                     {
    5093. 

  5093.                       /* attach the markup attribute */
    5094. 

  5094.                       attrType.AttrTypeNum = TextFile_ATTR_IsMarkup;
    5095. 

  5095.                       attr = TtaGetAttribute (el, attrType);
    5096. 

  5096.                       if (attr == NULL)
    5097. 

  5097.                         {
    5098. 

  5098.                           attr = TtaNewAttribute (attrType);
    5099. 

  5099.                           val = TextFile_ATTR_IsMarkup_VAL_Yes_;
    5100. 

  5100.                           TtaAttachAttribute (el, attr, doc);
    5101. 

  5101.                           TtaSetAttributeValue (attr, val, el, doc);
    5102. 

  5102.                         }
    5103. 

  5103.                     }
    5104. 

  5104.                   /* generate a new IsString element */
    5105. 

  5105.                   el = GetANewText (el, elType, doc);
    5106. 

  5106.                   attrType.AttrTypeNum = TextFile_ATTR_IsString;
    5107. 

  5107.                   attr = TtaGetAttribute (el, attrType);
    5108. 

  5108.                   if (attr == NULL)
    5109. 

  5109.                     {
    5110. 

  5110.                       attr = TtaNewAttribute (attrType);
    5111. 

  5111.                       val = TextFile_ATTR_IsString_VAL_Yes_;
    5112. 

  5112.                       TtaAttachAttribute (el, attr, doc);
    5113. 

  5113.                       TtaSetAttributeValue (attr, val, el, doc);
    5114. 

  5114.                     }
    5115. 

  5115.                   /* add the current character */
    5116. 

  5116.                   inputBuffer[LgBuffer++] = charRead;
    5117. 

  5117.                 }
    5118. 

  5118.               else
    5119. 

  5119.                 {
    5120. 

  5120.                   /* add the current character */
    5121. 

  5121.                   inputBuffer[LgBuffer++] = charRead;
    5122. 

  5122.                   /* close the IsString element */
    5123. 

  5123.                   el = GetANewText (el, elType, doc);
    5124. 

  5124.                 }
    5125. 

  5125.             }
    5126. 

  5126.           else if (!withinString && !withinComment &&
    5127. 

  5127.                    DocumentTypes[doc] != docCSS &&
    5128. 

  5128.                    DocumentTypes[doc] != docLog &&
    5129. 

  5129.                    DocumentTypes[doc] != docText &&
    5130. 

  5130.                    ((charRead == '\'' && withinQuote) ||
    5131. 

  5131.                     (charRead == '\'' && !withinQuote &&
    5132. 

  5132.                      LgBuffer > 0 && inputBuffer[LgBuffer-1] == '=') ||
    5133. 

  5133.                     (LgBuffer == 0 && withinQuote)))
    5134. 

  5134.             {
    5135. 

  5135.               if (charRead == '\'')
    5136. 

  5136.                 withinQuote = !withinQuote;
    5137. 

  5137.               if (withinQuote)
    5138. 

  5138.                 {
    5139. 

  5139.                   /* generate a new IsString element */
    5140. 

  5140.                   el = GetANewText (el, elType, doc);
    5141. 

  5141.                   attrType.AttrTypeNum = TextFile_ATTR_IsString;
    5142. 

  5142.                   attr = TtaGetAttribute (el, attrType);
    5143. 

  5143.                   if (attr == NULL)
    5144. 

  5144.                     {
    5145. 

  5145.                       attr = TtaNewAttribute (attrType);
    5146. 

  5146.                       val = TextFile_ATTR_IsString_VAL_Yes_;
    5147. 

  5147.                       TtaAttachAttribute (el, attr, doc);
    5148. 

  5148.                       TtaSetAttributeValue (attr, val, el, doc);
    5149. 

  5149.                     }
    5150. 

  5150.                   /* add the current character */
    5151. 

  5151.                   inputBuffer[LgBuffer++] = charRead;
    5152. 

  5152.                 }
    5153. 

  5153.               else
    5154. 

  5154.                 {
    5155. 

  5155.                   /* add the current character */
    5156. 

  5156.                   inputBuffer[LgBuffer++] = charRead;
    5157. 

  5157.                   /* close the IsString element */
    5158. 

  5158.                   el = GetANewText (el, elType, doc);
    5159. 

  5159.                 }
    5160. 

  5160.             }
    5161. 

  5161.           else if (!withinString && !withinQuote &&
    5162. 

  5162.                    !withinComment &&
    5163. 

  5163.                    DocumentTypes[doc] != docCSS &&
    5164. 

  5164.                    DocumentTypes[doc] != docLog &&
    5165. 

  5165.                    DocumentTypes[doc] != docText &&
    5166. 

  5166.                    (charRead == '<' ||
    5167. 

  5167.                     (charRead == '>' && withinMarkup)))
    5168. 

  5168.             {
    5169. 

  5169.               if (charRead == '<')
    5170. 

  5170.                 {
    5171. 

  5171.                   /* Start a markup */
    5172. 

  5172.                   withinMarkup = TRUE;
    5173. 

  5173.                   /* close the previous element */
    5174. 

  5174.                   el = GetANewText (el, elType, doc);
    5175. 

  5175.                   /* add the current character */
    5176. 

  5176.                   inputBuffer[LgBuffer++] = charRead;
    5177. 

  5177.                 }
    5178. 

  5178.               else
    5179. 

  5179.                 {
    5180. 

  5180.                   /* End a markup */
    5181. 

  5181.                   withinMarkup = FALSE;
    5182. 

  5182.                   /* add the current character */
    5183. 

  5183.                   inputBuffer[LgBuffer++] = charRead;
    5184. 

  5184.                   attrType.AttrTypeNum = TextFile_ATTR_IsMarkup;
    5185. 

  5185.                   attr = TtaGetAttribute (el, attrType);
    5186. 

  5186.                   if (attr == NULL)
    5187. 

  5187.                     {
    5188. 

  5188.                       attr = TtaNewAttribute (attrType);
    5189. 

  5189.                       val = TextFile_ATTR_IsMarkup_VAL_Yes_;
    5190. 

  5190.                       TtaAttachAttribute (el, attr, doc);
    5191. 

  5191.                       TtaSetAttributeValue (attr, val, el, doc);
    5192. 

  5192.                     }
    5193. 

  5193.                   el = GetANewText (el, elType, doc);
    5194. 

  5194.                 }
    5195. 

  5195.             }
    5196. 

  5196.           else if ((DocumentTypes[doc] == docCSS ||
    5197. 

  5197.                     DocumentTypes[doc] == docText) &&
    5198. 

  5198.                    (charRead == '*' || charRead == '/' ||
    5199. 

  5199.                     (LgBuffer == 0 && withinComment)))
    5200. 

  5200.             {
    5201. 

  5201.               if (!withinComment && charRead == '*' &&
    5202. 

  5202.                   LgBuffer > 0 && inputBuffer[LgBuffer-1] == '/')
    5203. 

  5203.                 {
    5204. 

  5204.                   /* open a comment */
    5205. 

  5205.                   withinComment = !withinComment;
    5206. 

  5206.                   /* close previous element */
    5207. 

  5207.                   inputBuffer[0] = EOS;
    5208. 

  5208.                   el = GetANewText (el, elType, doc);
    5209. 

  5209.                   /* add the current character */
    5210. 

  5210.                   inputBuffer[LgBuffer++] = '/';
    5211. 

  5211.                 }
    5212. 

  5212.               else if ((withinComment && charRead == '*') ||
    5213. 

  5213.                        (!withinComment && charRead == '/'))
    5214. 

  5214.                 {
    5215. 

  5215.                   /* flush the current buffer */
    5216. 

  5216.                   inputBuffer[LgBuffer] = EOS;
    5217. 

  5217.                   TtaAppendTextContent (el, (unsigned char *)inputBuffer, doc);
    5218. 

  5218.                   LgBuffer = 0;
    5219. 

  5219.                 }
    5220. 

  5220.               if (withinComment)
    5221. 

  5221.                 {
    5222. 

  5222.                   attrType.AttrTypeNum = TextFile_ATTR_IsComment;
    5223. 

  5223.                   attr = TtaGetAttribute (el, attrType);
    5224. 

  5224.                   if (attr == NULL)
    5225. 

  5225.                     {
    5226. 

  5226.                       attr = TtaNewAttribute (attrType);
    5227. 

  5227.                       val = TextFile_ATTR_IsComment_VAL_Yes_;
    5228. 

  5228.                       TtaAttachAttribute (el, attr, doc);
    5229. 

  5229.                       TtaSetAttributeValue (attr, val, el, doc);
    5230. 

  5230.                     }
    5231. 

  5231.                 }
    5232. 

  5232.               /* add the current character */
    5233. 

  5233.               inputBuffer[LgBuffer++] = charRead;
    5234. 

  5234.               if (withinComment && charRead == '/' &&
    5235. 

  5235.                   LgBuffer == 2 && inputBuffer[0] == '*')
    5236. 

  5236.                 {
    5237. 

  5237.                   /* close a comment */
    5238. 

  5238.                   withinComment = !withinComment;
    5239. 

  5239.                   el = GetANewText (el, elType, doc);
    5240. 

  5240.                 }
    5241. 

  5241.             }
    5242. 

  5242.           else if (LgBuffer + 1 >= AllmostFullBuffer)
    5243. 

  5243.             {
    5244. 

  5244.               /* store the current buffer contents and continue */
    5245. 

  5245.               inputBuffer[LgBuffer] = EOS;
    5246. 

  5246.               TtaAppendTextContent (el, (unsigned char *)inputBuffer, doc);
    5247. 

  5247.               LgBuffer = 0;
    5248. 

  5248.               inputBuffer[LgBuffer++] = charRead;
    5249. 

  5249.             }
    5250. 

  5250.           else
    5251. 

  5251.             inputBuffer[LgBuffer++] = charRead;
    5252. 

  5252. 

  5253.           if (el != NULL)
    5254. 

  5254.             {
    5255. 

  5255.               /* test if last created element is a Symbol */
    5256. 

  5256.               elType = TtaGetElementType (el);
    5257. 

  5257.               if (elType.ElTypeNum != TextFile_EL_TEXT_UNIT)
    5258. 

  5258.                 {
    5259. 

  5259.                   /* Create a new text leaf */
    5260. 

  5260.                   elType.ElTypeNum = TextFile_EL_TEXT_UNIT;
    5261. 

  5261.                   elLeaf = TtaNewElement (doc, elType);
    5262. 

  5262.                   TtaSetElementLineNumber (elLeaf, NumberOfLinesRead);
    5263. 

  5263.                   TtaInsertSibling (elLeaf, el,  FALSE, doc);
    5264. 

  5264.                   el = elLeaf;
    5265. 

  5265.                 }
    5266. 

  5266.             }
    5267. 

  5267.         }
    5268. 

  5268. 

  5269.       /* read next character from the source */
    5270. 

  5270.       charRead = GetNextInputChar (infile, &CurrentBufChar, &endOfTextFile);
    5271. 

  5271.     }
    5272. 

  5272.   /* close the document */
    5273. 

  5273.   if (LgBuffer != 0)
    5274. 

  5274.     {
    5275. 

  5275.       inputBuffer[LgBuffer] = EOS;
    5276. 

  5276.       TtaAppendTextContent (el, (unsigned char *)inputBuffer, doc);
    5277. 

  5277.     }
    5278. 

  5278.   if (DocumentTypes[doc] != docSource)
    5279. 

  5279.     // clean up the list of css files
    5280. 

  5280.     UpdateStyleList (doc, 1);
    5281. 

  5281. }
    5282. 

  5282. 

  5283. /*----------------------------------------------------------------------
    5284. 

  5284.   CheckDocHeader parses the loaded file to detect if it includes:
    5285. 

  5285.   - an XML declaration (returns xmlDec = TRUE)
    5286. 

  5286.   - a doctype (returns docType = TRUE)
    5287. 

  5287.   Other returns:
    5288. 

  5288.   The indicator isXML
    5289. 

  5289.   The document type transitional, XHTML 1.1, basic, other (docProfile)
    5290. 

  5290.   The charset value if the XML declaration gives an encoding or
    5291. 

  5291.   UNDEFINED_CHARSET.
    5292. 

  5292.   The type of the doc'ument (given by the first element name)
    5293. 

  5293.   A boolean that indicates if an XML DTD is supported by Amaya
    5294. 

  5294.   ----------------------------------------------------------------------*/
    5295. 

  5295. void CheckDocHeader (char *fileName, ThotBool *xmlDec, ThotBool *docType,
    5296. 

  5296.                      ThotBool *isXML, ThotBool *useMath, ThotBool *isknown,
    5297. 

  5297.                      int *docProfile, CHARSET *charset, char *charsetname,
    5298. 

  5298.                      DocumentType *thotType, int *extraProfile)
    5299. 

  5299. {
    5300. 

  5300.   gzFile      stream;
    5301. 

  5301.   char       *ptr, *beg, *end, *ptrns, *prefix;
    5302. 

  5302.   char       *buffer = FileBuffer;
    5303. 

  5303.   int         res, i, j, k, pref_lg = 0;
    5304. 

  5304.   ThotBool    endOfSniffedFile, beginning;
    5305. 

  5305.   ThotBool    found;
    5306. 

  5306. 

  5307.   *xmlDec = FALSE;
    5308. 

  5308.   *docType = FALSE;
    5309. 

  5309.   *isXML = FALSE;
    5310. 

  5310.   *isknown = FALSE;
    5311. 

  5311.   *useMath = FALSE;
    5312. 

  5312.   *docProfile = L_Other;
    5313. 

  5313.   *charset = UNDEFINED_CHARSET;
    5314. 

  5314.   *thotType = docText;
    5315. 

  5315.   *extraProfile = L_NoExtraProfile;
    5316. 

  5316.   CurrentNameSpace[0] = EOS;
    5317. 

  5317.   stream = TtaGZOpen (fileName);
    5318. 

  5318.   if (stream != 0)
    5319. 

  5319.     {
    5320. 

  5320.       InputText = NULL;
    5321. 

  5321.       LgBuffer = 0;
    5322. 

  5322.       endOfSniffedFile = FALSE;
    5323. 

  5323.       beginning = TRUE;
    5324. 

  5324.       while (!endOfSniffedFile)
    5325. 

  5325.         {
    5326. 

  5326.           res = gzread (stream, buffer, INPUT_FILE_BUFFER_SIZE);
    5327. 

  5327.           if (res < 0)
    5328. 

  5328.             {
    5329. 

  5329.               TtaGZClose (stream);
    5330. 

  5330.               return;
    5331. 

  5331.             }
    5332. 

  5332.           if (res >= 5)
    5333. 

  5333.             buffer[res] = EOS;
    5334. 

  5334.           /* check if the file contains "<?xml ..." */
    5335. 

  5335.           i = 0;
    5336. 

  5336.           prefix = NULL;
    5337. 

  5337.           endOfSniffedFile = (res < INPUT_FILE_BUFFER_SIZE);
    5338. 

  5338.           found = TRUE;
    5339. 

  5339.           while (found)
    5340. 

  5340.             {
    5341. 

  5341.               if (beginning)
    5342. 

  5342.                 {
    5343. 

  5343.                   /* looks for the first tag */
    5344. 

  5344.                   while (i < res &&
    5345. 

  5345.                          (buffer[i] == SPACE  ||
    5346. 

  5346.                           buffer[i] == EOL    ||
    5347. 

  5347.                           buffer[i] == TAB    ||
    5348. 

  5348.                           buffer[i] == __CR__ ||
    5349. 

  5349.                           (unsigned char) buffer[i] == 0xEF ||
    5350. 

  5350.                           (unsigned char) buffer[i] == 0xBB ||
    5351. 

  5351.                           (unsigned char) buffer[i] == 0xBF ))
    5352. 

  5352.                     i++;
    5353. 

  5353.                   if (buffer[i] == '<')
    5354. 

  5354.                     found = TRUE;
    5355. 

  5355.                   else
    5356. 

  5356.                     found = FALSE;
    5357. 

  5357.                 }
    5358. 

  5358.               else
    5359. 

  5359.                 {
    5360. 

  5360.                   /* looks for the next tag */
    5361. 

  5361.                   found = FALSE;
    5362. 

  5362.                   while (!found && i < res)
    5363. 

  5363.                     if (buffer[i] == '<')
    5364. 

  5364.                       found = TRUE;
    5365. 

  5365.                     else
    5366. 

  5366.                       i++;
    5367. 

  5367.                 }
    5368. 

  5368.               /* if the declaration is present it's the first element */
    5369. 

  5369.               if (found)
    5370. 

  5370.                 {
    5371. 

  5371.                   if (beginning && !strncmp (&buffer[i], "<?xml ", 6))
    5372. 

  5372.                     {
    5373. 

  5373.                       /* we've found <?xml */
    5374. 

  5374.                       i += 6;
    5375. 

  5375.                       *xmlDec = TRUE;
    5376. 

  5376.                       *isXML = TRUE;
    5377. 

  5377. #ifdef XML_GENERIC
    5378. 

  5378.                       *thotType = docXml;
    5379. 

  5379. #endif /* XML_GENERIC */
    5380. 

  5380.                       end = strstr (&buffer[i], "?>");
    5381. 

  5381.                       /* check whether there is an encoding */
    5382. 

  5382.                       ptr = strstr (&buffer[i], "encoding");
    5383. 

  5383.                       if (ptr && ptr < end)
    5384. 

  5384.                         {
    5385. 

  5385.                           beg = strstr (ptr, "\"");
    5386. 

  5386.                           if (beg && beg < end)
    5387. 

  5387.                             end = strstr (&beg[1], "\"");
    5388. 

  5388.                           else
    5389. 

  5389.                             {
    5390. 

  5390.                               beg = strstr (ptr, "\'");
    5391. 

  5391.                               if (beg && beg < end)
    5392. 

  5392.                                 end = strstr (&beg[1], "\'");
    5393. 

  5393.                             }
    5394. 

  5394.                           if (end && beg && end != beg)
    5395. 

  5395.                             {
    5396. 

  5396.                               /* get the document charset */
    5397. 

  5397.                               k = 0; j = 1;
    5398. 

  5398.                               while (&beg[j] != end && k < MAX_LENGTH)
    5399. 

  5399.                                 charsetname[k++] = beg[j++];
    5400. 

  5400.                               charsetname[k] = EOS;
    5401. 

  5401.                               *charset = TtaGetCharset (charsetname);
    5402. 

  5402.                             }
    5403. 

  5403.                         }
    5404. 

  5404.                     }
    5405. 

  5405.                   else if (!strncasecmp ((char *)&buffer[i], "<!DOCTYPE", 9))
    5406. 

  5406.                     {
    5407. 

  5407.                       /* the doctype is found */
    5408. 

  5408.                       i += 9;
    5409. 

  5409.                       *docType = TRUE;
    5410. 

  5410.                       /* it's not necessary to continue */
    5411. 

  5411.                       found = FALSE;
    5412. 

  5412.                       endOfSniffedFile = TRUE;
    5413. 

  5413.                       end = strstr (&buffer[i], ">");
    5414. 

  5414.                       /* check the current DOCTYPE */
    5415. 

  5415.                       ptr = strstr (&buffer[i], "HTML");
    5416. 

  5416.                       if (!ptr || (ptr && ptr > end))
    5417. 

  5417.                         ptr = strstr (&buffer[i], "html");
    5418. 

  5418.                       if (ptr && ptr < end)
    5419. 

  5419.                         {
    5420. 

  5420.                           *thotType = docHTML;
    5421. 

  5421.                           *docProfile = L_Transitional;
    5422. 

  5422.                           ptr = strstr (&buffer[i], "XHTML");
    5423. 

  5423.                           if (!ptr || (ptr && ptr > end))
    5424. 

  5424.                             ptr = strstr (&buffer[i], "xhtml");
    5425. 

  5425.                           if (ptr && ptr < end)
    5426. 

  5426.                             {
    5427. 

  5427.                               /* XHTML has been found */
    5428. 

  5428.                               /* Does Amaya support this doctype */
    5429. 

  5429.                               *isXML = TRUE;
    5430. 

  5430.                               *thotType = docXml;
    5431. 

  5431.                               ptr = strstr (&buffer[i], "Basic 1.0");
    5432. 

  5432.                               if (!ptr || (ptr && ptr > end))
    5433. 

  5433.                                 ptr = strstr (&buffer[i], "basic 1.0");
    5434. 

  5434.                               if (ptr && ptr < end)
    5435. 

  5435.                                 {
    5436. 

  5436.                                   *thotType = docHTML;
    5437. 

  5437.                                   *isknown = TRUE;
    5438. 

  5438.                                   *docProfile = L_Basic;
    5439. 

  5439.                                 }
    5440. 

  5440.                               else
    5441. 

  5441.                                 {
    5442. 

  5442.                                   ptr = strstr (&buffer[i], "XHTML 1.0");
    5443. 

  5443.                                   if (!ptr || (ptr && ptr > end))
    5444. 

  5444.                                     ptr = strstr (&buffer[i], "xhtml 1.0");
    5445. 

  5445.                                   if (!ptr || (ptr && ptr > end))
    5446. 

  5446.                                     ptr = strstr (&buffer[i], "XHTML 1.1");
    5447. 

  5447.                                   if (!ptr || (ptr && ptr > end))
    5448. 

  5448.                                     ptr = strstr (&buffer[i], "xhtml 1.1");
    5449. 

  5449.                                   if (ptr && ptr < end)
    5450. 

  5450.                                     {
    5451. 

  5451.                                       /* A supported XHTML doctype has been found */
    5452. 

  5452.                                       *thotType = docHTML;
    5453. 

  5453.                                       *isknown = TRUE;
    5454. 

  5454.                                       ptr = strstr (&buffer[i], "Strict");
    5455. 

  5455.                                       if (!ptr || (ptr && ptr > end))
    5456. 

  5456.                                         ptr = strstr (&buffer[i], "strict");
    5457. 

  5457.                                       if (ptr && ptr < end)
    5458. 

  5458.                                         *docProfile = L_Strict;
    5459. 

  5459.                                       else
    5460. 

  5460.                                         {
    5461. 

  5461.                                           ptr = strstr (&buffer[i], "Transitional");
    5462. 

  5462.                                           if (!ptr || (ptr && ptr > end))
    5463. 

  5463.                                             ptr = strstr (&buffer[i], "transitional");
    5464. 

  5464.                                           if (ptr && ptr < end)
    5465. 

  5465.                                             *docProfile = L_Transitional;
    5466. 

  5466.                                           else
    5467. 

  5467.                                             {
    5468. 

  5468.                                               ptr = strstr (&buffer[i], "1.1");
    5469. 

  5469.                                               if (ptr && ptr < end)
    5470. 

  5470.                                                 {
    5471. 

  5471.                                                   ptr = strstr (&buffer[i], "svg:svg");
    5472. 

  5472.                                                   if (ptr && ptr < end)
    5473. 

  5473.                                                     {
    5474. 

  5474.                                                       *thotType = docSVG;
    5475. 

  5475.                                                       *isXML = TRUE;
    5476. 

  5476.                                                       *isknown = TRUE;
    5477. 

  5477.                                                       *docProfile = L_SVG;
    5478. 

  5478.                                                       *useMath = TRUE;
    5479. 

  5479.                                                     }
    5480. 

  5480.                                                   else
    5481. 

  5481.                                                     {
    5482. 

  5482.                                                       *docProfile = L_Xhtml11;
    5483. 

  5483.                                                       ptr = strstr (&buffer[i], "plus MathML");
    5484. 

  5484.                                                       if (ptr && ptr < end)
    5485. 

  5485.                                                         *useMath = TRUE;
    5486. 

  5486.                                                     }
    5487. 

  5487.                                                 }
    5488. 

  5488.                                             }
    5489. 

  5489.                                         }
    5490. 

  5490.                                     }
    5491. 

  5491.                                   else
    5492. 

  5492.                                     {
    5493. 

  5493.                                       ptr = strstr (&buffer[i], "xhtml-math11");
    5494. 

  5494.                                       if (!ptr || (ptr && ptr > end))
    5495. 

  5495.                                         ptr = strstr (&buffer[i], "XHTML-MATH11");
    5496. 

  5496.                                       if (ptr && ptr < end)
    5497. 

  5497.                                         {
    5498. 

  5498.                                           *thotType = docHTML;
    5499. 

  5499.                                           *isknown = TRUE;
    5500. 

  5500.                                           *docProfile = L_Xhtml11;
    5501. 

  5501.                                         }
    5502. 

  5502.                                       else
    5503. 

  5503.                                         {
    5504. 

  5504.                                           ptr = strstr (&buffer[i], "+RDFa");
    5505. 

  5505.                                           if (!ptr || (ptr && ptr > end))
    5506. 

  5506.                                             ptr = strstr (&buffer[i], "+rdfa");
    5507. 

  5507.                                           if (ptr && ptr < end)
    5508. 

  5508.                                             {
    5509. 

  5509.                                               *thotType = docHTML;
    5510. 

  5510.                                               *isknown = TRUE;
    5511. 

  5511.                                               *docProfile = L_Xhtml11;
    5512. 

  5512.                                               *extraProfile = L_RDFa;
    5513. 

  5513.                                             }
    5514. 

  5514.                                         }
    5515. 

  5515.                                     }
    5516. 

  5516.                                 }
    5517. 

  5517.                             }
    5518. 

  5518.                           else
    5519. 

  5519.                             {
    5520. 

  5520.                               ptr = strstr (&buffer[i], "Strict");
    5521. 

  5521.                               if (!ptr || (ptr && ptr > end))
    5522. 

  5522.                                 ptr = strstr (&buffer[i], "strict");
    5523. 

  5523.                               if (ptr && ptr < end)
    5524. 

  5524.                                 *docProfile = L_Strict;
    5525. 

  5525.                               else
    5526. 

  5526.                                 {
    5527. 

  5527.                                   ptr = strstr (&buffer[i], "Transitional");
    5528. 

  5528.                                   if (!ptr || (ptr && ptr > end))
    5529. 

  5529.                                     ptr = strstr (&buffer[i], "transitional");
    5530. 

  5530.                                   if (ptr && ptr < end)
    5531. 

  5531.                                     *docProfile = L_Transitional;
    5532. 

  5532.                                 }
    5533. 

  5533.                             }
    5534. 

  5534.                         }
    5535. 

  5535.                       else
    5536. 

  5536.                         {
    5537. 

  5537.                           /* Look for svg tag */
    5538. 

  5538.                           ptr = strstr (&buffer[i], "SVG");
    5539. 

  5539.                           if (!ptr || (ptr && ptr > end))
    5540. 

  5540.                             ptr = strstr (&buffer[i], "svg");
    5541. 

  5541.                           if (ptr && ptr < end)
    5542. 

  5542.                             {
    5543. 

  5543.                               *thotType = docSVG;
    5544. 

  5544.                               *isXML = TRUE;
    5545. 

  5545.                               *isknown = TRUE;
    5546. 

  5546.                               *docProfile = L_SVG;
    5547. 

  5547.                             }
    5548. 

  5548.                           else
    5549. 

  5549.                             {
    5550. 

  5550.                               /* Look for math tag */
    5551. 

  5551.                               ptr = strstr (&buffer[i], "MATH");
    5552. 

  5552.                               if (!ptr || (ptr && ptr > end))
    5553. 

  5553.                                 ptr = strstr (&buffer[i], "math");
    5554. 

  5554.                               if (ptr && ptr < end)
    5555. 

  5555.                                 {
    5556. 

  5556.                                   *isXML = TRUE;
    5557. 

  5557.                                   *isknown = TRUE;
    5558. 

  5558.                                   *thotType = docMath;
    5559. 

  5559.                                   *docProfile = L_MathML;
    5560. 

  5560.                                 }
    5561. 

  5561.                             }
    5562. 

  5562.                         }
    5563. 

  5563.                     }
    5564. 

  5564.                   else if (!strncmp (&buffer[i], "<!", 2) ||
    5565. 

  5565.                            !strncmp (&buffer[i], "<?", 2))
    5566. 

  5566.                     {
    5567. 

  5567.                       /* it's a comment or a PI */
    5568. 

  5568.                       if (!strncmp (&buffer[i], "<!", 2))
    5569. 

  5569.                         {
    5570. 

  5570.                           /* look for the end of the comment */
    5571. 

  5571.                           found = FALSE;
    5572. 

  5572.                           while (!found && i < res-2)
    5573. 

  5573.                             if (!strncmp (&buffer[i], "-->", 3))
    5574. 

  5574.                               found = TRUE;
    5575. 

  5575.                             else
    5576. 

  5576.                               i++;
    5577. 

  5577.                         }
    5578. 

  5578.                       else
    5579. 

  5579.                         {
    5580. 

  5580.                           /* look for the end of the PI */
    5581. 

  5581.                           found = FALSE;
    5582. 

  5582.                           while (!found && i < res-1)
    5583. 

  5583.                             if (!strncmp (&buffer[i], "?>", 2))
    5584. 

  5584.                               found = TRUE;
    5585. 

  5585.                             else
    5586. 

  5586.                               i++;
    5587. 

  5587.                         }
    5588. 

  5588.                       if (!found)
    5589. 

  5589.                         /* the end of the comment or PI can't be found */
    5590. 

  5590.                         /* it's not necessary to continue */
    5591. 

  5591.                         endOfSniffedFile = TRUE;			
    5592. 

  5592.                     }
    5593. 

  5593.                   else if (buffer[i] == '<')
    5594. 

  5594.                     {
    5595. 

  5595.                       /* it's most probably a start tag. Is there a
    5596. 

  5596.                          namespace prefix? */
    5597. 

  5597.                       i++;
    5598. 

  5598.                       j = i;
    5599. 

  5599.                       while (j < res &&
    5600. 

  5600.                              (buffer[j] != SPACE  &&
    5601. 

  5601.                               buffer[j] != EOL    &&
    5602. 

  5602.                               buffer[j] != TAB    &&
    5603. 

  5603.                               buffer[j] != __CR__ &&
    5604. 

  5604.                               buffer[j] != ':'))
    5605. 

  5605.                         j++;
    5606. 

  5606.                       if (buffer[j] == ':')
    5607. 

  5607.                         {
    5608. 

  5608.                         /* there is a prefix, skip it */
    5609. 

  5609.                           prefix = &buffer[i];
    5610. 

  5610.                           pref_lg = j - i;
    5611. 

  5611.                           i = j + 1;
    5612. 

  5612.                         }
    5613. 

  5613.                       if (!strncasecmp ((char *)&buffer[i], "html", 4))
    5614. 

  5614.                         {
    5615. 

  5615.                           /* the html tag is found */
    5616. 

  5616.                           i += 4;
    5617. 

  5617.                           /* it's not necessary to continue */
    5618. 

  5618.                           found = FALSE;
    5619. 

  5619.                           endOfSniffedFile = TRUE;
    5620. 

  5620.                           end = strstr (&buffer[i], ">");
    5621. 

  5621.                           ptrns = strstr (&buffer[i], "xmlns");
    5622. 

  5622.                           if (ptrns)
    5623. 

  5623.                           while (ptrns && ptrns < end)
    5624. 

  5624.                             {
    5625. 

  5625.                               *isXML = TRUE;
    5626. 

  5626.                               ptrns += 5;
    5627. 

  5627.                               if (*ptrns != ':' ||
    5628. 

  5628.                                   (prefix && !strncmp (&ptrns[1], (const char*)prefix, pref_lg)))
    5629. 

  5629.                                 {
    5630. 

  5630.                                   ptr = strstr (ptrns,  XHTML_URI);
    5631. 

  5631.                                   if (ptr && ptr < end)
    5632. 

  5632.                                     {
    5633. 

  5633.                                       /* The xhtml namespace declaration is found */
    5634. 

  5634.                                       *thotType = docHTML;
    5635. 

  5635.                                       *isknown = TRUE;
    5636. 

  5636.                                       *docProfile = L_Transitional;
    5637. 

  5637.                                     }
    5638. 

  5638.                                   ptrns = NULL;
    5639. 

  5639.                                 }
    5640. 

  5640.                               else
    5641. 

  5641.                                 ptrns = strstr (ptrns, "xmlns");
    5642. 

  5642.                             }
    5643. 

  5643.                           else
    5644. 

  5644.                             /* No namespace, we consider the document as an html one */
    5645. 

  5645.                             *thotType = docHTML;
    5646. 

  5646.                         }
    5647. 

  5647.                       else if (!strncasecmp ((char *)&buffer[i], "svg", 3))
    5648. 

  5648.                         {
    5649. 

  5649.                           /* the svg tag is found */
    5650. 

  5650.                           i += 3;
    5651. 

  5651.                           /* it's not necessary to continue */
    5652. 

  5652.                           found = FALSE;
    5653. 

  5653.                           endOfSniffedFile = TRUE;
    5654. 

  5654.                           /* We consider the document as a svg one */
    5655. 

  5655.                           *thotType = docSVG;
    5656. 

  5656.                           *docProfile = L_SVG;
    5657. 

  5657.                           end = strstr (&buffer[i], ">");
    5658. 

  5658.                           ptrns = strstr (&buffer[i], "xmlns");
    5659. 

  5659.                           while (ptrns && ptrns < end)
    5660. 

  5660.                             {
    5661. 

  5661.                               *isXML = TRUE;
    5662. 

  5662.                               ptrns += 5;
    5663. 

  5663.                               if (*ptrns != ':' ||
    5664. 

  5664.                                   (prefix && !strncmp (&ptrns[1], (const char*)prefix, pref_lg)))
    5665. 

  5665.                                 {
    5666. 

  5666.                                   ptr = strstr (ptrns, "svg");
    5667. 

  5667.                                   if (ptr && ptr < end)
    5668. 

  5668.                                     {
    5669. 

  5669.                                       /* The svg namespace declaration is found */
    5670. 

  5670.                                       *isknown = TRUE;
    5671. 

  5671.                                     }
    5672. 

  5672.                                   ptrns = NULL;
    5673. 

  5673.                                 }
    5674. 

  5674.                               else
    5675. 

  5675.                                 ptrns = strstr (ptrns, "xmlns");
    5676. 

  5676.                             }
    5677. 

  5677.                         }
    5678. 

  5678.                       else if (!strncasecmp ((char *)&buffer[i], "math", 4))
    5679. 

  5679.                         {
    5680. 

  5680.                           /* the math tag is found */
    5681. 

  5681.                           i += 4;
    5682. 

  5682.                           /* it's not necessary to continue */
    5683. 

  5683.                           found = FALSE;
    5684. 

  5684.                           endOfSniffedFile = TRUE;
    5685. 

  5685.                           /* We consider the document as a mathml one */
    5686. 

  5686.                           *thotType = docMath;
    5687. 

  5687.                           *docProfile = L_MathML;
    5688. 

  5688.                           end = strstr (&buffer[i], ">");
    5689. 

  5689.                           ptrns = strstr (&buffer[i], "xmlns");
    5690. 

  5690.                           while (ptrns && ptrns < end)
    5691. 

  5691.                             {
    5692. 

  5692.                               *isXML = TRUE;
    5693. 

  5693.                               ptrns += 5;
    5694. 

  5694.                               if (*ptrns != ':' ||
    5695. 

  5695.                                   (prefix && !strncmp (&ptrns[1], (const char*)prefix, pref_lg)))
    5696. 

  5696.                                 {
    5697. 

  5697.                                   ptr = strstr (ptrns, "MathML");
    5698. 

  5698.                                   if (ptr && ptr < end)
    5699. 

  5699.                                     /* The MathML namespace declaration is found */
    5700. 

  5700.                                     *isknown = TRUE;
    5701. 

  5701.                                   ptrns = NULL;
    5702. 

  5702.                                 }
    5703. 

  5703.                               else
    5704. 

  5704.                                  ptrns = strstr (ptrns, "xmlns");
    5705. 

  5705.                             }
    5706. 

  5706.                         }
    5707. 

  5707.                       else if (!strncasecmp ((char *)&buffer[i], "library", 7))
    5708. 

  5708.                         {
    5709. 

  5709.                           /* the library tag is found */
    5710. 

  5710.                           i += 7;
    5711. 

  5711.                           /* it's not necessary to continue */
    5712. 

  5712.                           found = FALSE;
    5713. 

  5713.                           endOfSniffedFile = TRUE;
    5714. 

  5714.                           /* We consider the document as a mathml one */
    5715. 

  5715.                           *thotType = docTemplate;
    5716. 

  5716.                           end = strstr (&buffer[i], ">");
    5717. 

  5717.                           ptrns = strstr (&buffer[i], "xmlns");
    5718. 

  5718.                           while (ptrns && ptrns < end)
    5719. 

  5719.                             {
    5720. 

  5720.                               *isXML = TRUE;
    5721. 

  5721.                               ptrns += 5;
    5722. 

  5722.                               if (*ptrns != ':' ||
    5723. 

  5723.                                   (prefix && !strncmp (&ptrns[1], (const char*)prefix, pref_lg)))
    5724. 

  5724.                                 {
    5725. 

  5725.                                   ptr = strstr (ptrns, "xtiger");
    5726. 

  5726.                                   if (ptr && ptr < end)
    5727. 

  5727.                                     /* The xtiger namespace declaration is found */
    5728. 

  5728.                                     *isknown = TRUE;
    5729. 

  5729.                                   ptrns = NULL;
    5730. 

  5730.                                 }
    5731. 

  5731.                               else
    5732. 

  5732.                                  ptrns = strstr (ptrns, "xmlns");
    5733. 

  5733.                             }
    5734. 

  5734.                         }
    5735. 

  5735.                       else
    5736. 

  5736.                         {
    5737. 

  5737.                           /* it's not necessary to continue */
    5738. 

  5738.                           found = FALSE;
    5739. 

  5739.                           endOfSniffedFile = TRUE;			  
    5740. 

  5740.                           /* We consider the document as a xml one */
    5741. 

  5741.                           end = strstr (&buffer[i], ">");
    5742. 

  5742.                           ptrns = strstr (&buffer[i], "xmlns");
    5743. 

  5743.                           while (ptrns && ptrns < end)
    5744. 

  5744.                             {
    5745. 

  5745.                               *thotType = docXml;
    5746. 

  5746.                               ptrns += 5;
    5747. 

  5747.                               if (*ptrns != ':' ||
    5748. 

  5748.                                   (prefix && !strncmp (&ptrns[1], (const char*)prefix, pref_lg)))
    5749. 

  5749.                                 {
    5750. 

  5750.                                   // copy the namespace
    5751. 

  5751.                                   while (ptrns != end && *ptrns != '"')
    5752. 

  5752.                                     ptrns++;
    5753. 

  5753.                                   ptr = &ptrns[1];
    5754. 

  5754.                                   j = 0;
    5755. 

  5755.                                   while (ptr != end && *ptr != *ptrns && j < NAME_LENGTH)
    5756. 

  5756.                                     {
    5757. 

  5757.                                       CurrentNameSpace[j++] = *ptr;
    5758. 

  5758.                                       ptr++;
    5759. 

  5759.                                     }
    5760. 

  5760.                                   ptrns = NULL;
    5761. 

  5761.                                 }
    5762. 

  5762.                               else
    5763. 

  5763.                                  ptrns = strstr (ptrns, "xmlns");
    5764. 

  5764.                             }
    5765. 

  5765.                           if (CurrentNameSpace[0] == EOS)
    5766. 

  5766.                             {
    5767. 

  5767.                               // copy the root name
    5768. 

  5768.                               j = 0;
    5769. 

  5769.                               ptr = &buffer[i];
    5770. 

  5770.                               while (ptr != end && *ptr != SPACE && j < NAME_LENGTH)
    5771. 

  5771.                                 {
    5772. 

  5772.                                   CurrentNameSpace[j++] = *ptr;
    5773. 

  5773.                                   ptr++;
    5774. 

  5774.                                 }
    5775. 

  5775.                               
    5776. 

  5776.                             }
    5777. 

  5777.                         }
    5778. 

  5778.                     }
    5779. 

  5779.                   else
    5780. 

  5780.                     {
    5781. 

  5781.                       /* it's not a comment nor a PI nor a start tag */
    5782. 

  5782.                       /* stop sniffing */
    5783. 

  5783.                       found = FALSE;
    5784. 

  5784.                       endOfSniffedFile = TRUE;
    5785. 

  5785.                     }
    5786. 

  5786.                 }
    5787. 

  5787.               else
    5788. 

  5788.                 /* it's not necessary to continue */
    5789. 

  5789.                 endOfSniffedFile = TRUE;
    5790. 

  5790.               /* we're no longer parsing the beginning of the file */
    5791. 

  5791.               beginning = FALSE;
    5792. 

  5792.             }
    5793. 

  5793.         }
    5794. 

  5794.       TtaGZClose (stream);
    5795. 

  5795.     }
    5796. 

  5796. 

  5797.   // allow RDFa for XHTML documents without doctype
    5798. 

  5798.   if ((*docProfile == L_Xhtml11 || *docProfile == L_Transitional) &&
    5799. 

  5799.       *isXML && !(*docType))
    5800. 

  5800.     *extraProfile = L_RDFa;
    5801. 

  5801. }
    5802. 

  5802. 

  5803. /*----------------------------------------------------------------------
    5804. 

  5804.   CheckCharsetInMeta
    5805. 

  5805.   Parses the loaded file to detect if it includes a charset value 
    5806. 

  5806.   in a META element 
    5807. 

  5807.   ----------------------------------------------------------------------*/
    5808. 

  5808. void CheckCharsetInMeta (char *fileName, CHARSET *charset, char *charsetname)
    5809. 

  5809. {
    5810. 

  5810.   gzFile     stream;
    5811. 

  5811.   char      *ptr, *end, *end2, *meta, *endmeta, *content, *body, *http;
    5812. 

  5812.   char      *buffer = FileBuffer;
    5813. 

  5813.   int        res, i, j, k;
    5814. 

  5814.   ThotBool   endOfSniffedFile;
    5815. 

  5815. 

  5816.   *charset = UNDEFINED_CHARSET;
    5817. 

  5817.   stream = TtaGZOpen (fileName);
    5818. 

  5818.   if (stream != 0)
    5819. 

  5819.     {
    5820. 

  5820.       InputText = NULL;
    5821. 

  5821.       LgBuffer = 0;
    5822. 

  5822.       endOfSniffedFile = FALSE;
    5823. 

  5823.       while (!endOfSniffedFile)
    5824. 

  5824.         {
    5825. 

  5825.           res = gzread (stream, buffer, INPUT_FILE_BUFFER_SIZE);
    5826. 

  5826.           if (res < 0)
    5827. 

  5827.             {
    5828. 

  5828.               TtaGZClose (stream);
    5829. 

  5829.               return;
    5830. 

  5830.             }
    5831. 

  5831.           if (res >= 5)
    5832. 

  5832.             buffer[res] = EOS;
    5833. 

  5833.           i = 0;
    5834. 

  5834.           endOfSniffedFile = (res < INPUT_FILE_BUFFER_SIZE);
    5835. 

  5835. 	  
    5836. 

  5836.           /* looks for the first <meta> element */
    5837. 

  5837.           meta = (char*)StrCaseStr (&buffer[i], "<meta");
    5838. 

  5838.           if (meta)
    5839. 

  5839.             {
    5840. 

  5840.               endmeta = strstr (meta, ">");
    5841. 

  5841.               /* looks for the first "http-equiv" declaration */
    5842. 

  5842.               http = (char*)StrCaseStr (meta, "http-equiv");
    5843. 

  5843.               if (http && http > endmeta)
    5844. 

  5844.                 {
    5845. 

  5845.                   while (endmeta && http > endmeta)
    5846. 

  5846.                     {
    5847. 

  5847.                       meta =  (char*)StrCaseStr (endmeta,  "<meta");
    5848. 

  5848.                       if (meta)
    5849. 

  5849.                         endmeta = strstr (meta, ">");
    5850. 

  5850.                       else
    5851. 

  5851.                         {
    5852. 

  5852.                           endmeta = NULL;
    5853. 

  5853.                           http = NULL;
    5854. 

  5854.                         }
    5855. 

  5855.                     }
    5856. 

  5856. 		  
    5857. 

  5857.                 }
    5858. 

  5858.               if (http)
    5859. 

  5859.                 {
    5860. 

  5860.                   /* looks for the "Content-Type" declaration */
    5861. 

  5861.                   content = (char*)StrCaseStr (meta, "content-type");
    5862. 

  5862.                   if (content)
    5863. 

  5863.                     {
    5864. 

  5864.                       /* check whether there is a charset */
    5865. 

  5865.                       ptr = (char*)StrCaseStr (meta, "charset");
    5866. 

  5866.                       if (ptr)
    5867. 

  5867.                         {
    5868. 

  5868.                           endOfSniffedFile = TRUE;
    5869. 

  5869.                           end = NULL;
    5870. 

  5870.                           ptr = strstr (ptr, "=");
    5871. 

  5871.                           if (ptr)
    5872. 

  5872.                             {
    5873. 

  5873.                               end2 = strstr (&ptr[1], ">");
    5874. 

  5874.                               if (end2)
    5875. 

  5875.                                 {
    5876. 

  5876.                                   end = strstr (&ptr[1], "\"");
    5877. 

  5877.                                   if (!end || (end && end > end2))
    5878. 

  5878.                                     {
    5879. 

  5879.                                       end = strstr (&ptr[1], "\'");
    5880. 

  5880.                                       if (end && end > end2)
    5881. 

  5881.                                         end = NULL;
    5882. 

  5882.                                     }
    5883. 

  5883.                                 }
    5884. 

  5884.                             }
    5885. 

  5885.                           if (end && end != ptr)
    5886. 

  5886.                             {
    5887. 

  5887.                               /* get the document charset */
    5888. 

  5888.                               k = 0; j = 1;
    5889. 

  5889.                               while (&ptr[j] != end && k < MAX_LENGTH)
    5890. 

  5890.                                 charsetname[k++] = ptr[j++];
    5891. 

  5891.                               charsetname[k] = EOS;
    5892. 

  5892.                               *charset = TtaGetCharset (charsetname);
    5893. 

  5893.                             }
    5894. 

  5894.                         }
    5895. 

  5895.                     }
    5896. 

  5896.                 }
    5897. 

  5897.             }
    5898. 

  5898.           /* looks for the <body> element */
    5899. 

  5899.           if (!endOfSniffedFile)
    5900. 

  5900.             {
    5901. 

  5901.               body = (char*)StrCaseStr (&buffer[i], "<body");
    5902. 

  5902.               if (body)
    5903. 

  5903.                 endOfSniffedFile = TRUE;
    5904. 

  5904.             }
    5905. 

  5905.         }
    5906. 

  5906.       TtaGZClose (stream);
    5907. 

  5907.     }
    5908. 

  5908. }
    5909. 

  5909. 

  5910. /*----------------------------------------------------------------------
    5911. 

  5911.   ----------------------------------------------------------------------*/
    5912. 

  5912. static void CheckHeadElements (Element el, Element *elHead,
    5913. 

  5913.                                Element *elBody, Document doc)
    5914. 

  5914. {
    5915. 

  5915.   Element           nextEl, rootEl, lastChild;
    5916. 

  5916.   ElementType       elType;
    5917. 

  5917. 

  5918.   /* check all children of the given element */
    5919. 

  5919.   el = TtaGetFirstChild (el);
    5920. 

  5920.   lastChild = NULL;
    5921. 

  5921.   while (el != NULL)
    5922. 

  5922.     {
    5923. 

  5923.       nextEl = el;
    5924. 

  5924.       TtaNextSibling (&nextEl);
    5925. 

  5925.       elType = TtaGetElementType (el);
    5926. 

  5926.       if (elType.ElTypeNum == HTML_EL_BODY &&
    5927. 

  5927.           elType.ElSSchema == DocumentSSchema && *elBody == NULL)
    5928. 

  5928.         *elBody = el;
    5929. 

  5929.       else if ((elType.ElTypeNum == HTML_EL_TITLE ||
    5930. 

  5930.                 elType.ElTypeNum == HTML_EL_ISINDEX ||
    5931. 

  5931.                 elType.ElTypeNum == HTML_EL_BASE ||
    5932. 

  5932.                 elType.ElTypeNum == HTML_EL_STYLE_ ||
    5933. 

  5933.                 elType.ElTypeNum == HTML_EL_META ||
    5934. 

  5934.                 elType.ElTypeNum == HTML_EL_LINK) &&
    5935. 

  5935.                elType.ElSSchema == DocumentSSchema)
    5936. 

  5936.         /* this element should be a child of HEAD */
    5937. 

  5937.         {
    5938. 

  5938.           /* create the HEAD element if it does not exist */
    5939. 

  5939.           if (*elHead == NULL)
    5940. 

  5940.             {
    5941. 

  5941. #ifdef ANNOTATIONS
    5942. 

  5942.               if (DocumentTypes[doc] == docAnnot)
    5943. 

  5943.                 rootEl = ANNOT_GetHTMLRoot (doc, TRUE); 
    5944. 

  5944.               else
    5945. 

  5945. #endif /* ANNOTATIONS */
    5946. 

  5946.                 rootEl = TtaGetRootElement (doc);
    5947. 

  5947.               elType.ElTypeNum = HTML_EL_HEAD;
    5948. 

  5948.               *elHead = TtaNewElement (doc, elType);
    5949. 

  5949.               TtaInsertFirstChild (elHead, rootEl, doc);
    5950. 

  5950.             }
    5951. 

  5951.           else
    5952. 

  5952.             {
    5953. 

  5953.               elType.ElTypeNum = HTML_EL_TITLE;
    5954. 

  5954.               lastChild = TtaSearchTypedElement (elType, SearchInTree, *elHead);
    5955. 

  5955.               if (!lastChild)
    5956. 

  5956.                 lastChild = TtaGetFirstChild (*elHead);
    5957. 

  5957.             }
    5958. 

  5958.           /* move the element as the last child of the HEAD element */
    5959. 

  5959.           TtaRemoveTree (el, doc);
    5960. 

  5960.           if (lastChild)
    5961. 

  5961.             TtaInsertSibling (el, lastChild, FALSE, doc);
    5962. 

  5962.           else
    5963. 

  5963.             TtaInsertFirstChild (&el, *elHead, doc);
    5964. 

  5964.           lastChild = el;
    5965. 

  5965.         }
    5966. 

  5966.       /* get next child of the root */
    5967. 

  5967.       el = nextEl;
    5968. 

  5968.     }
    5969. 

  5969.   /* is there a TITLE element in the HEAD ? */
    5970. 

  5970.   if (*elHead != NULL)
    5971. 

  5971.     {
    5972. 

  5972.       elType = TtaGetElementType (*elHead);
    5973. 

  5973.       elType.ElTypeNum = HTML_EL_TITLE;
    5974. 

  5974.       if (!TtaSearchTypedElement (elType, SearchInTree, *elHead))
    5975. 

  5975.         {
    5976. 

  5976.           /* create the title */
    5977. 

  5977.           lastChild = TtaNewTree (doc, elType, "");
    5978. 

  5978.           TtaInsertFirstChild (&lastChild, *elHead, doc);
    5979. 

  5979.         }
    5980. 

  5980.     }
    5981. 

  5981. }
    5982. 

  5982. 

  5983. 

  5984. /*----------------------------------------------------------------------
    5985. 

  5985.   EncloseCharLevelElem
    5986. 

  5986.   create a copy of element charEl for all descendants of el which are not
    5987. 

  5987.   block level elements.
    5988. 

  5988.   ----------------------------------------------------------------------*/
    5989. 

  5989. static void EncloseCharLevelElem (Element el, Element charEl,
    5990. 

  5990.                                   Document doc, ThotBool *done)
    5991. 

  5991. {
    5992. 

  5992.   Element      child, next, copy, prev, elem;
    5993. 

  5993.   ElementType	elType;
    5994. 

  5994. 

  5995.   if (IsEmptyElement (el))
    5996. 

  5996.     return;
    5997. 

  5997.   elType = TtaGetElementType (el);
    5998. 

  5998.   if (elType.ElTypeNum == HTML_EL_Table_head ||
    5999. 

  5999.       elType.ElTypeNum == HTML_EL_C_Head ||
    6000. 

  6000.       elType.ElTypeNum == HTML_EL_Horizontal_Rule)
    6001. 

  6001.     /* cannot insert any element into a Table_head or Horizontal_Rule */
    6002. 

  6002.     return;
    6003. 

  6003.   child = TtaGetFirstChild (el);
    6004. 

  6004.   if (child == NULL)
    6005. 

  6005.     {
    6006. 

  6006.       copy = TtaCopyTree (charEl, doc, doc, el);
    6007. 

  6007.       TtaInsertFirstChild (&copy, el, doc);
    6008. 

  6008.     }
    6009. 

  6009.   else
    6010. 

  6010.     {
    6011. 

  6011.       prev = NULL;
    6012. 

  6012.       do
    6013. 

  6013.         {
    6014. 

  6014.           next = child;
    6015. 

  6015.           TtaNextSibling (&next);
    6016. 

  6016.           elem = child;
    6017. 

  6017.           if (!IsCharacterLevelElement (elem))
    6018. 

  6018.             /* create copies of element parent for all descendants of elem */
    6019. 

  6019.             {
    6020. 

  6020.               EncloseCharLevelElem (elem, charEl, doc, done);
    6021. 

  6021.               prev = NULL;
    6022. 

  6022.               if (*done)
    6023. 

  6023.                 next = NULL;
    6024. 

  6024.             }
    6025. 

  6025.           else
    6026. 

  6026.             /* enclose elem in a copy of charEl */
    6027. 

  6027.             {
    6028. 

  6028.               if (prev != NULL)
    6029. 

  6029.                 {
    6030. 

  6030.                   TtaRemoveTree (elem, doc);
    6031. 

  6031.                   TtaInsertSibling (elem, prev, FALSE, doc);
    6032. 

  6032.                 }
    6033. 

  6033.               else
    6034. 

  6034.                 {
    6035. 

  6035.                   elType = TtaGetElementType (charEl);
    6036. 

  6036.                   copy = TtaCopyTree (charEl, doc, doc, el);
    6037. 

  6037.                   TtaInsertSibling (copy, elem, TRUE, doc);
    6038. 

  6038.                   TtaRemoveTree (elem, doc);
    6039. 

  6039.                   TtaInsertFirstChild (&elem, copy, doc);
    6040. 

  6040.                   /* do it only once for an Anchor */
    6041. 

  6041.                   if (elType.ElTypeNum == HTML_EL_Anchor)
    6042. 

  6042.                     *done = TRUE;
    6043. 

  6043.                 }
    6044. 

  6044.               prev = elem;
    6045. 

  6045.             }
    6046. 

  6046.           child = next;
    6047. 

  6047.         }
    6048. 

  6048.       while (child != NULL);
    6049. 

  6049.     }
    6050. 

  6050. }
    6051. 

  6051. 

  6052. 

  6053. /*----------------------------------------------------------------------
    6054. 

  6054.   MergeElements
    6055. 

  6055.   merge element old into element element el.
    6056. 

  6056.   ----------------------------------------------------------------------*/
    6057. 

  6057. static void  MergeElements (Element old, Element el, Document doc)
    6058. 

  6058. {
    6059. 

  6059.   Element    elem, next, prev, sibling;
    6060. 

  6060. 

  6061.   elem = TtaGetFirstChild (old);
    6062. 

  6062.   sibling = TtaGetFirstChild (el);
    6063. 

  6063.   prev = NULL;
    6064. 

  6064.   while (elem != NULL)
    6065. 

  6065.     {
    6066. 

  6066.       next = elem;
    6067. 

  6067.       TtaNextSibling (&next);
    6068. 

  6068.       TtaRemoveTree (elem, doc);
    6069. 

  6069.       if (prev != NULL)
    6070. 

  6070.         TtaInsertSibling (elem, prev, FALSE, doc);
    6071. 

  6071.       else
    6072. 

  6072.         if (sibling == NULL)
    6073. 

  6073.           TtaInsertFirstChild (&elem, el, doc);
    6074. 

  6074.         else
    6075. 

  6075.           TtaInsertSibling (elem, sibling, TRUE, doc);
    6076. 

  6076.       prev = elem;
    6077. 

  6077.       elem = next;
    6078. 

  6078.     }
    6079. 

  6079.   TtaDeleteTree (old, doc);
    6080. 

  6080. }
    6081. 

  6081. 

  6082. /*----------------------------------------------------------------------
    6083. 

  6083.   MergePseudoParagraph
    6084. 

  6084.   if element el is a pseudo-paragraph and its neighbours elements are also
    6085. 

  6085.   pseudo paragraphs, merge these elements into a single pseudo-paragraph.
    6086. 

  6086.   ----------------------------------------------------------------------*/
    6087. 

  6087. static void MergePseudoParagraph (Element el, Document doc)
    6088. 

  6088. {
    6089. 

  6089.   Element	prev, next;
    6090. 

  6090.   ElementType	elType;
    6091. 

  6091. 

  6092.   elType = TtaGetElementType (el);
    6093. 

  6093.   if (elType.ElTypeNum == HTML_EL_Pseudo_paragraph)
    6094. 

  6094.     {
    6095. 

  6095.       prev = el;
    6096. 

  6096.       TtaPreviousSibling (&prev);
    6097. 

  6097.       if (prev != NULL)
    6098. 

  6098.         {
    6099. 

  6099.           elType = TtaGetElementType (prev);
    6100. 

  6100.           if (elType.ElTypeNum == HTML_EL_Pseudo_paragraph)
    6101. 

  6101.             /* previous sibling is a pseud-paragraph too */
    6102. 

  6102.             MergeElements (prev, el, doc);
    6103. 

  6103.         }
    6104. 

  6104.       next = el;
    6105. 

  6105.       TtaNextSibling (&next);
    6106. 

  6106.       if (next != NULL)
    6107. 

  6107.         {
    6108. 

  6108.           elType = TtaGetElementType (next);
    6109. 

  6109.           if (elType.ElTypeNum == HTML_EL_Pseudo_paragraph)
    6110. 

  6110.             /* next sibling is a pseud-paragraph too */
    6111. 

  6111.             MergeElements (el, next, doc);
    6112. 

  6112.         }
    6113. 

  6113.     }
    6114. 

  6114. }
    6115. 

  6115. 

  6116. /*----------------------------------------------------------------------
    6117. 

  6117.   CheckBlocksInCharElem
    6118. 

  6118.   handle character-level elements which contain block-level elements
    6119. 

  6119.   ----------------------------------------------------------------------*/
    6120. 

  6120. void CheckBlocksInCharElem (Document doc)
    6121. 

  6121. {
    6122. 

  6122.   Element             el, parent, child, first, last, next, copy;
    6123. 

  6123.   Element             newparent, elem, prev, firstNotCharElem;
    6124. 

  6124.   PtrElemToBeChecked  elTBC, nextElTBC, TBC;
    6125. 

  6125.   ElementType	      elType, parentType;
    6126. 

  6126.   ThotBool            done;
    6127. 

  6127.   
    6128. 

  6128.   /* check all block-level elements whose parent 
    6129. 

  6129.      was a character-level element */
    6130. 

  6130.   elTBC = FirstElemToBeChecked;
    6131. 

  6131.   while (elTBC)
    6132. 

  6132.     {
    6133. 

  6133.       el = elTBC->Elem;
    6134. 

  6134.       while (el != NULL)
    6135. 

  6135.         {
    6136. 

  6136.           parent = TtaGetParent (el);
    6137. 

  6137.           if (parent == NULL)
    6138. 

  6138.             el = NULL;
    6139. 

  6139.           else if (!IsCharacterLevelElement (parent))
    6140. 

  6140.             {
    6141. 

  6141.               MergePseudoParagraph (el, doc);
    6142. 

  6142.               el = NULL;
    6143. 

  6143.             }
    6144. 

  6144.           else
    6145. 

  6145.             {
    6146. 

  6146.               parentType = TtaGetElementType (parent);
    6147. 

  6147.               elType = TtaGetElementType (el);
    6148. 

  6148.               firstNotCharElem = NULL;
    6149. 

  6149.               if (elType.ElTypeNum == HTML_EL_Pseudo_paragraph)
    6150. 

  6150.                 {
    6151. 

  6151.                   first = TtaGetFirstChild (el);
    6152. 

  6152.                   child = first;
    6153. 

  6153.                   last = NULL;
    6154. 

  6154.                   /* move the pseudo paragraph as sibling of parent*/
    6155. 

  6155.                   TtaRemoveTree (el, doc);
    6156. 

  6156.                   TtaInsertSibling (el, parent, TRUE, doc);
    6157. 

  6157.                   /* move all children of element el as children of parent */
    6158. 

  6158.                   do
    6159. 

  6159.                     {
    6160. 

  6160.                       next = child;
    6161. 

  6161.                       TtaNextSibling (&next);
    6162. 

  6162.                       /* register the next element to be checked */
    6163. 

  6163.                       if (firstNotCharElem == NULL &&
    6164. 

  6164.                           !IsCharacterLevelElement (child))
    6165. 

  6165.                         firstNotCharElem = child;		    
    6166. 

  6166.                       TtaRemoveTree (child, doc);
    6167. 

  6167.                       if (child == first)
    6168. 

  6168.                         TtaInsertFirstChild (&child, parent, doc);
    6169. 

  6169.                       else
    6170. 

  6170.                         /* Modif LC 21/06/01 */
    6171. 

  6171.                         /* Insert the element 'child' after the element
    6172. 

  6172.                            'last', not before */
    6173. 

  6173.                         TtaInsertSibling (child, last, FALSE, doc);
    6174. 

  6174.                       last = child;
    6175. 

  6175.                       child = next;
    6176. 

  6176.                     }
    6177. 

  6177.                   while (child != NULL);
    6178. 

  6178.                   elType.ElTypeNum = HTML_EL_Pseudo_paragraph;
    6179. 

  6179.                   if (TtaGetTypedAncestor (parent, elType))
    6180. 

  6180.                     {
    6181. 

  6181.                       /* there is already an ancestor of type pseudo paragraph.
    6182. 

  6182.                          Delete this one */
    6183. 

  6183.                       TtaDeleteTree (el, doc);
    6184. 

  6184.                       el = NULL;
    6185. 

  6185.                     }
    6186. 

  6186.                   else
    6187. 

  6187.                     /* move parent as a child of the pseudo paragraph */
    6188. 

  6188.                     {
    6189. 

  6189.                       TtaRemoveTree (parent, doc);
    6190. 

  6190.                       TtaInsertFirstChild (&parent, el, doc);
    6191. 

  6191.                     }
    6192. 

  6192.                 }
    6193. 

  6193.               else
    6194. 

  6194.                 {
    6195. 

  6195.                   /* move all children of element parent as siblings of el */
    6196. 

  6196.                   first = TtaGetFirstChild (parent);
    6197. 

  6197.                   child = first;
    6198. 

  6198.                   do
    6199. 

  6199.                     {
    6200. 

  6200.                       next = child;
    6201. 

  6201.                       TtaNextSibling (&next);
    6202. 

  6202.                       TtaRemoveTree (child, doc);
    6203. 

  6203.                       TtaInsertSibling (child, parent, TRUE, doc);
    6204. 

  6204.                       last = child;
    6205. 

  6205.                       child = next;
    6206. 

  6206.                     }
    6207. 

  6207.                   while (child != NULL);
    6208. 

  6208.                   /* copy the character-level element for all elements that
    6209. 

  6209.                      have been moved */
    6210. 

  6210.                   newparent = TtaGetParent (parent);
    6211. 

  6211.                   elem = first;
    6212. 

  6212.                   prev = NULL;
    6213. 

  6213.                   do
    6214. 

  6214.                     {
    6215. 

  6215.                       /* if the character level element (parent) is an anchor, don't
    6216. 

  6216.                          repeat it several times */
    6217. 

  6217.                       if (elem == last || parentType.ElTypeNum == HTML_EL_Anchor)
    6218. 

  6218.                         next = NULL;
    6219. 

  6219.                       else
    6220. 

  6220.                         {
    6221. 

  6221.                           next = elem;
    6222. 

  6222.                           TtaNextSibling (&next);
    6223. 

  6223.                         }
    6224. 

  6224.                       elType = TtaGetElementType (elem);
    6225. 

  6225.                       if (elType.ElTypeNum != HTML_EL_Comment_ &&
    6226. 

  6226.                           !IsCharacterLevelElement (elem))
    6227. 

  6227.                         /* This is not a character level element */
    6228. 

  6228.                         /* create a copy of parent for all decendants of child */
    6229. 

  6229.                         {
    6230. 

  6230.                           done = FALSE;
    6231. 

  6231.                           EncloseCharLevelElem (elem, parent, doc, &done);
    6232. 

  6232.                           if (done)
    6233. 

  6233.                             next = NULL;
    6234. 

  6234.                           prev = NULL;
    6235. 

  6235.                           /* register the next element to be checked */
    6236. 

  6236.                           if (firstNotCharElem == NULL)
    6237. 

  6237.                             firstNotCharElem = elem;		    
    6238. 

  6238.                         }
    6239. 

  6239.                       else
    6240. 

  6240.                         /* this is a character level element */
    6241. 

  6241.                         /* enclose elem in a copy of parent element */
    6242. 

  6242.                         {
    6243. 

  6243.                           if (prev != NULL)
    6244. 

  6244.                             {
    6245. 

  6245.                               TtaRemoveTree (elem, doc);
    6246. 

  6246.                               TtaInsertSibling (elem, prev, FALSE, doc);
    6247. 

  6247.                             }
    6248. 

  6248.                           else
    6249. 

  6249.                             {
    6250. 

  6250.                               copy = TtaCopyTree (parent, doc, doc, newparent);
    6251. 

  6251.                               TtaInsertSibling (copy, elem, TRUE, doc);
    6252. 

  6252.                               TtaRemoveTree (elem, doc);
    6253. 

  6253.                               TtaInsertFirstChild (&elem, copy, doc);
    6254. 

  6254.                             }
    6255. 

  6255.                           prev = elem;
    6256. 

  6256.                         }
    6257. 

  6257.                       elem = next;
    6258. 

  6258.                     }
    6259. 

  6259.                   while (elem != NULL);
    6260. 

  6260.                   /* delete the old character-level element */
    6261. 

  6261.                   TtaDeleteTree (parent, doc);
    6262. 

  6262.                 }
    6263. 

  6263. 

  6264.               /* if, among the elements that have just been moved, there are
    6265. 

  6265.                  pseudo-paragraphs which are now children of a block element,
    6266. 

  6266.                  remove these pseudo-paragraphs */
    6267. 

  6267.               elem = firstNotCharElem;
    6268. 

  6268.               if (firstNotCharElem)
    6269. 

  6269.                 {
    6270. 

  6270.                   parent = TtaGetParent (firstNotCharElem);
    6271. 

  6271.                   if (parent != NULL && !IsBlockElement (parent))
    6272. 

  6272.                     elem = NULL;
    6273. 

  6273.                 }
    6274. 

  6274.               while (elem != NULL)
    6275. 

  6275.                 {
    6276. 

  6276.                   if (elem == last)
    6277. 

  6277.                     next = NULL;
    6278. 

  6278.                   else
    6279. 

  6279.                     {
    6280. 

  6280.                       next = elem;
    6281. 

  6281.                       TtaNextSibling (&next);
    6282. 

  6282.                     }
    6283. 

  6283.                   elType = TtaGetElementType (elem);
    6284. 

  6284.                   if (elType.ElTypeNum == HTML_EL_Pseudo_paragraph)
    6285. 

  6285.                     {
    6286. 

  6286.                       child = TtaGetFirstChild (elem);
    6287. 

  6287.                       do
    6288. 

  6288.                         {
    6289. 

  6289.                           next = child;
    6290. 

  6290.                           TtaNextSibling (&next);
    6291. 

  6291.                           TtaRemoveTree (child, doc);
    6292. 

  6292.                           TtaInsertSibling (child, elem, TRUE, doc);
    6293. 

  6293.                           child = next;
    6294. 

  6294.                         }
    6295. 

  6295.                       while (child != NULL);
    6296. 

  6296.                       if (elem == el)
    6297. 

  6297.                         el = NULL;
    6298. 

  6298. 

  6299.                       /* if this element is in the queue, remove it from the queue */
    6300. 

  6300.                       TBC = elTBC->nextElemToBeChecked;
    6301. 

  6301.                       while (TBC != NULL)
    6302. 

  6302.                         {
    6303. 

  6303.                           if (TBC->Elem == elem)
    6304. 

  6304.                             TBC->Elem = NULL;
    6305. 

  6305.                           TBC = TBC->nextElemToBeChecked;
    6306. 

  6306.                         }
    6307. 

  6307.                       TtaDeleteTree (elem, doc);
    6308. 

  6308.                     }
    6309. 

  6309.                   elem = next;	     
    6310. 

  6310.                 }
    6311. 

  6311.               /* if el is a Pseudo-paragraph, merge it with its next or previous
    6312. 

  6312.                  siblings if they also are Pseudo-paragraphs */
    6313. 

  6313.               if (el != NULL)
    6314. 

  6314.                 MergePseudoParagraph (el, doc);
    6315. 

  6315.             }
    6316. 

  6316.         }
    6317. 

  6317.       nextElTBC = elTBC->nextElemToBeChecked;
    6318. 

  6318.       TtaFreeMemory (elTBC);
    6319. 

  6319.       elTBC = nextElTBC;
    6320. 

  6320.     }
    6321. 

  6321.   FirstElemToBeChecked = NULL;
    6322. 

  6322.   LastElemToBeChecked = NULL;
    6323. 

  6323. }
    6324. 

  6324. 

  6325. /*----------------------------------------------------------------------
    6326. 

  6326.   ParentOfType
    6327. 

  6327.   Return the parent element of element el if it is an HTML element of type
    6328. 

  6328.   typeNum. Ignore elements from the Templates namespace.
    6329. 

  6329.   ----------------------------------------------------------------------*/
    6330. 

  6330. static Element ParentOfType (Element el, int typeNum)
    6331. 

  6331. {
    6332. 

  6332.   ElementType	elType;
    6333. 

  6333.   Element     parent;
    6334. 

  6334. 

  6335.   parent = TtaGetParent (el);
    6336. 

  6336.   elType = TtaGetElementType (parent);
    6337. 

  6337. #ifdef TEMPLATES
    6338. 

  6338.   /* if the parent is a Template element, skip it */
    6339. 

  6339.   while (strcmp(TtaGetSSchemaName(elType.ElSSchema),"Template") == 0)
    6340. 

  6340.     {
    6341. 

  6341.       parent = TtaGetParent (parent);
    6342. 

  6342.       elType = TtaGetElementType (parent);
    6343. 

  6343.     }
    6344. 

  6344. #endif /* TEMPLATES */
    6345. 

  6345.   if (elType.ElTypeNum != typeNum)
    6346. 

  6346.     parent = NULL;
    6347. 

  6347.   else if (strcmp(TtaGetSSchemaName(elType.ElSSchema),"HTML") != 0)
    6348. 

  6348.     parent = NULL;
    6349. 

  6349.   return parent;
    6350. 

  6350. }
    6351. 

  6351. 

  6352. /*----------------------------------------------------------------------
    6353. 

  6353.   CheckAbstractTree
    6354. 

  6354.   Check the Thot abstract tree and create the missing elements.
    6355. 

  6355.   The parameter isXTiger is TRUE when parsing a XTiger template.
    6356. 

  6356.   ----------------------------------------------------------------------*/
    6357. 

  6357. void CheckAbstractTree (Document doc, ThotBool isXTiger)
    6358. 

  6358. {
    6359. 

  6359.   ElementType	elType, newElType, headElType;
    6360. 

  6360.   Element	elRoot, glossary, list, elText, previous;
    6361. 

  6361.   Element	el, elHead, elBody, elFrameset, elNoframes, nextEl, newEl;
    6362. 

  6362.   Element	prevEl, lastChild, firstTerm, lastTerm, termList, child;
    6363. 

  6363.   Element	parent, firstDef, lastDef, defList, firstEntry, lastEntry;
    6364. 

  6364.   ThotBool	ok, moved;
    6365. 

  6365.   SSchema       htmlSSchema;
    6366. 

  6366. 

  6367.   /* the root HTML element only accepts elements HEAD, BODY, FRAMESET
    6368. 

  6368.      Comment and PI as children */
    6369. 

  6369.   elHead = NULL;
    6370. 

  6370.   elBody = NULL;
    6371. 

  6371.   elFrameset = NULL;
    6372. 

  6372.   elNoframes = NULL;
    6373. 

  6373. 

  6374.   htmlSSchema = TtaGetSSchema ("HTML", doc);
    6375. 

  6375. #ifdef ANNOTATIONS
    6376. 

  6376.   if (DocumentTypes[doc] == docAnnot)
    6377. 

  6377.     /* we search the start of HTML document in the annotation struct */
    6378. 

  6378.     elRoot = ANNOT_GetHTMLRoot (doc, FALSE);
    6379. 

  6379.   else
    6380. 

  6380. #endif /* ANNOTATIONS */
    6381. 

  6381.     elRoot = TtaGetRootElement (doc);
    6382. 

  6382.   if (!elRoot)
    6383. 

  6383.     /* there is no <html> element! Create one */
    6384. 

  6384.     {
    6385. 

  6385.       /* create a <html> element */
    6386. 

  6386.       elType.ElSSchema = htmlSSchema;
    6387. 

  6387.       elType.ElTypeNum = HTML_EL_HTML;
    6388. 

  6388.       elRoot = TtaNewElement (doc, elType);
    6389. 

  6389.       /* insert it as the first child of the Document node */
    6390. 

  6390.       el = TtaGetMainRoot (doc);
    6391. 

  6391.       TtaInsertFirstChild (&elRoot, el, doc);
    6392. 

  6392.       /* move all other children of the Document node within this
    6393. 

  6393.          new <html> element */
    6394. 

  6394.       el = elRoot;
    6395. 

  6395.       TtaNextSibling (&el);
    6396. 

  6396.       lastChild = NULL;
    6397. 

  6397.       while (el)
    6398. 

  6398.         {
    6399. 

  6399.           nextEl = el;
    6400. 

  6400.           TtaNextSibling (&nextEl);
    6401. 

  6401.           TtaRemoveTree (el, doc);
    6402. 

  6402.           if (!lastChild)
    6403. 

  6403.             TtaInsertFirstChild (&el, elRoot, doc);
    6404. 

  6404.           else
    6405. 

  6405.             TtaInsertSibling (el, lastChild, FALSE, doc);
    6406. 

  6406.           lastChild = el;
    6407. 

  6407.           el = nextEl;
    6408. 

  6408.         }
    6409. 

  6409.     }
    6410. 

  6410.   el = TtaGetFirstChild (elRoot);
    6411. 

  6411.   if (el != NULL)
    6412. 

  6412.     {
    6413. 

  6413.       elType = TtaGetElementType (el);
    6414. 

  6414.       /* skip Comments, PI and Invalid_elements */
    6415. 

  6415.       while (el != NULL && elType.ElSSchema == htmlSSchema &&
    6416. 

  6416.              (elType.ElTypeNum == HTML_EL_Comment_ ||
    6417. 

  6417.               elType.ElTypeNum == HTML_EL_Invalid_element ||
    6418. 

  6418.               elType.ElTypeNum == HTML_EL_XMLPI))
    6419. 

  6419.         {
    6420. 

  6420.           TtaNextSibling (&el);
    6421. 

  6421.           if (el != NULL)
    6422. 

  6422.             elType = TtaGetElementType (el);
    6423. 

  6423.         }
    6424. 

  6424.       if (elType.ElTypeNum == HTML_EL_HTML && elType.ElSSchema == htmlSSchema)
    6425. 

  6425.         /* that's the HTML root element */
    6426. 

  6426.         {
    6427. 

  6427.           elRoot = el;
    6428. 

  6428.           /* check its children elements */
    6429. 

  6429.           el = TtaGetFirstChild (elRoot);
    6430. 

  6430.           elType = TtaGetElementType (el);
    6431. 

  6431.           /* skip Comments, PI and Invalid_elements */
    6432. 

  6432.           while (el != NULL && elType.ElSSchema == htmlSSchema &&
    6433. 

  6433.                  (elType.ElTypeNum == HTML_EL_Comment_ ||
    6434. 

  6434.                   elType.ElTypeNum == HTML_EL_Invalid_element ||
    6435. 

  6435.                   elType.ElTypeNum == HTML_EL_XMLPI))
    6436. 

  6436.             {
    6437. 

  6437.               TtaNextSibling (&el);
    6438. 

  6438.               if (el != NULL)
    6439. 

  6439.                 elType = TtaGetElementType (el);
    6440. 

  6440.             }
    6441. 

  6441.         }
    6442. 

  6442.       if (elType.ElTypeNum == HTML_EL_HEAD && elType.ElSSchema == htmlSSchema)
    6443. 

  6443.         /* the first child of the root element is HEAD */
    6444. 

  6444.         {
    6445. 

  6445.           elHead = el;
    6446. 

  6446.           TtaNextSibling (&el);
    6447. 

  6447.           if (el != NULL)
    6448. 

  6448.             elType = TtaGetElementType (el);
    6449. 

  6449.         }
    6450. 

  6450.       else
    6451. 

  6451.         {
    6452. 

  6452.           elType.ElSSchema = htmlSSchema;
    6453. 

  6453.           elType.ElTypeNum = HTML_EL_HEAD;
    6454. 

  6454.           elHead = TtaSearchTypedElement (elType, SearchForward, elRoot);
    6455. 

  6455.           if (elHead != NULL)
    6456. 

  6456.             /* an element HEAD has been found */
    6457. 

  6457.             {
    6458. 

  6458.               /* move the HEAD element before the current element */
    6459. 

  6459.               TtaRemoveTree (elHead, doc);
    6460. 

  6460.               TtaInsertSibling (elHead, el, TRUE, doc);
    6461. 

  6461.             }
    6462. 

  6462.         }
    6463. 

  6463.       /* skip Comments, PI and Invalid_elements */
    6464. 

  6464.       while (el != NULL &&  elType.ElSSchema == htmlSSchema &&
    6465. 

  6465.              (elType.ElTypeNum == HTML_EL_Comment_ ||
    6466. 

  6466.               elType.ElTypeNum == HTML_EL_Invalid_element ||
    6467. 

  6467.               elType.ElTypeNum == HTML_EL_XMLPI))
    6468. 

  6468.         {
    6469. 

  6469.           TtaNextSibling (&el);
    6470. 

  6470.           if (el != NULL)
    6471. 

  6471.             elType = TtaGetElementType (el);
    6472. 

  6472.         }
    6473. 

  6473.       if (el != NULL)
    6474. 

  6474.         {
    6475. 

  6475.           if (elType.ElTypeNum == HTML_EL_HTML &&
    6476. 

  6476.               elType.ElSSchema == htmlSSchema)
    6477. 

  6477.             elRoot = el;
    6478. 

  6478.           else if (elType.ElTypeNum == HTML_EL_BODY &&
    6479. 

  6479.                    elType.ElSSchema == htmlSSchema)
    6480. 

  6480.             /* this child of the root element is BODY */
    6481. 

  6481.             elBody = el;
    6482. 

  6482.         }
    6483. 

  6483. 	
    6484. 

  6484.       /* check all children of the root element */
    6485. 

  6485.       CheckHeadElements (elRoot, &elHead, &elBody, doc);
    6486. 

  6486.       if (elBody != NULL)
    6487. 

  6487.         CheckHeadElements (elBody, &elHead, &elBody, doc);
    6488. 

  6488. 

  6489.       if (elHead == NULL)
    6490. 

  6490.         /* there is no HEAD element. Create one */
    6491. 

  6491.         {
    6492. 

  6492.           newElType.ElSSchema = htmlSSchema;
    6493. 

  6493.           newElType.ElTypeNum = HTML_EL_HEAD;
    6494. 

  6494.           elHead = TtaNewTree (doc, newElType, "");
    6495. 

  6495.           TtaInsertFirstChild (&elHead, elRoot, doc);
    6496. 

  6496.         }
    6497. 

  6497. 

  6498.       if (elHead != NULL)
    6499. 

  6499.         {
    6500. 

  6500.           headElType = TtaGetElementType (elHead);
    6501. 

  6501.           /* create a Document_URL element as the first child of HEAD */
    6502. 

  6502.           newElType.ElSSchema = htmlSSchema;
    6503. 

  6503.           newElType.ElTypeNum = HTML_EL_Document_URL;
    6504. 

  6504.           el = TtaGetFirstChild (elHead);
    6505. 

  6505.           if (el != NULL)
    6506. 

  6506.             {
    6507. 

  6507.               elType = TtaGetElementType (el);
    6508. 

  6508.               if (elType.ElTypeNum == newElType.ElTypeNum &&
    6509. 

  6509.                   elType.ElSSchema == newElType.ElSSchema)
    6510. 

  6510.                 /* element Document_URL already exists */
    6511. 

  6511.                 elText = TtaGetFirstChild (el);
    6512. 

  6512.               else
    6513. 

  6513.                 el = NULL;
    6514. 

  6514.             }
    6515. 

  6515.           if (el == NULL)
    6516. 

  6516.             /* there is no Document_URL element */
    6517. 

  6517.             {
    6518. 

  6518.               el = TtaNewElement (doc, newElType);
    6519. 

  6519.               TtaInsertFirstChild (&el, elHead, doc);
    6520. 

  6520.               newElType.ElTypeNum = HTML_EL_TEXT_UNIT;
    6521. 

  6521.               elText = TtaNewElement (doc, newElType);
    6522. 

  6522.               TtaInsertFirstChild (&elText, el, doc);
    6523. 

  6523.             }
    6524. 

  6524.           TtaSetAccessRight (el, ReadOnly, doc);
    6525. 

  6525.           if (DocumentURLs[doc] != NULL && elText != NULL)
    6526. 

  6526.             TtaSetTextContent (elText,(unsigned char *) DocumentURLs[doc], HTMLcontext.language, doc);
    6527. 

  6527.           /* check all chidren of the HEAD Element, except the first one */
    6528. 

  6528.           /* which is Document_URL */
    6529. 

  6529.           TtaNextSibling (&el);
    6530. 

  6530.           lastChild = NULL;
    6531. 

  6531.           while (el != NULL)
    6532. 

  6532.             {
    6533. 

  6533.               nextEl = el;
    6534. 

  6534.               TtaNextSibling (&nextEl);
    6535. 

  6535.               elType = TtaGetElementType (el);
    6536. 

  6536.               /* is this element allowed in the HEAD? */
    6537. 

  6537.               if (TtaGetRankInAggregate (elType, headElType) <= 0)
    6538. 

  6538.                 /* this element is not a valid component of aggregate HEAD */
    6539. 

  6539. #ifdef TEMPLATES
    6540. 

  6540.                 /* if it is a Template element, accept it */
    6541. 

  6541.                 if (strcmp(TtaGetSSchemaName(elType.ElSSchema),"Template") != 0)
    6542. 

  6542. #endif /* TEMPLATES */
    6543. 

  6543.                   /* It may be an SGML inclusion, let's check */
    6544. 

  6544.                   if (!TtaCanInsertFirstChild (elType, elHead, doc))
    6545. 

  6545.                     /* this element cannot be a child of HEAD, move it to
    6546. 

  6546.                        the BODY */
    6547. 

  6547.                     {
    6548. 

  6548.                       /* create the BODY element if it does not exist */
    6549. 

  6549.                       if (elBody == NULL)
    6550. 

  6550.                         {
    6551. 

  6551.                           newElType.ElSSchema = htmlSSchema;
    6552. 

  6552.                           newElType.ElTypeNum = HTML_EL_BODY;
    6553. 

  6553.                           elBody = TtaNewElement (doc, newElType);
    6554. 

  6554.                           TtaInsertSibling (elBody, elHead, FALSE, doc);
    6555. 

  6555.                         }
    6556. 

  6556.                       /* move the current element into the BODY element */
    6557. 

  6557.                       TtaRemoveTree (el, doc);
    6558. 

  6558.                       if (lastChild == NULL)
    6559. 

  6559.                         TtaInsertFirstChild (&el, elBody, doc);
    6560. 

  6560.                       else
    6561. 

  6561.                         TtaInsertSibling (el, lastChild, FALSE, doc);
    6562. 

  6562.                       lastChild = el;
    6563. 

  6563.                     }
    6564. 

  6564.               el = nextEl;
    6565. 

  6565.             }
    6566. 

  6566.         }
    6567. 

  6567.       /* check the children of the root */
    6568. 

  6568.       lastChild = NULL;
    6569. 

  6569.       el = TtaGetFirstChild (elRoot);
    6570. 

  6570.       previous = elHead;
    6571. 

  6571.       moved = FALSE;
    6572. 

  6572.       while (el != NULL)
    6573. 

  6573.         {
    6574. 

  6574.           nextEl = el;
    6575. 

  6575.           TtaNextSibling (&nextEl);
    6576. 

  6576.           elType = TtaGetElementType (el);
    6577. 

  6577.           if (elType.ElTypeNum == HTML_EL_BODY &&
    6578. 

  6578.               elType.ElSSchema == htmlSSchema)
    6579. 

  6579.             /* stop */
    6580. 

  6580.             nextEl = NULL;
    6581. 

  6581.           else if (elType.ElTypeNum == HTML_EL_FRAMESET &&
    6582. 

  6582.                    elType.ElSSchema == htmlSSchema)
    6583. 

  6583.             {
    6584. 

  6584.               if (elFrameset == NULL)
    6585. 

  6585.                 elFrameset = el;
    6586. 

  6586.             }
    6587. 

  6587.           else if (elType.ElTypeNum == HTML_EL_NOFRAMES &&
    6588. 

  6588.                    elType.ElSSchema == htmlSSchema)
    6589. 

  6589.             {
    6590. 

  6590.               if (elNoframes == NULL)
    6591. 

  6591.                 elNoframes = el;
    6592. 

  6592.             }
    6593. 

  6593.           else if (!moved && elType.ElSSchema == htmlSSchema &&
    6594. 

  6594.                    (elType.ElTypeNum == HTML_EL_Invalid_element ||
    6595. 

  6595.                     elType.ElTypeNum == HTML_EL_Comment_ ||
    6596. 

  6596.                     elType.ElTypeNum == HTML_EL_XMLPI))
    6597. 

  6597.             /* don't move Comments, PI and Invalid_elements if the previous
    6598. 

  6598.                element has not been moved */
    6599. 

  6599.             previous = el;
    6600. 

  6600.           else if (elType.ElTypeNum == HTML_EL_HEAD &&
    6601. 

  6601.                    elType.ElSSchema == htmlSSchema)
    6602. 

  6602.             previous = el;
    6603. 

  6603.           else if (elType.ElTypeNum != HTML_EL_FRAMESET ||
    6604. 

  6604.                    elType.ElSSchema != htmlSSchema)
    6605. 

  6605.             /* this element should be a child of BODY */
    6606. 

  6606.             {
    6607. 

  6607.               /* create the BODY element if it does not exist */
    6608. 

  6608.               if (elBody == NULL)
    6609. 

  6609.                 {
    6610. 

  6610.                   newElType.ElSSchema = htmlSSchema;
    6611. 

  6611.                   newElType.ElTypeNum = HTML_EL_BODY;
    6612. 

  6612.                   elBody = TtaNewElement (doc, newElType);
    6613. 

  6613.                   if (previous == NULL)
    6614. 

  6614.                     TtaInsertFirstChild (&elBody, elRoot, doc);
    6615. 

  6615.                   else
    6616. 

  6616.                     TtaInsertSibling (elBody, previous, FALSE, doc);
    6617. 

  6617.                 }
    6618. 

  6618.               /* move the current element into the BODY element */
    6619. 

  6619.               TtaRemoveTree (el, doc);
    6620. 

  6620.               if (lastChild == NULL)
    6621. 

  6621.                 TtaInsertFirstChild (&el, elBody, doc);
    6622. 

  6622.               else
    6623. 

  6623.                 TtaInsertSibling (el, lastChild, FALSE, doc);
    6624. 

  6624.               lastChild = el;
    6625. 

  6625.               moved = TRUE;
    6626. 

  6626.             }
    6627. 

  6627.           /* get next child of the root */
    6628. 

  6628.           el = nextEl;
    6629. 

  6629.         }
    6630. 

  6630.       if (elFrameset && elNoframes)
    6631. 

  6631.         if (!TtaIsAncestor(elNoframes, elFrameset))
    6632. 

  6632.           /* moves the NOFRAMES element within the FRAMESET element */
    6633. 

  6633.           {
    6634. 

  6634.             el = TtaGetFirstChild(elFrameset);
    6635. 

  6635.             previous = NULL;
    6636. 

  6636.             while (el)
    6637. 

  6637.               {
    6638. 

  6638.                 previous = el;
    6639. 

  6639.                 TtaNextSibling (&el);
    6640. 

  6640.               }
    6641. 

  6641.             TtaRemoveTree (elNoframes, doc);
    6642. 

  6642.             if (previous == NULL)
    6643. 

  6643.               TtaInsertFirstChild (&elNoframes, elFrameset, doc);
    6644. 

  6644.             else
    6645. 

  6645.               TtaInsertSibling (elNoframes, previous, FALSE, doc);
    6646. 

  6646.           }
    6647. 

  6647. 

  6648.       /* handle character-level elements which contain block-level elements*/
    6649. 

  6649.       CheckBlocksInCharElem (doc);
    6650. 

  6650. 

  6651.       /* create a Term_List element for each sequence of Term elements */
    6652. 

  6652.       el = TtaGetFirstChild (elRoot);
    6653. 

  6653.       /* search all Term elements in the document */
    6654. 

  6654.       while (el != NULL)
    6655. 

  6655.         {
    6656. 

  6656.           elType.ElSSchema = htmlSSchema;
    6657. 

  6657.           elType.ElTypeNum = HTML_EL_Term;
    6658. 

  6658.           el = TtaSearchTypedElement (elType, SearchForward, el);
    6659. 

  6659.           if (el != NULL)
    6660. 

  6660.             /* an element Term has been found */
    6661. 

  6661.             {
    6662. 

  6662.               /* search all immediate Term siblings, ignoring
    6663. 

  6663.                  Comments, PI and Invalid_elements */
    6664. 

  6664.               firstTerm = el;
    6665. 

  6665.               do
    6666. 

  6666.                 {
    6667. 

  6667.                   lastTerm = el;
    6668. 

  6668.                   TtaNextSibling (&el);
    6669. 

  6669.                   if (el == NULL)
    6670. 

  6670.                     elType.ElTypeNum = 0;
    6671. 

  6671.                   else
    6672. 

  6672.                     elType = TtaGetElementType (el);
    6673. 

  6673.                 }
    6674. 

  6674.               while (elType.ElSSchema == htmlSSchema &&
    6675. 

  6675.                      (elType.ElTypeNum == HTML_EL_Term ||
    6676. 

  6676.                       elType.ElTypeNum == HTML_EL_Invalid_element ||
    6677. 

  6677.                       elType.ElTypeNum == HTML_EL_Comment_ ||
    6678. 

  6678.                       elType.ElTypeNum == HTML_EL_XMLPI));
    6679. 

  6679.               termList = ParentOfType (firstTerm, HTML_EL_Term_List);
    6680. 

  6680.               if (!termList)
    6681. 

  6681.                 {
    6682. 

  6682.                   /* create a Term_List element before the first
    6683. 

  6683.                      Term element */
    6684. 

  6684.                   newElType.ElSSchema = htmlSSchema;
    6685. 

  6685.                   newElType.ElTypeNum = HTML_EL_Term_List;
    6686. 

  6686.                   termList = TtaNewElement (doc, newElType);
    6687. 

  6687.                   TtaInsertSibling (termList, firstTerm, TRUE, doc);
    6688. 

  6688.                   /* move the Term elements as children of the new Term_List */
    6689. 

  6689.                   nextEl = firstTerm;
    6690. 

  6690.                   TtaNextSibling (&nextEl);
    6691. 

  6691.                   TtaRemoveTree (firstTerm, doc);
    6692. 

  6692.                   TtaInsertFirstChild (&firstTerm, termList, doc);
    6693. 

  6693.                   if (lastTerm != firstTerm)
    6694. 

  6694.                     {
    6695. 

  6695.                       prevEl = firstTerm;
    6696. 

  6696.                       do
    6697. 

  6697.                         {
    6698. 

  6698.                           child = nextEl;
    6699. 

  6699.                           TtaNextSibling (&nextEl);
    6700. 

  6700.                           TtaRemoveTree (child, doc);
    6701. 

  6701.                           TtaInsertSibling (child, prevEl, FALSE, doc);
    6702. 

  6702.                           prevEl = child;
    6703. 

  6703.                         }
    6704. 

  6704.                       while (nextEl != NULL && child != lastTerm);
    6705. 

  6705.                     }
    6706. 

  6706.                 }
    6707. 

  6707.               if (!ParentOfType (termList, HTML_EL_Definition_Item))
    6708. 

  6708.                 {
    6709. 

  6709.                   /* Create a Definition_Item element surrounding */
    6710. 

  6710.                   /* the Term_List element */
    6711. 

  6711.                   newElType.ElSSchema = htmlSSchema;
    6712. 

  6712.                   newElType.ElTypeNum = HTML_EL_Definition_Item;
    6713. 

  6713.                   newEl = TtaNewElement (doc, newElType);
    6714. 

  6714.                   TtaInsertSibling (newEl, termList, TRUE, doc);
    6715. 

  6715.                   TtaRemoveTree (termList, doc);
    6716. 

  6716.                   TtaInsertFirstChild (&termList, newEl, doc);
    6717. 

  6717.                 }
    6718. 

  6718.               if (el != NULL)
    6719. 

  6719.                 {
    6720. 

  6720.                   elType = TtaGetElementType (el);
    6721. 

  6721.                   if (elType.ElTypeNum == HTML_EL_Definition &&
    6722. 

  6722.                       elType.ElSSchema == htmlSSchema)
    6723. 

  6723.                     /* the following element is a definition */
    6724. 

  6724.                     {
    6725. 

  6725.                       /* search all Definition siblings, ignoring
    6726. 

  6726.                          Comments, PI and Invalid_elements */
    6727. 

  6727.                       firstDef = el;
    6728. 

  6728.                       do
    6729. 

  6729.                         {
    6730. 

  6730.                           lastDef = el;
    6731. 

  6731.                           TtaNextSibling (&el);
    6732. 

  6732.                           if (el == NULL)
    6733. 

  6733.                             elType.ElTypeNum = 0;
    6734. 

  6734.                           else
    6735. 

  6735.                             elType = TtaGetElementType (el);
    6736. 

  6736.                         }
    6737. 

  6737.                       while (elType.ElSSchema == htmlSSchema &&
    6738. 

  6738.                              (elType.ElTypeNum == HTML_EL_Definition ||
    6739. 

  6739.                               elType.ElTypeNum == HTML_EL_Invalid_element ||
    6740. 

  6740.                               elType.ElTypeNum == HTML_EL_Comment_ ||
    6741. 

  6741.                               elType.ElTypeNum == HTML_EL_XMLPI));
    6742. 

  6742.                       if (!ParentOfType (firstDef, HTML_EL_Definitions))
    6743. 

  6743.                         {
    6744. 

  6744.                           /* create a Definitions element after the
    6745. 

  6745.                              Term_List element */
    6746. 

  6746.                           newElType.ElSSchema = htmlSSchema;
    6747. 

  6747.                           newElType.ElTypeNum = HTML_EL_Definitions;
    6748. 

  6748.                           defList = TtaNewElement (doc, newElType);
    6749. 

  6749.                           TtaInsertSibling (defList, termList, FALSE, doc);
    6750. 

  6750.                           /* move the Definitions elements as children of the
    6751. 

  6751.                              new Definitions element */
    6752. 

  6752.                           nextEl = firstDef;
    6753. 

  6753.                           TtaNextSibling (&nextEl);
    6754. 

  6754.                           TtaRemoveTree (firstDef, doc);
    6755. 

  6755.                           TtaInsertFirstChild (&firstDef, defList, doc);
    6756. 

  6756.                           if (lastDef != firstDef)
    6757. 

  6757.                             {
    6758. 

  6758.                               prevEl = firstDef;
    6759. 

  6759.                               do
    6760. 

  6760.                                 {
    6761. 

  6761.                                   child = nextEl;
    6762. 

  6762.                                   TtaNextSibling (&nextEl);
    6763. 

  6763.                                   TtaRemoveTree (child, doc);
    6764. 

  6764.                                   TtaInsertSibling (child, prevEl, FALSE, doc);
    6765. 

  6765.                                   prevEl = child;
    6766. 

  6766.                                 }
    6767. 

  6767.                               while (nextEl != NULL && child != lastDef);
    6768. 

  6768.                             }
    6769. 

  6769.                         }
    6770. 

  6770.                     }
    6771. 

  6771.                 }
    6772. 

  6772.               /* starting element for the next search of a Term element */
    6773. 

  6773.               el = lastTerm;
    6774. 

  6774.             }
    6775. 

  6775.         }
    6776. 

  6776. 

  6777.       /* search all Definition elements without a Definitions parent */
    6778. 

  6778.       el = TtaGetFirstChild (elRoot);
    6779. 

  6779.       if (el != NULL)
    6780. 

  6780.         {
    6781. 

  6781.           /* search all Definition elements in the document */
    6782. 

  6782.           while (el != NULL)
    6783. 

  6783.             {
    6784. 

  6784.               elType.ElSSchema = htmlSSchema;
    6785. 

  6785.               elType.ElTypeNum = HTML_EL_Definition;
    6786. 

  6786.               el = TtaSearchTypedElement (elType, SearchForward, el);
    6787. 

  6787.               if (el != NULL)
    6788. 

  6788.                 /* an element Definition has been found */
    6789. 

  6789.                 {
    6790. 

  6790.                   if (!ParentOfType (el, HTML_EL_Definitions))
    6791. 

  6791.                     /* this Definition is not within a Definitions
    6792. 

  6792.                        element */
    6793. 

  6793.                     {
    6794. 

  6794.                       /* search all Definition siblings, ignoring Comments,
    6795. 

  6795.                          PIs and Invalid_elements */
    6796. 

  6796.                       firstDef = el;
    6797. 

  6797.                       do
    6798. 

  6798.                         {
    6799. 

  6799.                           lastDef = el;
    6800. 

  6800.                           TtaNextSibling (&el);
    6801. 

  6801.                           if (el == NULL)
    6802. 

  6802.                             elType.ElTypeNum = 0;
    6803. 

  6803.                           else
    6804. 

  6804.                             elType = TtaGetElementType (el);
    6805. 

  6805.                         }
    6806. 

  6806.                       while (elType.ElSSchema == htmlSSchema &&
    6807. 

  6807.                              (elType.ElTypeNum == HTML_EL_Definition ||
    6808. 

  6808.                               elType.ElTypeNum == HTML_EL_Invalid_element ||
    6809. 

  6809.                               elType.ElTypeNum == HTML_EL_Comment_ ||
    6810. 

  6810.                               elType.ElTypeNum == HTML_EL_XMLPI));
    6811. 

  6811.                       /* create a Definitions element */
    6812. 

  6812.                       newElType.ElSSchema = htmlSSchema;
    6813. 

  6813.                       newElType.ElTypeNum = HTML_EL_Definitions;
    6814. 

  6814.                       defList = TtaNewElement (doc, newElType);
    6815. 

  6815.                       TtaInsertSibling (defList, firstDef, TRUE, doc);
    6816. 

  6816.                       TtaRemoveTree (firstDef, doc);
    6817. 

  6817.                       TtaInsertFirstChild (&firstDef, defList, doc);
    6818. 

  6818.                       if (!ParentOfType (defList, HTML_EL_Definition_Item))
    6819. 

  6819.                         /* this Definition is not within a Definition_Item
    6820. 

  6820.                            element */
    6821. 

  6821.                         {
    6822. 

  6822.                           /* create a Definition_Item */
    6823. 

  6823.                           newElType.ElTypeNum = HTML_EL_Definition_Item;
    6824. 

  6824.                           newEl = TtaNewElement (doc, newElType);
    6825. 

  6825.                           TtaInsertSibling (newEl, defList, TRUE, doc);
    6826. 

  6826.                           TtaRemoveTree (defList, doc);
    6827. 

  6827.                           TtaInsertFirstChild (&defList, newEl, doc);
    6828. 

  6828.                         }
    6829. 

  6829.                       /* move the Definitions elements as children of the
    6830. 

  6830.                          Definitions element */
    6831. 

  6831.                       nextEl = firstDef;
    6832. 

  6832.                       TtaNextSibling (&nextEl);
    6833. 

  6833.                       if (lastDef != firstDef)
    6834. 

  6834.                         {
    6835. 

  6835.                           prevEl = firstDef;
    6836. 

  6836.                           do
    6837. 

  6837.                             {
    6838. 

  6838.                               child = nextEl;
    6839. 

  6839.                               TtaNextSibling (&nextEl);
    6840. 

  6840.                               TtaRemoveTree (child, doc);
    6841. 

  6841.                               TtaInsertSibling (child, prevEl, FALSE, doc);
    6842. 

  6842.                               prevEl = child;
    6843. 

  6843.                             }
    6844. 

  6844.                           while (nextEl != NULL && child != lastDef);
    6845. 

  6845.                         }
    6846. 

  6846.                     }
    6847. 

  6847.                 }
    6848. 

  6848.             }
    6849. 

  6849.         }
    6850. 

  6850. 

  6851.       if (!isXTiger)
    6852. 

  6852.         {
    6853. 

  6853.           /* create a surrounding element Definition_List for each sequence */
    6854. 

  6854.           /* of elements Definition_Item which are not in a Definition_List */
    6855. 

  6855.           el = TtaGetFirstChild (elRoot);
    6856. 

  6856.           if (el != NULL)
    6857. 

  6857.             {
    6858. 

  6858.               /* search all elements Definition_Item in the document */
    6859. 

  6859.               while (el != NULL)
    6860. 

  6860.                 {
    6861. 

  6861.                   elType.ElSSchema = htmlSSchema;
    6862. 

  6862.                   elType.ElTypeNum = HTML_EL_Definition_Item;
    6863. 

  6863.                   el = TtaSearchTypedElement (elType, SearchForward, el);
    6864. 

  6864.                   if (el != NULL)
    6865. 

  6865.                     /* an element Definition_Item has been found */
    6866. 

  6866.                     {
    6867. 

  6867.                       if (!ParentOfType (el, HTML_EL_Definition_List))
    6868. 

  6868.                         /* this Definition_Item is not a child of a Definition_List*/
    6869. 

  6869.                         {
    6870. 

  6870.                           /* search all immediate Definition_Item siblings */
    6871. 

  6871.                           firstEntry = el;
    6872. 

  6872.                           do
    6873. 

  6873.                             {
    6874. 

  6874.                               lastEntry = el;
    6875. 

  6875.                               TtaNextSibling (&el);
    6876. 

  6876.                               if (el == NULL)
    6877. 

  6877.                                 elType.ElTypeNum = 0;
    6878. 

  6878.                               else
    6879. 

  6879.                                 elType = TtaGetElementType (el);
    6880. 

  6880.                             }
    6881. 

  6881.                           while (elType.ElSSchema == htmlSSchema &&
    6882. 

  6882.                                  (elType.ElTypeNum == HTML_EL_Definition_Item ||
    6883. 

  6883.                                   elType.ElTypeNum == HTML_EL_Invalid_element ||
    6884. 

  6884.                                   elType.ElTypeNum == HTML_EL_Comment_ ||
    6885. 

  6885.                                   elType.ElTypeNum == HTML_EL_XMLPI));
    6886. 

  6886.                           /* create a Definition_List element before the */
    6887. 

  6887.                           /* first Definition_Item element */
    6888. 

  6888.                           newElType.ElSSchema = htmlSSchema;
    6889. 

  6889.                           newElType.ElTypeNum = HTML_EL_Definition_List;
    6890. 

  6890.                           glossary = TtaNewElement (doc, newElType);
    6891. 

  6891.                           TtaInsertSibling (glossary, firstEntry, TRUE, doc);
    6892. 

  6892.                           /* move the Definition_Item elements as children */
    6893. 

  6893.                           /* of the new Definition_List element */
    6894. 

  6894.                           nextEl = firstEntry;
    6895. 

  6895.                           TtaNextSibling (&nextEl);
    6896. 

  6896.                           TtaRemoveTree (firstEntry, doc);
    6897. 

  6897.                           TtaInsertFirstChild (&firstEntry, glossary, doc);
    6898. 

  6898.                           if (lastEntry != firstEntry)
    6899. 

  6899.                             {
    6900. 

  6900.                               prevEl = firstEntry;
    6901. 

  6901.                               do
    6902. 

  6902.                                 {
    6903. 

  6903.                                   child = nextEl;
    6904. 

  6904.                                   TtaNextSibling (&nextEl);
    6905. 

  6905.                                   TtaRemoveTree (child, doc);
    6906. 

  6906.                                   TtaInsertSibling (child, prevEl, FALSE, doc);
    6907. 

  6907.                                   prevEl = child;
    6908. 

  6908.                                 }
    6909. 

  6909.                               while (nextEl != NULL && child != lastEntry);
    6910. 

  6910.                             }
    6911. 

  6911.                           /* starting element for the next search of a */
    6912. 

  6912.                           /* Definition_Item */
    6913. 

  6913.                           el = lastEntry;
    6914. 

  6914.                         }
    6915. 

  6915.                     }
    6916. 

  6916.                 }
    6917. 

  6917.             }
    6918. 

  6918. 

  6919.           /* create a surrounding element Unnumbered_List for each sequence */
    6920. 

  6920.           /* of elements List_Item which are not in a Unnumbered_List, a */
    6921. 

  6921.           /* Numbered_List, a Menu, or a Directory */
    6922. 

  6922.           el = TtaGetFirstChild (elRoot);
    6923. 

  6923.           if (el != NULL)
    6924. 

  6924.             {
    6925. 

  6925.               /* search all elements List_Item in the document */
    6926. 

  6926.               do
    6927. 

  6927.                 {
    6928. 

  6928.                   elType.ElSSchema = htmlSSchema;
    6929. 

  6929.                   elType.ElTypeNum = HTML_EL_List_Item;
    6930. 

  6930.                   el = TtaSearchTypedElement (elType, SearchForward, el);
    6931. 

  6931.                   if (el != NULL)
    6932. 

  6932.                     /* an element List_Item has been found */
    6933. 

  6933.                     {
    6934. 

  6934.                       parent = TtaGetParent (el);
    6935. 

  6935.                       elType = TtaGetElementType (parent);
    6936. 

  6936. #ifdef TEMPLATES
    6937. 

  6937.                       /* if its parent is a Template element, skip it */
    6938. 

  6938.                       while (strcmp(TtaGetSSchemaName(elType.ElSSchema),"Template") == 0)
    6939. 

  6939.                         {
    6940. 

  6940.                           parent = TtaGetParent (parent);
    6941. 

  6941.                           elType = TtaGetElementType (parent);
    6942. 

  6942.                         }
    6943. 

  6943. #endif /* TEMPLATES */
    6944. 

  6944.                       if (elType.ElSSchema != htmlSSchema ||
    6945. 

  6945.                           (elType.ElTypeNum != HTML_EL_Unnumbered_List &&
    6946. 

  6946.                            elType.ElTypeNum != HTML_EL_Numbered_List &&
    6947. 

  6947.                            elType.ElTypeNum != HTML_EL_Menu &&
    6948. 

  6948.                            elType.ElTypeNum != HTML_EL_Directory))
    6949. 

  6949.                         /* this List_Item is not within a list */
    6950. 

  6950.                         {
    6951. 

  6951.                           /* search all immediate List_Item siblings */
    6952. 

  6952.                           firstEntry = el;
    6953. 

  6953.                           do
    6954. 

  6954.                             {
    6955. 

  6955.                               lastEntry = el;
    6956. 

  6956.                               TtaNextSibling (&el);
    6957. 

  6957.                               if (el == NULL)
    6958. 

  6958.                                 elType.ElTypeNum = 0;
    6959. 

  6959.                               else
    6960. 

  6960.                                 elType = TtaGetElementType (el);
    6961. 

  6961.                             }
    6962. 

  6962.                           while (elType.ElSSchema == htmlSSchema &&
    6963. 

  6963.                                  (elType.ElTypeNum == HTML_EL_List_Item ||
    6964. 

  6964.                                   elType.ElTypeNum == HTML_EL_Invalid_element ||
    6965. 

  6965.                                   elType.ElTypeNum == HTML_EL_Comment_ ||
    6966. 

  6966.                                   elType.ElTypeNum == HTML_EL_XMLPI));
    6967. 

  6967.                           /* create a HTML_EL_Unnumbered_List element before
    6968. 

  6968.                              the first List_Item element */
    6969. 

  6969.                           newElType.ElSSchema = htmlSSchema;
    6970. 

  6970.                           newElType.ElTypeNum = HTML_EL_Unnumbered_List;
    6971. 

  6971.                           list = TtaNewElement (doc, newElType);
    6972. 

  6972.                           TtaInsertSibling (list, firstEntry, TRUE, doc);
    6973. 

  6973.                           /* move the List_Item elements as children of */
    6974. 

  6974.                           /* the new HTML_EL_Unnumbered_List element */
    6975. 

  6975.                           nextEl = firstEntry;
    6976. 

  6976.                           TtaNextSibling (&nextEl);
    6977. 

  6977.                           TtaRemoveTree (firstEntry, doc);
    6978. 

  6978.                           TtaInsertFirstChild (&firstEntry, list, doc);
    6979. 

  6979.                           if (lastEntry != firstEntry)
    6980. 

  6980.                             {
    6981. 

  6981.                               prevEl = firstEntry;
    6982. 

  6982.                               do
    6983. 

  6983.                                 {
    6984. 

  6984.                                   child = nextEl;
    6985. 

  6985.                                   TtaNextSibling (&nextEl);
    6986. 

  6986.                                   TtaRemoveTree (child, doc);
    6987. 

  6987.                                   TtaInsertSibling (child, prevEl, FALSE, doc);
    6988. 

  6988.                                   prevEl = child;
    6989. 

  6989.                                 }
    6990. 

  6990.                               while (nextEl != NULL && child != lastEntry);
    6991. 

  6991.                             }
    6992. 

  6992.                           /* starting element for the next search of a
    6993. 

  6993.                              List_Item */
    6994. 

  6994.                           el = lastEntry;
    6995. 

  6995.                         }
    6996. 

  6996.                     }
    6997. 

  6997.                 }
    6998. 

  6998.               while (el);
    6999. 

  6999.             }
    7000. 

  7000.         }
    7001. 

  7001. 

  7002.       /* merge sibling Text elements with same attributes */
    7003. 

  7003.       el = elRoot;
    7004. 

  7004.       elType.ElSSchema = htmlSSchema;
    7005. 

  7005.       elType.ElTypeNum = HTML_EL_TEXT_UNIT;
    7006. 

  7006.       /* search all TEXT elements in the document */
    7007. 

  7007.       while (el != NULL)
    7008. 

  7008.         {
    7009. 

  7009.           /* search the next TEXT element in the abstract tree */
    7010. 

  7010.           el = TtaSearchTypedElement (elType, SearchForward, el);
    7011. 

  7011.           if (el != NULL)
    7012. 

  7012.             /* a Text element has been found. Try to merge it with its */
    7013. 

  7013.             /* following siblings */
    7014. 

  7014.             do
    7015. 

  7015.               ok = TtaMergeText (el, doc);
    7016. 

  7016.             while (ok);
    7017. 

  7017.         }
    7018. 

  7018. 

  7019. #ifdef IV
    7020. 

  7020.       /* checks all MAP elements. If they are within a Block element, */
    7021. 

  7021.       /* move them up in the structure */
    7022. 

  7022.       el = elRoot;
    7023. 

  7023.       elType.ElSSchema = htmlSSchema;
    7024. 

  7024.       elType.ElTypeNum = HTML_EL_map;
    7025. 

  7025.       /* search all MAP elements in the document */
    7026. 

  7026.       while (el)
    7027. 

  7027.         {
    7028. 

  7028.           /* search the next MAP element in the abstract tree */
    7029. 

  7029.           el = TtaSearchTypedElement (elType, SearchForward, el);
    7030. 

  7030.           if (el != NULL)
    7031. 

  7031.             /* a MAP element has been found. */
    7032. 

  7032.             {
    7033. 

  7033.               parent = TtaGetParent(el);
    7034. 

  7034. #ifdef TEMPLATES
    7035. 

  7035.               /* if its parent is a Template element, skip it */
    7036. 

  7036.               elType = TtaGetElementType (parent);
    7037. 

  7037.               while (strcmp(TtaGetSSchemaName(elType.ElSSchema),"Template") == 0)
    7038. 

  7038.                 {
    7039. 

  7039.                   parent = TtaGetParent (parent);
    7040. 

  7040.                   elType = TtaGetElementType (parent);
    7041. 

  7041.                 }
    7042. 

  7042. #endif /* TEMPLATES */
    7043. 

  7043.               if (IsBlockElement (parent))
    7044. 

  7044.                 /* its parent is a block element */
    7045. 

  7045.                 {
    7046. 

  7046.                   TtaRemoveTree (el, doc);
    7047. 

  7047.                   TtaInsertSibling (el, parent, TRUE, doc);
    7048. 

  7048.                 }
    7049. 

  7049.             }
    7050. 

  7050.         }
    7051. 

  7051. #endif /* IV */
    7052. 

  7052. 

  7053.       /* If element BODY is empty, create an empty element as a placeholder*/
    7054. 

  7054.       if (elBody)
    7055. 

  7055.         {
    7056. 

  7056.           el = TtaGetFirstChild (elBody);
    7057. 

  7057.           elType = TtaGetElementType (el);
    7058. 

  7058.           while (el && TtaHasNotElementException(TtaGetElementType (el)))
    7059. 

  7059.             TtaNextSibling (&el);
    7060. 

  7060.           if (el == NULL)
    7061. 

  7061.             {
    7062. 

  7062.               newElType.ElSSchema = htmlSSchema;
    7063. 

  7063.               newElType.ElTypeNum = HTML_EL_Element;
    7064. 

  7064.               newEl = TtaNewElement (doc, newElType);
    7065. 

  7065.               TtaInsertFirstChild (&newEl, elBody, doc);
    7066. 

  7066.             }
    7067. 

  7067.         }
    7068. 

  7068.       /* add additional checking here */
    7069. 

  7069.     }
    7070. 

  7070. }
    7071. 

  7071. 

  7072. /*----------------------------------------------------------------------
    7073. 

  7073.   InitializeHTMLParser
    7074. 

  7074.   initializes variables and stack for parsing file
    7075. 

  7075.   the parser will insert the thot tree after or as a child
    7076. 

  7076.   of last elem, in the document doc.
    7077. 

  7077.   If last elem is NULL or doc=0, the parser doesn't initialize
    7078. 

  7078.   the stack
    7079. 

  7079.   ----------------------------------------------------------------------*/
    7080. 

  7080. static void InitializeHTMLParser (Element lastelem, ThotBool isclosed,
    7081. 

  7081.                                   Document doc)
    7082. 

  7082. {
    7083. 

  7083.   char         tag[20];
    7084. 

  7084.   Element      elem;
    7085. 

  7085.   int          i;
    7086. 

  7086.   SSchema      schema;
    7087. 

  7087. 

  7088.   StackLevel = 1;
    7089. 

  7089.   HTMLcontext.language = TtaGetDefaultLanguage ();
    7090. 

  7090.   HTMLcontext.parsingTextArea = FALSE;
    7091. 

  7091.   HTMLcontext.parsingScript = FALSE;
    7092. 

  7092.   HTMLcontext.parsingCSS = FALSE;
    7093. 

  7093.   if (lastelem != NULL && doc != 0)
    7094. 

  7094.     {
    7095. 

  7095.       /* initialize the stack with ancestors of lastelem */
    7096. 

  7096.       HTMLcontext.doc = doc;
    7097. 

  7097.       DocumentSSchema = TtaGetDocumentSSchema (HTMLcontext.doc);
    7098. 

  7098. #ifdef ANNOTATIONS
    7099. 

  7099.       if (DocumentTypes[doc] == docAnnot)
    7100. 

  7100.         rootElement = ANNOT_GetHTMLRoot (doc, TRUE); 
    7101. 

  7101.       else
    7102. 

  7102. #endif /* ANNOTATIONS */
    7103. 

  7103.         rootElement = TtaGetMainRoot (HTMLcontext.doc);
    7104. 

  7104.       if (isclosed)
    7105. 

  7105.         elem = TtaGetParent (lastelem);
    7106. 

  7106.       else
    7107. 

  7107.         elem = lastelem;
    7108. 

  7108.       while (elem != NULL && elem != rootElement && StackLevel < MaxStack-2)
    7109. 

  7109.         {
    7110. 

  7110.           strcpy ((char *)tag, (char *)GetXMLElementName (TtaGetElementType (elem), doc));
    7111. 

  7111.           if (strcmp (tag, "???"))
    7112. 

  7112.             {
    7113. 

  7113.               for (i = StackLevel; i > 0; i--)
    7114. 

  7114.                 {
    7115. 

  7115.                   GINumberStack[i + 1] = GINumberStack[i];
    7116. 

  7116.                   ElementStack[i + 1] = ElementStack[i];
    7117. 

  7117.                   LanguageStack[i + 1] = LanguageStack[i];
    7118. 

  7118.                   ThotLevel[i + 1] = ThotLevel[i] + 1;
    7119. 

  7119.                 }
    7120. 

  7120.               schema = DocumentSSchema;
    7121. 

  7121.               GINumberStack[1] = MapGI ((char *)tag, &schema, HTMLcontext.doc);
    7122. 

  7122.               ElementStack[1] = elem;
    7123. 

  7123.               ThotLevel[1] = 1;
    7124. 

  7124.               LanguageStack[1] = HTMLcontext.language;
    7125. 

  7125.               StackLevel++;
    7126. 

  7126.             }
    7127. 

  7127.           elem = TtaGetParent (elem);
    7128. 

  7128.         }
    7129. 

  7129.       HTMLcontext.lastElement = lastelem;
    7130. 

  7130.       HTMLcontext.lastElementClosed = isclosed;
    7131. 

  7131.     }
    7132. 

  7132.   else
    7133. 

  7133.     {
    7134. 

  7134.       HTMLcontext.lastElement = rootElement;
    7135. 

  7135.       HTMLcontext.lastElementClosed = FALSE;
    7136. 

  7136.     }
    7137. 

  7137.   NumberOfCharRead = 0;
    7138. 

  7138.   NumberOfLinesRead = 1;
    7139. 

  7139.   /* input file is supposed to be HTML */
    7140. 

  7140.   GINumberStack[0] = -1;
    7141. 

  7141.   ElementStack[0] = rootElement;
    7142. 

  7142.   ThotLevel[0] = 1;
    7143. 

  7143.   lastElemEntry = 0;
    7144. 

  7144.   /* initialize input buffer */
    7145. 

  7145.   EmptyLine = TRUE;
    7146. 

  7146.   StartOfFile = TRUE;
    7147. 

  7147.   inputBuffer[0] = EOS;
    7148. 

  7148.   LgBuffer = 0;
    7149. 

  7149.   lastAttribute = NULL;
    7150. 

  7150.   lastAttrElement = NULL;
    7151. 

  7151.   lastAttrEntry = NULL;
    7152. 

  7152.   UnknownAttr = FALSE;
    7153. 

  7153.   ReadingAnAttrValue = FALSE;
    7154. 

  7154.   LgEntityName = 0;
    7155. 

  7155.   EntityTableEntry = 0;
    7156. 

  7156.   CharRank = 0;
    7157. 

  7157.   HTMLcontext.mergeText = FALSE;
    7158. 

  7158.   AfterTagPRE = FALSE;
    7159. 

  7159.   HTMLcontext.parsingCSS = FALSE;
    7160. 

  7160.   CurrentBufChar = 0;
    7161. 

  7161. }
    7162. 

  7162. 

  7163. /*----------------------------------------------------------------------
    7164. 

  7164.   ParseIncludedHTML
    7165. 

  7165.   ----------------------------------------------------------------------*/
    7166. 

  7166. void ParseIncludedHTML (Element elem, char *closingTag)
    7167. 

  7167. {
    7168. 

  7168.   Element    oldLastElement;
    7169. 

  7169.   ThotBool   oldLastElementClosed;
    7170. 

  7170.   int	      oldLastElemEntry;
    7171. 

  7171.    
    7172. 

  7172. 

  7173.   oldLastElement = HTMLcontext.lastElement;
    7174. 

  7174.   HTMLcontext.lastElement = elem;
    7175. 

  7175.   oldLastElementClosed = HTMLcontext.lastElementClosed;
    7176. 

  7176.   HTMLcontext.lastElementClosed = FALSE;
    7177. 

  7177.   oldLastElemEntry = lastElemEntry;
    7178. 

  7178.   lastElemEntry = 0;
    7179. 

  7179.   HTMLrootClosingTag = closingTag;
    7180. 

  7180.   /* TODO: the XML parser must call that function with two new parameters:
    7181. 

  7181.      the current infile and current index */
    7182. 

  7182.   HTMLparse ((FILE*)stream, NULL);
    7183. 

  7183. 

  7184.   HTMLcontext.lastElement = oldLastElement;
    7185. 

  7185.   HTMLcontext.lastElementClosed = oldLastElementClosed;
    7186. 

  7186.   lastElemEntry = oldLastElemEntry;
    7187. 

  7187. }
    7188. 

  7188. 

  7189. 

  7190. /*----------------------------------------------------------------------
    7191. 

  7191.   ParseSubTree called by tranformation.
    7192. 

  7192.   ----------------------------------------------------------------------*/
    7193. 

  7193. void ParseSubTree (char* HTMLbuf, Element lastelem, Language language,
    7194. 

  7194.                    ThotBool isclosed, Document doc)
    7195. 

  7195. {
    7196. 

  7196.   ElementType  elType;
    7197. 

  7197.   char        *schemaName;
    7198. 

  7198. 

  7199.   docURL = NULL;
    7200. 

  7200.   docURL2 = NULL;
    7201. 

  7201.   elType = TtaGetElementType (lastelem);
    7202. 

  7202.   schemaName = TtaGetSSchemaName(elType.ElSSchema);
    7203. 

  7203.   if (strcmp (schemaName, "HTML") == 0)
    7204. 

  7204.     /* parse an HTML subtree */
    7205. 

  7205.     {
    7206. 

  7206.       InitializeHTMLParser (lastelem, isclosed, doc);
    7207. 

  7207.       /* Initialize the language context with the 'lastelem' language*/
    7208. 

  7208.       HTMLcontext.language = language;
    7209. 

  7209.       /* transformation files are alway encoded in UTF_8 */
    7210. 

  7210.       HTMLcontext.encoding = UTF_8;
    7211. 

  7211.       /* We set number line with 0 when we are parsing a sub-tree */
    7212. 

  7212.       NumberOfLinesRead = 0;
    7213. 

  7213.       HTMLparse (NULL, HTMLbuf);
    7214. 

  7214.       /* Handle character-level elements which contain block-level elements */
    7215. 

  7215.       TtaSetStructureChecking (FALSE, doc);
    7216. 

  7216.       CheckBlocksInCharElem (doc);
    7217. 

  7217.       TtaSetStructureChecking (TRUE, doc);
    7218. 

  7218.     }
    7219. 

  7219.   else
    7220. 

  7220.     {
    7221. 

  7221.       InputText = HTMLbuf; 
    7222. 

  7222.       /* InputText = HTMLbuf; */
    7223. 

  7223.       CurrentBufChar = 0;
    7224. 

  7224.       if (!ParseXmlBuffer (InputText, lastelem, isclosed, doc, language, NULL))
    7225. 

  7225.         StopParsing (doc);
    7226. 

  7226.     }
    7227. 

  7227. }
    7228. 

  7228. 

  7229. /*-------------------------------------------------------------------------------
    7230. 

  7230.   ParseExternalHTMLDoc
    7231. 

  7231.   Parse an external HTML document called from an other document
    7232. 

  7232.   ------------------------------------------------------------------------------*/
    7233. 

  7233. void ParseExternalHTMLDoc (Document doc, FILE * infile, CHARSET charset, char *extDocURL)
    7234. 

  7234. {
    7235. 

  7235.   Element         el, oldel;
    7236. 

  7236.   int             error;
    7237. 

  7237. 

  7238.   /* Context initialization */
    7239. 

  7239.   HTMLcontext.doc = doc;
    7240. 

  7240.   FirstElemToBeChecked = NULL;
    7241. 

  7241.   LastElemToBeChecked = NULL;
    7242. 

  7242.   HTMLcontext.lastElement = NULL;
    7243. 

  7243.   HTMLcontext.lastElementClosed = FALSE;
    7244. 

  7244.   lastElemEntry = 0;
    7245. 

  7245.   lastAttribute = NULL;
    7246. 

  7246.   lastAttrElement = NULL;
    7247. 

  7247.   lastAttrEntry = NULL;
    7248. 

  7248.   UnknownAttr = FALSE;
    7249. 

  7249.   ReadingAnAttrValue = FALSE;
    7250. 

  7250.   CommentText = NULL;
    7251. 

  7251.   UnknownTag = FALSE;
    7252. 

  7252.   HTMLcontext.mergeText = FALSE;
    7253. 

  7253.   LgEntityName = 0;
    7254. 

  7254.   EntityTableEntry = 0;
    7255. 

  7255.   CharRank = 0;
    7256. 

  7256.   HTMLcontext.encoding = TtaGetDocumentCharset (doc);
    7257. 

  7257.   HTMLcontext.withinTable = 0;
    7258. 

  7258.   LastCharInWorkBuffer = 0;
    7259. 

  7259.   FileBuffer[0] = EOS;
    7260. 

  7260.   HTMLcontext.language = TtaGetDefaultLanguage ();
    7261. 

  7261.   DocumentSSchema = TtaGetDocumentSSchema (doc);
    7262. 

  7262. 

  7263.   rootElement = TtaGetMainRoot (doc);
    7264. 

  7264.   /* delete all element except the root element and its parent document
    7265. 

  7265.      element */
    7266. 

  7266.   el = TtaGetFirstChild (rootElement);
    7267. 

  7267.   while (el != NULL)
    7268. 

  7268.     {
    7269. 

  7269.       oldel = el;
    7270. 

  7270.       TtaNextSibling (&el);
    7271. 

  7271.       TtaDeleteTree (oldel, doc);
    7272. 

  7272.     }
    7273. 

  7273. 

  7274.   docURL = (char*)TtaGetMemory (strlen ((char *)extDocURL) + 1);
    7275. 

  7275.   strcpy ((char *)docURL, (char *)extDocURL);
    7276. 

  7276. 

  7277.   /* Check if it's a valid encoding */
    7278. 

  7278.   if (DocumentMeta[doc]->charset)
    7279. 

  7279.     {
    7280. 

  7280.       charset = TtaGetCharset (DocumentMeta[doc]->charset);
    7281. 

  7281.       if (charset != UTF_8        && charset != ISO_8859_1   &&
    7282. 

  7282.           charset != ISO_8859_2   && charset != ISO_8859_3   &&
    7283. 

  7283.           charset != ISO_8859_4   && charset != ISO_8859_5   &&
    7284. 

  7284.           charset != ISO_8859_6   && charset != ISO_8859_7   &&
    7285. 

  7285.           charset != ISO_8859_8   && charset != ISO_8859_9   &&
    7286. 

  7286.           charset != ISO_8859_15  && charset != KOI8_R       &&
    7287. 

  7287.           charset != WINDOWS_1250 && charset != WINDOWS_1251 &&
    7288. 

  7288.           charset != WINDOWS_1252 && charset != WINDOWS_1253 &&
    7289. 

  7289.           charset != WINDOWS_1254 && charset != WINDOWS_1255 &&
    7290. 

  7290.           charset != WINDOWS_1256 && charset != WINDOWS_1257 &&
    7291. 

  7291.           charset != US_ASCII     && charset != SHIFT_JIS    &&
    7292. 

  7292.           charset != ISO_2022_JP  && charset != EUC_JP       &&
    7293. 

  7293.           charset != SHIFT_JIS    && charset != GB_2312)
    7294. 

  7294.         HTMLParseError (doc,
    7295. 

  7295.                         TtaGetMessage (AMAYA, AM_UNKNOWN_ENCODING), 0);
    7296. 

  7296.     }
    7297. 

  7297.   
    7298. 

  7298.   /* parse the input file and build the external document */
    7299. 

  7299.   /* initialize parsing environment */
    7300. 

  7300.   InitializeHTMLParser (NULL, FALSE, 0);
    7301. 

  7301.   HTMLparse (infile, NULL);
    7302. 

  7302.   /* completes all unclosed elements */
    7303. 

  7303.   el = HTMLcontext.lastElement;
    7304. 

  7304.   while (el != NULL)
    7305. 

  7305.     {
    7306. 

  7306.       XhtmlElementComplete (&HTMLcontext, el, &error);
    7307. 

  7307.       el = TtaGetParent (el);
    7308. 

  7308.     }
    7309. 

  7309.  
    7310. 

  7310.   if (docURL)
    7311. 

  7311.     {
    7312. 

  7312.       TtaFreeMemory (docURL);
    7313. 

  7313.       docURL = NULL;
    7314. 

  7314.     }
    7315. 

  7315.   DocumentSSchema = NULL;
    7316. 

  7316.   HTMLcontext.doc = 0;
    7317. 

  7317.   CleanUpParsingErrors ();
    7318. 

  7318.   return;
    7319. 

  7319. }
    7320. 

  7320. 

  7321. /*-------------------------------------------------------------------------------
    7322. 

  7322.   ClearHTMLParser 
    7323. 

  7323.   Clear all parser variables
    7324. 

  7324.   ------------------------------------------------------------------------------*/
    7325. 

  7325. void ClearHTMLParser ()
    7326. 

  7326. {
    7327. 

  7327.   PtrElemToBeChecked  elTBC;
    7328. 

  7328. 

  7329.   /* clean up the list of ElemToBeChecked */
    7330. 

  7330.   elTBC = FirstElemToBeChecked;
    7331. 

  7331.   while (FirstElemToBeChecked)
    7332. 

  7332.     {
    7333. 

  7333.       LastElemToBeChecked = FirstElemToBeChecked->nextElemToBeChecked;
    7334. 

  7334.       TtaFreeMemory (FirstElemToBeChecked);
    7335. 

  7335.       FirstElemToBeChecked = LastElemToBeChecked;
    7336. 

  7336.     }
    7337. 

  7337.   FirstElemToBeChecked = NULL;
    7338. 

  7338.   LastElemToBeChecked = NULL;
    7339. 

  7339.   lastElemEntry = 0;
    7340. 

  7340.   lastAttribute = NULL;
    7341. 

  7341.   lastAttrElement = NULL;
    7342. 

  7342.   lastAttrEntry = NULL;
    7343. 

  7343.   UnknownAttr = FALSE;
    7344. 

  7344.   ReadingAnAttrValue = FALSE;
    7345. 

  7345.   CommentText = NULL;
    7346. 

  7346.   UnknownTag = FALSE;
    7347. 

  7347.   LastCharInWorkBuffer = 0;
    7348. 

  7348.   FileBuffer[0] = EOS;
    7349. 

  7349.   LgEntityName = 0;
    7350. 

  7350.   EntityTableEntry = 0;
    7351. 

  7351.   CharRank = 0;
    7352. 

  7352. }
    7353. 

  7353. 

  7354. /*-------------------------------------------------------------------------------
    7355. 

  7355.   StartParser 
    7356. 

  7356.   Loads the file Directory/htmlFileName for displaying the document documentName.
    7357. 

  7357.   The parameter pathURL gives the original (local or distant)
    7358. 

  7358.   path or URL of the html document.
    7359. 

  7359.   ------------------------------------------------------------------------------*/
    7360. 

  7360. void StartParser (Document doc, char *fileName,
    7361. 

  7361.                   const char *documentName, char* documentDirectory,
    7362. 

  7362.                   const char *pathURL, ThotBool plainText, ThotBool external_doc)
    7363. 

  7363. {
    7364. 

  7364.   DisplayMode     dispMode;
    7365. 

  7365.   CHARSET         charset;
    7366. 

  7366.   Element         el, oldel, root;
    7367. 

  7367.   AttributeType   attrType;
    7368. 

  7368.   Attribute       attr;
    7369. 

  7369.   char           *s;
    7370. 

  7370.   char            tempname[MAX_LENGTH];
    7371. 

  7371.   char            temppath[MAX_LENGTH];
    7372. 

  7372.   ThotBool        isHTML;
    7373. 

  7373.   int             error;
    7374. 

  7374. 

  7375.   HTMLcontext.doc = doc;
    7376. 

  7376.   FirstElemToBeChecked = NULL;
    7377. 

  7377.   LastElemToBeChecked = NULL;
    7378. 

  7378.   HTMLcontext.lastElement = NULL;
    7379. 

  7379.   HTMLcontext.lastElementClosed = FALSE;
    7380. 

  7380.   lastElemEntry = 0;
    7381. 

  7381.   lastAttribute = NULL;
    7382. 

  7382.   lastAttrElement = NULL;
    7383. 

  7383.   lastAttrEntry = NULL;
    7384. 

  7384.   UnknownAttr = FALSE;
    7385. 

  7385.   ReadingAnAttrValue = FALSE;
    7386. 

  7386.   CommentText = NULL;
    7387. 

  7387.   UnknownTag = FALSE;
    7388. 

  7388.   HTMLcontext.mergeText = FALSE;
    7389. 

  7389.   HTMLcontext.withinTable = 0;
    7390. 

  7390.   LastCharInWorkBuffer = 0;
    7391. 

  7391.   FileBuffer[0] = EOS;
    7392. 

  7392.   LgEntityName = 0;
    7393. 

  7393.   EntityTableEntry = 0;
    7394. 

  7394.   CharRank = 0;
    7395. 

  7395. 

  7396.   HTMLcontext.encoding = TtaGetDocumentCharset (doc);
    7397. 

  7397.   stream = TtaGZOpen (fileName);
    7398. 

  7398.   if (stream != 0)
    7399. 

  7399.     {
    7400. 

  7400.       if (documentName[0] == EOS && !TtaCheckDirectory (documentDirectory))
    7401. 

  7401.         {
    7402. 

  7402.           strcpy ((char *)documentName, (char *)documentDirectory);
    7403. 

  7403.           documentDirectory[0] = EOS;
    7404. 

  7404.           s = TtaGetEnvString ("PWD");
    7405. 

  7405.           /* set path on current directory */
    7406. 

  7406.           if (s != NULL)
    7407. 

  7407.             strcpy ((char *)documentDirectory, (char *)s);
    7408. 

  7408.           else
    7409. 

  7409.             documentDirectory[0] = EOS;
    7410. 

  7410.         }
    7411. 

  7411.       TtaAppendDocumentPath (documentDirectory);
    7412. 

  7412. 

  7413.       /* Set document URL */
    7414. 

  7414.       if (DocumentURLs[doc])
    7415. 

  7415.         {
    7416. 

  7416.           docURL = (char*)TtaGetMemory (strlen ((char *)DocumentURLs[doc]) + 1);
    7417. 

  7417.           strcpy ((char *)docURL, (char *)DocumentURLs[doc]);
    7418. 

  7418.         }
    7419. 

  7419.       else
    7420. 

  7420.         {
    7421. 

  7421.           docURL = (char*)TtaGetMemory (strlen ((char *)pathURL) + 1);
    7422. 

  7422.           strcpy ((char *)docURL, (char *)pathURL);
    7423. 

  7423.         }
    7424. 

  7424.       /* Set document URL2 */
    7425. 

  7425.       if (docURL)
    7426. 

  7426.         {
    7427. 

  7427.           docURL2 = (char *)TtaGetMemory (strlen ((char *)docURL) + 1);
    7428. 

  7428.           strcpy ((char *)docURL2, (char *)docURL);
    7429. 

  7429.         }
    7430. 

  7430. 

  7431. 

  7432.       /* do not check the Thot abstract tree against the structure */
    7433. 

  7433.       /* schema while building the Thot document. */
    7434. 

  7434.       TtaSetStructureChecking (FALSE, doc);
    7435. 

  7435.       /* set the notification mode for the new document */
    7436. 

  7436.       TtaSetNotificationMode (doc, 1);
    7437. 

  7437.       HTMLcontext.language = TtaGetDefaultLanguage ();
    7438. 

  7438. #ifdef ANNOTATIONS
    7439. 

  7439.       if (DocumentTypes[doc] == docAnnot)
    7440. 

  7440.         {
    7441. 

  7441.           /* get the schema associated to the annotation body */
    7442. 

  7442.           DocumentSSchema = ANNOT_GetBodySSchema (doc);
    7443. 

  7443.           attrType.AttrSSchema = DocumentSSchema;
    7444. 

  7444.         }
    7445. 

  7445.       else
    7446. 

  7446. #endif /* ANNOTATIONS */
    7447. 

  7447.         DocumentSSchema = TtaGetDocumentSSchema (doc);
    7448. 

  7448. 

  7449.       /* is the current document a HTML document */
    7450. 

  7450.       isHTML = (strcmp (TtaGetSSchemaName (DocumentSSchema), "HTML") == 0);
    7451. 

  7451.       if (plainText)
    7452. 

  7452.         {
    7453. 

  7453. #ifdef ANNOTATIONS
    7454. 

  7454.           if (DocumentTypes[doc] == docAnnot)
    7455. 

  7455.             rootElement = ANNOT_GetHTMLRoot (doc, TRUE); 
    7456. 

  7456.           else
    7457. 

  7457. #endif /* ANNOTATIONS */
    7458. 

  7458.             rootElement = TtaGetRootElement (doc);
    7459. 

  7459. 

  7460.           if (DocumentTypes[doc] == docSource || DocumentTypes[doc] == docCSS)
    7461. 

  7461.             {
    7462. 

  7462.               /* add the attribute Source */
    7463. 

  7463.               attrType.AttrSSchema = DocumentSSchema;
    7464. 

  7464.               attrType.AttrTypeNum = TextFile_ATTR_Source;
    7465. 

  7465.               attr = TtaGetAttribute (rootElement, attrType);
    7466. 

  7466.               if (attr == 0)
    7467. 

  7467.                 {
    7468. 

  7468.                   attr = TtaNewAttribute (attrType);
    7469. 

  7469.                   TtaAttachAttribute (rootElement, attr, doc);
    7470. 

  7470.                 }
    7471. 

  7471.             }
    7472. 

  7472. 	  
    7473. 

  7473.           /* add the default attribute PrintURL */
    7474. 

  7474.           attrType.AttrSSchema = DocumentSSchema;
    7475. 

  7475.           attrType.AttrTypeNum = TextFile_ATTR_PrintURL;
    7476. 

  7476.           attr = TtaGetAttribute (rootElement, attrType);
    7477. 

  7477.           if (attr == 0)
    7478. 

  7478.             {
    7479. 

  7479.               attr = TtaNewAttribute (attrType);
    7480. 

  7480.               TtaAttachAttribute (rootElement, attr, doc);
    7481. 

  7481.             }
    7482. 

  7482.         }
    7483. 

  7483.       else
    7484. 

  7484.         {
    7485. 

  7485.           /* Check if it's a valid encoding */
    7486. 

  7486.           if (DocumentMeta[doc]->charset)
    7487. 

  7487.             {
    7488. 

  7488.               charset = TtaGetCharset (DocumentMeta[doc]->charset);
    7489. 

  7489.               if (charset != UTF_8        && charset != ISO_8859_1   &&
    7490. 

  7490.                   charset != ISO_8859_2   && charset != ISO_8859_3   &&
    7491. 

  7491.                   charset != ISO_8859_4   && charset != ISO_8859_5   &&
    7492. 

  7492.                   charset != ISO_8859_6   && charset != ISO_8859_7   &&
    7493. 

  7493.                   charset != ISO_8859_8   && charset != ISO_8859_9   &&
    7494. 

  7494.                   charset != ISO_8859_15  && charset != KOI8_R       &&
    7495. 

  7495.                   charset != WINDOWS_1250 && charset != WINDOWS_1251 &&
    7496. 

  7496.                   charset != WINDOWS_1252 && charset != WINDOWS_1253 &&
    7497. 

  7497.                   charset != WINDOWS_1254 && charset != WINDOWS_1255 &&
    7498. 

  7498.                   charset != WINDOWS_1256 && charset != WINDOWS_1257 &&
    7499. 

  7499.                   charset != US_ASCII     && charset != SHIFT_JIS    &&
    7500. 

  7500.                   charset != ISO_2022_JP  && charset != EUC_JP       &&
    7501. 

  7501.                   charset != SHIFT_JIS    && charset != GB_2312)
    7502. 

  7502.                 HTMLParseError (doc,
    7503. 

  7503.                                 TtaGetMessage (AMAYA, AM_UNKNOWN_ENCODING), 0);
    7504. 

  7504.             }
    7505. 

  7505.           if (!isHTML)
    7506. 

  7506.             {
    7507. 

  7507.               /* change the document type */
    7508. 

  7508.               TtaFreeView (doc, 1);
    7509. 

  7509.               doc = TtaNewDocument ("HTML", documentName);
    7510. 

  7510.               if (TtaGetScreenDepth () > 1)
    7511. 

  7511.                 TtaSetPSchema (doc, "HTMLP");
    7512. 

  7512.               else
    7513. 

  7513.                 TtaSetPSchema (doc, "HTMLPBW");
    7514. 

  7514.               DocumentSSchema = TtaGetDocumentSSchema (doc);
    7515. 

  7515.               /* set attribute dir on the Document element. */
    7516. 

  7516.               root = TtaGetMainRoot (doc);
    7517. 

  7517.               if (root)
    7518. 

  7518.                 {
    7519. 

  7519.                   attrType.AttrSSchema = DocumentSSchema;
    7520. 

  7520.                   attrType.AttrTypeNum = HTML_ATTR_dir;
    7521. 

  7521.                   attr = TtaNewAttribute (attrType);
    7522. 

  7522.                   TtaAttachAttribute (root, attr, doc);
    7523. 

  7523.                   TtaSetAttributeValue (attr, HTML_ATTR_dir_VAL_ltr_, root,
    7524. 

  7524.                                         doc);
    7525. 

  7525.                 }
    7526. 

  7526.               isHTML = TRUE;
    7527. 

  7527.             }
    7528. 

  7528. 

  7529. #ifdef ANNOTATIONS
    7530. 

  7530.           if (DocumentTypes[doc] == docAnnot)
    7531. 

  7531.             rootElement = ANNOT_GetHTMLRoot (doc, FALSE); 
    7532. 

  7532.           else
    7533. 

  7533. #endif /* ANNOTATIONS */
    7534. 

  7534.             rootElement = TtaGetMainRoot (doc);
    7535. 

  7535.           /* add the default attribute PrintURL */
    7536. 

  7536.           attrType.AttrSSchema = DocumentSSchema;
    7537. 

  7537.           attrType.AttrTypeNum = HTML_ATTR_PrintURL;
    7538. 

  7538.           attr = TtaGetAttribute (rootElement, attrType);
    7539. 

  7539.           if (!attr)
    7540. 

  7540.             {
    7541. 

  7541.               attr = TtaNewAttribute (attrType);
    7542. 

  7542.               TtaAttachAttribute (rootElement, attr, doc);
    7543. 

  7543.             }
    7544. 

  7544.           if (MapAreas[doc])
    7545. 

  7545.             ChangeAttrOnRoot (doc, HTML_ATTR_ShowAreas);
    7546. 

  7546.         }
    7547. 

  7547. 

  7548.       dispMode = TtaGetDisplayMode (doc);
    7549. 

  7549.       if (dispMode != NoComputedDisplay)
    7550. 

  7550.         TtaSetDisplayMode (doc, NoComputedDisplay);
    7551. 

  7551.       /* delete all element except the root element and its parent document
    7552. 

  7552.          element */
    7553. 

  7553.       el = TtaGetFirstChild (rootElement);
    7554. 

  7554.       while (el != NULL)
    7555. 

  7555.         {
    7556. 

  7556.           oldel = el;
    7557. 

  7557.           TtaNextSibling (&el);
    7558. 

  7558.           TtaDeleteTree (oldel, doc);
    7559. 

  7559.         }
    7560. 

  7560. 

  7561.       /* save the path or URL of the document */
    7562. 

  7562.       TtaExtractName (pathURL, temppath, tempname);
    7563. 

  7563.       TtaSetDocumentDirectory (doc, temppath);
    7564. 

  7564.       // change the type of the root element if needed
    7565. 

  7565.       if (isHTML)
    7566. 

  7566.         TtaUpdateRootElementType (rootElement, "HTML", doc);
    7567. 

  7567. 

  7568.       /* parse the input file and build the Thot document */
    7569. 

  7569.       if (plainText)
    7570. 

  7570.         ReadTextFile ((FILE*)stream, NULL, doc, pathURL);
    7571. 

  7571.       else
    7572. 

  7572.         {
    7573. 

  7573.           /* initialize parsing environment */
    7574. 

  7574.           InitializeHTMLParser (NULL, FALSE, 0);
    7575. 

  7575.           HTMLparse ((FILE*)stream, NULL);
    7576. 

  7576.           /* completes all unclosed elements */
    7577. 

  7577.           el = HTMLcontext.lastElement;
    7578. 

  7578.           while (el != NULL)
    7579. 

  7579.             {
    7580. 

  7580.               XhtmlElementComplete (&HTMLcontext, el, &error);
    7581. 

  7581.               el = TtaGetParent (el);
    7582. 

  7582.             }
    7583. 

  7583.           /* check the Thot abstract tree */
    7584. 

  7584.           CheckAbstractTree (HTMLcontext.doc, IsXTiger (documentName));
    7585. 

  7585.           // now load the user style sheet
    7586. 

  7586.           if (!external_doc)
    7587. 

  7587.             {
    7588. 

  7588.               LoadUserStyleSheet (doc);
    7589. 

  7589.               UpdateStyleList (doc, 1);
    7590. 

  7590.             }
    7591. 

  7591.         }
    7592. 

  7592. 

  7593.       TtaGZClose (stream);
    7594. 

  7594.       if (docURL)
    7595. 

  7595.         {
    7596. 

  7596.           TtaFreeMemory (docURL);
    7597. 

  7597.           docURL = NULL;
    7598. 

  7598.         }
    7599. 

  7599.       if (docURL2)
    7600. 

  7600.         {
    7601. 

  7601.           TtaFreeMemory (docURL2);
    7602. 

  7602.           docURL2 = NULL;
    7603. 

  7603.         }
    7604. 

  7604. 

  7605.       if (!external_doc)
    7606. 

  7606.         TtaSetDisplayMode (doc, dispMode);
    7607. 

  7607. 

  7608.       /* check the Thot abstract tree against the structure schema. */
    7609. 

  7609.       TtaSetStructureChecking (TRUE, doc);
    7610. 

  7610. 

  7611.       DocumentSSchema = NULL;
    7612. 

  7612.     }
    7613. 

  7613. 

  7614.   TtaSetDocumentUnmodified (doc);
    7615. 

  7615.   HTMLcontext.doc = 0;
    7616. 

  7616. }
    7617. 

  7617. 

  7618. /* end of module */
    7619. 

  7619.