home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume3 / texchk / part1 / texchk.c < prev    next >
Encoding:
C/C++ Source or Header  |  1986-11-30  |  16.3 KB  |  737 lines
  1. /* Texchk -- a LaTeX syntax and spelling checker.
  2.    Written by JP Massar, Thinking Machines Corporation, Cambridge, MA
  3.    This code is hereby released into the public domain, for better or worse.
  4. */
  5.  
  6. #include <stdio.h>
  7. #include <ctype.h>
  8.  
  9. /* if your system doesn't have either string.h or strings.h you */
  10. /* may have to declare the string functions yourself */
  11. #ifdef BSD42
  12. #include <strings.h>
  13. #else
  14. #include <string.h>
  15. #endif
  16.  
  17. #ifdef TMC
  18. #include <ctools.h>
  19. #else
  20. #include "ctools.h"
  21. #endif
  22.  
  23. #include "texchk.h"
  24. #include "cmds.h"
  25. #include "texchars.h"
  26.  
  27. Bool Verbose_Mode = F;                  /* -v option */
  28. Bool Check_Mode = F;                    /* -c option */
  29.  
  30. int Indent_Level = 0;                   /* for verbose output mode */
  31.  
  32. Stack_Entry Lex_Stack[MAX_ENTRIES];     /* environment stack */
  33. int Lex_TOS = -1;
  34.  
  35. FILE *fp;                               /* file being processed */
  36. Bool Already_At_Eof = F;
  37.  
  38. long Current_Line = 0;                  /* where we are in input text */
  39. long Current_Char = 0;                  /* where we are in input text */
  40. long Line_Length = 0;                   /* current line length */
  41. char Line_Buffer[MAXLL];                /* buffer for input text */
  42.  
  43. Bool In_Math_Mode = F;
  44. int Math_Mode_Depth = 0;
  45.  
  46. char Keyword_Buffer[MAX_KEYWORD_LENGTH];
  47.  
  48.  
  49. new_file ()
  50. {
  51.   Current_Line = 0;
  52.   Current_Char = 0;
  53.   Line_Length = 0;
  54.   In_Math_Mode = F;
  55.   Math_Mode_Depth = 0;
  56.   Indent_Level = 0;
  57. }  
  58.         
  59. do_indent (level) int level;
  60. {
  61.   int j,i;
  62.   for (j = 0; j < level; j++)
  63.       for (i = 0; i < SPACES_PER_INDENT_LEVEL; i++) putc(' ',stderr);
  64. }
  65.  
  66.  
  67. lex_push (etype,keyword,linenum) envtype etype; char *keyword; long linenum;
  68.  
  69. /* push an environment onto the stack */
  70.  
  71. {
  72.   if (++Lex_TOS >= MAX_ENTRIES) {
  73.      fprintf(stderr,"Stack overflow...Process terminating.\n");
  74.      texit();
  75.   }
  76.   Lex_Stack[Lex_TOS].etype = etype;
  77.   Lex_Stack[Lex_TOS].keyword = keyword;
  78.   Lex_Stack[Lex_TOS].linenum = linenum;
  79. }
  80.  
  81.  
  82. lex_pop (ptr_etype,ptr_keyword,ptr_linenum)
  83.  
  84. /* pop an environment and return its components */
  85.  
  86.   envtype *ptr_etype;
  87.   char **ptr_keyword;
  88.   long *ptr_linenum;
  89.  
  90. {
  91.   if (Lex_TOS < 0) {
  92.      fprintf(stderr,"Stack underflow...Process terminating\n");
  93.      texit();
  94.   }
  95.   *ptr_etype = Lex_Stack[Lex_TOS].etype;
  96.   *ptr_keyword = Lex_Stack[Lex_TOS].keyword;
  97.   *ptr_linenum = Lex_Stack[Lex_TOS].linenum;
  98.   Lex_TOS--;
  99. }
  100.  
  101.  
  102. curstack (ptr_etype,ptr_keyword,ptr_linenum)
  103.  
  104.   /* get the components of the current stack entry, but leave the entry */
  105.   /* on the stack. */
  106.  
  107.   envtype *ptr_etype;
  108.   char **ptr_keyword;
  109.   long *ptr_linenum;
  110.  
  111. {
  112.   if (Stack_Empty) {
  113.      fprintf(stderr,"Fatal error, bad call to curstack\n");
  114.      texit();
  115.   }
  116.   lex_pop(ptr_etype,ptr_keyword,ptr_linenum);
  117.   lex_push(*ptr_etype,*ptr_keyword,*ptr_linenum);
  118. }
  119.  
  120.  
  121. char *copy_keyword (starttoken,endtoken) int starttoken,endtoken;
  122.  
  123. /* grab a keyword from the Line_Buffer and copy it into a static buffer */
  124.  
  125. {
  126.   int len;
  127.   if (MAX_KEYWORD_LENGTH <= (len = (endtoken - starttoken) + 1)) {
  128.      keyword_length_error();
  129.      texit();
  130.   }
  131.   strncpy(Keyword_Buffer,Line_Buffer + starttoken,len);
  132.   Keyword_Buffer[len] = '\0';
  133.   return(Keyword_Buffer);
  134. }
  135.  
  136.  
  137. do_pop (etype,keyword) envtype etype; char *keyword;
  138.  
  139. /* make sure that the current environment is the matching begin-environment */
  140. /* for the end-environment that we have just discovered.  If so, pop the */
  141. /* environment off the stack.   If not its an error. */
  142.  
  143. {
  144.         
  145.   envtype oldetype;
  146.   char *oldkeyword;
  147.   long oldlinenum;
  148.   char *s, *e;
  149.         
  150.   lex_pop(&oldetype,&oldkeyword,&oldlinenum);
  151.         
  152.   switch (etype) {
  153.      
  154.     case ESCAPE_END :
  155.       s = "\\begin";
  156.       e = "\\end";
  157.       if (oldetype != ESCAPE_BEGIN) goto nesterror;
  158.       if (0 != strcmp(oldkeyword,keyword)) goto nesterror;
  159.       break;
  160.  
  161.     case RIGHT_SQUARE_BRACKET :
  162.       s = "[";
  163.       e = "]";
  164.       if (oldetype != LEFT_SQUARE_BRACKET) goto nesterror;
  165.       break;
  166.  
  167.     case RIGHT_CURLY_BRACKET :
  168.       s = "{";
  169.       e = "}";
  170.       if (oldetype != LEFT_CURLY_BRACKET) goto nesterror;
  171.       break;
  172.  
  173.     case MATH :
  174.       s = "Begin Math Mode";
  175.       e = "End Math Mode";
  176.       if (oldetype != etype) goto nesterror;
  177.       break;
  178.       
  179.     case DOUBLE_MATH :
  180.       s = "Begin Display Math Mode";
  181.       e = "End Display Math Mode";
  182.       if (oldetype != etype) goto nesterror;
  183.       break;
  184.  
  185.   }
  186.  
  187.   return(0);
  188.  
  189.   nesterror:
  190.  
  191.   nest_error(s,e,oldlinenum,oldkeyword);
  192.   texit();
  193.  
  194. }
  195.  
  196.  
  197. int get_a_char ()
  198.  
  199. /* buffered input routine, to keep track of line number */
  200.  
  201. {
  202.   int ch,rval;
  203.   if (Current_Char >= Line_Length) {
  204.      switch (rval = getline(fp,Line_Buffer,MAXLL-2)) {
  205.        case AT_EOF:
  206.          return(EOF);
  207.          break;
  208.        case TOO_MANY_CHARS :
  209.          line_too_long_error();
  210.          texit();
  211.          break;
  212.        default :
  213.          Line_Buffer[rval] = '\n';
  214.          Line_Buffer[++rval] = '\0';
  215.          Line_Length = rval;
  216.          Current_Char = 0;
  217.          Current_Line++;
  218.          break;
  219.      }
  220.   }
  221.   ch = (int) (255 & Line_Buffer[Current_Char++]);
  222.   if (!LGL_CHAR(ch)) bad_char_error(ch,T);
  223.   return(ch);
  224. }  
  225.   
  226.  
  227. unget_a_char ()
  228.  
  229. {
  230.   if (Current_Char == 0) {        
  231.      fprintf(stderr,"Invalid unget...process terminating\n");
  232.      texit();
  233.   }
  234.   Current_Char--;
  235. }  
  236.  
  237.  
  238. char *get_keyword ()
  239.  
  240. /* read a keyword.  Keywords consist of contiguous alphabetic characters */
  241. /* keyword returned is in a static buffer. */
  242.  
  243. {
  244.   int starttoken,endtoken,ch;
  245.   starttoken = Current_Char - 1;
  246.   endtoken = Current_Char - 1;
  247.   while (isalpha(ch = get_a_char())) {
  248.     endtoken++;
  249.   }
  250.   if (ch == EOF) {
  251.      Already_At_Eof = 1;
  252.   }
  253.   else unget_a_char();
  254.   return(copy_keyword(starttoken,endtoken));
  255. } 
  256.  
  257.  
  258. char *get_begin_end_keyword ()
  259.  
  260. /* called after a \begin or \end construct is found. */
  261. /* begin and end keywords are enclosed in {}. */
  262. /* a warning is issued if there is any whitespace within the {}s */
  263. /* returns a string constituting what is in between the {}s save for */
  264. /* whitespace immediately after the { and immediately before the } */
  265.  
  266. /* keyword returned is in a static buffer. */
  267.  
  268. {
  269.   int ch;        
  270.   int starttoken,endtoken;
  271.   
  272.   ch = get_a_char();
  273.   if (ch != LCB) {
  274.      no_brace_after_begin_end_error();
  275.      texit();
  276.   }
  277.   
  278.   starttoken = Current_Char;
  279.   endtoken = starttoken - 1;
  280.   while (RCB != (ch = get_a_char())) {
  281.     if (ch == '\n')
  282.        warning_close_brace();
  283.     else if (ch == EOF) {
  284.        eof_error();
  285.        texit();
  286.     }
  287.     else 
  288.        endtoken++;
  289.   }
  290.   
  291.   /* ignore whitespace after '{' and before '}' */
  292.   
  293.   if (ISWHITE(Line_Buffer[starttoken]) || ISWHITE(Line_Buffer[endtoken])) {
  294.      warning_blanks_in_cb();
  295.   }
  296.   
  297.   while (starttoken < endtoken && ISWHITE(Line_Buffer[starttoken]))
  298.     starttoken++;
  299.   if (starttoken >= endtoken) {
  300.      blank_begin_end_error();
  301.      texit();
  302.   }
  303.   while (endtoken > starttoken && ISWHITE(Line_Buffer[endtoken]))
  304.     endtoken--;
  305.   return(copy_keyword(starttoken,endtoken));
  306.   
  307. }  
  308.  
  309.  
  310. get_token (action,etype,keyword) 
  311.  
  312.   /* get the next significant token from the input stream. Based on its type */
  313.   /* an action to perform is computed.  The significant part of the token is */
  314.   /* returns in *keyword, which points to a static buffer. */
  315.  
  316.   /* returns 0 on encountering EOF, otherwise returns 1. */
  317.  
  318.   Actions *action;
  319.   envtype *etype;
  320.   char **keyword;
  321.  
  322. {  
  323.   int ch,isbegin,isend;
  324.   
  325.   *keyword = 0;
  326.   if (Already_At_Eof) return(0);
  327.   
  328.   readloop:
  329.   
  330.   if (EOF == (ch = get_a_char())) return(0);
  331.  
  332.   switch (ch) {
  333.  
  334.     case LSB :
  335.       *etype = LEFT_SQUARE_BRACKET;
  336.       *action = PUSH;
  337.       *keyword = "[";
  338.       return(1);
  339.  
  340.     case RSB :
  341.       *etype = RIGHT_SQUARE_BRACKET;
  342.       *action = POP;
  343.       *keyword = "]";
  344.       return(1);
  345.  
  346.     case LCB :
  347.       *etype = LEFT_CURLY_BRACKET;
  348.       *action = PUSH;
  349.       *keyword = "{";
  350.       return(1);
  351.  
  352.     case RCB :
  353.       *etype = RIGHT_CURLY_BRACKET;
  354.       *action = POP;
  355.       *keyword = "}";
  356.       return(1);
  357.  
  358.     case MATH_CHAR :
  359.     
  360.       /* Is the next character also a '$'? If so this is 'Display Math Mode' */
  361.     
  362.       if (EOF == (ch = get_a_char())) {
  363.          *action = DOLLAR;
  364.          *etype = MATH;
  365.          *keyword = "$";
  366.          Already_At_Eof = 1;
  367.       }
  368.       else if (ch == MATH_CHAR) {
  369.          *action = DOLLAR_DOLLAR;
  370.          *etype = DOUBLE_MATH;
  371.          *keyword = "$$";
  372.       }
  373.       else {
  374.          unget_a_char();
  375.          *action = DOLLAR;
  376.          *etype = MATH;
  377.          *keyword = "$";
  378.       }
  379.       return(1);
  380.  
  381.     case ESCAPE :
  382.     
  383.       /* treat specially \begin and \end */
  384.     
  385.       if (EOF == (ch = get_a_char())) {
  386.          eof_error();
  387.          texit();
  388.       }
  389.       
  390.       /* first check for single character non-alphabetic commands */
  391.       
  392.       if (!isalpha(ch)) {
  393.          *action = CHECK_SINGLE;
  394.          *etype = ESCAPE_SINGLE_CHAR;
  395.          Keyword_Buffer[0] = ch;
  396.          Keyword_Buffer[1] = '\0';
  397.          *keyword = Keyword_Buffer;
  398.          return(1);
  399.       }
  400.         
  401.         
  402.       *keyword = get_keyword();
  403.       isbegin = (0 == strcmp(*keyword,BEGINSTRING));
  404.       isend = (0 == strcmp(*keyword,ENDSTRING));
  405.       if (!isbegin && !isend) {
  406.          *action = CHECK;
  407.          *etype = ESCAPE_ANY;
  408.          return(1);
  409.       }
  410.       
  411.       *etype = isbegin ? ESCAPE_BEGIN : ESCAPE_END;
  412.       *action = isbegin ? PUSH : POP;
  413.       *keyword = get_begin_end_keyword();
  414.       return(1);
  415.  
  416.     case COMMENT :
  417.     
  418.       /* just read in the rest of the line and ignore what's on it */
  419.     
  420.       while ('\n' != (ch = get_a_char())) {
  421.         if (EOF == ch) return(0);
  422.       }
  423.       goto readloop;
  424.     
  425.     default :
  426.       goto readloop;
  427.       
  428.   }
  429.  
  430. }
  431.  
  432. push_math_mode (key) char *key;
  433. {
  434.   if (Verbose_Mode) {
  435.      do_indent(Indent_Level++);
  436.      fprintf (
  437.          stderr,"Line %d: Entering math mode using <%s>\n",Current_Line,key
  438.        );
  439.   }
  440.   Math_Mode_Depth++;
  441.   In_Math_Mode = T;
  442.   lex_push(MATH,key,Current_Line);
  443. }
  444.  
  445. pop_math_mode (key) char *key;
  446. {
  447.   envtype etype;
  448.   char *keyword;
  449.   long linenum;
  450.   if (Verbose_Mode) {
  451.      do_indent(--Indent_Level);
  452.      fprintf (
  453.          stderr,"Line %d: Leaving math mode using <%s>\n",Current_Line,key
  454.        );
  455.   }
  456.   Math_Mode_Depth--;
  457.   In_Math_Mode = (Math_Mode_Depth > 0);
  458.   lex_pop(&etype,&keyword,&linenum);
  459. }
  460.  
  461.  
  462. math_mode_action (action,keyword) Actions action; char *keyword;
  463.  
  464. /* check for math mode tokens, and enter or leave math mode as appropriate */
  465.  
  466. {
  467.   char *stack_keyword;
  468.   long linenum;
  469.   envtype etype;
  470.   char *key, *matching_keyword;
  471.   
  472.   switch (action) {
  473.  
  474.     /* If there is a matching '$' or '$$' as the latest entry on the stack */
  475.     /* we pop it because it is a matching token.  Otherwise, we push it, */
  476.     /* even if we are already in math mode. */
  477.         
  478.     case (DOLLAR) :
  479.     case (DOLLAR_DOLLAR) :
  480.       key = (action == DOLLAR) ? "$" : "$$";
  481.       if (!In_Math_Mode) {
  482.          push_math_mode(key);
  483.          break;
  484.       }
  485.       curstack(&etype,&stack_keyword,&linenum);
  486.       if (0 != strcmp(key,stack_keyword)) {
  487.          push_math_mode(key);
  488.       }
  489.       else {
  490.          pop_math_mode(key);
  491.       }
  492.       break;
  493.      
  494.     /* just adjust Math Mode for PUSH and POP, because in process_file */
  495.     /* we will do the actual pushing and popping of these environments. */
  496.       
  497.     case (PUSH) :
  498.       if (is_math_environment(keyword)) {
  499.          Math_Mode_Depth++;
  500.          In_Math_Mode = T;
  501.       }
  502.       break;
  503.  
  504.     case (POP) :
  505.       if (is_math_environment(keyword)) {
  506.          Math_Mode_Depth--;
  507.          In_Math_Mode = (Math_Mode_Depth == 0);
  508.       }
  509.       break;
  510.       
  511.     /* look for \( and \[ commands which put us into math mode, and \) and */
  512.     /* \] commands which pop us out of math mode.   Make sure if we are */
  513.     /* popping that the proper pushed math mode command is the current */
  514.     /* stack entry. */
  515.       
  516.     case (CHECK_SINGLE) :
  517.       if (*keyword == '(' || *keyword == '[') {
  518.          push_math_mode(anewstr(keyword));
  519.       }
  520.       else if (*keyword == ')' || *keyword == ']') {
  521.          if (Stack_Empty) {
  522.             stack_empty_error(MATH,keyword);
  523.             texit();
  524.          }
  525.          curstack(&etype,&stack_keyword,&linenum);
  526.          matching_keyword = (*keyword == ')') ? "(" : "[";
  527.          if (0 != strcmp(matching_keyword,stack_keyword)) {
  528.             nest_error(matching_keyword,keyword,linenum,stack_keyword);
  529.             texit();
  530.          }
  531.          pop_math_mode(keyword);
  532.       }
  533.       break;
  534.  
  535.   }
  536.  
  537. }
  538.  
  539.  
  540. process_file () 
  541.  
  542. /* Get significant LaTeX forms from the input file.  For each one, depending */
  543. /* on its nature perform a verification or manipulate the environment stack. */
  544. /* When we are done the stack should be empty. */
  545.  
  546. /* The file has already been opened using the global file descriptor 'fp' */
  547.  
  548. {
  549.   Actions action;          
  550.   envtype etype;
  551.   char *keyword;
  552.   int cmd_index,ch;
  553.         
  554.   while (0 != get_token(&action,&etype,&keyword)) {
  555.  
  556.     switch (action) {
  557.  
  558.       case (POP) :
  559.  
  560.         /* \end{keyword},, '}', ']' */
  561.       
  562.         if (Stack_Empty) {
  563.            stack_empty_error(etype,keyword);
  564.            texit();
  565.         }
  566.         
  567.         math_mode_action(POP,keyword);
  568.       
  569.         if (Verbose_Mode && *keyword != '}' && *keyword != ']') {
  570.            do_indent(--Indent_Level);
  571.            printf("line %d: \\end{%s}\n",Current_Line,keyword);
  572.         }
  573.         do_pop(etype,keyword);
  574.         break;
  575.  
  576.       case (PUSH) :
  577.       
  578.         /* \begin{keyword}, '{', '[' */
  579.       
  580.         math_mode_action(PUSH,keyword);
  581.       
  582.         if (Verbose_Mode && *keyword != '{' && *keyword != '[') {
  583.            do_indent(Indent_Level++);
  584.            printf("line %d: \\begin{%s}\n",Current_Line,keyword);
  585.         }
  586.         
  587.         if (0==strcmp("verbatim",keyword) || 0==strcmp("verbatim*",keyword)) {
  588.            do_verbatim(keyword);
  589.            break;
  590.         }
  591.         else {
  592.            lex_push(etype,anewstr(keyword),Current_Line);
  593.            break;
  594.         }
  595.  
  596.       case (DOLLAR) :
  597.         math_mode_action(DOLLAR,keyword);
  598.         break;
  599.         
  600.       case (DOLLAR_DOLLAR) :
  601.         math_mode_action(DOLLAR_DOLLAR,keyword);
  602.         break;
  603.       
  604.       case (CHECK_SINGLE) :
  605.  
  606.         /* check for \(, \[, \), \] for math mode */
  607.       
  608.         math_mode_action(CHECK_SINGLE,keyword);
  609.         
  610.         if (Check_Mode) {
  611.            if (!LGL_SINGLE_COMMAND_CHAR(*keyword)) {
  612.               single_char_command_error(*keyword);
  613.            }
  614.            if (NOT_FOUND == (cmd_index = command_lookup(keyword))) {
  615.               fprintf(stderr,"Fatal error:\n");
  616.               fprintf(stderr,"Command Table and Legal Chars out of sync\n");
  617.               exit(1);
  618.            }
  619.            if (!In_Math_Mode && IS_MATH_MODE(cmd_index)) {
  620.               math_keyword_error(keyword);
  621.            }
  622.               
  623.         }
  624.         break;
  625.         
  626.       case (CHECK) :
  627.       
  628.         /* \command token */
  629.       
  630.         if (0 == strcmp("verb",keyword)) {
  631.            if ('*' != (ch = get_a_char())) unget_a_char();
  632.            do_verb();
  633.            break;
  634.         }
  635.       
  636.         if (Check_Mode) {
  637.            if (NOT_FOUND == (cmd_index = command_lookup(keyword))) {
  638.               keyword_error(keyword);
  639.            }
  640.            else if (!In_Math_Mode && IS_MATH_MODE(cmd_index)) {
  641.               math_keyword_error(keyword);
  642.            }
  643.         }
  644.         
  645.         break;
  646.         
  647.       default :
  648.         fprintf(stderr,"Invalid return from get_token...\n");
  649.         texit();
  650.         
  651.     }
  652.  
  653.   }
  654.     
  655.   if (!Stack_Empty) {
  656.      eof_error();
  657.      texit();
  658.   }
  659.  
  660.   return(0);
  661.  
  662. }
  663.  
  664.  
  665. texit ()
  666. {
  667.   fclose(fp);
  668.   exit(1);
  669. }
  670.  
  671.  
  672. usage () 
  673. {
  674.   fprintf(stderr,"\nUnrecognized argument to texchk\n");
  675.   fprintf(stderr,"Usage: texchk [ -v -c ] [ file1 file2 ... ]\n");
  676.   exit(1);
  677. }
  678.   
  679.   
  680. main (argc,argv) int argc; char **argv;
  681.  
  682. {
  683.   char **argptr;        
  684.   int j,input_files = 0;
  685.         
  686.   init_legal_chars();
  687.   
  688.   /* process command line arguments */
  689.   
  690.   argptr = argv;        
  691.   while (*++argptr != 0) {
  692.     if (**argptr == '-') {
  693.        if (strlen(*argptr) != 2) { 
  694.           usage();
  695.        }
  696.        switch ((*argptr)[1]) {
  697.          case 'v' :
  698.            Verbose_Mode = T;
  699.            break;
  700.          case 'c' :
  701.            Check_Mode = T;
  702.            break;
  703.          default :
  704.            usage();
  705.            break;
  706.        }
  707.        *argptr = '\0';
  708.     }
  709.     else input_files = 1;
  710.   }
  711.         
  712.   /* read and process each file */
  713.   
  714.   if (!input_files) {
  715.      printf("\n");
  716.      fp = stdin;
  717.      process_file();
  718.      printf("\nOK!\n\n");
  719.   }  
  720.   else {
  721.     for (j = 1; j < argc; j++) {
  722.         if (argv[j] != '\0') {
  723.            printf("\nChecking file %s.\n\n",argv[j]);
  724.            new_file();
  725.            fp = (FILE *) efopen(argv[j],"r");
  726.            process_file();
  727.            fclose(fp);
  728.         }
  729.     }
  730.  }
  731.   
  732.  exit(0);
  733.  
  734. }
  735.  
  736.  
  737.