Mercurial > emacs
annotate src/casetab.c @ 1687:2bee660c3046
* configure: Don't make the top-level Makefile read-only - people
may want to edit the values of the path variables.
Make path specification conform to GNU coding standards.
* configure (long_usage): Remove all traces of old arguments from
usage messages, and document the options we do accept in more
detail: -with-x... and --srcdir.
(options, boolean_opts): Deleted; we don't have enough options to
make this worthwhile.
(prefix, bindir, lisppath, datadir, libdir, lockdir): Deleted,
along with the code which supported them; these should be set as
arguments to the top-level make.
(config_h_opts): Since this no longer doubles as a list of option
names, make them upper case; this simplifies the code which uses
them to build the sed command to edit src/config.h. Change the
code which sets them.
(cc, g, O): Don't allow the user to set these using options; they
should be specified using `CC=' and `CFLAGS=' arguments to the
top-level make. Just choose reasonable default values for them,
and edit them into Makefile.in's default CC and CONFIG_CFLAGS
values.
(gnu_malloc, rel_alloc): Don't allow the user to set these using
options; use them whenever the configuration files say they're
possible.
Simplify the argument processing loop. Don't accept abbreviations
for option names; these might conflict with other configuration
options in the future.
Add some support for the `--srcdir' option. Check for the sources
in . and .. if `--srcdir' is omitted. If the directories we will
compile in don't exist yet, create them under the current directory.
Note that the rest of the build process doesn't really support
this.
Edit only the top Makefile. That should edit the others. Edit
into the makefile: `version', from lisp/version.el, `configname'
and `srcdir' from the configuration arguments, `CC' and
`CONFIG_CFLAGS' as guessed from the presence or absence of GCC in
the user's path, and LOADLIBES as gleaned from the system
description files.
Simplify the report generated; it doesn't need to include any
description of paths now.
Make `config.status' exec configure instead of just calling it, so
there's no harm in overwriting `config.status'.
* Makefile.in (version, configname): New variables, used to choose
the default values for datadir and libdir.
Path variables rearranged into two clearer groups:
- In the first group are the variables specified by the GNU coding
standards (prefix, bindir, datadir, statedir, libdir, mandir,
manext, infodir, and srcdir).
- In the second are the variables actually used for Emacs's paths
(lispdir, locallisppath, lisppath, buildlisppath, etcdir, lockdir,
archlibdir), which depend on the first category.
datadir and libdir default to directories under
${prefix}/lib/emacs instead of ${prefix}/emacs, by popular
demand.
etcdir and lispdir default to subdirectories of datadir.
archlibdir defaults to libdir.
The new installation tree is a bit deeper than it used to be, so
use the new make-path program in lib-src to build them all.
Always build a new src/paths.h.tmp and then move-if-change it to
src/paths.h, to avoid unnecessary rebuilds while responding to the
right changes.
Remove all mention of arch-lib. Run utility commands from
lib-src, and let the executables be copied into archlibdir when
Emacs is installed.
Add targets for src/Makefile, lib-src/Makefile, and
oldXMenu/Makefile, editing the values of the path variables into
them.
Let lib-src do its own installation.
(datadir): Default to putting data files under
${prefix}/lib/emacs/${version}, not /usr/local/emacs.
(emacsdir): Variable deleted; it would only be confusing to use.
(lispdir, etcdir): Default to ${datadir}/lisp.
(mkdir): Use make-path for this.
(lockdir): Do this in mkdir.
(Makefile): New target.
* configure (usage_message): Rename to long_usage.
author | Jim Blandy <jimb@redhat.com> |
---|---|
date | Sat, 12 Dec 1992 15:42:53 +0000 |
parents | 5fe52748a72c |
children | 952f2a18f83d |
rev | line source |
---|---|
118 | 1 /* GNU Emacs routines to deal with case tables. |
2 Copyright (C) 1987 Free Software Foundation, Inc. | |
3 | |
4 This file is part of GNU Emacs. | |
5 | |
6 GNU Emacs is free software; you can redistribute it and/or modify | |
7 it under the terms of the GNU General Public License as published by | |
8 the Free Software Foundation; either version 1, or (at your option) | |
9 any later version. | |
10 | |
11 GNU Emacs is distributed in the hope that it will be useful, | |
12 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 GNU General Public License for more details. | |
15 | |
16 You should have received a copy of the GNU General Public License | |
17 along with GNU Emacs; see the file COPYING. If not, write to | |
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
19 | |
20 /* Written by Howard Gayle. See chartab.c for details. */ | |
21 | |
22 #include "config.h" | |
23 #include "lisp.h" | |
24 #include "buffer.h" | |
25 | |
26 Lisp_Object Qcase_table_p; | |
27 Lisp_Object Vascii_downcase_table, Vascii_upcase_table; | |
28 Lisp_Object Vascii_canon_table, Vascii_eqv_table; | |
29 | |
30 void compute_trt_inverse (); | |
31 | |
32 DEFUN ("case-table-p", Fcase_table_p, Scase_table_p, 1, 1, 0, | |
33 "Return t iff ARG is a case table.\n\ | |
34 See `set-case-table' for more information on these data structures.") | |
35 (table) | |
36 Lisp_Object table; | |
37 { | |
38 Lisp_Object down, up, canon, eqv; | |
39 down = Fcar_safe (table); | |
40 up = Fcar_safe (Fcdr_safe (table)); | |
41 canon = Fcar_safe (Fcdr_safe (Fcdr_safe (table))); | |
42 eqv = Fcar_safe (Fcdr_safe (Fcdr_safe (Fcdr_safe (table)))); | |
43 | |
44 #define STRING256_P(obj) \ | |
45 (XTYPE (obj) == Lisp_String && XSTRING (obj)->size == 256) | |
46 | |
47 return (STRING256_P (down) | |
484 | 48 && (NILP (up) || STRING256_P (up)) |
49 && ((NILP (canon) && NILP (eqv)) | |
118 | 50 || (STRING256_P (canon) && STRING256_P (eqv))) |
51 ? Qt : Qnil); | |
52 } | |
53 | |
54 static Lisp_Object | |
55 check_case_table (obj) | |
56 Lisp_Object obj; | |
57 { | |
58 register Lisp_Object tem; | |
59 | |
484 | 60 while (tem = Fcase_table_p (obj), NILP (tem)) |
118 | 61 obj = wrong_type_argument (Qcase_table_p, obj, 0); |
62 return (obj); | |
63 } | |
64 | |
65 DEFUN ("current-case-table", Fcurrent_case_table, Scurrent_case_table, 0, 0, 0, | |
66 "Return the case table of the current buffer.") | |
67 () | |
68 { | |
69 Lisp_Object down, up, canon, eqv; | |
70 | |
71 down = current_buffer->downcase_table; | |
72 up = current_buffer->upcase_table; | |
73 canon = current_buffer->case_canon_table; | |
74 eqv = current_buffer->case_eqv_table; | |
75 | |
76 return Fcons (down, Fcons (up, Fcons (canon, Fcons (eqv, Qnil)))); | |
77 } | |
78 | |
79 DEFUN ("standard-case-table", Fstandard_case_table, | |
80 Sstandard_case_table, 0, 0, 0, | |
81 "Return the standard case table.\n\ | |
82 This is the one used for new buffers.") | |
83 () | |
84 { | |
85 return Fcons (Vascii_downcase_table, | |
86 Fcons (Vascii_upcase_table, | |
87 Fcons (Vascii_canon_table, | |
88 Fcons (Vascii_eqv_table, Qnil)))); | |
89 } | |
90 | |
1506
5fe52748a72c
* casetab.c (set_case_table): Declare this to be static, and
Jim Blandy <jimb@redhat.com>
parents:
484
diff
changeset
|
91 static Lisp_Object set_case_table (); |
5fe52748a72c
* casetab.c (set_case_table): Declare this to be static, and
Jim Blandy <jimb@redhat.com>
parents:
484
diff
changeset
|
92 |
118 | 93 DEFUN ("set-case-table", Fset_case_table, Sset_case_table, 1, 1, 0, |
94 "Select a new case table for the current buffer.\n\ | |
95 A case table is a list (DOWNCASE UPCASE CANONICALIZE EQUIVALENCES)\n\ | |
96 where each element is either nil or a string of length 256.\n\ | |
97 DOWNCASE maps each character to its lower-case equivalent.\n\ | |
98 UPCASE maps each character to its upper-case equivalent;\n\ | |
99 if lower and upper case characters are in 1-1 correspondence,\n\ | |
100 you may use nil and the upcase table will be deduced from DOWNCASE.\n\ | |
101 CANONICALIZE maps each character to a canonical equivalent;\n\ | |
102 any two characters that are related by case-conversion have the same\n\ | |
103 canonical equivalent character.\n\ | |
104 EQUIVALENCES is a map that cyclicly permutes each equivalence class\n\ | |
105 (of characters with the same canonical equivalent).\n\ | |
106 Both CANONICALIZE and EQUIVALENCES may be nil, in which case\n\ | |
107 both are deduced from DOWNCASE and UPCASE.") | |
108 (table) | |
109 Lisp_Object table; | |
110 { | |
1506
5fe52748a72c
* casetab.c (set_case_table): Declare this to be static, and
Jim Blandy <jimb@redhat.com>
parents:
484
diff
changeset
|
111 return set_case_table (table, 0); |
118 | 112 } |
113 | |
114 DEFUN ("set-standard-case-table", | |
115 Fset_standard_case_table, Sset_standard_case_table, 1, 1, 0, | |
116 "Select a new standard case table for new buffers.\n\ | |
117 See `set-case-table' for more info on case tables.") | |
118 (table) | |
119 Lisp_Object table; | |
120 { | |
1506
5fe52748a72c
* casetab.c (set_case_table): Declare this to be static, and
Jim Blandy <jimb@redhat.com>
parents:
484
diff
changeset
|
121 return set_case_table (table, 1); |
118 | 122 } |
123 | |
1506
5fe52748a72c
* casetab.c (set_case_table): Declare this to be static, and
Jim Blandy <jimb@redhat.com>
parents:
484
diff
changeset
|
124 static Lisp_Object |
118 | 125 set_case_table (table, standard) |
126 Lisp_Object table; | |
127 int standard; | |
128 { | |
129 Lisp_Object down, up, canon, eqv; | |
130 | |
131 check_case_table (table); | |
132 | |
133 down = Fcar_safe (table); | |
134 up = Fcar_safe (Fcdr_safe (table)); | |
135 canon = Fcar_safe (Fcdr_safe (Fcdr_safe (table))); | |
136 eqv = Fcar_safe (Fcdr_safe (Fcdr_safe (Fcdr_safe (table)))); | |
137 | |
484 | 138 if (NILP (up)) |
118 | 139 { |
140 up = Fmake_string (make_number (256), make_number (0)); | |
141 compute_trt_inverse (XSTRING (down)->data, XSTRING (up)->data); | |
142 } | |
143 | |
484 | 144 if (NILP (canon)) |
118 | 145 { |
146 register int i; | |
147 unsigned char *upvec = XSTRING (up)->data; | |
148 unsigned char *downvec = XSTRING (down)->data; | |
149 | |
150 canon = Fmake_string (make_number (256), make_number (0)); | |
151 eqv = Fmake_string (make_number (256), make_number (0)); | |
152 | |
153 /* Set up the CANON vector; for each character, | |
154 this sequence of upcasing and downcasing ought to | |
155 get the "preferred" lowercase equivalent. */ | |
156 for (i = 0; i < 256; i++) | |
157 XSTRING (canon)->data[i] = downvec[upvec[downvec[i]]]; | |
158 | |
159 compute_trt_inverse (XSTRING (canon)->data, XSTRING (eqv)->data); | |
160 } | |
161 | |
162 if (standard) | |
163 { | |
164 Vascii_downcase_table = down; | |
165 Vascii_upcase_table = up; | |
166 Vascii_canon_table = canon; | |
167 Vascii_eqv_table = eqv; | |
168 } | |
169 else | |
170 { | |
171 current_buffer->downcase_table = down; | |
172 current_buffer->upcase_table = up; | |
173 current_buffer->case_canon_table = canon; | |
174 current_buffer->case_eqv_table = eqv; | |
175 } | |
176 return table; | |
177 } | |
178 | |
179 /* Given a translate table TRT, store the inverse mapping into INVERSE. | |
180 Since TRT is not one-to-one, INVERSE is not a simple mapping. | |
181 Instead, it divides the space of characters into equivalence classes. | |
182 All characters in a given class form one circular list, chained through | |
183 the elements of INVERSE. */ | |
184 | |
185 void | |
186 compute_trt_inverse (trt, inverse) | |
187 register unsigned char *trt; | |
188 register unsigned char *inverse; | |
189 { | |
190 register int i = 0400; | |
191 register unsigned char c, q; | |
192 | |
193 while (i--) | |
194 inverse[i] = i; | |
195 i = 0400; | |
196 while (i--) | |
197 { | |
198 if ((q = trt[i]) != (unsigned char) i) | |
199 { | |
200 c = inverse[q]; | |
201 inverse[q] = i; | |
202 inverse[i] = c; | |
203 } | |
204 } | |
205 } | |
206 | |
207 init_casetab_once () | |
208 { | |
209 register int i; | |
210 Lisp_Object tem; | |
211 | |
212 tem = Fmake_string (make_number (256), make_number (0)); | |
213 Vascii_downcase_table = tem; | |
214 Vascii_canon_table = tem; | |
215 | |
216 for (i = 0; i < 256; i++) | |
217 XSTRING (tem)->data[i] = (i >= 'A' && i <= 'Z') ? i + 040 : i; | |
218 | |
219 tem = Fmake_string (make_number (256), make_number (0)); | |
220 Vascii_upcase_table = tem; | |
221 Vascii_eqv_table = tem; | |
222 | |
223 for (i = 0; i < 256; i++) | |
224 XSTRING (tem)->data[i] | |
225 = ((i >= 'A' && i <= 'Z') | |
226 ? i + ('a' - 'A') | |
227 : ((i >= 'a' && i <= 'z') | |
228 ? i + ('A' - 'a') | |
229 : i)); | |
230 } | |
231 | |
232 syms_of_casetab () | |
233 { | |
234 Qcase_table_p = intern ("case-table-p"); | |
235 staticpro (&Qcase_table_p); | |
236 staticpro (&Vascii_downcase_table); | |
237 staticpro (&Vascii_upcase_table); | |
238 staticpro (&Vascii_canon_table); | |
239 staticpro (&Vascii_eqv_table); | |
240 | |
241 defsubr (&Scase_table_p); | |
242 defsubr (&Scurrent_case_table); | |
243 defsubr (&Sstandard_case_table); | |
244 defsubr (&Sset_case_table); | |
245 defsubr (&Sset_standard_case_table); | |
246 | |
247 #if 0 | |
248 DEFVAR_LISP ("ascii-downcase-table", &Vascii_downcase_table, | |
249 "String mapping ASCII characters to lowercase equivalents."); | |
250 DEFVAR_LISP ("ascii-upcase-table", &Vascii_upcase_table, | |
251 "String mapping ASCII characters to uppercase equivalents."); | |
252 #endif | |
253 } |