home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / INTERNET / HTML / TEX2RTF / SOURCES.ZIP / TOOLS / LACHECK / LACHECK.LEX < prev    next >
Encoding:
Text File  |  1991-06-27  |  16.7 KB  |  813 lines
  1. /*                    -*- Mode: C -*- 
  2.  * 
  3.  * lacheck.lex - A consistency checker checker for LaTeX documents
  4.  * 
  5.  * Copyright (C) 1991 Kresten Krab Thorup (krab@iesd.auc.dk).
  6.  * 
  7.  * $Locker: krab $
  8.  * $Revision: 1.10 $
  9.  * Author          : Kresten Krab Thorup
  10.  * Created On      : Sun May 26 18:11:58 1991
  11.  * Last Modified By: Kresten Krab Thorup
  12.  * Last Modified On: Thu May 30 02:29:57 1991
  13.  * Update Count    : 16
  14.  * 
  15.  * HISTORY
  16.  * 30-May-1991  (Last Mod: Thu May 30 02:22:33 1991 #15)  Kresten Krab Thorup
  17.  *    Added check for `$${punct}' and `{punct}$' constructions
  18.  * 30-May-1991  (Last Mod: Wed May 29 10:31:35 1991 #6)  Kresten Krab Thorup
  19.  *    Improved (dynamical) stack management from Andreas Stolcke ...
  20.  *                                       <stolcke@ICSI.Berkeley.EDU> 
  21.  * 26-May-1991  Kresten Krab Thorup
  22.  *    Initial distribution version.
  23.  */
  24. %{
  25. #include <stdio.h>
  26. #include <string.h>
  27. #include <sys/param.h>
  28.  
  29. extern char *realloc();
  30.  
  31. #ifdef NEED_STRSTR
  32. char *strstr();
  33. #endif
  34.  
  35. #define GROUP_STACK_SIZE 10
  36. #define INPUT_STACK_SIZE 10
  37.  
  38. #define PROGNAME "LaCheck"
  39.  
  40.   /* macros */
  41.  
  42. #define CG_NAME gstack[gstackp-1].s_name
  43. #define CG_TYPE gstack[gstackp-1].s_type
  44. #define CG_LINE gstack[gstackp-1].s_line
  45. #define CG_FILE gstack[gstackp-1].s_file
  46.  
  47. char *bg_command();
  48. void pop();
  49. void push();
  50. void g_checkend();
  51. void e_checkend();
  52. void f_checkend();
  53. void input_file();
  54. void print_bad_match();
  55. int check_top_level_end();
  56.  
  57.   /* global variables */
  58.  
  59. char returnval[100];
  60. int line_count = 1;
  61. int warn_count = 0;
  62. char *file_name;
  63. char verb_char;
  64.  
  65.   /* the group stack */
  66.  
  67. typedef struct tex_group 
  68.  {
  69.     unsigned char *s_name;
  70.     int s_type;
  71.     int s_line;
  72.     char *s_file; 
  73.  } tex_group;
  74.  
  75. tex_group *gstack;
  76. int gstack_size = GROUP_STACK_SIZE;
  77. int gstackp = 0;
  78.  
  79. typedef struct input_ 
  80.  {
  81.     YY_BUFFER_STATE stream;
  82.     char *name;
  83.     int linenum;
  84.  } input_;
  85.  
  86. input_ *istack;
  87. int istack_size = INPUT_STACK_SIZE;
  88. int istackp = 0;
  89.  
  90. int def_count = 0;
  91.  
  92. %}
  93.  
  94. %x B_ENVIRONMENT E_ENVIRONMENT VERBATIM INCLUDE MATH COMMENT VERB DEF
  95. %x AFTER_DISPLAY
  96.  
  97. b_group ("{"|\\bgroup)
  98. e_group ("}"|\\egroup)
  99.  
  100. b_math \\\(
  101. e_math \\\)
  102. math \$
  103.  
  104. b_display \\\[
  105. e_display \\\]
  106. display \$\$
  107.  
  108. non_par_ws ([ \t]+\n?[ \t]*|[ \t]*\n[ \t]*|[ \t]*\n?[ \t]+)
  109.  
  110. ws [ \n\t]
  111. space ({ws}|\~|\\space)
  112. hard_space (\~|\\space)
  113.  
  114. u_letter [A-ZFXE] 
  115. l_letter [a-zfxe] 
  116. punct [\!\.\?]
  117. atoz [a-zA-Z]
  118. letter (u_letter|l_letter)
  119.  
  120. c_bin ("-"|"+"|"\\cdot"|"\\oplus"|"\\otimes"|"\\times")
  121. l_bin (",")
  122.  
  123. general_abbrev {letter}+{punct}
  124.  
  125. non_abbrev {u_letter}{u_letter}+{punct}
  126.  
  127. font_spec (rm|bf|sl|it|tt|em|mediumseries|normalshape)
  128.  
  129. primitive \\(above|advance|catcode|chardef|closein|closeout|copy|count|countdef|cr|crcr|csname|delcode|dimendef|dimen|divide|expandafter|font|hskp|vskip|openout)
  130.  
  131. symbol ("$"("\\"{atoz}+|.)"$"|"\\#"|"\\$"|"\\%"|"\\ref")
  132.  
  133. %%
  134.  
  135. "\\\\" { ; }
  136.  
  137. <DEF,INITIAL>"\\\%" { ; }
  138.  
  139. <DEF,INITIAL>"%"[^\n]* { ; }
  140.  
  141. <DEF,INITIAL>\n     { line_count++; }
  142.  
  143. <DEF,INITIAL>"\\\{" { ; }
  144.  
  145. <DEF,INITIAL>"\\\}" { ; }
  146.  
  147. "\\\$" { ; }
  148.  
  149. {b_group} {  push( "{", 0, line_count);}
  150.  
  151. {e_group} {  g_checkend(0); }
  152.  
  153. "\\"[exg]?def[^\{]     BEGIN(DEF);
  154.  
  155. <DEF>{b_group} { ++def_count; }
  156.  
  157. <DEF>{e_group} { --def_count;
  158.          if(def_count == 0)
  159.              BEGIN(INITIAL); }
  160.  
  161. <DEF>. { ; }
  162.  
  163. {b_math} {
  164.     if(CG_TYPE == 4 || CG_TYPE == 5)
  165.     print_bad_match(yytext,4);
  166.     else
  167.     {
  168.     push( yytext, 4, line_count);
  169.     }}
  170.  
  171. {e_math} {  g_checkend(4); }
  172.  
  173. {b_display} {
  174.     if(CG_TYPE == 4 || CG_TYPE == 5)
  175.     print_bad_match(yytext,5);
  176.     else 
  177.     {
  178.     push( yytext, 5, line_count);
  179.     }}
  180.  
  181.  
  182. {e_display} {  g_checkend(5);
  183.            BEGIN(AFTER_DISPLAY);}
  184.  
  185. <AFTER_DISPLAY>{punct} { 
  186.  
  187.     printf( "\"%s\", line %d: puctation mark \"%s\" should be placed before end of displaymath\n", 
  188.        file_name, line_count, yytext); 
  189.     ++warn_count ; 
  190.  
  191.   BEGIN(INITIAL); }
  192.  
  193. <AFTER_DISPLAY>. {  BEGIN(INITIAL); }
  194.  
  195. <AFTER_DISPLAY>\n {     ++line_count; 
  196.             BEGIN(INITIAL); }
  197.  
  198. {punct}/("\$"|"\\)") { if (CG_TYPE == 4)
  199.        {
  200.      printf( "\"%s\", line %d: puctation mark \"%s\" should be placed after end of math mode\n", 
  201.         file_name, line_count, yytext); 
  202.      ++warn_count ;
  203.        }}
  204.  
  205. {math} {
  206.  
  207.     if(CG_TYPE == 5)
  208.     print_bad_match(yytext, 4);
  209.     else 
  210.  
  211.     if(CG_TYPE == 4)
  212.     {
  213.     e_checkend(4, yytext);
  214.     }
  215.     else
  216.     {
  217.     push( yytext, 4, line_count); 
  218.     }}
  219.  
  220.  
  221. {display}  {
  222.  
  223.     if(CG_TYPE == 4)
  224.     print_bad_match(yytext,5);
  225.     else 
  226.  
  227.     if(CG_TYPE == 5)
  228.     {
  229.     e_checkend(5, yytext);
  230.         BEGIN(AFTER_DISPLAY);
  231.     }
  232.     else
  233.     {
  234.     push( yytext, 5, line_count);
  235.     }}
  236.  
  237. \\begingroup/[^a-zA-Z]  {
  238.  {
  239.     push((unsigned char *)"\\begingroup", 1, line_count); 
  240.  }}
  241.  
  242.  
  243. \\endgroup/[^a-zA-Z]  {
  244.  {
  245.     g_checkend(1);
  246.  }}
  247.  
  248.  
  249. \\begin[ \t]*"{" { BEGIN(B_ENVIRONMENT); }
  250.  
  251. \\begin[ \t]*/\n { 
  252.  {
  253.     
  254.     printf("\"%s\", line %i: {argument} missing for \\begin\n",
  255.        file_name, line_count) ;
  256.     ++warn_count;
  257.  }}
  258.  
  259. <B_ENVIRONMENT>[^\}\n]+ { 
  260.  {
  261.     if (strcmp( yytext, "verbatim" ) == 0 )
  262.     {
  263.      input();
  264.      BEGIN(VERBATIM);
  265.     }
  266.     else
  267.     {
  268.          push(yytext, 2, line_count);
  269.       input();
  270.      BEGIN(INITIAL);
  271.     }
  272.  }}
  273.  
  274. <VERBATIM>\\end[ \t]*\{verbatim\} { BEGIN(INITIAL); }
  275.  
  276. <VERBATIM>. { ; }
  277.  
  278. <VERBATIM>\n { ++line_count; }
  279.  
  280.  
  281. \\verb.    { 
  282.       sscanf (yytext, "\\verb%c", &verb_char  ); 
  283.       BEGIN(VERB); 
  284.     }
  285.  
  286. <VERB>. {
  287.         if ( *yytext == verb_char )
  288.           BEGIN(INITIAL); 
  289.         if ( *yytext == '\n' )
  290.            ++line_count;
  291.     } 
  292.  
  293.  
  294. \\end[ \t]*"{" { BEGIN(E_ENVIRONMENT); }
  295.  
  296. \\end[ \t]*/\n { 
  297.  {
  298.     printf("\"%s\", line %i: {argument} missing for \\end\n",
  299.        file_name, line_count) ;
  300.     ++warn_count;
  301.  }}
  302.  
  303.  
  304. <E_ENVIRONMENT>[^\}\n]+ { 
  305.  {
  306.     e_checkend(2, yytext);
  307.     input();
  308.     
  309.     BEGIN(INITIAL);
  310.  }}
  311.  
  312.  
  313. {ws}([a-zfxe]".")*[a-zA-ZfxeFXE]*[a-zfxe]"."/{non_par_ws}+[a-zfxe]    { 
  314.  {
  315.     if ( *yytext == '\n' )
  316.         ++line_count; 
  317.  
  318.     printf( "\"%s\", line %d: missing `\\ ' after \"%s\"\n", 
  319.        file_name, line_count, ++yytext); 
  320.     ++warn_count ; 
  321.  }}
  322.  
  323. ([a-zfxe]".")*[a-zA-ZfxeFXE]*[a-zfxe]"."/{non_par_ws}+[a-zfxe]    { 
  324.  {
  325.     printf( "\"%s\", line %d: missing `\\ ' after \"%s\"\n", 
  326.        file_name, line_count, yytext); 
  327.     ++warn_count ; 
  328.  }}
  329.  
  330. {ws}{non_abbrev}/{non_par_ws}{u_letter}   { 
  331.  {
  332.     if ( *yytext == '\n' )
  333.     ++line_count;
  334.     printf("\"%s\", line %d: missing `\\\@' before punctation mark in \"%s\"\n", 
  335.        file_name, line_count, ++yytext); 
  336.     ++warn_count ; 
  337.  }}
  338.  
  339. {non_abbrev}/{non_par_ws}{u_letter}   { 
  340.  {
  341.     printf("\"%s\", line %d: missing `\\\@' before `.' in \"%s\"\n", 
  342.        file_name, line_count, yytext); 
  343.     ++warn_count ; 
  344.  }}
  345.  
  346. ({hard_space}{space}|{space}{hard_space})  { 
  347.  
  348.     printf("\"%s\", line %d: double space at \"%s\"\n",
  349.        file_name, line_count, yytext); 
  350.     ++warn_count;
  351.   }
  352.  
  353. {c_bin}{ws}?(\\(\.|\,|\;|\:))*{ws}?\\ldots{ws}?(\\(\.|\,|\;|\:))*{ws}?{c_bin} {
  354.     printf("\"%s\", line %d: \\ldots should be \\cdots in \"%s\"\n",
  355.        file_name, line_count, yytext); 
  356.     ++warn_count;
  357.   }
  358.  
  359. [^\\]{l_bin}{ws}?(\\(\.|\,|\;|\:))*{ws}?\\cdots{ws}?(\\(\.|\,|\;|\:))*{ws}?[^\\]{l_bin} {
  360.     printf("\"%s\", line %d: \\cdots should be \\ldots in \"%s\"\n",
  361.        file_name, line_count, yytext); 
  362.     ++warn_count;
  363.   }
  364.  
  365. {c_bin}{ws}?(\\(\.|\,|\;|\:))*{ws}?"."+{ws}?(\\(\.|\,|\;|\:))*{ws}?{c_bin} {
  366.     printf("\"%s\", line %d: Dots should be \\cdots in \"%s\"\n",
  367.        file_name, line_count, yytext); 
  368.     ++warn_count;
  369.   }
  370.  
  371. [^\\]{l_bin}{ws}?(\\(\.|\,|\;|\:))*{ws}?"."+{ws}?(\\(\.|\,|\;|\:))*{ws}?[^\\]{l_bin} {
  372.     printf("\"%s\", line %d: Dots should be \\ldots in \"%s\"\n",
  373.        file_name, line_count, yytext); 
  374.     ++warn_count;
  375.   }
  376.  
  377.  
  378. \.\.\. { 
  379.     printf("\"%s\", line %d: Dots should be ellipsis \"%s\"\n",
  380.        file_name, line_count, yytext); 
  381.     ++warn_count;
  382.   }
  383.  
  384.  /*
  385.  *
  386.  *  The `~' one is not too good, perhaps it shoud be an option.
  387.  *
  388.  */
  389.  /*
  390.  {l_letter}" "{symbol}  {
  391.  
  392.     printf("\"%s\", line %d: perhaps you should insert a `~' before%s\n",
  393.        file_name, line_count, ++yytext); 
  394.   }
  395.  */
  396.  
  397.  /*
  398.  {primitive}/[^a-zA-Z] {
  399.  {
  400.     printf("\"%s\", line %d: Don't use \"%s\" in LaTeX documents\n", 
  401.        file_name, line_count, yytext); 
  402.     ++warn_count ; 
  403.  }}    
  404.  */
  405.  
  406. \\{font_spec}/[ \t]*"{" { 
  407.  {
  408.     printf("\"%s\", line %d: Fontspecifiers don't take arguments. \"%s\"\n", 
  409.        file_name, line_count, yytext); 
  410.     ++warn_count; 
  411.   /*    (void) input(); */
  412.  }}
  413.  
  414.  
  415. \\([a-zA-Z\@]+\@[a-zA-Z\@]*|[a-zA-Z\@]*\@[a-zA-Z\@]+) { 
  416.  {
  417.     printf("\"%s\", line %d: Do not use @ in LaTeX macro names. \"%s\"\n", 
  418.        file_name, line_count, yytext); 
  419.     ++warn_count; 
  420.  }}
  421.  
  422.  
  423. "%"  { BEGIN(COMMENT); }
  424.  
  425. <COMMENT>\n    { BEGIN(INITIAL); ++line_count; }
  426.  
  427. <COMMENT>.    { ; }
  428.  
  429.  
  430. \\(input|include)([ \t]|"{")    { BEGIN(INCLUDE); }
  431.  
  432. <INCLUDE>[^\}\n]+    {
  433.  {
  434.     if ( strstr(yytext,"\.sty") == NULL )
  435.     {
  436.         input_file(yytext);
  437.     }
  438.     else
  439.     {
  440.         printf("\"%s\", line %d: Style file \`%s\' omitted.\n",
  441.             file_name,
  442.             line_count,
  443.             yytext);
  444.         input();
  445.     }
  446.     BEGIN(INITIAL);
  447.  }}
  448.  
  449. <<EOF>> { 
  450.       if (--istackp < 0)
  451.           yyterminate(); 
  452.  
  453.       else
  454.         { 
  455.           fclose(yyin);
  456.             f_checkend(file_name);
  457.           yy_switch_to_buffer(istack[istackp].stream);
  458.           free(file_name);
  459.           line_count = istack[istackp].linenum;
  460.           file_name = istack[istackp].name;
  461.           input();
  462.           BEGIN(INITIAL);
  463.         }        
  464.      
  465.     }
  466.  
  467.  
  468. . { ; }
  469. %%
  470. int main( argc, argv )
  471. int argc;
  472. char *argv[];
  473. {
  474.     /* allocate initial stacks */
  475.     gstack = (tex_group *)malloc(gstack_size * sizeof(tex_group));
  476.     istack = (input_ *)malloc(istack_size * sizeof(input_));
  477.     if ( gstack == NULL || istack == NULL ) {
  478.     fprintf(stderr, "%s: not enough memory for stacks\n", PROGNAME);
  479.     exit(3);
  480.     }
  481.     
  482.     if(argc > 1)
  483.     {
  484.         if ( (file_name = malloc(strlen(argv[1]) + 5)) == NULL ) {
  485.         fprintf(stderr, "%s: out of memory\n", PROGNAME);
  486.         exit(3);
  487.     }
  488.     
  489.     strcpy(file_name, argv[1]);
  490.     
  491.     if ((yyin = fopen( file_name, "r")) != NULL )
  492.     {
  493.         push(file_name, 3, 1);
  494.         yylex();
  495.         f_checkend(file_name);
  496.     }
  497.     else {   
  498.          strcat(file_name, ".tex" );
  499.          if ((yyin = fopen( file_name, "r")) != NULL )
  500.          {
  501.              push(file_name, 3, 1);
  502.              yylex();
  503.              f_checkend(file_name);
  504.          }
  505.          else
  506.              fprintf(stderr,
  507.                 "%s: Could not open : %s\n",PROGNAME, argv[1]);
  508.          }
  509.     }
  510.     else
  511.     {
  512.     printf("\n* %s *\n\n",PROGNAME);
  513.     printf("\t...a consistency checker for LaTeX documents.\n\n");
  514.  
  515.     printf("Usage:\n\tlacheck filename[.tex] <return>\n\n\n");
  516.  
  517.     printf("\tFrom within Emacs:\n\n\t");
  518.     printf("M-x compile <return>\n\tlacheck filename[.tex] <return>");
  519.     printf("\n\n\tUse C-x ` to step through the messages.\n\n");
  520.     printf("\n\tThe found context is displayed in \"double quotes\"\n\n");
  521.     printf("Remark:\n\tAll messages are only warnings!\n\n");
  522.     printf("\tYour document may be right though LaCheck tells\n");
  523.     printf("\tsomthing else.\n\n");
  524.     }
  525.     return(0);
  526. }
  527.  
  528. #ifdef NEED_STRSTR
  529. char *
  530. strstr(string, substring)
  531.     register char *string;    /* String to search. */
  532.     char *substring;        /* Substring to try to find in string. */
  533. {
  534.     register char *a, *b;
  535.  
  536.     /* First scan quickly through the two strings looking for a
  537.      * single-character match.  When it's found, then compare the
  538.      * rest of the substring.
  539.      */
  540.  
  541.     b = substring;
  542.     if (*b == 0) {
  543.     return string;
  544.     }
  545.     for ( ; *string != 0; string += 1) {
  546.     if (*string != *b) {
  547.         continue;
  548.     }
  549.     a = string;
  550.     while (1) {
  551.         if (*b == 0) {
  552.         return string;
  553.         }
  554.         if (*a++ != *b++) {
  555.         break;
  556.         }
  557.     }
  558.     b = substring;
  559.     }
  560.     return (char *) 0;
  561. }
  562. #endif /* NEED_STRSTR */
  563.  
  564. void push(p_name, p_type, p_line)
  565. unsigned char *p_name;
  566. int p_type;
  567. int p_line;
  568. {
  569.     if ( gstackp == gstack_size ) {    /* extend stack */
  570.     gstack_size *= 2;
  571.     gstack = (tex_group *)realloc(gstack, gstack_size * sizeof(tex_group));
  572.     if ( gstack == NULL ) {
  573.         fprintf(stderr, "%s: stack out of memory", PROGNAME);
  574.     exit(3);
  575.     }
  576.     }
  577.     
  578.     if ( (gstack[gstackp].s_name =
  579.         (unsigned char *)malloc(strlen(p_name) + 1)) == NULL ||
  580.          (gstack[gstackp].s_file =
  581.         (char *)malloc(strlen(file_name) + 1)) == NULL ) {
  582.     fprintf(stderr, "%s: out of memory\n", PROGNAME);
  583.     exit(3);
  584.     }
  585.  
  586.     strcpy(gstack[gstackp].s_name,p_name);
  587.     gstack[gstackp].s_type = p_type;
  588.     gstack[gstackp].s_line = p_line;    
  589.     strcpy(gstack[gstackp].s_file,file_name);
  590.     ++gstackp;    
  591.  
  592. }
  593.  
  594. void input_file(file_nam)
  595. char *file_nam;
  596. {
  597.     char *tmp_file_name;
  598.     FILE *tmp_yyin;
  599.  
  600.     if ( (tmp_file_name = malloc(strlen(file_nam) + 5)) == NULL ) {
  601.     fprintf(stderr, "%s: out of memory\n", PROGNAME);
  602.     exit(3);
  603.     }
  604.     strcpy(tmp_file_name,file_nam);
  605.  
  606.     if (istackp == istack_size) {    /* extend stack */
  607.     istack_size *= 2;
  608.     istack = (input_ *)realloc(istack, istack_size * sizeof(input_));
  609.     if ( istack == NULL ) {
  610.         fprintf(stderr, "%s: \\input stack out of memory\n", PROGNAME);
  611.     exit(3);
  612.         } 
  613.     } 
  614.         
  615.     istack[istackp].stream = YY_CURRENT_BUFFER;
  616.     istack[istackp].linenum = line_count;
  617.     istack[istackp].name = file_name;
  618.     ++istackp;    
  619.  
  620.     if ((tmp_yyin = fopen( file_nam, "r")) != NULL )
  621.     {
  622.       yyin = tmp_yyin;
  623.       yy_switch_to_buffer(yy_create_buffer(yyin,YY_BUF_SIZE));
  624.       file_name = tmp_file_name;
  625.       push(file_name, 3, 1);
  626.           line_count = 1;
  627.     }
  628.     else {
  629.       (void) strcat(tmp_file_name, ".tex");
  630.       if ((tmp_yyin = fopen( tmp_file_name , "r")) != NULL )
  631.         {
  632.         yyin = tmp_yyin;
  633.            yy_switch_to_buffer(yy_create_buffer(yyin,YY_BUF_SIZE));
  634.         file_name = tmp_file_name;
  635.         push(file_name, 3, 1);
  636.                line_count = 1;
  637.         }
  638.           else
  639.       {
  640.            --istackp;
  641.            fclose(tmp_yyin);
  642.            free(tmp_file_name);
  643.            printf("\"%s\", line %d: Could not open \"%s\"\n", 
  644.             file_name,
  645.             line_count,
  646.             file_nam);
  647.            input();
  648.       }
  649.      }
  650. }
  651.  
  652. void pop()
  653. {
  654.     if ( gstackp == 0 )
  655.     {
  656.            fprintf(stderr, "%s: Stack underflow\n", PROGNAME);
  657.     exit(4);
  658.     }
  659.     --gstackp;
  660.  
  661.     free(gstack[gstackp].s_name);
  662.     free(gstack[gstackp].s_file);
  663. }
  664.  
  665. char *bg_command(name)
  666. char *name;
  667. {
  668.     
  669.     switch (CG_TYPE) {
  670.     
  671.     case 2:
  672.     (void) strcpy( returnval, "\\begin\{" );
  673.     (void) strcat( returnval, (char *) name);
  674.     (void) strcat( returnval, "}" );
  675.     break;
  676.     
  677.     case 3:
  678.     (void) strcpy( returnval, "beginning of file " );
  679.     (void) strcat( returnval, (char *) name);
  680.     break;
  681.     
  682.     case 4:
  683.     (void) strcpy( returnval, "math begin " );
  684.     (void) strcat( returnval, (char *) name);
  685.     break;
  686.     
  687.     case 5:
  688.     (void) strcpy( returnval, "display math begin " );
  689.     (void) strcat( returnval, (char *) name);
  690.     break;
  691.     
  692.     default:
  693.         (void) strcpy( returnval, name );
  694.     
  695.     }
  696.     
  697.     return ((char *)returnval);
  698. }
  699.  
  700. char *eg_command(name,type)
  701. int type;
  702. char *name;
  703. {
  704.     
  705.     switch (type) {
  706.     
  707.     case 2:
  708.     (void) strcpy( returnval, "\\end{" );
  709.     (void) strcat( returnval, (char *) name);
  710.     (void) strcat( returnval, "}" );
  711.     break;
  712.     
  713.     case 3:
  714.     (void) strcpy( returnval, "end of file " );
  715.     (void) strcat( returnval, (char *) name);
  716.     break;
  717.     
  718.     case 4:
  719.     (void) strcpy( returnval, "math end " );
  720.     (void) strcat( returnval, (char *) name);
  721.     break;
  722.     
  723.     case 5:
  724.     (void) strcpy( returnval, "display math end " );
  725.     (void) strcat( returnval, (char *) name);
  726.     break;
  727.     
  728.     default:
  729.         (void) strcpy( returnval, name );
  730.     break;
  731.     }
  732.     
  733.     return ((char *)returnval);
  734. }
  735.  
  736.  
  737. void g_checkend(n)
  738. int n;
  739. {
  740.     if ( check_top_level_end(yytext,n) == 1 ) 
  741.        if (  CG_TYPE != n  )
  742.      print_bad_match(yytext,n);
  743.        else
  744.     pop();
  745. }
  746.  
  747. void e_checkend(n, name)
  748. int n;
  749. char *name;
  750. {
  751.    if ( check_top_level_end(name,n) == 1 )
  752.     {
  753.      if (  CG_TYPE != n  ||  strcmp( CG_NAME, name ) != 0 )
  754.         print_bad_match(name,n);
  755.  
  756.      pop();
  757.  
  758.     }
  759. }
  760.  
  761. void f_checkend(name)
  762. char *name;
  763. {
  764.     if ( check_top_level_end(name,3) == 1 )
  765.      {
  766.        if (  CG_TYPE != 3  ||  strcmp( CG_NAME, name ) != 0 )
  767.  
  768.         while( CG_TYPE != 3  )
  769.     {
  770.       print_bad_match(name,3);
  771.           pop();
  772.         }
  773.  
  774.          pop();  
  775.      }
  776. }
  777.  
  778. void print_bad_match(end_command,type)
  779. char *end_command;          
  780. int type;
  781. {
  782.       printf("\"%s\", line %i: <- unmatched \"%s\"\n",
  783.              file_name, 
  784.          line_count, 
  785.          eg_command( end_command , type) ) ;
  786.  
  787.       printf("\"%s\", line %i: -> unmatched \"%s\"\n",
  788.              CG_FILE, 
  789.          CG_LINE, 
  790.          bg_command( CG_NAME ) ) ;
  791.       warn_count += 2;
  792. }
  793.  
  794. int check_top_level_end(end_command,type)
  795. char *end_command;          
  796. int type;
  797. {
  798.     if ( gstackp == 0 )
  799.     {
  800.      printf("\"%s\", line %i: \"%s\" found at top level\n",
  801.            file_name, 
  802.            line_count, 
  803.            eg_command( end_command, type )) ;
  804.      ++warn_count;
  805.          return(0);
  806.     }
  807.     else
  808.         return(1);
  809. }
  810.  
  811.  
  812.  
  813.