w32tex
About: TeX Live provides a comprehensive TeX system including all the major TeX-related programs, macro packages, and fonts that are free software. Windows sources.
  Fossies Dox: w32tex-src.tar.xz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

convert.c
Go to the documentation of this file.
1 /* convert.c - high level routines for LaTeX to RTF conversion
2 
3 Copyright (C) 2002 The Free Software Foundation
4 
5 This program is free software; you can redistribute it and/or
6 modify it under the terms of the GNU General Public License
7 as published by the Free Software Foundation; either version 2
8 of the License, or (at your option) any later version.
9 
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14 
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18 
19 This file is available from http://sourceforge.net/projects/latex2rtf/
20 
21 TeX has six modes:
22 
23  MODE_VERTICAL Building the main vertical list, from which the
24  pages of output are derived
25 
26  MODE_INTERNAL_VERTICAL Building a vertical list from a vbox
27 
28  MODE_HORIZONTAL Building a horizontal list for a paragraph
29 
30  MODE_RESTICTED_HORIZONTAL Building a horizontal list for an hbox
31 
32  MODE_MATH Building a mathematical formula to be placed in a
33  horizontal list
34 
35  MODE_DISPLAYMATH Building a mathematical formula to be placed on a
36  line by itself, temporarily interrupting the current paragraph
37 
38 LaTeX has three modes: paragraph mode, math mode, or left-to-right mode.
39 This is not a particularly useful, since paragraph mode is a combination of
40 vertical and horizontal modes.
41 
42 Why bother keeping track of modes? Mostly so that paragraph indentation gets handled
43 correctly, as well as vertical and horizontal space.
44 
45 */
46 
47 #include <string.h>
48 #include <stdlib.h>
49 #include <errno.h>
50 #include <ctype.h>
51 #include "main.h"
52 #include "convert.h"
53 #include "commands.h"
54 #include "chars.h"
55 #include "funct1.h"
56 #include "l2r_fonts.h"
57 #include "stack.h"
58 #include "tables.h"
59 #include "equation.h"
60 #include "direct.h"
61 #include "ignore.h"
62 #include "cfg.h"
63 #include "encode.h"
64 #include "util.h"
65 #include "parser.h"
66 #include "lengths.h"
67 #include "counters.h"
68 #include "preamble.h"
69 
70 static void TranslateCommand(); /* converts commands */
71 
72 static int ret = 0;
74 
75 char TexModeName[7][25] = {"bad", "internal vertical", "horizontal",
76  "restricted horizontal", "math", "displaymath","vertical"};
77 
78 void SetTexMode(int mode)
79 {
80  if (abs(mode) != g_TeX_mode)
81  diagnostics(4, "TeX mode changing from [%s] -> [%s]", TexModeName[g_TeX_mode], TexModeName[abs(mode)]);
82 
83  if (mode < 0) { /* hack to allow CmdStartParagraph to set mode directly */
84  g_TeX_mode = -mode;
85  return;
86  }
87 
90 
92  CmdEndParagraph(0);
93 
94  g_TeX_mode = mode;
95 }
96 
97 int GetTexMode(void)
98 {
99  return g_TeX_mode;
100 }
101 
102 void
103 ConvertString(char *string)
104 /******************************************************************************
105  purpose : converts string in TeX-format to Rtf-format
106  ******************************************************************************/
107 {
108  char temp[256];
109 
110  if (string==NULL) return;
111 
112  if (strlen(string)<250)
113  strncpy(temp,string,250);
114  else {
115  strncpy(temp,string,125);
116  strncpy(temp+125,"\n...\n", 5);
117  strncpy(temp+130,string+strlen(string)-125,125);
118  temp[255] = '\0';
119  }
120 
121  if (PushSource(NULL, string) == 0) {
122  diagnostics(4, "Entering Convert() from StringConvert()\n******\n%s\n*****",temp);
123 
124  while (StillSource())
125  Convert();
126 
127  PopSource();
128  diagnostics(4, "Exiting Convert() from StringConvert()");
129  }
130 }
131 
132 void
134 /******************************************************************************
135  purpose : converts string in TeX-format to Rtf-format
136  according to the alltt environment, which is like
137  verbatim environment except that \, {, and } have
138  their usual meanings
139 ******************************************************************************/
140 {
141  char cThis;
142 
143  if (s==NULL) return;
144  diagnostics(4, "Entering Convert() from StringAllttConvert()");
145 
146  if(PushSource(NULL, s)==0) {
147 
148  while (StillSource()) {
149 
150  cThis = getRawTexChar(); /* it is a verbatim like environment */
151  switch (cThis) {
152 
153  case '\\':
154  PushLevels();
156  CleanStack();
157  break;
158 
159  case '{':
160  PushBrace();
161  fprintRTF("{");
162  break;
163 
164  case '}':
166  fprintRTF("}");
167  break;
168 
169  default:
170  putRtfChar(cThis);
171  break;
172  }
173  }
174  PopSource();
175  }
176  diagnostics(4, "Exiting Convert() from StringAllttConvert()");
177 }
178 
179 static int Knj=0;
180 
181 void
183 /****************************************************************************
184 purpose: converts inputfile and writes result to outputfile
185 globals: fTex, fRtf and all global flags for convert (see above)
186  ****************************************************************************/
187 {
188  char cThis = '\n';
189  char cLast = '\0';
190  char cNext;
191  int mode, count,pending_new_paragraph;
192 
193  diagnostics(3, "Entering Convert ret = %d", ret);
194  RecursionLevel++;
195  PushLevels();
196 
197  while ((cThis = getTexChar()) && cThis != '\0') {
198 
199  if(isknj(cThis)) {
200  if(Knj == 0) {
201  Knj = 1;
202  fprintRTF("{\\f99 ");
203  }
204  fputc(cThis, fRtf);
205  cThis = getTexChar();
206  fputc(cThis, fRtf);
207  continue;
208  }
209 
210  if(Knj == 1) {
211  Knj = 0;
212  fprintRTF("}");
213  }
214  if (cThis == '\n')
215  diagnostics(5, "Current character is '\\n' mode = %d ret = %d level = %d", GetTexMode(), ret, RecursionLevel);
216  else
217  diagnostics(5, "Current character is '%c' mode = %d ret = %d level = %d", cThis, GetTexMode(), ret, RecursionLevel);
218 
219  mode = GetTexMode();
220 
221  pending_new_paragraph--;
222 
223  switch (cThis) {
224 
225  case '\\':
226  PushLevels();
227 
229 
230  CleanStack();
231 
232  if (ret > 0) {
233  diagnostics(5, "Exiting Convert via TranslateCommand ret = %d level = %d", ret, RecursionLevel);
234  ret--;
235  RecursionLevel--;
236  return;
237  }
238  break;
239 
240 
241  case '{':
243 
244  CleanStack();
245  PushBrace();
246  fprintRTF("{");
247  break;
248 
249  case '}':
250  CleanStack();
252  fprintRTF("}");
253  if (ret > 0) {
254  diagnostics(5, "Exiting Convert via '}' ret = %d level = %d", ret, RecursionLevel);
255  ret--;
256  RecursionLevel--;
257  return;
258  }
259  break;
260 
261  case ' ':
263  cThis = cLast;
264 
265  else if ( cLast != ' ' && cLast != '\n' ) {
266 
268  fprintRTF("\\~");
269  else
270  fprintRTF(" ");
271  }
272 
273  break;
274 
275  case '\n':
276  tabcounter = 0;
277 
278  if (mode==MODE_MATH || mode==MODE_DISPLAYMATH) {
279 
280  cNext = getNonBlank();
281  ungetTexChar(cNext);
282 
283  } else {
284  cNext = getNonSpace();
285 
286  if (cNext == '\n') { /* new paragraph ... skip all ' ' and '\n' */
287  pending_new_paragraph=2;
288  CmdEndParagraph(0);
289  cNext = getNonBlank();
290  ungetTexChar(cNext);
291 
292  } else { /* add a space if needed */
293  ungetTexChar(cNext);
294  if (mode != MODE_VERTICAL && cLast != ' ')
295  fprintRTF(" ");
296  }
297  }
298  break;
299 
300 
301  case '$':
302  cNext = getTexChar();
303  diagnostics(5,"Processing $, next char <%c>",cNext);
304 
305  if (cNext == '$' && GetTexMode() != MODE_MATH)
307  else {
308  ungetTexChar(cNext);
310  }
311 
312  /*
313  Formulas need to close all Convert() operations when they end
314  This works for \begin{equation} but not $$ since the BraceLevel
315  and environments don't get pushed properly. We do it explicitly here.
316  */
317  /*
318  if (GetTexMode() == MODE_MATH || GetTexMode() == MODE_DISPLAYMATH)
319  PushBrace();
320  else {
321  ret = RecursionLevel - PopBrace();
322  if (ret > 0) {
323  ret--;
324  RecursionLevel--;
325  diagnostics(5, "Exiting Convert via Math ret = %d", ret);
326  return;
327  }
328  }
329  */
330  break;
331 
332  case '&':
333  if (g_processing_arrays) {
335  break;
336  }
337 
338  if (GetTexMode() == MODE_MATH || GetTexMode() == MODE_DISPLAYMATH) { /* in eqnarray */
339  fprintRTF("\\tab ");
341  break;
342  }
343 
344  if (g_processing_tabular) { /* in tabular */
345  actCol++;
346  fprintRTF("\\cell\\pard\\intbl\\q%c ", colFmt[actCol]);
347  break;
348  }
349  fprintRTF("&");
350  break;
351 
352  case '~':
353  fprintRTF("\\~");
354  break;
355 
356  case '^':
357  CmdSuperscript(0);
358  break;
359 
360  case '_':
361  CmdSubscript(0);
362  break;
363 
364  case '-':
365  if (mode == MODE_MATH || mode == MODE_DISPLAYMATH)
366  fprintRTF("-");
367  else {
369 
370  count = getSameChar('-')+1;
371 
372  if (count == 1)
373  fprintRTF("-");
374  else if (count == 2)
375  fprintRTF("\\endash ");
376  else if (count == 3)
377  fprintRTF("\\emdash ");
378  else
379  while (count--) fprintRTF("-");
380  }
381  break;
382 
383  case '|':
384  if (mode == MODE_MATH || mode == MODE_DISPLAYMATH)
385  fprintRTF("|");
386  else
387  fprintRTF("\\emdash ");
388  break;
389 
390  case '\'':
391  if (mode == MODE_MATH || mode == MODE_DISPLAYMATH)
392  fprintRTF("'");
393  else {
395  count = getSameChar('\'')+1;
396  if (count == 2)
397  fprintRTF("\\rdblquote ");
398  else
399  while (count--) fprintRTF("\\rquote ");
400  }
401  break;
402 
403  case '`':
405  count = getSameChar('`')+1;
406  if (count == 2)
407  fprintRTF("\\ldblquote ");
408  else
409  while (count--) fprintRTF("\\lquote ");
410  break;
411 
412  case '\"':
414  if (GermanMode)
415  TranslateGerman();
416  else
417  fprintRTF("\"");
418  break;
419 
420  case '<':
422  if (GetTexMode() == MODE_HORIZONTAL){
423  cNext = getTexChar();
424  if (cNext == '<') {
425  if (FrenchMode) { /* not quite right */
426  skipSpaces();
427  cNext = getTexChar();
428  if (cNext == '~')
429  skipSpaces();
430  else
431  ungetTexChar(cNext);
432  fprintRTF("\\'ab\\~");
433 
434  } else
435  fprintRTF("\\'ab");
436  } else {
437  ungetTexChar(cNext);
438  fprintRTF("<");
439  }
440  } else
441  fprintRTF("<");
442 
443  break;
444 
445  case '>':
447  if (GetTexMode() == MODE_HORIZONTAL){
448  cNext = getTexChar();
449  if (cNext == '>')
450  fprintRTF("\\'bb");
451  else {
452  ungetTexChar(cNext);
453  fprintRTF(">");
454  }
455  } else
456  fprintRTF(">");
457  break;
458 
459  case '!':
460  if (mode == MODE_MATH || mode == MODE_DISPLAYMATH)
461  fprintRTF("!");
462  else {
464  if ((cNext = getTexChar()) && cNext == '`') {
465  fprintRTF("\\'a1 ");
466  } else {
467  fprintRTF("! ");
468  ungetTexChar(cNext);
469  }
470  }
471  break;
472 
473  case '?':
475  if ((cNext = getTexChar()) && cNext == '`') {
476  fprintRTF("\\'bf ");
477  } else {
478  fprintRTF("? ");
479  ungetTexChar(cNext);
480  }
481  break;
482 
483  case ':':
484  if (mode == MODE_MATH || mode == MODE_DISPLAYMATH)
485  fprintRTF(":");
486  else {
488  if (FrenchMode)
489  fprintRTF("\\~:");
490  else
491  fprintRTF(":");
492  }
493  break;
494 
495  case '.':
496  if (mode == MODE_MATH || mode == MODE_DISPLAYMATH)
497  fprintRTF(".");
498  else {
500  fprintRTF(".");
501 
502  /* try to simulate double spaces after sentences */
503  cNext = getTexChar();
504  if (0 && cNext == ' ' && (isalpha((int)cLast) && !isupper((int) cLast)))
505  fprintRTF(" ");
506  ungetTexChar(cNext);
507  }
508  break;
509 
510  case '\t':
511  diagnostics(WARNING__, "This should not happen, ignoring \\t");
512  cThis = ' ';
513  break;
514 
515  case '\r':
516  diagnostics(WARNING__, "This should not happen, ignoring \\r");
517  cThis = ' ';
518  break;
519 
520  case '%':
521  diagnostics(WARNING__, "This should not happen, ignoring %%");
522  cThis = ' ';
523  break;
524 
525  case '(':
527  fprintRTF("\\\\(");
528  else
529  fprintRTF("(");
530  break;
531 
532  case ')':
534  fprintRTF("\\\\)");
535  else
536  fprintRTF(")");
537  break;
538 
539  case ';':
541  fprintRTF("\\\\;");
542  else
543  if (FrenchMode)
544  fprintRTF("\\~;");
545  else
546  fprintRTF(";");
547  break;
548 
549  case ',':
551  fprintRTF("\\\\,");
552  else
553  fprintRTF(",");
554  break;
555 
556  default:
557  if (mode == MODE_MATH || mode == MODE_DISPLAYMATH) {
558  if (('a' <= cThis && cThis <= 'z') || ('A' <= cThis && cThis <= 'Z'))
559  fprintRTF("{\\i %c}", cThis);
560  else
561  fprintRTF("%c", cThis);
562 
563  } else {
564 
566  fprintRTF("%c", cThis);
567  }
568  break;
569  }
570 
571  tabcounter++;
572  cLast = cThis;
573  }
574  RecursionLevel--;
575  diagnostics(5, "Exiting Convert via exhaustion ret = %d", ret);
576 }
577 
578 void
580 /****************************************************************************
581 purpose: The function is called on a backslash in input file and
582  tries to call the command-function for the following command.
583 returns: success or not
584 globals: fTex, fRtf, command-functions have side effects or recursive calls;
585  global flags for convert
586  ****************************************************************************/
587 {
588  char cCommand[MAXCOMMANDLEN];
589  int i,mode;
590  int cThis;
591 
592  cThis = getTexChar();
593  mode = GetTexMode();
594 
595  diagnostics(5, "Beginning TranslateCommand() \\%c", cThis);
596 
597  switch (cThis) {
598  case '}':
600  fprintRTF("\\}");
601  return;
602  case '{':
604  fprintRTF("\\{");
605  return;
606  case '#':
608  fprintRTF("#");
609  return;
610  case '$':
612  fprintRTF("$");
613  return;
614  case '&':
616  fprintRTF("&");
617  return;
618  case '%':
620  fprintRTF("%%");
621  return;
622  case '_':
624  fprintRTF("_");
625  return;
626 
627  case '\\': /* \\[1mm] or \\*[1mm] possible */
628  CmdSlashSlash(0);
629  return;
630 
631  case ' ':
632  case '\n':
634  fprintRTF(" "); /* ordinary interword space */
635  skipSpaces();
636  return;
637 
638 /* \= > < \+ \- \' \` all have different meanings in a tabbing environment */
639 
640  case '-':
643  (void) PopBrace();
644  PushBrace();
645  } else
646  fprintRTF("\\-");
647  return;
648 
649  case '+':
652  (void) PopBrace();
653  PushBrace();
654  }
655  return;
656 
657  case '<':
660  (void) PopBrace();
661  PushBrace();
662  }
663  return;
664 
665  case '>':
668  (void) PopBrace();
669  CmdTabjump();
670  PushBrace();
671  } else
672  CmdSpace(0.50); /* medium space */
673  return;
674 
675  case '`':
678  (void) PopBrace();
679  PushBrace();
680  } else
682  return;
683 
684  case '\'':
687  (void) PopBrace();
688  PushBrace();
689  return;
690  } else
691  CmdRApostrophChar(0); /* char ' =?= \' */
692  return;
693 
694  case '=':
697  (void) PopBrace();
698  CmdTabset();
699  PushBrace();
700  }
701  else
702  CmdMacronChar(0);
703  return;
704 
705  case '~':
707  CmdTildeChar(0);
708  return;
709  case '^':
711  CmdHatChar(0);
712  return;
713  case '.':
715  CmdDotChar(0);
716  return;
717  case '\"':
719  CmdUmlauteChar(0);
720  return;
721  case '(':
723  /*PushBrace();*/
724  return;
725  case '[':
727  /*PushBrace();*/
728  return;
729  case ')':
731  /*ret = RecursionLevel - PopBrace();*/
732  return;
733  case ']':
735  /*ret = RecursionLevel - PopBrace();*/
736  return;
737  case '/':
738  CmdIgnore(0); /* italic correction */
739  return;
740  case '!':
741  CmdIgnore(0); /* \! negative thin space */
742  return;
743  case ',':
745  CmdSpace(0.33); /* \, produces a small space */
746  return;
747  case ';':
749  CmdSpace(0.75); /* \; produces a thick space */
750  return;
751  case '@':
752  CmdIgnore(0); /* \@ produces an "end of sentence" space */
753  return;
754  case '3':
756  fprintRTF("{\\'df}"); /* german symbol '' */
757  return;
758  }
759 
760 
761  /* LEG180498 Commands consist of letters and can have an optional * at the end */
762  for (i = 0; i < MAXCOMMANDLEN; i++) {
763  if (!isalpha((int)cThis) && (cThis != '*')) {
764  bool found_nl = FALSE;
765 
766  if (cThis == '%'){ /* put the % back and get the next char */
767  ungetTexChar('%');
768  cThis=getTexChar();
769  }
770 
771  /* all spaces after commands are ignored, a single \n may occur */
772  while (cThis == ' ' || (cThis == '\n' && !found_nl)) {
773  if (cThis == '\n')
774  found_nl = TRUE;
775  cThis = getTexChar();
776  }
777 
778  ungetTexChar((char)cThis); /* put back first non-space char after command */
779  break; /* done skipping spaces */
780  } else
781  cCommand[i] = cThis;
782 
783  cThis = getRawTexChar(); /* Necessary because % ends a command */
784  }
785 
786  cCommand[i] = '\0'; /* mark end of string with zero */
787  diagnostics(5, "TranslateCommand() <%s>", cCommand);
788 
789  if (i == 0)
790  return;
791 
792  if (strcmp(cCommand,"begin")==0){
793  fprintRTF("{");
794  PushBrace();
795  }
796 
797  if (CallCommandFunc(cCommand)){ /* call handling function for command */
798  if (strcmp(cCommand,"end")==0) {
800  fprintRTF("}");
801  }
802  return;
803  }
804 
805  if (TryDirectConvert(cCommand)) return;
806 
807  if (TryVariableIgnore(cCommand)) return;
808 
809  diagnostics(WARNING__, "Command \\%s not found - ignored", cCommand);
810 }
static int isknj(int c)
Definition: allow5c.c:29
#define count(a)
Definition: aptex-macros.h:781
#define mode
Definition: aptex-macros.h:510
void CmdRApostrophChar(int code)
Definition: chars.c:165
void CmdTildeChar(int code)
Definition: chars.c:356
void CmdHatChar(int code)
Definition: chars.c:252
void CmdLApostrophChar(int code)
Definition: chars.c:104
void CmdUmlauteChar(int code)
Definition: chars.c:41
void CmdMacronChar(int code)
Definition: chars.c:231
void CmdDotChar(int code)
#define MODE_HORIZONTAL
Definition: convert.h:2
#define MODE_MATH
Definition: convert.h:4
#define MODE_RESTRICTED_HORIZONTAL
Definition: convert.h:3
#define MODE_VERTICAL
Definition: convert.h:6
#define MODE_DISPLAYMATH
Definition: convert.h:5
@ FALSE
Definition: dd.h:101
@ TRUE
Definition: dd.h:102
bool TryDirectConvert(char *command)
Definition: direct.c:77
char * strncpy()
int strcmp()
Definition: coll.cpp:143
char * temp
Definition: dvidvi.c:137
void CmdSubscript(int code)
Definition: equation.c:1072
void CmdSuperscript(int code)
Definition: equation.c:1049
void CmdEquation(int code)
Definition: equation.c:640
int g_equation_column
Definition: equation.c:46
#define EQN_DOLLAR
Definition: equation.h:1
#define EQN_BRACKET_OPEN
Definition: equation.h:3
#define EQN_BRACKET_CLOSE
Definition: equation.h:5
#define EQN_DOLLAR_DOLLAR
Definition: equation.h:12
#define EQN_RND_CLOSE
Definition: equation.h:4
#define EQN_RND_OPEN
Definition: equation.h:2
static void
Definition: fpif.c:118
void CmdIgnore(int code)
Definition: funct1.c:604
void CmdSlashSlash(int code)
Definition: funct1.c:367
void CmdSpace(float kk)
Definition: funct1.c:1550
void CmdEndParagraph(int code)
Definition: funct1.c:146
void CmdStartParagraph(int code)
Definition: funct1.c:65
void TranslateGerman(void)
Definition: funct1.c:1446
#define ANY_PAR
Definition: funct1.h:41
#define s
Definition: afcover.h:80
bool TryVariableIgnore(char *command)
Definition: ignore.c:44
#define NULL
Definition: ftobjs.h:61
small capitals from c petite p scientific i
Definition: afcover.h:80
bool CallCommandFunc(char *cCommand)
Definition: commands.c:726
#define OFF
Definition: commands.h:20
void ConvertString(char *string)
Definition: convert.c:103
static void TranslateCommand()
Definition: convert.c:579
char TexModeName[7][25]
Definition: convert.c:75
static int Knj
Definition: convert.c:179
void Convert()
Definition: convert.c:182
static int g_TeX_mode
Definition: convert.c:73
static int ret
Definition: convert.c:72
int GetTexMode(void)
Definition: convert.c:97
void ConvertAllttString(char *s)
Definition: convert.c:133
void SetTexMode(int mode)
Definition: convert.c:78
void diagnostics(int level, char *format,...)
Definition: main.c:469
bool g_escape_parent
Definition: main.c:106
void fprintRTF(char *format,...)
Definition: main.c:722
bool GermanMode
Definition: main.c:65
int g_processing_fields
Definition: main.c:85
char g_field_separator
Definition: main.c:105
bool FrenchMode
Definition: main.c:66
int RecursionLevel
Definition: main.c:120
int g_processing_arrays
Definition: main.c:84
void putRtfChar(char cThis)
Definition: main.c:703
FILE * fRtf
Definition: main.c:54
char * colFmt
Definition: tables.c:62
int actCol
Definition: tables.c:61
#define WARNING__
Definition: main.h:32
bool g_processing_tabular
Definition: tables.c:57
bool g_processing_tabbing
Definition: tables.c:56
#define MAXCOMMANDLEN
Definition: main.h:34
int tabcounter
Definition: main.h:81
int PushSource(char *filename, char *string)
Definition: parser.c:139
void PopSource(void)
Definition: parser.c:243
int StillSource(void)
Definition: parser.c:231
void skipSpaces(void)
char getRawTexChar(void)
char getTexChar(void)
char getNonSpace(void)
void ungetTexChar(char c)
int getSameChar(char c)
char getNonBlank(void)
#define abs(a)
Definition: pbmplus.h:225
#define isupper(ch)
Definition: utype.h:80
#define isalpha(ch)
Definition: utype.h:82
*job_name strlen((char *) job_name) - 4)
void CmdTabjump(void)
Definition: tables.c:64
void CmdTabset(void)
Definition: tables.c:69
int PopBrace(void)
Definition: stack.c:191
void PushBrace(void)
Definition: stack.c:179
void CleanStack(void)
Definition: stack.c:155
void PushLevels(void)
Definition: stack.c:109
@ ON
Definition: ubidiimp.h:55