428
+ − 1 %{
+ − 2
+ − 3 /* This is a Lex file. */
+ − 4
+ − 5 /* Localizable-message snarfing.
+ − 6 Copyright (C) 1994, 1995 Amdahl Corporation.
+ − 7
+ − 8 This file is part of XEmacs.
+ − 9
+ − 10 XEmacs is free software; you can redistribute it and/or modify
+ − 11 it under the terms of the GNU General Public License as published by
+ − 12 the Free Software Foundation; either version 2, or (at your option)
+ − 13 any later version.
+ − 14
+ − 15 XEmacs is distributed in the hope that it will be useful,
+ − 16 but WITHOUT ANY WARRANTY; without even the implied warranty of
+ − 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ − 18 GNU General Public License for more details.
+ − 19
+ − 20 You should have received a copy of the GNU General Public License
+ − 21 along with XEmacs; see the file COPYING. If not, write to
+ − 22 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ − 23 Boston, MA 02111-1307, USA. */
+ − 24
+ − 25 /* Written by Ben Wing, November 1994. Some code based on earlier
+ − 26 make-msgfile.c. */
+ − 27
2367
+ − 28 /* See text.c for a proposal about how this whole system should work. */
+ − 29
428
+ − 30 /* Note: there is still much work to be done on this.
+ − 31
+ − 32 1) Definition of Arg below won't handle a generalized argument
+ − 33 as might appear in a function call. This is fine for DEFUN
+ − 34 and friends, because only simple arguments appear there; but
+ − 35 it might run into problems if Arg is used for other sorts
+ − 36 of functions.
+ − 37 2) snarf() should be modified so that it doesn't output null
+ − 38 strings and non-textual strings (see the comment at the top
+ − 39 of make-msgfile.c).
+ − 40 3) parsing of (insert) should snarf all of the arguments.
+ − 41 4) need to add set-keymap-prompt and deal with gettext of that.
+ − 42 5) parsing of arguments should snarf all strings anywhere within
+ − 43 the arguments, rather than just looking for a string as the
+ − 44 argument. This allows if statements as arguments to get parsed.
+ − 45 6) begin_paren_counting() et al. should handle recursive entry.
+ − 46 7) handle set-window-buffer and other such functions that take
+ − 47 a buffer as the other-than-first argument.
+ − 48 8) there is a fair amount of work to be done on the C code.
+ − 49 Look through the code for #### comments associated with
+ − 50 '#ifdef I18N3' or with an I18N3 nearby.
+ − 51 9) Deal with `get-buffer-process' et al.
+ − 52 10) Many of the changes in the Lisp code marked
+ − 53 'rewritten for I18N3 snarfing' should be undone once (5) is
+ − 54 implemented.
+ − 55 11) Go through the Lisp code in prim and make sure that all
+ − 56 strings are gettexted as necessary. This may reveal more
+ − 57 things to implement.
+ − 58 12) Do the equivalent of (8) for the Lisp code.
+ − 59 13) Deal with parsing of menu specifications.
+ − 60
+ − 61 --ben
+ − 62
+ − 63 */
+ − 64
+ − 65 /* Some notes:
+ − 66
+ − 67 -- {Arg} below could get confused by commas inside of quotes.
+ − 68 -- {LispToken} below can match some things that are not tokens (e.g.
+ − 69 numbers) but for all practical purposes it should be fine.
+ − 70 */
+ − 71
+ − 72 #include <stdio.h>
+ − 73
+ − 74 int snarf_return_state;
+ − 75
+ − 76 %}
+ − 77
+ − 78 %p 6000
+ − 79 %e 2000
+ − 80 %n 1000
+ − 81 %a 4000
+ − 82 %s C_QUOTE C_COMMENT LQUO LCOM
+ − 83 %s CSNARF LSNARF
+ − 84 %s DO_C DO_LISP DEFUN
+ − 85 %s DEFUN2 DEFUN3 LDEF
+ − 86
+ − 87 W [ \t\n]
+ − 88 Any (.|"\n")
+ − 89 Q "\""
+ − 90 NQ [^"]
+ − 91 NT [^A-Za-z_0-9]
+ − 92 LP "("
+ − 93 RP ")"
+ − 94 BS "\\"
+ − 95 Esc ({BS}{Any})
+ − 96 Wh ({W}*)
+ − 97 LCom (";"({Esc}|.)*)
+ − 98 LWh (({W}|{Lcom})*)
+ − 99 Open ({Wh}{LP})
+ − 100 OpWQ ({Open}{Wh}{Q})
+ − 101 String ({Q}({Esc}|{NQ})*{Q})
+ − 102 Arg ([^,]*",")
+ − 103 StringArg ({Wh}{String}{Wh}",")
+ − 104 OpenString ({Open}{StringArg})
+ − 105 LispToken (({Esc}|[-A-Za-z0-9!@$%^&*_=+|{}`~,<.>/?])+)
+ − 106 %%
+ − 107
+ − 108 <DO_C>{NT}"GETTEXT"{OpWQ} { snarf (); }
+ − 109 <DO_C>{NT}"DEFER_GETTEXT"{OpWQ} { snarf (); }
+ − 110 <DO_C>{NT}"build_translated_string"{OpWQ} { snarf (); }
+ − 111 <DO_C>{NT}"insert_string"{OpWQ} { snarf (); }
+ − 112 <DO_C>{NT}"message"{OpWQ} { snarf (); }
+ − 113 <DO_C>{NT}"warn_when_safe"{OpWQ} { snarf (); }
+ − 114 <DO_C>{NT}"error"{OpWQ} { snarf (); }
+ − 115 <DO_C>{NT}"continuable_error"{OpWQ} { snarf (); }
+ − 116 <DO_C>{NT}"signal_simple_error"{OpWQ} { snarf (); }
+ − 117 <DO_C>{NT}"signal_simple_error_2"{OpWQ} { snarf (); }
+ − 118 <DO_C>{NT}"signal_simple_continuable_error"{OpWQ} { snarf (); }
+ − 119 <DO_C>{NT}"signal_simple_continuable_error_2"{OpWQ} { snarf (); }
+ − 120 <DO_C>{NT}"report_file_error"{OpWQ} { snarf (); }
+ − 121 <DO_C>{NT}"signal_file_error"{OpWQ} { snarf (); }
+ − 122 <DO_C>{NT}"signal_double_file_error"{OpWQ} { snarf (); }
+ − 123 <DO_C>{NT}"signal_double_file_error_2"{OpWQ} { snarf (); }
+ − 124 <DO_C>{NT}"syntax_error"{OpWQ} { snarf (); }
+ − 125 <DO_C>{NT}"continuable_syntax_error"{OpWQ} { snarf (); }
+ − 126 <DO_C>{NT}"CTB_ERROR"{OpWQ} { snarf (); }
+ − 127 <DO_C>{NT}"fatal"{OpWQ} { snarf (); }
+ − 128 <DO_C>{NT}"stdout_out"{OpWQ} { snarf (); }
+ − 129 <DO_C>{NT}"stderr_out"{OpWQ} { snarf (); }
+ − 130 <DO_C>{NT}"with_output_to_temp_buffer"{OpWQ} { snarf (); }
+ − 131
+ − 132 <DO_C>{NT}"DEFVAR_BOOL"{OpenString}{Arg}{Wh}{Q} { snarf (); }
+ − 133 <DO_C>{NT}"DEFVAR_LISP"{OpenString}{Arg}{Wh}{Q} { snarf (); }
+ − 134 <DO_C>{NT}"DEFVAR_SPECIFIER"{OpenString}{Arg}{Wh}{Q} { snarf (); }
+ − 135 <DO_C>{NT}"DEFVAR_INT"{OpenString}{Arg}{Wh}{Q} { snarf (); }
+ − 136 <DO_C>{NT}"DEFVAR_BUFFER_LOCAL"{OpenString}{Arg}{Wh}{Q} { snarf (); }
+ − 137 <DO_C>{NT}"DEFVAR_BUFFER_DEFAULTS"{OpenString}{Arg}{Wh}{Q} { snarf (); }
+ − 138 <DO_C>{NT}"deferror"{Open}{Arg}{StringArg}{Wh}{Q} { snarf (); }
+ − 139
+ − 140 <DO_C>{NT}"barf_or_query_if_file_exists"{Open}{Arg}{Wh}{Q} {
+ − 141 /* #### see comment above about use of Arg */
+ − 142 snarf ();
+ − 143 }
+ − 144
+ − 145 <DO_C>{NT}"DEFUN"{Open} { BEGIN DEFUN; }
+ − 146
+ − 147 <DO_C>"/*" {
+ − 148 /* This is hateful, but doc strings are sometimes put inside of comments
+ − 149 (to get around limits in cpp), so we can't ignore stuff inside of
+ − 150 comments. */
+ − 151 /* BEGIN C_COMMENT; */
+ − 152 }
+ − 153 <DO_C>{Q} { BEGIN C_QUOTE; }
+ − 154 <DO_C>{Any} { }
+ − 155
+ − 156 <DEFUN>{StringArg}{Arg}{Arg}{Arg}{Arg}{Wh} { BEGIN DEFUN2; }
+ − 157 <DEFUN>{Any} { bad_c_defun (); }
+ − 158
+ − 159 <DEFUN2>{Q} {
+ − 160 /* We found an interactive specification. */
+ − 161 snarf_return_state = DEFUN3;
+ − 162 snarf ();
+ − 163 }
+ − 164 <DEFUN2>[^,]* {
+ − 165 /* This function doesn't have an interactive specification.
+ − 166 Don't use {Arg} in the specification because DEFUN3 looks
+ − 167 for the comma. */
+ − 168 BEGIN DEFUN3;
+ − 169 }
+ − 170
+ − 171 <DEFUN3>{Wh}","{Wh}{Q} {
+ − 172 snarf_return_state = DO_C;
+ − 173 snarf ();
+ − 174 }
+ − 175 <DEFUN3>{Any} { bad_c_defun (); }
+ − 176
+ − 177 <C_QUOTE>{Esc} { }
+ − 178 <C_QUOTE>{Q} { BEGIN DO_C; }
+ − 179 <C_QUOTE>{Any} { }
+ − 180
+ − 181 <C_COMMENT>"*/" { BEGIN DO_C; }
+ − 182 <C_COMMENT>{Any} { }
+ − 183
+ − 184 <DO_LISP>{LP}{LWh}"gettext"{LWh}{Q} { inc_paren (); snarf (); }
+ − 185 <DO_LISP>{LP}{LWh}"purecopy"{LWh}{Q} { inc_paren (); snarf (); }
+ − 186 <DO_LISP>{LP}{LWh}"interactive"{LWh}{Q} { inc_paren (); snarf (); }
+ − 187 <DO_LISP>{LP}{LWh}"message"{LWh}{Q} { inc_paren (); snarf (); }
+ − 188 <DO_LISP>{LP}{LWh}"error"{LWh}{Q} { inc_paren (); snarf (); }
+ − 189 <DO_LISP>{LP}{LWh}"warn"{LWh}{Q} { inc_paren (); snarf (); }
+ − 190 <DO_LISP>{LP}{LWh}"format"{LWh}{Q} { inc_paren (); snarf (); }
+ − 191 <DO_LISP>{LP}{LWh}"substitute-command-keys"{LWh}{Q} { inc_paren (); snarf (); }
+ − 192 <DO_LISP>{LP}{LWh}"temp-minibuffer-message"{LWh}{Q} { inc_paren (); snarf (); }
+ − 193 <DO_LISP>{LP}{LWh}"momentary-string-display"{LWh}{Q} { inc_paren (); snarf (); }
+ − 194 <DO_LISP>{LP}{LWh}"princ"{LWh}{Q} { inc_paren (); snarf (); }
+ − 195 <DO_LISP>{LP}{LWh}"prin1"{LWh}{Q} { inc_paren (); snarf (); }
+ − 196 <DO_LISP>{LP}{LWh}"prin1-to-string"{LWh}{Q} { inc_paren (); snarf (); }
+ − 197 <DO_LISP>{LP}{LWh}"print"{LWh}{Q} { inc_paren (); snarf (); }
+ − 198 <DO_LISP>{LP}{LWh}"insert"{LWh}{Q} { inc_paren (); snarf (); }
+ − 199 <DO_LISP>{LP}{LWh}"insert-before-markers"{LWh}{Q} { inc_paren (); snarf (); }
+ − 200
+ − 201 <DO_LISP>{LP}{LWh}"get-buffer"{LWh}{Q} { inc_paren (); snarf (); }
+ − 202 <DO_LISP>{LP}{LWh}"get-buffer-create"{LWh}{Q} { inc_paren (); snarf (); }
+ − 203 <DO_LISP>{LP}{LWh}"generate-new-buffer-name"{LWh}{Q} { inc_paren (); snarf (); }
+ − 204 <DO_LISP>{LP}{LWh}"rename-buffer"{LWh}{Q} { inc_paren (); snarf (); }
+ − 205 <DO_LISP>{LP}{LWh}"set-buffer"{LWh}{Q} { inc_paren (); snarf (); }
+ − 206 <DO_LISP>{LP}{LWh}"switch-to-buffer"{LWh}{Q} { inc_paren (); snarf (); }
+ − 207 <DO_LISP>{LP}{LWh}"pop-to-buffer"{LWh}{Q} { inc_paren (); snarf (); }
+ − 208 <DO_LISP>{LP}{LWh}"with-output-to-temp-buffer"{LWh}{Q} { inc_paren (); snarf (); }
+ − 209 <DO_LISP>{LP}{LWh}"buffer-enable-undo"{LWh}{Q} { inc_paren (); snarf (); }
+ − 210 <DO_LISP>{LP}{LWh}"buffer-disable-undo"{LWh}{Q} { inc_paren (); snarf (); }
+ − 211 <DO_LISP>{LP}{LWh}"get-buffer-window"{LWh}{Q} { inc_paren (); snarf (); }
+ − 212 <DO_LISP>{LP}{LWh}"delete-windows-on"{LWh}{Q} { inc_paren (); snarf (); }
+ − 213 <DO_LISP>{LP}{LWh}"replace-buffer-in-windows"{LWh}{Q} { inc_paren (); snarf (); }
+ − 214 <DO_LISP>{LP}{LWh}"display-buffer"{LWh}{Q} { inc_paren (); snarf (); }
+ − 215 <DO_LISP>{LP}{LWh}"other-buffer"{LWh}{Q} { inc_paren (); snarf (); }
+ − 216
+ − 217 <DO_LISP>{LP}{LWh}"read-from-minibuffer"{LWh}{Q} { inc_paren (); snarf (); }
+ − 218 <DO_LISP>{LP}{LWh}"read-shell-command"{LWh}{Q} { inc_paren (); snarf (); }
+ − 219 <DO_LISP>{LP}{LWh}"read-file-name"{LWh}{Q} { inc_paren (); snarf (); }
+ − 220 <DO_LISP>{LP}{LWh}"read-buffer"{LWh}{Q} { inc_paren (); snarf (); }
+ − 221 <DO_LISP>{LP}{LWh}"read-variable"{LWh}{Q} { inc_paren (); snarf (); }
+ − 222 <DO_LISP>{LP}{LWh}"read-command"{LWh}{Q} { inc_paren (); snarf (); }
+ − 223 <DO_LISP>{LP}{LWh}"read-function"{LWh}{Q} { inc_paren (); snarf (); }
+ − 224 <DO_LISP>{LP}{LWh}"read-directory-name"{LWh}{Q} { inc_paren (); snarf (); }
+ − 225 <DO_LISP>{LP}{LWh}"read-string"{LWh}{Q} { inc_paren (); snarf (); }
+ − 226 <DO_LISP>{LP}{LWh}"read-number"{LWh}{Q} { inc_paren (); snarf (); }
+ − 227 <DO_LISP>{LP}{LWh}"read-minibuffer"{LWh}{Q} { inc_paren (); snarf (); }
+ − 228 <DO_LISP>{LP}{LWh}"read-quoted-char"{LWh}{Q} { inc_paren (); snarf (); }
+ − 229 <DO_LISP>{LP}{LWh}"read-face-name"{LWh}{Q} { inc_paren (); snarf (); }
+ − 230 <DO_LISP>{LP}{LWh}"read-itimer"{LWh}{Q} { inc_paren (); snarf (); }
+ − 231 <DO_LISP>{LP}{LWh}"completing-read"{LWh}{Q} { inc_paren (); snarf (); }
+ − 232 <DO_LISP>{LP}{LWh}"y-or-n-p"{LWh}{Q} { inc_paren (); snarf (); }
+ − 233 <DO_LISP>{LP}{LWh}"yes-or-no-p"{LWh}{Q} { inc_paren (); snarf (); }
+ − 234 <DO_LISP>{LP}{LWh}"query-replace-read-args"{LWh}{Q} { inc_paren (); snarf (); }
+ − 235 <DO_LISP>{LP}{LWh}"eval-minibuffer"{LWh}{Q} { inc_paren (); snarf (); }
+ − 236 <DO_LISP>{LP}{LWh}"edit-and-eval-command"{LWh}{Q} { inc_paren (); snarf (); }
+ − 237
+ − 238 <DO_LISP>{LP}{LWh}"defvar"{LWh}{LispToken}{LWh} {
+ − 239 inc_paren (); begin_paren_counting (LDEF);
+ − 240 }
+ − 241 <DO_LISP>{LP}{LWh}"defconst"{LWh}{LispToken}{LWh} {
+ − 242 inc_paren (); begin_paren_counting (LDEF);
+ − 243 }
+ − 244 <DO_LISP>{LP}{LWh}"defun"{LWh}{LispToken}{LWh} {
+ − 245 inc_paren (); begin_paren_counting (LDEF);
+ − 246 }
+ − 247 <DO_LISP>{LP}{LWh}"defmacro"{LWh}{LispToken}{LWh} {
+ − 248 inc_paren (); begin_paren_counting (LDEF);
+ − 249 }
+ − 250 <DO_LISP>{LP}{LWh}"defsubst"{LWh}{LispToken}{LWh} {
+ − 251 inc_paren (); begin_paren_counting (LDEF);
+ − 252 }
+ − 253
+ − 254 <DO_LISP>{Q} { BEGIN LQUO; }
+ − 255 <DO_LISP>";" { BEGIN LCOM; }
+ − 256 <DO_LISP>{LP} { inc_paren (); }
+ − 257 <DO_LISP>{RP} { dec_paren (); }
+ − 258 <DO_LISP>{Esc} { }
+ − 259 <DO_LISP>{W} { lisp_whitespace (); }
+ − 260 <DO_LISP>{Any} { }
+ − 261
+ − 262 <LQUO>{Esc} { }
+ − 263 <LQUO>{Q} { BEGIN DO_LISP; }
+ − 264 <LQUO>{Any} { }
+ − 265
+ − 266 <LCOM>"\n" { BEGIN DO_LISP; }
+ − 267 <LCOM>{Any} { }
+ − 268
+ − 269 <LDEF>{LWh}{Q} { snarf (); }
+ − 270 <LDEF>{Any} { BEGIN DO_LISP; }
+ − 271
+ − 272 <CSNARF>{Esc} { ECHO; }
+ − 273 <CSNARF>{Q} { ECHO; fprintf (yyout, ")\n"); BEGIN snarf_return_state; }
+ − 274 <CSNARF>{Any} { ECHO; }
+ − 275
+ − 276 <LSNARF>{Esc} { ECHO; }
+ − 277 <LSNARF>"\n" { fprintf (yyout, "\\n\\\n"); }
+ − 278 <LSNARF>{Q} { ECHO; fprintf (yyout, ")\n"); BEGIN snarf_return_state; }
+ − 279 <LSNARF>{Any} { ECHO; }
+ − 280
+ − 281 %%
+ − 282
+ − 283 enum filetype { C_FILE, LISP_FILE, INVALID_FILE };
+ − 284 /* some brain-dead headers define this ... */
+ − 285 #undef FALSE
+ − 286 #undef TRUE
+ − 287 enum boolean { FALSE, TRUE };
+ − 288
+ − 289 void scan_file (char *filename);
+ − 290 void process_C_file (void);
+ − 291 void process_Lisp_file (void);
+ − 292
+ − 293 int in_c;
+ − 294 int in_paren_counting, paren_count;
+ − 295 int paren_return_state;
+ − 296
+ − 297 snarf ()
+ − 298 {
+ − 299 fprintf (yyout, "gettext(\"");
+ − 300 if (in_c)
+ − 301 BEGIN CSNARF;
+ − 302 else
+ − 303 BEGIN LSNARF;
+ − 304 }
+ − 305
+ − 306 bad_c_defun ()
+ − 307 {
+ − 308 fprintf (stderr, "Warning: Invalid DEFUN encountered in C, line %d.\n",
+ − 309 yylineno);
+ − 310 snarf_return_state = DO_C;
+ − 311 BEGIN DO_C;
+ − 312 /* REJECT; Sun's lex is broken! Use Flex! */
+ − 313 }
+ − 314
+ − 315 bad_lisp_def ()
+ − 316 {
+ − 317 fprintf (stderr,
+ − 318 "Warning: Invalid defmumble encountered in Lisp, line %d.\n",
+ − 319 yylineno);
+ − 320 snarf_return_state = DO_LISP;
+ − 321 BEGIN DO_LISP;
+ − 322 /* REJECT; Sun's lex is broken! Use Flex! */
+ − 323 }
+ − 324
+ − 325 inc_paren ()
+ − 326 {
+ − 327 if (in_paren_counting)
+ − 328 paren_count++;
+ − 329 }
+ − 330
+ − 331 dec_paren ()
+ − 332 {
+ − 333 if (in_paren_counting)
+ − 334 {
+ − 335 /* If we find a right paren without a matching left paren, it usually
+ − 336 just indicates a statement like
+ − 337
+ − 338 (defvar foo-mumble nil)
+ − 339
+ − 340 where 'nil' is the sexp we are skipping over, and there's no
+ − 341 doc string. */
+ − 342 if (paren_count > 0)
+ − 343 paren_count--;
+ − 344 else
+ − 345 unput (')');
+ − 346 if (paren_count == 0)
+ − 347 {
+ − 348 in_paren_counting = 0;
+ − 349 BEGIN paren_return_state;
+ − 350 }
+ − 351 }
+ − 352 }
+ − 353
+ − 354 /* #### begin_paren_counting () does not handle recursive entries */
+ − 355
+ − 356 begin_paren_counting (int return_state)
+ − 357 {
+ − 358 in_paren_counting = 1;
+ − 359 paren_count = 0;
+ − 360 paren_return_state = return_state;
+ − 361 }
+ − 362
+ − 363 lisp_whitespace ()
+ − 364 {
+ − 365 if (in_paren_counting && !paren_count)
+ − 366 {
+ − 367 /* We got to the end of a token and we're not in a parenthesized
+ − 368 expression, so we're at the end of an sexp. */
+ − 369 in_paren_counting = 0;
+ − 370 BEGIN paren_return_state;
+ − 371 }
+ − 372 }
+ − 373
+ − 374 yywrap ()
+ − 375 {
+ − 376 return 1;
+ − 377 }
+ − 378
+ − 379 main (int argc, char *argv[])
+ − 380 {
+ − 381 register int i;
+ − 382
+ − 383 yyout = stdout;
+ − 384
+ − 385 /* If first two args are -o FILE, output to FILE. */
+ − 386 i = 1;
+ − 387 if (argc > i + 1 && strcmp (argv[i], "-o") == 0) {
+ − 388 yyout = fopen (argv[++i], "w");
+ − 389 ++i;
+ − 390 }
+ − 391 /* ...Or if args are -a FILE, append to FILE. */
+ − 392 if (argc > i + 1 && strcmp (argv[i], "-a") == 0) {
+ − 393 yyout = fopen (argv[++i], "a");
+ − 394 ++i;
+ − 395 }
+ − 396 if (!yyout) {
+ − 397 fprintf (stderr, "Unable to open output file %s\n", argv[--i]);
+ − 398 return;
+ − 399 }
+ − 400
+ − 401 for (; i < argc; i++)
+ − 402 scan_file (argv[i]);
+ − 403
+ − 404 return 0;
+ − 405 }
+ − 406
+ − 407
+ − 408 void scan_file (char *filename)
+ − 409 {
+ − 410 enum filetype type = INVALID_FILE;
+ − 411 register char *p = filename + strlen (filename);
+ − 412
+ − 413 if (strcmp (p - 4, ".elc") == 0) {
+ − 414 *--p = '\0'; /* Use .el file instead */
+ − 415 type = LISP_FILE;
+ − 416 } else if (strcmp (p - 3, ".el") == 0)
+ − 417 type = LISP_FILE;
+ − 418 else if (strcmp (p - 2, ".o") == 0) {
+ − 419 *--p = 'c'; /* Use .c file instead */
+ − 420 type = C_FILE;
+ − 421 } else if (strcmp (p - 2, ".c") == 0)
+ − 422 type = C_FILE;
+ − 423
+ − 424 if (type == INVALID_FILE) {
+ − 425 fprintf (stderr, "File %s being ignored\n", filename);
+ − 426 return;
+ − 427 }
+ − 428 yyin = fopen (filename, "r");
+ − 429 if (!yyin) {
+ − 430 fprintf (stderr, "Unable to open input file %s\n", filename);
+ − 431 return;
+ − 432 }
+ − 433
+ − 434 fprintf (yyout, "/* %s */\n", filename);
+ − 435 if (type == C_FILE)
+ − 436 process_C_file ();
+ − 437 else
+ − 438 process_Lisp_file ();
+ − 439 fputc ('\n', yyout);
+ − 440
+ − 441 fclose (yyin);
+ − 442 }
+ − 443
+ − 444 void process_C_file ()
+ − 445 {
+ − 446 snarf_return_state = DO_C;
+ − 447 in_c = 1;
+ − 448 BEGIN DO_C;
+ − 449 yylex ();
+ − 450 }
+ − 451
+ − 452 void process_Lisp_file ()
+ − 453 {
+ − 454 snarf_return_state = DO_LISP;
+ − 455 in_c = 0;
+ − 456 BEGIN DO_LISP;
+ − 457 yylex ();
+ − 458 }
+ − 459
