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