home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 2 / FFMCD02.bin / new / dev / misc / cweb / examples / extex.w < prev    next >
Text File  |  1993-12-21  |  12KB  |  363 lines
  1. \datethis
  2. @* Introduction. This program is a simple filter that inputs \TEX/ or \.{CWEB}
  3. files and outputs its best guess at the ``words'' they contain. The word
  4. list can then be passed to a spelling check routine such as {\tt wordtest}.
  5.  
  6. If this program is invoked with the name `{\tt excweb}', it will apply
  7. special rules based on the syntax of \.{CWEB} files. Otherwise it will
  8. use only the \TEX/ conventions. (Note that \UNIX/'s {\tt ln} command
  9. allows a program to be invoked with more than one name although it
  10. appears only once in the computer's memory.)
  11.  
  12. The \TEX/ conventions adopted here say that words are what remain
  13. after you remove nonletters, control sequences,
  14. comments triggered by \.\% marks, and material enclosed
  15. within \.{\$...\$} or \.{\$\$...\$\$}. However, an apostrophe within
  16. a word will be retained. The plain \TEX/ control
  17. sequences for accented characters and special text characters, namely
  18. $$\vbox{\halign{&\.{\\#}\hfil\qquad\cr
  19. '&`&\relax\^&"&\relax\~&=&.&u&v\cr
  20. H&t&c&d&b&oe&OE&ae&AE\cr
  21. aa&AA&o&O&l&L&ss&i&j\cr}}$$
  22. will also be retained, so that users can treat them as parts of words.
  23. A blank space
  24. following any of the alphabetic control sequences in this list will be carried
  25. along too. If any of these control sequences is followed by \.\{, everything
  26. up to the next \.\} will also be retained. Thus, for example, the
  27. construction `\.{m\\=\{\\i\}n\\u\ us}' will be considered a single word,
  28. in spite of the control sequences and the space between the two u's.
  29.  
  30. The \.{CWEB} conventions are essentially the same as the \TEX/ conventions,
  31. in the \TEX/ parts of a \.{CWEB} file. The \CEE/ parts of the file
  32. are blanked out.
  33.  
  34. No attempt is made to reach a high level of artificial intelligence,
  35. which would be able to truly understand the input file. Tricky users can
  36.  confuse us. But we claim that devious tricks are their problem, not ours.
  37.  
  38. @ So here goes. The main idea is to keep a one-character lookahead
  39. buffer, called |c|, which is set to zero when the character has been
  40. processed. A giant switch to various cases, depending on the value of~|c|,
  41. keeps everything moving.
  42.  
  43. If you don't like |goto| statements, don't read this. (And don't read
  44. any other programs that simulate finite-state automata.)
  45.  
  46. @c
  47. #include <stdio.h>
  48. #include <ctype.h>
  49. extern void exit(); /* system routine that terminates execution */
  50. @#
  51. @<Global variables@>@;
  52. @<Procedures@>@;
  53. @#
  54. int main(argc,argv)
  55.   int argc; /* the number of arguments (should be 1, but this isn't checked) */
  56.   char *argv[]; /* the arguments (|*argv| is the program name) */
  57. {
  58.   @<Local variables@>;
  59.   if (strcmp(*argv,"excweb")==0) {
  60.     web=1;
  61.     @<Adjust tables for \.{CWEB} mode@>;
  62.   } else web=0;
  63.   comment=skipping=c=0;
  64.   main_cycle: if (c) goto big_switch;
  65.   restart: c=get();
  66.   big_switch: switch(c) {
  67.      @<Special cases of the giant switch where we don't just discard |c|@>@;
  68.     case EOF: exit(0);
  69.     default: goto restart;
  70.     }
  71.     @<Labeled code segments, which exit by explicit |goto|@>;
  72. }
  73.  
  74. @ @<Global variables@>=
  75. int c; /* one-character look-see buffer */
  76.  
  77. @ @<Local variables@>=
  78. int web; /* are we looking for \.{CWEB} constructs? */
  79. int comment; /* are we inside a \CEE/ comment in a \.{CWEB} document? */
  80. int skipping; /* are we skipping \CEE/ code in a \.{CWEB} document? */
  81. int save_skipping; /* value of |skipping| outside current \CEE/ mode */
  82. register int cc; /* temporary buffer */
  83.  
  84. @* Simple cases.
  85. Let's do some of the easiest things first, in order to get the hang of
  86. this program. Several special characters will cause us to ignore everything
  87. until the first appearance of something else.
  88.  
  89. @d discard_to(x) {@+while (get()!=x) ;@+}
  90.  
  91. @<Special cases...@>=
  92. case '%': discard_to('\n');@+goto restart;
  93. case '$': c=getchar();
  94.   if (c!='$') discard_to('$')@;
  95.   else { /* after \.{\$\$} we discard everything to the next \.{\$\$} */
  96.     do discard_to('$')@;
  97.     while (getchar()!='$');
  98.   }
  99.   goto restart;
  100.  
  101. @ The `|get|' procedure in the code above is like \Cee's standard
  102. `|getchar|', except that it immediately terminates execution at the end of
  103. the input file. Otherwise malformed input files could lead to
  104. infinite loops.
  105.  
  106. @<Procedures@>=
  107. int get()
  108. {@+register int x;
  109.   x=getchar();
  110.   if (x==EOF) exit(0);
  111.   return x;
  112. }
  113.  
  114. @ More complex behavior is handled by jumping out of the |switch| statement
  115. to one of the routines following it. None of the cases say |break|, so
  116. the code following the switch statement is accessible only via |goto|.
  117.  
  118. @<Special cases...@>=
  119. case 'a': case 'A':
  120. case 'b': case 'B':
  121. case 'c': case 'C':
  122. case 'd': case 'D':
  123. case 'e': case 'E':
  124. case 'f': case 'F':
  125. case 'g': case 'G':
  126. case 'h': case 'H':
  127. case 'i': case 'I':
  128. case 'j': case 'J':
  129. case 'k': case 'K':
  130. case 'l': case 'L':
  131. case 'm': case 'M':
  132. case 'n': case 'N':
  133. case 'o': case 'O':
  134. case 'p': case 'P':
  135. case 'q': case 'Q':
  136. case 'r': case 'R':
  137. case 's': case 'S':
  138. case 't': case 'T':
  139. case 'u': case 'U':
  140. case 'v': case 'V':
  141. case 'w': case 'W':
  142. case 'x': case 'X':
  143. case 'y': case 'Y':
  144. case 'z': case 'Z':
  145. goto out_word;
  146.  
  147. @ When letters appear in |stdin|, we pass them immediately through to |stdout|
  148. with little further ado.
  149. An apostrophe is rejected unless it is immediately followed by a letter.
  150.  
  151. @<Labeled code...@>=
  152. out_word: putchar(c);
  153. continue_word: c=getchar();
  154. checkout_word:
  155. if (isalpha(c)) goto out_word;
  156. if (c=='\'') {
  157.   c=getchar();
  158.   if (isalpha(c)) {
  159.     putchar('\'');@+goto out_word;
  160.   }
  161.   goto end_word;
  162. }
  163. if (c=='\\' && controlseq()) goto control_seq_in_word;
  164. end_word: putchar('\n');
  165.   goto main_cycle;
  166.  
  167. @* Control sequences.  The |controlseq()| function is the only
  168. delicate part of this program.  After a backslash has been scanned,
  169. |controlseq| looks to see if the next characters define one of the
  170. special plain \TEX/ macros listed above. If so, the control sequence
  171. and its immediately following argument (if any) are output and
  172. |controlseq| returns a nonzero value. If not, nothing is output and
  173. |controlseq| returns zero. In both cases the value of |c| will be
  174. nonzero if and only if |controlseq| has had to look ahead at a
  175. character it decided not to process.
  176.  
  177. @ @<Labeled code...@>=
  178. control_seq_in_word: if (!c) goto continue_word;
  179. goto checkout_word;
  180.  
  181. @ @<Special cases...@>=
  182. case '\\': if (controlseq()) goto control_seq_in_word;
  183. goto main_cycle;
  184.  
  185. @ @<Procedures@>=
  186. int controlseq()
  187. {
  188.   int l; /* number of letters in the control sequence */
  189.   char a,b; /* the first two characters after `\.\\' */
  190.   l=0;
  191.   a=c=getchar();
  192.   while (isalpha(c)) {
  193.     l++;
  194.     c=getchar();
  195.     if (l==1) b=c;
  196.   }
  197.   if (l==0) c=getchar();
  198.   @<Check for special plain \TEX/ control sequences;
  199.     output them and |return 1| if found@>;
  200.   return 0;
  201. }
  202.  
  203. @ @d pair(x,y) (a==x && b==y)
  204.  
  205. @<Check for special...@>=
  206. if ((a>='"' && a<='~' && ptab[a-'"']==l) ||
  207.  (l==2 && (pair('a','e') || pair('A','E')@|
  208.            || pair('o','e') || pair('O','E')@|
  209.            || pair('a','a') || pair('A','A') || pair('s','s')))) {
  210.   putchar('\\');
  211.   putchar(a);
  212.   if (l==2) putchar(b);
  213.   if (l && c==' ') {
  214.     putchar(' '); /* optional space after alphabetic control sequence */
  215.     c=getchar();
  216.   }
  217.   if (c=='{') {
  218.     do@+{putchar(c);
  219.       c=get();
  220.     }@+while (c!='}'); /* optional argument after special control sequence */
  221.     putchar(c);
  222.     c=0;
  223.   }
  224.   return 1;
  225. }
  226.  
  227. @ The |ptab| entries for nonletters are 0 when the control sequence is
  228. special, otherwise~1; the conventions for letters are reversed.
  229.  
  230. @<Global...@>=
  231. char ptab[]={0,1,1,1,1,0, /* \.{\\"} and \.{\\'} */
  232.   1,1,1,1,1,1,0,1, /* \.{\\.} */
  233.   1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1, /* \.{\\=} */
  234.   1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1, /* \.{\\H}, \.{\\L}, \.{\\O} */
  235.   0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1, /* \.{\\\^} */
  236.   0,0,1,1,1,0,0,0, /* \.{\\`}, \.{\\b}, \.{\\c}, \.{\\d} */
  237.   0,1,1,0,1,0,0,1, /* \.{\\i}, \.{\\j}, \.{\\l}, \.{\\o} */
  238.   0,0,0,0,1,1,1,0, /* \.{\\t}, \.{\\u}, \.{\\v} */
  239.   0,0,0,1,1,1,0}; /* \.{\\\~} */
  240.  
  241. @ In \.{CWEB} the \TEX/ control sequence `\.{\\.}' denotes the typewriter
  242. font used for strings, not the dot-over accent. We must modify
  243. |ptab| to reflect this unfortunate (but too-late-too-change) design decision.
  244.  
  245. @<Adjust tables for \.{CWEB} mode@>=
  246. ptab[12]=1;
  247.  
  248. @* CWEB considerations.
  249. We're finished now with all that wou