Mercurial > hg > xemacs-beta
view lib-src/make-msgfile.lex @ 5142:f965e31a35f0
reduce lcrecord headers to 2 words, rename printing_unreadable_object
-------------------- ChangeLog entries follow: --------------------
man/ChangeLog addition:
2010-03-13 Ben Wing <ben@xemacs.org>
* internals/internals.texi (Working with Lisp Objects):
* internals/internals.texi (Writing Macros):
* internals/internals.texi (lrecords):
More rewriting to correspond with changes from
*LRECORD* to *LISP_OBJECT*.
modules/ChangeLog addition:
2010-03-13 Ben Wing <ben@xemacs.org>
* postgresql/postgresql.c (print_pgconn):
* postgresql/postgresql.c (print_pgresult):
printing_unreadable_object -> printing_unreadable_object_fmt.
2010-03-13 Ben Wing <ben@xemacs.org>
* ldap/eldap.c (print_ldap):
printing_unreadable_object -> printing_unreadable_object_fmt.
src/ChangeLog addition:
2010-03-13 Ben Wing <ben@xemacs.org>
* alloc.c (alloc_sized_lrecord_1):
* alloc.c (alloc_sized_lrecord_array):
* alloc.c (old_alloc_sized_lcrecord):
* alloc.c (disksave_object_finalization_1):
* alloc.c (mark_lcrecord_list):
* alloc.c (alloc_managed_lcrecord):
* alloc.c (free_managed_lcrecord):
* alloc.c (tick_lcrecord_stats):
* alloc.c (sweep_lcrecords_1):
* buffer.c (print_buffer):
* buffer.c (DEFVAR_BUFFER_LOCAL_1):
* casetab.c:
* casetab.c (print_case_table):
* console.c (print_console):
* console.c (DEFVAR_CONSOLE_LOCAL_1):
* data.c (print_weak_list):
* data.c (print_weak_box):
* data.c (print_ephemeron):
* data.c (ephemeron_equal):
* database.c (print_database):
* database.c (finalize_database):
* device-msw.c (sync_printer_with_devmode):
* device-msw.c (print_devmode):
* device-msw.c (finalize_devmode):
* device.c:
* device.c (print_device):
* elhash.c:
* elhash.c (print_hash_table):
* eval.c (print_subr):
* eval.c (print_multiple_value):
* event-stream.c (event_stream_resignal_wakeup):
* events.c (clear_event_resource):
* events.c (zero_event):
* events.c (print_event):
* extents.c:
* extents.c (print_extent):
* file-coding.c (print_coding_system):
* font-mgr.c:
* font-mgr.c (Ffc_init):
* frame.c:
* frame.c (print_frame):
* gc.c:
* gc.c (GC_CHECK_NOT_FREE):
* glyphs.c:
* glyphs.c (print_image_instance):
* glyphs.c (print_glyph):
* gui.c (print_gui_item):
* gui.c (copy_gui_item):
* keymap.c (print_keymap):
* keymap.c (MARKED_SLOT):
* lisp.h:
* lisp.h (struct Lisp_String):
* lisp.h (DEFUN):
* lisp.h (DEFUN_NORETURN):
* lrecord.h:
* lrecord.h (NORMAL_LISP_OBJECT_UID):
* lrecord.h (struct lrecord_header):
* lrecord.h (set_lheader_implementation):
* lrecord.h (struct old_lcrecord_header):
* lrecord.h (struct free_lcrecord_header):
* marker.c (print_marker):
* mule-charset.c:
* mule-charset.c (print_charset):
* objects.c (print_color_instance):
* objects.c (print_font_instance):
* objects.c (finalize_font_instance):
* print.c (print_cons):
* print.c (printing_unreadable_object_fmt):
* print.c (printing_unreadable_lisp_object):
* print.c (external_object_printer):
* print.c (internal_object_printer):
* print.c (debug_p4):
* print.c (ext_print_begin):
* process.c (print_process):
* rangetab.c (print_range_table):
* rangetab.c (range_table_equal):
* scrollbar.c (free_scrollbar_instance):
* specifier.c (print_specifier):
* specifier.c (finalize_specifier):
* symbols.c (guts_of_unbound_marker):
* symeval.h:
* symeval.h (DEFVAR_SYMVAL_FWD):
* tooltalk.c:
* tooltalk.c (print_tooltalk_message):
* tooltalk.c (print_tooltalk_pattern):
* ui-gtk.c (ffi_object_printer):
* ui-gtk.c (emacs_gtk_object_printer):
* ui-gtk.c (emacs_gtk_boxed_printer):
* window.c (print_window):
* window.c (free_window_mirror):
* window.c (debug_print_window):
* xemacs.def.in.in:
(1) printing_unreadable_object -> printing_unreadable_object_fmt.
(2) printing_unreadable_lcrecord -> printing_unreadable_lisp_object
and fix up so it no longer requires an lcrecord.
These previous changes eliminate most of the remaining places where
the terms `lcrecord' and `lrecord' occurred outside of specialized
code.
(3) Fairly major change: Reduce the number of words in an lcrecord
from 3 to 2. The third word consisted of a uid that duplicated the
lrecord uid, and a single free bit, which was moved into the lrecord
structure. This reduces the size of the `uid' slot from 21 bits to
20 bits. Arguably this isn't enough -- we could easily have more than
1,000,000 or so objects created in a session. The answer is
(a) It doesn't really matter if we overflow the uid field because
it's only used for debugging, to identify an object uniquely
(or pretty much so).
(b) If we cared about it overflowing and wanted to reduce this,
we could make it so that cons, string, float and certain other
frob-block types that never print out the uid simply don't
store a uid in them and don't increment the lrecord_uid_counter.
(4) In conjunction with (3), create new macro NORMAL_LISP_OBJECT_UID()
and use it to abstract out the differences between NEWGC and old-GC
in accessing the `uid' value from a "normal Lisp Object pointer".
(5) In events.c, use zero_nonsized_lisp_object() in place of custom-
written equivalent. In font-mgr.c use external_object_printer()
in place of custom-written equivalents.
author | Ben Wing <ben@xemacs.org> |
---|---|
date | Sat, 13 Mar 2010 05:38:08 -0600 (2010-03-13) |
parents | c50b0b3c7b8d |
children | 308d34e9f07d |
line wrap: on
line source
%{ /* This is a Lex file. */ /* Localizable-message snarfing. Copyright (C) 1994, 1995 Amdahl Corporation. Copyright (C) 2010 Ben Wing. This file is part of XEmacs. XEmacs is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. XEmacs is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with XEmacs; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Written by Ben Wing, November 1994. Some code based on earlier make-msgfile.c. */ /* #### A comment: Directly writing a lex file isn't right. We want to be able to specify functions to snarf in simpler ways, e.g. BEGIN_C_FUNCS weird_doc (arg, snarf, snarf, arg); signal_error (arg, snarf, arg); etc. END_C_FUNCS In this case, `arg' indicates an arbitrary argument and `snarf' indicates that when a quoted string is seen, it should be snarfed. Then either we write a program to read this script and directly snarf messages, or we write a program to convert the script into lex. --ben, 1/26/10 */ /* See text.c for a proposal about how this whole system should work. */ /* Note: there is still much work to be done on this. 1) Definition of Arg below won't handle a generalized argument as might appear in a function call. This is fine for DEFUN and friends, because only simple arguments appear there; but it might run into problems if Arg is used for other sorts of functions. 2) snarf() should be modified so that it doesn't output null strings and non-textual strings (see the comment at the top of make-msgfile.c). 3) parsing of (insert) should snarf all of the arguments. 4) need to add set-keymap-prompt and deal with gettext of that. 5) parsing of arguments should snarf all strings anywhere within the arguments, rather than just looking for a string as the argument. This allows if statements as arguments to get parsed. 6) begin_paren_counting() et al. should handle recursive entry. 7) handle set-window-buffer and other such functions that take a buffer as the other-than-first argument. 8) there is a fair amount of work to be done on the C code. Look through the code for #### comments associated with '#ifdef I18N3' or with an I18N3 nearby. 9) Deal with `get-buffer-process' et al. 10) Many of the changes in the Lisp code marked 'rewritten for I18N3 snarfing' should be undone once (5) is implemented. 11) Go through the Lisp code in prim and make sure that all strings are gettexted as necessary. This may reveal more things to implement. 12) Do the equivalent of (8) for the Lisp code. 13) Deal with parsing of menu specifications. --ben */ /* Some notes: -- {Arg} below could get confused by commas inside of quotes. -- {LispToken} below can match some things that are not tokens (e.g. numbers) but for all practical purposes it should be fine. */ #include <stdio.h> int snarf_return_state; %} %p 6000 %e 2000 %n 1000 %a 4000 %s C_QUOTE C_COMMENT LQUO LCOM %s CSNARF LSNARF %s DO_C DO_LISP DEFUN %s DEFUN2 DEFUN3 LDEF W [ \t\n] Any .|\n Q \" Cm , NQ [^\"] NT [^A-Za-z_0-9] LP "(" RP ")" NQP [^\"()] NQPCm [^,\"()] BS "\\" Esc ({BS}{Any}) Wh ({W}*) LCom (;({Esc}|.)*) LWh ({W}|{LCom})* Open {Wh}{LP} OpWQ {Open}{Wh}{Q} String {Q}({Esc}|{NQ})*{Q} ParenExpr5 "("({String}|{NQP})*")" ParenExpr4 "("({String}|{NQP}|{ParenExpr5})*")" ParenExpr3 "("({String}|{NQP}|{ParenExpr4})*")" ParenExpr2 "("({String}|{NQP}|{ParenExpr3})*")" ParenExpr "("({String}|{NQP}|{ParenExpr5})*")" Arg ({NQPCm}|{String}|{ParenExpr})* ArgCm {Arg}{Cm} StringArg {Wh}{String}{Wh}"," OpenString {Open}{StringArg} LispToken ({Esc}|[-A-Za-z0-9!@$%^&*_=+|{}`~,<.>/?])+ %% <DO_C>{NT}"GETTEXT"{OpWQ} { snarf (); } <DO_C>{NT}"DEFER_GETTEXT"{OpWQ} { snarf (); } <DO_C>{NT}"build_translated_string"{OpWQ} { snarf (); } <DO_C>{NT}"insert_string"{OpWQ} { snarf (); } <DO_C>{NT}"message"{OpWQ} { snarf (); } <DO_C>{NT}"warn_when_safe"{OpWQ} { snarf (); } <DO_C>{NT}"error"{OpWQ} { snarf (); } <DO_C>{NT}"continuable_error"{OpWQ} { snarf (); } <DO_C>{NT}"signal_simple_error"{OpWQ} { snarf (); } <DO_C>{NT}"signal_simple_error_2"{OpWQ} { snarf (); } <DO_C>{NT}"signal_simple_continuable_error"{OpWQ} { snarf (); } <DO_C>{NT}"signal_simple_continuable_error_2"{OpWQ} { snarf (); } <DO_C>{NT}"report_file_error"{OpWQ} { snarf (); } <DO_C>{NT}"signal_file_error"{OpWQ} { snarf (); } <DO_C>{NT}"signal_double_file_error"{OpWQ} { snarf (); } <DO_C>{NT}"signal_double_file_error_2"{OpWQ} { snarf (); } <DO_C>{NT}"syntax_error"{OpWQ} { snarf (); } <DO_C>{NT}"continuable_syntax_error"{OpWQ} { snarf (); } <DO_C>{NT}"CTB_ERROR"{OpWQ} { snarf (); } <DO_C>{NT}"fatal"{OpWQ} { snarf (); } <DO_C>{NT}"stdout_out"{OpWQ} { snarf (); } <DO_C>{NT}"stderr_out"{OpWQ} { snarf (); } <DO_C>{NT}"with_output_to_temp_buffer"{OpWQ} { snarf (); } <DO_C>{NT}"weird_doc"{Open}{ArgCm}{Wh}{Q} { snarf (); /* #### FIXME snarf next arg() */} <DO_C>{NT}"DEFVAR_BOOL"{OpenString}{ArgCm}{Wh}{Q} { snarf (); } <DO_C>{NT}"DEFVAR_LISP"{OpenString}{ArgCm}{Wh}{Q} { snarf (); } <DO_C>{NT}"DEFVAR_SPECIFIER"{OpenString}{ArgCm}{Wh}{Q} { snarf (); } <DO_C>{NT}"DEFVAR_INT"{OpenString}{ArgCm}{Wh}{Q} { snarf (); } <DO_C>{NT}"DEFVAR_BUFFER_LOCAL"{OpenString}{ArgCm}{Wh}{Q} { snarf (); } <DO_C>{NT}"DEFVAR_BUFFER_DEFAULTS"{OpenString}{ArgCm}{Wh}{Q} { snarf (); } <DO_C>{NT}"deferror"{Open}{ArgCm}{StringArg}{Wh}{Q} { snarf (); } <DO_C>{NT}"barf_or_query_if_file_exists"{Open}{ArgCm}{Wh}{Q} { /* #### see comment above about use of Arg */ snarf (); } <DO_C>{NT}"DEFUN"{Open} { BEGIN DEFUN; } <DO_C>"/*" { /* This is hateful, but doc strings are sometimes put inside of comments (to get around limits in cpp), so we can't ignore stuff inside of comments. */ /* BEGIN C_COMMENT; */ } <DO_C>{Q} { BEGIN C_QUOTE; } <DO_C>{Any} { } <DEFUN>{StringArg}{ArgCm}{ArgCm}{ArgCm}{ArgCm}{Wh} { BEGIN DEFUN2; } <DEFUN>{Any} { bad_c_defun (); } <DEFUN2>{Q} { /* We found an interactive specification. */ snarf_return_state = DEFUN3; snarf (); } <DEFUN2>[^,]* { /* This function doesn't have an interactive specification. Don't use {ArgCm} in the specification because DEFUN3 looks for the comma. */ BEGIN DEFUN3; } <DEFUN3>{Wh}","{Wh}{Q} { snarf_return_state = DO_C; snarf (); } <DEFUN3>{Any} { bad_c_defun (); } <C_QUOTE>{Esc} { } <C_QUOTE>{Q} { BEGIN DO_C; } <C_QUOTE>{Any} { } <C_COMMENT>"*/" { BEGIN DO_C; } <C_COMMENT>{Any} { } <DO_LISP>{LP}{LWh}"gettext"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"purecopy"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"interactive"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"message"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"error"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"warn"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"format"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"substitute-command-keys"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"temp-minibuffer-message"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"momentary-string-display"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"princ"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"prin1"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"prin1-to-string"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"print"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"insert"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"insert-before-markers"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"get-buffer"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"get-buffer-create"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"generate-new-buffer-name"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"rename-buffer"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"set-buffer"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"switch-to-buffer"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"pop-to-buffer"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"with-output-to-temp-buffer"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"buffer-enable-undo"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"buffer-disable-undo"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"get-buffer-window"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"delete-windows-on"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"replace-buffer-in-windows"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"display-buffer"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"other-buffer"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"read-from-minibuffer"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"read-shell-command"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"read-file-name"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"read-buffer"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"read-variable"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"read-command"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"read-function"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"read-directory-name"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"read-string"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"read-number"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"read-minibuffer"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"read-quoted-char"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"read-face-name"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"read-itimer"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"completing-read"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"y-or-n-p"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"yes-or-no-p"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"query-replace-read-args"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"eval-minibuffer"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"edit-and-eval-command"{LWh}{Q} { inc_paren (); snarf (); } <DO_LISP>{LP}{LWh}"defvar"{LWh}{LispToken}{LWh} { inc_paren (); begin_paren_counting (LDEF); } <DO_LISP>{LP}{LWh}"defconst"{LWh}{LispToken}{LWh} { inc_paren (); begin_paren_counting (LDEF); } <DO_LISP>{LP}{LWh}"defun"{LWh}{LispToken}{LWh} { inc_paren (); begin_paren_counting (LDEF); } <DO_LISP>{LP}{LWh}"defmacro"{LWh}{LispToken}{LWh} { inc_paren (); begin_paren_counting (LDEF); } <DO_LISP>{LP}{LWh}"defsubst"{LWh}{LispToken}{LWh} { inc_paren (); begin_paren_counting (LDEF); } <DO_LISP>{Q} { BEGIN LQUO; } <DO_LISP>";" { BEGIN LCOM; } <DO_LISP>{LP} { inc_paren (); } <DO_LISP>{RP} { dec_paren (); } <DO_LISP>{Esc} { } <DO_LISP>{W} { lisp_whitespace (); } <DO_LISP>{Any} { } <LQUO>{Esc} { } <LQUO>{Q} { BEGIN DO_LISP; } <LQUO>{Any} { } <LCOM>"\n" { BEGIN DO_LISP; } <LCOM>{Any} { } <LDEF>{LWh}{Q} { snarf (); } <LDEF>{Any} { BEGIN DO_LISP; } <CSNARF>{Esc} { ECHO; } <CSNARF>{Q} { ECHO; fprintf (yyout, ")\n"); BEGIN snarf_return_state; } <CSNARF>{Any} { ECHO; } <LSNARF>{Esc} { ECHO; } <LSNARF>"\n" { fprintf (yyout, "\\n\\\n"); } <LSNARF>{Q} { ECHO; fprintf (yyout, ")\n"); BEGIN snarf_return_state; } <LSNARF>{Any} { ECHO; } %% enum filetype { C_FILE, LISP_FILE, INVALID_FILE }; /* some brain-dead headers define this ... */ #undef FALSE #undef TRUE enum boolean { FALSE, TRUE }; void scan_file (char *filename); void process_C_file (void); void process_Lisp_file (void); int in_c; int in_paren_counting, paren_count; int paren_return_state; snarf () { fprintf (yyout, "gettext(\""); if (in_c) BEGIN CSNARF; else BEGIN LSNARF; } bad_c_defun () { fprintf (stderr, "Warning: Invalid DEFUN encountered in C, line %d.\n", yylineno); snarf_return_state = DO_C; BEGIN DO_C; /* REJECT; Sun's lex is broken! Use Flex! */ } bad_lisp_def () { fprintf (stderr, "Warning: Invalid defmumble encountered in Lisp, line %d.\n", yylineno); snarf_return_state = DO_LISP; BEGIN DO_LISP; /* REJECT; Sun's lex is broken! Use Flex! */ } inc_paren () { if (in_paren_counting) paren_count++; } dec_paren () { if (in_paren_counting) { /* If we find a right paren without a matching left paren, it usually just indicates a statement like (defvar foo-mumble nil) where 'nil' is the sexp we are skipping over, and there's no doc string. */ if (paren_count > 0) paren_count--; else unput (')'); if (paren_count == 0) { in_paren_counting = 0; BEGIN paren_return_state; } } } /* #### begin_paren_counting () does not handle recursive entries */ begin_paren_counting (int return_state) { in_paren_counting = 1; paren_count = 0; paren_return_state = return_state; } lisp_whitespace () { if (in_paren_counting && !paren_count) { /* We got to the end of a token and we're not in a parenthesized expression, so we're at the end of an sexp. */ in_paren_counting = 0; BEGIN paren_return_state; } } yywrap () { return 1; } main (int argc, char *argv[]) { register int i; yyout = stdout; /* If first two args are -o FILE, output to FILE. */ i = 1; if (argc > i + 1 && strcmp (argv[i], "-o") == 0) { yyout = fopen (argv[++i], "w"); ++i; } /* ...Or if args are -a FILE, append to FILE. */ if (argc > i + 1 && strcmp (argv[i], "-a") == 0) { yyout = fopen (argv[++i], "a"); ++i; } if (!yyout) { fprintf (stderr, "Unable to open output file %s\n", argv[--i]); return; } for (; i < argc; i++) scan_file (argv[i]); return 0; } void scan_file (char *filename) { enum filetype type = INVALID_FILE; register char *p = filename + strlen (filename); if (strcmp (p - 4, ".elc") == 0) { *--p = '\0'; /* Use .el file instead */ type = LISP_FILE; } else if (strcmp (p - 3, ".el") == 0) type = LISP_FILE; else if (strcmp (p - 2, ".o") == 0) { *--p = 'c'; /* Use .c file instead */ type = C_FILE; } else if (strcmp (p - 2, ".c") == 0) type = C_FILE; if (type == INVALID_FILE) { fprintf (stderr, "File %s being ignored\n", filename); return; } yyin = fopen (filename, "r"); if (!yyin) { fprintf (stderr, "Unable to open input file %s\n", filename); return; } fprintf (yyout, "/* %s */\n", filename); if (type == C_FILE) process_C_file (); else process_Lisp_file (); fputc ('\n', yyout); fclose (yyin); } void process_C_file () { snarf_return_state = DO_C; in_c = 1; BEGIN DO_C; yylex (); } void process_Lisp_file () { snarf_return_state = DO_LISP; in_c = 0; BEGIN DO_LISP; yylex (); }