Mercurial > hg > xemacs-beta
annotate lib-src/make-msgfile.lex @ 4981:4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
-------------------- ChangeLog entries follow: --------------------
modules/ChangeLog addition:
2010-02-05 Ben Wing <ben@xemacs.org>
* postgresql/postgresql.c:
* postgresql/postgresql.c (CHECK_LIVE_CONNECTION):
* postgresql/postgresql.c (Fpq_connectdb):
* postgresql/postgresql.c (Fpq_connect_start):
* postgresql/postgresql.c (Fpq_lo_import):
* postgresql/postgresql.c (Fpq_lo_export):
* ldap/eldap.c (Fldap_open):
* ldap/eldap.c (Fldap_search_basic):
* ldap/eldap.c (Fldap_add):
* ldap/eldap.c (Fldap_modify):
* ldap/eldap.c (Fldap_delete):
* canna/canna_api.c (Fcanna_initialize):
* canna/canna_api.c (Fcanna_store_yomi):
* canna/canna_api.c (Fcanna_parse):
* canna/canna_api.c (Fcanna_henkan_begin):
EXTERNAL_TO_C_STRING returns its argument instead of storing it
in a parameter, and is renamed to EXTERNAL_TO_ITEXT. Similar
things happen to related macros. See entry in src/ChangeLog.
More Mule-izing of postgresql.c. Extract out common code
between `pq-connectdb' and `pq-connect-start'. Fix places
that signal an error string using a formatted string to instead
follow the standard and have a fixed reason followed by the
particular error message stored as one of the frobs.
src/ChangeLog addition:
2010-02-05 Ben Wing <ben@xemacs.org>
* console-msw.c (write_string_to_mswindows_debugging_output):
* console-msw.c (Fmswindows_message_box):
* console-x.c (x_perhaps_init_unseen_key_defaults):
* console.c:
* database.c (dbm_get):
* database.c (dbm_put):
* database.c (dbm_remove):
* database.c (berkdb_get):
* database.c (berkdb_put):
* database.c (berkdb_remove):
* database.c (Fopen_database):
* device-gtk.c (gtk_init_device):
* device-msw.c (msprinter_init_device_internal):
* device-msw.c (msprinter_default_printer):
* device-msw.c (msprinter_init_device):
* device-msw.c (sync_printer_with_devmode):
* device-msw.c (Fmsprinter_select_settings):
* device-x.c (sanity_check_geometry_resource):
* device-x.c (Dynarr_add_validified_lisp_string):
* device-x.c (x_init_device):
* device-x.c (Fx_put_resource):
* device-x.c (Fx_valid_keysym_name_p):
* device-x.c (Fx_set_font_path):
* dialog-msw.c (push_lisp_string_as_unicode):
* dialog-msw.c (handle_directory_dialog_box):
* dialog-msw.c (handle_file_dialog_box):
* dialog-x.c (dbox_descriptor_to_widget_value):
* editfns.c (Fformat_time_string):
* editfns.c (Fencode_time):
* editfns.c (Fset_time_zone_rule):
* emacs.c (make_argc_argv):
* emacs.c (Fdump_emacs):
* emodules.c (emodules_load):
* eval.c:
* eval.c (maybe_signal_error_1):
* event-msw.c (Fdde_alloc_advise_item):
* event-msw.c (mswindows_dde_callback):
* event-msw.c (mswindows_wnd_proc):
* fileio.c (report_error_with_errno):
* fileio.c (Fsysnetunam):
* fileio.c (Fdo_auto_save):
* font-mgr.c (extract_fcapi_string):
* font-mgr.c (Ffc_config_app_font_add_file):
* font-mgr.c (Ffc_config_app_font_add_dir):
* font-mgr.c (Ffc_config_filename):
* frame-gtk.c (gtk_set_frame_text_value):
* frame-gtk.c (gtk_create_widgets):
* frame-msw.c (mswindows_init_frame_1):
* frame-msw.c (mswindows_set_title_from_ibyte):
* frame-msw.c (msprinter_init_frame_3):
* frame-x.c (x_set_frame_text_value):
* frame-x.c (x_set_frame_properties):
* frame-x.c (start_drag_internal_1):
* frame-x.c (x_cde_transfer_callback):
* frame-x.c (x_create_widgets):
* glyphs-eimage.c (my_jpeg_output_message):
* glyphs-eimage.c (jpeg_instantiate):
* glyphs-eimage.c (gif_instantiate):
* glyphs-eimage.c (png_instantiate):
* glyphs-eimage.c (tiff_instantiate):
* glyphs-gtk.c (xbm_instantiate_1):
* glyphs-gtk.c (gtk_xbm_instantiate):
* glyphs-gtk.c (gtk_xpm_instantiate):
* glyphs-gtk.c (gtk_xface_instantiate):
* glyphs-gtk.c (cursor_font_instantiate):
* glyphs-gtk.c (gtk_redisplay_widget):
* glyphs-gtk.c (gtk_widget_instantiate_1):
* glyphs-gtk.c (gtk_add_tab_item):
* glyphs-msw.c (mswindows_xpm_instantiate):
* glyphs-msw.c (bmp_instantiate):
* glyphs-msw.c (mswindows_resource_instantiate):
* glyphs-msw.c (xbm_instantiate_1):
* glyphs-msw.c (mswindows_xbm_instantiate):
* glyphs-msw.c (mswindows_xface_instantiate):
* glyphs-msw.c (mswindows_redisplay_widget):
* glyphs-msw.c (mswindows_widget_instantiate):
* glyphs-msw.c (add_tree_item):
* glyphs-msw.c (add_tab_item):
* glyphs-msw.c (mswindows_combo_box_instantiate):
* glyphs-msw.c (mswindows_widget_query_string_geometry):
* glyphs-x.c (x_locate_pixmap_file):
* glyphs-x.c (xbm_instantiate_1):
* glyphs-x.c (x_xbm_instantiate):
* glyphs-x.c (extract_xpm_color_names):
* glyphs-x.c (x_xpm_instantiate):
* glyphs-x.c (x_xface_instantiate):
* glyphs-x.c (autodetect_instantiate):
* glyphs-x.c (safe_XLoadFont):
* glyphs-x.c (cursor_font_instantiate):
* glyphs-x.c (x_redisplay_widget):
* glyphs-x.c (Fchange_subwindow_property):
* glyphs-x.c (x_widget_instantiate):
* glyphs-x.c (x_tab_control_redisplay):
* glyphs.c (pixmap_to_lisp_data):
* gui-x.c (menu_separator_style_and_to_external):
* gui-x.c (add_accel_and_to_external):
* gui-x.c (button_item_to_widget_value):
* hpplay.c (player_error_internal):
* hpplay.c (play_sound_file):
* hpplay.c (play_sound_data):
* intl.c (Fset_current_locale):
* lisp.h:
* menubar-gtk.c (gtk_xemacs_set_accel_keys):
* menubar-msw.c (populate_menu_add_item):
* menubar-msw.c (populate_or_checksum_helper):
* menubar-x.c (menu_item_descriptor_to_widget_value_1):
* nt.c (init_user_info):
* nt.c (get_long_basename):
* nt.c (nt_get_resource):
* nt.c (init_mswindows_environment):
* nt.c (get_cached_volume_information):
* nt.c (mswindows_readdir):
* nt.c (read_unc_volume):
* nt.c (mswindows_stat):
* nt.c (mswindows_getdcwd):
* nt.c (mswindows_executable_type):
* nt.c (Fmswindows_short_file_name):
* ntplay.c (nt_play_sound_file):
* objects-gtk.c:
* objects-gtk.c (gtk_valid_color_name_p):
* objects-gtk.c (gtk_initialize_font_instance):
* objects-gtk.c (gtk_font_list):
* objects-msw.c (font_enum_callback_2):
* objects-msw.c (parse_font_spec):
* objects-x.c (x_parse_nearest_color):
* objects-x.c (x_valid_color_name_p):
* objects-x.c (x_initialize_font_instance):
* objects-x.c (x_font_instance_truename):
* objects-x.c (x_font_list):
* objects-xlike-inc.c (XFUN):
* objects-xlike-inc.c (xft_find_charset_font):
* process-nt.c (mswindows_report_winsock_error):
* process-nt.c (nt_create_process):
* process-nt.c (get_internet_address):
* process-nt.c (nt_open_network_stream):
* process-unix.c:
* process-unix.c (allocate_pty):
* process-unix.c (get_internet_address):
* process-unix.c (unix_canonicalize_host_name):
* process-unix.c (unix_open_network_stream):
* realpath.c:
* select-common.h (lisp_data_to_selection_data):
* select-gtk.c (symbol_to_gtk_atom):
* select-gtk.c (atom_to_symbol):
* select-msw.c (symbol_to_ms_cf):
* select-msw.c (mswindows_register_selection_data_type):
* select-x.c (symbol_to_x_atom):
* select-x.c (x_atom_to_symbol):
* select-x.c (hack_motif_clipboard_selection):
* select-x.c (Fx_store_cutbuffer_internal):
* sound.c (Fplay_sound_file):
* sound.c (Fplay_sound):
* sound.h (sound_perror):
* sysdep.c:
* sysdep.c (qxe_allocating_getcwd):
* sysdep.c (qxe_execve):
* sysdep.c (copy_in_passwd):
* sysdep.c (qxe_getpwnam):
* sysdep.c (qxe_ctime):
* sysdll.c (dll_open):
* sysdll.c (dll_function):
* sysdll.c (dll_variable):
* sysdll.c (search_linked_libs):
* sysdll.c (dll_error):
* sysfile.h:
* sysfile.h (PATHNAME_CONVERT_OUT_TSTR):
* sysfile.h (PATHNAME_CONVERT_OUT_UTF_8):
* sysfile.h (PATHNAME_CONVERT_OUT):
* sysfile.h (LISP_PATHNAME_CONVERT_OUT):
* syswindows.h (ITEXT_TO_TSTR):
* syswindows.h (LOCAL_FILE_FORMAT_TO_TSTR):
* syswindows.h (TSTR_TO_LOCAL_FILE_FORMAT):
* syswindows.h (LOCAL_FILE_FORMAT_TO_INTERNAL_MSWIN):
* syswindows.h (LISP_LOCAL_FILE_FORMAT_MAYBE_URL_TO_TSTR):
* text.h:
* text.h (eicpy_ext_len):
* text.h (enum new_dfc_src_type):
* text.h (EXTERNAL_TO_ITEXT):
* text.h (GET_STRERROR):
* tooltalk.c (check_status):
* tooltalk.c (Fadd_tooltalk_message_arg):
* tooltalk.c (Fadd_tooltalk_pattern_attribute):
* tooltalk.c (Fadd_tooltalk_pattern_arg):
* win32.c (tstr_to_local_file_format):
* win32.c (mswindows_lisp_error_1):
* win32.c (mswindows_report_process_error):
* win32.c (Fmswindows_shell_execute):
* win32.c (mswindows_read_link_1):
Changes involving external/internal format conversion,
mostly code cleanup and renaming.
1. Eliminate the previous macros like LISP_STRING_TO_EXTERNAL
that stored its result in a parameter. The new version of
LISP_STRING_TO_EXTERNAL returns its result through the
return value, same as the previous NEW_LISP_STRING_TO_EXTERNAL.
Use the new-style macros throughout the code.
2. Rename C_STRING_TO_EXTERNAL and friends to ITEXT_TO_EXTERNAL,
in keeping with overall naming rationalization involving
Itext and related types.
Macros involved in previous two:
EXTERNAL_TO_C_STRING -> EXTERNAL_TO_ITEXT
EXTERNAL_TO_C_STRING_MALLOC -> EXTERNAL_TO_ITEXT_MALLOC
SIZED_EXTERNAL_TO_C_STRING -> SIZED_EXTERNAL_TO_ITEXT
SIZED_EXTERNAL_TO_C_STRING_MALLOC -> SIZED_EXTERNAL_TO_ITEXT_MALLOC
C_STRING_TO_EXTERNAL -> ITEXT_TO_EXTERNAL
C_STRING_TO_EXTERNAL_MALLOC -> ITEXT_TO_EXTERNAL_MALLOC
LISP_STRING_TO_EXTERNAL
LISP_STRING_TO_EXTERNAL_MALLOC
LISP_STRING_TO_TSTR
C_STRING_TO_TSTR -> ITEXT_TO_TSTR
TSTR_TO_C_STRING -> TSTR_TO_ITEXT
The following four still return their values through parameters,
since they have more than one value to return:
C_STRING_TO_SIZED_EXTERNAL -> ITEXT_TO_SIZED_EXTERNAL
LISP_STRING_TO_SIZED_EXTERNAL
C_STRING_TO_SIZED_EXTERNAL_MALLOC -> ITEXT_TO_SIZED_EXTERNAL_MALLOC
LISP_STRING_TO_SIZED_EXTERNAL_MALLOC
Sometimes additional casts had to be inserted, since the old
macros played strange games and completely defeated the type system
of the store params.
3. Rewrite many places where direct calls to TO_EXTERNAL_FORMAT
occurred with calls to one of the convenience macros listed above,
or to make_extstring().
4. Eliminate SIZED_C_STRING macros (they were hardly used, anyway)
and use a direct call to TO_EXTERNAL_FORMAT or TO_INTERNAL_FORMAT.
4. Use LISP_PATHNAME_CONVERT_OUT in many places instead of something
like LISP_STRING_TO_EXTERNAL(..., Qfile_name).
5. Eliminate some temporary variables that are no longer necessary
now that we return a value rather than storing it into a variable.
6. Some Mule-izing in database.c.
7. Error functions:
-- A bit of code cleanup in maybe_signal_error_1.
-- Eliminate report_file_type_error; it's just an alias for
signal_error_2 with params in a different order.
-- Fix some places in the hostname-handling code that directly
inserted externally-retrieved error strings into the
supposed ASCII "reason" param instead of doing the right thing
and sticking text descriptive of what was going on in "reason"
and putting the external message in a frob.
8. Use Ascbyte instead of CIbyte in process-unix.c and maybe one
or two other places.
9. Some code cleanup in copy_in_passwd() in sysdep.c.
10. Fix a real bug due to accidental variable shadowing in
tstr_to_local_file_format() in win32.c.
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Fri, 05 Feb 2010 11:02:24 -0600 |
| parents | c50b0b3c7b8d |
| children | 308d34e9f07d |
| rev | line source |
|---|---|
| 428 | 1 %{ |
| 2 | |
| 3 /* This is a Lex file. */ | |
| 4 | |
| 5 /* Localizable-message snarfing. | |
| 6 Copyright (C) 1994, 1995 Amdahl Corporation. | |
|
4950
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
7 Copyright (C) 2010 Ben Wing. |
| 428 | 8 |
| 9 This file is part of XEmacs. | |
| 10 | |
| 11 XEmacs is free software; you can redistribute it and/or modify | |
| 12 it under the terms of the GNU General Public License as published by | |
| 13 the Free Software Foundation; either version 2, or (at your option) | |
| 14 any later version. | |
| 15 | |
| 16 XEmacs is distributed in the hope that it will be useful, | |
| 17 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| 19 GNU General Public License for more details. | |
| 20 | |
| 21 You should have received a copy of the GNU General Public License | |
| 22 along with XEmacs; see the file COPYING. If not, write to | |
| 23 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
| 24 Boston, MA 02111-1307, USA. */ | |
| 25 | |
| 26 /* Written by Ben Wing, November 1994. Some code based on earlier | |
| 27 make-msgfile.c. */ | |
| 28 | |
|
4950
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
29 /* #### A comment: |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
30 |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
31 Directly writing a lex file isn't right. We want to be able to specify |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
32 functions to snarf in simpler ways, e.g. |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
33 |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
34 BEGIN_C_FUNCS |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
35 |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
36 weird_doc (arg, snarf, snarf, arg); |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
37 signal_error (arg, snarf, arg); |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
38 etc. |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
39 |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
40 END_C_FUNCS |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
41 |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
42 In this case, `arg' indicates an arbitrary argument and `snarf' indicates |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
43 that when a quoted string is seen, it should be snarfed. |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
44 |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
45 Then either we write a program to read this script and directly snarf |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
46 messages, or we write a program to convert the script into lex. |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
47 |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
48 --ben, 1/26/10 */ |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
49 |
| 2367 | 50 /* See text.c for a proposal about how this whole system should work. */ |
| 51 | |
| 428 | 52 /* Note: there is still much work to be done on this. |
| 53 | |
| 54 1) Definition of Arg below won't handle a generalized argument | |
| 55 as might appear in a function call. This is fine for DEFUN | |
| 56 and friends, because only simple arguments appear there; but | |
| 57 it might run into problems if Arg is used for other sorts | |
| 58 of functions. | |
| 59 2) snarf() should be modified so that it doesn't output null | |
| 60 strings and non-textual strings (see the comment at the top | |
| 61 of make-msgfile.c). | |
| 62 3) parsing of (insert) should snarf all of the arguments. | |
| 63 4) need to add set-keymap-prompt and deal with gettext of that. | |
| 64 5) parsing of arguments should snarf all strings anywhere within | |
| 65 the arguments, rather than just looking for a string as the | |
| 66 argument. This allows if statements as arguments to get parsed. | |
| 67 6) begin_paren_counting() et al. should handle recursive entry. | |
| 68 7) handle set-window-buffer and other such functions that take | |
| 69 a buffer as the other-than-first argument. | |
| 70 8) there is a fair amount of work to be done on the C code. | |
| 71 Look through the code for #### comments associated with | |
| 72 '#ifdef I18N3' or with an I18N3 nearby. | |
| 73 9) Deal with `get-buffer-process' et al. | |
| 74 10) Many of the changes in the Lisp code marked | |
| 75 'rewritten for I18N3 snarfing' should be undone once (5) is | |
| 76 implemented. | |
| 77 11) Go through the Lisp code in prim and make sure that all | |
| 78 strings are gettexted as necessary. This may reveal more | |
| 79 things to implement. | |
| 80 12) Do the equivalent of (8) for the Lisp code. | |
| 81 13) Deal with parsing of menu specifications. | |
| 82 | |
| 83 --ben | |
| 84 | |
| 85 */ | |
| 86 | |
| 87 /* Some notes: | |
| 88 | |
| 89 -- {Arg} below could get confused by commas inside of quotes. | |
| 90 -- {LispToken} below can match some things that are not tokens (e.g. | |
| 91 numbers) but for all practical purposes it should be fine. | |
| 92 */ | |
| 93 | |
| 94 #include <stdio.h> | |
| 95 | |
| 96 int snarf_return_state; | |
| 97 | |
| 98 %} | |
| 99 | |
| 100 %p 6000 | |
| 101 %e 2000 | |
| 102 %n 1000 | |
| 103 %a 4000 | |
| 104 %s C_QUOTE C_COMMENT LQUO LCOM | |
| 105 %s CSNARF LSNARF | |
| 106 %s DO_C DO_LISP DEFUN | |
| 107 %s DEFUN2 DEFUN3 LDEF | |
| 108 | |
|
4950
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
109 W [ \t\n] |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
110 Any .|\n |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
111 Q \" |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
112 Cm , |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
113 NQ [^\"] |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
114 NT [^A-Za-z_0-9] |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
115 LP "(" |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
116 RP ")" |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
117 NQP [^\"()] |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
118 NQPCm [^,\"()] |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
119 BS "\\" |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
120 Esc ({BS}{Any}) |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
121 Wh ({W}*) |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
122 LCom (;({Esc}|.)*) |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
123 LWh ({W}|{LCom})* |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
124 Open {Wh}{LP} |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
125 OpWQ {Open}{Wh}{Q} |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
126 String {Q}({Esc}|{NQ})*{Q} |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
127 ParenExpr5 "("({String}|{NQP})*")" |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
128 ParenExpr4 "("({String}|{NQP}|{ParenExpr5})*")" |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
129 ParenExpr3 "("({String}|{NQP}|{ParenExpr4})*")" |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
130 ParenExpr2 "("({String}|{NQP}|{ParenExpr3})*")" |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
131 ParenExpr "("({String}|{NQP}|{ParenExpr5})*")" |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
132 Arg ({NQPCm}|{String}|{ParenExpr})* |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
133 ArgCm {Arg}{Cm} |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
134 StringArg {Wh}{String}{Wh}"," |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
135 OpenString {Open}{StringArg} |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
136 LispToken ({Esc}|[-A-Za-z0-9!@$%^&*_=+|{}`~,<.>/?])+ |
| 428 | 137 %% |
| 138 | |
| 139 <DO_C>{NT}"GETTEXT"{OpWQ} { snarf (); } | |
| 140 <DO_C>{NT}"DEFER_GETTEXT"{OpWQ} { snarf (); } | |
| 141 <DO_C>{NT}"build_translated_string"{OpWQ} { snarf (); } | |
| 142 <DO_C>{NT}"insert_string"{OpWQ} { snarf (); } | |
| 143 <DO_C>{NT}"message"{OpWQ} { snarf (); } | |
| 144 <DO_C>{NT}"warn_when_safe"{OpWQ} { snarf (); } | |
| 145 <DO_C>{NT}"error"{OpWQ} { snarf (); } | |
| 146 <DO_C>{NT}"continuable_error"{OpWQ} { snarf (); } | |
| 147 <DO_C>{NT}"signal_simple_error"{OpWQ} { snarf (); } | |
| 148 <DO_C>{NT}"signal_simple_error_2"{OpWQ} { snarf (); } | |
| 149 <DO_C>{NT}"signal_simple_continuable_error"{OpWQ} { snarf (); } | |
| 150 <DO_C>{NT}"signal_simple_continuable_error_2"{OpWQ} { snarf (); } | |
| 151 <DO_C>{NT}"report_file_error"{OpWQ} { snarf (); } | |
| 152 <DO_C>{NT}"signal_file_error"{OpWQ} { snarf (); } | |
| 153 <DO_C>{NT}"signal_double_file_error"{OpWQ} { snarf (); } | |
| 154 <DO_C>{NT}"signal_double_file_error_2"{OpWQ} { snarf (); } | |
| 155 <DO_C>{NT}"syntax_error"{OpWQ} { snarf (); } | |
| 156 <DO_C>{NT}"continuable_syntax_error"{OpWQ} { snarf (); } | |
| 157 <DO_C>{NT}"CTB_ERROR"{OpWQ} { snarf (); } | |
| 158 <DO_C>{NT}"fatal"{OpWQ} { snarf (); } | |
| 159 <DO_C>{NT}"stdout_out"{OpWQ} { snarf (); } | |
| 160 <DO_C>{NT}"stderr_out"{OpWQ} { snarf (); } | |
| 161 <DO_C>{NT}"with_output_to_temp_buffer"{OpWQ} { snarf (); } | |
|
4950
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
162 <DO_C>{NT}"weird_doc"{Open}{ArgCm}{Wh}{Q} { snarf (); /* #### FIXME snarf next arg() */} |
| 428 | 163 |
|
4950
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
164 <DO_C>{NT}"DEFVAR_BOOL"{OpenString}{ArgCm}{Wh}{Q} { snarf (); } |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
165 <DO_C>{NT}"DEFVAR_LISP"{OpenString}{ArgCm}{Wh}{Q} { snarf (); } |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
166 <DO_C>{NT}"DEFVAR_SPECIFIER"{OpenString}{ArgCm}{Wh}{Q} { snarf (); } |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
167 <DO_C>{NT}"DEFVAR_INT"{OpenString}{ArgCm}{Wh}{Q} { snarf (); } |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
168 <DO_C>{NT}"DEFVAR_BUFFER_LOCAL"{OpenString}{ArgCm}{Wh}{Q} { snarf (); } |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
169 <DO_C>{NT}"DEFVAR_BUFFER_DEFAULTS"{OpenString}{ArgCm}{Wh}{Q} { snarf (); } |
|
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
170 <DO_C>{NT}"deferror"{Open}{ArgCm}{StringArg}{Wh}{Q} { snarf (); } |
| 428 | 171 |
|
4950
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
172 <DO_C>{NT}"barf_or_query_if_file_exists"{Open}{ArgCm}{Wh}{Q} { |
| 428 | 173 /* #### see comment above about use of Arg */ |
| 174 snarf (); | |
| 175 } | |
| 176 | |
| 177 <DO_C>{NT}"DEFUN"{Open} { BEGIN DEFUN; } | |
| 178 | |
| 179 <DO_C>"/*" { | |
| 180 /* This is hateful, but doc strings are sometimes put inside of comments | |
| 181 (to get around limits in cpp), so we can't ignore stuff inside of | |
| 182 comments. */ | |
| 183 /* BEGIN C_COMMENT; */ | |
| 184 } | |
| 185 <DO_C>{Q} { BEGIN C_QUOTE; } | |
| 186 <DO_C>{Any} { } | |
| 187 | |
|
4950
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
188 <DEFUN>{StringArg}{ArgCm}{ArgCm}{ArgCm}{ArgCm}{Wh} { BEGIN DEFUN2; } |
| 428 | 189 <DEFUN>{Any} { bad_c_defun (); } |
| 190 | |
| 191 <DEFUN2>{Q} { | |
| 192 /* We found an interactive specification. */ | |
| 193 snarf_return_state = DEFUN3; | |
| 194 snarf (); | |
| 195 } | |
| 196 <DEFUN2>[^,]* { | |
| 197 /* This function doesn't have an interactive specification. | |
|
4950
c50b0b3c7b8d
Random changes to make-msgfile.lex
Ben Wing <ben@xemacs.org>
parents:
2367
diff
changeset
|
198 Don't use {ArgCm} in the specification because DEFUN3 looks |
| 428 | 199 for the comma. */ |
| 200 BEGIN DEFUN3; | |
| 201 } | |
| 202 | |
| 203 <DEFUN3>{Wh}","{Wh}{Q} { | |
| 204 snarf_return_state = DO_C; | |
| 205 snarf (); | |
| 206 } | |
| 207 <DEFUN3>{Any} { bad_c_defun (); } | |
| 208 | |
| 209 <C_QUOTE>{Esc} { } | |
| 210 <C_QUOTE>{Q} { BEGIN DO_C; } | |
| 211 <C_QUOTE>{Any} { } | |
| 212 | |
| 213 <C_COMMENT>"*/" { BEGIN DO_C; } | |
| 214 <C_COMMENT>{Any} { } | |
| 215 | |
| 216 <DO_LISP>{LP}{LWh}"gettext"{LWh}{Q} { inc_paren (); snarf (); } | |
| 217 <DO_LISP>{LP}{LWh}"purecopy"{LWh}{Q} { inc_paren (); snarf (); } | |
| 218 <DO_LISP>{LP}{LWh}"interactive"{LWh}{Q} { inc_paren (); snarf (); } | |
| 219 <DO_LISP>{LP}{LWh}"message"{LWh}{Q} { inc_paren (); snarf (); } | |
| 220 <DO_LISP>{LP}{LWh}"error"{LWh}{Q} { inc_paren (); snarf (); } | |
| 221 <DO_LISP>{LP}{LWh}"warn"{LWh}{Q} { inc_paren (); snarf (); } | |
| 222 <DO_LISP>{LP}{LWh}"format"{LWh}{Q} { inc_paren (); snarf (); } | |
| 223 <DO_LISP>{LP}{LWh}"substitute-command-keys"{LWh}{Q} { inc_paren (); snarf (); } | |
| 224 <DO_LISP>{LP}{LWh}"temp-minibuffer-message"{LWh}{Q} { inc_paren (); snarf (); } | |
| 225 <DO_LISP>{LP}{LWh}"momentary-string-display"{LWh}{Q} { inc_paren (); snarf (); } | |
| 226 <DO_LISP>{LP}{LWh}"princ"{LWh}{Q} { inc_paren (); snarf (); } | |
| 227 <DO_LISP>{LP}{LWh}"prin1"{LWh}{Q} { inc_paren (); snarf (); } | |
| 228 <DO_LISP>{LP}{LWh}"prin1-to-string"{LWh}{Q} { inc_paren (); snarf (); } | |
| 229 <DO_LISP>{LP}{LWh}"print"{LWh}{Q} { inc_paren (); snarf (); } | |
| 230 <DO_LISP>{LP}{LWh}"insert"{LWh}{Q} { inc_paren (); snarf (); } | |
| 231 <DO_LISP>{LP}{LWh}"insert-before-markers"{LWh}{Q} { inc_paren (); snarf (); } | |
| 232 | |
| 233 <DO_LISP>{LP}{LWh}"get-buffer"{LWh}{Q} { inc_paren (); snarf (); } | |
| 234 <DO_LISP>{LP}{LWh}"get-buffer-create"{LWh}{Q} { inc_paren (); snarf (); } | |
| 235 <DO_LISP>{LP}{LWh}"generate-new-buffer-name"{LWh}{Q} { inc_paren (); snarf (); } | |
| 236 <DO_LISP>{LP}{LWh}"rename-buffer"{LWh}{Q} { inc_paren (); snarf (); } | |
| 237 <DO_LISP>{LP}{LWh}"set-buffer"{LWh}{Q} { inc_paren (); snarf (); } | |
| 238 <DO_LISP>{LP}{LWh}"switch-to-buffer"{LWh}{Q} { inc_paren (); snarf (); } | |
| 239 <DO_LISP>{LP}{LWh}"pop-to-buffer"{LWh}{Q} { inc_paren (); snarf (); } | |
| 240 <DO_LISP>{LP}{LWh}"with-output-to-temp-buffer"{LWh}{Q} { inc_paren (); snarf (); } | |
| 241 <DO_LISP>{LP}{LWh}"buffer-enable-undo"{LWh}{Q} { inc_paren (); snarf (); } | |
| 242 <DO_LISP>{LP}{LWh}"buffer-disable-undo"{LWh}{Q} { inc_paren (); snarf (); } | |
| 243 <DO_LISP>{LP}{LWh}"get-buffer-window"{LWh}{Q} { inc_paren (); snarf (); } | |
| 244 <DO_LISP>{LP}{LWh}"delete-windows-on"{LWh}{Q} { inc_paren (); snarf (); } | |
| 245 <DO_LISP>{LP}{LWh}"replace-buffer-in-windows"{LWh}{Q} { inc_paren (); snarf (); } | |
| 246 <DO_LISP>{LP}{LWh}"display-buffer"{LWh}{Q} { inc_paren (); snarf (); } | |
| 247 <DO_LISP>{LP}{LWh}"other-buffer"{LWh}{Q} { inc_paren (); snarf (); } | |
| 248 | |
| 249 <DO_LISP>{LP}{LWh}"read-from-minibuffer"{LWh}{Q} { inc_paren (); snarf (); } | |
| 250 <DO_LISP>{LP}{LWh}"read-shell-command"{LWh}{Q} { inc_paren (); snarf (); } | |
| 251 <DO_LISP>{LP}{LWh}"read-file-name"{LWh}{Q} { inc_paren (); snarf (); } | |
| 252 <DO_LISP>{LP}{LWh}"read-buffer"{LWh}{Q} { inc_paren (); snarf (); } | |
| 253 <DO_LISP>{LP}{LWh}"read-variable"{LWh}{Q} { inc_paren (); snarf (); } | |
| 254 <DO_LISP>{LP}{LWh}"read-command"{LWh}{Q} { inc_paren (); snarf (); } | |
| 255 <DO_LISP>{LP}{LWh}"read-function"{LWh}{Q} { inc_paren (); snarf (); } | |
| 256 <DO_LISP>{LP}{LWh}"read-directory-name"{LWh}{Q} { inc_paren (); snarf (); } | |
| 257 <DO_LISP>{LP}{LWh}"read-string"{LWh}{Q} { inc_paren (); snarf (); } | |
| 258 <DO_LISP>{LP}{LWh}"read-number"{LWh}{Q} { inc_paren (); snarf (); } | |
| 259 <DO_LISP>{LP}{LWh}"read-minibuffer"{LWh}{Q} { inc_paren (); snarf (); } | |
| 260 <DO_LISP>{LP}{LWh}"read-quoted-char"{LWh}{Q} { inc_paren (); snarf (); } | |
| 261 <DO_LISP>{LP}{LWh}"read-face-name"{LWh}{Q} { inc_paren (); snarf (); } | |
| 262 <DO_LISP>{LP}{LWh}"read-itimer"{LWh}{Q} { inc_paren (); snarf (); } | |
| 263 <DO_LISP>{LP}{LWh}"completing-read"{LWh}{Q} { inc_paren (); snarf (); } | |
| 264 <DO_LISP>{LP}{LWh}"y-or-n-p"{LWh}{Q} { inc_paren (); snarf (); } | |
| 265 <DO_LISP>{LP}{LWh}"yes-or-no-p"{LWh}{Q} { inc_paren (); snarf (); } | |
| 266 <DO_LISP>{LP}{LWh}"query-replace-read-args"{LWh}{Q} { inc_paren (); snarf (); } | |
| 267 <DO_LISP>{LP}{LWh}"eval-minibuffer"{LWh}{Q} { inc_paren (); snarf (); } | |
| 268 <DO_LISP>{LP}{LWh}"edit-and-eval-command"{LWh}{Q} { inc_paren (); snarf (); } | |
| 269 | |
| 270 <DO_LISP>{LP}{LWh}"defvar"{LWh}{LispToken}{LWh} { | |
| 271 inc_paren (); begin_paren_counting (LDEF); | |
| 272 } | |
| 273 <DO_LISP>{LP}{LWh}"defconst"{LWh}{LispToken}{LWh} { | |
| 274 inc_paren (); begin_paren_counting (LDEF); | |
| 275 } | |
| 276 <DO_LISP>{LP}{LWh}"defun"{LWh}{LispToken}{LWh} { | |
| 277 inc_paren (); begin_paren_counting (LDEF); | |
| 278 } | |
| 279 <DO_LISP>{LP}{LWh}"defmacro"{LWh}{LispToken}{LWh} { | |
| 280 inc_paren (); begin_paren_counting (LDEF); | |
| 281 } | |
| 282 <DO_LISP>{LP}{LWh}"defsubst"{LWh}{LispToken}{LWh} { | |
| 283 inc_paren (); begin_paren_counting (LDEF); | |
| 284 } | |
| 285 | |
| 286 <DO_LISP>{Q} { BEGIN LQUO; } | |
| 287 <DO_LISP>";" { BEGIN LCOM; } | |
| 288 <DO_LISP>{LP} { inc_paren (); } | |
| 289 <DO_LISP>{RP} { dec_paren (); } | |
| 290 <DO_LISP>{Esc} { } | |
| 291 <DO_LISP>{W} { lisp_whitespace (); } | |
| 292 <DO_LISP>{Any} { } | |
| 293 | |
| 294 <LQUO>{Esc} { } | |
| 295 <LQUO>{Q} { BEGIN DO_LISP; } | |
| 296 <LQUO>{Any} { } | |
| 297 | |
| 298 <LCOM>"\n" { BEGIN DO_LISP; } | |
| 299 <LCOM>{Any} { } | |
| 300 | |
| 301 <LDEF>{LWh}{Q} { snarf (); } | |
| 302 <LDEF>{Any} { BEGIN DO_LISP; } | |
| 303 | |
| 304 <CSNARF>{Esc} { ECHO; } | |
| 305 <CSNARF>{Q} { ECHO; fprintf (yyout, ")\n"); BEGIN snarf_return_state; } | |
| 306 <CSNARF>{Any} { ECHO; } | |
| 307 | |
| 308 <LSNARF>{Esc} { ECHO; } | |
| 309 <LSNARF>"\n" { fprintf (yyout, "\\n\\\n"); } | |
| 310 <LSNARF>{Q} { ECHO; fprintf (yyout, ")\n"); BEGIN snarf_return_state; } | |
| 311 <LSNARF>{Any} { ECHO; } | |
| 312 | |
| 313 %% | |
| 314 | |
| 315 enum filetype { C_FILE, LISP_FILE, INVALID_FILE }; | |
| 316 /* some brain-dead headers define this ... */ | |
| 317 #undef FALSE | |
| 318 #undef TRUE | |
| 319 enum boolean { FALSE, TRUE }; | |
| 320 | |
| 321 void scan_file (char *filename); | |
| 322 void process_C_file (void); | |
| 323 void process_Lisp_file (void); | |
| 324 | |
| 325 int in_c; | |
| 326 int in_paren_counting, paren_count; | |
| 327 int paren_return_state; | |
| 328 | |
| 329 snarf () | |
| 330 { | |
| 331 fprintf (yyout, "gettext(\""); | |
| 332 if (in_c) | |
| 333 BEGIN CSNARF; | |
| 334 else | |
| 335 BEGIN LSNARF; | |
| 336 } | |
| 337 | |
| 338 bad_c_defun () | |
| 339 { | |
| 340 fprintf (stderr, "Warning: Invalid DEFUN encountered in C, line %d.\n", | |
| 341 yylineno); | |
| 342 snarf_return_state = DO_C; | |
| 343 BEGIN DO_C; | |
| 344 /* REJECT; Sun's lex is broken! Use Flex! */ | |
| 345 } | |
| 346 | |
| 347 bad_lisp_def () | |
| 348 { | |
| 349 fprintf (stderr, | |
| 350 "Warning: Invalid defmumble encountered in Lisp, line %d.\n", | |
| 351 yylineno); | |
| 352 snarf_return_state = DO_LISP; | |
| 353 BEGIN DO_LISP; | |
| 354 /* REJECT; Sun's lex is broken! Use Flex! */ | |
| 355 } | |
| 356 | |
| 357 inc_paren () | |
| 358 { | |
| 359 if (in_paren_counting) | |
| 360 paren_count++; | |
| 361 } | |
| 362 | |
| 363 dec_paren () | |
| 364 { | |
| 365 if (in_paren_counting) | |
| 366 { | |
| 367 /* If we find a right paren without a matching left paren, it usually | |
| 368 just indicates a statement like | |
| 369 | |
| 370 (defvar foo-mumble nil) | |
| 371 | |
| 372 where 'nil' is the sexp we are skipping over, and there's no | |
| 373 doc string. */ | |
| 374 if (paren_count > 0) | |
| 375 paren_count--; | |
| 376 else | |
| 377 unput (')'); | |
| 378 if (paren_count == 0) | |
| 379 { | |
| 380 in_paren_counting = 0; | |
| 381 BEGIN paren_return_state; | |
| 382 } | |
| 383 } | |
| 384 } | |
| 385 | |
| 386 /* #### begin_paren_counting () does not handle recursive entries */ | |
| 387 | |
| 388 begin_paren_counting (int return_state) | |
| 389 { | |
| 390 in_paren_counting = 1; | |
| 391 paren_count = 0; | |
| 392 paren_return_state = return_state; | |
| 393 } | |
| 394 | |
| 395 lisp_whitespace () | |
| 396 { | |
| 397 if (in_paren_counting && !paren_count) | |
| 398 { | |
| 399 /* We got to the end of a token and we're not in a parenthesized | |
| 400 expression, so we're at the end of an sexp. */ | |
| 401 in_paren_counting = 0; | |
| 402 BEGIN paren_return_state; | |
| 403 } | |
| 404 } | |
| 405 | |
| 406 yywrap () | |
| 407 { | |
| 408 return 1; | |
| 409 } | |
| 410 | |
| 411 main (int argc, char *argv[]) | |
| 412 { | |
| 413 register int i; | |
| 414 | |
| 415 yyout = stdout; | |
| 416 | |
| 417 /* If first two args are -o FILE, output to FILE. */ | |
| 418 i = 1; | |
| 419 if (argc > i + 1 && strcmp (argv[i], "-o") == 0) { | |
| 420 yyout = fopen (argv[++i], "w"); | |
| 421 ++i; | |
| 422 } | |
| 423 /* ...Or if args are -a FILE, append to FILE. */ | |
| 424 if (argc > i + 1 && strcmp (argv[i], "-a") == 0) { | |
| 425 yyout = fopen (argv[++i], "a"); | |
| 426 ++i; | |
| 427 } | |
| 428 if (!yyout) { | |
| 429 fprintf (stderr, "Unable to open output file %s\n", argv[--i]); | |
| 430 return; | |
| 431 } | |
| 432 | |
| 433 for (; i < argc; i++) | |
| 434 scan_file (argv[i]); | |
| 435 | |
| 436 return 0; | |
| 437 } | |
| 438 | |
| 439 | |
| 440 void scan_file (char *filename) | |
| 441 { | |
| 442 enum filetype type = INVALID_FILE; | |
| 443 register char *p = filename + strlen (filename); | |
| 444 | |
| 445 if (strcmp (p - 4, ".elc") == 0) { | |
| 446 *--p = '\0'; /* Use .el file instead */ | |
| 447 type = LISP_FILE; | |
| 448 } else if (strcmp (p - 3, ".el") == 0) | |
| 449 type = LISP_FILE; | |
| 450 else if (strcmp (p - 2, ".o") == 0) { | |
| 451 *--p = 'c'; /* Use .c file instead */ | |
| 452 type = C_FILE; | |
| 453 } else if (strcmp (p - 2, ".c") == 0) | |
| 454 type = C_FILE; | |
| 455 | |
| 456 if (type == INVALID_FILE) { | |
| 457 fprintf (stderr, "File %s being ignored\n", filename); | |
| 458 return; | |
| 459 } | |
| 460 yyin = fopen (filename, "r"); | |
| 461 if (!yyin) { | |
| 462 fprintf (stderr, "Unable to open input file %s\n", filename); | |
| 463 return; | |
| 464 } | |
| 465 | |
| 466 fprintf (yyout, "/* %s */\n", filename); | |
| 467 if (type == C_FILE) | |
| 468 process_C_file (); | |
| 469 else | |
| 470 process_Lisp_file (); | |
| 471 fputc ('\n', yyout); | |
| 472 | |
| 473 fclose (yyin); | |
| 474 } | |
| 475 | |
| 476 void process_C_file () | |
| 477 { | |
| 478 snarf_return_state = DO_C; | |
| 479 in_c = 1; | |
| 480 BEGIN DO_C; | |
| 481 yylex (); | |
| 482 } | |
| 483 | |
| 484 void process_Lisp_file () | |
| 485 { | |
| 486 snarf_return_state = DO_LISP; | |
| 487 in_c = 0; | |
| 488 BEGIN DO_LISP; | |
| 489 yylex (); | |
| 490 } | |
| 491 |