Mercurial > hg > xemacs-beta
annotate lib-src/make-msgfile.lex @ 5157:1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
-------------------- ChangeLog entries follow: --------------------
lisp/ChangeLog addition:
2010-03-18 Ben Wing <ben@xemacs.org>
* diagnose.el (show-memory-usage):
Rewrite to take into account API changes in memory-usage functions.
src/ChangeLog addition:
2010-03-18 Ben Wing <ben@xemacs.org>
* alloc.c:
* alloc.c (disksave_object_finalization_1):
* alloc.c (lisp_object_storage_size):
* alloc.c (listu):
* alloc.c (listn):
* alloc.c (Fobject_memory_usage_stats):
* alloc.c (compute_memusage_stats_length):
* alloc.c (Fobject_memory_usage):
* alloc.c (Ftotal_object_memory_usage):
* alloc.c (malloced_storage_size):
* alloc.c (common_init_alloc_early):
* alloc.c (reinit_alloc_objects_early):
* alloc.c (reinit_alloc_early):
* alloc.c (init_alloc_once_early):
* alloc.c (syms_of_alloc):
* alloc.c (reinit_vars_of_alloc):
* buffer.c:
* buffer.c (struct buffer_stats):
* buffer.c (compute_buffer_text_usage):
* buffer.c (compute_buffer_usage):
* buffer.c (buffer_memory_usage):
* buffer.c (buffer_objects_create):
* buffer.c (syms_of_buffer):
* buffer.c (vars_of_buffer):
* console-impl.h (struct console_methods):
* dynarr.c (Dynarr_memory_usage):
* emacs.c (main_1):
* events.c (clear_event_resource):
* extents.c:
* extents.c (compute_buffer_extent_usage):
* extents.c (extent_objects_create):
* extents.h:
* faces.c:
* faces.c (compute_face_cachel_usage):
* faces.c (face_objects_create):
* faces.h:
* general-slots.h:
* glyphs.c:
* glyphs.c (compute_glyph_cachel_usage):
* glyphs.c (glyph_objects_create):
* glyphs.h:
* lisp.h:
* lisp.h (struct usage_stats):
* lrecord.h:
* lrecord.h (enum lrecord_type):
* lrecord.h (struct lrecord_implementation):
* lrecord.h (MC_ALLOC_CALL_FINALIZER_FOR_DISKSAVE):
* lrecord.h (DEFINE_DUMPABLE_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_SIZABLE_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_FROB_BLOCK_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_FROB_BLOCK_SIZABLE_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_INTERNAL_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_SIZABLE_INTERNAL_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_SIZABLE_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_FROB_BLOCK_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_FROB_BLOCK_SIZABLE_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_INTERNAL_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_SIZABLE_INTERNAL_LISP_OBJECT):
* lrecord.h (MAKE_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_MODULE_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_MODULE_SIZABLE_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_MODULE_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_MODULE_SIZABLE_LISP_OBJECT):
* lrecord.h (MAKE_MODULE_LISP_OBJECT):
* lrecord.h (INIT_LISP_OBJECT):
* lrecord.h (INIT_MODULE_LISP_OBJECT):
* lrecord.h (UNDEF_LISP_OBJECT):
* lrecord.h (UNDEF_MODULE_LISP_OBJECT):
* lrecord.h (DECLARE_LISP_OBJECT):
* lrecord.h (DECLARE_MODULE_API_LISP_OBJECT):
* lrecord.h (DECLARE_MODULE_LISP_OBJECT):
* lstream.c:
* lstream.c (syms_of_lstream):
* lstream.c (vars_of_lstream):
* marker.c:
* marker.c (compute_buffer_marker_usage):
* mc-alloc.c (mc_alloced_storage_size):
* mc-alloc.h:
* mule-charset.c:
* mule-charset.c (struct charset_stats):
* mule-charset.c (compute_charset_usage):
* mule-charset.c (charset_memory_usage):
* mule-charset.c (mule_charset_objects_create):
* mule-charset.c (syms_of_mule_charset):
* mule-charset.c (vars_of_mule_charset):
* redisplay.c:
* redisplay.c (compute_rune_dynarr_usage):
* redisplay.c (compute_display_block_dynarr_usage):
* redisplay.c (compute_glyph_block_dynarr_usage):
* redisplay.c (compute_display_line_dynarr_usage):
* redisplay.c (compute_line_start_cache_dynarr_usage):
* redisplay.h:
* scrollbar-gtk.c (gtk_compute_scrollbar_instance_usage):
* scrollbar-msw.c (mswindows_compute_scrollbar_instance_usage):
* scrollbar-x.c (x_compute_scrollbar_instance_usage):
* scrollbar.c (compute_scrollbar_instance_usage):
* scrollbar.h:
* symbols.c:
* symbols.c (reinit_symbol_objects_early):
* symbols.c (init_symbols_once_early):
* symbols.c (reinit_symbols_early):
* symbols.c (defsymbol_massage_name_1):
* symsinit.h:
* ui-gtk.c:
* ui-gtk.c (emacs_gtk_object_getprop):
* ui-gtk.c (emacs_gtk_object_putprop):
* ui-gtk.c (ui_gtk_objects_create):
* unicode.c (compute_from_unicode_table_size_1):
* unicode.c (compute_to_unicode_table_size_1):
* unicode.c (compute_from_unicode_table_size):
* unicode.c (compute_to_unicode_table_size):
* window.c:
* window.c (struct window_stats):
* window.c (compute_window_mirror_usage):
* window.c (compute_window_usage):
* window.c (window_memory_usage):
* window.c (window_objects_create):
* window.c (syms_of_window):
* window.c (vars_of_window):
* window.h:
Redo memory-usage mechanism, make it general; add way of dynamically
initializing Lisp object types -- OBJECT_HAS_METHOD(), similar to
CONSOLE_HAS_METHOD().
(1) Create OBJECT_HAS_METHOD(), OBJECT_HAS_PROPERTY() etc. for
specifying that a Lisp object type has a particular method or
property. Call such methods with OBJECT_METH, MAYBE_OBJECT_METH,
OBJECT_METH_OR_GIVEN; retrieve properties with OBJECT_PROPERTY.
Methods that formerly required a DEFINE_*GENERAL_LISP_OBJECT() to
specify them (getprop, putprop, remprop, plist, disksave) now
instead use the dynamic-method mechanism. The main benefit of
this is that new methods or properties can be added without
requiring that the declaration statements of all existing methods
be modified. We have to make the `struct lrecord_implementation'
non-const, but I don't think this should have any effect on speed --
the only possible method that's really speed-critical is the
mark method, and we already extract those out into a separate
(non-const) array for increased cache locality.
Object methods need to be reinitialized after pdump, so we put
them in separate functions such as face_objects_create(),
extent_objects_create() and call them appropriately from emacs.c
The only current object property (`memusage_stats_list') that
objects can specify is a Lisp object and gets staticpro()ed so it
only needs to be set during dump time, but because it references
symbols that might not exist in a syms_of_() function, we
initialize it in vars_of_(). There is also an object property
(`num_extra_memusage_stats') that is automatically initialized based
on `memusage_stats_list'; we do that in reinit_vars_of_alloc(),
which is called after all vars_of_() functions are called.
`disksaver' method was renamed `disksave' to correspond with the
name normally given to the function (e.g. disksave_lstream()).
(2) Generalize the memory-usage mechanism in `buffer-memory-usage',
`window-memory-usage', `charset-memory-usage' into an object-type-
specific mechanism called by a single function
`object-memory-usage'. (Former function `object-memory-usage'
renamed to `total-object-memory-usage'). Generalize the mechanism
of different "slices" so that we can have different "classes" of
memory described and different "slices" onto each class; `t'
separates classes, `nil' separates slices. Currently we have
three classes defined: the memory of an object itself,
non-Lisp-object memory associated with the object (e.g. arrays or
dynarrs stored as fields in the object), and Lisp-object memory
associated with the object (other internal Lisp objects stored in
the object). This isn't completely finished yet and we might need
to further separate the "other internal Lisp objects" class into
two classes.
The memory-usage mechanism uses a `struct usage_stats' (renamed
from `struct overhead_stats') to describe a malloc-view onto a set
of allocated memory (listing how much was requested and various
types of overhead) and a more general `struct generic_usage_stats'
(with a `struct usage_stats' in it) to hold all statistics about
object memory. `struct generic_usage_stats' contains an array of
32 Bytecounts, which are statistics of unspecified semantics. The
intention is that individual types declare a corresponding struct
(e.g. `struct window_stats') with the same structure but with
specific fields in place of the array, corresponding to specific
statistics. The number of such statistics is an object property
computed from the list of tags (Lisp symbols describing the
statistics) stored in `memusage_stats_list'. The idea here is to
allow particular object types to customize the number and
semantics of the statistics where completely avoiding consing.
This doesn't matter so much yet, but the intention is to have the
memory usage of all objects computed at the end of GC, at the same
time as other statistics are currently computed. The values for
all statistics for a single type would be added up to compute
aggregate values for all objects of a specific type. To make this
efficient, we can't allow any memory allocation at all.
(3) Create some additional functions for creating lists that
specify the elements directly as args rather than indirectly through
an array: listn() (number of args given), listu() (list terminated
by Qunbound).
(4) Delete a bit of remaining unused C window_config stuff, also
unused lrecord_type_popup_data.
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Thu, 18 Mar 2010 10:50:06 -0500 |
| 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 |