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

/source/src/Data/Convert/Tex/parsetex.cpp

http://itexmacs.googlecode.com/
C++ | 959 lines | 826 code | 53 blank | 80 comment | 519 complexity | 4d9af31b7868adb27436d38087bf5d52 MD5 | raw file
Possible License(s): GPL-3.0, GPL-2.0, MPL-2.0-no-copyleft-exception, LGPL-2.0 
    

  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.       t << tuple ("\\nbsp");
    104. 

  104.       i++;
    105. 

  105.       break;
    106. 

  106.     case ' ':
    107. 

  107.     case '\t':
    108. 

  108.     case '\r':
    109. 

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

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

  111.       break;
    112. 

  112.     case '\n': {
    113. 

  113.       int ln=0;
    114. 

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

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

  116.       if (i<n) {
    117. 

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

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

  119.       }
    120. 

  120.       break;
    121. 

  121.     }
    122. 

  122.     case '%': {
    123. 

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

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

  125.       int ln=0;
    126. 

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

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

  128.       if (ln > 0) {
    129. 

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

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

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

  132.       }
    133. 

  133.       break;
    134. 

  134.     }
    135. 

  135.     case '#':
    136. 

  136.       i++;
    137. 

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

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

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

  140. 	i++;
    141. 

  141.       }
    142. 

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

  143.       break;
    144. 

  144.     case '\\':
    145. 

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

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

  147. 	{
    148. 

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

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

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

  151. 	  int j;
    152. 

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

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

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

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

  156. 	  i+=5;
    157. 

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

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

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

  160. 	}
    161. 

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

  162. 	i+=3;
    163. 

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

  164.       }
    165. 

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

  166. 	i+=3;
    167. 

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

  168.       }
    169. 

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

  170. 	i+=8;
    171. 

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

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

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

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

  175. 	else t << arg;
    176. 

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

  177.       }
    178. 

  178.       else  {
    179. 

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

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

  181.       }
    182. 

  182.       break;
    183. 

  183.     case '\'':
    184. 

  184.       i++;
    185. 

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

  186. 	int start= i-1;
    187. 

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

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

  189.       }
    190. 

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

  191.       break;
    192. 

  192.     case '*':
    193. 

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

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

  195.       i++;
    196. 

  196.       break;
    197. 

  197.     case '_':
    198. 

  198.       i++;
    199. 

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

  200.       /*
    201. 

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

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

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

  204.       */
    205. 

  205.       break;
    206. 

  206.     case '^':
    207. 

  207.       i++;
    208. 

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

  209.       /*
    210. 

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

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

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

  213.       */
    214. 

  214.       break;
    215. 

  215.     case '<':
    216. 

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

  217.       i++;
    218. 

  218.       break;
    219. 

  219.     case '>':
    220. 

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

  221.       i++;
    222. 

  222.       break;
    223. 

  223.     case '\244':
    224. 

  224.       i++;
    225. 

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

  226.       break;
    227. 

  227.     case '{': {
    228. 

  228.       i++;
    229. 

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

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

  231. 

  232.       int ln=0;
    233. 

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

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

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

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

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

  238.       break;
    239. 

  239.     }
    240. 

  240.     case '$': {
    241. 

  241.       i++;
    242. 

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

  243. 	i++;
    244. 

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

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

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

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

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

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

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

  251.       }
    252. 

  252.       else {
    253. 

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

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

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

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

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

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

  259.       }
    260. 

  260.       break;
    261. 

  261.     }
    262. 

  262.     default:
    263. 

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

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

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

  266.       }
    267. 

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

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

  269. 	int start= i;
    270. 

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

  271. 	int end= i;
    272. 

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

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

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

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

  276. 	    i++;
    277. 

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

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

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

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

  281. 		letters++;
    282. 

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

  283. 	      }
    284. 

  284. 	    }
    285. 

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

  286. 	      i= start;
    287. 

  287. 	      no_error= false;
    288. 

  288. 	    }
    289. 

  289. 	  }
    290. 

  290. 	}
    291. 

  291. 	if (no_error)
    292. 

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

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

  294.       }
    295. 

  295.       else {
    296. 

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

  297. 	i++;
    298. 

  298.       }
    299. 

  299.       break;
    300. 

  300.     }
    301. 

  301.   }
    302. 

  302. 

  303.   if (change) {
    304. 

  304.     command_type ->merge ();
    305. 

  305.     command_arity->merge ();
    306. 

  306.     command_def  ->merge ();
    307. 

  307.   }
    308. 

  308.   else {
    309. 

  309.     command_type ->shorten ();
    310. 

  310.     command_arity->shorten ();
    311. 

  311.     command_def  ->shorten ();
    312. 

  312.   }
    313. 

  313. 

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

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

  316.   return t;
    317. 

  317. }
    318. 

  318. 

  319. /******************************************************************************
    320. 

  320. * Parsing commands
    321. 

  321. ******************************************************************************/
    322. 

  322. 

  323. tree
    324. 

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

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

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

  327.     i+=6;
    328. 

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

  329.   }
    330. 

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

  331.     i+=16;
    332. 

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

  333.   }
    334. 

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

  335.     i+=4;
    336. 

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

  337.     string ss;
    338. 

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

  339.       i++;
    340. 

  340.       int start= i;
    341. 

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

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

  343.     }
    344. 

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

  345.   }
    346. 

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

  347.     i+=5;
    348. 

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

  349.     string ss;
    350. 

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

  351.       i++;
    352. 

  352.       int start= i;
    353. 

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

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

  355.     }
    356. 

  356.     tree u= "";
    357. 

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

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

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

  360.   }
    361. 

  361. 

  362.   /************************ special commands *********************************/
    363. 

  363.   i++;
    364. 

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

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

  366.     i++;
    367. 

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

  368.   }
    369. 

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

  370.     i++;
    371. 

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

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

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

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

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

  376.   }
    377. 

  377. 

  378.   /************************* normal commands *********************************/
    379. 

  379.   int start= i-1;
    380. 

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

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

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

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

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

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

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

  387.       return "";
    388. 

  388.     }
    389. 

  389.     i++; start= i;
    390. 

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

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

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

  393.   }
    394. 

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

  395. }
    396. 

  396. 

  397. static string
    398. 

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

  399.   int i;
    400. 

  400.   string r;
    401. 

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

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

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

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

  405.     }
    406. 

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

  407.   return r;
    408. 

  408. }
    409. 

  409. 

  410. tree
    411. 

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

  412.   int start= i;
    413. 

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

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

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

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

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

  418.   i++;
    419. 

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

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

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

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

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

  424. }
    425. 

  425. 

  426. static bool
    427. 

  427. is_math_environment (tree t) {
    428. 

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

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

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

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

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

  433.   int i, j;
    434. 

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

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

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

  437. 	break;
    438. 

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

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

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

  441. 	break;
    442. 

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

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

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

  445.     bool ok=
    446. 

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

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

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

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

  450.     return ok;
    451. 

  451.   }
    452. 

  452.   return false;
    453. 

  453. }
    454. 

  454. 

  455. static bool
    456. 

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

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

  458.   (void) remaining_arity;
    459. 

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

  460. }
    461. 

  461. 

  462. tree
    463. 

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

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

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

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

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

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

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

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

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

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

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

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

  475. 

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

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

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

  479.   }
    480. 

  480. 

  481.   bool mbox_flag=
    482. 

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

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

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

  485. 

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

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

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

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

  490. 

  491.   /************************ retrieve arguments *******************************/
    492. 

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

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

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

  495.     int j= i;
    496. 

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

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

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

  499.       j++;
    500. 

  500.       i=j;
    501. 

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

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

  503. 	t << opt;
    504. 

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

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

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

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

  508.       option= false;
    509. 

  509.     }
    510. 

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

  511.       bool text_arg=
    512. 

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

  513.       j++;
    514. 

  514.       i=j;
    515. 

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

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

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

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

  519.       }
    520. 

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

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

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

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

  524.       arity--;
    525. 

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

  526.     }
    527. 

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

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

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

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

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

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

  533. 	i= j+2;
    534. 

  534.       }
    535. 

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

  536.       option= false;
    537. 

  537.     }
    538. 

  538.     else {
    539. 

  539.       if (arity>0) {
    540. 

  540. 	i=j;
    541. 

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

  542. 	t << st;
    543. 

  543. 	u << st;
    544. 

  544. 	arity--;
    545. 

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

  546.       }
    547. 

  547.       else break;
    548. 

  548.     }
    549. 

  549.   }
    550. 

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

  551. 

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

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

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

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

  556.     command_arity (var)= 0;
    557. 

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

  558.   }
    559. 

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

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

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

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

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

  564.   }
    565. 

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

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

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

  568.     command_arity (var)= 0;
    569. 

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

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

  571.     command_arity (var)= 0;
    572. 

  572.   }
    573. 

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

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

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

  576.     command_arity (var)= 0;
    577. 

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

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

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

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

  581.     command_arity (var)= 0;
    582. 

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

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

  584.   }
    585. 

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

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

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

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

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

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

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

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

  593.     command_arity (var)= 0;
    594. 

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

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

  596.   }
    597. 

  597. 

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

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

  600.     int pos= 0;
    601. 

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

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

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

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

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

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

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

  608.   }
    609. 

  609. 

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

  611.   return t;
    612. 

  612. }
    613. 

  613. 

  614. tree
    615. 

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

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

  617.   bool option= false;
    618. 

  618. 

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

  620.   while (i<n) {
    621. 

  621.     int j=i;
    622. 

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

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

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

  625.       j++;
    626. 

  626.       i=j;
    627. 

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

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

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

  630.       option= false;
    631. 

  631.     }
    632. 

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

  633.       j++;
    634. 

  634.       i=j;
    635. 

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

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

  637.     }
    638. 

  638.     else break;
    639. 

  639.   }
    640. 

  640.   return t;
    641. 

  641. }
    642. 

  642. 

  643. /******************************************************************************
    644. 

  644. * Parsing verbatim text
    645. 

  645. ******************************************************************************/
    646. 

  646. 

  647. tree
    648. 

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

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

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

  651.   i+=e;
    652. 

  652.   return tree (CONCAT,
    653. 

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

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

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

  656. }
    657. 

  657. 

  658. /******************************************************************************
    659. 

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

  660. ******************************************************************************/
    661. 

  661. 

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

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

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

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

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

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

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

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

  670.   'y', 'z', 'z', 'z', ' ', ' ', ' ', ' ',
    671. 

  671.   'A', 'A', 'A', 'A', 'A', 'A', ' ', 'C',
    672. 

  672.   'E', 'E', 'E', 'E', 'I', 'I', 'I', 'I',
    673. 

  673.   'D', 'N', 'O', 'O', 'O', 'O', 'O', ' ',
    674. 

  674.   ' ', 'U', 'U', 'U', 'U', 'Y', ' ', ' ',
    675. 

  675.   'a', 'a', 'a', 'a', 'a', 'a', ' ', 'c',
    676. 

  676.   'e', 'e', 'e', 'e', 25 , 25 , 25 , 25 ,
    677. 

  677.   'd', 'n', 'o', 'o', 'o', 'o', 'o', ' ',
    678. 

  678.   ' ', 'u', 'u', 'u', 'u', 'y', ' ', ' '
    679. 

  679. };
    680. 

  680. 

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

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

  683.   '\'', 'v' , ' ' , '\'', 'v' , ' ' , 'H' , '\'',
    684. 

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

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

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

  687.   '\'', 'v' , ' ' , '\'', 'v' , ' ' , 'H' , '\'',
    688. 

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

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

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

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

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

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

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

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

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

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

  698. };
    699. 

  699. 

  700. tree
    701. 

  701. accented_to_Cork (tree t) {
    702. 

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

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

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

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

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

  707. 

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

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

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

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

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

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

  714. 	string ret_s (1);
    715. 

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

  716. 	return ret_s;
    717. 

  717.       }
    718. 

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

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

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

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

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

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

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

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

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

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

  728.     }
    729. 

  729.     else {
    730. 

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

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

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

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

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

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

  736.     }
    737. 

  737.   }
    738. 

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

  739.   return r;
    740. 

  740. }
    741. 

  741. 

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

  743. * Interface
    744. 

  744. ******************************************************************************/
    745. 

  745. 

  746. tree
    747. 

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

  748.   command_type ->extend ();
    749. 

  749.   command_arity->extend ();
    750. 

  750.   command_def  ->extend ();
    751. 

  751. 

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

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

  754.   array<string> a;
    755. 

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

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

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

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

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

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

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

  762. 	  i++;
    763. 

  763. 	i += 30;
    764. 

  764. 	start= i;
    765. 

  765. 	continue;
    766. 

  766.       }
    767. 

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

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

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

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

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

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

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

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

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

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

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

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

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

  780. 	{
    781. 

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

  782. 	  start= i;
    783. 

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

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

  785. 	    int start_name= i+1;
    786. 

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

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

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

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

  790.             string body;
    791. 

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

  792.             else {
    793. 

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

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

  795.               n= N(s);
    796. 

  796.               i= start + 1;
    797. 

  797.             }
    798. 

  798.             start= i;
    799. 

  799.           }
    800. 

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

  801.             i += 10;
    802. 

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

  803.             start= i;
    804. 

  804.           }
    805. 

  805. 	}
    806. 

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

  807.     }
    808. 

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

  809. 

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

  811.   tree t (CONCAT);
    812. 

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

  813.     int j=0;
    814. 

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

  815.       int start= j;
    816. 

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

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

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

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

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

  821.       else t << u;
    822. 

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

  823.     }
    824. 

  824.   }
    825. 

  825. 

  826.   if (change) {
    827. 

  827.     command_type ->merge ();
    828. 

  828.     command_arity->merge ();
    829. 

  829.     command_def  ->merge ();
    830. 

  830.   }
    831. 

  831.   else {
    832. 

  832.     command_type ->shorten ();
    833. 

  833.     command_arity->shorten ();
    834. 

  834.     command_def  ->shorten ();
    835. 

  835.   }
    836. 

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

  837.   return t;
    838. 

  838. }
    839. 

  839. 

  840. static bool
    841. 

  841. japanese_tex (string& s) {
    842. 

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

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

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

  845.     return true;
    846. 

  846.   }
    847. 

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

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

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

  850.     return true;
    851. 

  851.   }
    852. 

  852.   return false;
    853. 

  853. }
    854. 

  854. 

  855. static bool
    856. 

  856. korean_tex (string& s) {
    857. 

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

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

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

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

  861.     {
    862. 

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

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

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

  865.       return true;
    866. 

  866.     }
    867. 

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

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

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

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

  871.     {
    872. 

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

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

  874.       return true;
    875. 

  875.     }
    876. 

  876.   return false;
    877. 

  877. }
    878. 

  878. 

  879. static bool
    880. 

  880. chinese_tex (string& s) {
    881. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  898.     return true;
    899. 

  899.   }
    900. 

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

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

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

  903.     return true;
    904. 

  904.   }
    905. 

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

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

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

  908.     return true;
    909. 

  909.   }
    910. 

  910.   return false;
    911. 

  911. }
    912. 

  912. 

  913. static bool
    914. 

  914. taiwanese_tex (string& s) {
    915. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  930.     return true;
    931. 

  931.   }
    932. 

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

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

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

  935.     return true;
    936. 

  936.   }
    937. 

  937.   return false;
    938. 

  938. }
    939. 

  939. 

  940. tree
    941. 

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

  942.   s= dos_to_better (s);
    943. 

  943.   string lan= "";
    944. 

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

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

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

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

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

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

  950.   latex_parser ltx (unicode);
    951. 

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

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

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

  954. }
    955. 

  955. 

  956. tree
    957. 

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

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

  959. }
    960. 

  960.