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

/source/src/Data/Tree/tree_correct.cpp

http://itexmacs.googlecode.com/
C++ | 928 lines | 790 code | 57 blank | 81 comment | 610 complexity | 214589f22dad55d9ef29c79ba217c905 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     : tree_correct.cpp
    4. 

  4. * DESCRIPTION: make a tree syntactically match a drd
    5. 

  5. * COPYRIGHT  : (C) 2005  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 "tree_correct.hpp"
    13. 

  13. #include "tree_analyze.hpp"
    14. 

  14. #include "Scheme/object.hpp"
    15. 

  15. #include "packrat.hpp"
    16. 

  16. 

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

  18. * DRD based correction
    19. 

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

  20. 

  21. tree
    22. 

  22. drd_correct (drd_info drd, tree t) {
    23. 

  23.   if (is_atomic (t)) return t;
    24. 

  24.   else {
    25. 

  25.     int i, n= N(t);
    26. 

  26.     if (drd->contains (as_string (L(t))) &&
    27. 

  27. 	!drd->correct_arity (L(t), n))
    28. 

  28.       return "";
    29. 

  29.     tree r (t, n);
    30. 

  30.     for (i=0; i<n; i++)
    31. 

  31.       r[i]= drd_correct (drd, t[i]);
    32. 

  32.     return r;
    33. 

  33.   }
    34. 

  34. }
    35. 

  35. 

  36. /******************************************************************************
    37. 

  37. * Correct WITHs or WITH-like macros
    38. 

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

  39. 

  40. tree
    41. 

  41. with_correct (tree t) {
    42. 

  42.   if (is_atomic (t)) return t;
    43. 

  43.   else {
    44. 

  44.     //cout << "Correcting " << t << LF << INDENT;
    45. 

  45.     tree u (t, N(t));
    46. 

  46.     for (int k=0; k<N(t); k++)
    47. 

  47.       u[k]= with_correct (t[k]);
    48. 

  48.     array<tree> a= concat_decompose (u);
    49. 

  49.     int i, n= N(a);
    50. 

  50.     array<tree> r;
    51. 

  51.     for (i=0; i<n; i++) {
    52. 

  52.       if (is_with_like (a[i])) {
    53. 

  53. 	array<tree> b= with_decompose (a[i], with_body (a[i]));
    54. 

  54. 	int p= N(b), k1, k2;
    55. 

  55. 	for (k1=0; k1<p ; k1++)
    56. 

  56. 	  if (is_with_like (b[k1]) && with_similar_type (a[i], b[k1]));
    57. 

  57. 	  else break;
    58. 

  58. 	for (k2=p; k2>k1; k2--)
    59. 

  59. 	  if (is_with_like (b[k2-1]) && with_similar_type (a[i], b[k2-1]));
    60. 

  60. 	  else break;
    61. 

  61. 	array<tree> x;
    62. 

  62. 	if (0  < k1) x << range (b, 0, k1);
    63. 

  63. 	if (k1 < k2) x << with_recompose (a[i], range (b, k1, k2));
    64. 

  64. 	if (k2 < p ) x << range (b, k2, p);
    65. 

  65. 	if (N(x) == 0) continue;
    66. 

  66. 	if (N(r) != 0 &&
    67. 

  67. 	    is_with_like (r[N(r)-1]) &&
    68. 

  68. 	    with_same_type (r[N(r)-1], x[0]))
    69. 

  69. 	  {
    70. 

  70. 	    array<tree> c= concat_decompose (with_body (r[N(r)-1]));
    71. 

  71. 	    c << concat_decompose (with_body (x[0]));
    72. 

  72. 	    r[N(r)-1]= with_recompose (x[0], c);
    73. 

  73. 	    r << range (x, 1, N(x));
    74. 

  74. 	  }
    75. 

  75. 	else r << x;
    76. 

  76.       }
    77. 

  77.       else r << a[i];
    78. 

  78.     }
    79. 

  79.     //cout << UNINDENT << "Corrected " << t << " -> "
    80. 

  80.     //<< concat_recompose (r) << LF;
    81. 

  81.     return concat_recompose (r);
    82. 

  82.   }
    83. 

  83. }
    84. 

  84. 

  85. static tree
    86. 

  86. superfluous_with_correct (tree t, tree env) {
    87. 

  87.   if (is_atomic (t)) return t;
    88. 

  88.   else {
    89. 

  89.     //cout << "Superfluous correcting " << t << ", " << env << LF;
    90. 

  90.     if (is_compound (t, "body", 1))
    91. 

  91.       return compound ("body", superfluous_with_correct (t[0], env));
    92. 

  92.     if (is_func (t, WITH) && ((N(t) & 1) == 0))
    93. 

  93.       t= t * tree (WITH, "");
    94. 

  94.     tree r (t, N(t));
    95. 

  95.     for (int i=0; i<N(t); i++)
    96. 

  96.       r[i]= superfluous_with_correct
    97. 

  97. 	      (t[i], the_drd->get_env_child (t, i, env));
    98. 

  98.     if (is_compound (r, "math", 1) && r[0] == "") return "";
    99. 

  99.     else if (is_compound (r, "text", 1) && r[0] == "") return "";
    100. 

  100.     else if (is_compound (r, "math", 1) && drd_env_read (env, MODE) == "math")
    101. 

  101.       return r[0];
    102. 

  102.     else if (is_compound (r, "text", 1) && drd_env_read (env, MODE) == "text")
    103. 

  103.       return r[0];
    104. 

  104.     else if (is_func (r, WITH)) {
    105. 

  105.       for (int i=0; i+1<N(r); i+=2)
    106. 

  106. 	if (!is_atomic (r[i])) return r;
    107. 

  107. 	else if (drd_env_read (env, r[i]->label) != r[i+1]) return r;
    108. 

  108.       return r[N(r)-1];
    109. 

  109.     }
    110. 

  110.     else if (is_func (r, CONCAT)) {
    111. 

  111.       array<tree> a= concat_decompose (r);
    112. 

  112.       return concat_recompose (a);
    113. 

  113.     }
    114. 

  114.     return r;
    115. 

  115.   }
    116. 

  116. }
    117. 

  117. 

  118. tree
    119. 

  119. superfluous_with_correct (tree t) {
    120. 

  120.   with_drd drd (get_document_drd (t));
    121. 

  121.   return superfluous_with_correct (t, tree (WITH, MODE, "text"));
    122. 

  122. }
    123. 

  123. 

  124. /******************************************************************************
    125. 

  125. * Replace symbols by appropriate homoglyphs
    126. 

  126. ******************************************************************************/
    127. 

  127. 

  128. static array<tree>
    129. 

  129. homoglyph_correct (array<tree> a) {
    130. 

  130.   array<int>  tp= symbol_types (a);
    131. 

  131.   array<tree> r;
    132. 

  132.   //cout << a << ", " << tp << "\n";
    133. 

  133.   for (int i=0; i<N(a); i++)
    134. 

  134.     if (a[i] == "<minus>") r << tree ("-");
    135. 

  135.     else if (a[i] == "\\" || a[i] == "<backslash>") {
    136. 

  136.       int j1, j2;
    137. 

  137.       for (j1= i-1; j1>=0; j1--)
    138. 

  138. 	if (tp[j1] != SYMBOL_SKIP && tp[j1] != SYMBOL_SCRIPT) break;
    139. 

  139.       for (j2= i+1; j2<N(a); j2++)
    140. 

  140. 	if (tp[j2] != SYMBOL_SKIP && tp[j2] != SYMBOL_SCRIPT) break;
    141. 

  141.       if (j1 < 0 || j2 >= N(a));
    142. 

  142.       else if ((a[i] == "\\" ||
    143. 

  143. 		a[i] == "<backslash>") &&
    144. 

  144. 	       ((tp[j1] == SYMBOL_BASIC) ||
    145. 

  145. 		(tp[j1] == SYMBOL_POSTFIX)) &&
    146. 

  146. 	       ((tp[j2] == SYMBOL_BASIC) ||
    147. 

  147. 		(tp[j2] == SYMBOL_PREFIX)))
    148. 

  148. 	r << tree ("<setminus>");
    149. 

  149.       else r << a[i];
    150. 

  150.     }
    151. 

  151.     else if (is_func (a[i], NEG, 1) && is_atomic (a[i][0])) {
    152. 

  152.       string s= a[i][0]->label;
    153. 

  153.       if (s == "=") r << tree ("<neq>");
    154. 

  154.       else if (s == "<less>") r << tree ("<nless>");
    155. 

  155.       else if (s == "<gtr>") r << tree ("<ngtr>");
    156. 

  156.       else if (s == "<leq>") r << tree ("<nleq>");
    157. 

  157.       else if (s == "<geq>") r << tree ("<ngeq>");
    158. 

  158.       else if (s == "<leqslant>") r << tree ("<nleqslant>");
    159. 

  159.       else if (s == "<geqslant>") r << tree ("<ngeqslant>");
    160. 

  160.       else if (s == "<prec>") r << tree ("<nprec>");
    161. 

  161.       else if (s == "<succ>") r << tree ("<nsucc>");
    162. 

  162.       else if (s == "<preceq>") r << tree ("<npreceq>");
    163. 

  163.       else if (s == "<succeq>") r << tree ("<nsucceq>");
    164. 

  164.       else if (s == "<preccurlyeq>") r << tree ("<npreccurlyeq>");
    165. 

  165.       else if (s == "<succcurlyeq>") r << tree ("<nsucccurlyeq>");
    166. 

  166.       else if (s == "<rightarrow>") r << tree ("<nrightarrow>");
    167. 

  167.       else if (s == "<Rightarrow>") r << tree ("<nRightarrow>");
    168. 

  168.       else if (s == "<leftarrow>") r << tree ("<nleftarrow>");
    169. 

  169.       else if (s == "<Leftarrow>") r << tree ("<nLeftarrow>");
    170. 

  170.       else if (s == "<leftrightarrow>") r << tree ("<nleftrightarrow>");
    171. 

  171.       else if (s == "<Leftrightarrow>") r << tree ("<nLeftrightarrow>");
    172. 

  172.       else if (s == "<equiv>") r << tree ("<nequiv>");
    173. 

  173.       else if (s == "<sim>") r << tree ("<nsim>");
    174. 

  174.       else if (s == "<simeq>") r << tree ("<nsimeq>");
    175. 

  175.       else if (s == "<approx>") r << tree ("<napprox>");
    176. 

  176.       else if (s == "<cong>") r << tree ("<ncong>");
    177. 

  177.       else if (s == "<asymp>") r << tree ("<nasymp>");
    178. 

  178.       else if (s == "<in>") r << tree ("<nin>");
    179. 

  179.       else if (s == "<ni>") r << tree ("<nni>");
    180. 

  180.       else if (s == "<subset>") r << tree ("<nsubset>");
    181. 

  181.       else if (s == "<supset>") r << tree ("<nsupset>");
    182. 

  182.       else if (s == "<subseteq>") r << tree ("<nsubseteq>");
    183. 

  183.       else if (s == "<supseteq>") r << tree ("<nsupseteq>");
    184. 

  184.       else if (s == "<sqsubset>") r << tree ("<nsqsubset>");
    185. 

  185.       else if (s == "<sqsupset>") r << tree ("<nsqsupset>");
    186. 

  186.       else if (s == "<sqsubseteq>") r << tree ("<nsqsubseteq>");
    187. 

  187.       else if (s == "<sqsupseteq>") r << tree ("<nsqsupseteq>");
    188. 

  188.       else if (s == "<leadsto>") r << tree ("<nleadsto>");
    189. 

  189.       else r << a[i];
    190. 

  190.     }
    191. 

  191.     else if (a[i] == ":" && i+1 < N(a) && a[i+1] == "=") {
    192. 

  192.       r << tree ("<assign>");
    193. 

  193.       i++;
    194. 

  194.     }
    195. 

  195.     else r << a[i];
    196. 

  196.   return r;
    197. 

  197. }
    198. 

  198. 

  199. static tree
    200. 

  200. homoglyph_correct (tree t, string mode) {
    201. 

  201.   //cout << "Correct " << t << ", " << mode << "\n";
    202. 

  202.   tree r= t;
    203. 

  203.   if (is_compound (t)) {
    204. 

  204.     int i, n= N(t);
    205. 

  205.     r= tree (t, n);
    206. 

  206.     for (i=0; i<n; i++) {
    207. 

  207.       tree tmode= the_drd->get_env_child (t, i, MODE, mode);
    208. 

  208.       string smode= (is_atomic (tmode)? tmode->label: string ("text"));
    209. 

  209.       if (is_correctable_child (t, i))
    210. 

  210. 	r[i]= homoglyph_correct (t[i], smode);
    211. 

  211.       else r[i]= t[i];
    212. 

  212.     }
    213. 

  213.   }
    214. 

  214. 

  215.   if (mode == "math") {
    216. 

  216.     array<tree> a= concat_tokenize (r);
    217. 

  217.     a= homoglyph_correct (a);
    218. 

  218.     tree ret= concat_recompose (a);
    219. 

  219.     //if (ret != r) cout << "< " << r << " >" << LF
    220. 

  220.     //<< "> " << ret << " <" << LF;
    221. 

  221.     return ret;
    222. 

  222.   }
    223. 

  223.   else return r;
    224. 

  224. }
    225. 

  225. 

  226. tree
    227. 

  227. homoglyph_correct (tree t) {
    228. 

  228.   with_drd drd (get_document_drd (t));
    229. 

  229.   return homoglyph_correct (t, "text");
    230. 

  230. }
    231. 

  231. 

  232. /******************************************************************************
    233. 

  233. * Remove incorrect spaces and multiplications
    234. 

  234. ******************************************************************************/
    235. 

  235. 

  236. static array<tree>
    237. 

  237. superfluous_invisible_correct (array<tree> a) {
    238. 

  238.   array<int>  tp= symbol_types (a);
    239. 

  239.   array<tree> r;
    240. 

  240.   //cout << a << ", " << tp << "\n";
    241. 

  241.   for (int i=0; i<N(a); i++)
    242. 

  242.     if (a[i] == " " || a[i] == "*") {
    243. 

  243.       int j1, j2;
    244. 

  244.       for (j1= i-1; j1>=0; j1--)
    245. 

  245. 	if (tp[j1] != SYMBOL_SKIP && tp[j1] != SYMBOL_SCRIPT) break;
    246. 

  246. 	else if (a[j1] == " ") break;
    247. 

  247.       for (j2= i+1; j2<N(a); j2++)
    248. 

  248. 	if (tp[j2] != SYMBOL_SKIP && tp[j2] != SYMBOL_SCRIPT)
    249. 

  249. 	  if (a[j2] != " " && a[j2] != "*") break;
    250. 

  250.       //cout << "  " << i << ": " << j1 << ", " << j2
    251. 

  251.       //<< "; " << tp[j1] << ", " << tp[j2] << "\n";
    252. 

  252.       if (j1 < 0 || j2 >= N(a));
    253. 

  253.       else if (a[j1] == " " || a[j1] == "*");
    254. 

  254.       else if (tp[j1] == SYMBOL_PREFIX ||
    255. 

  255. 	       tp[j1] == SYMBOL_INFIX ||
    256. 

  256. 	       tp[j1] == SYMBOL_SEPARATOR ||
    257. 

  257.                tp[j1] == SYMBOL_PROBABLE_MIDDLE);
    258. 

  258.       else if (tp[j2] == SYMBOL_POSTFIX ||
    259. 

  259. 	       tp[j2] == SYMBOL_INFIX ||
    260. 

  260. 	       tp[j2] == SYMBOL_SEPARATOR ||
    261. 

  261.                tp[j2] == SYMBOL_PROBABLE_MIDDLE);
    262. 

  262.       else r << a[i];
    263. 

  263.     }
    264. 

  264.     else if (is_func (a[i], SQRT, 2) && a[i][1] == "")
    265. 

  265.       r << tree (SQRT, a[i][0]);
    266. 

  266.     else if (is_script (a[i]) && a[i][0] == "")
    267. 

  267.       r << tree (L(a[i]), "<nosymbol>");
    268. 

  268.     else r << a[i];
    269. 

  269.   return r;
    270. 

  270. }
    271. 

  271. 

  272. static tree
    273. 

  273. superfluous_invisible_correct (tree t, string mode) {
    274. 

  274.   //cout << "Correct " << t << ", " << mode << "\n";
    275. 

  275.   tree r= t;
    276. 

  276.   if (is_compound (t)) {
    277. 

  277.     int i, n= N(t);
    278. 

  278.     r= tree (t, n);
    279. 

  279.     for (i=0; i<n; i++) {
    280. 

  280.       tree tmode= the_drd->get_env_child (t, i, MODE, mode);
    281. 

  281.       string smode= (is_atomic (tmode)? tmode->label: string ("text"));
    282. 

  282.       //cout << "  " << i << ": " << is_correctable_child (t, i)
    283. 

  283.       //<< ", " << smode << "\n";
    284. 

  284.       if (is_func (t, WITH) && i != N(t)-1)
    285. 

  285. 	r[i]= t[i];
    286. 

  286.       else if (is_correctable_child (t, i))
    287. 

  287. 	r[i]= superfluous_invisible_correct (t[i], smode);
    288. 

  288.       else r[i]= t[i];
    289. 

  289.     }
    290. 

  290.   }
    291. 

  291.   
    292. 

  292.   if (is_func (r, CONCAT)) {
    293. 

  293.     bool ok= true;
    294. 

  294.     int i, found= -1;
    295. 

  295.     for (i=0; i<N(r); i++)
    296. 

  296.       if (is_compound (r[i], "hide-preamble") ||
    297. 

  297. 	  is_compound (r[i], "show-preamble"))
    298. 

  298. 	{
    299. 

  299. 	  ok= (found == -1);
    300. 

  300. 	  found= i;
    301. 

  301. 	}
    302. 

  302.       else if (!is_atomic (r[i])) ok= false;
    303. 

  303.       else {
    304. 

  304. 	string s= r[i]->label;
    305. 

  305. 	for (int j=0; j<N(s); j++)
    306. 

  306. 	  if (s[j] != ' ') ok= false;
    307. 

  307.       }
    308. 

  308.     if (ok) r= r[found];
    309. 

  309.   }
    310. 

  310. 

  311.   if (is_func (r, INACTIVE, 1) && is_func (r[0], RIGID))
    312. 

  312.     return r[0];
    313. 

  313.   else if (mode == "math") {
    314. 

  314.     array<tree> a= concat_tokenize (r);
    315. 

  315.     a= superfluous_invisible_correct (a);
    316. 

  316.     tree ret= concat_recompose (a);
    317. 

  317.     //if (ret != r) cout << "< " << r << " >" << LF
    318. 

  318.     //<< "> " << ret << " <" << LF;
    319. 

  319.     return ret;
    320. 

  320.   }
    321. 

  321.   else return r;
    322. 

  322. }
    323. 

  323. 

  324. tree
    325. 

  325. superfluous_invisible_correct (tree t) {
    326. 

  326.   with_drd drd (get_document_drd (t));
    327. 

  327.   return superfluous_invisible_correct (t, "text");
    328. 

  328. }
    329. 

  329. 

  330. /******************************************************************************
    331. 

  331. * Insert missing multiplications or function applications
    332. 

  332. ******************************************************************************/
    333. 

  333. 

  334. #define SURE_NOTHING     0
    335. 

  335. #define SURE_TIMES       1
    336. 

  336. #define SURE_SPACE       2
    337. 

  337. #define PROBABLE_TIMES   3
    338. 

  338. #define PROBABLE_SPACE   4
    339. 

  339. #define BOTH_WAYS        5
    340. 

  340. 

  341. struct invisible_corrector {
    342. 

  342.   int force;
    343. 

  343.   hashmap<string,int> times_before;
    344. 

  344.   hashmap<string,int> times_after;
    345. 

  345.   hashmap<string,int> space_before;
    346. 

  346.   hashmap<string,int> space_after;
    347. 

  347. 

  348. protected:
    349. 

  349.   bool is_letter_like (string s);
    350. 

  350.   bool contains_infix (tree t);
    351. 

  351.   bool contains_plus_like (tree t);
    352. 

  352.   void count_invisible (array<tree> a);
    353. 

  353.   void count_invisible (tree t, string mode);
    354. 

  354.   int  get_status (tree t, bool left, bool script_flag);
    355. 

  355.   array<tree> correct (array<tree> a);
    356. 

  356. 

  357. public:
    358. 

  358.   inline invisible_corrector (tree t, int force2):
    359. 

  359.     force (force2), times_before (0), times_after (0), space_after (0) {
    360. 

  360.       count_invisible (t, "text"); }
    361. 

  361.   tree correct (tree t, string mode);
    362. 

  362. };
    363. 

  363. 

  364. bool
    365. 

  365. invisible_corrector::is_letter_like (string s) {
    366. 

  366.   static language lan= math_language ("std-math");
    367. 

  367.   if (s != "" && is_iso_alpha (s)) return true;
    368. 

  368.   return lan->get_group (s) == "Letter-symbol";
    369. 

  369. }
    370. 

  370. 

  371. bool
    372. 

  372. invisible_corrector::contains_infix (tree t) {
    373. 

  373.   array<int> tp= symbol_types (concat_tokenize (t));
    374. 

  374.   for (int i=0; i<N(tp); i++)
    375. 

  375.     if (tp[i] == SYMBOL_INFIX)
    376. 

  376.       return true;
    377. 

  377.   return false;
    378. 

  378. }
    379. 

  379. 

  380. bool
    381. 

  381. invisible_corrector::contains_plus_like (tree t) {
    382. 

  382.   array<tree> a= concat_tokenize (t);
    383. 

  383.   for (int i=1; i<N(a)-1; i++)
    384. 

  384.     if (a[i] == "+" || a[i] == "-")
    385. 

  385.       return true;
    386. 

  386.   return false;
    387. 

  387. }
    388. 

  388. 

  389. void
    390. 

  390. invisible_corrector::count_invisible (array<tree> a) {
    391. 

  391.   array<int>  tp= symbol_types (a);
    392. 

  392.   for (int i=0; i<N(a); i++)
    393. 

  393.     if (is_atomic (a[i]) && is_letter_like (a[i]->label)) {
    394. 

  394.       int j1, j2;
    395. 

  395.       for (j1= i-1; j1>=0; j1--)
    396. 

  396. 	if (tp[j1] != SYMBOL_SKIP && tp[j1] != SYMBOL_SCRIPT) break;
    397. 

  397. 	else if (a[j1] == " ") break;
    398. 

  398.       for (j2= i+1; j2<N(a); j2++)
    399. 

  399. 	if (tp[j2] != SYMBOL_SKIP && tp[j2] != SYMBOL_SCRIPT) break;
    400. 

  400. 	else if (a[j2] == " ") break;
    401. 

  401.       string s= a[i]->label;
    402. 

  402.       if (j1 >= 0) {
    403. 

  403. 	if (a[j1] == "*")
    404. 

  404. 	  times_before (s)= times_before[s] + 1;
    405. 

  405. 	if (a[j1] == " ")
    406. 

  406. 	  space_before (s)= space_before[s] + 1;
    407. 

  407.       }
    408. 

  408.       if (j2 < N(a)) {
    409. 

  409. 	if (a[j2] == "*")
    410. 

  410. 	  times_after (s)= times_after[s] + 1;
    411. 

  411. 	if (a[j2] == " ")
    412. 

  412. 	  space_after (s)= space_after[s] + 1;
    413. 

  413.         // NOTE: this heuristic might not be a good idea,
    414. 

  414.         // because it inhibits the correction of QR -> Q*R,
    415. 

  415.         // if Q is a polynomial which is applied somewhere Q(1).
    416. 

  416.         // We might introduce a table 'apply_after'.
    417. 

  417. 	//if (is_around (a[j2]) && a[j2][0] == "(" &&
    418. 

  418.         //!contains_infix (a[j2][1]))
    419. 

  419.         //space_after (s)= space_after[s] + 1;
    420. 

  420.       }
    421. 

  421.     }
    422. 

  422. }
    423. 

  423. 

  424. void
    425. 

  425. invisible_corrector::count_invisible (tree t, string mode) {
    426. 

  426.   if (is_compound (t)) {
    427. 

  427.     int i, n= N(t);
    428. 

  428.     for (i=0; i<n; i++) {
    429. 

  429.       tree tmode= the_drd->get_env_child (t, i, MODE, mode);
    430. 

  430.       string smode= (is_atomic (tmode)? tmode->label: string ("text"));
    431. 

  431.       if (is_func (t, WITH) && i != N(t)-1);
    432. 

  432.       else if (is_correctable_child (t, i))
    433. 

  433. 	count_invisible (t[i], smode);
    434. 

  434.     }
    435. 

  435.   }
    436. 

  436.   if (mode == "math")
    437. 

  437.     count_invisible (concat_tokenize (t));
    438. 

  438. }
    439. 

  439. 

  440. int
    441. 

  441. invisible_corrector::get_status (tree t, bool left, bool script_flag) {
    442. 

  442.   if (is_atomic (t)) {
    443. 

  443.     static language lan= math_language ("std-math");
    444. 

  444.     string s= t->label;
    445. 

  445.     string g= lan->get_group (t->label);
    446. 

  446.     if (is_numeric (s))
    447. 

  447.       return (left? SURE_TIMES: PROBABLE_TIMES);
    448. 

  448.     else if (starts (g, "Unary-operator-textual"))
    449. 

  449.       return (left? SURE_SPACE: BOTH_WAYS);
    450. 

  450.     else if (starts (g, "Binary-operator"))
    451. 

  451.       return SURE_SPACE;
    452. 

  452.     else if (starts (g, "N-ary-operator"))
    453. 

  453.       return (left? SURE_SPACE: BOTH_WAYS);
    454. 

  454.     else if (is_letter_like (s)) {
    455. 

  455.       if (left) {
    456. 

  456. 	if (times_after[s] > 0 && space_after[s] == 0)
    457. 

  457. 	  return SURE_TIMES;
    458. 

  458. 	else if (space_after[s] > 0 && times_after[s] == 0)
    459. 

  459. 	  return SURE_SPACE;
    460. 

  460. 	else if (times_after[s] > space_after[s])
    461. 

  461. 	  return PROBABLE_TIMES;
    462. 

  462. 	else if (space_after[s] > times_after[s])
    463. 

  463. 	  return PROBABLE_SPACE;
    464. 

  464. 	else if (N(s)>1 && is_iso_alpha (s))
    465. 

  465. 	  return PROBABLE_SPACE;
    466. 

  466.         else if (script_flag)
    467. 

  467.           return PROBABLE_TIMES;
    468. 

  468. 	else return BOTH_WAYS;
    469. 

  469.       }
    470. 

  470.       else {
    471. 

  471. 	if (times_before[s] > space_before[s])
    472. 

  472. 	  return PROBABLE_TIMES;
    473. 

  473. 	else if (times_after[s] > 0 && space_after[s] == 0)
    474. 

  474. 	  return PROBABLE_TIMES;
    475. 

  475.         else if (script_flag && (N(s) == 1 || !is_iso_alpha (s)))
    476. 

  476.           return PROBABLE_TIMES;
    477. 

  477. 	else return BOTH_WAYS;
    478. 

  478.       }
    479. 

  479.     }
    480. 

  480.     else if (s == "<cdots>" || s == "<ldots>")
    481. 

  481.       return PROBABLE_TIMES;
    482. 

  482.     else return ((force > 0)? BOTH_WAYS: SURE_NOTHING);
    483. 

  483.   }
    484. 

  484.   else {
    485. 

  485.     if (is_around (t)) {
    486. 

  486.       if (left && contains_plus_like (t[1]))
    487. 

  487. 	return ((force > 0)? SURE_TIMES: PROBABLE_TIMES);
    488. 

  488.       else if (contains_plus_like (t[1]))
    489. 

  489. 	return ((force > 0)? PROBABLE_TIMES: BOTH_WAYS);
    490. 

  490.       else if (!contains_infix (t[1]))
    491. 

  491. 	return (left? BOTH_WAYS: SURE_SPACE);
    492. 

  492.       else return BOTH_WAYS;
    493. 

  493.     }
    494. 

  494.     else if (is_func (t, FRAC) ||
    495. 

  495. 	     is_func (t, SQRT))
    496. 

  496.       return (left? SURE_TIMES: BOTH_WAYS);
    497. 

  497.     else if (!left && is_func (t, BIG_AROUND, 2) &&
    498. 

  498.              (t[0] == "<sum>" || t[0] == "<amalg>" ||
    499. 

  499.               t[0] == "<oplus>" || t[0] == "<uplus>" ||
    500. 

  500.               t[0] == "<int>" || t[0] == "<oint>" ||
    501. 

  501.               t[0] == "<intlim>" || t[0] == "<ointlim>" ||
    502. 

  502.               t[0] == "<prod>" || t[0] == "<odot>" || t[0] == "<otimes>"))
    503. 

  503.       return PROBABLE_TIMES;
    504. 

  504.     else if (is_func (t, WIDE, 2))
    505. 

  505.       return get_status (t[0], left, script_flag);
    506. 

  506.     else if (is_func (t, WITH))
    507. 

  507.       return get_status (t[N(t)-1], left, script_flag);
    508. 

  508.     else if (N(t) == 0 && L(t) >= START_EXTENSIONS) {
    509. 

  509.       tree def= the_drd->get_syntax (L(t));
    510. 

  510.       if (is_func (def, MACRO, 1))
    511. 

  511.         return get_status (def[0], left, script_flag);
    512. 

  512.       else return SURE_NOTHING;
    513. 

  513.     }
    514. 

  514.     else return SURE_NOTHING;
    515. 

  515.   }
    516. 

  516. }
    517. 

  517. 

  518. static bool
    519. 

  519. admits_script (array<int> tp, int i) {
    520. 

  520.   i++;
    521. 

  521.   while (i<N(tp))
    522. 

  522.     if (tp[i] == SYMBOL_SCRIPT) return true;
    523. 

  523.     else if (tp[i] == SYMBOL_SKIP) i++;
    524. 

  524.     else return false;
    525. 

  525.   return false;
    526. 

  526. }
    527. 

  527. 

  528. array<tree>
    529. 

  529. invisible_corrector::correct (array<tree> a) {
    530. 

  530.   //cout << "Correct " << a << "\n";
    531. 

  531.   array<tree> r;
    532. 

  532.   array<int> tp= symbol_types (a);
    533. 

  533.   for (int i=0; i<N(a); i++) {
    534. 

  534.     r << a[i];
    535. 

  535.     if (a[i] != " " && tp[i] == SYMBOL_BASIC) {
    536. 

  536.       int j;
    537. 

  537.       for (j= i+1; j<N(a); j++)
    538. 

  538. 	if (tp[j] != SYMBOL_SKIP && tp[j] != SYMBOL_SCRIPT) break;
    539. 

  539. 	else if (a[j] == " ") break;
    540. 

  540.       if (j >= N(a) || a[j] == " " || tp[j] != SYMBOL_BASIC)
    541. 

  541. 	continue;
    542. 

  542.       
    543. 

  543.       string ins= "";
    544. 

  544.       int sti= get_status (a[i], true, admits_script (tp, i));
    545. 

  545.       int stj= get_status (a[j], false, admits_script (tp, j));
    546. 

  546.       //cout << "Pair (" << a[i] << ", " << a[j] << ")"
    547. 

  547.       //<< " -> (" << sti << ", " << stj << ")" << LF;
    548. 

  548.       if (sti == SURE_NOTHING || stj == SURE_NOTHING)
    549. 

  549. 	ins= "";
    550. 

  550.       else if (sti == SURE_TIMES && stj != SURE_SPACE)
    551. 

  551. 	ins= "*";
    552. 

  552.       else if (sti == SURE_SPACE && stj != SURE_TIMES)
    553. 

  553. 	ins= " ";
    554. 

  554.       else if (sti == PROBABLE_TIMES && stj == PROBABLE_TIMES)
    555. 

  555. 	ins= "*";
    556. 

  556.       else if (sti == PROBABLE_SPACE && stj == PROBABLE_SPACE)
    557. 

  557. 	ins= " ";
    558. 

  558.       else if (sti == PROBABLE_TIMES && stj == BOTH_WAYS)
    559. 

  559. 	ins= "*";
    560. 

  560.       else if (sti == PROBABLE_SPACE && stj == BOTH_WAYS)
    561. 

  561. 	ins= " ";
    562. 

  562.       else if (sti == BOTH_WAYS && stj == PROBABLE_TIMES)
    563. 

  563. 	ins= "*";
    564. 

  564.       else if (sti == BOTH_WAYS && stj == PROBABLE_SPACE)
    565. 

  565. 	ins= " ";
    566. 

  566.       else if (sti == BOTH_WAYS && stj == BOTH_WAYS && force == 1 &&
    567. 

  567. 	       (is_atomic (a[i]) || is_around (a[i])) &&
    568. 

  568. 	       (is_atomic (a[j]) || is_around (a[j])))
    569. 

  569. 	ins= "*";
    570. 

  570. 

  571.       if (is_around (a[j]))
    572. 

  572. 	if (ins == " " || (ins == "*" && force == -1))
    573. 

  573. 	  ins= "";
    574. 

  574.       if (a[j] == ".") ins= "";
    575. 

  575.       while (i+1 < N(a) && (is_func (a[i+1], RSUB, 1) ||
    576. 

  576. 			    is_func (a[i+1], RSUP, 1) ||
    577. 

  577. 			    is_func (a[i+1], RPRIME, 1))) {
    578. 

  578. 	i++;
    579. 

  579. 	r << a[i];
    580. 

  580.       }
    581. 

  581.       if (ins != "") r << tree (ins);
    582. 

  582.     }
    583. 

  583.   }
    584. 

  584.   return r;
    585. 

  585. }
    586. 

  586. 

  587. tree
    588. 

  588. invisible_corrector::correct (tree t, string mode) {
    589. 

  589.   //cout << "Correct " << t << ", " << mode << "\n";
    590. 

  590.   tree r= t;
    591. 

  591.   if (is_compound (t)) {
    592. 

  592.     int i, n= N(t);
    593. 

  593.     r= tree (t, n);
    594. 

  594.     for (i=0; i<n; i++) {
    595. 

  595.       tree tmode= the_drd->get_env_child (t, i, MODE, mode);
    596. 

  596.       string smode= (is_atomic (tmode)? tmode->label: string ("text"));
    597. 

  597.       if (is_func (t, WITH) && i != N(t)-1)
    598. 

  598. 	r[i]= t[i];
    599. 

  599.       else if (is_correctable_child (t, i))
    600. 

  600. 	r[i]= correct (t[i], smode);
    601. 

  601.       else r[i]= t[i];
    602. 

  602.     }
    603. 

  603.   }
    604. 

  604.   
    605. 

  605.   if (mode == "math") {
    606. 

  606.     array<tree> a= concat_tokenize (r);
    607. 

  607.     a= correct (a);
    608. 

  608.     tree ret= concat_recompose (a);
    609. 

  609.     //if (ret != r)
    610. 

  610.     //  cout << "<< " << r << " >>" << LF
    611. 

  611.     //       << ">> " << ret << " <<" << LF;
    612. 

  612.     return ret;
    613. 

  613.   }
    614. 

  614.   else return r;
    615. 

  615. }
    616. 

  616. 

  617. tree
    618. 

  618. missing_invisible_correct (tree t, int force) {
    619. 

  619.   // force = -1, only correct when sure, and when old markup is incorrect
    620. 

  620.   // force = 0 , only correct when pretty sure
    621. 

  621.   // force = 1 , correct whenever reasonable (used for LaTeX import)
    622. 

  622.   with_drd drd (get_document_drd (t));
    623. 

  623.   invisible_corrector corrector (t, force);
    624. 

  624.   //cout << "Times before " << corrector.times_before << "\n";
    625. 

  625.   //cout << "Space before " << corrector.space_before << "\n";
    626. 

  626.   //cout << "Times after  " << corrector.times_after  << "\n";
    627. 

  627.   //cout << "Space after  " << corrector.space_after  << "\n";
    628. 

  628.   return corrector.correct (t, "text");
    629. 

  629. }
    630. 

  630. 

  631. tree
    632. 

  632. missing_invisible_correct_twice (tree t, int force= -1) {
    633. 

  633.   tree u= missing_invisible_correct (t, force);
    634. 

  634.   if (u == t) return t;
    635. 

  635.   return missing_invisible_correct (u, force);
    636. 

  636. }
    637. 

  637. 

  638. /******************************************************************************
    639. 

  639. * Miscellaneous corrections
    640. 

  640. ******************************************************************************/
    641. 

  641. 

  642. tree
    643. 

  643. misc_math_correct (tree t) {
    644. 

  644.   if (is_atomic (t)) return t;
    645. 

  645.   else if (is_compound (t, "math", 1) && is_func (t[0], RSUB, 1))
    646. 

  646.     return tree (RSUB, compound ("math", misc_math_correct (t[0][0])));
    647. 

  647.   else if (is_compound (t, "math", 1) && is_func (t[0], RSUP, 1))
    648. 

  648.     return tree (RSUP, compound ("math", misc_math_correct (t[0][0])));
    649. 

  649.   else if (is_func (t, RSUB, 1) && is_func (t[0], RSUB, 1))
    650. 

  650.     return misc_math_correct (t[0]);
    651. 

  651.   else if (is_func (t, RSUB, 1) && is_func (t[0], RSUP, 1))
    652. 

  652.     return misc_math_correct (tree (RSUB, t[0][0]));
    653. 

  653.   else if (is_func (t, RSUP, 1) && is_func (t[0], RSUB, 1))
    654. 

  654.     return misc_math_correct (tree (RSUP, t[0][0]));
    655. 

  655.   else if (is_func (t, RSUP, 1) && is_func (t[0], RSUP, 1))
    656. 

  656.     return misc_math_correct (t[0]);
    657. 

  657.   else if (is_func (t, RSUP, 1) && is_func (t[0], RPRIME, 1))
    658. 

  658.     return misc_math_correct (t[0]);
    659. 

  659.   else if (is_script (t) && is_compound (t[0], "text", 1) &&
    660. 

  660.            is_atomic (t[0][0]) && is_alpha (t[0][0]->label))
    661. 

  661.     {
    662. 

  662.       if (N(t[0][0]->label) != 1) return tree (L(t), t[0][0]);
    663. 

  663.       else return tree (L(t), tree (WITH, "math-font-family", "trm",
    664. 

  664.                                     misc_math_correct (t[0])));
    665. 

  665.     }
    666. 

  666.   else if (is_compound (t, "math", 1)) {
    667. 

  667.     tree arg = misc_math_correct (t[0]);
    668. 

  668.     tree last= arg;
    669. 

  669.     if (is_concat (last) && N(last) > 0) last= last[N(last)-1];
    670. 

  670.     if (is_atomic (last) && N(last->label) > 0 &&
    671. 

  671.         is_punctuation (last->label [N(last->label)-1]))
    672. 

  672.       {
    673. 

  673.         string s= last->label;
    674. 

  674.         int i= N(s);
    675. 

  675.         while (i>0 && is_punctuation (s[i-1])) i--;
    676. 

  676.         if (i == N(s)) return compound ("math", arg);
    677. 

  677.         string tail= s (i, N(s));
    678. 

  678.         s= s (0, i);
    679. 

  679.         if (last == arg) {
    680. 

  680.           if (N(s) == 0) return tail;
    681. 

  681.           else return concat (compound ("math", s), tail);
    682. 

  682.         }
    683. 

  683.         else {
    684. 

  684.           tree cc= arg (0, N(arg) - 1);
    685. 

  685.           if (N(s) != 0) cc << tree (s);
    686. 

  686.           if (N(cc) == 1) cc= cc[0];
    687. 

  687.           return concat (compound ("math", cc), tail);
    688. 

  688.         }        
    689. 

  689.       }
    690. 

  690.     else return compound ("math", arg);
    691. 

  691.   }
    692. 

  692.   else {
    693. 

  693.     int i, n= N(t);
    694. 

  694.     tree r (t, n);
    695. 

  695.     for (i=0; i<n; i++)
    696. 

  696.       r[i]= misc_math_correct (t[i]);
    697. 

  697.     if (is_concat (r))
    698. 

  698.       r= concat_recompose (concat_decompose (r));
    699. 

  699.     return r;
    700. 

  700.   }
    701. 

  701. }
    702. 

  702. 

  703. /******************************************************************************
    704. 

  704. * Count errors
    705. 

  705. ******************************************************************************/
    706. 

  706. 

  707. static int
    708. 

  708. count_math_formula_errors (tree t, int mode) {
    709. 

  709.   if (mode == 1) return 1;
    710. 

  710.   if (packrat_correct ("std-math", "Main", t)) return 0;
    711. 

  711.   else {
    712. 

  712.     if (mode == 2) cout << "  ERROR> " << t << "\n";
    713. 

  713.     return 1;
    714. 

  714.   }
    715. 

  715. }
    716. 

  716. 

  717. static int
    718. 

  718. count_math_table_errors (tree t, int mode) {
    719. 

  719.   if (is_atomic (t)) return 0;
    720. 

  720.   else if (is_func (t, CELL, 1)) {
    721. 

  721.     if (t[0] == "" || t[0] == tree (DOCUMENT, "")) return 0;
    722. 

  722.     if (mode == 1) return 1;
    723. 

  723.     if (packrat_correct ("std-math", "Cell", t[0])) return 0;
    724. 

  724.     else {
    725. 

  725.       if (mode == 2) cout << "  ERROR> " << t << "\n";
    726. 

  726.       return 1;
    727. 

  727.     }
    728. 

  728.   }
    729. 

  729.   else {
    730. 

  730.     int sum= 0;
    731. 

  731.     for (int i=0; i<N(t); i++)
    732. 

  732.       sum += count_math_table_errors (t[i], mode);
    733. 

  733.     return sum;
    734. 

  734.   }
    735. 

  735. }
    736. 

  736. 

  737. int
    738. 

  738. count_math_errors (tree t, int mode) {
    739. 

  739.   if (is_atomic (t)) return 0;
    740. 

  740.   else {
    741. 

  741.     int sum= 0;
    742. 

  742.     for (int i=0; i<N(t); i++) {
    743. 

  743.       tree cmode= the_drd->get_env_child (t, i, MODE, "text");
    744. 

  744.       if (cmode != "math") sum += count_math_errors (t[i], mode);
    745. 

  745.       else {
    746. 

  746.         tree u= t[i];
    747. 

  747.         while (is_func (u, DOCUMENT, 1) ||
    748. 

  748.                is_func (u, TFORMAT) ||
    749. 

  749.                is_func (u, WITH))
    750. 

  750.           u= u[N(u)-1];
    751. 

  751.         if (is_func (u, TABLE)) sum += count_math_table_errors (u, mode);
    752. 

  752.         else sum += count_math_formula_errors (u, mode);
    753. 

  753.       }
    754. 

  754.     }
    755. 

  755.     return sum;
    756. 

  756.   }
    757. 

  757. }
    758. 

  758. 

  759. /******************************************************************************
    760. 

  760. * Print mathematical status
    761. 

  761. ******************************************************************************/
    762. 

  762. 

  763. static int count_formula= 0;
    764. 

  764. static int count_initial_errors= 0;
    765. 

  765. static int count_final_errors= 0;
    766. 

  766. 

  767. static int corrected_with= 0;
    768. 

  768. static int corrected_superfluous_with= 0;
    769. 

  769. static int corrected_brackets= 0;
    770. 

  770. static int corrected_move_brackets= 0;
    771. 

  771. static int corrected_misc= 0;
    772. 

  772. static int corrected_superfluous_invisible= 0;
    773. 

  773. static int corrected_homoglyph= 0;
    774. 

  774. static int corrected_missing_invisible= 0;
    775. 

  775. static int corrected_zealous_invisible= 0;
    776. 

  776. 

  777. void
    778. 

  778. math_status_cumul_sub (tree t, int& cumul, int& errors) {
    779. 

  779.   int new_errors= count_math_errors (t);
    780. 

  780.   cumul += (errors - new_errors);
    781. 

  781.   errors= new_errors;
    782. 

  782. }
    783. 

  783. 

  784. void
    785. 

  785. math_status_cumul (tree t) {
    786. 

  786.   with_drd drd (get_document_drd (t));
    787. 

  787.   if (is_func (t, DOCUMENT))
    788. 

  788.     for (int i=0; i<N(t); i++)
    789. 

  789.       if (is_compound (t[i], "body", 1)) {
    790. 

  790.         t= t[i][0];
    791. 

  791.         break;
    792. 

  792.       }
    793. 

  793. 

  794.   int errors= count_math_errors (t);
    795. 

  795.   count_formula += count_math_errors (t, 1);
    796. 

  796.   count_initial_errors += errors;
    797. 

  797.   t= with_correct (t);
    798. 

  798.   math_status_cumul_sub (t, corrected_with, errors);
    799. 

  799.   t= superfluous_with_correct (t);
    800. 

  800.   math_status_cumul_sub (t, corrected_superfluous_with, errors);
    801. 

  801.   t= upgrade_brackets (t);
    802. 

  802.   math_status_cumul_sub (t, corrected_brackets, errors);
    803. 

  803.   t= move_brackets (t);
    804. 

  804.   math_status_cumul_sub (t, corrected_move_brackets, errors);
    805. 

  805.   t= misc_math_correct (t);
    806. 

  806.   math_status_cumul_sub (t, corrected_misc, errors);
    807. 

  807.   t= superfluous_invisible_correct (t);
    808. 

  808.   math_status_cumul_sub (t, corrected_superfluous_invisible, errors);
    809. 

  809.   t= homoglyph_correct (t);
    810. 

  810.   math_status_cumul_sub (t, corrected_homoglyph, errors);
    811. 

  811.   t= superfluous_invisible_correct (t);
    812. 

  812.   math_status_cumul_sub (t, corrected_superfluous_invisible, errors);
    813. 

  813.   t= missing_invisible_correct (t);
    814. 

  814.   math_status_cumul_sub (t, corrected_missing_invisible, errors);
    815. 

  815.   count_final_errors += errors;
    816. 

  816.   //cout << "Errors= " << errors << "\n";
    817. 

  817.   //(void) count_math_errors (t, 2);
    818. 

  818.   t= missing_invisible_correct (t, 1);
    819. 

  819.   math_status_cumul_sub (t, corrected_zealous_invisible, errors);
    820. 

  820. }
    821. 

  821. 

  822. void
    823. 

  823. math_status_reset () {
    824. 

  824.   count_formula= 0;
    825. 

  825.   count_initial_errors= 0;
    826. 

  826.   count_final_errors= 0;
    827. 

  827.   corrected_with= 0;
    828. 

  828.   corrected_superfluous_with= 0;
    829. 

  829.   corrected_brackets= 0;
    830. 

  830.   corrected_move_brackets= 0;
    831. 

  831.   corrected_misc= 0;
    832. 

  832.   corrected_superfluous_invisible= 0;
    833. 

  833.   corrected_homoglyph= 0;
    834. 

  834.   corrected_missing_invisible= 0;
    835. 

  835. }
    836. 

  836. 

  837. void
    838. 

  838. math_status_print () {
    839. 

  839.   cout << "Formulas       : " << count_formula << "\n";
    840. 

  840.   cout << "Initial errors : " << count_initial_errors << "\n";
    841. 

  841.   cout << "Final errors   : " << count_final_errors << "\n";
    842. 

  842.   cout << "\n";
    843. 

  843.   cout << "With corrected                  : "
    844. 

  844.        << corrected_with << "\n";
    845. 

  845.   cout << "Superfluous with corrected      : "
    846. 

  846.        << corrected_superfluous_with << "\n";
    847. 

  847.   cout << "Upgraded brackets               : "
    848. 

  848.        << corrected_brackets << "\n";
    849. 

  849.   cout << "Moved brackets                  : "
    850. 

  850.        << corrected_move_brackets << "\n";
    851. 

  851.   cout << "Miscellaneous corrected         : "
    852. 

  852.        << corrected_misc << "\n";
    853. 

  853.   cout << "Superfluous invisible corrected : "
    854. 

  854.        << corrected_superfluous_invisible << "\n";
    855. 

  855.   cout << "Homoglyphs corrected            : "
    856. 

  856.        << corrected_homoglyph << "\n";
    857. 

  857.   cout << "Missing invisible corrected     : "
    858. 

  858.        << corrected_missing_invisible << "\n";
    859. 

  859.   cout << "Zealous invisible corrected     : "
    860. 

  860.        << corrected_zealous_invisible << "\n";
    861. 

  861.   cout << "\n";
    862. 

  862. }
    863. 

  863. 

  864. /******************************************************************************
    865. 

  865. * Master routines
    866. 

  866. ******************************************************************************/
    867. 

  867. 

  868. bool
    869. 

  869. enabled_preference (string s) {
    870. 

  870.   return call ("get-preference", s) == object ("on");
    871. 

  871. }
    872. 

  872. 

  873. tree
    874. 

  874. latex_correct (tree t) {
    875. 

  875.   // NOTE: matching brackets corrected in upgrade_tex
    876. 

  876.   t= misc_math_correct (t);
    877. 

  877.   //if (enabled_preference ("remove superfluous invisible"))
    878. 

  878.   t= superfluous_invisible_correct (t);
    879. 

  879.   //if (enabled_preference ("homoglyph correct"))
    880. 

  880.   t= homoglyph_correct (t);
    881. 

  881.   //if (enabled_preference ("remove superfluous invisible"))
    882. 

  882.   t= superfluous_invisible_correct (t);
    883. 

  883.   //if (enabled_preference ("insert missing invisible"))
    884. 

  884.   t= missing_invisible_correct_twice (t);
    885. 

  885.   //if (enabled_preference ("insert missing invisible"))
    886. 

  886.   t= missing_invisible_correct (t, 1);
    887. 

  887.   t= downgrade_big (t);
    888. 

  888.   return t;
    889. 

  889. }
    890. 

  890. 

  891. tree
    892. 

  892. automatic_correct (tree t, string version) {
    893. 

  893.   if (version_inf_eq (version, "1.0.7.9")) {
    894. 

  894.     t= misc_math_correct (t);
    895. 

  895.     if (enabled_preference ("remove superfluous invisible"))
    896. 

  896.       t= superfluous_invisible_correct (t);
    897. 

  897.     if (enabled_preference ("homoglyph correct"))
    898. 

  898.       t= homoglyph_correct (t);
    899. 

  899.     if (enabled_preference ("remove superfluous invisible"))
    900. 

  900.       t= superfluous_invisible_correct (t);
    901. 

  901.     if (enabled_preference ("insert missing invisible"))
    902. 

  902.       t= missing_invisible_correct_twice (t);
    903. 

  903.     if (enabled_preference ("zealous invisible correct"))
    904. 

  904.       t= missing_invisible_correct (t, 1);
    905. 

  905.   }
    906. 

  906.   t= downgrade_big (t);
    907. 

  907.   return t;
    908. 

  908. }
    909. 

  909. 

  910. tree
    911. 

  911. manual_correct (tree t) {
    912. 

  912.   t= with_correct (t);
    913. 

  913.   t= superfluous_with_correct (t);
    914. 

  914.   t= upgrade_brackets (t);
    915. 

  915.   t= misc_math_correct (t);
    916. 

  916.   if (enabled_preference ("manual remove superfluous invisible"))
    917. 

  917.     t= superfluous_invisible_correct (t);
    918. 

  918.   if (enabled_preference ("manual homoglyph correct"))
    919. 

  919.     t= homoglyph_correct (t);
    920. 

  920.   if (enabled_preference ("manual remove superfluous invisible"))
    921. 

  921.     t= superfluous_invisible_correct (t);
    922. 

  922.   if (enabled_preference ("manual insert missing invisible"))
    923. 

  923.     t= missing_invisible_correct_twice (t);
    924. 

  924.   if (enabled_preference ("manual zealous invisible correct"))
    925. 

  925.     t= missing_invisible_correct (t, 1);
    926. 

  926.   t= downgrade_big (t);
    927. 

  927.   return t;
    928. 

  928. }
    929. 

  929.