|
771
|
1 /* Header file for text manipulation primitives and macros.
|
|
|
2 Copyright (C) 1985-1995 Free Software Foundation, Inc.
|
|
|
3 Copyright (C) 1995 Sun Microsystems, Inc.
|
|
788
|
4 Copyright (C) 2000, 2001, 2002 Ben Wing.
|
|
771
|
5
|
|
|
6 This file is part of XEmacs.
|
|
|
7
|
|
|
8 XEmacs is free software; you can redistribute it and/or modify it
|
|
|
9 under the terms of the GNU General Public License as published by the
|
|
|
10 Free Software Foundation; either version 2, or (at your option) any
|
|
|
11 later version.
|
|
|
12
|
|
|
13 XEmacs is distributed in the hope that it will be useful, but WITHOUT
|
|
|
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
16 for more details.
|
|
|
17
|
|
|
18 You should have received a copy of the GNU General Public License
|
|
|
19 along with XEmacs; see the file COPYING. If not, write to
|
|
|
20 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
21 Boston, MA 02111-1307, USA. */
|
|
|
22
|
|
|
23 /* Synched up with: FSF 19.30. */
|
|
|
24
|
|
|
25 /* Authorship:
|
|
|
26
|
|
|
27 Mostly written by Ben Wing, starting around 1995.
|
|
|
28 Current TO_IN/EXTERNAL_FORMAT macros written by Martin Buchholz,
|
|
|
29 designed by Ben Wing based on earlier macros by Ben Wing.
|
|
|
30 Separated out June 18, 2000 from buffer.h into text.h.
|
|
|
31 */
|
|
|
32
|
|
|
33 #ifndef INCLUDED_text_h_
|
|
|
34 #define INCLUDED_text_h_
|
|
|
35
|
|
|
36 #include <wchar.h>
|
|
|
37
|
|
|
38 /* ---------------------------------------------------------------------- */
|
|
|
39 /* Super-basic character properties */
|
|
|
40 /* ---------------------------------------------------------------------- */
|
|
|
41
|
|
|
42 /* These properties define the specifics of how our current encoding fits
|
|
|
43 in the basic model used for the encoding. Because this model is the same
|
|
|
44 as is used for UTF-8, all these properties could be defined for it, too.
|
|
|
45 This would instantly make the rest of this file work with UTF-8 (with
|
|
|
46 the exception of a few called functions that would need to be redefined).
|
|
|
47
|
|
|
48 (UTF-2000 implementers, take note!)
|
|
|
49 */
|
|
|
50
|
|
|
51 /* If you want more than this, you need to include charset.h */
|
|
|
52
|
|
|
53 #ifndef MULE
|
|
|
54
|
|
826
|
55 #define rep_bytes_by_first_byte(fb) 1
|
|
|
56 #define byte_ascii_p(byte) 1
|
|
|
57 #define MAX_EMCHAR_LEN 1
|
|
771
|
58
|
|
|
59 #else /* MULE */
|
|
|
60
|
|
|
61 /* These are carefully designed to work if BYTE is signed or unsigned. */
|
|
|
62 /* Note that SPC and DEL are considered ASCII, not control. */
|
|
|
63
|
|
826
|
64 #define byte_ascii_p(byte) (((byte) & ~0x7f) == 0)
|
|
|
65 #define byte_c0_p(byte) (((byte) & ~0x1f) == 0)
|
|
|
66 #define byte_c1_p(byte) (((byte) & ~0x1f) == 0x80)
|
|
771
|
67
|
|
|
68 /* Does BYTE represent the first byte of a character? */
|
|
|
69
|
|
826
|
70 #ifdef ERROR_CHECK_TEXT
|
|
|
71
|
|
|
72 DECLARE_INLINE_HEADER (
|
|
|
73 int
|
|
|
74 intbyte_first_byte_p_1 (int byte, const char *file, int line)
|
|
|
75 )
|
|
|
76 {
|
|
|
77 assert_at_line (byte >= 0 && byte < 256, file, line);
|
|
|
78 return byte < 0xA0;
|
|
|
79 }
|
|
|
80
|
|
|
81 #define intbyte_first_byte_p(byte) \
|
|
|
82 intbyte_first_byte_p_1 (byte, __FILE__, __LINE__)
|
|
|
83
|
|
|
84 #else
|
|
|
85
|
|
|
86 #define intbyte_first_byte_p(byte) ((byte) < 0xA0)
|
|
|
87
|
|
|
88 #endif
|
|
|
89
|
|
|
90 #ifdef ERROR_CHECK_TEXT
|
|
771
|
91
|
|
|
92 /* Does BYTE represent the first byte of a multi-byte character? */
|
|
|
93
|
|
826
|
94 DECLARE_INLINE_HEADER (
|
|
|
95 int
|
|
|
96 intbyte_leading_byte_p_1 (int byte, const char *file, int line)
|
|
|
97 )
|
|
|
98 {
|
|
|
99 assert_at_line (byte >= 0 && byte < 256, file, line);
|
|
|
100 return byte_c1_p (byte);
|
|
|
101 }
|
|
|
102
|
|
|
103 #define intbyte_leading_byte_p(byte) \
|
|
|
104 intbyte_leading_byte_p_1 (byte, __FILE__, __LINE__)
|
|
|
105
|
|
|
106 #else
|
|
|
107
|
|
|
108 #define intbyte_leading_byte_p(byte) byte_c1_p (byte)
|
|
|
109
|
|
|
110 #endif
|
|
771
|
111
|
|
|
112 /* Table of number of bytes in the string representation of a character
|
|
|
113 indexed by the first byte of that representation.
|
|
|
114
|
|
|
115 This value can be derived in other ways -- e.g. something like
|
|
826
|
116 XCHARSET_REP_BYTES (charset_by_leading_byte (first_byte))
|
|
771
|
117 but it's faster this way. */
|
|
|
118 extern const Bytecount rep_bytes_by_first_byte[0xA0];
|
|
|
119
|
|
|
120 /* Number of bytes in the string representation of a character. */
|
|
788
|
121
|
|
800
|
122 #ifdef ERROR_CHECK_TEXT
|
|
788
|
123
|
|
826
|
124 DECLARE_INLINE_HEADER (
|
|
|
125 Bytecount
|
|
|
126 rep_bytes_by_first_byte_1 (int fb, const char *file, int line)
|
|
|
127 )
|
|
771
|
128 {
|
|
826
|
129 assert_at_line (fb >= 0 && fb < 0xA0, file, line);
|
|
771
|
130 return rep_bytes_by_first_byte[fb];
|
|
|
131 }
|
|
|
132
|
|
826
|
133 #define rep_bytes_by_first_byte(fb) \
|
|
|
134 rep_bytes_by_first_byte_1 (fb, __FILE__, __LINE__)
|
|
788
|
135
|
|
800
|
136 #else /* ERROR_CHECK_TEXT */
|
|
788
|
137
|
|
826
|
138 #define rep_bytes_by_first_byte(fb) (rep_bytes_by_first_byte[fb])
|
|
788
|
139
|
|
800
|
140 #endif /* ERROR_CHECK_TEXT */
|
|
788
|
141
|
|
826
|
142 /* Is this character represented by more than one byte in a string in the
|
|
|
143 default format? */
|
|
|
144
|
|
|
145 #define emchar_multibyte_p(c) ((c) >= 0x80)
|
|
|
146
|
|
|
147 #define emchar_ascii_p(c) (!emchar_multibyte_p (c))
|
|
|
148
|
|
|
149 /* Maximum number of bytes per Emacs character when represented as text, in
|
|
|
150 any format.
|
|
|
151 */
|
|
771
|
152
|
|
|
153 #define MAX_EMCHAR_LEN 4
|
|
|
154
|
|
826
|
155 #endif /* not MULE */
|
|
|
156
|
|
|
157 /* ---------------- Handling non-default formats ----------------- */
|
|
|
158
|
|
|
159 /* We support, at least to some extent, formats other than the default
|
|
|
160 variable-width format, for speed; all of these alternative formats are
|
|
|
161 fixed-width. Currently we only handle these non-default formats in
|
|
|
162 buffers, because access to their text is strictly controlled and thus
|
|
|
163 the details of the format mostly compartmentalized. The only really
|
|
|
164 tricky part is the search code -- the regex, Boyer-Moore, and
|
|
|
165 simple-search algorithms in search.c and regex.c. All other code that
|
|
|
166 knows directly about the buffer representation is the basic code to
|
|
|
167 modify or retrieve the buffer text.
|
|
|
168
|
|
|
169 Supporting fixed-width formats in Lisp strings is harder, but possible
|
|
|
170 -- FSF currently does this, for example. In this case, however,
|
|
|
171 probably only 8-bit-fixed is reasonable for Lisp strings -- getting
|
|
|
172 non-ASCII-compatible fixed-width formats to work is much, much harder
|
|
|
173 because a lot of code assumes that strings are ASCII-compatible
|
|
|
174 (i.e. ASCII + other characters represented exclusively using high-bit
|
|
|
175 bytes) and a lot of code mixes Lisp strings and non-Lisp strings freely.
|
|
|
176
|
|
|
177 The different possible fixed-width formats are 8-bit fixed, 16-bit
|
|
|
178 fixed, and 32-bit fixed. The latter can represent all possible
|
|
|
179 characters, but at a substantial memory penalty. The other two can
|
|
|
180 represent only a subset of the possible characters. How these subsets
|
|
|
181 are defined can be simple or very tricky.
|
|
|
182
|
|
|
183 Currently we support only the default format and the 8-bit fixed format,
|
|
|
184 and in the latter, we only allow these to be the first 256 characters in
|
|
|
185 an Emchar (ASCII and Latin 1).
|
|
|
186
|
|
|
187 One reasonable approach for 8-bit fixed is to allow the upper half to
|
|
|
188 represent any 1-byte charset, which is specified on a per-buffer basis.
|
|
|
189 This should work fairly well in practice since most documents are in
|
|
|
190 only one foreign language (possibly with some English mixed in). I
|
|
|
191 think FSF does something like this; or at least, they have something
|
|
|
192 called nonascii-translation-table and use it when converting from
|
|
|
193 8-bit-fixed text ("unibyte text") to default text ("multibyte text").
|
|
|
194 With 16-bit fixed, you could do something like assign chunks of the 64K
|
|
|
195 worth of characters to charsets as they're encountered in documents.
|
|
|
196 This should work well with most Asian documents.
|
|
|
197
|
|
|
198 If/when we switch to using Unicode internally, we might have formats more
|
|
|
199 like this:
|
|
|
200
|
|
|
201 -- UTF-8 or some extension as the default format. Perl uses an
|
|
|
202 extension that handles 64-bit chars and requires as much as 13 bytes per
|
|
|
203 char, vs. the standard of 31-bit chars and 6 bytes max. UTF-8 has the
|
|
|
204 same basic properties as our own variable-width format (see text.c,
|
|
|
205 Internal String Encoding) and so most code would not need to be changed.
|
|
|
206
|
|
|
207 -- UTF-16 as a "pseudo-fixed" format (i.e. 16-bit fixed plus surrogates
|
|
|
208 for representing characters not in the BMP, aka >= 65536). The vast
|
|
|
209 majority of documents will have no surrogates in them so byte/char
|
|
|
210 conversion will be very fast.
|
|
|
211
|
|
|
212 -- an 8-bit fixed format, like currently.
|
|
|
213
|
|
|
214 -- possibly, UCS-4 as a 32-bit fixed format.
|
|
|
215
|
|
|
216 The fixed-width formats essentially treat the buffer as an array of
|
|
|
217 8-bit, 16-bit or 32-bit integers. This means that how they are stored
|
|
|
218 in memory (in particular, big-endian or little-endian) depends on the
|
|
|
219 native format of the machine's processor. It also means we have to
|
|
|
220 worry a bit about alignment (basically, we just need to keep the gap an
|
|
|
221 integral size of the character size, and get things aligned properly
|
|
|
222 when converting the buffer between formats).
|
|
|
223 */
|
|
|
224 typedef enum internal_format
|
|
|
225 {
|
|
|
226 FORMAT_DEFAULT,
|
|
|
227 FORMAT_8_BIT_FIXED,
|
|
|
228 FORMAT_16_BIT_FIXED, /* not implemented */
|
|
|
229 FORMAT_32_BIT_FIXED /* not implemented */
|
|
|
230 } Internal_Format;
|
|
|
231
|
|
|
232 #ifdef MULE
|
|
|
233 /* "OBJECT" below will usually be a buffer, string, or nil. This needs to
|
|
|
234 be passed in because the interpretation of 8-bit-fixed and 16-bit-fixed
|
|
|
235 values may depend on the buffer, e.g. depending on what language the
|
|
|
236 text in the buffer is in. */
|
|
|
237
|
|
|
238 /* True if Emchar CH can be represented in 8-bit-fixed format. */
|
|
|
239 #define emchar_8_bit_fixed_p(ch, object) (((ch) & ~0xff) == 0)
|
|
|
240 /* Convert Emchar CH to an 8-bit int, as will be stored in the buffer. */
|
|
|
241 #define emchar_to_raw_8_bit_fixed(ch, object) ((Intbyte) (ch))
|
|
|
242 /* Convert the other way. */
|
|
|
243 #define raw_8_bit_fixed_to_emchar(ch, object) ((Emchar) (ch))
|
|
|
244
|
|
|
245 #define emchar_16_bit_fixed_p(ch, object) (((ch) & ~0xffff) == 0)
|
|
|
246 /* Convert Emchar CH to a 16-bit int, as will be stored in the buffer. */
|
|
|
247 #define emchar_to_raw_16_bit_fixed(ch, object) ((UINT_16_BIT) (ch))
|
|
|
248 /* Convert the other way. */
|
|
|
249 #define raw_16_bit_fixed_to_emchar(ch, object) ((Emchar) (ch))
|
|
|
250
|
|
|
251 /* Convert Emchar CH to a 32-bit int, as will be stored in the buffer. */
|
|
|
252 #define emchar_to_raw_32_bit_fixed(ch, object) ((UINT_32_BIT) (ch))
|
|
|
253 /* Convert the other way. */
|
|
|
254 #define raw_32_bit_fixed_to_emchar(ch, object) ((Emchar) (ch))
|
|
|
255
|
|
|
256 /* Return the "raw value" of a character as stored in the buffer. In the
|
|
|
257 default format, this is just the same as the character. In fixed-width
|
|
|
258 formats, this is the actual value in the buffer, which will be limited
|
|
|
259 to the range as established by the format. This is used when searching
|
|
|
260 for a character in a buffer -- it's faster to convert the character to
|
|
|
261 the raw value and look for that, than repeatedly convert each raw value
|
|
|
262 in the buffer into a character. */
|
|
|
263
|
|
|
264 DECLARE_INLINE_HEADER (
|
|
|
265 Raw_Emchar
|
|
|
266 emchar_to_raw (Emchar ch, Internal_Format fmt, Lisp_Object object)
|
|
|
267 )
|
|
|
268 {
|
|
|
269 switch (fmt)
|
|
|
270 {
|
|
|
271 case FORMAT_DEFAULT:
|
|
|
272 return (Raw_Emchar) ch;
|
|
|
273 case FORMAT_16_BIT_FIXED:
|
|
|
274 text_checking_assert (emchar_16_bit_fixed_p (ch, object));
|
|
|
275 return (Raw_Emchar) emchar_to_raw_16_bit_fixed (ch, object);
|
|
|
276 case FORMAT_32_BIT_FIXED:
|
|
|
277 return (Raw_Emchar) emchar_to_raw_32_bit_fixed (ch, object);
|
|
|
278 default:
|
|
|
279 text_checking_assert (fmt == FORMAT_8_BIT_FIXED);
|
|
|
280 text_checking_assert (emchar_8_bit_fixed_p (ch, object));
|
|
|
281 return (Raw_Emchar) emchar_to_raw_8_bit_fixed (ch, object);
|
|
|
282 }
|
|
|
283 }
|
|
|
284
|
|
|
285 /* Return whether CH is representable in the given format in the given
|
|
|
286 object. */
|
|
|
287
|
|
|
288 DECLARE_INLINE_HEADER (
|
|
|
289 int
|
|
|
290 emchar_fits_in_format (Emchar ch, Internal_Format fmt, Lisp_Object object)
|
|
|
291 )
|
|
|
292 {
|
|
|
293 switch (fmt)
|
|
|
294 {
|
|
|
295 case FORMAT_DEFAULT:
|
|
|
296 return 1;
|
|
|
297 case FORMAT_16_BIT_FIXED:
|
|
|
298 return emchar_16_bit_fixed_p (ch, object);
|
|
|
299 case FORMAT_32_BIT_FIXED:
|
|
|
300 return 1;
|
|
|
301 default:
|
|
|
302 text_checking_assert (fmt == FORMAT_8_BIT_FIXED);
|
|
|
303 return emchar_8_bit_fixed_p (ch, object);
|
|
|
304 }
|
|
|
305 }
|
|
|
306
|
|
|
307 /* Assuming the formats are the same, return whether the two objects
|
|
|
308 represent text in exactly the same way. */
|
|
|
309
|
|
|
310 DECLARE_INLINE_HEADER (
|
|
|
311 int
|
|
|
312 objects_have_same_internal_representation (Lisp_Object srcobj,
|
|
|
313 Lisp_Object dstobj)
|
|
|
314 )
|
|
|
315 {
|
|
|
316 /* &&#### implement this properly when we allow per-object format
|
|
|
317 differences */
|
|
|
318 return 1;
|
|
|
319 }
|
|
|
320
|
|
|
321 #else
|
|
|
322
|
|
|
323 #define emchar_to_raw(ch, fmt, object) ((Raw_Emchar) (ch))
|
|
|
324 #define emchar_fits_in_format(ch, fmt, object) 1
|
|
|
325 #define objects_have_same_internal_representation(srcobj, dstobj) 1
|
|
|
326
|
|
771
|
327 #endif /* MULE */
|
|
|
328
|
|
|
329 int dfc_coding_system_is_unicode (Lisp_Object coding_system);
|
|
|
330
|
|
|
331 DECLARE_INLINE_HEADER (
|
|
|
332 Bytecount dfc_external_data_len (const void *ptr, Lisp_Object codesys)
|
|
|
333 )
|
|
|
334 {
|
|
|
335 if (dfc_coding_system_is_unicode (codesys))
|
|
|
336 return sizeof (wchar_t) * wcslen ((wchar_t *) ptr);
|
|
|
337 else
|
|
|
338 return strlen ((char *) ptr);
|
|
|
339 }
|
|
|
340
|
|
|
341
|
|
|
342 /************************************************************************/
|
|
|
343 /* */
|
|
|
344 /* working with raw internal-format data */
|
|
|
345 /* */
|
|
|
346 /************************************************************************/
|
|
|
347
|
|
826
|
348 /*
|
|
|
349 Use the following functions/macros on contiguous text in any of the
|
|
|
350 internal formats. Those that take a format arg work on all internal
|
|
|
351 formats; the others work only on the default (variable-width under Mule)
|
|
|
352 format. If the text you're operating on is known to come from a buffer,
|
|
|
353 use the buffer-level functions in buffer.h, which automatically know the
|
|
|
354 correct format and handle the gap.
|
|
|
355
|
|
|
356 Some terminology:
|
|
|
357
|
|
|
358 "charptr" appearing in the macros means "internal-format text" -- type
|
|
|
359 `Intbyte *'. Operations on such pointers themselves, rather than on the
|
|
|
360 text being pointed to, have "charptr" instead of "charptr" in the macro
|
|
|
361 name. "emchar" in the macro names means an Emchar -- the representation
|
|
|
362 of a character as a single integer rather than a series of bytes, as part
|
|
|
363 of "charptr". Many of the macros below are for converting between the
|
|
|
364 two representations of characters.
|
|
|
365
|
|
|
366 Note also that we try to consistently distinguish between an "Emchar" and
|
|
|
367 a Lisp character. Stuff working with Lisp characters often just says
|
|
|
368 "char", so we consistently use "Emchar" when that's what we're working
|
|
|
369 with. */
|
|
|
370
|
|
|
371 /* The three golden rules of macros:
|
|
771
|
372
|
|
|
373 1) Anything that's an lvalue can be evaluated more than once.
|
|
826
|
374
|
|
|
375 2) Macros where anything else can be evaluated more than once should
|
|
|
376 have the word "unsafe" in their name (exceptions may be made for
|
|
|
377 large sets of macros that evaluate arguments of certain types more
|
|
|
378 than once, e.g. struct buffer * arguments, when clearly indicated in
|
|
|
379 the macro documentation). These macros are generally meant to be
|
|
|
380 called only by other macros that have already stored the calling
|
|
|
381 values in temporary variables.
|
|
|
382
|
|
|
383 3) Nothing else can be evaluated more than once. Use inline
|
|
771
|
384 functions, if necessary, to prevent multiple evaluation.
|
|
826
|
385
|
|
|
386 NOTE: The functions and macros below are given full prototypes in their
|
|
|
387 docs, even when the implementation is a macro. In such cases, passing
|
|
|
388 an argument of a type other than expected will produce undefined
|
|
|
389 results. Also, given that macros can do things functions can't (in
|
|
|
390 particular, directly modify arguments as if they were passed by
|
|
|
391 reference), the declaration syntax has been extended to include the
|
|
|
392 call-by-reference syntax from C++, where an & after a type indicates
|
|
|
393 that the argument is an lvalue and is passed by reference, i.e. the
|
|
|
394 function can modify its value. (This is equivalent in C to passing a
|
|
|
395 pointer to the argument, but without the need to explicitly worry about
|
|
|
396 pointers.)
|
|
|
397
|
|
|
398 When to capitalize macros:
|
|
|
399
|
|
|
400 -- Capitalize macros doing stuff obviously impossible with (C)
|
|
|
401 functions, e.g. directly modifying arguments as if they were passed by
|
|
|
402 reference.
|
|
|
403
|
|
|
404 -- Capitalize macros that evaluate *any* argument more than once regardless
|
|
|
405 of whether that's "allowed" (e.g. buffer arguments).
|
|
|
406
|
|
|
407 -- Capitalize macros that directly access a field in a Lisp_Object or
|
|
|
408 its equivalent underlying structure. In such cases, access through the
|
|
|
409 Lisp_Object precedes the macro with an X, and access through the underlying
|
|
|
410 structure doesn't.
|
|
|
411
|
|
|
412 -- Capitalize certain other basic macros relating to Lisp_Objects; e.g.
|
|
|
413 FRAMEP, CHECK_FRAME, etc.
|
|
|
414
|
|
|
415 -- Try to avoid capitalizing any other macros.
|
|
771
|
416 */
|
|
|
417
|
|
|
418 /* ---------------------------------------------------------------------- */
|
|
826
|
419 /* Working with charptr's (pointers to internally-formatted text) */
|
|
771
|
420 /* ---------------------------------------------------------------------- */
|
|
|
421
|
|
826
|
422 /* Given an charptr, does it point to the beginning of a character?
|
|
|
423 */
|
|
|
424
|
|
771
|
425 #ifdef MULE
|
|
826
|
426 # define valid_charptr_p(ptr) intbyte_first_byte_p (* (ptr))
|
|
771
|
427 #else
|
|
826
|
428 # define valid_charptr_p(ptr) 1
|
|
771
|
429 #endif
|
|
|
430
|
|
826
|
431 /* If error-checking is enabled, assert that the given charptr points to
|
|
|
432 the beginning of a character. Otherwise, do nothing.
|
|
|
433 */
|
|
|
434
|
|
|
435 #define assert_valid_charptr(ptr) text_checking_assert (valid_charptr_p (ptr))
|
|
|
436
|
|
|
437 /* Given a charptr (assumed to point at the beginning of a character),
|
|
|
438 modify that pointer so it points to the beginning of the next character.
|
|
|
439
|
|
|
440 Note that INC_CHARPTR() and DEC_CHARPTR() have to be written in
|
|
771
|
441 completely separate ways. INC_CHARPTR() cannot use the DEC_CHARPTR()
|
|
|
442 trick of looking for a valid first byte because it might run off
|
|
|
443 the end of the string. DEC_CHARPTR() can't use the INC_CHARPTR()
|
|
|
444 method because it doesn't have easy access to the first byte of
|
|
|
445 the character it's moving over. */
|
|
|
446
|
|
826
|
447 #define INC_CHARPTR(ptr) do { \
|
|
|
448 assert_valid_charptr (ptr); \
|
|
|
449 (ptr) += rep_bytes_by_first_byte (* (ptr)); \
|
|
|
450 } while (0)
|
|
|
451
|
|
|
452 #define INC_CHARPTR_FMT(ptr, fmt) \
|
|
|
453 do { \
|
|
|
454 Internal_Format __icf_fmt = (fmt); \
|
|
|
455 switch (__icf_fmt) \
|
|
|
456 { \
|
|
|
457 case FORMAT_DEFAULT: \
|
|
|
458 INC_CHARPTR (ptr); \
|
|
|
459 break; \
|
|
|
460 case FORMAT_16_BIT_FIXED: \
|
|
|
461 text_checking_assert (ptr == ALIGN_PTR (ptr, UINT_16_BIT)); \
|
|
|
462 (ptr) += 2; \
|
|
|
463 break; \
|
|
|
464 case FORMAT_32_BIT_FIXED: \
|
|
|
465 text_checking_assert (ptr == ALIGN_PTR (ptr, UINT_32_BIT)); \
|
|
|
466 (ptr) += 4; \
|
|
|
467 break; \
|
|
|
468 default: \
|
|
|
469 text_checking_assert (fmt == FORMAT_8_BIT_FIXED); \
|
|
|
470 (ptr)++; \
|
|
|
471 break; \
|
|
|
472 } \
|
|
|
473 } while (0)
|
|
|
474
|
|
|
475 /* Given a charptr (assumed to point at the beginning of a character or at
|
|
|
476 the very end of the text), modify that pointer so it points to the
|
|
|
477 beginning of the previous character.
|
|
|
478 */
|
|
771
|
479
|
|
800
|
480 #ifdef ERROR_CHECK_TEXT
|
|
826
|
481 /* We use a separate definition to avoid warnings about unused dc_ptr1 */
|
|
|
482 #define DEC_CHARPTR(ptr) do { \
|
|
|
483 const Intbyte *dc_ptr1 = (ptr); \
|
|
|
484 do { \
|
|
|
485 (ptr)--; \
|
|
|
486 } while (!valid_charptr_p (ptr)); \
|
|
|
487 text_checking_assert (dc_ptr1 - (ptr) == rep_bytes_by_first_byte (*(ptr))); \
|
|
771
|
488 } while (0)
|
|
826
|
489 #else
|
|
|
490 #define DEC_CHARPTR(ptr) do { \
|
|
|
491 do { \
|
|
|
492 (ptr)--; \
|
|
|
493 } while (!valid_charptr_p (ptr)); \
|
|
771
|
494 } while (0)
|
|
826
|
495 #endif /* ERROR_CHECK_TEXT */
|
|
|
496
|
|
|
497 #define DEC_CHARPTR_FMT(ptr, fmt) \
|
|
|
498 do { \
|
|
|
499 Internal_Format __icf_fmt = (fmt); \
|
|
|
500 switch (__icf_fmt) \
|
|
|
501 { \
|
|
|
502 case FORMAT_DEFAULT: \
|
|
|
503 DEC_CHARPTR (ptr); \
|
|
|
504 break; \
|
|
|
505 case FORMAT_16_BIT_FIXED: \
|
|
|
506 text_checking_assert (ptr == ALIGN_PTR (ptr, UINT_16_BIT)); \
|
|
|
507 (ptr) -= 2; \
|
|
|
508 break; \
|
|
|
509 case FORMAT_32_BIT_FIXED: \
|
|
|
510 text_checking_assert (ptr == ALIGN_PTR (ptr, UINT_32_BIT)); \
|
|
|
511 (ptr) -= 4; \
|
|
|
512 break; \
|
|
|
513 default: \
|
|
|
514 text_checking_assert (fmt == FORMAT_8_BIT_FIXED); \
|
|
|
515 (ptr)--; \
|
|
|
516 break; \
|
|
|
517 } \
|
|
771
|
518 } while (0)
|
|
|
519
|
|
|
520 #ifdef MULE
|
|
|
521
|
|
826
|
522 /* Make sure that PTR is pointing to the beginning of a character. If not,
|
|
|
523 back up until this is the case. Note that there are not too many places
|
|
|
524 where it is legitimate to do this sort of thing. It's an error if
|
|
|
525 you're passed an "invalid" char * pointer. NOTE: PTR *must* be pointing
|
|
|
526 to a valid part of the string (i.e. not the very end, unless the string
|
|
|
527 is zero-terminated or something) in order for this function to not cause
|
|
|
528 crashes.
|
|
|
529 */
|
|
|
530
|
|
771
|
531 /* Note that this reads the byte at *PTR! */
|
|
|
532
|
|
|
533 #define VALIDATE_CHARPTR_BACKWARD(ptr) do { \
|
|
826
|
534 while (!valid_charptr_p (ptr)) ptr--; \
|
|
771
|
535 } while (0)
|
|
|
536
|
|
826
|
537 /* Make sure that PTR is pointing to the beginning of a character. If not,
|
|
|
538 move forward until this is the case. Note that there are not too many
|
|
|
539 places where it is legitimate to do this sort of thing. It's an error
|
|
|
540 if you're passed an "invalid" char * pointer.
|
|
|
541 */
|
|
771
|
542
|
|
|
543 /* This needs to be trickier than VALIDATE_CHARPTR_BACKWARD() to avoid the
|
|
|
544 possibility of running off the end of the string. */
|
|
|
545
|
|
|
546 #define VALIDATE_CHARPTR_FORWARD(ptr) do { \
|
|
|
547 Intbyte *vcf_ptr = (ptr); \
|
|
|
548 VALIDATE_CHARPTR_BACKWARD (vcf_ptr); \
|
|
|
549 if (vcf_ptr != (ptr)) \
|
|
|
550 { \
|
|
|
551 (ptr) = vcf_ptr; \
|
|
|
552 INC_CHARPTR (ptr); \
|
|
|
553 } \
|
|
|
554 } while (0)
|
|
|
555
|
|
|
556 #else /* not MULE */
|
|
|
557 #define VALIDATE_CHARPTR_BACKWARD(ptr)
|
|
|
558 #define VALIDATE_CHARPTR_FORWARD(ptr)
|
|
826
|
559 #endif /* not MULE */
|
|
|
560
|
|
|
561 #ifdef MULE
|
|
|
562
|
|
|
563 /* Given a Intbyte string at PTR of size N, possibly with a partial
|
|
|
564 character at the end, return the size of the longest substring of
|
|
|
565 complete characters. Does not assume that the byte at *(PTR + N) is
|
|
|
566 readable. Note that there are not too many places where it is
|
|
|
567 legitimate to do this sort of thing. It's an error if you're passed an
|
|
|
568 "invalid" offset. */
|
|
|
569
|
|
|
570 DECLARE_INLINE_HEADER (
|
|
|
571 Bytecount
|
|
|
572 validate_intbyte_string_backward (const Intbyte *ptr, Bytecount n)
|
|
|
573 )
|
|
|
574 {
|
|
|
575 const Intbyte *ptr2;
|
|
|
576
|
|
|
577 if (n == 0)
|
|
|
578 return n;
|
|
|
579 ptr2 = ptr + n - 1;
|
|
|
580 VALIDATE_CHARPTR_BACKWARD (ptr2);
|
|
|
581 if (ptr2 + rep_bytes_by_first_byte (*ptr2) != ptr + n)
|
|
|
582 return ptr2 - ptr;
|
|
|
583 return n;
|
|
|
584 }
|
|
|
585
|
|
|
586 #else
|
|
|
587
|
|
771
|
588 #define validate_intbyte_string_backward(ptr, n) (n)
|
|
826
|
589
|
|
|
590 #endif /* MULE */
|
|
771
|
591
|
|
|
592 /* -------------------------------------------------------------- */
|
|
826
|
593 /* Working with the length (in bytes and characters) of a */
|
|
|
594 /* section of internally-formatted text */
|
|
771
|
595 /* -------------------------------------------------------------- */
|
|
|
596
|
|
826
|
597 #ifdef MULE
|
|
|
598
|
|
|
599 Charcount bytecount_to_charcount_fun (const Intbyte *ptr, Bytecount len);
|
|
|
600 Bytecount charcount_to_bytecount_fun (const Intbyte *ptr, Charcount len);
|
|
|
601
|
|
|
602 /* Given a pointer to a text string and a length in bytes, return
|
|
|
603 the equivalent length in characters. */
|
|
|
604
|
|
|
605 DECLARE_INLINE_HEADER (
|
|
|
606 Charcount
|
|
|
607 bytecount_to_charcount (const Intbyte *ptr, Bytecount len)
|
|
|
608 )
|
|
|
609 {
|
|
|
610 if (len < 20) /* Just a random guess, but it should be more or less correct.
|
|
|
611 If number of bytes is small, just do a simple loop,
|
|
|
612 which should be more efficient. */
|
|
|
613 {
|
|
|
614 Charcount count = 0;
|
|
|
615 const Intbyte *end = ptr + len;
|
|
|
616 while (ptr < end)
|
|
|
617 {
|
|
|
618 INC_CHARPTR (ptr);
|
|
|
619 count++;
|
|
|
620 }
|
|
|
621 /* Bomb out if the specified substring ends in the middle
|
|
|
622 of a character. Note that we might have already gotten
|
|
|
623 a core dump above from an invalid reference, but at least
|
|
|
624 we will get no farther than here.
|
|
|
625
|
|
|
626 This also catches len < 0. */
|
|
|
627 text_checking_assert (ptr == end);
|
|
|
628
|
|
|
629 return count;
|
|
|
630 }
|
|
|
631 else
|
|
|
632 return bytecount_to_charcount_fun (ptr, len);
|
|
|
633 }
|
|
|
634
|
|
|
635 /* Given a pointer to a text string and a length in characters, return the
|
|
|
636 equivalent length in bytes.
|
|
|
637 */
|
|
|
638
|
|
|
639 DECLARE_INLINE_HEADER (
|
|
|
640 Bytecount
|
|
|
641 charcount_to_bytecount (const Intbyte *ptr, Charcount len)
|
|
|
642 )
|
|
|
643 {
|
|
|
644 text_checking_assert (len >= 0);
|
|
|
645 if (len < 20) /* See above */
|
|
|
646 {
|
|
|
647 const Intbyte *newptr = ptr;
|
|
|
648 while (len > 0)
|
|
|
649 {
|
|
|
650 INC_CHARPTR (newptr);
|
|
|
651 len--;
|
|
|
652 }
|
|
|
653 return newptr - ptr;
|
|
|
654 }
|
|
|
655 else
|
|
|
656 return charcount_to_bytecount_fun (ptr, len);
|
|
|
657 }
|
|
|
658
|
|
|
659 /* Given a pointer to a text string in the specified format and a length in
|
|
|
660 bytes, return the equivalent length in characters.
|
|
|
661 */
|
|
|
662
|
|
|
663 DECLARE_INLINE_HEADER (
|
|
|
664 Charcount
|
|
|
665 bytecount_to_charcount_fmt (const Intbyte *ptr, Bytecount len,
|
|
|
666 Internal_Format fmt)
|
|
|
667 )
|
|
|
668 {
|
|
|
669 switch (fmt)
|
|
|
670 {
|
|
|
671 case FORMAT_DEFAULT:
|
|
|
672 return bytecount_to_charcount (ptr, len);
|
|
|
673 case FORMAT_16_BIT_FIXED:
|
|
|
674 text_checking_assert (ptr == ALIGN_PTR (ptr, UINT_16_BIT));
|
|
|
675 return (Charcount) (len << 1);
|
|
|
676 case FORMAT_32_BIT_FIXED:
|
|
|
677 text_checking_assert (ptr == ALIGN_PTR (ptr, UINT_32_BIT));
|
|
|
678 return (Charcount) (len << 2);
|
|
|
679 default:
|
|
|
680 text_checking_assert (fmt == FORMAT_8_BIT_FIXED);
|
|
|
681 return (Charcount) len;
|
|
|
682 }
|
|
|
683 }
|
|
|
684
|
|
|
685 /* Given a pointer to a text string in the specified format and a length in
|
|
|
686 characters, return the equivalent length in bytes.
|
|
|
687 */
|
|
|
688
|
|
|
689 DECLARE_INLINE_HEADER (
|
|
|
690 Bytecount
|
|
|
691 charcount_to_bytecount_fmt (const Intbyte *ptr, Charcount len,
|
|
|
692 Internal_Format fmt)
|
|
|
693 )
|
|
|
694 {
|
|
|
695 switch (fmt)
|
|
|
696 {
|
|
|
697 case FORMAT_DEFAULT:
|
|
|
698 return charcount_to_bytecount (ptr, len);
|
|
|
699 case FORMAT_16_BIT_FIXED:
|
|
|
700 text_checking_assert (ptr == ALIGN_PTR (ptr, UINT_16_BIT));
|
|
|
701 text_checking_assert (!(len & 1));
|
|
|
702 return (Bytecount) (len >> 1);
|
|
|
703 case FORMAT_32_BIT_FIXED:
|
|
|
704 text_checking_assert (!(len & 3));
|
|
|
705 text_checking_assert (ptr == ALIGN_PTR (ptr, UINT_32_BIT));
|
|
|
706 return (Bytecount) (len >> 2);
|
|
|
707 default:
|
|
|
708 text_checking_assert (fmt == FORMAT_8_BIT_FIXED);
|
|
|
709 return (Bytecount) len;
|
|
|
710 }
|
|
|
711 }
|
|
|
712
|
|
|
713 #else
|
|
|
714
|
|
|
715 #define bytecount_to_charcount(ptr, len) ((Charcount) (len))
|
|
|
716 #define bytecount_to_charcount_fmt(ptr, len, fmt) ((Charcount) (len))
|
|
|
717 #define charcount_to_bytecount(ptr, len) ((Bytecount) (len))
|
|
|
718 #define charcount_to_bytecount_fmt(ptr, len, fmt) ((Bytecount) (len))
|
|
|
719
|
|
|
720 #endif /* MULE */
|
|
|
721
|
|
|
722 /* Return the length of the first character at PTR. Equivalent to
|
|
|
723 charcount_to_bytecount (ptr, 1).
|
|
|
724
|
|
|
725 [Since charcount_to_bytecount() is Written as inline, a smart compiler
|
|
|
726 should really optimize charcount_to_bytecount (ptr, 1) to the same as
|
|
|
727 the following, with no error checking. But since this idiom occurs so
|
|
|
728 often, we'll be helpful and define a special macro for it.]
|
|
|
729 */
|
|
|
730
|
|
|
731 #define charptr_emchar_len(ptr) rep_bytes_by_first_byte (*(ptr))
|
|
|
732
|
|
|
733 /* Return the length of the first character at PTR, which is in the
|
|
|
734 specified internal format. Equivalent to charcount_to_bytecount_fmt
|
|
|
735 (ptr, 1, fmt).
|
|
|
736 */
|
|
|
737
|
|
|
738 DECLARE_INLINE_HEADER (
|
|
|
739 Bytecount
|
|
|
740 charptr_emchar_len_fmt (const Intbyte *ptr, Internal_Format fmt)
|
|
|
741 )
|
|
|
742 {
|
|
|
743 switch (fmt)
|
|
|
744 {
|
|
|
745 case FORMAT_DEFAULT:
|
|
|
746 return charptr_emchar_len (ptr);
|
|
|
747 case FORMAT_16_BIT_FIXED:
|
|
|
748 text_checking_assert (ptr == ALIGN_PTR (ptr, UINT_16_BIT));
|
|
|
749 return 2;
|
|
|
750 case FORMAT_32_BIT_FIXED:
|
|
|
751 text_checking_assert (ptr == ALIGN_PTR (ptr, UINT_32_BIT));
|
|
|
752 return 4;
|
|
|
753 default:
|
|
|
754 text_checking_assert (fmt == FORMAT_8_BIT_FIXED);
|
|
|
755 return 1;
|
|
|
756 }
|
|
|
757 }
|
|
|
758
|
|
|
759 /* Return a pointer to the beginning of the character offset N (in
|
|
|
760 characters) from PTR.
|
|
|
761 */
|
|
|
762
|
|
|
763 DECLARE_INLINE_HEADER (
|
|
|
764 const Intbyte *
|
|
771
|
765 charptr_n_addr (const Intbyte *ptr, Charcount offset)
|
|
826
|
766 )
|
|
771
|
767 {
|
|
|
768 return ptr + charcount_to_bytecount (ptr, offset);
|
|
|
769 }
|
|
|
770
|
|
826
|
771 /* Given a charptr and an offset into the text pointed to by the charptr,
|
|
|
772 modify the offset so it points to the beginning of the next character.
|
|
|
773 */
|
|
|
774
|
|
|
775 #define INC_BYTECOUNT(ptr, pos) do { \
|
|
|
776 assert_valid_charptr (ptr); \
|
|
|
777 (pos += rep_bytes_by_first_byte (* ((ptr) + (pos)))); \
|
|
|
778 } while (0)
|
|
|
779
|
|
771
|
780 /* -------------------------------------------------------------------- */
|
|
826
|
781 /* Retrieving or changing the character pointed to by a charptr */
|
|
771
|
782 /* -------------------------------------------------------------------- */
|
|
|
783
|
|
|
784 #define simple_charptr_emchar(ptr) ((Emchar) (ptr)[0])
|
|
814
|
785 #define simple_set_charptr_emchar(ptr, x) \
|
|
|
786 ((ptr)[0] = (Intbyte) (x), (Bytecount) 1)
|
|
826
|
787 #define simple_charptr_copy_emchar(src, dst) \
|
|
814
|
788 ((dst)[0] = *(src), (Bytecount) 1)
|
|
771
|
789
|
|
|
790 #ifdef MULE
|
|
|
791
|
|
|
792 Emchar non_ascii_charptr_emchar (const Intbyte *ptr);
|
|
|
793 Bytecount non_ascii_set_charptr_emchar (Intbyte *ptr, Emchar c);
|
|
826
|
794 Bytecount non_ascii_charptr_copy_emchar (const Intbyte *src, Intbyte *dst);
|
|
|
795
|
|
|
796 /* Retrieve the character pointed to by PTR as an Emchar. */
|
|
|
797
|
|
|
798 DECLARE_INLINE_HEADER (
|
|
|
799 Emchar
|
|
771
|
800 charptr_emchar (const Intbyte *ptr)
|
|
826
|
801 )
|
|
771
|
802 {
|
|
826
|
803 return byte_ascii_p (*ptr) ?
|
|
771
|
804 simple_charptr_emchar (ptr) :
|
|
|
805 non_ascii_charptr_emchar (ptr);
|
|
|
806 }
|
|
|
807
|
|
826
|
808 /* Retrieve the character pointed to by PTR (a pointer to text in the
|
|
|
809 format FMT, coming from OBJECT [a buffer, string?, or nil]) as an
|
|
|
810 Emchar.
|
|
|
811
|
|
|
812 Note: For these and other *_fmt() functions, if you pass in a constant
|
|
|
813 FMT, the switch will be optimized out of existence. Therefore, there is
|
|
|
814 no need to create separate versions for the various formats for
|
|
|
815 "efficiency reasons". In fact, we don't really need charptr_emchar()
|
|
|
816 and such written separately, but they are used often so it's simpler
|
|
|
817 that way. */
|
|
|
818
|
|
|
819 DECLARE_INLINE_HEADER (
|
|
|
820 Emchar
|
|
|
821 charptr_emchar_fmt (const Intbyte *ptr, Internal_Format fmt,
|
|
|
822 Lisp_Object object)
|
|
|
823 )
|
|
|
824 {
|
|
|
825 switch (fmt)
|
|
|
826 {
|
|
|
827 case FORMAT_DEFAULT:
|
|
|
828 return charptr_emchar (ptr);
|
|
|
829 case FORMAT_16_BIT_FIXED:
|
|
|
830 text_checking_assert (ptr == ALIGN_PTR (ptr, UINT_16_BIT));
|
|
|
831 return raw_16_bit_fixed_to_emchar (* (UINT_16_BIT *) ptr, object);
|
|
|
832 case FORMAT_32_BIT_FIXED:
|
|
|
833 text_checking_assert (ptr == ALIGN_PTR (ptr, UINT_32_BIT));
|
|
|
834 return raw_32_bit_fixed_to_emchar (* (UINT_32_BIT *) ptr, object);
|
|
|
835 default:
|
|
|
836 text_checking_assert (fmt == FORMAT_8_BIT_FIXED);
|
|
|
837 return raw_8_bit_fixed_to_emchar (*ptr, object);
|
|
|
838 }
|
|
|
839 }
|
|
|
840
|
|
|
841 /* Return the character at PTR (which is in format FMT), suitable for
|
|
|
842 comparison with an ASCII character. This guarantees that if the
|
|
|
843 character at PTR is ASCII (range 0 - 127), that character will be
|
|
|
844 returned; otherwise, some character outside of the ASCII range will be
|
|
|
845 returned, but not necessarily the character actually at PTR. This will
|
|
|
846 be faster than charptr_emchar_fmt() for some formats -- in particular,
|
|
|
847 FORMAT_DEFAULT. */
|
|
|
848
|
|
|
849 DECLARE_INLINE_HEADER (
|
|
|
850 Emchar
|
|
|
851 charptr_emchar_ascii_fmt (const Intbyte *ptr, Internal_Format fmt,
|
|
|
852 Lisp_Object object)
|
|
|
853 )
|
|
|
854 {
|
|
|
855 switch (fmt)
|
|
|
856 {
|
|
|
857 case FORMAT_DEFAULT:
|
|
|
858 return (Emchar) *ptr;
|
|
|
859 case FORMAT_16_BIT_FIXED:
|
|
|
860 text_checking_assert (ptr == ALIGN_PTR (ptr, UINT_16_BIT));
|
|
|
861 return raw_16_bit_fixed_to_emchar (* (UINT_16_BIT *) ptr, object);
|
|
|
862 case FORMAT_32_BIT_FIXED:
|
|
|
863 text_checking_assert (ptr == ALIGN_PTR (ptr, UINT_32_BIT));
|
|
|
864 return raw_32_bit_fixed_to_emchar (* (UINT_32_BIT *) ptr, object);
|
|
|
865 default:
|
|
|
866 text_checking_assert (fmt == FORMAT_8_BIT_FIXED);
|
|
|
867 return raw_8_bit_fixed_to_emchar (*ptr, object);
|
|
|
868 }
|
|
|
869 }
|
|
|
870
|
|
|
871 /* Return the "raw value" of the character at PTR, in format FMT. This is
|
|
|
872 useful when searching for a character; convert the character using
|
|
|
873 emchar_to_raw(). */
|
|
|
874
|
|
|
875 DECLARE_INLINE_HEADER (
|
|
|
876 Raw_Emchar
|
|
|
877 charptr_emchar_raw_fmt (const Intbyte *ptr, Internal_Format fmt)
|
|
|
878 )
|
|
|
879 {
|
|
|
880 switch (fmt)
|
|
|
881 {
|
|
|
882 case FORMAT_DEFAULT:
|
|
|
883 return (Raw_Emchar) charptr_emchar (ptr);
|
|
|
884 case FORMAT_16_BIT_FIXED:
|
|
|
885 text_checking_assert (ptr == ALIGN_PTR (ptr, UINT_16_BIT));
|
|
|
886 return (Raw_Emchar) (* (UINT_16_BIT *) ptr);
|
|
|
887 case FORMAT_32_BIT_FIXED:
|
|
|
888 text_checking_assert (ptr == ALIGN_PTR (ptr, UINT_32_BIT));
|
|
|
889 return (Raw_Emchar) (* (UINT_32_BIT *) ptr);
|
|
|
890 default:
|
|
|
891 text_checking_assert (fmt == FORMAT_8_BIT_FIXED);
|
|
|
892 return (Raw_Emchar) (*ptr);
|
|
|
893 }
|
|
|
894 }
|
|
|
895
|
|
|
896 /* Store the character CH (an Emchar) as internally-formatted text starting
|
|
|
897 at PTR. Return the number of bytes stored.
|
|
|
898 */
|
|
|
899
|
|
|
900 DECLARE_INLINE_HEADER (
|
|
|
901 Bytecount
|
|
771
|
902 set_charptr_emchar (Intbyte *ptr, Emchar x)
|
|
826
|
903 )
|
|
771
|
904 {
|
|
826
|
905 return !emchar_multibyte_p (x) ?
|
|
771
|
906 simple_set_charptr_emchar (ptr, x) :
|
|
|
907 non_ascii_set_charptr_emchar (ptr, x);
|
|
|
908 }
|
|
|
909
|
|
826
|
910 /* Store the character CH (an Emchar) as internally-formatted text of
|
|
|
911 format FMT starting at PTR, which comes from OBJECT. Return the number
|
|
|
912 of bytes stored.
|
|
|
913 */
|
|
|
914
|
|
|
915 DECLARE_INLINE_HEADER (
|
|
|
916 Bytecount
|
|
|
917 set_charptr_emchar_fmt (Intbyte *ptr, Emchar x, Internal_Format fmt,
|
|
|
918 Lisp_Object object)
|
|
|
919 )
|
|
771
|
920 {
|
|
826
|
921 switch (fmt)
|
|
|
922 {
|
|
|
923 case FORMAT_DEFAULT:
|
|
|
924 return set_charptr_emchar (ptr, x);
|
|
|
925 case FORMAT_16_BIT_FIXED:
|
|
|
926 text_checking_assert (emchar_16_bit_fixed_p (x, object));
|
|
|
927 text_checking_assert (ptr == ALIGN_PTR (ptr, UINT_16_BIT));
|
|
|
928 * (UINT_16_BIT *) ptr = emchar_to_raw_16_bit_fixed (x, object);
|
|
|
929 return 2;
|
|
|
930 case FORMAT_32_BIT_FIXED:
|
|
|
931 text_checking_assert (ptr == ALIGN_PTR (ptr, UINT_32_BIT));
|
|
|
932 * (UINT_32_BIT *) ptr = emchar_to_raw_32_bit_fixed (x, object);
|
|
|
933 return 4;
|
|
|
934 default:
|
|
|
935 text_checking_assert (fmt == FORMAT_8_BIT_FIXED);
|
|
|
936 text_checking_assert (emchar_8_bit_fixed_p (x, object));
|
|
|
937 *ptr = emchar_to_raw_8_bit_fixed (x, object);
|
|
|
938 return 1;
|
|
|
939 }
|
|
|
940 }
|
|
|
941
|
|
|
942 /* Retrieve the character pointed to by SRC and store it as
|
|
|
943 internally-formatted text in DST.
|
|
|
944 */
|
|
|
945
|
|
|
946 DECLARE_INLINE_HEADER (
|
|
|
947 Bytecount
|
|
|
948 charptr_copy_emchar (const Intbyte *src, Intbyte *dst)
|
|
|
949 )
|
|
|
950 {
|
|
|
951 return byte_ascii_p (*src) ?
|
|
|
952 simple_charptr_copy_emchar (src, dst) :
|
|
|
953 non_ascii_charptr_copy_emchar (src, dst);
|
|
771
|
954 }
|
|
|
955
|
|
|
956 #else /* not MULE */
|
|
|
957
|
|
826
|
958 # define charptr_emchar(ptr) simple_charptr_emchar (ptr)
|
|
|
959 # define charptr_emchar_fmt(ptr, fmt, object) charptr_emchar (ptr)
|
|
|
960 # define charptr_emchar_ascii_fmt(ptr, fmt, object) charptr_emchar (ptr)
|
|
|
961 # define charptr_emchar_raw_fmt(ptr, fmt) charptr_emchar (ptr)
|
|
|
962 # define set_charptr_emchar(ptr, x) simple_set_charptr_emchar (ptr, x)
|
|
|
963 # define set_charptr_emchar_fmt(ptr, x, fmt, obj) set_charptr_emchar (ptr, x)
|
|
|
964 # define charptr_copy_emchar(src, dst) simple_charptr_copy_emchar (src, dst)
|
|
771
|
965
|
|
|
966 #endif /* not MULE */
|
|
|
967
|
|
826
|
968 /* Retrieve the character at offset N (in characters) from PTR, as an
|
|
|
969 Emchar.
|
|
|
970 */
|
|
|
971
|
|
771
|
972 #define charptr_emchar_n(ptr, offset) \
|
|
|
973 charptr_emchar (charptr_n_addr (ptr, offset))
|
|
|
974
|
|
|
975
|
|
|
976 /* ---------------------------- */
|
|
826
|
977 /* Working with Emchars */
|
|
771
|
978 /* ---------------------------- */
|
|
|
979
|
|
826
|
980 /* NOTE: There are other functions/macros for working with Emchars in
|
|
|
981 charset.h, for retrieving the charset of an Emchar, the length of an
|
|
|
982 Emchar when converted to text, etc.
|
|
|
983 */
|
|
|
984
|
|
771
|
985 #ifdef MULE
|
|
|
986
|
|
826
|
987 int non_ascii_valid_emchar_p (Emchar ch);
|
|
|
988
|
|
|
989 /* Return whether the given Emchar is valid.
|
|
|
990 */
|
|
|
991
|
|
|
992 DECLARE_INLINE_HEADER (
|
|
|
993 int
|
|
|
994 valid_emchar_p (Emchar ch)
|
|
|
995 )
|
|
771
|
996 {
|
|
826
|
997 return (! (ch & ~0xFF)) || non_ascii_valid_emchar_p (ch);
|
|
771
|
998 }
|
|
|
999
|
|
|
1000 #else /* not MULE */
|
|
|
1001
|
|
826
|
1002 #define valid_emchar_p(ch) (! (ch & ~0xFF))
|
|
771
|
1003
|
|
|
1004 #endif /* not MULE */
|
|
|
1005
|
|
831
|
1006 DECLARE_INLINE_HEADER (
|
|
|
1007 Lisp_Object
|
|
|
1008 make_char (Emchar val)
|
|
|
1009 )
|
|
|
1010 {
|
|
|
1011 type_checking_assert (valid_emchar_p (val));
|
|
|
1012 return make_char_1 (val);
|
|
|
1013 }
|
|
|
1014
|
|
826
|
1015 #define CHAR_INTP(x) (INTP (x) && valid_emchar_p (XINT (x)))
|
|
771
|
1016
|
|
|
1017 #define CHAR_OR_CHAR_INTP(x) (CHARP (x) || CHAR_INTP (x))
|
|
|
1018
|
|
826
|
1019 DECLARE_INLINE_HEADER (
|
|
|
1020 Emchar
|
|
771
|
1021 XCHAR_OR_CHAR_INT (Lisp_Object obj)
|
|
826
|
1022 )
|
|
771
|
1023 {
|
|
|
1024 return CHARP (obj) ? XCHAR (obj) : XINT (obj);
|
|
|
1025 }
|
|
|
1026
|
|
826
|
1027 /* Signal an error if CH is not a valid character or integer Lisp_Object.
|
|
|
1028 If CH is an integer Lisp_Object, convert it to a character Lisp_Object,
|
|
|
1029 but merely by repackaging, without performing tests for char validity.
|
|
|
1030 */
|
|
|
1031
|
|
771
|
1032 #define CHECK_CHAR_COERCE_INT(x) do { \
|
|
|
1033 if (CHARP (x)) \
|
|
|
1034 ; \
|
|
|
1035 else if (CHAR_INTP (x)) \
|
|
|
1036 x = make_char (XINT (x)); \
|
|
|
1037 else \
|
|
|
1038 x = wrong_type_argument (Qcharacterp, x); \
|
|
|
1039 } while (0)
|
|
|
1040
|
|
|
1041
|
|
|
1042
|
|
|
1043 /************************************************************************/
|
|
|
1044 /* */
|
|
826
|
1045 /* working with Lisp strings */
|
|
|
1046 /* */
|
|
|
1047 /************************************************************************/
|
|
|
1048
|
|
|
1049 #define string_char_length(s) \
|
|
|
1050 string_index_byte_to_char (s, XSTRING_LENGTH (s))
|
|
|
1051 #define string_byte(s, i) (XSTRING_DATA (s)[i] + 0)
|
|
|
1052 /* In case we ever allow strings to be in a different format ... */
|
|
|
1053 #define set_string_byte(s, i, c) (XSTRING_DATA (s)[i] = (c))
|
|
|
1054
|
|
|
1055 #define ASSERT_VALID_CHAR_STRING_INDEX_UNSAFE(s, x) do { \
|
|
|
1056 text_checking_assert ((x) >= 0 && x <= string_char_length (s)); \
|
|
|
1057 } while (0)
|
|
|
1058
|
|
|
1059 #define ASSERT_VALID_BYTE_STRING_INDEX_UNSAFE(s, x) do { \
|
|
|
1060 text_checking_assert ((x) >= 0 && x <= XSTRING_LENGTH (s)); \
|
|
|
1061 text_checking_assert (valid_charptr_p (string_byte_addr (s, x))); \
|
|
|
1062 } while (0)
|
|
|
1063
|
|
|
1064 /* Convert offset I in string S to a pointer to text there. */
|
|
|
1065 #define string_byte_addr(s, i) (&(XSTRING_DATA (s)[i]))
|
|
|
1066 /* Convert pointer to text in string S into the byte offset to that text. */
|
|
|
1067 #define string_addr_to_byte(s, ptr) ((Bytecount) ((ptr) - XSTRING_DATA (s)))
|
|
|
1068 /* Return the Emchar at *CHARACTER* offset I. */
|
|
|
1069 #define string_emchar(s, i) charptr_emchar (string_char_addr (s, i))
|
|
|
1070
|
|
|
1071 #ifdef ERROR_CHECK_TEXT
|
|
|
1072 #define SLEDGEHAMMER_CHECK_ASCII_BEGIN
|
|
|
1073 #endif
|
|
|
1074
|
|
|
1075 #ifdef SLEDGEHAMMER_CHECK_ASCII_BEGIN
|
|
|
1076 void sledgehammer_check_ascii_begin (Lisp_Object str);
|
|
|
1077 #else
|
|
|
1078 #define sledgehammer_check_ascii_begin(str)
|
|
|
1079 #endif
|
|
|
1080
|
|
|
1081 /* Make an alloca'd copy of a Lisp string */
|
|
|
1082 #define LISP_STRING_TO_ALLOCA(s, lval) \
|
|
|
1083 do { \
|
|
|
1084 Intbyte **_lta_ = (Intbyte **) &(lval); \
|
|
|
1085 Lisp_Object _lta_2 = (s); \
|
|
|
1086 *_lta_ = alloca_array (Intbyte, 1 + XSTRING_LENGTH (_lta_2)); \
|
|
|
1087 memcpy (*_lta_, XSTRING_DATA (_lta_2), 1 + XSTRING_LENGTH (_lta_2)); \
|
|
|
1088 } while (0)
|
|
|
1089
|
|
|
1090 /* Make an alloca'd copy of a Intbyte * */
|
|
|
1091 #define INTBYTE_STRING_TO_ALLOCA(p, lval) \
|
|
|
1092 do { \
|
|
|
1093 Intbyte **_bsta_ = (Intbyte **) &(lval); \
|
|
|
1094 const Intbyte *_bsta_2 = (p); \
|
|
|
1095 Bytecount _bsta_3 = qxestrlen (_bsta_2); \
|
|
|
1096 *_bsta_ = alloca_array (Intbyte, 1 + _bsta_3); \
|
|
|
1097 memcpy (*_bsta_, _bsta_2, 1 + _bsta_3); \
|
|
|
1098 } while (0)
|
|
|
1099
|
|
851
|
1100
|
|
826
|
1101 #define alloca_intbytes(num) alloca_array (Intbyte, num)
|
|
|
1102 #define alloca_extbytes(num) alloca_array (Extbyte, num)
|
|
|
1103
|
|
|
1104 void resize_string (Lisp_Object s, Bytecount pos, Bytecount delta);
|
|
|
1105
|
|
|
1106 /* Convert a byte index into a string into a char index. */
|
|
|
1107 DECLARE_INLINE_HEADER (
|
|
|
1108 Charcount
|
|
|
1109 string_index_byte_to_char (Lisp_Object s, Bytecount idx)
|
|
|
1110 )
|
|
|
1111 {
|
|
|
1112 Charcount retval;
|
|
|
1113 ASSERT_VALID_BYTE_STRING_INDEX_UNSAFE (s, idx);
|
|
|
1114 #ifdef MULE
|
|
|
1115 if (idx <= (Bytecount) XSTRING_ASCII_BEGIN (s))
|
|
|
1116 retval = (Charcount) idx;
|
|
|
1117 else
|
|
|
1118 retval = (XSTRING_ASCII_BEGIN (s) +
|
|
|
1119 bytecount_to_charcount (XSTRING_DATA (s) +
|
|
|
1120 XSTRING_ASCII_BEGIN (s),
|
|
|
1121 idx - XSTRING_ASCII_BEGIN (s)));
|
|
|
1122 # ifdef SLEDGEHAMMER_CHECK_ASCII_BEGIN
|
|
|
1123 assert (retval == bytecount_to_charcount (XSTRING_DATA (s), idx));
|
|
|
1124 # endif
|
|
|
1125 #else
|
|
|
1126 retval = (Charcount) idx;
|
|
|
1127 #endif
|
|
|
1128 /* Don't call ASSERT_VALID_CHAR_STRING_INDEX_UNSAFE() here because it will
|
|
|
1129 call string_index_byte_to_char(). */
|
|
|
1130 return retval;
|
|
|
1131 }
|
|
|
1132
|
|
|
1133 /* Convert a char index into a string into a byte index. */
|
|
|
1134 DECLARE_INLINE_HEADER (
|
|
|
1135 Bytecount
|
|
|
1136 string_index_char_to_byte (Lisp_Object s, Charcount idx)
|
|
|
1137 )
|
|
|
1138 {
|
|
|
1139 Bytecount retval;
|
|
|
1140 ASSERT_VALID_CHAR_STRING_INDEX_UNSAFE (s, idx);
|
|
|
1141 #ifdef MULE
|
|
|
1142 if (idx <= (Charcount) XSTRING_ASCII_BEGIN (s))
|
|
|
1143 retval = (Bytecount) idx;
|
|
|
1144 else
|
|
|
1145 retval = (XSTRING_ASCII_BEGIN (s) +
|
|
|
1146 charcount_to_bytecount (XSTRING_DATA (s) +
|
|
|
1147 XSTRING_ASCII_BEGIN (s),
|
|
|
1148 idx - XSTRING_ASCII_BEGIN (s)));
|
|
|
1149 # ifdef SLEDGEHAMMER_CHECK_ASCII_BEGIN
|
|
|
1150 assert (retval == charcount_to_bytecount (XSTRING_DATA (s), idx));
|
|
|
1151 # endif
|
|
|
1152 #else
|
|
|
1153 retval = (Bytecount) idx;
|
|
|
1154 #endif
|
|
|
1155 ASSERT_VALID_BYTE_STRING_INDEX_UNSAFE (s, retval);
|
|
|
1156 return retval;
|
|
|
1157 }
|
|
|
1158
|
|
|
1159 /* Convert a substring length (starting at byte offset OFF) from bytes to
|
|
|
1160 chars. */
|
|
|
1161 DECLARE_INLINE_HEADER (
|
|
|
1162 Charcount
|
|
|
1163 string_offset_byte_to_char_len (Lisp_Object s, Bytecount off, Bytecount len)
|
|
|
1164 )
|
|
|
1165 {
|
|
|
1166 Charcount retval;
|
|
|
1167 ASSERT_VALID_BYTE_STRING_INDEX_UNSAFE (s, off);
|
|
|
1168 ASSERT_VALID_BYTE_STRING_INDEX_UNSAFE (s, off + len);
|
|
|
1169 #ifdef MULE
|
|
|
1170 if (off + len <= (Bytecount) XSTRING_ASCII_BEGIN (s))
|
|
|
1171 retval = (Charcount) len;
|
|
|
1172 else if (off < (Bytecount) XSTRING_ASCII_BEGIN (s))
|
|
|
1173 retval =
|
|
|
1174 XSTRING_ASCII_BEGIN (s) - (Charcount) off +
|
|
|
1175 bytecount_to_charcount (XSTRING_DATA (s) + XSTRING_ASCII_BEGIN (s),
|
|
|
1176 len - (XSTRING_ASCII_BEGIN (s) - off));
|
|
|
1177 else
|
|
|
1178 retval = bytecount_to_charcount (XSTRING_DATA (s) + off, len);
|
|
|
1179 # ifdef SLEDGEHAMMER_CHECK_ASCII_BEGIN
|
|
|
1180 assert (retval == bytecount_to_charcount (XSTRING_DATA (s) + off, len));
|
|
|
1181 # endif
|
|
|
1182 #else
|
|
|
1183 retval = (Charcount) len;
|
|
|
1184 #endif
|
|
|
1185 return retval;
|
|
|
1186 }
|
|
|
1187
|
|
|
1188 /* Convert a substring length (starting at byte offset OFF) from chars to
|
|
|
1189 bytes. */
|
|
|
1190 DECLARE_INLINE_HEADER (
|
|
|
1191 Bytecount
|
|
|
1192 string_offset_char_to_byte_len (Lisp_Object s, Bytecount off, Charcount len)
|
|
|
1193 )
|
|
|
1194 {
|
|
|
1195 Bytecount retval;
|
|
|
1196 ASSERT_VALID_BYTE_STRING_INDEX_UNSAFE (s, off);
|
|
|
1197 #ifdef MULE
|
|
|
1198 /* casts to avoid errors from combining Bytecount/Charcount and warnings
|
|
|
1199 from signed/unsigned comparisons */
|
|
|
1200 if (off + (Bytecount) len <= (Bytecount) XSTRING_ASCII_BEGIN (s))
|
|
|
1201 retval = (Bytecount) len;
|
|
|
1202 else if (off < (Bytecount) XSTRING_ASCII_BEGIN (s))
|
|
|
1203 retval =
|
|
|
1204 XSTRING_ASCII_BEGIN (s) - off +
|
|
|
1205 charcount_to_bytecount (XSTRING_DATA (s) + XSTRING_ASCII_BEGIN (s),
|
|
|
1206 len - (XSTRING_ASCII_BEGIN (s) -
|
|
|
1207 (Charcount) off));
|
|
|
1208 else
|
|
|
1209 retval = charcount_to_bytecount (XSTRING_DATA (s) + off, len);
|
|
|
1210 # ifdef SLEDGEHAMMER_CHECK_ASCII_BEGIN
|
|
|
1211 assert (retval == charcount_to_bytecount (XSTRING_DATA (s) + off, len));
|
|
|
1212 # endif
|
|
|
1213 #else
|
|
|
1214 retval = (Bytecount) len;
|
|
|
1215 #endif
|
|
|
1216 ASSERT_VALID_BYTE_STRING_INDEX_UNSAFE (s, off + retval);
|
|
|
1217 return retval;
|
|
|
1218 }
|
|
|
1219
|
|
|
1220 DECLARE_INLINE_HEADER (
|
|
|
1221 const Intbyte *
|
|
|
1222 string_char_addr (Lisp_Object s, Charcount idx)
|
|
|
1223 )
|
|
|
1224 {
|
|
|
1225 return XSTRING_DATA (s) + string_index_char_to_byte (s, idx);
|
|
|
1226 }
|
|
|
1227
|
|
|
1228 /* WARNING: If you modify an existing string, you must call
|
|
|
1229 bump_string_modiff() afterwards. */
|
|
|
1230 #ifdef MULE
|
|
|
1231 void set_string_char (Lisp_Object s, Charcount i, Emchar c);
|
|
|
1232 #else
|
|
|
1233 #define set_string_char(s, i, c) set_string_byte (s, i, c)
|
|
|
1234 #endif /* not MULE */
|
|
|
1235
|
|
|
1236 /* Return index to character before the one at IDX. */
|
|
|
1237 DECLARE_INLINE_HEADER (
|
|
|
1238 Bytecount
|
|
|
1239 prev_string_index (Lisp_Object s, Bytecount idx)
|
|
|
1240 )
|
|
|
1241 {
|
|
|
1242 const Intbyte *ptr = string_byte_addr (s, idx);
|
|
|
1243 DEC_CHARPTR (ptr);
|
|
|
1244 return string_addr_to_byte (s, ptr);
|
|
|
1245 }
|
|
|
1246
|
|
|
1247 /* Return index to character after the one at IDX. */
|
|
|
1248 DECLARE_INLINE_HEADER (
|
|
|
1249 Bytecount
|
|
|
1250 next_string_index (Lisp_Object s, Bytecount idx)
|
|
|
1251 )
|
|
|
1252 {
|
|
|
1253 const Intbyte *ptr = string_byte_addr (s, idx);
|
|
|
1254 INC_CHARPTR (ptr);
|
|
|
1255 return string_addr_to_byte (s, ptr);
|
|
|
1256 }
|
|
|
1257
|
|
|
1258
|
|
|
1259 /************************************************************************/
|
|
|
1260 /* */
|
|
771
|
1261 /* working with Eistrings */
|
|
|
1262 /* */
|
|
|
1263 /************************************************************************/
|
|
|
1264
|
|
|
1265 /*
|
|
|
1266 #### NOTE: This is a work in progress. Neither the API nor especially
|
|
|
1267 the implementation is finished.
|
|
|
1268
|
|
|
1269 NOTE: An Eistring is a structure that makes it easy to work with
|
|
|
1270 internally-formatted strings of data. It provides operations similar
|
|
|
1271 in feel to the standard strcpy(), strcat(), strlen(), etc., but
|
|
|
1272
|
|
|
1273 (a) it is Mule-correct
|
|
|
1274 (b) it does dynamic allocation so you never have to worry about size
|
|
793
|
1275 restrictions
|
|
851
|
1276 (c) it comes in an ALLOCA() variety (all allocation is stack-local,
|
|
793
|
1277 so there is no need to explicitly clean up) as well as a malloc()
|
|
|
1278 variety
|
|
|
1279 (d) it knows its own length, so it does not suffer from standard null
|
|
|
1280 byte brain-damage -- but it null-terminates the data anyway, so
|
|
|
1281 it can be passed to standard routines
|
|
|
1282 (e) it provides a much more powerful set of operations and knows about
|
|
771
|
1283 all the standard places where string data might reside: Lisp_Objects,
|
|
|
1284 other Eistrings, Intbyte * data with or without an explicit length,
|
|
|
1285 ASCII strings, Emchars, etc.
|
|
793
|
1286 (f) it provides easy operations to convert to/from externally-formatted
|
|
|
1287 data, and is easier to use than the standard TO_INTERNAL_FORMAT
|
|
771
|
1288 and TO_EXTERNAL_FORMAT macros. (An Eistring can store both the internal
|
|
|
1289 and external version of its data, but the external version is only
|
|
|
1290 initialized or changed when you call eito_external().)
|
|
|
1291
|
|
793
|
1292 The idea is to make it as easy to write Mule-correct string manipulation
|
|
|
1293 code as it is to write normal string manipulation code. We also make
|
|
|
1294 the API sufficiently general that it can handle multiple internal data
|
|
|
1295 formats (e.g. some fixed-width optimizing formats and a default variable
|
|
|
1296 width format) and allows for *ANY* data format we might choose in the
|
|
|
1297 future for the default format, including UCS2. (In other words, we can't
|
|
|
1298 assume that the internal format is ASCII-compatible and we can't assume
|
|
|
1299 it doesn't have embedded null bytes. We do assume, however, that any
|
|
|
1300 chosen format will have the concept of null-termination.) All of this is
|
|
|
1301 hidden from the user.
|
|
771
|
1302
|
|
|
1303 #### It is really too bad that we don't have a real object-oriented
|
|
|
1304 language, or at least a language with polymorphism!
|
|
|
1305
|
|
|
1306
|
|
|
1307 **********************************************
|
|
|
1308 * Declaration *
|
|
|
1309 **********************************************
|
|
|
1310
|
|
|
1311 To declare an Eistring, either put one of the following in the local
|
|
|
1312 variable section:
|
|
|
1313
|
|
|
1314 DECLARE_EISTRING (name);
|
|
|
1315 Declare a new Eistring. This is a standard local variable declaration
|
|
|
1316 and can go anywhere in the variable declaration section. NAME itself
|
|
|
1317 is declared as an Eistring *, and its storage declared on the stack.
|
|
|
1318
|
|
|
1319 DECLARE_EISTRING_MALLOC (name);
|
|
851
|
1320 Declare a new Eistring, which uses malloc()ed instead of ALLOCA()ed
|
|
771
|
1321 data. This is a standard local variable declaration and can go
|
|
|
1322 anywhere in the variable declaration section. Once you initialize
|
|
|
1323 the Eistring, you will have to free it using eifree() to avoid
|
|
793
|
1324 memory leaks. You will need to use this form if you are passing
|
|
|
1325 an Eistring to any function that modifies it (otherwise, the
|
|
|
1326 modified data may be in stack space and get overwritten when the
|
|
|
1327 function returns).
|
|
771
|
1328
|
|
|
1329 or use
|
|
|
1330
|
|
793
|
1331 Eistring ei;
|
|
|
1332 void eiinit (Eistring *ei);
|
|
|
1333 void eiinit_malloc (Eistring *einame);
|
|
771
|
1334 If you need to put an Eistring elsewhere than in a local variable
|
|
|
1335 declaration (e.g. in a structure), declare it as shown and then
|
|
|
1336 call one of the init macros.
|
|
|
1337
|
|
|
1338 Also note:
|
|
|
1339
|
|
793
|
1340 void eifree (Eistring *ei);
|
|
771
|
1341 If you declared an Eistring to use malloc() to hold its data,
|
|
|
1342 or converted it to the heap using eito_malloc(), then this
|
|
|
1343 releases any data in it and afterwards resets the Eistring
|
|
|
1344 using eiinit_malloc(). Otherwise, it just resets the Eistring
|
|
|
1345 using eiinit().
|
|
|
1346
|
|
|
1347
|
|
|
1348 **********************************************
|
|
|
1349 * Conventions *
|
|
|
1350 **********************************************
|
|
|
1351
|
|
|
1352 - The names of the functions have been chosen, where possible, to
|
|
|
1353 match the names of str*() functions in the standard C API.
|
|
|
1354 -
|
|
|
1355
|
|
|
1356
|
|
|
1357 **********************************************
|
|
|
1358 * Initialization *
|
|
|
1359 **********************************************
|
|
|
1360
|
|
|
1361 void eireset (Eistring *eistr);
|
|
|
1362 Initialize the Eistring to the empty string.
|
|
|
1363
|
|
|
1364 void eicpy_* (Eistring *eistr, ...);
|
|
|
1365 Initialize the Eistring from somewhere:
|
|
|
1366
|
|
|
1367 void eicpy_ei (Eistring *eistr, Eistring *eistr2);
|
|
|
1368 ... from another Eistring.
|
|
|
1369 void eicpy_lstr (Eistring *eistr, Lisp_Object lisp_string);
|
|
|
1370 ... from a Lisp_Object string.
|
|
|
1371 void eicpy_ch (Eistring *eistr, Emchar ch);
|
|
793
|
1372 ... from an Emchar (this can be a conventional C character).
|
|
771
|
1373
|
|
|
1374 void eicpy_lstr_off (Eistring *eistr, Lisp_Object lisp_string,
|
|
|
1375 Bytecount off, Charcount charoff,
|
|
|
1376 Bytecount len, Charcount charlen);
|
|
|
1377 ... from a section of a Lisp_Object string.
|
|
|
1378 void eicpy_lbuf (Eistring *eistr, Lisp_Object lisp_buf,
|
|
|
1379 Bytecount off, Charcount charoff,
|
|
|
1380 Bytecount len, Charcount charlen);
|
|
|
1381 ... from a section of a Lisp_Object buffer.
|
|
|
1382 void eicpy_raw (Eistring *eistr, const Intbyte *data, Bytecount len);
|
|
|
1383 ... from raw internal-format data in the default internal format.
|
|
|
1384 void eicpy_rawz (Eistring *eistr, const Intbyte *data);
|
|
|
1385 ... from raw internal-format data in the default internal format
|
|
|
1386 that is "null-terminated" (the meaning of this depends on the nature
|
|
|
1387 of the default internal format).
|
|
|
1388 void eicpy_raw_fmt (Eistring *eistr, const Intbyte *data, Bytecount len,
|
|
826
|
1389 Internal_Format intfmt, Lisp_Object object);
|
|
771
|
1390 ... from raw internal-format data in the specified format.
|
|
|
1391 void eicpy_rawz_fmt (Eistring *eistr, const Intbyte *data,
|
|
826
|
1392 Internal_Format intfmt, Lisp_Object object);
|
|
771
|
1393 ... from raw internal-format data in the specified format that is
|
|
|
1394 "null-terminated" (the meaning of this depends on the nature of
|
|
|
1395 the specific format).
|
|
|
1396 void eicpy_c (Eistring *eistr, const Char_ASCII *c_string);
|
|
|
1397 ... from an ASCII null-terminated string. Non-ASCII characters in
|
|
|
1398 the string are *ILLEGAL* (read abort() with error-checking defined).
|
|
|
1399 void eicpy_c_len (Eistring *eistr, const Char_ASCII *c_string, len);
|
|
|
1400 ... from an ASCII string, with length specified. Non-ASCII characters
|
|
|
1401 in the string are *ILLEGAL* (read abort() with error-checking defined).
|
|
|
1402 void eicpy_ext (Eistring *eistr, const Extbyte *extdata,
|
|
|
1403 Lisp_Object coding_system);
|
|
|
1404 ... from external null-terminated data, with coding system specified.
|
|
|
1405 void eicpy_ext_len (Eistring *eistr, const Extbyte *extdata,
|
|
|
1406 Bytecount extlen, Lisp_Object coding_system);
|
|
|
1407 ... from external data, with length and coding system specified.
|
|
|
1408 void eicpy_lstream (Eistring *eistr, Lisp_Object lstream);
|
|
|
1409 ... from an lstream; reads data till eof. Data must be in default
|
|
|
1410 internal format; otherwise, interpose a decoding lstream.
|
|
|
1411
|
|
|
1412
|
|
|
1413 **********************************************
|
|
|
1414 * Getting the data out of the Eistring *
|
|
|
1415 **********************************************
|
|
|
1416
|
|
|
1417 Intbyte *eidata (Eistring *eistr);
|
|
|
1418 Return a pointer to the raw data in an Eistring. This is NOT
|
|
|
1419 a copy.
|
|
|
1420
|
|
|
1421 Lisp_Object eimake_string (Eistring *eistr);
|
|
|
1422 Make a Lisp string out of the Eistring.
|
|
|
1423
|
|
|
1424 Lisp_Object eimake_string_off (Eistring *eistr,
|
|
|
1425 Bytecount off, Charcount charoff,
|
|
|
1426 Bytecount len, Charcount charlen);
|
|
|
1427 Make a Lisp string out of a section of the Eistring.
|
|
|
1428
|
|
|
1429 void eicpyout_alloca (Eistring *eistr, LVALUE: Intbyte *ptr_out,
|
|
|
1430 LVALUE: Bytecount len_out);
|
|
851
|
1431 Make an ALLOCA() copy of the data in the Eistring, using the
|
|
|
1432 default internal format. Due to the nature of ALLOCA(), this
|
|
771
|
1433 must be a macro, with all lvalues passed in as parameters.
|
|
793
|
1434 (More specifically, not all compilers correctly handle using
|
|
851
|
1435 ALLOCA() as the argument to a function call -- GCC on x86
|
|
|
1436 didn't used to, for example.) A pointer to the ALLOCA()ed data
|
|
793
|
1437 is stored in PTR_OUT, and the length of the data (not including
|
|
|
1438 the terminating zero) is stored in LEN_OUT.
|
|
771
|
1439
|
|
|
1440 void eicpyout_alloca_fmt (Eistring *eistr, LVALUE: Intbyte *ptr_out,
|
|
|
1441 LVALUE: Bytecount len_out,
|
|
826
|
1442 Internal_Format intfmt, Lisp_Object object);
|
|
771
|
1443 Like eicpyout_alloca(), but converts to the specified internal
|
|
|
1444 format. (No formats other than FORMAT_DEFAULT are currently
|
|
|
1445 implemented, and you get an assertion failure if you try.)
|
|
|
1446
|
|
|
1447 Intbyte *eicpyout_malloc (Eistring *eistr, Bytecount *intlen_out);
|
|
|
1448 Make a malloc() copy of the data in the Eistring, using the
|
|
|
1449 default internal format. This is a real function. No lvalues
|
|
|
1450 passed in. Returns the new data, and stores the length (not
|
|
|
1451 including the terminating zero) using INTLEN_OUT, unless it's
|
|
|
1452 a NULL pointer.
|
|
|
1453
|
|
|
1454 Intbyte *eicpyout_malloc_fmt (Eistring *eistr, Internal_Format intfmt,
|
|
826
|
1455 Bytecount *intlen_out, Lisp_Object object);
|
|
771
|
1456 Like eicpyout_malloc(), but converts to the specified internal
|
|
|
1457 format. (No formats other than FORMAT_DEFAULT are currently
|
|
|
1458 implemented, and you get an assertion failure if you try.)
|
|
|
1459
|
|
|
1460
|
|
|
1461 **********************************************
|
|
|
1462 * Moving to the heap *
|
|
|
1463 **********************************************
|
|
|
1464
|
|
|
1465 void eito_malloc (Eistring *eistr);
|
|
|
1466 Move this Eistring to the heap. Its data will be stored in a
|
|
|
1467 malloc()ed block rather than the stack. Subsequent changes to
|
|
|
1468 this Eistring will realloc() the block as necessary. Use this
|
|
|
1469 when you want the Eistring to remain in scope past the end of
|
|
|
1470 this function call. You will have to manually free the data
|
|
|
1471 in the Eistring using eifree().
|
|
|
1472
|
|
|
1473 void eito_alloca (Eistring *eistr);
|
|
|
1474 Move this Eistring back to the stack, if it was moved to the
|
|
|
1475 heap with eito_malloc(). This will automatically free any
|
|
|
1476 heap-allocated data.
|
|
|
1477
|
|
|
1478
|
|
|
1479
|
|
|
1480 **********************************************
|
|
|
1481 * Retrieving the length *
|
|
|
1482 **********************************************
|
|
|
1483
|
|
|
1484 Bytecount eilen (Eistring *eistr);
|
|
|
1485 Return the length of the internal data, in bytes. See also
|
|
|
1486 eiextlen(), below.
|
|
|
1487 Charcount eicharlen (Eistring *eistr);
|
|
|
1488 Return the length of the internal data, in characters.
|
|
|
1489
|
|
|
1490
|
|
|
1491 **********************************************
|
|
|
1492 * Working with positions *
|
|
|
1493 **********************************************
|
|
|
1494
|
|
|
1495 Bytecount eicharpos_to_bytepos (Eistring *eistr, Charcount charpos);
|
|
|
1496 Convert a char offset to a byte offset.
|
|
|
1497 Charcount eibytepos_to_charpos (Eistring *eistr, Bytecount bytepos);
|
|
|
1498 Convert a byte offset to a char offset.
|
|
|
1499 Bytecount eiincpos (Eistring *eistr, Bytecount bytepos);
|
|
|
1500 Increment the given position by one character.
|
|
|
1501 Bytecount eiincpos_n (Eistring *eistr, Bytecount bytepos, Charcount n);
|
|
|
1502 Increment the given position by N characters.
|
|
|
1503 Bytecount eidecpos (Eistring *eistr, Bytecount bytepos);
|
|
|
1504 Decrement the given position by one character.
|
|
|
1505 Bytecount eidecpos_n (Eistring *eistr, Bytecount bytepos, Charcount n);
|
|
|
1506 Deccrement the given position by N characters.
|
|
|
1507
|
|
|
1508
|
|
|
1509 **********************************************
|
|
|
1510 * Getting the character at a position *
|
|
|
1511 **********************************************
|
|
|
1512
|
|
|
1513 Emchar eigetch (Eistring *eistr, Bytecount bytepos);
|
|
|
1514 Return the character at a particular byte offset.
|
|
|
1515 Emchar eigetch_char (Eistring *eistr, Charcount charpos);
|
|
|
1516 Return the character at a particular character offset.
|
|
|
1517
|
|
|
1518
|
|
|
1519 **********************************************
|
|
|
1520 * Setting the character at a position *
|
|
|
1521 **********************************************
|
|
|
1522
|
|
|
1523 Emchar eisetch (Eistring *eistr, Bytecount bytepos, Emchar chr);
|
|
|
1524 Set the character at a particular byte offset.
|
|
|
1525 Emchar eisetch_char (Eistring *eistr, Charcount charpos, Emchar chr);
|
|
|
1526 Set the character at a particular character offset.
|
|
|
1527
|
|
|
1528
|
|
|
1529 **********************************************
|
|
|
1530 * Concatenation *
|
|
|
1531 **********************************************
|
|
|
1532
|
|
|
1533 void eicat_* (Eistring *eistr, ...);
|
|
|
1534 Concatenate onto the end of the Eistring, with data coming from the
|
|
|
1535 same places as above:
|
|
|
1536
|
|
|
1537 void eicat_ei (Eistring *eistr, Eistring *eistr2);
|
|
|
1538 ... from another Eistring.
|
|
|
1539 void eicat_c (Eistring *eistr, Char_ASCII *c_string);
|
|
|
1540 ... from an ASCII null-terminated string. Non-ASCII characters in
|
|
|
1541 the string are *ILLEGAL* (read abort() with error-checking defined).
|
|
|
1542 void eicat_raw (ei, const Intbyte *data, Bytecount len);
|
|
|
1543 ... from raw internal-format data in the default internal format.
|
|
|
1544 void eicat_rawz (ei, const Intbyte *data);
|
|
|
1545 ... from raw internal-format data in the default internal format
|
|
|
1546 that is "null-terminated" (the meaning of this depends on the nature
|
|
|
1547 of the default internal format).
|
|
|
1548 void eicat_lstr (ei, Lisp_Object lisp_string);
|
|
|
1549 ... from a Lisp_Object string.
|
|
|
1550 void eicat_ch (ei, Emchar ch);
|
|
|
1551 ... from an Emchar.
|
|
|
1552
|
|
|
1553 (All except the first variety are convenience functions.
|
|
|
1554 In the general case, create another Eistring from the source.)
|
|
|
1555
|
|
|
1556
|
|
|
1557 **********************************************
|
|
|
1558 * Replacement *
|
|
|
1559 **********************************************
|
|
|
1560
|
|
|
1561 void eisub_* (Eistring *eistr, Bytecount off, Charcount charoff,
|
|
|
1562 Bytecount len, Charcount charlen, ...);
|
|
|
1563 Replace a section of the Eistring, specifically:
|
|
|
1564
|
|
|
1565 void eisub_ei (Eistring *eistr, Bytecount off, Charcount charoff,
|
|
|
1566 Bytecount len, Charcount charlen, Eistring *eistr2);
|
|
|
1567 ... with another Eistring.
|
|
|
1568 void eisub_c (Eistring *eistr, Bytecount off, Charcount charoff,
|
|
|
1569 Bytecount len, Charcount charlen, Char_ASCII *c_string);
|
|
|
1570 ... with an ASCII null-terminated string. Non-ASCII characters in
|
|
|
1571 the string are *ILLEGAL* (read abort() with error-checking defined).
|
|
|
1572 void eisub_ch (Eistring *eistr, Bytecount off, Charcount charoff,
|
|
|
1573 Bytecount len, Charcount charlen, Emchar ch);
|
|
|
1574 ... with an Emchar.
|
|
|
1575
|
|
|
1576 void eidel (Eistring *eistr, Bytecount off, Charcount charoff,
|
|
|
1577 Bytecount len, Charcount charlen);
|
|
|
1578 Delete a section of the Eistring.
|
|
|
1579
|
|
|
1580
|
|
|
1581 **********************************************
|
|
|
1582 * Converting to an external format *
|
|
|
1583 **********************************************
|
|
|
1584
|
|
|
1585 void eito_external (Eistring *eistr, Lisp_Object coding_system);
|
|
|
1586 Convert the Eistring to an external format and store the result
|
|
|
1587 in the string. NOTE: Further changes to the Eistring will *NOT*
|
|
|
1588 change the external data stored in the string. You will have to
|
|
|
1589 call eito_external() again in such a case if you want the external
|
|
|
1590 data.
|
|
|
1591
|
|
|
1592 Extbyte *eiextdata (Eistring *eistr);
|
|
|
1593 Return a pointer to the external data stored in the Eistring as
|
|
|
1594 a result of a prior call to eito_external().
|
|
|
1595
|
|
|
1596 Bytecount eiextlen (Eistring *eistr);
|
|
|
1597 Return the length in bytes of the external data stored in the
|
|
|
1598 Eistring as a result of a prior call to eito_external().
|
|
|
1599
|
|
|
1600
|
|
|
1601 **********************************************
|
|
|
1602 * Searching in the Eistring for a character *
|
|
|
1603 **********************************************
|
|
|
1604
|
|
|
1605 Bytecount eichr (Eistring *eistr, Emchar chr);
|
|
|
1606 Charcount eichr_char (Eistring *eistr, Emchar chr);
|
|
|
1607 Bytecount eichr_off (Eistring *eistr, Emchar chr, Bytecount off,
|
|
|
1608 Charcount charoff);
|
|
|
1609 Charcount eichr_off_char (Eistring *eistr, Emchar chr, Bytecount off,
|
|
|
1610 Charcount charoff);
|
|
|
1611 Bytecount eirchr (Eistring *eistr, Emchar chr);
|
|
|
1612 Charcount eirchr_char (Eistring *eistr, Emchar chr);
|
|
|
1613 Bytecount eirchr_off (Eistring *eistr, Emchar chr, Bytecount off,
|
|
|
1614 Charcount charoff);
|
|
|
1615 Charcount eirchr_off_char (Eistring *eistr, Emchar chr, Bytecount off,
|
|
|
1616 Charcount charoff);
|
|
|
1617
|
|
|
1618
|
|
|
1619 **********************************************
|
|
|
1620 * Searching in the Eistring for a string *
|
|
|
1621 **********************************************
|
|
|
1622
|
|
|
1623 Bytecount eistr_ei (Eistring *eistr, Eistring *eistr2);
|
|
|
1624 Charcount eistr_ei_char (Eistring *eistr, Eistring *eistr2);
|
|
|
1625 Bytecount eistr_ei_off (Eistring *eistr, Eistring *eistr2, Bytecount off,
|
|
|
1626 Charcount charoff);
|
|
|
1627 Charcount eistr_ei_off_char (Eistring *eistr, Eistring *eistr2,
|
|
|
1628 Bytecount off, Charcount charoff);
|
|
|
1629 Bytecount eirstr_ei (Eistring *eistr, Eistring *eistr2);
|
|
|
1630 Charcount eirstr_ei_char (Eistring *eistr, Eistring *eistr2);
|
|
|
1631 Bytecount eirstr_ei_off (Eistring *eistr, Eistring *eistr2, Bytecount off,
|
|
|
1632 Charcount charoff);
|
|
|
1633 Charcount eirstr_ei_off_char (Eistring *eistr, Eistring *eistr2,
|
|
|
1634 Bytecount off, Charcount charoff);
|
|
|
1635
|
|
|
1636 Bytecount eistr_c (Eistring *eistr, Char_ASCII *c_string);
|
|
|
1637 Charcount eistr_c_char (Eistring *eistr, Char_ASCII *c_string);
|
|
|
1638 Bytecount eistr_c_off (Eistring *eistr, Char_ASCII *c_string, Bytecount off,
|
|
|
1639 Charcount charoff);
|
|
|
1640 Charcount eistr_c_off_char (Eistring *eistr, Char_ASCII *c_string,
|
|
|
1641 Bytecount off, Charcount charoff);
|
|
|
1642 Bytecount eirstr_c (Eistring *eistr, Char_ASCII *c_string);
|
|
|
1643 Charcount eirstr_c_char (Eistring *eistr, Char_ASCII *c_string);
|
|
|
1644 Bytecount eirstr_c_off (Eistring *eistr, Char_ASCII *c_string,
|
|
|
1645 Bytecount off, Charcount charoff);
|
|
|
1646 Charcount eirstr_c_off_char (Eistring *eistr, Char_ASCII *c_string,
|
|
|
1647 Bytecount off, Charcount charoff);
|
|
|
1648
|
|
|
1649
|
|
|
1650 **********************************************
|
|
|
1651 * Comparison *
|
|
|
1652 **********************************************
|
|
|
1653
|
|
|
1654 int eicmp_* (Eistring *eistr, ...);
|
|
|
1655 int eicmp_off_* (Eistring *eistr, Bytecount off, Charcount charoff,
|
|
|
1656 Bytecount len, Charcount charlen, ...);
|
|
|
1657 int eicasecmp_* (Eistring *eistr, ...);
|
|
|
1658 int eicasecmp_off_* (Eistring *eistr, Bytecount off, Charcount charoff,
|
|
|
1659 Bytecount len, Charcount charlen, ...);
|
|
|
1660 int eicasecmp_i18n_* (Eistring *eistr, ...);
|
|
|
1661 int eicasecmp_i18n_off_* (Eistring *eistr, Bytecount off, Charcount charoff,
|
|
|
1662 Bytecount len, Charcount charlen, ...);
|
|
|
1663
|
|
|
1664 Compare the Eistring with the other data. Return value same as
|
|
|
1665 from strcmp. The `*' is either `ei' for another Eistring (in
|
|
|
1666 which case `...' is an Eistring), or `c' for a pure-ASCII string
|
|
|
1667 (in which case `...' is a pointer to that string). For anything
|
|
|
1668 more complex, first create an Eistring out of the source.
|
|
|
1669 Comparison is either simple (`eicmp_...'), ASCII case-folding
|
|
|
1670 (`eicasecmp_...'), or multilingual case-folding
|
|
|
1671 (`eicasecmp_i18n_...).
|
|
|
1672
|
|
|
1673
|
|
|
1674 More specifically, the prototypes are:
|
|
|
1675
|
|
|
1676 int eicmp_ei (Eistring *eistr, Eistring *eistr2);
|
|
|
1677 int eicmp_off_ei (Eistring *eistr, Bytecount off, Charcount charoff,
|
|
|
1678 Bytecount len, Charcount charlen, Eistring *eistr2);
|
|
|
1679 int eicasecmp_ei (Eistring *eistr, Eistring *eistr2);
|
|
|
1680 int eicasecmp_off_ei (Eistring *eistr, Bytecount off, Charcount charoff,
|
|
|
1681 Bytecount len, Charcount charlen, Eistring *eistr2);
|
|
|
1682 int eicasecmp_i18n_ei (Eistring *eistr, Eistring *eistr2);
|
|
|
1683 int eicasecmp_i18n_off_ei (Eistring *eistr, Bytecount off,
|
|
|
1684 Charcount charoff, Bytecount len,
|
|
|
1685 Charcount charlen, Eistring *eistr2);
|
|
|
1686
|
|
|
1687 int eicmp_c (Eistring *eistr, Char_ASCII *c_string);
|
|
|
1688 int eicmp_off_c (Eistring *eistr, Bytecount off, Charcount charoff,
|
|
|
1689 Bytecount len, Charcount charlen, Char_ASCII *c_string);
|
|
|
1690 int eicasecmp_c (Eistring *eistr, Char_ASCII *c_string);
|
|
|
1691 int eicasecmp_off_c (Eistring *eistr, Bytecount off, Charcount charoff,
|
|
|
1692 Bytecount len, Charcount charlen,
|
|
|
1693 Char_ASCII *c_string);
|
|
|
1694 int eicasecmp_i18n_c (Eistring *eistr, Char_ASCII *c_string);
|
|
|
1695 int eicasecmp_i18n_off_c (Eistring *eistr, Bytecount off, Charcount charoff,
|
|
|
1696 Bytecount len, Charcount charlen,
|
|
|
1697 Char_ASCII *c_string);
|
|
|
1698
|
|
|
1699
|
|
|
1700 **********************************************
|
|
|
1701 * Case-changing the Eistring *
|
|
|
1702 **********************************************
|
|
|
1703
|
|
|
1704 void eilwr (Eistring *eistr);
|
|
|
1705 Convert all characters in the Eistring to lowercase.
|
|
|
1706 void eiupr (Eistring *eistr);
|
|
|
1707 Convert all characters in the Eistring to uppercase.
|
|
|
1708 */
|
|
|
1709
|
|
|
1710
|
|
|
1711 /* Principles for writing Eistring functions:
|
|
|
1712
|
|
|
1713 (1) Unfortunately, we have to write most of the Eistring functions
|
|
851
|
1714 as macros, because of the use of ALLOCA(). The principle used
|
|
771
|
1715 below to assure no conflict in local variables is to prefix all
|
|
|
1716 local variables with "ei" plus a number, which should be unique
|
|
|
1717 among macros. In practice, when finding a new number, find the
|
|
|
1718 highest so far used, and add 1.
|
|
|
1719
|
|
|
1720 (2) We also suffix the Eistring fields with an _ to avoid problems
|
|
|
1721 with macro parameters of the same name. (And as the standard
|
|
|
1722 signal not to access these fields directly.)
|
|
|
1723
|
|
|
1724 (3) We maintain both the length in bytes and chars of the data in
|
|
|
1725 the Eistring at all times, for convenient retrieval by outside
|
|
|
1726 functions. That means when writing functions that manipulate
|
|
|
1727 Eistrings, you too need to keep both lengths up to date for all
|
|
|
1728 data that you work with.
|
|
|
1729
|
|
|
1730 (4) When writing a new type of operation (e.g. substitution), you
|
|
|
1731 will often find yourself working with outside data, and thus
|
|
|
1732 have a series of related API's, for different forms that the
|
|
|
1733 outside data is in. Generally, you will want to choose a
|
|
|
1734 subset of the forms supported by eicpy_*, which has to be
|
|
|
1735 totally general because that's the fundamental way to get data
|
|
|
1736 into an Eistring, and once the data is into the string, it
|
|
|
1737 would be to create a whole series of Ei operations that work on
|
|
|
1738 nothing but Eistrings. Although theoretically nice, in
|
|
|
1739 practice it's a hassle, so we suggest that you provide
|
|
|
1740 convenience functions. In particular, there are two paths you
|
|
|
1741 can take. One is minimalist -- it only allows other Eistrings
|
|
|
1742 and ASCII data, and Emchars if the particular operation makes
|
|
|
1743 sense with a character. The other provides interfaces for the
|
|
|
1744 most commonly-used forms -- Eistring, ASCII data, Lisp string,
|
|
|
1745 raw internal-format string with length, raw internal-format
|
|
|
1746 string without, and possibly Emchar. (In the function names,
|
|
|
1747 these are designated `ei', `c', `lstr', `raw', `rawz', and
|
|
|
1748 `ch', respectively.)
|
|
|
1749
|
|
|
1750 (5) When coding a new type of operation, such as was discussed in
|
|
|
1751 previous section, the correct approach is to declare an worker
|
|
|
1752 function that does the work of everything, and is called by the
|
|
|
1753 other "container" macros that handle the different outside data
|
|
|
1754 forms. The data coming into the worker function, which
|
|
|
1755 typically ends in `_1', is in the form of three parameters:
|
|
|
1756 DATA, LEN, CHARLEN. (See point [3] about having two lengths and
|
|
|
1757 keeping them in sync.)
|
|
|
1758
|
|
|
1759 (6) Handling argument evaluation in macros: We take great care
|
|
|
1760 never to evaluate any argument more than once in any macro,
|
|
|
1761 except the initial Eistring parameter. This can and will be
|
|
|
1762 evaluated multiple times, but it should pretty much always just
|
|
|
1763 be a simple variable. This means, for example, that if an
|
|
|
1764 Eistring is the second (not first) argument of a macro, it
|
|
|
1765 doesn't fall under the "initial Eistring" exemption, so it
|
|
|
1766 needs protection against multi-evaluation. (Take the address of
|
|
|
1767 the Eistring structure, store in a temporary variable, and use
|
|
|
1768 temporary variable for all access to the Eistring.
|
|
|
1769 Essentially, we want it to appear as if these Eistring macros
|
|
|
1770 are functions -- we would like to declare them as functions but
|
|
851
|
1771 they use ALLOCA(), so we can't (and we can't make them inline
|
|
|
1772 functions either -- ALLOCA() is explicitly disallowed in inline
|
|
771
|
1773 functions.)
|
|
|
1774
|
|
|
1775 (7) Note that our rules regarding multiple evaluation are *more*
|
|
|
1776 strict than the rules listed above under the heading "working
|
|
|
1777 with raw internal-format data".
|
|
|
1778 */
|
|
|
1779
|
|
|
1780
|
|
|
1781 /* ----- Declaration ----- */
|
|
|
1782
|
|
|
1783 typedef struct
|
|
|
1784 {
|
|
|
1785 /* Data for the Eistring, stored in the default internal format.
|
|
|
1786 Always includes terminating null. */
|
|
|
1787 Intbyte *data_;
|
|
|
1788 /* Total number of bytes allocated in DATA (including null). */
|
|
|
1789 Bytecount max_size_allocated_;
|
|
|
1790 Bytecount bytelen_;
|
|
|
1791 Charcount charlen_;
|
|
|
1792 int mallocp_;
|
|
|
1793
|
|
|
1794 Extbyte *extdata_;
|
|
|
1795 Bytecount extlen_;
|
|
|
1796 } Eistring;
|
|
|
1797
|
|
|
1798 extern Eistring the_eistring_zero_init, the_eistring_malloc_zero_init;
|
|
|
1799
|
|
|
1800 #define DECLARE_EISTRING(name) \
|
|
|
1801 Eistring __ ## name ## __storage__ = the_eistring_zero_init; \
|
|
|
1802 Eistring *name = & __ ## name ## __storage__
|
|
|
1803 #define DECLARE_EISTRING_MALLOC(name) \
|
|
|
1804 Eistring __ ## name ## __storage__ = the_eistring_malloc_zero_init; \
|
|
|
1805 Eistring *name = & __ ## name ## __storage__
|
|
|
1806
|
|
|
1807 #define eiinit(ei) \
|
|
|
1808 do { \
|
|
793
|
1809 *(ei) = the_eistring_zero_init; \
|
|
771
|
1810 } while (0)
|
|
|
1811
|
|
|
1812 #define eiinit_malloc(ei) \
|
|
|
1813 do { \
|
|
793
|
1814 *(ei) = the_eistring_malloc_zero_init; \
|
|
771
|
1815 } while (0)
|
|
|
1816
|
|
|
1817
|
|
|
1818 /* ----- Utility ----- */
|
|
|
1819
|
|
|
1820 /* Make sure both LEN and CHARLEN are specified, in case one is given
|
|
|
1821 as -1. PTR evaluated at most once, others multiply. */
|
|
|
1822 #define eifixup_bytechar(ptr, len, charlen) \
|
|
|
1823 do { \
|
|
|
1824 if ((len) == -1) \
|
|
|
1825 (len) = charcount_to_bytecount (ptr, charlen); \
|
|
|
1826 else if ((charlen) == -1) \
|
|
|
1827 (charlen) = bytecount_to_charcount (ptr, len); \
|
|
|
1828 } while (0)
|
|
|
1829
|
|
|
1830 /* Make sure LEN is specified, in case it's is given as -1. PTR
|
|
|
1831 evaluated at most once, others multiply. */
|
|
|
1832 #define eifixup_byte(ptr, len, charlen) \
|
|
|
1833 do { \
|
|
|
1834 if ((len) == -1) \
|
|
|
1835 (len) = charcount_to_bytecount (ptr, charlen); \
|
|
|
1836 } while (0)
|
|
|
1837
|
|
|
1838 /* Make sure CHARLEN is specified, in case it's is given as -1. PTR
|
|
|
1839 evaluated at most once, others multiply. */
|
|
|
1840 #define eifixup_char(ptr, len, charlen) \
|
|
|
1841 do { \
|
|
|
1842 if ((charlen) == -1) \
|
|
|
1843 (charlen) = bytecount_to_charcount (ptr, len); \
|
|
|
1844 } while (0)
|
|
|
1845
|
|
|
1846
|
|
|
1847
|
|
|
1848 /* Make sure we can hold NEWBYTELEN bytes (which is NEWCHARLEN chars)
|
|
|
1849 plus a zero terminator. Preserve existing data as much as possible,
|
|
|
1850 including existing zero terminator. Put a new zero terminator where it
|
|
|
1851 should go if NEWZ if non-zero. All args but EI are evalled only once. */
|
|
|
1852
|
|
|
1853 #define EI_ALLOC(ei, newbytelen, newcharlen, newz) \
|
|
|
1854 do { \
|
|
|
1855 int ei1oldeibytelen = (ei)->bytelen_; \
|
|
|
1856 \
|
|
|
1857 (ei)->charlen_ = (newcharlen); \
|
|
|
1858 (ei)->bytelen_ = (newbytelen); \
|
|
|
1859 \
|
|
|
1860 if (ei1oldeibytelen != (ei)->bytelen_) \
|
|
|
1861 { \
|
|
|
1862 int ei1newsize = (ei)->max_size_allocated_; \
|
|
|
1863 while (ei1newsize < (ei)->bytelen_ + 1) \
|
|
|
1864 { \
|
|
|
1865 ei1newsize = (int) (ei1newsize * 1.5); \
|
|
|
1866 if (ei1newsize < 32) \
|
|
|
1867 ei1newsize = 32; \
|
|
|
1868 } \
|
|
|
1869 if (ei1newsize != (ei)->max_size_allocated_) \
|
|
|
1870 { \
|
|
|
1871 if ((ei)->mallocp_) \
|
|
|
1872 /* xrealloc always preserves existing data as much as possible */ \
|
|
|
1873 (ei)->data_ = (Intbyte *) xrealloc ((ei)->data_, ei1newsize); \
|
|
|
1874 else \
|
|
|
1875 { \
|
|
851
|
1876 /* We don't have realloc, so ALLOCA() more space and copy the \
|
|
771
|
1877 data into it. */ \
|
|
|
1878 Intbyte *ei1oldeidata = (ei)->data_; \
|
|
851
|
1879 (ei)->data_ = (Intbyte *) ALLOCA (ei1newsize); \
|
|
771
|
1880 if (ei1oldeidata) \
|
|
|
1881 memcpy ((ei)->data_, ei1oldeidata, ei1oldeibytelen + 1); \
|
|
|
1882 } \
|
|
|
1883 (ei)->max_size_allocated_ = ei1newsize; \
|
|
|
1884 } \
|
|
|
1885 if (newz) \
|
|
|
1886 (ei)->data_[(ei)->bytelen_] = '\0'; \
|
|
|
1887 } \
|
|
|
1888 } while (0)
|
|
|
1889
|
|
|
1890 #define EI_ALLOC_AND_COPY(ei, data, bytelen, charlen) \
|
|
|
1891 do { \
|
|
|
1892 EI_ALLOC (ei, bytelen, charlen, 1); \
|
|
|
1893 memcpy ((ei)->data_, data, (ei)->bytelen_); \
|
|
|
1894 } while (0)
|
|
|
1895
|
|
800
|
1896 #ifdef ERROR_CHECK_TEXT
|
|
771
|
1897 #define EI_ASSERT_ASCII(ptr, len) \
|
|
|
1898 do { \
|
|
|
1899 int ei5; \
|
|
|
1900 const Char_ASCII *ei5ptr = (ptr); \
|
|
|
1901 int ei5len = (len); \
|
|
|
1902 \
|
|
|
1903 for (ei5 = 0; ei5 < ei5len; ei5++) \
|
|
|
1904 assert (ei5ptr[ei5] >= 0x00 && ei5ptr[ei5] < 0x7F); \
|
|
|
1905 } while (0)
|
|
|
1906 #define EI_ASSERT_ASCIIZ(ptr) \
|
|
|
1907 do { \
|
|
|
1908 const Char_ASCII *ei5p1 = (ptr); \
|
|
|
1909 EI_ASSERT_ASCII (ei5p1, strlen (ei5p1)); \
|
|
|
1910 } while (0)
|
|
|
1911 #else
|
|
|
1912 #define EI_ASSERT_ASCII(ptr, len)
|
|
|
1913 #define EI_ASSERT_ASCIIZ(ptr)
|
|
|
1914 #endif
|
|
|
1915
|
|
|
1916
|
|
|
1917 /* ----- Initialization ----- */
|
|
|
1918
|
|
|
1919 #define eicpy_ei(ei, eicpy) \
|
|
|
1920 do { \
|
|
|
1921 const Eistring *ei2 = (eicpy); \
|
|
|
1922 EI_ALLOC_AND_COPY (ei, ei2->data_, ei2->bytelen_, ei2->charlen_); \
|
|
|
1923 } while (0)
|
|
|
1924
|
|
|
1925 #define eicpy_lstr(ei, lisp_string) \
|
|
|
1926 do { \
|
|
|
1927 Lisp_Object ei3 = (lisp_string); \
|
|
|
1928 EI_ALLOC_AND_COPY (ei, XSTRING_DATA (ei3), XSTRING_LENGTH (ei3), \
|
|
826
|
1929 string_char_length (ei3)); \
|
|
771
|
1930 } while (0)
|
|
|
1931
|
|
|
1932 #define eicpy_lstr_off(ei, lisp_string, off, charoff, len, charlen) \
|
|
|
1933 do { \
|
|
|
1934 Lisp_Object ei23lstr = (lisp_string); \
|
|
|
1935 int ei23off = (off); \
|
|
|
1936 int ei23charoff = (charoff); \
|
|
|
1937 int ei23len = (len); \
|
|
|
1938 int ei23charlen = (charlen); \
|
|
|
1939 const Intbyte *ei23data = XSTRING_DATA (ei23lstr); \
|
|
|
1940 \
|
|
|
1941 int ei23oldbytelen = (ei)->bytelen_; \
|
|
|
1942 \
|
|
|
1943 eifixup_byte (ei23data, ei23off, ei23charoff); \
|
|
|
1944 eifixup_bytechar (ei23data + ei23off, ei23len, ei23charlen); \
|
|
|
1945 \
|
|
|
1946 EI_ALLOC_AND_COPY (ei, ei23data + ei23off, ei23len, ei23charlen); \
|
|
|
1947 } while (0)
|
|
|
1948
|
|
826
|
1949 #define eicpy_raw_fmt(ei, ptr, len, fmt, object) \
|
|
771
|
1950 do { \
|
|
|
1951 const Intbyte *ei12ptr = (ptr); \
|
|
|
1952 Internal_Format ei12fmt = (fmt); \
|
|
|
1953 int ei12len = (len); \
|
|
|
1954 assert (ei12fmt == FORMAT_DEFAULT); \
|
|
|
1955 EI_ALLOC_AND_COPY (ei, ei12ptr, ei12len, \
|
|
|
1956 bytecount_to_charcount (ei12ptr, ei12len)); \
|
|
|
1957 } while (0)
|
|
|
1958
|
|
826
|
1959 #define eicpy_raw(ei, ptr, len) \
|
|
|
1960 eicpy_raw_fmt (ei, ptr, len, FORMAT_DEFAULT, Qnil)
|
|
|
1961
|
|
|
1962 #define eicpy_rawz_fmt(ei, ptr, fmt, object) \
|
|
|
1963 do { \
|
|
|
1964 const Intbyte *ei12p1ptr = (ptr); \
|
|
|
1965 Internal_Format ei12p1fmt = (fmt); \
|
|
|
1966 assert (ei12p1fmt == FORMAT_DEFAULT); \
|
|
|
1967 eicpy_raw_fmt (ei, ei12p1ptr, qxestrlen (ei12p1ptr), fmt, object); \
|
|
771
|
1968 } while (0)
|
|
|
1969
|
|
826
|
1970 #define eicpy_rawz(ei, ptr) eicpy_rawz_fmt (ei, ptr, FORMAT_DEFAULT, Qnil)
|
|
771
|
1971
|
|
|
1972 #define eicpy_ch(ei, ch) \
|
|
|
1973 do { \
|
|
|
1974 Intbyte ei12p2[MAX_EMCHAR_LEN]; \
|
|
|
1975 Bytecount ei12p2len = set_charptr_emchar (ei12p2, ch); \
|
|
|
1976 EI_ALLOC_AND_COPY (ei, ei12p2, ei12p2len, 1); \
|
|
|
1977 } while (0)
|
|
|
1978
|
|
|
1979 #define eicpy_c(ei, c_string) \
|
|
|
1980 do { \
|
|
|
1981 const Char_ASCII *ei4 = (c_string); \
|
|
|
1982 \
|
|
|
1983 EI_ASSERT_ASCIIZ (ei4); \
|
|
|
1984 eicpy_ext (ei, ei4, Qbinary); \
|
|
|
1985 } while (0)
|
|
|
1986
|
|
|
1987 #define eicpy_c_len(ei, c_string, c_len) \
|
|
|
1988 do { \
|
|
|
1989 const Char_ASCII *ei6 = (c_string); \
|
|
|
1990 int ei6len = (c_len); \
|
|
|
1991 \
|
|
|
1992 EI_ASSERT_ASCII (ei6, ei6len); \
|
|
|
1993 eicpy_ext_len (ei, ei6, ei6len, Qbinary); \
|
|
|
1994 } while (0)
|
|
|
1995
|
|
|
1996 #define eicpy_ext_len(ei, extdata, extlen, coding_system) \
|
|
|
1997 do { \
|
|
|
1998 const Extbyte *ei7 = (extdata); \
|
|
|
1999 int ei7len = (extlen); \
|
|
|
2000 \
|
|
|
2001 TO_INTERNAL_FORMAT (DATA, (ei7, ei7len), \
|
|
|
2002 ALLOCA, ((ei)->data_, (ei)->bytelen_), \
|
|
|
2003 coding_system); \
|
|
|
2004 (ei)->max_size_allocated_ = (ei)->bytelen_ + 1; \
|
|
|
2005 (ei)->charlen_ = bytecount_to_charcount ((ei)->data_, (ei)->bytelen_); \
|
|
|
2006 } while (0)
|
|
|
2007
|
|
|
2008 #define eicpy_ext(ei, extdata, coding_system) \
|
|
|
2009 do { \
|
|
|
2010 const Extbyte *ei8 = (extdata); \
|
|
|
2011 \
|
|
|
2012 eicpy_ext_len (ei, ei8, dfc_external_data_len (ei8, coding_system), \
|
|
|
2013 coding_system); \
|
|
|
2014 } while (0)
|
|
|
2015
|
|
|
2016 #define eicpy_lbuf(eistr, lisp_buf, off, charoff, len, charlen) \
|
|
|
2017 NOT YET IMPLEMENTED
|
|
|
2018
|
|
|
2019 #define eicpy_lstream(eistr, lstream) \
|
|
|
2020 NOT YET IMPLEMENTED
|
|
|
2021
|
|
|
2022 #define eireset(eistr) eicpy_rawz (eistr, (Intbyte *) "")
|
|
|
2023
|
|
|
2024 /* ----- Getting the data out of the Eistring ----- */
|
|
|
2025
|
|
|
2026 #define eidata(ei) ((ei)->data_)
|
|
|
2027
|
|
|
2028 #define eimake_string(ei) make_string (eidata (ei), eilen (ei))
|
|
|
2029
|
|
|
2030 #define eimake_string_off(eistr, off, charoff, len, charlen) \
|
|
|
2031 do { \
|
|
|
2032 Lisp_Object ei24lstr; \
|
|
|
2033 int ei24off = (off); \
|
|
|
2034 int ei24charoff = (charoff); \
|
|
|
2035 int ei24len = (len); \
|
|
|
2036 int ei24charlen = (charlen); \
|
|
|
2037 \
|
|
|
2038 eifixup_byte ((eistr)->data_, ei24off, ei24charoff); \
|
|
|
2039 eifixup_byte ((eistr)->data_ + ei24off, ei24len, ei24charlen); \
|
|
|
2040 \
|
|
|
2041 return make_string ((eistr)->data_ + ei24off, ei24len); \
|
|
|
2042 } while (0)
|
|
|
2043
|
|
|
2044 #define eicpyout_alloca(eistr, ptrout, lenout) \
|
|
826
|
2045 eicpyout_alloca_fmt (eistr, ptrout, lenout, FORMAT_DEFAULT, Qnil)
|
|
771
|
2046 #define eicpyout_malloc(eistr, lenout) \
|
|
826
|
2047 eicpyout_malloc_fmt (eistr, lenout, FORMAT_DEFAULT, Qnil)
|
|
771
|
2048 Intbyte *eicpyout_malloc_fmt (Eistring *eistr, Bytecount *len_out,
|
|
826
|
2049 Internal_Format fmt, Lisp_Object object);
|
|
|
2050 #define eicpyout_alloca_fmt(eistr, ptrout, lenout, fmt, object) \
|
|
771
|
2051 do { \
|
|
|
2052 Internal_Format ei23fmt = (fmt); \
|
|
|
2053 Intbyte *ei23ptrout = &(ptrout); \
|
|
|
2054 Bytecount *ei23lenout = &(lenout); \
|
|
|
2055 \
|
|
|
2056 assert (ei23fmt == FORMAT_DEFAULT); \
|
|
|
2057 \
|
|
|
2058 *ei23lenout = (eistr)->bytelen_; \
|
|
|
2059 *ei23ptrout = alloca_array (Intbyte, (eistr)->bytelen_ + 1); \
|
|
|
2060 memcpy (*ei23ptrout, (eistr)->data_, (eistr)->bytelen_ + 1); \
|
|
|
2061 } while (0)
|
|
|
2062
|
|
|
2063 /* ----- Moving to the heap ----- */
|
|
|
2064
|
|
|
2065 #define eifree(ei) \
|
|
|
2066 do { \
|
|
|
2067 if ((ei)->mallocp_) \
|
|
|
2068 { \
|
|
|
2069 if ((ei)->data_) \
|
|
|
2070 xfree ((ei)->data_); \
|
|
|
2071 if ((ei)->extdata_) \
|
|
|
2072 xfree ((ei)->extdata_); \
|
|
|
2073 eiinit_malloc (ei); \
|
|
|
2074 } \
|
|
|
2075 else \
|
|
|
2076 eiinit (ei); \
|
|
|
2077 } while (0)
|
|
|
2078
|
|
|
2079 int eifind_large_enough_buffer (int oldbufsize, int needed_size);
|
|
|
2080 void eito_malloc_1 (Eistring *ei);
|
|
|
2081
|
|
|
2082 #define eito_malloc(ei) eito_malloc_1 (ei)
|
|
|
2083
|
|
|
2084 #define eito_alloca(ei) \
|
|
|
2085 do { \
|
|
|
2086 if (!(ei)->mallocp_) \
|
|
|
2087 return; \
|
|
|
2088 (ei)->mallocp_ = 0; \
|
|
|
2089 if ((ei)->data_) \
|
|
|
2090 { \
|
|
|
2091 Intbyte *ei13newdata; \
|
|
|
2092 \
|
|
|
2093 (ei)->max_size_allocated_ = \
|
|
|
2094 eifind_large_enough_buffer (0, (ei)->bytelen_ + 1); \
|
|
851
|
2095 ei13newdata = (Intbyte *) ALLOCA ((ei)->max_size_allocated_); \
|
|
771
|
2096 memcpy (ei13newdata, (ei)->data_, (ei)->bytelen_ + 1); \
|
|
|
2097 xfree ((ei)->data_); \
|
|
|
2098 (ei)->data_ = ei13newdata; \
|
|
|
2099 } \
|
|
|
2100 \
|
|
|
2101 if ((ei)->extdata_) \
|
|
|
2102 { \
|
|
851
|
2103 Extbyte *ei13newdata = (Extbyte *) ALLOCA ((ei)->extlen_ + 2); \
|
|
771
|
2104 \
|
|
|
2105 memcpy (ei13newdata, (ei)->extdata_, (ei)->extlen_); \
|
|
|
2106 /* Double null-terminate in case of Unicode data */ \
|
|
|
2107 ei13newdata[(ei)->extlen_] = '\0'; \
|
|
|
2108 ei13newdata[(ei)->extlen_ + 1] = '\0'; \
|
|
|
2109 xfree ((ei)->extdata_); \
|
|
|
2110 (ei)->extdata_ = ei13newdata; \
|
|
|
2111 } \
|
|
|
2112 } while (0)
|
|
|
2113
|
|
|
2114
|
|
|
2115 /* ----- Retrieving the length ----- */
|
|
|
2116
|
|
|
2117 #define eilen(ei) ((ei)->bytelen_)
|
|
|
2118 #define eicharlen(ei) ((ei)->charlen_)
|
|
|
2119
|
|
|
2120
|
|
|
2121 /* ----- Working with positions ----- */
|
|
|
2122
|
|
|
2123 #define eicharpos_to_bytepos(ei, charpos) \
|
|
|
2124 charcount_to_bytecount ((ei)->data_, charpos)
|
|
|
2125 #define eibytepos_to_charpos(ei, bytepos) \
|
|
|
2126 bytecount_to_charcount ((ei)->data_, bytepos)
|
|
|
2127
|
|
|
2128 DECLARE_INLINE_HEADER (Bytecount eiincpos_1 (Eistring *eistr,
|
|
|
2129 Bytecount bytepos,
|
|
|
2130 Charcount n))
|
|
|
2131 {
|
|
|
2132 Intbyte *pos = eistr->data_ + bytepos;
|
|
814
|
2133 Charcount i;
|
|
771
|
2134
|
|
800
|
2135 text_checking_assert (bytepos >= 0 && bytepos <= eistr->bytelen_);
|
|
|
2136 text_checking_assert (n >= 0 && n <= eistr->charlen_);
|
|
771
|
2137 /* We could check N more correctly now, but that would require a
|
|
|
2138 call to bytecount_to_charcount(), which would be needlessly
|
|
|
2139 expensive (it would convert O(N) algorithms into O(N^2) algorithms
|
|
800
|
2140 with ERROR_CHECK_TEXT, which would be bad). If N is bad, we are
|
|
771
|
2141 guaranteed to catch it either inside INC_CHARPTR() or in the check
|
|
|
2142 below. */
|
|
|
2143 for (i = 0; i < n; i++)
|
|
|
2144 INC_CHARPTR (pos);
|
|
800
|
2145 text_checking_assert (pos - eistr->data_ <= eistr->bytelen_);
|
|
771
|
2146 return pos - eistr->data_;
|
|
|
2147 }
|
|
|
2148
|
|
|
2149 #define eiincpos (ei, bytepos) eiincpos_1 (ei, bytepos, 1)
|
|
|
2150 #define eiincpos_n (ei, bytepos, n) eiincpos_1 (ei, bytepos, n)
|
|
|
2151
|
|
|
2152 DECLARE_INLINE_HEADER (Bytecount eidecpos_1 (Eistring *eistr,
|
|
|
2153 Bytecount bytepos,
|
|
|
2154 Charcount n))
|
|
|
2155 {
|
|
|
2156 Intbyte *pos = eistr->data_ + bytepos;
|
|
|
2157 int i;
|
|
|
2158
|
|
800
|
2159 text_checking_assert (bytepos >= 0 && bytepos <= eistr->bytelen_);
|
|
|
2160 text_checking_assert (n >= 0 && n <= eistr->charlen_);
|
|
771
|
2161 /* We could check N more correctly now, but ... see above. */
|
|
|
2162 for (i = 0; i < n; i++)
|
|
|
2163 DEC_CHARPTR (pos);
|
|
800
|
2164 text_checking_assert (pos - eistr->data_ <= eistr->bytelen_);
|
|
771
|
2165 return pos - eistr->data_;
|
|
|
2166 }
|
|
|
2167
|
|
|
2168 #define eidecpos (ei, bytepos) eidecpos_1 (ei, bytepos, 1)
|
|
|
2169 #define eidecpos_n (ei, bytepos, n) eidecpos_1 (ei, bytepos, n)
|
|
|
2170
|
|
|
2171
|
|
|
2172 /* ----- Getting the character at a position ----- */
|
|
|
2173
|
|
|
2174 #define eigetch(ei, bytepos) \
|
|
|
2175 charptr_emchar ((ei)->data_ + (bytepos))
|
|
|
2176 #define eigetch_char(ei, charpos) charptr_emchar_n ((ei)->data_, charpos)
|
|
|
2177
|
|
|
2178
|
|
|
2179 /* ----- Setting the character at a position ----- */
|
|
|
2180
|
|
|
2181 #define eisetch(ei, bytepos, chr) \
|
|
|
2182 eisub_ch (ei, bytepos, -1, -1, 1, chr)
|
|
|
2183 #define eisetch_char(ei, charpos, chr) \
|
|
|
2184 eisub_ch (ei, -1, charpos, -1, 1, chr)
|
|
|
2185
|
|
|
2186
|
|
|
2187 /* ----- Concatenation ----- */
|
|
|
2188
|
|
|
2189 #define eicat_1(ei, data, bytelen, charlen) \
|
|
|
2190 do { \
|
|
|
2191 int ei14oldeibytelen = (ei)->bytelen_; \
|
|
|
2192 int ei14bytelen = (bytelen); \
|
|
|
2193 EI_ALLOC (ei, (ei)->bytelen_ + ei14bytelen, \
|
|
|
2194 (ei)->charlen_ + (charlen), 1); \
|
|
|
2195 memcpy ((ei)->data_ + ei14oldeibytelen, (data), \
|
|
|
2196 ei14bytelen); \
|
|
|
2197 } while (0)
|
|
|
2198
|
|
|
2199 #define eicat_ei(ei, ei2) \
|
|
|
2200 do { \
|
|
|
2201 const Eistring *ei9 = (ei2); \
|
|
|
2202 eicat_1 (ei, ei9->data_, ei9->bytelen_, ei9->charlen_); \
|
|
|
2203 } while (0)
|
|
|
2204
|
|
|
2205 #define eicat_c(ei, c_string) \
|
|
|
2206 do { \
|
|
|
2207 const Char_ASCII *ei15 = (c_string); \
|
|
|
2208 int ei15len = strlen (ei15); \
|
|
|
2209 \
|
|
|
2210 EI_ASSERT_ASCII (ei15, ei15len); \
|
|
|
2211 eicat_1 (ei, ei15, ei15len, \
|
|
|
2212 bytecount_to_charcount ((Intbyte *) ei15, ei15len)); \
|
|
|
2213 } while (0)
|
|
|
2214
|
|
|
2215 #define eicat_raw(ei, data, len) \
|
|
|
2216 do { \
|
|
|
2217 int ei16len = (len); \
|
|
|
2218 const Intbyte *ei16data = (data); \
|
|
|
2219 eicat_1 (ei, ei16data, ei16len, \
|
|
|
2220 bytecount_to_charcount (ei16data, ei16len)); \
|
|
|
2221 } while (0)
|
|
|
2222
|
|
|
2223 #define eicat_rawz(ei, ptr) \
|
|
|
2224 do { \
|
|
|
2225 const Intbyte *ei16p5ptr = (ptr); \
|
|
|
2226 eicat_raw (ei, ei16p5ptr, qxestrlen (ei16p5ptr)); \
|
|
|
2227 } while (0)
|
|
|
2228
|
|
|
2229 #define eicat_lstr(ei, lisp_string) \
|
|
|
2230 do { \
|
|
|
2231 Lisp_Object ei17 = (lisp_string); \
|
|
|
2232 eicat_1 (ei, XSTRING_DATA (ei17), XSTRING_LENGTH (ei17), \
|
|
826
|
2233 string_char_length (ei17)); \
|
|
771
|
2234 } while (0)
|
|
|
2235
|
|
|
2236 #define eicat_ch(ei, ch) \
|
|
|
2237 do { \
|
|
|
2238 Intbyte ei22ch[MAX_EMCHAR_LEN]; \
|
|
|
2239 Bytecount ei22len = set_charptr_emchar (ei22ch, ch); \
|
|
|
2240 eicat_1 (ei, ei22ch, ei22len, 1); \
|
|
|
2241 } while (0)
|
|
|
2242
|
|
|
2243
|
|
|
2244 /* ----- Replacement ----- */
|
|
|
2245
|
|
|
2246 /* Replace the section of an Eistring at (OFF, LEN) with the data at
|
|
|
2247 SRC of length LEN. All positions have corresponding character values,
|
|
|
2248 and either can be -1 -- it will be computed from the other. */
|
|
|
2249
|
|
|
2250 #define eisub_1(ei, off, charoff, len, charlen, src, srclen, srccharlen) \
|
|
|
2251 do { \
|
|
|
2252 int ei18off = (off); \
|
|
|
2253 int ei18charoff = (charoff); \
|
|
|
2254 int ei18len = (len); \
|
|
|
2255 int ei18charlen = (charlen); \
|
|
|
2256 Intbyte *ei18src = (Intbyte *) (src); \
|
|
|
2257 int ei18srclen = (srclen); \
|
|
|
2258 int ei18srccharlen = (srccharlen); \
|
|
|
2259 \
|
|
|
2260 int ei18oldeibytelen = (ei)->bytelen_; \
|
|
|
2261 \
|
|
|
2262 eifixup_bytechar ((ei)->data_, ei18off, ei18charoff); \
|
|
|
2263 eifixup_bytechar ((ei)->data_ + ei18off, ei18len, ei18charlen); \
|
|
|
2264 eifixup_bytechar (ei18src, ei18srclen, ei18srccharlen); \
|
|
|
2265 \
|
|
|
2266 EI_ALLOC (ei, (ei)->bytelen_ + ei18srclen - ei18len, \
|
|
|
2267 (ei)->charlen_ + ei18srccharlen - ei18charlen, 0); \
|
|
|
2268 if (ei18len != ei18srclen) \
|
|
|
2269 memmove ((ei)->data_ + ei18off + ei18srclen, \
|
|
|
2270 (ei)->data_ + ei18off + ei18len, \
|
|
|
2271 /* include zero terminator. */ \
|
|
|
2272 ei18oldeibytelen - (ei18off + ei18len) + 1); \
|
|
|
2273 if (ei18srclen > 0) \
|
|
|
2274 memcpy ((ei)->data_ + ei18off, ei18src, ei18srclen); \
|
|
|
2275 } while (0)
|
|
|
2276
|
|
|
2277 #define eisub_ei(ei, off, charoff, len, charlen, ei2) \
|
|
|
2278 do { \
|
|
|
2279 const Eistring *ei19 = (ei2); \
|
|
|
2280 eisub_1 (ei, off, charoff, len, charlen, ei19->data_, ei19->bytelen_, \
|
|
|
2281 ei19->charlen_); \
|
|
|
2282 } while (0)
|
|
|
2283
|
|
|
2284 #define eisub_c(ei, off, charoff, len, charlen, c_string) \
|
|
|
2285 do { \
|
|
|
2286 const Char_ASCII *ei20 = (c_string); \
|
|
|
2287 int ei20len = strlen (ei20); \
|
|
|
2288 EI_ASSERT_ASCII (ei20, ei20len); \
|
|
|
2289 eisub_1 (ei, off, charoff, len, charlen, ei20, ei20len, -1); \
|
|
|
2290 } while (0)
|
|
|
2291
|
|
|
2292 #define eisub_ch(ei, off, charoff, len, charlen, ch) \
|
|
|
2293 do { \
|
|
|
2294 Intbyte ei21ch[MAX_EMCHAR_LEN]; \
|
|
|
2295 Bytecount ei21len = set_charptr_emchar (ei21ch, ch); \
|
|
|
2296 eisub_1 (ei, off, charoff, len, charlen, ei21ch, ei21len, 1); \
|
|
|
2297 } while (0)
|
|
|
2298
|
|
|
2299 #define eidel(ei, off, charoff, len, charlen) \
|
|
|
2300 eisub_1(ei, off, charoff, len, charlen, NULL, 0, 0)
|
|
|
2301
|
|
|
2302
|
|
|
2303 /* ----- Converting to an external format ----- */
|
|
|
2304
|
|
|
2305 #define eito_external(ei, coding_system) \
|
|
|
2306 do { \
|
|
|
2307 if ((ei)->mallocp_) \
|
|
|
2308 { \
|
|
|
2309 if ((ei)->extdata_) \
|
|
|
2310 { \
|
|
|
2311 xfree ((ei)->extdata_); \
|
|
|
2312 (ei)->extdata_ = 0; \
|
|
|
2313 } \
|
|
|
2314 TO_EXTERNAL_FORMAT (DATA, ((ei)->data_, (ei)->bytelen_), \
|
|
|
2315 MALLOC, ((ei)->extdata_, (ei)->extlen_), \
|
|
|
2316 coding_system); \
|
|
|
2317 } \
|
|
|
2318 else \
|
|
|
2319 TO_EXTERNAL_FORMAT (DATA, ((ei)->data_, (ei)->bytelen_), \
|
|
|
2320 ALLOCA, ((ei)->extdata_, (ei)->extlen_), \
|
|
|
2321 coding_system); \
|
|
|
2322 } while (0)
|
|
|
2323
|
|
|
2324 #define eiextdata(ei) ((ei)->extdata_)
|
|
|
2325 #define eiextlen(ei) ((ei)->extlen_)
|
|
|
2326
|
|
|
2327
|
|
|
2328 /* ----- Searching in the Eistring for a character ----- */
|
|
|
2329
|
|
|
2330 #define eichr(eistr, chr) \
|
|
|
2331 NOT YET IMPLEMENTED
|
|
|
2332 #define eichr_char(eistr, chr) \
|
|
|
2333 NOT YET IMPLEMENTED
|
|
|
2334 #define eichr_off(eistr, chr, off, charoff) \
|
|
|
2335 NOT YET IMPLEMENTED
|
|
|
2336 #define eichr_off_char(eistr, chr, off, charoff) \
|
|
|
2337 NOT YET IMPLEMENTED
|
|
|
2338 #define eirchr(eistr, chr) \
|
|
|
2339 NOT YET IMPLEMENTED
|
|
|
2340 #define eirchr_char(eistr, chr) \
|
|
|
2341 NOT YET IMPLEMENTED
|
|
|
2342 #define eirchr_off(eistr, chr, off, charoff) \
|
|
|
2343 NOT YET IMPLEMENTED
|
|
|
2344 #define eirchr_off_char(eistr, chr, off, charoff) \
|
|
|
2345 NOT YET IMPLEMENTED
|
|
|
2346
|
|
|
2347
|
|
|
2348 /* ----- Searching in the Eistring for a string ----- */
|
|
|
2349
|
|
|
2350 #define eistr_ei(eistr, eistr2) \
|
|
|
2351 NOT YET IMPLEMENTED
|
|
|
2352 #define eistr_ei_char(eistr, eistr2) \
|
|
|
2353 NOT YET IMPLEMENTED
|
|
|
2354 #define eistr_ei_off(eistr, eistr2, off, charoff) \
|
|
|
2355 NOT YET IMPLEMENTED
|
|
|
2356 #define eistr_ei_off_char(eistr, eistr2, off, charoff) \
|
|
|
2357 NOT YET IMPLEMENTED
|
|
|
2358 #define eirstr_ei(eistr, eistr2) \
|
|
|
2359 NOT YET IMPLEMENTED
|
|
|
2360 #define eirstr_ei_char(eistr, eistr2) \
|
|
|
2361 NOT YET IMPLEMENTED
|
|
|
2362 #define eirstr_ei_off(eistr, eistr2, off, charoff) \
|
|
|
2363 NOT YET IMPLEMENTED
|
|
|
2364 #define eirstr_ei_off_char(eistr, eistr2, off, charoff) \
|
|
|
2365 NOT YET IMPLEMENTED
|
|
|
2366
|
|
|
2367 #define eistr_c(eistr, c_string) \
|
|
|
2368 NOT YET IMPLEMENTED
|
|
|
2369 #define eistr_c_char(eistr, c_string) \
|
|
|
2370 NOT YET IMPLEMENTED
|
|
|
2371 #define eistr_c_off(eistr, c_string, off, charoff) \
|
|
|
2372 NOT YET IMPLEMENTED
|
|
|
2373 #define eistr_c_off_char(eistr, c_string, off, charoff) \
|
|
|
2374 NOT YET IMPLEMENTED
|
|
|
2375 #define eirstr_c(eistr, c_string) \
|
|
|
2376 NOT YET IMPLEMENTED
|
|
|
2377 #define eirstr_c_char(eistr, c_string) \
|
|
|
2378 NOT YET IMPLEMENTED
|
|
|
2379 #define eirstr_c_off(eistr, c_string, off, charoff) \
|
|
|
2380 NOT YET IMPLEMENTED
|
|
|
2381 #define eirstr_c_off_char(eistr, c_string, off, charoff) \
|
|
|
2382 NOT YET IMPLEMENTED
|
|
|
2383
|
|
|
2384
|
|
|
2385 /* ----- Comparison ----- */
|
|
|
2386
|
|
|
2387 int eicmp_1 (Eistring *ei, Bytecount off, Charcount charoff,
|
|
|
2388 Bytecount len, Charcount charlen, const Intbyte *data,
|
|
|
2389 const Eistring *ei2, int is_c, int fold_case);
|
|
|
2390
|
|
|
2391 #define eicmp_ei(eistr, eistr2) \
|
|
|
2392 eicmp_1 (eistr, 0, -1, -1, -1, 0, eistr2, 0, 0)
|
|
|
2393 #define eicmp_off_ei(eistr, off, charoff, len, charlen, eistr2) \
|
|
|
2394 eicmp_1 (eistr, off, charoff, len, charlen, 0, eistr2, 0, 0)
|
|
|
2395 #define eicasecmp_ei(eistr, eistr2) \
|
|
|
2396 eicmp_1 (eistr, 0, -1, -1, -1, 0, eistr2, 0, 1)
|
|
|
2397 #define eicasecmp_off_ei(eistr, off, charoff, len, charlen, eistr2) \
|
|
|
2398 eicmp_1 (eistr, off, charoff, len, charlen, 0, eistr2, 0, 1)
|
|
|
2399 #define eicasecmp_i18n_ei(eistr, eistr2) \
|
|
|
2400 eicmp_1 (eistr, 0, -1, -1, -1, 0, eistr2, 0, 2)
|
|
|
2401 #define eicasecmp_i18n_off_ei(eistr, off, charoff, len, charlen, eistr2) \
|
|
|
2402 eicmp_1 (eistr, off, charoff, len, charlen, 0, eistr2, 0, 2)
|
|
|
2403
|
|
|
2404 #define eicmp_c(eistr, c_string) \
|
|
|
2405 eicmp_1 (eistr, 0, -1, -1, -1, c_string, 0, 1, 0)
|
|
|
2406 #define eicmp_off_c(eistr, off, charoff, len, charlen, c_string) \
|
|
|
2407 eicmp_1 (eistr, off, charoff, len, charlen, c_string, 0, 1, 0)
|
|
|
2408 #define eicasecmp_c(eistr, c_string) \
|
|
|
2409 eicmp_1 (eistr, 0, -1, -1, -1, c_string, 0, 1, 1)
|
|
|
2410 #define eicasecmp_off_c(eistr, off, charoff, len, charlen, c_string) \
|
|
|
2411 eicmp_1 (eistr, off, charoff, len, charlen, c_string, 0, 1, 1)
|
|
|
2412 #define eicasecmp_i18n_c(eistr, c_string) \
|
|
|
2413 eicmp_1 (eistr, 0, -1, -1, -1, c_string, 0, 1, 2)
|
|
|
2414 #define eicasecmp_i18n_off_c(eistr, off, charoff, len, charlen, c_string) \
|
|
|
2415 eicmp_1 (eistr, off, charoff, len, charlen, c_string, 0, 1, 2)
|
|
|
2416
|
|
|
2417
|
|
|
2418 /* ----- Case-changing the Eistring ----- */
|
|
|
2419
|
|
|
2420 int eistr_casefiddle_1 (Intbyte *olddata, Bytecount len, Intbyte *newdata,
|
|
|
2421 int downp);
|
|
|
2422
|
|
|
2423 #define EI_CASECHANGE(ei, downp) \
|
|
|
2424 do { \
|
|
|
2425 int ei11new_allocmax = (ei)->charlen_ * MAX_EMCHAR_LEN + 1; \
|
|
851
|
2426 Intbyte *ei11storage = \
|
|
|
2427 (Intbyte *) alloca_array (Intbyte, ei11new_allocmax); \
|
|
771
|
2428 int ei11newlen = eistr_casefiddle_1 ((ei)->data_, (ei)->bytelen_, \
|
|
|
2429 ei11storage, downp); \
|
|
|
2430 \
|
|
|
2431 if (ei11newlen) \
|
|
|
2432 { \
|
|
|
2433 (ei)->max_size_allocated_ = ei11new_allocmax; \
|
|
|
2434 (ei)->data_ = ei11storage; \
|
|
|
2435 (ei)->bytelen_ = ei11newlen; \
|
|
|
2436 /* charlen is the same. */ \
|
|
|
2437 } \
|
|
|
2438 } while (0)
|
|
|
2439
|
|
|
2440 #define eilwr(ei) EI_CASECHANGE (ei, 1)
|
|
|
2441 #define eiupr(ei) EI_CASECHANGE (ei, 0)
|
|
|
2442
|
|
|
2443
|
|
|
2444 /************************************************************************/
|
|
|
2445 /* */
|
|
|
2446 /* Converting between internal and external format */
|
|
|
2447 /* */
|
|
|
2448 /************************************************************************/
|
|
|
2449 /*
|
|
|
2450 All client code should use only the two macros
|
|
|
2451
|
|
|
2452 TO_EXTERNAL_FORMAT (source_type, source, sink_type, sink, coding_system)
|
|
|
2453 TO_INTERNAL_FORMAT (source_type, source, sink_type, sink, coding_system)
|
|
|
2454
|
|
|
2455 Typical use is
|
|
|
2456
|
|
|
2457 TO_EXTERNAL_FORMAT (DATA, (ptr, len),
|
|
|
2458 LISP_BUFFER, buffer,
|
|
|
2459 Qfile_name);
|
|
|
2460
|
|
|
2461 NOTE: GC is inhibited during the entire operation of these macros. This
|
|
|
2462 is because frequently the data to be converted comes from strings but
|
|
|
2463 gets passed in as just DATA, and GC may move around the string data. If
|
|
|
2464 we didn't inhibit GC, there'd have to be a lot of messy recoding,
|
|
|
2465 alloca-copying of strings and other annoying stuff.
|
|
|
2466
|
|
|
2467 The source or sink can be specified in one of these ways:
|
|
|
2468
|
|
|
2469 DATA, (ptr, len), // input data is a fixed buffer of size len
|
|
851
|
2470 ALLOCA, (ptr, len), // output data is in a ALLOCA()ed buffer of size len
|
|
771
|
2471 MALLOC, (ptr, len), // output data is in a malloc()ed buffer of size len
|
|
|
2472 C_STRING_ALLOCA, ptr, // equivalent to ALLOCA (ptr, len_ignored) on output
|
|
|
2473 C_STRING_MALLOC, ptr, // equivalent to MALLOC (ptr, len_ignored) on output
|
|
|
2474 C_STRING, ptr, // equivalent to DATA, (ptr, strlen/wcslen (ptr))
|
|
|
2475 // on input (the Unicode version is used when correct)
|
|
|
2476 LISP_STRING, string, // input or output is a Lisp_Object of type string
|
|
|
2477 LISP_BUFFER, buffer, // output is written to (point) in lisp buffer
|
|
|
2478 LISP_LSTREAM, lstream, // input or output is a Lisp_Object of type lstream
|
|
|
2479 LISP_OPAQUE, object, // input or output is a Lisp_Object of type opaque
|
|
|
2480
|
|
|
2481 When specifying the sink, use lvalues, since the macro will assign to them,
|
|
|
2482 except when the sink is an lstream or a lisp buffer.
|
|
|
2483
|
|
|
2484 The macros accept the kinds of sources and sinks appropriate for
|
|
|
2485 internal and external data representation. See the type_checking_assert
|
|
|
2486 macros below for the actual allowed types.
|
|
|
2487
|
|
|
2488 Since some sources and sinks use one argument (a Lisp_Object) to
|
|
|
2489 specify them, while others take a (pointer, length) pair, we use
|
|
|
2490 some C preprocessor trickery to allow pair arguments to be specified
|
|
|
2491 by parenthesizing them, as in the examples above.
|
|
|
2492
|
|
|
2493 Anything prefixed by dfc_ (`data format conversion') is private.
|
|
|
2494 They are only used to implement these macros.
|
|
|
2495
|
|
|
2496 [[Using C_STRING* is appropriate for using with external APIs that
|
|
|
2497 take null-terminated strings. For internal data, we should try to
|
|
|
2498 be '\0'-clean - i.e. allow arbitrary data to contain embedded '\0'.
|
|
|
2499
|
|
|
2500 Sometime in the future we might allow output to C_STRING_ALLOCA or
|
|
|
2501 C_STRING_MALLOC _only_ with TO_EXTERNAL_FORMAT(), not
|
|
|
2502 TO_INTERNAL_FORMAT().]]
|
|
|
2503
|
|
|
2504 The above comments are not true. Frequently (most of the time, in
|
|
|
2505 fact), external strings come as zero-terminated entities, where the
|
|
|
2506 zero-termination is the only way to find out the length. Even in
|
|
|
2507 cases where you can get the length, most of the time the system will
|
|
|
2508 still use the null to signal the end of the string, and there will
|
|
|
2509 still be no way to either send in or receive a string with embedded
|
|
|
2510 nulls. In such situations, it's pointless to track the length
|
|
|
2511 because null bytes can never be in the string. We have a lot of
|
|
|
2512 operations that make it easy to operate on zero-terminated strings,
|
|
|
2513 and forcing the user the deal with the length everywhere would only
|
|
|
2514 make the code uglier and more complicated, for no gain. --ben
|
|
|
2515
|
|
|
2516 There is no problem using the same lvalue for source and sink.
|
|
|
2517
|
|
|
2518 Also, when pointers are required, the code (currently at least) is
|
|
|
2519 lax and allows any pointer types, either in the source or the sink.
|
|
|
2520 This makes it possible, e.g., to deal with internal format data held
|
|
|
2521 in char *'s or external format data held in WCHAR * (i.e. Unicode).
|
|
|
2522
|
|
|
2523 Finally, whenever storage allocation is called for, extra space is
|
|
|
2524 allocated for a terminating zero, and such a zero is stored in the
|
|
|
2525 appropriate place, regardless of whether the source data was
|
|
|
2526 specified using a length or was specified as zero-terminated. This
|
|
|
2527 allows you to freely pass the resulting data, no matter how
|
|
|
2528 obtained, to a routine that expects zero termination (modulo, of
|
|
|
2529 course, that any embedded zeros in the resulting text will cause
|
|
|
2530 truncation). In fact, currently two embedded zeros are allocated
|
|
|
2531 and stored after the data result. This is to allow for the
|
|
|
2532 possibility of storing a Unicode value on output, which needs the
|
|
|
2533 two zeros. Currently, however, the two zeros are stored regardless
|
|
|
2534 of whether the conversion is internal or external and regardless of
|
|
|
2535 whether the external coding system is in fact Unicode. This
|
|
|
2536 behavior may change in the future, and you cannot rely on this --
|
|
|
2537 the most you can rely on is that sink data in Unicode format will
|
|
|
2538 have two terminating nulls, which combine to form one Unicode null
|
|
|
2539 character. */
|
|
|
2540
|
|
|
2541 #define TO_EXTERNAL_FORMAT(source_type, source, sink_type, sink, codesys) \
|
|
|
2542 do { \
|
|
|
2543 dfc_conversion_type dfc_simplified_source_type; \
|
|
|
2544 dfc_conversion_type dfc_simplified_sink_type; \
|
|
|
2545 dfc_conversion_data dfc_source; \
|
|
|
2546 dfc_conversion_data dfc_sink; \
|
|
|
2547 Lisp_Object dfc_codesys = (codesys); \
|
|
|
2548 \
|
|
|
2549 type_checking_assert \
|
|
|
2550 ((DFC_TYPE_##source_type == DFC_TYPE_DATA || \
|
|
|
2551 DFC_TYPE_##source_type == DFC_TYPE_C_STRING || \
|
|
|
2552 DFC_TYPE_##source_type == DFC_TYPE_LISP_STRING || \
|
|
|
2553 DFC_TYPE_##source_type == DFC_TYPE_LISP_OPAQUE || \
|
|
|
2554 DFC_TYPE_##source_type == DFC_TYPE_LISP_LSTREAM) \
|
|
|
2555 && \
|
|
|
2556 (DFC_TYPE_##sink_type == DFC_TYPE_ALLOCA || \
|
|
|
2557 DFC_TYPE_##sink_type == DFC_TYPE_MALLOC || \
|
|
|
2558 DFC_TYPE_##sink_type == DFC_TYPE_C_STRING_ALLOCA || \
|
|
|
2559 DFC_TYPE_##sink_type == DFC_TYPE_C_STRING_MALLOC || \
|
|
|
2560 DFC_TYPE_##sink_type == DFC_TYPE_LISP_LSTREAM || \
|
|
|
2561 DFC_TYPE_##sink_type == DFC_TYPE_LISP_OPAQUE)); \
|
|
|
2562 \
|
|
|
2563 DFC_EXT_SOURCE_##source_type##_TO_ARGS (source, dfc_codesys); \
|
|
|
2564 DFC_SINK_##sink_type##_TO_ARGS (sink); \
|
|
|
2565 \
|
|
|
2566 dfc_convert_to_external_format (dfc_simplified_source_type, &dfc_source, \
|
|
|
2567 dfc_codesys, \
|
|
|
2568 dfc_simplified_sink_type, &dfc_sink); \
|
|
|
2569 \
|
|
|
2570 DFC_##sink_type##_USE_CONVERTED_DATA (sink); \
|
|
|
2571 } while (0)
|
|
|
2572
|
|
|
2573 #define TO_INTERNAL_FORMAT(source_type, source, sink_type, sink, codesys) \
|
|
|
2574 do { \
|
|
|
2575 dfc_conversion_type dfc_simplified_source_type; \
|
|
|
2576 dfc_conversion_type dfc_simplified_sink_type; \
|
|
|
2577 dfc_conversion_data dfc_source; \
|
|
|
2578 dfc_conversion_data dfc_sink; \
|
|
|
2579 Lisp_Object dfc_codesys = (codesys); \
|
|
|
2580 \
|
|
|
2581 type_checking_assert \
|
|
|
2582 ((DFC_TYPE_##source_type == DFC_TYPE_DATA || \
|
|
|
2583 DFC_TYPE_##source_type == DFC_TYPE_C_STRING || \
|
|
|
2584 DFC_TYPE_##source_type == DFC_TYPE_LISP_OPAQUE || \
|
|
|
2585 DFC_TYPE_##source_type == DFC_TYPE_LISP_LSTREAM) \
|
|
|
2586 && \
|
|
|
2587 (DFC_TYPE_##sink_type == DFC_TYPE_ALLOCA || \
|
|
|
2588 DFC_TYPE_##sink_type == DFC_TYPE_MALLOC || \
|
|
|
2589 DFC_TYPE_##sink_type == DFC_TYPE_C_STRING_ALLOCA || \
|
|
|
2590 DFC_TYPE_##sink_type == DFC_TYPE_C_STRING_MALLOC || \
|
|
|
2591 DFC_TYPE_##sink_type == DFC_TYPE_LISP_STRING || \
|
|
|
2592 DFC_TYPE_##sink_type == DFC_TYPE_LISP_LSTREAM || \
|
|
|
2593 DFC_TYPE_##sink_type == DFC_TYPE_LISP_BUFFER)); \
|
|
|
2594 \
|
|
|
2595 DFC_INT_SOURCE_##source_type##_TO_ARGS (source, dfc_codesys); \
|
|
|
2596 DFC_SINK_##sink_type##_TO_ARGS (sink); \
|
|
|
2597 \
|
|
|
2598 dfc_convert_to_internal_format (dfc_simplified_source_type, &dfc_source, \
|
|
|
2599 dfc_codesys, \
|
|
|
2600 dfc_simplified_sink_type, &dfc_sink); \
|
|
|
2601 \
|
|
|
2602 DFC_##sink_type##_USE_CONVERTED_DATA (sink); \
|
|
|
2603 } while (0)
|
|
|
2604
|
|
814
|
2605 #ifdef __cplusplus
|
|
771
|
2606
|
|
814
|
2607 /* Error if you try to use a union here: "member `struct {anonymous
|
|
|
2608 union}::{anonymous} {anonymous union}::data' with constructor not allowed
|
|
|
2609 in union" (Bytecount is a class) */
|
|
|
2610
|
|
|
2611 typedef struct
|
|
|
2612 #else
|
|
771
|
2613 typedef union
|
|
814
|
2614 #endif
|
|
771
|
2615 {
|
|
|
2616 struct { const void *ptr; Bytecount len; } data;
|
|
|
2617 Lisp_Object lisp_object;
|
|
|
2618 } dfc_conversion_data;
|
|
|
2619
|
|
|
2620 enum dfc_conversion_type
|
|
|
2621 {
|
|
|
2622 DFC_TYPE_DATA,
|
|
|
2623 DFC_TYPE_ALLOCA,
|
|
|
2624 DFC_TYPE_MALLOC,
|
|
|
2625 DFC_TYPE_C_STRING,
|
|
|
2626 DFC_TYPE_C_STRING_ALLOCA,
|
|
|
2627 DFC_TYPE_C_STRING_MALLOC,
|
|
|
2628 DFC_TYPE_LISP_STRING,
|
|
|
2629 DFC_TYPE_LISP_LSTREAM,
|
|
|
2630 DFC_TYPE_LISP_OPAQUE,
|
|
|
2631 DFC_TYPE_LISP_BUFFER
|
|
|
2632 };
|
|
|
2633 typedef enum dfc_conversion_type dfc_conversion_type;
|
|
|
2634
|
|
|
2635 /* WARNING: These use a static buffer. This can lead to disaster if
|
|
|
2636 these functions are not used *very* carefully. Another reason to only use
|
|
|
2637 TO_EXTERNAL_FORMAT() and TO_INTERNAL_FORMAT(). */
|
|
|
2638 void
|
|
|
2639 dfc_convert_to_external_format (dfc_conversion_type source_type,
|
|
|
2640 dfc_conversion_data *source,
|
|
|
2641 Lisp_Object coding_system,
|
|
|
2642 dfc_conversion_type sink_type,
|
|
|
2643 dfc_conversion_data *sink);
|
|
|
2644 void
|
|
|
2645 dfc_convert_to_internal_format (dfc_conversion_type source_type,
|
|
|
2646 dfc_conversion_data *source,
|
|
|
2647 Lisp_Object coding_system,
|
|
|
2648 dfc_conversion_type sink_type,
|
|
|
2649 dfc_conversion_data *sink);
|
|
|
2650 /* CPP Trickery */
|
|
|
2651 #define DFC_CPP_CAR(x,y) (x)
|
|
|
2652 #define DFC_CPP_CDR(x,y) (y)
|
|
|
2653
|
|
|
2654 /* Convert `source' to args for dfc_convert_to_external_format() */
|
|
|
2655 #define DFC_EXT_SOURCE_DATA_TO_ARGS(val, codesys) do { \
|
|
|
2656 dfc_source.data.ptr = DFC_CPP_CAR val; \
|
|
|
2657 dfc_source.data.len = DFC_CPP_CDR val; \
|
|
|
2658 dfc_simplified_source_type = DFC_TYPE_DATA; \
|
|
|
2659 } while (0)
|
|
|
2660 #define DFC_EXT_SOURCE_C_STRING_TO_ARGS(val, codesys) do { \
|
|
|
2661 dfc_source.data.len = \
|
|
|
2662 strlen ((char *) (dfc_source.data.ptr = (val))); \
|
|
|
2663 dfc_simplified_source_type = DFC_TYPE_DATA; \
|
|
|
2664 } while (0)
|
|
|
2665 #define DFC_EXT_SOURCE_LISP_STRING_TO_ARGS(val, codesys) do { \
|
|
|
2666 Lisp_Object dfc_slsta = (val); \
|
|
|
2667 type_checking_assert (STRINGP (dfc_slsta)); \
|
|
|
2668 dfc_source.lisp_object = dfc_slsta; \
|
|
|
2669 dfc_simplified_source_type = DFC_TYPE_LISP_STRING; \
|
|
|
2670 } while (0)
|
|
|
2671 #define DFC_EXT_SOURCE_LISP_LSTREAM_TO_ARGS(val, codesys) do { \
|
|
|
2672 Lisp_Object dfc_sllta = (val); \
|
|
|
2673 type_checking_assert (LSTREAMP (dfc_sllta)); \
|
|
|
2674 dfc_source.lisp_object = dfc_sllta; \
|
|
|
2675 dfc_simplified_source_type = DFC_TYPE_LISP_LSTREAM; \
|
|
|
2676 } while (0)
|
|
|
2677 #define DFC_EXT_SOURCE_LISP_OPAQUE_TO_ARGS(val, codesys) do { \
|
|
|
2678 Lisp_Opaque *dfc_slota = XOPAQUE (val); \
|
|
|
2679 dfc_source.data.ptr = OPAQUE_DATA (dfc_slota); \
|
|
|
2680 dfc_source.data.len = OPAQUE_SIZE (dfc_slota); \
|
|
|
2681 dfc_simplified_source_type = DFC_TYPE_DATA; \
|
|
|
2682 } while (0)
|
|
|
2683
|
|
|
2684 /* Convert `source' to args for dfc_convert_to_internal_format() */
|
|
|
2685 #define DFC_INT_SOURCE_DATA_TO_ARGS(val, codesys) \
|
|
|
2686 DFC_EXT_SOURCE_DATA_TO_ARGS (val, codesys)
|
|
|
2687 #define DFC_INT_SOURCE_C_STRING_TO_ARGS(val, codesys) do { \
|
|
|
2688 dfc_source.data.len = dfc_external_data_len (dfc_source.data.ptr = (val), \
|
|
|
2689 codesys); \
|
|
|
2690 dfc_simplified_source_type = DFC_TYPE_DATA; \
|
|
|
2691 } while (0)
|
|
|
2692 #define DFC_INT_SOURCE_LISP_STRING_TO_ARGS(val, codesys) \
|
|
|
2693 DFC_EXT_SOURCE_LISP_STRING_TO_ARGS (val, codesys)
|
|
|
2694 #define DFC_INT_SOURCE_LISP_LSTREAM_TO_ARGS(val, codesys) \
|
|
|
2695 DFC_EXT_SOURCE_LISP_LSTREAM_TO_ARGS (val, codesys)
|
|
|
2696 #define DFC_INT_SOURCE_LISP_OPAQUE_TO_ARGS(val, codesys) \
|
|
|
2697 DFC_EXT_SOURCE_LISP_OPAQUE_TO_ARGS (val, codesys)
|
|
|
2698
|
|
|
2699 /* Convert `sink' to args for dfc_convert_to_*_format() */
|
|
|
2700 #define DFC_SINK_ALLOCA_TO_ARGS(val) \
|
|
|
2701 dfc_simplified_sink_type = DFC_TYPE_DATA
|
|
|
2702 #define DFC_SINK_C_STRING_ALLOCA_TO_ARGS(val) \
|
|
|
2703 dfc_simplified_sink_type = DFC_TYPE_DATA
|
|
|
2704 #define DFC_SINK_MALLOC_TO_ARGS(val) \
|
|
|
2705 dfc_simplified_sink_type = DFC_TYPE_DATA
|
|
|
2706 #define DFC_SINK_C_STRING_MALLOC_TO_ARGS(val) \
|
|
|
2707 dfc_simplified_sink_type = DFC_TYPE_DATA
|
|
|
2708 #define DFC_SINK_LISP_STRING_TO_ARGS(val) \
|
|
|
2709 dfc_simplified_sink_type = DFC_TYPE_DATA
|
|
|
2710 #define DFC_SINK_LISP_OPAQUE_TO_ARGS(val) \
|
|
|
2711 dfc_simplified_sink_type = DFC_TYPE_DATA
|
|
|
2712 #define DFC_SINK_LISP_LSTREAM_TO_ARGS(val) do { \
|
|
|
2713 Lisp_Object dfc_sllta = (val); \
|
|
|
2714 type_checking_assert (LSTREAMP (dfc_sllta)); \
|
|
|
2715 dfc_sink.lisp_object = dfc_sllta; \
|
|
|
2716 dfc_simplified_sink_type = DFC_TYPE_LISP_LSTREAM; \
|
|
|
2717 } while (0)
|
|
|
2718 #define DFC_SINK_LISP_BUFFER_TO_ARGS(val) do { \
|
|
|
2719 struct buffer *dfc_slbta = XBUFFER (val); \
|
|
|
2720 dfc_sink.lisp_object = \
|
|
|
2721 make_lisp_buffer_output_stream \
|
|
|
2722 (dfc_slbta, BUF_PT (dfc_slbta), 0); \
|
|
|
2723 dfc_simplified_sink_type = DFC_TYPE_LISP_LSTREAM; \
|
|
|
2724 } while (0)
|
|
|
2725
|
|
|
2726 /* Assign to the `sink' lvalue(s) using the converted data. */
|
|
|
2727 /* + 2 because we double zero-extended to account for Unicode conversion */
|
|
|
2728 typedef union { char c; void *p; } *dfc_aliasing_voidpp;
|
|
|
2729 #define DFC_ALLOCA_USE_CONVERTED_DATA(sink) do { \
|
|
851
|
2730 void * dfc_sink_ret = ALLOCA (dfc_sink.data.len + 2); \
|
|
771
|
2731 memcpy (dfc_sink_ret, dfc_sink.data.ptr, dfc_sink.data.len + 2); \
|
|
|
2732 ((dfc_aliasing_voidpp) &(DFC_CPP_CAR sink))->p = dfc_sink_ret; \
|
|
|
2733 (DFC_CPP_CDR sink) = dfc_sink.data.len; \
|
|
|
2734 } while (0)
|
|
|
2735 #define DFC_MALLOC_USE_CONVERTED_DATA(sink) do { \
|
|
|
2736 void * dfc_sink_ret = xmalloc (dfc_sink.data.len + 2); \
|
|
|
2737 memcpy (dfc_sink_ret, dfc_sink.data.ptr, dfc_sink.data.len + 2); \
|
|
|
2738 ((dfc_aliasing_voidpp) &(DFC_CPP_CAR sink))->p = dfc_sink_ret; \
|
|
|
2739 (DFC_CPP_CDR sink) = dfc_sink.data.len; \
|
|
|
2740 } while (0)
|
|
|
2741 #define DFC_C_STRING_ALLOCA_USE_CONVERTED_DATA(sink) do { \
|
|
851
|
2742 void * dfc_sink_ret = ALLOCA (dfc_sink.data.len + 2); \
|
|
771
|
2743 memcpy (dfc_sink_ret, dfc_sink.data.ptr, dfc_sink.data.len + 2); \
|
|
|
2744 ((dfc_aliasing_voidpp) &(sink))->p = dfc_sink_ret; \
|
|
|
2745 } while (0)
|
|
|
2746 #define DFC_C_STRING_MALLOC_USE_CONVERTED_DATA(sink) do { \
|
|
|
2747 void * dfc_sink_ret = xmalloc (dfc_sink.data.len + 2); \
|
|
|
2748 memcpy (dfc_sink_ret, dfc_sink.data.ptr, dfc_sink.data.len + 2); \
|
|
|
2749 ((dfc_aliasing_voidpp) &(sink))->p = dfc_sink_ret; \
|
|
|
2750 } while (0)
|
|
|
2751 #define DFC_LISP_STRING_USE_CONVERTED_DATA(sink) \
|
|
|
2752 sink = make_string ((Intbyte *) dfc_sink.data.ptr, dfc_sink.data.len)
|
|
|
2753 #define DFC_LISP_OPAQUE_USE_CONVERTED_DATA(sink) \
|
|
|
2754 sink = make_opaque (dfc_sink.data.ptr, dfc_sink.data.len)
|
|
|
2755 #define DFC_LISP_LSTREAM_USE_CONVERTED_DATA(sink) /* data already used */
|
|
|
2756 #define DFC_LISP_BUFFER_USE_CONVERTED_DATA(sink) \
|
|
|
2757 Lstream_delete (XLSTREAM (dfc_sink.lisp_object))
|
|
|
2758
|
|
|
2759 /* Convenience macros for extremely common invocations */
|
|
|
2760 #define C_STRING_TO_EXTERNAL(in, out, coding_system) \
|
|
|
2761 TO_EXTERNAL_FORMAT (C_STRING, in, C_STRING_ALLOCA, out, coding_system)
|
|
|
2762 #define C_STRING_TO_EXTERNAL_MALLOC(in, out, coding_system) \
|
|
|
2763 TO_EXTERNAL_FORMAT (C_STRING, in, C_STRING_MALLOC, out, coding_system)
|
|
|
2764 #define EXTERNAL_TO_C_STRING(in, out, coding_system) \
|
|
|
2765 TO_INTERNAL_FORMAT (C_STRING, in, C_STRING_ALLOCA, out, coding_system)
|
|
|
2766 #define EXTERNAL_TO_C_STRING_MALLOC(in, out, coding_system) \
|
|
|
2767 TO_INTERNAL_FORMAT (C_STRING, in, C_STRING_MALLOC, out, coding_system)
|
|
|
2768 #define LISP_STRING_TO_EXTERNAL(in, out, coding_system) \
|
|
|
2769 TO_EXTERNAL_FORMAT (LISP_STRING, in, C_STRING_ALLOCA, out, coding_system)
|
|
|
2770 #define LISP_STRING_TO_EXTERNAL_MALLOC(in, out, coding_system) \
|
|
|
2771 TO_EXTERNAL_FORMAT (LISP_STRING, in, C_STRING_MALLOC, out, coding_system)
|
|
|
2772
|
|
|
2773 /* Standins for various encodings, until we know them better */
|
|
|
2774 #define Qcommand_argument_encoding Qnative
|
|
|
2775 #define Qenvironment_variable_encoding Qnative
|
|
|
2776 #define Qunix_host_name_encoding Qnative
|
|
|
2777 #define Qunix_service_name_encoding Qnative
|
|
|
2778 #define Qmswindows_host_name_encoding Qmswindows_multibyte
|
|
|
2779 #define Qmswindows_service_name_encoding Qmswindows_multibyte
|
|
|
2780
|
|
|
2781 /* Standins for various X encodings, until we know them better */
|
|
|
2782
|
|
|
2783 /* !!#### Need to verify the encoding used in lwlib -- Qnative or Qctext?
|
|
|
2784 Almost certainly the former. Use a standin for now. */
|
|
|
2785 #define Qlwlib_encoding Qnative
|
|
|
2786
|
|
|
2787 #define Qx_atom_name_encoding Qctext
|
|
|
2788 /* font names are often stored in atoms, so it gets sticky if we set this
|
|
|
2789 to something different from atom-name encoding */
|
|
|
2790 #define Qx_font_name_encoding Qctext
|
|
|
2791
|
|
|
2792 #define Qx_color_name_encoding Qctext
|
|
|
2793
|
|
|
2794 /* the following probably must agree with Qcommand_argument_encoding and
|
|
|
2795 Qenvironment_variable_encoding */
|
|
|
2796 #define Qx_display_name_encoding Qnative
|
|
|
2797
|
|
|
2798 #define Qstrerror_encoding Qnative
|
|
|
2799
|
|
|
2800 #define GET_STRERROR(var, num) \
|
|
|
2801 do { \
|
|
|
2802 int __gsnum__ = (num); \
|
|
|
2803 Extbyte * __gserr__ = strerror (__gsnum__); \
|
|
|
2804 \
|
|
|
2805 if (!__gserr__) \
|
|
|
2806 { \
|
|
851
|
2807 var = alloca_intbytes (99); \
|
|
771
|
2808 qxesprintf (var, "Unknown error %d", __gsnum__); \
|
|
|
2809 } \
|
|
|
2810 else \
|
|
|
2811 EXTERNAL_TO_C_STRING (__gserr__, var, Qstrerror_encoding); \
|
|
|
2812 } while (0)
|
|
|
2813
|
|
|
2814 #endif /* INCLUDED_text_h_ */
|
