PageRenderTime 54ms CodeModel.GetById 19ms RepoModel.GetById 0ms app.codeStats 0ms

/TeXmacs-1.0.7.11-src/src/Data/Convert/Tex/parsetex.cpp

#
C++ | 960 lines | 827 code | 53 blank | 80 comment | 522 complexity | 2783e653b68ced7c8129955ddad7da52 MD5 | raw file
Possible License(s): GPL-3.0, GPL-2.0, MPL-2.0-no-copyleft-exception 
    

  1. 

  2. /******************************************************************************
    3. 

  3. * MODULE     : parsetex.cpp
    4. 

  4. * DESCRIPTION: conversion of tex/latex strings into logical tex/latex trees
    5. 

  5. * COPYRIGHT  : (C) 1999  Joris van der Hoeven
    6. 

  6. *******************************************************************************
    7. 

  7. * This software falls under the GNU general public license version 3 or later.
    8. 

  8. * It comes WITHOUT ANY WARRANTY WHATSOEVER. For details, see the file LICENSE
    9. 

  9. * in the root directory or <http://www.gnu.org/licenses/gpl-3.0.html>.
    10. 

  10. ******************************************************************************/
    11. 

  11. 

  12. #include "Tex/convert_tex.hpp"
    13. 

  13. #include "converter.hpp"
    14. 

  14. 

  15. string string_arg (tree t);
    16. 

  16. 

  17. /******************************************************************************
    18. 

  18. * The latex_parser structure
    19. 

  19. *******************************************************************************
    20. 

  20. *
    21. 

  21. * During the parsing, the following global variables are used:
    22. 

  22. *
    23. 

  23. *     command_type   Contains the types of all currently defined tex commands.
    24. 

  24. *                    This is either 'command' 'modifier' 'operator'
    25. 

  25. *                    'environment' 'list' 'symbol' 'big-symbol' or 'user'.
    26. 

  26. *     command_arity  Contains the corresponding arity.
    27. 

  27. *     command_def    Contains the definitions of user commands.
    28. 

  28. *
    29. 

  29. * The command_type hashmap also contains come special fields
    30. 

  30. *
    31. 

  31. *     \<sub>         Stands for the subscript command
    32. 

  32. *     \<sup>         Stands for the supscript command
    33. 

  33. *
    34. 

  34. *     !mode          Gives the current mode ("text" or "math").
    35. 

  35. *     !verbatim      Verbatim mode ("true" or "false")
    36. 

  36. *     !em            Emphasized mode ("true" or "false")
    37. 

  37. *
    38. 

  38. *******************************************************************************
    39. 

  39. * WARNING: we recently put the standard LaTeX macros in latex_type and
    40. 

  40. * latex_arity instead of command_type and command_arity.
    41. 

  41. ******************************************************************************/
    42. 

  42. 

  43. struct latex_parser {
    44. 

  44.   bool unicode;
    45. 

  45.   latex_parser (bool unicode2): unicode (unicode2) {}
    46. 

  46.   void latex_error (string s, int i, string message);
    47. 

  47. 

  48.   tree parse           (string s, int& i, string stop= "", bool change= false);
    49. 

  49.   tree parse_backslash (string s, int& i);
    50. 

  50.   tree parse_symbol    (string s, int& i);
    51. 

  51.   tree parse_command   (string s, int& i, string which);
    52. 

  52.   tree parse_unknown   (string s, int& i, string which);
    53. 

  53.   tree parse_verbatim  (string s, int& i, string end);
    54. 

  54. 

  55.   tree parse           (string s, bool change);
    56. 

  56. };
    57. 

  57. 

  58. /******************************************************************************
    59. 

  59. * Error handling
    60. 

  60. ******************************************************************************/
    61. 

  61. 

  62. void
    63. 

  63. latex_parser::latex_error (string s, int i, string message) {
    64. 

  64.   cerr << "Latex error] " << message << "\n";
    65. 

  65.   if (i>30) s= "..." * s (i-27, N(s));
    66. 

  66.   if (N(s)>60) s= s (0, 57) * "...";
    67. 

  67.   cerr << "Latex error] in " << s << "\n";
    68. 

  68. }
    69. 

  69. 

  70. /******************************************************************************
    71. 

  71. * Main parsing routine
    72. 

  72. ******************************************************************************/
    73. 

  73. 

  74. static bool
    75. 

  75. is_regular (tree t) {
    76. 

  76.   if (!is_tuple (t)) return true;
    77. 

  77.   if (N(t) == 0 || !is_atomic (t[0])) return false;
    78. 

  78.   string s= t[0]->label;
    79. 

  79.   return !starts (s, "\\begin-") && !starts (s, "\\end-");
    80. 

  80. }
    81. 

  81. 

  82. tree
    83. 

  83. latex_parser::parse (string s, int& i, string stop, bool change) {
    84. 

  84.   bool no_error= true;
    85. 

  85.   int n= N(s);
    86. 

  86.   tree t (CONCAT);
    87. 

  87. 

  88.   command_type ->extend ();
    89. 

  89.   command_arity->extend ();
    90. 

  90.   command_def  ->extend ();
    91. 

  91. 

  92.   while ((i<n) && is_space (s[i])) i++;
    93. 

  93.   while ((i<n) && no_error &&
    94. 

  94. 	 (s[i] != '\0' || N (stop) != 0) &&
    95. 

  95. 	 (N(stop) != 1 || s[i] != stop[0]) &&
    96. 

  96. 	 (s[i] != '$' || stop != "$$" || i+1>=n || s[i+1] != '$') &&
    97. 

  97. 	 (stop != "denom" ||
    98. 

  98. 	  (s[i] != '$' && s[i] != '}' &&
    99. 

  99. 	   (i+2>n || s(i,i+2) != "\\]") &&
    100. 

  100. 	   (i+4>n || s(i,i+4) != "\\end")))) {
    101. 

  101.     switch (s[i]) {
    102. 

  102.     case '~':
    103. 

  103.       if (command_type ["!mode"] == "math") t << tuple ("\\sim");
    104. 

  104.       else t << tuple ("\\nbsp");
    105. 

  105.       i++;
    106. 

  106.       break;
    107. 

  107.     case ' ':
    108. 

  108.     case '\t':
    109. 

  109.     case '\r':
    110. 

  110.       while ((i<n) && ((s[i]==' ') || (s[i]=='\t') || (s[i]=='\r'))) i++;
    111. 

  111.       if ((i<n) && (s[i]!='\n')) t << " ";
    112. 

  112.       break;
    113. 

  113.     case '\n': {
    114. 

  114.       int ln=0;
    115. 

  115.       while ((i<n) && is_space (s[i]))
    116. 

  116. 	if (s[i++]=='\n') ln++;
    117. 

  117.       if (i<n) {
    118. 

  118. 	if (ln == 1) t << " ";
    119. 

  119. 	else t << "\n";
    120. 

  120.       }
    121. 

  121.       break;
    122. 

  122.     }
    123. 

  123.     case '%': {
    124. 

  124.       while ((i<n) && (s[i]!='\n')) i++;
    125. 

  125.       if (i<n) i++;
    126. 

  126.       int ln=0;
    127. 

  127.       while ((i<n) && is_space (s[i]))
    128. 

  128. 	if (s[i++]=='\n') ln++;
    129. 

  129.       if (ln > 0) {
    130. 

  130. 	if ((N(t)>0) && ((t[N(t)-1]==" ") || (t[N(t)-1]=="\n")))
    131. 

  131. 	  t[N(t)-1]= "\n";
    132. 

  132. 	else t << "\n";
    133. 

  133.       }
    134. 

  134.       break;
    135. 

  135.     }
    136. 

  136.     case '#':
    137. 

  137.       i++;
    138. 

  138.       if (i==n) return t;
    139. 

  139.       if (is_numeric (s[i])) {
    140. 

  140. 	t << s (i-1, i+1);
    141. 

  141. 	i++;
    142. 

  142.       }
    143. 

  143.       else t << s (i-1, i);
    144. 

  144.       break;
    145. 

  145.     case '\\':
    146. 

  146.       if (((i+7)<n) && !is_alpha (s (i+5, i+7)) &&
    147. 

  147. 	  (s (i, i+5) == "\\over" || s (i, i+5) == "\\atop"))
    148. 

  148. 	{
    149. 

  149. 	  string fr_cmd= s(i,i+5);
    150. 

  150. 	  if (fr_cmd == "\\over") fr_cmd= "\\frac";
    151. 

  151. 	  if (fr_cmd == "\\atop") fr_cmd= "\\ontop";
    152. 

  152. 	  int j;
    153. 

  153. 	  for (j=N(t); j>0 && is_regular (t[j-1]); j--) {}
    154. 

  154. 	  tree num= t (j, N(t));
    155. 

  155. 	  if (N(num) == 0) num= "";
    156. 

  156. 	  t= t (0, j);
    157. 

  157. 	  i+=5;
    158. 

  158. 	  while (i<n && (s[i] == ' ' || s[i] == '\n' || s[i] == '\t')) i++;
    159. 

  159. 	  tree den= parse (s, i, "denom");
    160. 

  160. 	  t << tree (TUPLE, fr_cmd, num, den);
    161. 

  161. 	}
    162. 

  162.       else if (((i+5)<n) && (s(i,i+3)=="\\sp") && (!is_alpha(s[i+3]))) {
    163. 

  163. 	i+=3;
    164. 

  164. 	t << parse_command (s, i, "\\<sup>");
    165. 

  165.       }
    166. 

  166.       else if (((i+5)<n) && (s(i,i+3)=="\\sb") && (!is_alpha(s[i+3]))) {
    167. 

  167. 	i+=3;
    168. 

  168. 	t << parse_command (s, i, "\\<sub>");
    169. 

  169.       }
    170. 

  170.       else if (((i+10)<n) && (s(i,i+8)=="\\pmatrix")) {
    171. 

  171. 	i+=8;
    172. 

  172. 	tree arg= parse_command (s, i, "\\pmatrix");
    173. 

  173. 	if (is_tuple (arg, "\\pmatrix", 1)) arg= arg[1];
    174. 

  174. 	t << tree (TUPLE, "\\begin-pmatrix");
    175. 

  175. 	if (is_concat (arg)) t << A (arg);
    176. 

  176. 	else t << arg;
    177. 

  177. 	t << tree (TUPLE, "\\end-pmatrix");
    178. 

  178.       }
    179. 

  179.       else  {
    180. 

  180. 	tree u= parse_backslash (s, i);
    181. 

  181. 	if (u != "") t << u;
    182. 

  182.       }
    183. 

  183.       break;
    184. 

  184.     case '\'':
    185. 

  185.       i++;
    186. 

  186.       if (command_type ["!mode"] == "math") {
    187. 

  187. 	int start= i-1;
    188. 

  188. 	while ((i < N(s)) && (s[i] == '\'')) i++;
    189. 

  189. 	t << tuple ("\\prime", s (start, i));
    190. 

  190.       }
    191. 

  191.       else t << s (i-1, i);
    192. 

  192.       break;
    193. 

  193.     case '*':
    194. 

  194.       if (command_type ["!mode"] == "math") t << tree (TUPLE, "\\ast");
    195. 

  195.       else t << "*";
    196. 

  196.       i++;
    197. 

  197.       break;
    198. 

  198.     case '_':
    199. 

  199.       i++;
    200. 

  200.       t << parse_command (s, i, "\\<sub>");
    201. 

  201.       /*
    202. 

  202.       if (command_type ["!mode"] == "math")
    203. 

  203. 	t << parse_command (s, i, "\\<sub>");
    204. 

  204.       else t << s (i-1, i);
    205. 

  205.       */
    206. 

  206.       break;
    207. 

  207.     case '^':
    208. 

  208.       i++;
    209. 

  209.       t << parse_command (s, i, "\\<sup>");
    210. 

  210.       /*
    211. 

  211.       if (command_type ["!mode"] == "math")
    212. 

  212. 	t << parse_command (s, i, "\\<sup>");
    213. 

  213.       else t << s (i-1, i);
    214. 

  214.       */
    215. 

  215.       break;
    216. 

  216.     case '<':
    217. 

  217.       t << tree (TUPLE, "\\<less>");
    218. 

  218.       i++;
    219. 

  219.       break;
    220. 

  220.     case '>':
    221. 

  221.       t << tree (TUPLE, "\\<gtr>");
    222. 

  222.       i++;
    223. 

  223.       break;
    224. 

  224.     case '\244':
    225. 

  225.       i++;
    226. 

  226.       t << parse_verbatim (s, i, "\244");
    227. 

  227.       break;
    228. 

  228.     case '{': {
    229. 

  229.       i++;
    230. 

  230.       t << parse (s, i, "}");
    231. 

  231.       if ((i<n) && (s[i]=='}')) i++;
    232. 

  232. 

  233.       int ln=0;
    234. 

  234.       if ((i<n) && (!is_space (s[i]))) break;
    235. 

  235.       while ((i<n) && is_space (s[i]))
    236. 

  236. 	if (s[i++]=='\n') ln++;
    237. 

  237.       if (ln >= 2) t << "\n";
    238. 

  238.       else if (i<n) t << tree (TUPLE, "\\ ");
    239. 

  239.       break;
    240. 

  240.     }
    241. 

  241.     case '$': {
    242. 

  242.       i++;
    243. 

  243.       if ((i<n) & (s[i]=='$')) {
    244. 

  244. 	i++;
    245. 

  245. 	t << tree (TUPLE, "\\begin-displaymath");
    246. 

  246. 	command_type ("!mode")= "math";
    247. 

  247. 	t << parse (s, i, "$$");
    248. 

  248. 	command_type ("!mode")= "text";
    249. 

  249. 	if ((i<n) && (s[i]=='$')) i++;
    250. 

  250. 	if ((i<n) && (s[i]=='$')) i++;
    251. 

  251. 	t << tree (TUPLE, "\\end-displaymath");
    252. 

  252.       }
    253. 

  253.       else {
    254. 

  254. 	t << tree (TUPLE, "\\begin-math");
    255. 

  255. 	command_type ("!mode")= "math";
    256. 

  256. 	t << parse (s, i, "$");
    257. 

  257. 	command_type ("!mode")= "text";
    258. 

  258. 	if ((i<n) && (s[i]=='$')) i++;
    259. 

  259. 	t << tree (TUPLE, "\\end-math");
    260. 

  260.       }
    261. 

  261.       break;
    262. 

  262.     }
    263. 

  263.     default:
    264. 

  264.       if (unicode && ((unsigned char) s[i]) >= 128) {
    265. 

  265. 	unsigned int code= decode_from_utf8 (s, i);
    266. 

  266. 	t << tree (TUPLE, "\\#" * as_hexadecimal (code));
    267. 

  267.       }
    268. 

  268.       else if (!unicode && is_iso_alpha (s[i])) {
    269. 

  269. 	// If we encounter too much text in math mode, then return
    270. 

  270. 	int start= i;
    271. 

  271. 	while ((i<n) && is_iso_alpha (s[i])) i++;
    272. 

  272. 	int end= i;
    273. 

  273. 	if ((i >= start+3) && (command_type ["!mode"] == "math")) {
    274. 

  274. 	  while ((i<n) && (is_iso_alpha (s[i]) ||
    275. 

  275. 			   is_punctuation (s[i]) ||
    276. 

  276. 			   is_space (s[i])))
    277. 

  277. 	    i++;
    278. 

  278. 	  if (i >= start+20) {
    279. 

  279. 	    int last= i, words= 0, letters= 0;
    280. 

  280. 	    for (i=start; i<last; i++) {
    281. 

  281. 	      if (is_iso_alpha (s[i])) {
    282. 

  282. 		letters++;
    283. 

  283. 		if ((i==start) || (!is_iso_alpha (s[i-1]))) words++;
    284. 

  284. 	      }
    285. 

  285. 	    }
    286. 

  286. 	    if ((words > 3) && (letters/words >= 3) && (letters >= 15)) {
    287. 

  287. 	      i= start;
    288. 

  288. 	      no_error= false;
    289. 

  289. 	    }
    290. 

  290. 	  }
    291. 

  291. 	}
    292. 

  292. 	if (no_error)
    293. 

  293. 	  for (i=start; i<end; i++)
    294. 

  294. 	    t << s(i, i+1);
    295. 

  295.       }
    296. 

  296.       else {
    297. 

  297. 	t << s (i, i+1);
    298. 

  298. 	i++;
    299. 

  299.       }
    300. 

  300.       break;
    301. 

  301.     }
    302. 

  302.   }
    303. 

  303. 

  304.   if (change) {
    305. 

  305.     command_type ->merge ();
    306. 

  306.     command_arity->merge ();
    307. 

  307.     command_def  ->merge ();
    308. 

  308.   }
    309. 

  309.   else {
    310. 

  310.     command_type ->shorten ();
    311. 

  311.     command_arity->shorten ();
    312. 

  312.     command_def  ->shorten ();
    313. 

  313.   }
    314. 

  314. 

  315.   if (N(t)==0) return "";
    316. 

  316.   if (N(t)==1) return t[0];
    317. 

  317.   return t;
    318. 

  318. }
    319. 

  319. 

  320. /******************************************************************************
    321. 

  321. * Parsing commands
    322. 

  322. ******************************************************************************/
    323. 

  323. 

  324. tree
    325. 

  325. latex_parser::parse_backslash (string s, int& i) {
    326. 

  326.   int n= N(s);
    327. 

  327.   if (((i+7)<n) && (s(i,i+5)=="\\verb")) {
    328. 

  328.     i+=6;
    329. 

  329.     return parse_verbatim (s, i, s(i-1,i));
    330. 

  330.   }
    331. 

  331.   if (((i+29)<n) && (s(i,i+16)=="\\begin{verbatim}")) {
    332. 

  332.     i+=16;
    333. 

  333.     return parse_verbatim (s, i, "\\end{verbatim}");
    334. 

  334.   }
    335. 

  335.   if (((i+5)<n) && (s(i,i+4)=="\\url") && !is_alpha (s[i+5])) {
    336. 

  336.     i+=4;
    337. 

  337.     while (i<n && (s[i] == ' ' || s[i] == '\n' || s[i] == '\t')) i++;
    338. 

  338.     string ss;
    339. 

  339.     if (i<n && s[i] == '{') {
    340. 

  340.       i++;
    341. 

  341.       int start= i;
    342. 

  342.       while ((i<n) && s[i] != '}') i++;
    343. 

  343.       ss= s (start, i++);
    344. 

  344.     }
    345. 

  345.     return tree (TUPLE, "\\url", ss);
    346. 

  346.   }
    347. 

  347.   if (((i+6)<n) && (s(i,i+5)=="\\href")) {
    348. 

  348.     i+=5;
    349. 

  349.     while (i<n && (s[i] == ' ' || s[i] == '\n' || s[i] == '\t')) i++;
    350. 

  350.     string ss;
    351. 

  351.     if (i<n && s[i] == '{') {
    352. 

  352.       i++;
    353. 

  353.       int start= i;
    354. 

  354.       while ((i<n) && s[i] != '}') i++;
    355. 

  355.       ss= s (start, i++);
    356. 

  356.     }
    357. 

  357.     tree u= "";
    358. 

  358.     while (i<n && (s[i] == ' ' || s[i] == '\n' || s[i] == '\t')) i++;
    359. 

  359.     if (i<n && s[i] == '{') { i++; u= parse (s, i, "}"); i++; }
    360. 

  360.     return tree (TUPLE, "\\href", ss, u);
    361. 

  361.   }
    362. 

  362. 

  363.   /************************ special commands *********************************/
    364. 

  364.   i++;
    365. 

  365.   if (i==n) return "";
    366. 

  366.   if (s[i]==' ') {
    367. 

  367.     i++;
    368. 

  368.     return tree (TUPLE, "\\ ");
    369. 

  369.   }
    370. 

  370.   if (!is_alpha(s[i])) {
    371. 

  371.     i++;
    372. 

  372.     if (s[i-1]=='(') return parse_command (s, i, "\\begin-math");
    373. 

  373.     if (s[i-1]==')') return parse_command (s, i, "\\end-math");
    374. 

  374.     if (s[i-1]=='[') return parse_command (s, i, "\\begin-displaymath");
    375. 

  375.     if (s[i-1]==']') return parse_command (s, i, "\\end-displaymath");
    376. 

  376.     return parse_command (s, i, s (i-2, i));
    377. 

  377.   }
    378. 

  378. 

  379.   /************************* normal commands *********************************/
    380. 

  380.   int start= i-1;
    381. 

  381.   while ((i<n) && is_alpha (s[i])) i++;
    382. 

  382.   if ((i<n) && (s[i]=='*') && latex_type (s (start, i+1)) != "undefined") i++;
    383. 

  383.   string r= s (start, i);
    384. 

  384.   if ((r == "\\begin") || (r == "\\end")) {
    385. 

  385.     while ((i<n) && is_space (s[i])) i++;
    386. 

  386.     if ((i==n) || (s[i]!='{')) {
    387. 

  387.       latex_error (s, i, "begin or end which environment ?");
    388. 

  388.       return "";
    389. 

  389.     }
    390. 

  390.     i++; start= i;
    391. 

  391.     while ((i<n) && (s[i]!='}')) i++;
    392. 

  392.     r = r * "-" * s (start, i);
    393. 

  393.     if (i<n) i++;
    394. 

  394.   }
    395. 

  395.   return parse_command (s, i, r);
    396. 

  396. }
    397. 

  397. 

  398. static string
    399. 

  399. sharp_to_arg (string s, tree args) {
    400. 

  400.   int i;
    401. 

  401.   string r;
    402. 

  402.   for (i=0; i<N(s); i++)
    403. 

  403.     if ((s[i]=='#') && ((i+1)<N(s)) && (s[i+1]>='1') && (s[i+1]<='9')) {
    404. 

  404.       int nr= ((int) s[++i]) - ((int) '0');
    405. 

  405.       if (N(args)>nr) r << string_arg (args[nr]);
    406. 

  406.     }
    407. 

  407.     else r << s[i];
    408. 

  408.   return r;
    409. 

  409. }
    410. 

  410. 

  411. tree
    412. 

  412. latex_parser::parse_symbol (string s, int& i) {
    413. 

  413.   int start= i;
    414. 

  414.   if ((s[i] == '*') && (command_type ["!mode"] == "math")) {
    415. 

  415.     i++; return tree (TUPLE, "\\ast"); }
    416. 

  416.   if (s[i] == '<') { i++; return tree (TUPLE, "\\<less>"); }
    417. 

  417.   if (s[i] == '>') { i++; return tree (TUPLE, "\\<gtr>"); }
    418. 

  418.   if (s[i] != '\\') { i++; return s(start, i); }
    419. 

  419.   i++;
    420. 

  420.   if (i == N(s)) return tree (TUPLE, "\\backslash");
    421. 

  421.   if (!is_alpha (s[i])) { i++; return s(start, i); }
    422. 

  422.   while ((i<N(s)) && is_alpha (s[i])) i++;
    423. 

  423.   if ((i<N(s)) && (s[i]=='*')) i++;
    424. 

  424.   return s(start,i);
    425. 

  425. }
    426. 

  426. 

  427. static bool
    428. 

  428. is_math_environment (tree t) {
    429. 

  429.   //cout << "t= " << t << "\n";
    430. 

  430.   tree b= t[N(t)-2];
    431. 

  431.   tree e= t[N(t)-1];
    432. 

  432.   if (!is_concat (b)) b= tree (CONCAT, b);
    433. 

  433.   if (!is_concat (e)) e= tree (CONCAT, e);
    434. 

  434.   int i, j;
    435. 

  435.   for (i=N(b)-1; i>=0; i--)
    436. 

  436.     if (is_tuple (b[i]) && N(b[i])>0 && is_atomic (b[i][0]))
    437. 

  437.       if (latex_type (b[i][0]->label) == "math-environment")
    438. 

  438. 	break;
    439. 

  439.   for (j=0; j<N(e); j++)
    440. 

  440.     if (is_tuple (e[j]) && N(e[j])>0 && is_atomic (e[j][0]))
    441. 

  441.       if (latex_type (e[j][0]->label) == "math-environment")
    442. 

  442. 	break;
    443. 

  443.   if (i >= 0 && j < N(e)) {
    444. 

  444.     string bs= b[i][0]->label;
    445. 

  445.     string es= e[j][0]->label;
    446. 

  446.     bool ok=
    447. 

  447.       starts (bs, "\\begin-") &&
    448. 

  448.       starts (es, "\\end-") &&
    449. 

  449.       bs (7, N(bs)) == es (5, N(es));
    450. 

  450.     //cout << t[1] << " -> " << ok << "\n";
    451. 

  451.     return ok;
    452. 

  452.   }
    453. 

  453.   return false;
    454. 

  454. }
    455. 

  455. 

  456. static bool
    457. 

  457. is_text_argument (string cmd, int remaining_arity) {
    458. 

  458.   // FIXME: this test should be improved using DRD properties
    459. 

  459.   (void) remaining_arity;
    460. 

  460.   return cmd == "\\label" || cmd == "\\ref";
    461. 

  461. }
    462. 

  462. 

  463. tree
    464. 

  464. latex_parser::parse_command (string s, int& i, string cmd) {
    465. 

  465.   //cout << cmd << " [" << latex_type (cmd) << ", "
    466. 

  466.   //<< command_type ["!mode"] << ", " << latex_arity (cmd) << "]" << LF;
    467. 

  467.   if (cmd == "\\newcommand") cmd= "\\def";
    468. 

  468.   if (cmd == "\\renewcommand") cmd= "\\def";
    469. 

  469.   if (cmd == "\\renewenvironment") cmd= "\\newenvironment";
    470. 

  470.   if (cmd == "\\begin-split") cmd= "\\begin-eqsplit";
    471. 

  471.   if (cmd == "\\end-split") cmd= "\\end-eqsplit";
    472. 

  472.   if (cmd == "\\begin-split*") cmd= "\\begin-eqsplit*";
    473. 

  473.   if (cmd == "\\end-split*") cmd= "\\end-eqsplit*";
    474. 

  474.   if (latex_type (cmd) == "undefined")
    475. 

  475.     return parse_unknown (s, i, cmd);
    476. 

  476. 

  477.   if (latex_type (cmd) == "math-environment") {
    478. 

  478.     if (cmd (0, 6) == "\\begin") command_type ("!mode") = "math";
    479. 

  479.     else command_type ("!mode") = "text";
    480. 

  480.   }
    481. 

  481. 

  482.   bool mbox_flag=
    483. 

  483.     ((cmd == "\\text") || (cmd == "\\mbox")) &&
    484. 

  484.     (command_type ["!mode"] == "math");
    485. 

  485.   if (mbox_flag) command_type ("!mode") = "text";
    486. 

  486. 

  487.   int  n     = N(s);
    488. 

  488.   int  arity = latex_arity (cmd);
    489. 

  489.   bool option= (arity<0);
    490. 

  490.   if (option) arity= -1-arity;
    491. 

  491. 

  492.   /************************ retrieve arguments *******************************/
    493. 

  493.   tree t (TUPLE, copy (cmd)); // parsed arguments
    494. 

  494.   tree u (TUPLE, copy (cmd)); // unparsed arguments
    495. 

  495.   while (i<n && arity>=0 && (arity>0 || option)) {
    496. 

  496.     int j= i;
    497. 

  497.     while ((j<n) && is_space (s[j])) j++;
    498. 

  498.     if (j==n) break;
    499. 

  499.     if (option && (s[j]=='[')) {
    500. 

  500.       j++;
    501. 

  501.       i=j;
    502. 

  502.       tree opt= parse (s, i, "]");
    503. 

  503.       if (cmd != "\\newtheorem" && cmd != "\\newtheorem*")
    504. 

  504. 	t << opt;
    505. 

  505.       u << s (j, i);
    506. 

  506.       if ((i<n) && (s[i]==']')) i++;
    507. 

  507.       if (cmd != "\\newtheorem" && cmd != "\\newtheorem*")
    508. 

  508. 	t[0]->label= t[0]->label * "*";
    509. 

  509.       option= false;
    510. 

  510.     }
    511. 

  511.     else if ((arity>0) && (s[j]=='{')) {
    512. 

  512.       bool text_arg=
    513. 

  513. 	(command_type["!mode"] == "math") && is_text_argument (cmd, arity);
    514. 

  514.       j++;
    515. 

  515.       i=j;
    516. 

  516.       if (text_arg) command_type ("!mode")= "text";
    517. 

  517.       if ((N(t)==1) && (cmd == "\\def")) {
    518. 

  518. 	while ((i<n) && (s[i]!='}')) i++;
    519. 

  519. 	t << s (j, i);
    520. 

  520.       }
    521. 

  521.       else t << parse (s, i, "}");
    522. 

  522.       if (text_arg) command_type ("!mode")= "math";
    523. 

  523.       u << s (j, i);
    524. 

  524.       if ((i<n) && (s[i]=='}')) i++;
    525. 

  525.       arity--;
    526. 

  526.       if (arity == 0) option= false;
    527. 

  527.     }
    528. 

  528.     else if (s[j] == '}') break;
    529. 

  529.     else if (option && (s[j]=='#') && (cmd == "\\def")) {
    530. 

  530.       while ((j+3 <= n) && is_numeric (s[j+1]) && (s[j+2] == '#')) j+=2;
    531. 

  531.       if (j+2<=n) {
    532. 

  532. 	t << s (j+1, j+2);
    533. 

  533. 	u << s (j+1, j+2);
    534. 

  534. 	i= j+2;
    535. 

  535.       }
    536. 

  536.       t[0]->label= t[0]->label * "*";
    537. 

  537.       option= false;
    538. 

  538.     }
    539. 

  539.     else {
    540. 

  540.       if (arity>0) {
    541. 

  541. 	i=j;
    542. 

  542. 	tree st= parse_symbol (s, i);
    543. 

  543. 	t << st;
    544. 

  544. 	u << st;
    545. 

  545. 	arity--;
    546. 

  546. 	if (arity == 0) option= false;
    547. 

  547.       }
    548. 

  548.       else break;
    549. 

  549.     }
    550. 

  550.   }
    551. 

  551.   if (arity>0) latex_error (s, i, "too little arguments for " * cmd);
    552. 

  552. 

  553.   /******************** new commands and environments ************************/
    554. 

  554.   if (is_tuple (t, "\\def", 2)) {
    555. 

  555.     string var= string_arg (t[1]);
    556. 

  556.     command_type  (var)= "user";
    557. 

  557.     command_arity (var)= 0;
    558. 

  558.     command_def   (var)= as_string (u[2]);
    559. 

  559.   }
    560. 

  560.   if (is_tuple (t, "\\def*", 3)) {
    561. 

  561.     string var= string_arg (t[1]);
    562. 

  562.     command_type  (var)= "user";
    563. 

  563.     command_arity (var)= as_int (t[2]);
    564. 

  564.     command_def   (var)= as_string (u[3]);
    565. 

  565.   }
    566. 

  566.   if (is_tuple (t, "\\newtheorem", 2) || is_tuple (t, "\\newtheorem*", 2)) {
    567. 

  567.     string var= "\\begin-" * string_arg (t[1]);
    568. 

  568.     command_type  (var)= "environment";
    569. 

  569.     command_arity (var)= 0;
    570. 

  570.     var= "\\end-" * string_arg (t[1]);
    571. 

  571.     command_type  (var)= "environment";
    572. 

  572.     command_arity (var)= 0;
    573. 

  573.   }
    574. 

  574.   if (is_tuple (t, "\\newenvironment", 3)) {
    575. 

  575.     string var= "\\begin-" * string_arg (t[1]);
    576. 

  576.     command_type  (var)= "user";
    577. 

  577.     command_arity (var)= 0;
    578. 

  578.     command_def   (var)= as_string (u[2]);
    579. 

  579.     if (is_math_environment (t)) command_type (var)= "math-environment";
    580. 

  580.     var= "\\end-" * string_arg (t[1]);
    581. 

  581.     command_type  (var)= "user";
    582. 

  582.     command_arity (var)= 0;
    583. 

  583.     command_def   (var)= as_string (u[3]);
    584. 

  584.     if (is_math_environment (t)) command_type (var)= "math-environment";
    585. 

  585.   }
    586. 

  586.   if (is_tuple (t, "\\newenvironment*", 4)) {
    587. 

  587.     string var= "\\begin-" * string_arg (t[1]);
    588. 

  588.     command_type  (var)= "user";
    589. 

  589.     command_arity (var)= as_int (t[2]);
    590. 

  590.     command_def   (var)= as_string (u[3]);
    591. 

  591.     if (is_math_environment (t)) command_type (var)= "math-environment";
    592. 

  592.     var= "\\end-" * string_arg (t[1]);
    593. 

  593.     command_type  (var)= "user";
    594. 

  594.     command_arity (var)= 0;
    595. 

  595.     command_def   (var)= as_string (u[4]);
    596. 

  596.     if (is_math_environment (t)) command_type (var)= "math-environment";
    597. 

  597.   }
    598. 

  598. 

  599.   /***************** environment changes for user commands  ******************/
    600. 

  600.   if (latex_type (cmd) == "user") {
    601. 

  601.     int pos= 0;
    602. 

  602.     string body= command_def[cmd];
    603. 

  603.     if (count_occurrences ("\\begin", body) ==
    604. 

  604. 	count_occurrences ("\\end", body))
    605. 

  605.       (void) parse (sharp_to_arg (body, u), pos, "", true);
    606. 

  606.     else t= parse (sharp_to_arg (body, u), pos, "", true);
    607. 

  607.     // replaces macros by their definitions in the case when
    608. 

  608.     // the user defined shorthands for \\begin{env} and \\end{env}
    609. 

  609.   }
    610. 

  610. 

  611.   if (mbox_flag) command_type ("!mode") = "math";
    612. 

  612.   return t;
    613. 

  613. }
    614. 

  614. 

  615. tree
    616. 

  616. latex_parser::parse_unknown (string s, int& i, string cmd) {
    617. 

  617.   int  n     = N(s);
    618. 

  618.   bool option= false;
    619. 

  619. 

  620.   tree t (TUPLE, copy (cmd));
    621. 

  621.   while (i<n) {
    622. 

  622.     int j=i;
    623. 

  623.     while ((j<n) && is_space (s[j])) j++;
    624. 

  624.     if (j==n) break;
    625. 

  625.     if (option && (s[j]=='[')) {
    626. 

  626.       j++;
    627. 

  627.       i=j;
    628. 

  628.       t << parse (s, i, "]");
    629. 

  629.       if ((i<n) && (s[i]==']')) i++;
    630. 

  630.       t[0]->label= t[0]->label * "*";
    631. 

  631.       option= false;
    632. 

  632.     }
    633. 

  633.     else if (s[j]=='{') {
    634. 

  634.       j++;
    635. 

  635.       i=j;
    636. 

  636.       t << parse (s, i, "}");
    637. 

  637.       if ((i<n) && (s[i]=='}')) i++;
    638. 

  638.     }
    639. 

  639.     else break;
    640. 

  640.   }
    641. 

  641.   return t;
    642. 

  642. }
    643. 

  643. 

  644. /******************************************************************************
    645. 

  645. * Parsing verbatim text
    646. 

  646. ******************************************************************************/
    647. 

  647. 

  648. tree
    649. 

  649. latex_parser::parse_verbatim (string s, int& i, string end) {
    650. 

  650.   int start=i, n= N(s), e= N(end);
    651. 

  651.   while ((i<(n-e)) && (s(i,i+e)!=end)) i++;
    652. 

  652.   i+=e;
    653. 

  653.   return tree (CONCAT,
    654. 

  654. 	       tree (TUPLE, "\\begin-verbatim"),
    655. 

  655. 	       s(start,i-e),
    656. 

  656. 	       tree (TUPLE, "\\end-verbatim"));
    657. 

  657. }
    658. 

  658. 

  659. /******************************************************************************
    660. 

  660. * This routine may be used to transform accented characters to the Cork format
    661. 

  661. ******************************************************************************/
    662. 

  662. 

  663. static char Cork_unaccented[128]= {
    664. 

  664.   'A', 'A', 'C', 'C', 'D', 'E', 'E', 'G',
    665. 

  665.   'L', 'L', ' ', 'N', 'N', ' ', 'O', 'R',
    666. 

  666.   'R', 'S', 'S', 'S', 'T', 'T', 'U', 'U',
    667. 

  667.   'Y', 'Z', 'Z', 'Z', ' ', 'I', 'd', ' ',
    668. 

  668.   'a', 'a', 'c', 'c', 'd', 'e', 'e', 'g',
    669. 

  669.   'l', 'l', ' ', 'n', 'n', ' ', 'o', 'r',
    670. 

  670.   'r', 's', 's', 's', 't', 't', 'u', 'u',
    671. 

  671.   'y', 'z', 'z', 'z', ' ', ' ', ' ', ' ',
    672. 

  672.   'A', 'A', 'A', 'A', 'A', 'A', ' ', 'C',
    673. 

  673.   'E', 'E', 'E', 'E', 'I', 'I', 'I', 'I',
    674. 

  674.   'D', 'N', 'O', 'O', 'O', 'O', 'O', ' ',
    675. 

  675.   ' ', 'U', 'U', 'U', 'U', 'Y', ' ', ' ',
    676. 

  676.   'a', 'a', 'a', 'a', 'a', 'a', ' ', 'c',
    677. 

  677.   'e', 'e', 'e', 'e', 25 , 25 , 25 , 25 ,
    678. 

  678.   'd', 'n', 'o', 'o', 'o', 'o', 'o', ' ',
    679. 

  679.   ' ', 'u', 'u', 'u', 'u', 'y', ' ', ' '
    680. 

  680. };
    681. 

  681. 

  682. static char Cork_accent[128]= {
    683. 

  683.   'u' , 'k' , '\'', 'v' , 'v' , 'v' , 'k' , 'u' ,
    684. 

  684.   '\'', 'v' , ' ' , '\'', 'v' , ' ' , 'H' , '\'',
    685. 

  685.   'v' , '\'', 'v' , 'c' , 'v' , 'c' , 'H' , 'r' ,
    686. 

  686.   '\"', '\'', 'v' , '.' , ' ' , '.' , '=' , ' ' , // "
    687. 

  687.   'u' , 'k' , '\'', 'v' , 'v' , 'v' , 'k' , 'u' ,
    688. 

  688.   '\'', 'v' , ' ' , '\'', 'v' , ' ' , 'H' , '\'',
    689. 

  689.   'v' , '\'', 'v' , 'c' , 'v' , 'c' , 'H' , 'r' ,
    690. 

  690.   '\"', '\'', 'v' , '.' , ' ' , ' ' , ' ' , ' ' , // "
    691. 

  691.   '`' , '\'', '^' , '~' , '\"', ' ' , ' ' , 'c' , // "
    692. 

  692.   '`' , '\'', '^' , '\"', '`' , '\'', '^' , '\"', // "
    693. 

  693.   '=' , '~' , '`' , '\'', '^' , '~' , '\"', ' ' , // "
    694. 

  694.   ' ' , '`' , '\'', '^' , '\"', '\'', ' ' , ' ' , // "
    695. 

  695.   '`' , '\'', '^' , '~' , '\"', ' ' , ' ' , 'c' , // "
    696. 

  696.   '`' , '\'', '^' , '\"', '`' , '\'', '^' , '\"', // "
    697. 

  697.   '=' , '~' , '`' , '\'', '^' , '~' , '\"', ' ' , // "
    698. 

  698.   ' ' , '`' , '\'', '^' , '\"', '\'', ' ' , ' '   // "
    699. 

  699. };
    700. 

  700. 

  701. tree
    702. 

  702. accented_to_Cork (tree t) {
    703. 

  703.   if (arity (t) == 0) return t;
    704. 

  704.   int i, n=N(t);
    705. 

  705.   tree r (t, n);
    706. 

  706.   for (i=0; i<n; i++) r[i]= accented_to_Cork (t[i]);
    707. 

  707.   if (is_compound (t[0])) return r;
    708. 

  708. 

  709.   string s= t[0]->label;
    710. 

  710.   if ((N(s)==2) && (s[0]=='\\') && (n==2) &&
    711. 

  711.       is_atomic (r[1]) && (N(r[1]->label)<=2)) {
    712. 

  712.     string v= r[1]->label;
    713. 

  713.     if (N(v)==0) {
    714. 

  714.       if (s[1] == '`' ) {
    715. 

  715. 	string ret_s (1);
    716. 

  716. 	ret_s[0]= '\000';
    717. 

  717. 	return ret_s;
    718. 

  718.       }
    719. 

  719.       if (s[1] == '\'') return "\001";
    720. 

  720.       if (s[1] == '^' ) return "\136";
    721. 

  721.       if (s[1] == '\"') return "\004"; // "
    722. 

  722.       if (s[1] == '~' ) return "\176";
    723. 

  723.       if (s[1] == '=' ) return "\026";
    724. 

  724.       if (s[1] == '.' ) return "\137";
    725. 

  725.       if (s[1] == 'u' ) return "\025";
    726. 

  726.       if (s[1] == 'v' ) return "\024";
    727. 

  727.       if (s[1] == 'H' ) return "\175";
    728. 

  728.       if (s[1] == 'c' ) return "\030";
    729. 

  729.     }
    730. 

  730.     else {
    731. 

  731.       char c1= v[0], c2= s[1];
    732. 

  732.       if (v == "\\i") c1= (char) 25;
    733. 

  733.       if ((N(v)==1) || (v=="\\i"))
    734. 

  734. 	for (i=0; i<127; i++)
    735. 

  735. 	  if ((Cork_unaccented[i]==c1) && (Cork_accent[i]==c2))
    736. 

  736. 	    return tree (string ((char) (i+128)));
    737. 

  737.     }
    738. 

  738.   }
    739. 

  739.   if (r == tuple ("\\i")) return "\\i";
    740. 

  740.   return r;
    741. 

  741. }
    742. 

  742. 

  743. /******************************************************************************
    744. 

  744. * Interface
    745. 

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

  746. 

  747. tree
    748. 

  748. latex_parser::parse (string s, bool change) {
    749. 

  749.   command_type ->extend ();
    750. 

  750.   command_arity->extend ();
    751. 

  751.   command_def  ->extend ();
    752. 

  752. 

  753.   // We first cut the string into pieces at strategic places
    754. 

  754.   // This reduces the risk that the parser gets confused
    755. 

  755.   array<string> a;
    756. 

  756.   int i, start=0, n= N(s);
    757. 

  757.   for (i=0; i<n; i++)
    758. 

  758.     if (s[i]=='\n' || (s[i] == '\\' && test (s, i, "\\nextbib"))) {
    759. 

  759.       while ((i<n) && is_space (s[i])) i++;
    760. 

  760.       if (test (s, i, "%%%%%%%%%% Start TeXmacs macros\n")) {
    761. 

  761. 	a << s (start, i);
    762. 

  762. 	while ((i<n) && (!test (s, i, "%%%%%%%%%% End TeXmacs macros\n")))
    763. 

  763. 	  i++;
    764. 

  764. 	i += 30;
    765. 

  765. 	start= i;
    766. 

  766. 	continue;
    767. 

  767.       }
    768. 

  768.       if (test (s, i, "\\begin{document}") ||
    769. 

  769. 	  test (s, i, "\\begin{abstract}") ||
    770. 

  770. 	  test (s, i, "\\chapter") ||
    771. 

  771. 	  test (s, i, "\\section") ||
    772. 

  772. 	  test (s, i, "\\subsection") ||
    773. 

  773. 	  test (s, i, "\\subsubsection") ||
    774. 

  774. 	  test (s, i, "\\paragraph") ||
    775. 

  775. 	  test (s, i, "\\subparagraph") ||
    776. 

  776. 	  test (s, i, "\\nextbib") ||
    777. 

  777. 	  test (s, i, "\\newcommand") ||
    778. 

  778. 	  test (s, i, "\\def") ||
    779. 

  779. 	  test (s, i, "\\input{") ||
    780. 

  780. 	  test (s, i, "\\include{"))
    781. 

  781. 	{
    782. 

  782. 	  a << s (start, i);
    783. 

  783. 	  start= i;
    784. 

  784.           if (test (s, i, "\\input{") || test (s, i, "\\include{")) {
    785. 

  785. 	    while (i<N(s) && s[i] != '{') i++;
    786. 

  786. 	    int start_name= i+1;
    787. 

  787.             while (i<N(s) && s[i] != '}') i++;
    788. 

  788.             string name= s (start_name, i);
    789. 

  789.             if (!ends (name, ".tex")) name= name * ".tex";
    790. 

  790.             url incl= relative (get_file_focus (), name);
    791. 

  791.             string body;
    792. 

  792.             if (!exists (incl) || load_string (incl, body, false)) i++;
    793. 

  793.             else {
    794. 

  794.               //cout << "Include " << name << " -> " << incl << "\n";
    795. 

  795.               s= s (0, start) * "\n" * body * "\n" * s (i+1, N(s));
    796. 

  796.               n= N(s);
    797. 

  797.               i= start + 1;
    798. 

  798.             }
    799. 

  799.             start= i;
    800. 

  800.           }
    801. 

  801.           while (i < n && test (s, i, "\\nextbib{}")) {
    802. 

  802.             i += 10;
    803. 

  803.             a << s (start, i);
    804. 

  804.             start= i;
    805. 

  805.           }
    806. 

  806. 	}
    807. 

  807.       if (i == n) break;
    808. 

  808.     }
    809. 

  809.   a << s (start, i);
    810. 

  810. 

  811.   // We now parse each of the pieces
    812. 

  812.   tree t (CONCAT);
    813. 

  813.   for (i=0; i<N(a); i++) {
    814. 

  814.     int j=0;
    815. 

  815.     while (j<N(a[i])) {
    816. 

  816.       int start= j;
    817. 

  817.       command_type ("!mode") = "text";
    818. 

  818.       command_type ("!em") = "false";
    819. 

  819.       tree u= parse (a[i], j, "", true);
    820. 

  820.       if ((N(t)>0) && (t[N(t)-1]!='\n') && (start==0)) t << "\n";
    821. 

  821.       if (is_concat (u)) t << A(u);
    822. 

  822.       else t << u;
    823. 

  823.       if (j == start) j++;
    824. 

  824.     }
    825. 

  825.   }
    826. 

  826. 

  827.   if (change) {
    828. 

  828.     command_type ->merge ();
    829. 

  829.     command_arity->merge ();
    830. 

  830.     command_def  ->merge ();
    831. 

  831.   }
    832. 

  832.   else {
    833. 

  833.     command_type ->shorten ();
    834. 

  834.     command_arity->shorten ();
    835. 

  835.     command_def  ->shorten ();
    836. 

  836.   }
    837. 

  837.   //cout << "Parsed " << t << "\n";
    838. 

  838.   return t;
    839. 

  839. }
    840. 

  840. 

  841. static bool
    842. 

  842. japanese_tex (string& s) {
    843. 

  843.   if (search_forwards ("\\documentclass{jarticle}", s) != -1) {
    844. 

  844.     s= replace (s, "\\documentclass{jarticle}", "\\documentclass{article}");
    845. 

  845.     s= convert (s, "ISO-2022-JP", "UTF-8");
    846. 

  846.     return true;
    847. 

  847.   }
    848. 

  848.   if (search_forwards ("\\documentclass{jbook}", s) != -1) {
    849. 

  849.     s= replace (s, "\\documentclass{jbook}", "\\documentclass{book}");
    850. 

  850.     s= convert (s, "ISO-2022-JP", "UTF-8");
    851. 

  851.     return true;
    852. 

  852.   }
    853. 

  853.   return false;
    854. 

  854. }
    855. 

  855. 

  856. static bool
    857. 

  857. korean_tex (string& s) {
    858. 

  858.   if (search_forwards ("\\usepackage{hangul}", s) != -1 ||
    859. 

  859.       search_forwards ("\\usepackage{hfont}", s) != -1 ||
    860. 

  860.       search_forwards ("]{hangul}", s) != -1 ||
    861. 

  861.       search_forwards ("]{hfont}", s) != -1)
    862. 

  862.     {
    863. 

  863.       s= replace (s, "\\usepackage{hangul}", "");
    864. 

  864.       s= replace (s, "\\usepackage{hfont}", "");
    865. 

  865.       s= convert (s, "EUC-KR", "UTF-8");
    866. 

  866.       return true;
    867. 

  867.     }
    868. 

  868.   if (search_forwards ("\\usepackage{dhucs}", s) != -1 ||
    869. 

  869.       search_forwards ("\\usepackage{memhangul-ucs}", s) != -1 ||
    870. 

  870.       search_forwards ("]{dhucs}", s) != -1 ||
    871. 

  871.       search_forwards ("]{memhangul-ucs}", s) != -1)
    872. 

  872.     {
    873. 

  873.       s= replace (s, "\\usepackage{dhucs}", "");
    874. 

  874.       s= replace (s, "\\usepackage{memhangul-ucs}", "");
    875. 

  875.       return true;
    876. 

  876.     }
    877. 

  877.   return false;
    878. 

  878. }
    879. 

  879. 

  880. static bool
    881. 

  881. chinese_tex (string& s) {
    882. 

  882.   if (search_forwards ("\\kaishu", s) != -1)
    883. 

  883.     s= replace (s, "\\kaishu", "");
    884. 

  884.   if (search_forwards ("\\begin{CJK}{GBK}{kai}", s) != -1)
    885. 

  885.     s= replace (s, "\\begin{CJK}{GBK}{kai}", "");
    886. 

  886.   if (search_forwards ("\\begin{CJK*}{GBK}{kai}", s) != -1)
    887. 

  887.     s= replace (s, "\\begin{CJK*}{GBK}{kai}", "");
    888. 

  888.   if (search_forwards ("\\end{CJK}", s) != -1)
    889. 

  889.     s= replace (s, "\\end{CJK}", "");
    890. 

  890.   if (search_forwards ("\\end{CJK*}", s) != -1)
    891. 

  891.     s= replace (s, "\\end{CJK*}", "");
    892. 

  892.   if (search_forwards ("\\CJKindent", s) != -1)
    893. 

  893.     s= replace (s, "\\CJKindent", "");
    894. 

  894.   if (search_forwards ("\\CJKcaption{GBk}", s) != -1)
    895. 

  895.     s= replace (s, "\\CJKcaption{GBK}", "");
    896. 

  896.   if (search_forwards ("\\usepackage{CJK}", s) != -1) {
    897. 

  897.     s= replace (s, "\\usepackage{CJK}", "");
    898. 

  898.     s= convert (s, "cp936", "UTF-8");
    899. 

  899.     return true;
    900. 

  900.   }
    901. 

  901.   if (search_forwards ("\\documentclass{cctart}", s) != -1) {
    902. 

  902.     s= replace (s, "\\documentclass{cctart}", "\\documentclass{article}");
    903. 

  903.     s= convert (s, "cp936", "UTF-8");
    904. 

  904.     return true;
    905. 

  905.   }
    906. 

  906.   if (search_forwards ("\\documentclass[CJK]{cctart}", s) != -1) {
    907. 

  907.     s= replace (s, "\\documentclass[CJK]{cctart}", "\\documentclass{article}");
    908. 

  908.     s= convert (s, "cp936", "UTF-8");
    909. 

  909.     return true;
    910. 

  910.   }
    911. 

  911.   return false;
    912. 

  912. }
    913. 

  913. 

  914. static bool
    915. 

  915. taiwanese_tex (string& s) {
    916. 

  916.   if (search_forwards ("\\usepackage{CJKvert,type1cm}", s) != -1)
    917. 

  917.     s= replace (s, "\\usepackage{CJKvert,type1cm}", "");
    918. 

  918.   if (search_forwards ("\\begin{CJK}{Bg5}{aming}", s) != -1)
    919. 

  919.     s= replace (s, "\\begin{CJK}{Bg5}{aming}", "");
    920. 

  920.   if (search_forwards ("\\begin{CJK}{Bg5}{kai}", s) != -1)
    921. 

  921.     s= replace (s, "\\begin{CJK}{Bg5}{kai}", "");
    922. 

  922.   if (search_forwards ("\\end{CJK}", s) != -1)
    923. 

  923.     s= replace (s, "\\end{CJK}", "");
    924. 

  924.   if (search_forwards ("\\CJKcaption{Bg5}", s) != -1)
    925. 

  925.     s= replace (s, "\\CJKcaption{Bg5}", "");
    926. 

  926.   if (search_forwards ("\\CJKindent", s) != -1)
    927. 

  927.     s= replace (s, "\\CJKindent", "");
    928. 

  928.   if (search_forwards ("\\usepackage{CJK}", s) != -1) {
    929. 

  929.     s= replace (s, "\\usepackage{CJK}", "");
    930. 

  930.     s= convert (s, "cp950", "UTF-8");
    931. 

  931.     return true;
    932. 

  932.   }
    933. 

  933.   if (search_forwards ("\\usepackage{CJK*}", s) != -1) {
    934. 

  934.     s= replace (s, "\\usepackage{CJK*}", "");
    935. 

  935.     s= convert (s, "cp950", "UTF-8");
    936. 

  936.     return true;
    937. 

  937.   }
    938. 

  938.   return false;
    939. 

  939. }
    940. 

  940. 

  941. tree
    942. 

  942. parse_latex (string s, bool change) {
    943. 

  943.   s= dos_to_better (s);
    944. 

  944.   string lan= "";
    945. 

  945.   if (japanese_tex (s)) lan= "japanese";
    946. 

  946.   else if (korean_tex (s)) lan= "korean";
    947. 

  947.   else if (taiwanese_tex (s)) lan= "taiwanese";
    948. 

  948.   else if (chinese_tex (s)) lan= "chinese";
    949. 

  949.   bool unicode= (lan == "chinese" || lan == "japanese" ||
    950. 

  950. 		 lan == "korean" || lan == "taiwanese");
    951. 

  951.   latex_parser ltx (unicode);
    952. 

  952.   tree r= accented_to_Cork (ltx.parse (s, change));
    953. 

  953.   if (lan == "") return r;
    954. 

  954.   return compound ("!language", r, lan);
    955. 

  955. }
    956. 

  956. 

  957. tree
    958. 

  958. parse_latex_document (string s, bool change) {
    959. 

  959.   return compound ("!file", parse_latex (s, change));
    960. 

  960. }
    961. 

  961.