Mercurial > hg > xemacs-beta

comparison src/lisp.h @ 867:804517e16990

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[xemacs-hg @ 2002-06-05 09:54:39 by ben] Textual renaming: text/char names abbrev.c, alloc.c, buffer.c, buffer.h, bytecode.c, callint.c, casefiddle.c, casetab.c, charset.h, chartab.c, chartab.h, cmds.c, console-gtk.h, console-msw.c, console-msw.h, console-stream.c, console-tty.c, console-x.c, console-x.h, console.h, data.c, device-msw.c, device-x.c, dialog-msw.c, dired-msw.c, dired.c, doc.c, doprnt.c, editfns.c, eldap.c, emodules.c, eval.c, event-Xt.c, event-gtk.c, event-msw.c, event-stream.c, event-unixoid.c, events.c, events.h, file-coding.c, file-coding.h, fileio.c, filelock.c, fns.c, font-lock.c, frame-gtk.c, frame-msw.c, frame-x.c, frame.c, glyphs-eimage.c, glyphs-msw.c, glyphs-x.c, glyphs.c, glyphs.h, gpmevent.c, gui-x.c, gui-x.h, gui.c, gui.h, hpplay.c, indent.c, insdel.c, insdel.h, intl-win32.c, keymap.c, line-number.c, line-number.h, lisp-disunion.h, lisp-union.h, lisp.h, lread.c, lrecord.h, lstream.c, lstream.h, md5.c, menubar-msw.c, menubar-x.c, menubar.c, minibuf.c, mule-ccl.c, mule-charset.c, mule-coding.c, mule-wnnfns.c, ndir.h, nt.c, objects-gtk.c, objects-gtk.h, objects-msw.c, objects-tty.c, objects-x.c, objects.c, objects.h, postgresql.c, print.c, process-nt.c, process-unix.c, process.c, procimpl.h, realpath.c, redisplay-gtk.c, redisplay-msw.c, redisplay-output.c, redisplay-tty.c, redisplay-x.c, redisplay.c, redisplay.h, regex.c, search.c, select-common.h, select-gtk.c, select-x.c, sound.h, symbols.c, syntax.c, syntax.h, sysdep.c, sysdep.h, sysdir.h, sysfile.h, sysproc.h, syspwd.h, systime.h, syswindows.h, termcap.c, tests.c, text.c, text.h, toolbar-common.c, tooltalk.c, ui-gtk.c, unexnt.c, unicode.c, win32.c: Text/char naming rationalization. [a] distinguish between "charptr" when it refers to operations on the pointer itself and when it refers to operations on text; and [b] use consistent naming for everything referring to internal format, i.e. Itext == text in internal format Ibyte == a byte in such text Ichar == a char as represented in internal character format thus e.g. set_charptr_emchar -> set_itext_ichar The pre and post tags on either side of this change are: pre-internal-format-textual-renaming post-internal-format-textual-renaming See the Internals Manual for details of exactly how this was done, how to handle the change in your workspace, etc.
author ben
date Wed, 05 Jun 2002 09:58:45 +0000
parents 2c12fe2da451
children 79c6ff3eef26
comparison
equal deleted inserted replaced
866:613552a02607 867:804517e16990
192 the C code's perspective, they are exactly equivalent to `char *', 192 the C code's perspective, they are exactly equivalent to `char *',
193 `unsigned char *', etc., so you can freely use them with library 193 `unsigned char *', etc., so you can freely use them with library
194 functions declared as such. */ 194 functions declared as such. */
195 195
196 /* The data representing the text in a buffer is logically a set 196 /* The data representing the text in a buffer is logically a set
197 of Intbytes, declared as follows. */ 197 of Ibytes, declared as follows. */
198 198
199 typedef unsigned char Intbyte; 199 typedef unsigned char Ibyte;
200 200
201 /* The following should be used when you are working with internal data 201 /* The following should be used when you are working with internal data
202 but for whatever reason need to have it declared a "char *". Examples 202 but for whatever reason need to have it declared a "char *". Examples
203 are function arguments whose values are most commonly literal strings, 203 are function arguments whose values are most commonly literal strings,
204 or where you have to apply a stdlib string function to internal data. 204 or where you have to apply a stdlib string function to internal data.
205 205
206 In general, you should avoid this where possible and use Intbyte instead, 206 In general, you should avoid this where possible and use Ibyte instead,
207 for consistency. For example, the new Mule workspace contains 207 for consistency. For example, the new Mule workspace contains
208 Intbyte versions of the stdlib string functions. */ 208 Ibyte versions of the stdlib string functions. */
209 209
210 typedef char CIntbyte; 210 typedef char CIbyte;
211 211
212 /* The data representing a string in "external" format (binary or any 212 /* The data representing a string in "external" format (binary or any
213 external encoding) is logically a set of Extbytes, declared as 213 external encoding) is logically a set of Extbytes, declared as
214 follows. Extbyte is guaranteed to be just a char, so for example 214 follows. Extbyte is guaranteed to be just a char, so for example
215 strlen (Extbyte *) is OK. Extbyte is only a documentation device 215 strlen (Extbyte *) is OK. Extbyte is only a documentation device
228 228
229 typedef char Char_ASCII; 229 typedef char Char_ASCII;
230 typedef unsigned char UChar_ASCII; 230 typedef unsigned char UChar_ASCII;
231 231
232 /* To the user, a buffer is made up of characters. In the non-Mule world, 232 /* To the user, a buffer is made up of characters. In the non-Mule world,
233 characters and Intbytes are equivalent, restricted to the range 0 - 255. 233 characters and Ibytes are equivalent, restricted to the range 0 - 255.
234 In the Mule world, many more characters are possible (19 bits worth, 234 In the Mule world, many more characters are possible (19 bits worth,
235 more or less), and a character requires (typically) 1 to 4 Intbytes for 235 more or less), and a character requires (typically) 1 to 4 Ibytes for
236 its representation in a buffer or string. Note that the representation 236 its representation in a buffer or string. Note that the representation
237 of a character by itself, in a variable, is very different from its 237 of a character by itself, in a variable, is very different from its
238 representation in a string of text (in a buffer or Lisp string). 238 representation in a string of text (in a buffer or Lisp string).
239 239
240 Under Mule, text can be represented in more than one way. The "default" 240 Under Mule, text can be represented in more than one way. The "default"
247 247
248 See text.c/text.h for a detailed discussion of all of this. */ 248 See text.c/text.h for a detailed discussion of all of this. */
249 249
250 /* A character, as represented on its own. */ 250 /* A character, as represented on its own. */
251 251
252 typedef int Emchar; 252 typedef int Ichar;
253 253
254 /* The "raw value" of a character as stored in the buffer. In the default 254 /* The "raw value" of a character as stored in the buffer. In the default
255 format, this is just the same as the character. In fixed-width formats, 255 format, this is just the same as the character. In fixed-width formats,
256 this is the actual value in the buffer, which will be limited to the 256 this is the actual value in the buffer, which will be limited to the
257 range as established by the format. This is used when searching for a 257 range as established by the format. This is used when searching for a
258 character in a buffer -- it's faster to convert the character to the raw 258 character in a buffer -- it's faster to convert the character to the raw
259 value and look for that, than repeatedly convert each raw value in the 259 value and look for that, than repeatedly convert each raw value in the
260 buffer into a character. */ 260 buffer into a character. */
261 261
262 typedef int Raw_Emchar; 262 typedef int Raw_Ichar;
263 263
264 264
265 #if !defined (__cplusplus) || !defined (CPLUSPLUS_INTEGRAL_CLASSES_NOT_YET) 265 #if !defined (__cplusplus) || !defined (CPLUSPLUS_INTEGRAL_CLASSES_NOT_YET)
266 266
267 /* Counts of bytes or chars */ 267 /* Counts of bytes or chars */
712 { return b ? cl (x) : y; } \ 712 { return b ? cl (x) : y; } \
713 inline cl operator ?: (bool b, const cl& x, integral y) \ 713 inline cl operator ?: (bool b, const cl& x, integral y) \
714 { return b ? x : cl (y); } 714 { return b ? x : cl (y); }
715 #endif /* 0 */ 715 #endif /* 0 */
716 716
717 /* DECLARE_POINTER_TYPE_ARITH_COUNT (const Intbyte *, Bytecount); 717 /* DECLARE_POINTER_TYPE_ARITH_COUNT (const Ibyte *, Bytecount);
718 DECLARE_POINTER_TYPE_ARITH_COUNT (const Extbyte *, Bytecount); */ 718 DECLARE_POINTER_TYPE_ARITH_COUNT (const Extbyte *, Bytecount); */
719 DECLARE_POINTER_TYPE_ARITH_COUNT (Intbyte *, Bytecount); 719 DECLARE_POINTER_TYPE_ARITH_COUNT (Ibyte *, Bytecount);
720 DECLARE_POINTER_TYPE_ARITH_COUNT (Extbyte *, Bytecount); 720 DECLARE_POINTER_TYPE_ARITH_COUNT (Extbyte *, Bytecount);
721 721
722 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (int, Bytecount); 722 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (int, Bytecount);
723 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (int, Charcount); 723 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (int, Charcount);
724 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (unsigned int, Bytecount); 724 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (unsigned int, Bytecount);
736 DECLARE_INTEGRAL_TYPE_COMPARE (long, Charcount); 736 DECLARE_INTEGRAL_TYPE_COMPARE (long, Charcount);
737 DECLARE_INTEGRAL_TYPE_COMPARE (unsigned long, Bytecount); 737 DECLARE_INTEGRAL_TYPE_COMPARE (unsigned long, Bytecount);
738 DECLARE_INTEGRAL_TYPE_COMPARE (unsigned long, Charcount); 738 DECLARE_INTEGRAL_TYPE_COMPARE (unsigned long, Charcount);
739 739
740 #if 0 /* doesn't work */ 740 #if 0 /* doesn't work */
741 inline Bytecount operator - (const Intbyte *x, const Intbyte *y) \ 741 inline Bytecount operator - (const Ibyte *x, const Ibyte *y) \
742 { return Bytecount (x - y); } 742 { return Bytecount (x - y); }
743 #endif 743 #endif
744 744
745 #define class c_class 745 #define class c_class
746 #define this c_this 746 #define this c_this
1300 1300
1301 /* Dynarr typedefs -- basic types first */ 1301 /* Dynarr typedefs -- basic types first */
1302 1302
1303 typedef struct 1303 typedef struct
1304 { 1304 {
1305 Dynarr_declare (Intbyte); 1305 Dynarr_declare (Ibyte);
1306 } Intbyte_dynarr; 1306 } Ibyte_dynarr;
1307 1307
1308 typedef struct 1308 typedef struct
1309 { 1309 {
1310 Dynarr_declare (Extbyte); 1310 Dynarr_declare (Extbyte);
1311 } Extbyte_dynarr; 1311 } Extbyte_dynarr;
1312 1312
1313 typedef struct 1313 typedef struct
1314 { 1314 {
1315 Dynarr_declare (Emchar); 1315 Dynarr_declare (Ichar);
1316 } Emchar_dynarr; 1316 } Ichar_dynarr;
1317 1317
1318 typedef struct 1318 typedef struct
1319 { 1319 {
1320 Dynarr_declare (char); 1320 Dynarr_declare (char);
1321 } char_dynarr; 1321 } char_dynarr;
2072 (byte_ascii_p) */ 2072 (byte_ascii_p) */
2073 unsigned int ascii_begin :21; 2073 unsigned int ascii_begin :21;
2074 } v; 2074 } v;
2075 } u; 2075 } u;
2076 Bytecount size_; 2076 Bytecount size_;
2077 Intbyte *data_; 2077 Ibyte *data_;
2078 Lisp_Object plist; 2078 Lisp_Object plist;
2079 }; 2079 };
2080 typedef struct Lisp_String Lisp_String; 2080 typedef struct Lisp_String Lisp_String;
2081 2081
2082 #define MAX_STRING_ASCII_BEGIN ((1 << 21) - 1) 2082 #define MAX_STRING_ASCII_BEGIN ((1 << 21) - 1)
2334 #define CHARP(x) (XTYPE (x) == Lisp_Type_Char) 2334 #define CHARP(x) (XTYPE (x) == Lisp_Type_Char)
2335 2335
2336 #ifdef ERROR_CHECK_TYPES 2336 #ifdef ERROR_CHECK_TYPES
2337 2337
2338 DECLARE_INLINE_HEADER ( 2338 DECLARE_INLINE_HEADER (
2339 Emchar 2339 Ichar
2340 XCHAR_1 (Lisp_Object obj, const char *file, int line) 2340 XCHAR_1 (Lisp_Object obj, const char *file, int line)
2341 ) 2341 )
2342 { 2342 {
2343 assert_at_line (CHARP (obj), file, line); 2343 assert_at_line (CHARP (obj), file, line);
2344 return XCHARVAL (obj); 2344 return XCHARVAL (obj);
2346 2346
2347 #define XCHAR(x) XCHAR_1 (x, __FILE__, __LINE__) 2347 #define XCHAR(x) XCHAR_1 (x, __FILE__, __LINE__)
2348 2348
2349 #else /* no error checking */ 2349 #else /* no error checking */
2350 2350
2351 #define XCHAR(x) ((Emchar) XCHARVAL (x)) 2351 #define XCHAR(x) ((Ichar) XCHARVAL (x))
2352 2352
2353 #endif /* no error checking */ 2353 #endif /* no error checking */
2354 2354
2355 #define CHECK_CHAR(x) CHECK_NONRECORD (x, Lisp_Type_Char, Qcharacterp) 2355 #define CHECK_CHAR(x) CHECK_NONRECORD (x, Lisp_Type_Char, Qcharacterp)
2356 #define CONCHECK_CHAR(x) CONCHECK_NONRECORD (x, Lisp_Type_Char, Qcharacterp) 2356 #define CONCHECK_CHAR(x) CONCHECK_NONRECORD (x, Lisp_Type_Char, Qcharacterp)
2897 and also call Fgettext() on args[0] and, if that is different, 2897 and also call Fgettext() on args[0] and, if that is different,
2898 format it and store it in the `string-translatable' property of the 2898 format it and store it in the `string-translatable' property of the
2899 returned string. See Fgettext(). 2899 returned string. See Fgettext().
2900 2900
2901 CGETTEXT() is the same as GETTEXT() but works with char * strings 2901 CGETTEXT() is the same as GETTEXT() but works with char * strings
2902 instead of Intbyte * strings. 2902 instead of Ibyte * strings.
2903 2903
2904 build_msg_string() is a shorthand for build_string (GETTEXT (x)). 2904 build_msg_string() is a shorthand for build_string (GETTEXT (x)).
2905 build_msg_intstring() is a shorthand for build_intstring (GETTEXT (x)). 2905 build_msg_intstring() is a shorthand for build_intstring (GETTEXT (x)).
2906 */ 2906 */
2907 2907
3344 void disksave_object_finalization (void); 3344 void disksave_object_finalization (void);
3345 extern int purify_flag; 3345 extern int purify_flag;
3346 extern EMACS_INT gc_generation_number[1]; 3346 extern EMACS_INT gc_generation_number[1];
3347 int c_readonly (Lisp_Object); 3347 int c_readonly (Lisp_Object);
3348 int lisp_readonly (Lisp_Object); 3348 int lisp_readonly (Lisp_Object);
3349 Lisp_Object build_intstring (const Intbyte *); 3349 Lisp_Object build_intstring (const Ibyte *);
3350 Lisp_Object build_string (const CIntbyte *); 3350 Lisp_Object build_string (const CIbyte *);
3351 Lisp_Object build_ext_string (const Extbyte *, Lisp_Object); 3351 Lisp_Object build_ext_string (const Extbyte *, Lisp_Object);
3352 Lisp_Object build_msg_intstring (const Intbyte *); 3352 Lisp_Object build_msg_intstring (const Ibyte *);
3353 Lisp_Object build_msg_string (const CIntbyte *); 3353 Lisp_Object build_msg_string (const CIbyte *);
3354 Lisp_Object make_string (const Intbyte *, Bytecount); 3354 Lisp_Object make_string (const Ibyte *, Bytecount);
3355 Lisp_Object make_ext_string (const Extbyte *, EMACS_INT, Lisp_Object); 3355 Lisp_Object make_ext_string (const Extbyte *, EMACS_INT, Lisp_Object);
3356 void init_string_ascii_begin (Lisp_Object string); 3356 void init_string_ascii_begin (Lisp_Object string);
3357 Lisp_Object make_uninit_string (Bytecount); 3357 Lisp_Object make_uninit_string (Bytecount);
3358 Lisp_Object make_float (double); 3358 Lisp_Object make_float (double);
3359 Lisp_Object make_string_nocopy (const Intbyte *, Bytecount); 3359 Lisp_Object make_string_nocopy (const Ibyte *, Bytecount);
3360 void free_cons (Lisp_Object); 3360 void free_cons (Lisp_Object);
3361 void free_list (Lisp_Object); 3361 void free_list (Lisp_Object);
3362 void free_alist (Lisp_Object); 3362 void free_alist (Lisp_Object);
3363 void mark_conses_in_list (Lisp_Object); 3363 void mark_conses_in_list (Lisp_Object);
3364 void free_marker (Lisp_Marker *); 3364 void free_marker (Lisp_Marker *);
3387 /* Defined in buffer.c */ 3387 /* Defined in buffer.c */
3388 Lisp_Object get_truename_buffer (Lisp_Object); 3388 Lisp_Object get_truename_buffer (Lisp_Object);
3389 void switch_to_buffer (Lisp_Object, Lisp_Object); 3389 void switch_to_buffer (Lisp_Object, Lisp_Object);
3390 extern int find_file_compare_truenames; 3390 extern int find_file_compare_truenames;
3391 extern int find_file_use_truenames; 3391 extern int find_file_use_truenames;
3392 Intbyte *get_initial_directory (Intbyte *pathname, Bytecount size); 3392 Ibyte *get_initial_directory (Ibyte *pathname, Bytecount size);
3393 extern Lisp_Object Vbuffer_alist; 3393 extern Lisp_Object Vbuffer_alist;
3394 void set_buffer_internal (struct buffer *b); 3394 void set_buffer_internal (struct buffer *b);
3395 struct buffer *decode_buffer (Lisp_Object buffer, int allow_string); 3395 struct buffer *decode_buffer (Lisp_Object buffer, int allow_string);
3396 3396
3397 void record_buffer (Lisp_Object buf); 3397 void record_buffer (Lisp_Object buf);
3430 3430
3431 /* Defined in bytecode.c */ 3431 /* Defined in bytecode.c */
3432 EXFUN (Fbyte_code, 3); 3432 EXFUN (Fbyte_code, 3);
3433 3433
3434 DECLARE_DOESNT_RETURN (invalid_byte_code 3434 DECLARE_DOESNT_RETURN (invalid_byte_code
3435 (const CIntbyte *reason, Lisp_Object frob)); 3435 (const CIbyte *reason, Lisp_Object frob));
3436 3436
3437 /* Defined in callint.c */ 3437 /* Defined in callint.c */
3438 EXFUN (Fcall_interactively, 3); 3438 EXFUN (Fcall_interactively, 3);
3439 EXFUN (Fprefix_numeric_value, 1); 3439 EXFUN (Fprefix_numeric_value, 1);
3440 3440
3462 3462
3463 /* Defined in console-msw.c */ 3463 /* Defined in console-msw.c */
3464 EXFUN (Fmswindows_message_box, 3); 3464 EXFUN (Fmswindows_message_box, 3);
3465 extern int mswindows_message_outputted; 3465 extern int mswindows_message_outputted;
3466 void mswindows_hide_console (void); 3466 void mswindows_hide_console (void);
3467 int mswindows_output_console_string (const Intbyte *ptr, Bytecount len); 3467 int mswindows_output_console_string (const Ibyte *ptr, Bytecount len);
3468 void write_string_to_mswindows_debugging_output (Intbyte *str, Bytecount len); 3468 void write_string_to_mswindows_debugging_output (Ibyte *str, Bytecount len);
3469 3469
3470 /* Defined in data.c */ 3470 /* Defined in data.c */
3471 EXFUN (Fadd1, 1); 3471 EXFUN (Fadd1, 1);
3472 EXFUN (Faref, 2); 3472 EXFUN (Faref, 2);
3473 EXFUN (Faset, 3); 3473 EXFUN (Faset, 3);
3520 values! Use make_time. */ 3520 values! Use make_time. */
3521 Lisp_Object word_to_lisp (unsigned int); 3521 Lisp_Object word_to_lisp (unsigned int);
3522 unsigned int lisp_to_word (Lisp_Object); 3522 unsigned int lisp_to_word (Lisp_Object);
3523 3523
3524 /* Defined in dired.c */ 3524 /* Defined in dired.c */
3525 Lisp_Object make_directory_hash_table (const Intbyte *); 3525 Lisp_Object make_directory_hash_table (const Ibyte *);
3526 Lisp_Object wasteful_word_to_lisp (unsigned int); 3526 Lisp_Object wasteful_word_to_lisp (unsigned int);
3527 3527
3528 /* Defined in doc.c */ 3528 /* Defined in doc.c */
3529 EXFUN (Fsubstitute_command_keys, 1); 3529 EXFUN (Fsubstitute_command_keys, 1);
3530 3530
3531 Lisp_Object unparesseuxify_doc_string (int fd, EMACS_INT position, 3531 Lisp_Object unparesseuxify_doc_string (int fd, EMACS_INT position,
3532 Intbyte *name_nonreloc, 3532 Ibyte *name_nonreloc,
3533 Lisp_Object name_reloc, 3533 Lisp_Object name_reloc,
3534 int standard_doc_file); 3534 int standard_doc_file);
3535 Lisp_Object read_doc_string (Lisp_Object); 3535 Lisp_Object read_doc_string (Lisp_Object);
3536 3536
3537 /* Defined in doprnt.c */ 3537 /* Defined in doprnt.c */
3538 Bytecount emacs_doprnt_va (Lisp_Object stream, const Intbyte *format_nonreloc, 3538 Bytecount emacs_doprnt_va (Lisp_Object stream, const Ibyte *format_nonreloc,
3539 Bytecount format_length, Lisp_Object format_reloc, 3539 Bytecount format_length, Lisp_Object format_reloc,
3540 va_list vargs); 3540 va_list vargs);
3541 Bytecount emacs_doprnt (Lisp_Object stream, const Intbyte *format_nonreloc, 3541 Bytecount emacs_doprnt (Lisp_Object stream, const Ibyte *format_nonreloc,
3542 Bytecount format_length, Lisp_Object format_reloc, 3542 Bytecount format_length, Lisp_Object format_reloc,
3543 int nargs, const Lisp_Object *largs, ...); 3543 int nargs, const Lisp_Object *largs, ...);
3544 Lisp_Object emacs_vsprintf_string_lisp (const CIntbyte *format_nonreloc, 3544 Lisp_Object emacs_vsprintf_string_lisp (const CIbyte *format_nonreloc,
3545 Lisp_Object format_reloc, int nargs, 3545 Lisp_Object format_reloc, int nargs,
3546 const Lisp_Object *largs); 3546 const Lisp_Object *largs);
3547 Lisp_Object emacs_sprintf_string_lisp (const CIntbyte *format_nonreloc, 3547 Lisp_Object emacs_sprintf_string_lisp (const CIbyte *format_nonreloc,
3548 Lisp_Object format_reloc, int nargs, ...); 3548 Lisp_Object format_reloc, int nargs, ...);
3549 Intbyte *emacs_vsprintf_malloc_lisp (const CIntbyte *format_nonreloc, 3549 Ibyte *emacs_vsprintf_malloc_lisp (const CIbyte *format_nonreloc,
3550 Lisp_Object format_reloc, int nargs, 3550 Lisp_Object format_reloc, int nargs,
3551 const Lisp_Object *largs, 3551 const Lisp_Object *largs,
3552 Bytecount *len_out); 3552 Bytecount *len_out);
3553 Intbyte *emacs_sprintf_malloc_lisp (Bytecount *len_out, 3553 Ibyte *emacs_sprintf_malloc_lisp (Bytecount *len_out,
3554 const CIntbyte *format_nonreloc, 3554 const CIbyte *format_nonreloc,
3555 Lisp_Object format_reloc, int nargs, ...); 3555 Lisp_Object format_reloc, int nargs, ...);
3556 Lisp_Object emacs_vsprintf_string (const CIntbyte *format, va_list vargs); 3556 Lisp_Object emacs_vsprintf_string (const CIbyte *format, va_list vargs);
3557 Lisp_Object emacs_sprintf_string (const CIntbyte *format, ...) 3557 Lisp_Object emacs_sprintf_string (const CIbyte *format, ...)
3558 PRINTF_ARGS (1, 2); 3558 PRINTF_ARGS (1, 2);
3559 Intbyte *emacs_vsprintf_malloc (const CIntbyte *format, va_list vargs, 3559 Ibyte *emacs_vsprintf_malloc (const CIbyte *format, va_list vargs,
3560 Bytecount *len_out); 3560 Bytecount *len_out);
3561 Intbyte *emacs_sprintf_malloc (Bytecount *len_out, const CIntbyte *format, ...) 3561 Ibyte *emacs_sprintf_malloc (Bytecount *len_out, const CIbyte *format, ...)
3562 PRINTF_ARGS (2, 3); 3562 PRINTF_ARGS (2, 3);
3563 Bytecount emacs_vsprintf (Intbyte *output, const CIntbyte *format, 3563 Bytecount emacs_vsprintf (Ibyte *output, const CIbyte *format,
3564 va_list vargs); 3564 va_list vargs);
3565 Bytecount emacs_sprintf (Intbyte *output, const CIntbyte *format, ...) 3565 Bytecount emacs_sprintf (Ibyte *output, const CIbyte *format, ...)
3566 PRINTF_ARGS (2, 3); 3566 PRINTF_ARGS (2, 3);
3567 3567
3568 3568
3569 /* Defined in editfns.c */ 3569 /* Defined in editfns.c */
3570 EXFUN (Fbobp, 1); 3570 EXFUN (Fbobp, 1);
3591 EXFUN (Fuser_home_directory, 0); 3591 EXFUN (Fuser_home_directory, 0);
3592 EXFUN (Fuser_login_name, 1); 3592 EXFUN (Fuser_login_name, 1);
3593 EXFUN (Fwiden, 1); 3593 EXFUN (Fwiden, 1);
3594 3594
3595 void uncache_home_directory (void); 3595 void uncache_home_directory (void);
3596 Intbyte *get_home_directory (void); 3596 Ibyte *get_home_directory (void);
3597 Intbyte *user_login_name (uid_t *); 3597 Ibyte *user_login_name (uid_t *);
3598 void buffer_insert1 (struct buffer *, Lisp_Object); 3598 void buffer_insert1 (struct buffer *, Lisp_Object);
3599 Lisp_Object make_string_from_buffer (struct buffer *, Charbpos, Charcount); 3599 Lisp_Object make_string_from_buffer (struct buffer *, Charbpos, Charcount);
3600 Lisp_Object make_string_from_buffer_no_extents (struct buffer *, Charbpos, Charcount); 3600 Lisp_Object make_string_from_buffer_no_extents (struct buffer *, Charbpos, Charcount);
3601 Lisp_Object make_time (time_t); 3601 Lisp_Object make_time (time_t);
3602 Lisp_Object save_excursion_save (void); 3602 Lisp_Object save_excursion_save (void);
3616 SIGTYPE fatal_error_signal (int); 3616 SIGTYPE fatal_error_signal (int);
3617 Lisp_Object make_arg_list (int, Extbyte **); 3617 Lisp_Object make_arg_list (int, Extbyte **);
3618 void make_argc_argv (Lisp_Object, int *, Extbyte ***); 3618 void make_argc_argv (Lisp_Object, int *, Extbyte ***);
3619 void free_argc_argv (Extbyte **); 3619 void free_argc_argv (Extbyte **);
3620 Lisp_Object split_external_path (const Extbyte *path); 3620 Lisp_Object split_external_path (const Extbyte *path);
3621 Lisp_Object split_env_path (const CIntbyte *evarname, const Intbyte *default_); 3621 Lisp_Object split_env_path (const CIbyte *evarname, const Ibyte *default_);
3622 3622
3623 /* Nonzero means don't do interactive redisplay and don't change tty modes */ 3623 /* Nonzero means don't do interactive redisplay and don't change tty modes */
3624 extern int noninteractive, noninteractive1; 3624 extern int noninteractive, noninteractive1;
3625 extern int inhibit_non_essential_printing_operations; 3625 extern int inhibit_non_essential_printing_operations;
3626 extern int preparing_for_armageddon; 3626 extern int preparing_for_armageddon;
3657 Error_Behavior); 3657 Error_Behavior);
3658 Lisp_Object maybe_signal_continuable_error_1 (Lisp_Object, Lisp_Object, 3658 Lisp_Object maybe_signal_continuable_error_1 (Lisp_Object, Lisp_Object,
3659 Lisp_Object, Error_Behavior); 3659 Lisp_Object, Error_Behavior);
3660 DECLARE_DOESNT_RETURN_GCC_ATTRIBUTE_SYNTAX_SUCKS (signal_ferror 3660 DECLARE_DOESNT_RETURN_GCC_ATTRIBUTE_SYNTAX_SUCKS (signal_ferror
3661 (Lisp_Object, 3661 (Lisp_Object,
3662 const CIntbyte *, 3662 const CIbyte *,
3663 ...), 2, 3); 3663 ...), 2, 3);
3664 void maybe_signal_ferror (Lisp_Object, Lisp_Object, Error_Behavior, 3664 void maybe_signal_ferror (Lisp_Object, Lisp_Object, Error_Behavior,
3665 const CIntbyte *, ...) PRINTF_ARGS (4, 5); 3665 const CIbyte *, ...) PRINTF_ARGS (4, 5);
3666 Lisp_Object signal_continuable_ferror (Lisp_Object, const CIntbyte *, ...) 3666 Lisp_Object signal_continuable_ferror (Lisp_Object, const CIbyte *, ...)
3667 PRINTF_ARGS (2, 3); 3667 PRINTF_ARGS (2, 3);
3668 Lisp_Object maybe_signal_continuable_ferror (Lisp_Object, Lisp_Object, 3668 Lisp_Object maybe_signal_continuable_ferror (Lisp_Object, Lisp_Object,
3669 Error_Behavior, 3669 Error_Behavior,
3670 const CIntbyte *, ...) 3670 const CIbyte *, ...)
3671 PRINTF_ARGS (4, 5); 3671 PRINTF_ARGS (4, 5);
3672 3672
3673 Lisp_Object build_error_data (const CIntbyte *reason, Lisp_Object frob); 3673 Lisp_Object build_error_data (const CIbyte *reason, Lisp_Object frob);
3674 DECLARE_DOESNT_RETURN (signal_error (Lisp_Object, const CIntbyte *, 3674 DECLARE_DOESNT_RETURN (signal_error (Lisp_Object, const CIbyte *,
3675 Lisp_Object)); 3675 Lisp_Object));
3676 void maybe_signal_error (Lisp_Object, const CIntbyte *, Lisp_Object, 3676 void maybe_signal_error (Lisp_Object, const CIbyte *, Lisp_Object,
3677 Lisp_Object, Error_Behavior); 3677 Lisp_Object, Error_Behavior);
3678 Lisp_Object signal_continuable_error (Lisp_Object, const CIntbyte *, 3678 Lisp_Object signal_continuable_error (Lisp_Object, const CIbyte *,
3679 Lisp_Object); 3679 Lisp_Object);
3680 Lisp_Object maybe_signal_continuable_error (Lisp_Object, const CIntbyte *, 3680 Lisp_Object maybe_signal_continuable_error (Lisp_Object, const CIbyte *,
3681 Lisp_Object, 3681 Lisp_Object,
3682 Lisp_Object, Error_Behavior); 3682 Lisp_Object, Error_Behavior);
3683 DECLARE_DOESNT_RETURN_GCC_ATTRIBUTE_SYNTAX_SUCKS (signal_ferror_with_frob 3683 DECLARE_DOESNT_RETURN_GCC_ATTRIBUTE_SYNTAX_SUCKS (signal_ferror_with_frob
3684 (Lisp_Object, Lisp_Object, 3684 (Lisp_Object, Lisp_Object,
3685 const CIntbyte *, 3685 const CIbyte *,
3686 ...), 3, 4); 3686 ...), 3, 4);
3687 void maybe_signal_ferror_with_frob (Lisp_Object, Lisp_Object, Lisp_Object, 3687 void maybe_signal_ferror_with_frob (Lisp_Object, Lisp_Object, Lisp_Object,
3688 Error_Behavior, 3688 Error_Behavior,
3689 const CIntbyte *, ...) PRINTF_ARGS (5, 6); 3689 const CIbyte *, ...) PRINTF_ARGS (5, 6);
3690 Lisp_Object signal_continuable_ferror_with_frob (Lisp_Object, Lisp_Object, 3690 Lisp_Object signal_continuable_ferror_with_frob (Lisp_Object, Lisp_Object,
3691 const CIntbyte *, 3691 const CIbyte *,
3692 ...) PRINTF_ARGS (3, 4); 3692 ...) PRINTF_ARGS (3, 4);
3693 Lisp_Object maybe_signal_continuable_ferror_with_frob (Lisp_Object, 3693 Lisp_Object maybe_signal_continuable_ferror_with_frob (Lisp_Object,
3694 Lisp_Object, 3694 Lisp_Object,
3695 Lisp_Object, 3695 Lisp_Object,
3696 Error_Behavior, 3696 Error_Behavior,
3697 const CIntbyte *, ...) 3697 const CIbyte *, ...)
3698 PRINTF_ARGS (5, 6); 3698 PRINTF_ARGS (5, 6);
3699 DECLARE_DOESNT_RETURN (signal_error_2 (Lisp_Object, const CIntbyte *, 3699 DECLARE_DOESNT_RETURN (signal_error_2 (Lisp_Object, const CIbyte *,
3700 Lisp_Object, Lisp_Object)); 3700 Lisp_Object, Lisp_Object));
3701 void maybe_signal_error_2 (Lisp_Object, const CIntbyte *, Lisp_Object, 3701 void maybe_signal_error_2 (Lisp_Object, const CIbyte *, Lisp_Object,
3702 Lisp_Object, Lisp_Object, Error_Behavior); 3702 Lisp_Object, Lisp_Object, Error_Behavior);
3703 Lisp_Object signal_continuable_error_2 (Lisp_Object, const CIntbyte *, 3703 Lisp_Object signal_continuable_error_2 (Lisp_Object, const CIbyte *,
3704 Lisp_Object, Lisp_Object); 3704 Lisp_Object, Lisp_Object);
3705 Lisp_Object maybe_signal_continuable_error_2 (Lisp_Object, const CIntbyte *, 3705 Lisp_Object maybe_signal_continuable_error_2 (Lisp_Object, const CIbyte *,
3706 Lisp_Object, Lisp_Object, 3706 Lisp_Object, Lisp_Object,
3707 Lisp_Object, 3707 Lisp_Object,
3708 Error_Behavior); 3708 Error_Behavior);
3709 3709
3710 3710
3711 DECLARE_DOESNT_RETURN (signal_malformed_list_error (Lisp_Object)); 3711 DECLARE_DOESNT_RETURN (signal_malformed_list_error (Lisp_Object));
3712 DECLARE_DOESNT_RETURN (signal_malformed_property_list_error (Lisp_Object)); 3712 DECLARE_DOESNT_RETURN (signal_malformed_property_list_error (Lisp_Object));
3713 DECLARE_DOESNT_RETURN (signal_circular_list_error (Lisp_Object)); 3713 DECLARE_DOESNT_RETURN (signal_circular_list_error (Lisp_Object));
3714 DECLARE_DOESNT_RETURN (signal_circular_property_list_error (Lisp_Object)); 3714 DECLARE_DOESNT_RETURN (signal_circular_property_list_error (Lisp_Object));
3715 3715
3716 DECLARE_DOESNT_RETURN (syntax_error (const CIntbyte *reason, 3716 DECLARE_DOESNT_RETURN (syntax_error (const CIbyte *reason,
3717 Lisp_Object frob)); 3717 Lisp_Object frob));
3718 DECLARE_DOESNT_RETURN (syntax_error_2 (const CIntbyte *reason, 3718 DECLARE_DOESNT_RETURN (syntax_error_2 (const CIbyte *reason,
3719 Lisp_Object frob1, 3719 Lisp_Object frob1,
3720 Lisp_Object frob2)); 3720 Lisp_Object frob2));
3721 void maybe_syntax_error (const CIntbyte *, Lisp_Object, Lisp_Object, 3721 void maybe_syntax_error (const CIbyte *, Lisp_Object, Lisp_Object,
3722 Error_Behavior); 3722 Error_Behavior);
3723 DECLARE_DOESNT_RETURN (sferror (const CIntbyte *reason, Lisp_Object frob)); 3723 DECLARE_DOESNT_RETURN (sferror (const CIbyte *reason, Lisp_Object frob));
3724 DECLARE_DOESNT_RETURN (sferror_2 (const CIntbyte *reason, Lisp_Object frob1, 3724 DECLARE_DOESNT_RETURN (sferror_2 (const CIbyte *reason, Lisp_Object frob1,
3725 Lisp_Object frob2)); 3725 Lisp_Object frob2));
3726 void maybe_sferror (const CIntbyte *, Lisp_Object, Lisp_Object, 3726 void maybe_sferror (const CIbyte *, Lisp_Object, Lisp_Object,
3727 Error_Behavior); 3727 Error_Behavior);
3728 DECLARE_DOESNT_RETURN (invalid_argument (const CIntbyte *reason, 3728 DECLARE_DOESNT_RETURN (invalid_argument (const CIbyte *reason,
3729 Lisp_Object frob)); 3729 Lisp_Object frob));
3730 DECLARE_DOESNT_RETURN (invalid_argument_2 (const CIntbyte *reason, 3730 DECLARE_DOESNT_RETURN (invalid_argument_2 (const CIbyte *reason,
3731 Lisp_Object frob1, 3731 Lisp_Object frob1,
3732 Lisp_Object frob2)); 3732 Lisp_Object frob2));
3733 void maybe_invalid_argument (const CIntbyte *, Lisp_Object, Lisp_Object, 3733 void maybe_invalid_argument (const CIbyte *, Lisp_Object, Lisp_Object,
3734 Error_Behavior); 3734 Error_Behavior);
3735 DECLARE_DOESNT_RETURN (invalid_operation (const CIntbyte *reason, 3735 DECLARE_DOESNT_RETURN (invalid_operation (const CIbyte *reason,
3736 Lisp_Object frob)); 3736 Lisp_Object frob));
3737 DECLARE_DOESNT_RETURN (invalid_operation_2 (const CIntbyte *reason, 3737 DECLARE_DOESNT_RETURN (invalid_operation_2 (const CIbyte *reason,
3738 Lisp_Object frob1, 3738 Lisp_Object frob1,
3739 Lisp_Object frob2)); 3739 Lisp_Object frob2));
3740 void maybe_invalid_operation (const CIntbyte *, Lisp_Object, Lisp_Object, 3740 void maybe_invalid_operation (const CIbyte *, Lisp_Object, Lisp_Object,
3741 Error_Behavior); 3741 Error_Behavior);
3742 DECLARE_DOESNT_RETURN (invalid_state (const CIntbyte *reason, 3742 DECLARE_DOESNT_RETURN (invalid_state (const CIbyte *reason,
3743 Lisp_Object frob)); 3743 Lisp_Object frob));
3744 DECLARE_DOESNT_RETURN (invalid_state_2 (const CIntbyte *reason, 3744 DECLARE_DOESNT_RETURN (invalid_state_2 (const CIbyte *reason,
3745 Lisp_Object frob1, 3745 Lisp_Object frob1,
3746 Lisp_Object frob2)); 3746 Lisp_Object frob2));
3747 void maybe_invalid_state (const CIntbyte *, Lisp_Object, Lisp_Object, 3747 void maybe_invalid_state (const CIbyte *, Lisp_Object, Lisp_Object,
3748 Error_Behavior); 3748 Error_Behavior);
3749 DECLARE_DOESNT_RETURN (invalid_change (const CIntbyte *reason, 3749 DECLARE_DOESNT_RETURN (invalid_change (const CIbyte *reason,
3750 Lisp_Object frob)); 3750 Lisp_Object frob));
3751 DECLARE_DOESNT_RETURN (invalid_change_2 (const CIntbyte *reason, 3751 DECLARE_DOESNT_RETURN (invalid_change_2 (const CIbyte *reason,
3752 Lisp_Object frob1, 3752 Lisp_Object frob1,
3753 Lisp_Object frob2)); 3753 Lisp_Object frob2));
3754 void maybe_invalid_change (const CIntbyte *, Lisp_Object, Lisp_Object, 3754 void maybe_invalid_change (const CIbyte *, Lisp_Object, Lisp_Object,
3755 Error_Behavior); 3755 Error_Behavior);
3756 DECLARE_DOESNT_RETURN (invalid_constant (const CIntbyte *reason, 3756 DECLARE_DOESNT_RETURN (invalid_constant (const CIbyte *reason,
3757 Lisp_Object frob)); 3757 Lisp_Object frob));
3758 DECLARE_DOESNT_RETURN (invalid_constant_2 (const CIntbyte *reason, 3758 DECLARE_DOESNT_RETURN (invalid_constant_2 (const CIbyte *reason,
3759 Lisp_Object frob1, 3759 Lisp_Object frob1,
3760 Lisp_Object frob2)); 3760 Lisp_Object frob2));
3761 void maybe_invalid_constant (const CIntbyte *, Lisp_Object, Lisp_Object, 3761 void maybe_invalid_constant (const CIbyte *, Lisp_Object, Lisp_Object,
3762 Error_Behavior); 3762 Error_Behavior);
3763 DECLARE_DOESNT_RETURN (wtaerror (const CIntbyte *reason, Lisp_Object frob)); 3763 DECLARE_DOESNT_RETURN (wtaerror (const CIbyte *reason, Lisp_Object frob));
3764 DECLARE_DOESNT_RETURN (out_of_memory (const CIntbyte *reason, 3764 DECLARE_DOESNT_RETURN (out_of_memory (const CIbyte *reason,
3765 Lisp_Object frob)); 3765 Lisp_Object frob));
3766 DECLARE_DOESNT_RETURN (stack_overflow (const CIntbyte *reason, 3766 DECLARE_DOESNT_RETURN (stack_overflow (const CIbyte *reason,
3767 Lisp_Object frob)); 3767 Lisp_Object frob));
3768 DECLARE_DOESNT_RETURN_GCC_ATTRIBUTE_SYNTAX_SUCKS (printing_unreadable_object 3768 DECLARE_DOESNT_RETURN_GCC_ATTRIBUTE_SYNTAX_SUCKS (printing_unreadable_object
3769 (const CIntbyte *, 3769 (const CIbyte *,
3770 ...), 1, 2); 3770 ...), 1, 2);
3771 3771
3772 Lisp_Object signal_void_function_error (Lisp_Object); 3772 Lisp_Object signal_void_function_error (Lisp_Object);
3773 Lisp_Object signal_invalid_function_error (Lisp_Object); 3773 Lisp_Object signal_invalid_function_error (Lisp_Object);
3774 Lisp_Object signal_wrong_number_of_arguments_error (Lisp_Object, int); 3774 Lisp_Object signal_wrong_number_of_arguments_error (Lisp_Object, int);
3935 int internal_bind_int (int *addr, int newval); 3935 int internal_bind_int (int *addr, int newval);
3936 int internal_bind_lisp_object (Lisp_Object *addr, Lisp_Object newval); 3936 int internal_bind_lisp_object (Lisp_Object *addr, Lisp_Object newval);
3937 void do_autoload (Lisp_Object, Lisp_Object); 3937 void do_autoload (Lisp_Object, Lisp_Object);
3938 Lisp_Object un_autoload (Lisp_Object); 3938 Lisp_Object un_autoload (Lisp_Object);
3939 void warn_when_safe_lispobj (Lisp_Object, Lisp_Object, Lisp_Object); 3939 void warn_when_safe_lispobj (Lisp_Object, Lisp_Object, Lisp_Object);
3940 void warn_when_safe (Lisp_Object, Lisp_Object, const CIntbyte *, 3940 void warn_when_safe (Lisp_Object, Lisp_Object, const CIbyte *,
3941 ...) PRINTF_ARGS (3, 4); 3941 ...) PRINTF_ARGS (3, 4);
3942 3942
3943 3943
3944 /* Defined in event-stream.c */ 3944 /* Defined in event-stream.c */
3945 EXFUN (Faccept_process_output, 3); 3945 EXFUN (Faccept_process_output, 3);
4119 EXFUN (Fverify_visited_file_modtime, 1); 4119 EXFUN (Fverify_visited_file_modtime, 1);
4120 4120
4121 void record_auto_save (void); 4121 void record_auto_save (void);
4122 void force_auto_save_soon (void); 4122 void force_auto_save_soon (void);
4123 DECLARE_DOESNT_RETURN (report_error_with_errno (Lisp_Object errtype, 4123 DECLARE_DOESNT_RETURN (report_error_with_errno (Lisp_Object errtype,
4124 const CIntbyte *string, 4124 const CIbyte *string,
4125 Lisp_Object data)); 4125 Lisp_Object data));
4126 DECLARE_DOESNT_RETURN (report_file_type_error (Lisp_Object errtype, 4126 DECLARE_DOESNT_RETURN (report_file_type_error (Lisp_Object errtype,
4127 Lisp_Object oserrmess, 4127 Lisp_Object oserrmess,
4128 const CIntbyte *string, 4128 const CIbyte *string,
4129 Lisp_Object data)); 4129 Lisp_Object data));
4130 DECLARE_DOESNT_RETURN (report_file_error (const CIntbyte *, Lisp_Object)); 4130 DECLARE_DOESNT_RETURN (report_file_error (const CIbyte *, Lisp_Object));
4131 Lisp_Object lisp_strerror (int); 4131 Lisp_Object lisp_strerror (int);
4132 Lisp_Object expand_and_dir_to_file (Lisp_Object, Lisp_Object); 4132 Lisp_Object expand_and_dir_to_file (Lisp_Object, Lisp_Object);
4133 int internal_delete_file (Lisp_Object); 4133 int internal_delete_file (Lisp_Object);
4134 4134
4135 /* Defined in filelock.c */ 4135 /* Defined in filelock.c */
4359 extern int menubar_show_keybindings; 4359 extern int menubar_show_keybindings;
4360 extern int popup_menu_titles; 4360 extern int popup_menu_titles;
4361 4361
4362 /* Defined in minibuf.c */ 4362 /* Defined in minibuf.c */
4363 extern int minibuf_level; 4363 extern int minibuf_level;
4364 Charcount scmp_1 (const Intbyte *, const Intbyte *, Charcount, int); 4364 Charcount scmp_1 (const Ibyte *, const Ibyte *, Charcount, int);
4365 #define scmp(s1, s2, len) scmp_1 (s1, s2, len, completion_ignore_case) 4365 #define scmp(s1, s2, len) scmp_1 (s1, s2, len, completion_ignore_case)
4366 extern int completion_ignore_case; 4366 extern int completion_ignore_case;
4367 int regexp_ignore_completion_p (const Intbyte *, Lisp_Object, 4367 int regexp_ignore_completion_p (const Ibyte *, Lisp_Object,
4368 Bytecount, Bytecount); 4368 Bytecount, Bytecount);
4369 Lisp_Object clear_echo_area (struct frame *, Lisp_Object, int); 4369 Lisp_Object clear_echo_area (struct frame *, Lisp_Object, int);
4370 Lisp_Object clear_echo_area_from_print (struct frame *, Lisp_Object, int); 4370 Lisp_Object clear_echo_area_from_print (struct frame *, Lisp_Object, int);
4371 void echo_area_append (struct frame *, const Intbyte *, Lisp_Object, 4371 void echo_area_append (struct frame *, const Ibyte *, Lisp_Object,
4372 Bytecount, Bytecount, Lisp_Object); 4372 Bytecount, Bytecount, Lisp_Object);
4373 void echo_area_message (struct frame *, const Intbyte *, Lisp_Object, 4373 void echo_area_message (struct frame *, const Ibyte *, Lisp_Object,
4374 Bytecount, Bytecount, Lisp_Object); 4374 Bytecount, Bytecount, Lisp_Object);
4375 Lisp_Object echo_area_status (struct frame *); 4375 Lisp_Object echo_area_status (struct frame *);
4376 int echo_area_active (struct frame *); 4376 int echo_area_active (struct frame *);
4377 Lisp_Object echo_area_contents (struct frame *); 4377 Lisp_Object echo_area_contents (struct frame *);
4378 void message_internal (const Intbyte *, Lisp_Object, Bytecount, Bytecount); 4378 void message_internal (const Ibyte *, Lisp_Object, Bytecount, Bytecount);
4379 void message_append_internal (const Intbyte *, Lisp_Object, 4379 void message_append_internal (const Ibyte *, Lisp_Object,
4380 Bytecount, Bytecount); 4380 Bytecount, Bytecount);
4381 void message (const char *, ...) PRINTF_ARGS (1, 2); 4381 void message (const char *, ...) PRINTF_ARGS (1, 2);
4382 void message_append (const char *, ...) PRINTF_ARGS (1, 2); 4382 void message_append (const char *, ...) PRINTF_ARGS (1, 2);
4383 void message_no_translate (const char *, ...) PRINTF_ARGS (1, 2); 4383 void message_no_translate (const char *, ...) PRINTF_ARGS (1, 2);
4384 void clear_message (void); 4384 void clear_message (void);
4401 void print_internal (Lisp_Object, Lisp_Object, int); 4401 void print_internal (Lisp_Object, Lisp_Object, int);
4402 void debug_print (Lisp_Object); 4402 void debug_print (Lisp_Object);
4403 /* NOTE: Do not call this with the data of a Lisp_String. Use princ. 4403 /* NOTE: Do not call this with the data of a Lisp_String. Use princ.
4404 * Note: stream should be defaulted before calling 4404 * Note: stream should be defaulted before calling
4405 * (eg Qnil means stdout, not Vstandard_output, etc) */ 4405 * (eg Qnil means stdout, not Vstandard_output, etc) */
4406 void write_c_string (Lisp_Object stream, const CIntbyte *str); 4406 void write_c_string (Lisp_Object stream, const CIbyte *str);
4407 /* Same goes for this function. */ 4407 /* Same goes for this function. */
4408 void write_string (Lisp_Object stream, const Intbyte *str); 4408 void write_string (Lisp_Object stream, const Ibyte *str);
4409 /* Same goes for this function. */ 4409 /* Same goes for this function. */
4410 void write_string_1 (Lisp_Object stream, const Intbyte *str, Bytecount size); 4410 void write_string_1 (Lisp_Object stream, const Ibyte *str, Bytecount size);
4411 void write_eistring (Lisp_Object stream, const Eistring *ei); 4411 void write_eistring (Lisp_Object stream, const Eistring *ei);
4412 4412
4413 /* Higher-level (printf-style) ways to output data: */ 4413 /* Higher-level (printf-style) ways to output data: */
4414 void write_fmt_string (Lisp_Object stream, const CIntbyte *fmt, ...); 4414 void write_fmt_string (Lisp_Object stream, const CIbyte *fmt, ...);
4415 void write_fmt_string_lisp (Lisp_Object stream, const CIntbyte *fmt, 4415 void write_fmt_string_lisp (Lisp_Object stream, const CIbyte *fmt,
4416 int nargs, ...); 4416 int nargs, ...);
4417 void stderr_out (const CIntbyte *, ...) PRINTF_ARGS (1, 2); 4417 void stderr_out (const CIbyte *, ...) PRINTF_ARGS (1, 2);
4418 void stderr_out_lisp (const CIntbyte *, int nargs, ...); 4418 void stderr_out_lisp (const CIbyte *, int nargs, ...);
4419 void stdout_out (const CIntbyte *, ...) PRINTF_ARGS (1, 2); 4419 void stdout_out (const CIbyte *, ...) PRINTF_ARGS (1, 2);
4420 void debug_out (const CIntbyte *, ...) PRINTF_ARGS (1, 2); 4420 void debug_out (const CIbyte *, ...) PRINTF_ARGS (1, 2);
4421 DECLARE_DOESNT_RETURN_GCC_ATTRIBUTE_SYNTAX_SUCKS (fatal (const CIntbyte *, 4421 DECLARE_DOESNT_RETURN_GCC_ATTRIBUTE_SYNTAX_SUCKS (fatal (const CIbyte *,
4422 ...), 1, 2); 4422 ...), 1, 2);
4423 4423
4424 /* Internal functions: */ 4424 /* Internal functions: */
4425 void temp_output_buffer_setup (Lisp_Object); 4425 void temp_output_buffer_setup (Lisp_Object);
4426 void temp_output_buffer_show (Lisp_Object, Lisp_Object); 4426 void temp_output_buffer_show (Lisp_Object, Lisp_Object);
4458 4458
4459 DECLARE_DOESNT_RETURN (report_process_error (const char *, Lisp_Object)); 4459 DECLARE_DOESNT_RETURN (report_process_error (const char *, Lisp_Object));
4460 DECLARE_DOESNT_RETURN (report_network_error (const char *, Lisp_Object)); 4460 DECLARE_DOESNT_RETURN (report_network_error (const char *, Lisp_Object));
4461 extern Lisp_Object Vlisp_EXEC_SUFFIXES; 4461 extern Lisp_Object Vlisp_EXEC_SUFFIXES;
4462 4462
4463 Intbyte *egetenv (const CIntbyte *var); 4463 Ibyte *egetenv (const CIbyte *var);
4464 void eputenv (const CIntbyte *var, const CIntbyte *value); 4464 void eputenv (const CIbyte *var, const CIbyte *value);
4465 extern int env_initted; 4465 extern int env_initted;
4466 4466
4467 /* Defined in profile.c */ 4467 /* Defined in profile.c */
4468 void mark_profiling_info (void); 4468 void mark_profiling_info (void);
4469 void profile_increase_call_count (Lisp_Object); 4469 void profile_increase_call_count (Lisp_Object);
4492 EXFUN (Fskip_chars_forward, 3); 4492 EXFUN (Fskip_chars_forward, 3);
4493 EXFUN (Fstring_match, 4); 4493 EXFUN (Fstring_match, 4);
4494 4494
4495 struct re_pattern_buffer; 4495 struct re_pattern_buffer;
4496 struct re_registers; 4496 struct re_registers;
4497 Charbpos scan_buffer (struct buffer *, Emchar, Charbpos, Charbpos, EMACS_INT, 4497 Charbpos scan_buffer (struct buffer *, Ichar, Charbpos, Charbpos, EMACS_INT,
4498 EMACS_INT *, int); 4498 EMACS_INT *, int);
4499 Charbpos find_next_newline (struct buffer *, Charbpos, int); 4499 Charbpos find_next_newline (struct buffer *, Charbpos, int);
4500 Charbpos find_next_newline_no_quit (struct buffer *, Charbpos, int); 4500 Charbpos find_next_newline_no_quit (struct buffer *, Charbpos, int);
4501 Bytebpos byte_find_next_newline_no_quit (struct buffer *, Bytebpos, int); 4501 Bytebpos byte_find_next_newline_no_quit (struct buffer *, Bytebpos, int);
4502 Bytecount byte_find_next_emchar_in_string (Lisp_Object, Emchar, Bytecount, 4502 Bytecount byte_find_next_ichar_in_string (Lisp_Object, Ichar, Bytecount,
4503 EMACS_INT); 4503 EMACS_INT);
4504 Charbpos find_before_next_newline (struct buffer *, Charbpos, Charbpos, int); 4504 Charbpos find_before_next_newline (struct buffer *, Charbpos, Charbpos, int);
4505 struct re_pattern_buffer *compile_pattern (Lisp_Object pattern, 4505 struct re_pattern_buffer *compile_pattern (Lisp_Object pattern,
4506 struct re_registers *regp, 4506 struct re_registers *regp,
4507 Lisp_Object translate, 4507 Lisp_Object translate,
4508 Lisp_Object searchobj, 4508 Lisp_Object searchobj,
4509 struct buffer *searchbuf, 4509 struct buffer *searchbuf,
4510 int posix, Error_Behavior errb); 4510 int posix, Error_Behavior errb);
4511 Bytecount fast_string_match (Lisp_Object, const Intbyte *, 4511 Bytecount fast_string_match (Lisp_Object, const Ibyte *,
4512 Lisp_Object, Bytecount, 4512 Lisp_Object, Bytecount,
4513 Bytecount, int, Error_Behavior, int); 4513 Bytecount, int, Error_Behavior, int);
4514 Bytecount fast_lisp_string_match (Lisp_Object, Lisp_Object); 4514 Bytecount fast_lisp_string_match (Lisp_Object, Lisp_Object);
4515 void restore_match_data (void); 4515 void restore_match_data (void);
4516 extern Fixnum warn_about_possibly_incompatible_back_references; 4516 extern Fixnum warn_about_possibly_incompatible_back_references;
4549 EXFUN (Fsymbol_function, 1); 4549 EXFUN (Fsymbol_function, 1);
4550 EXFUN (Fsymbol_name, 1); 4550 EXFUN (Fsymbol_name, 1);
4551 EXFUN (Fsymbol_plist, 1); 4551 EXFUN (Fsymbol_plist, 1);
4552 EXFUN (Fsymbol_value, 1); 4552 EXFUN (Fsymbol_value, 1);
4553 4553
4554 unsigned int hash_string (const Intbyte *, Bytecount); 4554 unsigned int hash_string (const Ibyte *, Bytecount);
4555 Lisp_Object intern_int (const Intbyte *str); 4555 Lisp_Object intern_int (const Ibyte *str);
4556 Lisp_Object intern (const CIntbyte *str); 4556 Lisp_Object intern (const CIbyte *str);
4557 Lisp_Object intern_converting_underscores_to_dashes (const CIntbyte *str); 4557 Lisp_Object intern_converting_underscores_to_dashes (const CIbyte *str);
4558 Lisp_Object oblookup (Lisp_Object, const Intbyte *, Bytecount); 4558 Lisp_Object oblookup (Lisp_Object, const Ibyte *, Bytecount);
4559 void map_obarray (Lisp_Object, int (*) (Lisp_Object, void *), void *); 4559 void map_obarray (Lisp_Object, int (*) (Lisp_Object, void *), void *);
4560 Lisp_Object indirect_function (Lisp_Object, int); 4560 Lisp_Object indirect_function (Lisp_Object, int);
4561 Lisp_Object symbol_value_in_buffer (Lisp_Object, Lisp_Object); 4561 Lisp_Object symbol_value_in_buffer (Lisp_Object, Lisp_Object);
4562 void kill_buffer_local_variables (struct buffer *); 4562 void kill_buffer_local_variables (struct buffer *);
4563 int symbol_value_buffer_local_info (Lisp_Object, struct buffer *); 4563 int symbol_value_buffer_local_info (Lisp_Object, struct buffer *);
4583 /* Defined in sysdep.c */ 4583 /* Defined in sysdep.c */
4584 long get_random (void); 4584 long get_random (void);
4585 void seed_random (long arg); 4585 void seed_random (long arg);
4586 4586
4587 /* Defined in text.c */ 4587 /* Defined in text.c */
4588 void find_charsets_in_intbyte_string (unsigned char *charsets, 4588 void find_charsets_in_ibyte_string (unsigned char *charsets,
4589 const Intbyte *str, 4589 const Ibyte *str,
4590 Bytecount len); 4590 Bytecount len);
4591 void find_charsets_in_emchar_string (unsigned char *charsets, 4591 void find_charsets_in_ichar_string (unsigned char *charsets,
4592 const Emchar *str, 4592 const Ichar *str,
4593 Charcount len); 4593 Charcount len);
4594 int intbyte_string_displayed_columns (const Intbyte *str, Bytecount len); 4594 int ibyte_string_displayed_columns (const Ibyte *str, Bytecount len);
4595 int emchar_string_displayed_columns (const Emchar *str, Charcount len); 4595 int ichar_string_displayed_columns (const Ichar *str, Charcount len);
4596 Charcount intbyte_string_nonascii_chars (const Intbyte *str, Bytecount len); 4596 Charcount ibyte_string_nonascii_chars (const Ibyte *str, Bytecount len);
4597 void convert_intbyte_string_into_emchar_dynarr (const Intbyte *str, 4597 void convert_ibyte_string_into_ichar_dynarr (const Ibyte *str,
4598 Bytecount len, 4598 Bytecount len,
4599 Emchar_dynarr *dyn); 4599 Ichar_dynarr *dyn);
4600 Charcount convert_intbyte_string_into_emchar_string (const Intbyte *str, 4600 Charcount convert_ibyte_string_into_ichar_string (const Ibyte *str,
4601 Bytecount len, 4601 Bytecount len,
4602 Emchar *arr); 4602 Ichar *arr);
4603 void convert_emchar_string_into_intbyte_dynarr (Emchar *arr, int nels, 4603 void convert_ichar_string_into_ibyte_dynarr (Ichar *arr, int nels,
4604 Intbyte_dynarr *dyn); 4604 Ibyte_dynarr *dyn);
4605 Intbyte *convert_emchar_string_into_malloced_string (Emchar *arr, int nels, 4605 Ibyte *convert_ichar_string_into_malloced_string (Ichar *arr, int nels,
4606 Bytecount *len_out); 4606 Bytecount *len_out);
4607 Bytecount copy_text_between_formats (const Intbyte *src, Bytecount srclen, 4607 Bytecount copy_text_between_formats (const Ibyte *src, Bytecount srclen,
4608 Internal_Format srcfmt, 4608 Internal_Format srcfmt,
4609 Lisp_Object srcobj, 4609 Lisp_Object srcobj,
4610 Intbyte *dst, Bytecount dstlen, 4610 Ibyte *dst, Bytecount dstlen,
4611 Internal_Format dstfmt, 4611 Internal_Format dstfmt,
4612 Lisp_Object dstobj, 4612 Lisp_Object dstobj,
4613 Bytecount *src_used); 4613 Bytecount *src_used);
4614 Bytecount copy_buffer_text_out (struct buffer *buf, Bytebpos pos, 4614 Bytecount copy_buffer_text_out (struct buffer *buf, Bytebpos pos,
4615 Bytecount len, Intbyte *dst, Bytecount dstlen, 4615 Bytecount len, Ibyte *dst, Bytecount dstlen,
4616 Internal_Format dstfmt, Lisp_Object dstobj, 4616 Internal_Format dstfmt, Lisp_Object dstobj,
4617 Bytecount *src_used); 4617 Bytecount *src_used);
4618 4618
4619 /* flags for get_buffer_pos_char(), get_buffer_range_char(), etc. */ 4619 /* flags for get_buffer_pos_char(), get_buffer_range_char(), etc. */
4620 /* At most one of GB_COERCE_RANGE and GB_NO_ERROR_IF_BAD should be 4620 /* At most one of GB_COERCE_RANGE and GB_NO_ERROR_IF_BAD should be
4685 Bytexpos pos); 4685 Bytexpos pos);
4686 4686
4687 4687
4688 #ifdef ENABLE_COMPOSITE_CHARS 4688 #ifdef ENABLE_COMPOSITE_CHARS
4689 4689
4690 Emchar lookup_composite_char (Intbyte *str, int len); 4690 Ichar lookup_composite_char (Ibyte *str, int len);
4691 Lisp_Object composite_char_string (Emchar ch); 4691 Lisp_Object composite_char_string (Ichar ch);
4692 #endif /* ENABLE_COMPOSITE_CHARS */ 4692 #endif /* ENABLE_COMPOSITE_CHARS */
4693 4693
4694 EXFUN (Ffind_charset, 1); 4694 EXFUN (Ffind_charset, 1);
4695 EXFUN (Fget_charset, 1); 4695 EXFUN (Fget_charset, 1);
4696 EXFUN (Fcharset_list, 0); 4696 EXFUN (Fcharset_list, 0);
4718 extern Lisp_Object Vcharset_chinese_cns11643_2; 4718 extern Lisp_Object Vcharset_chinese_cns11643_2;
4719 extern Lisp_Object Vcharset_chinese_big5_1; 4719 extern Lisp_Object Vcharset_chinese_big5_1;
4720 extern Lisp_Object Vcharset_chinese_big5_2; 4720 extern Lisp_Object Vcharset_chinese_big5_2;
4721 extern Lisp_Object Vcharset_composite; 4721 extern Lisp_Object Vcharset_composite;
4722 4722
4723 Emchar Lstream_get_emchar_1 (Lstream *stream, int first_char); 4723 Ichar Lstream_get_ichar_1 (Lstream *stream, int first_char);
4724 int Lstream_fput_emchar (Lstream *stream, Emchar ch); 4724 int Lstream_fput_ichar (Lstream *stream, Ichar ch);
4725 void Lstream_funget_emchar (Lstream *stream, Emchar ch); 4725 void Lstream_funget_ichar (Lstream *stream, Ichar ch);
4726 4726
4727 DECLARE_INLINE_HEADER (Intbyte *qxestrdup (const Intbyte *s)) 4727 DECLARE_INLINE_HEADER (Ibyte *qxestrdup (const Ibyte *s))
4728 { 4728 {
4729 return (Intbyte *) xstrdup ((const char *) s); 4729 return (Ibyte *) xstrdup ((const char *) s);
4730 } 4730 }
4731 4731
4732 DECLARE_INLINE_HEADER (Bytecount qxestrlen (const Intbyte *s)) 4732 DECLARE_INLINE_HEADER (Bytecount qxestrlen (const Ibyte *s))
4733 { 4733 {
4734 return strlen ((const char *) s); 4734 return strlen ((const char *) s);
4735 } 4735 }
4736 4736
4737 DECLARE_INLINE_HEADER (Charcount qxestrcharlen (const Intbyte *s)) 4737 DECLARE_INLINE_HEADER (Charcount qxestrcharlen (const Ibyte *s))
4738 { 4738 {
4739 return bytecount_to_charcount (s, qxestrlen (s)); 4739 return bytecount_to_charcount (s, qxestrlen (s));
4740 } 4740 }
4741 4741
4742 DECLARE_INLINE_HEADER (int qxestrcmp (const Intbyte *s1, 4742 DECLARE_INLINE_HEADER (int qxestrcmp (const Ibyte *s1,
4743 const Intbyte *s2)) 4743 const Ibyte *s2))
4744 { 4744 {
4745 return strcmp ((const char *) s1, (const char *) s2); 4745 return strcmp ((const char *) s1, (const char *) s2);
4746 } 4746 }
4747 4747
4748 DECLARE_INLINE_HEADER (int qxestrcmp_c (const Intbyte *s1, 4748 DECLARE_INLINE_HEADER (int qxestrcmp_c (const Ibyte *s1,
4749 const char *s2)) 4749 const char *s2))
4750 { 4750 {
4751 return strcmp ((const char *) s1, s2); 4751 return strcmp ((const char *) s1, s2);
4752 } 4752 }
4753 4753
4754 DECLARE_INLINE_HEADER (int qxestrncmp (const Intbyte *string1, 4754 DECLARE_INLINE_HEADER (int qxestrncmp (const Ibyte *string1,
4755 const Intbyte *string2, 4755 const Ibyte *string2,
4756 Bytecount count)) 4756 Bytecount count))
4757 { 4757 {
4758 return strncmp ((const char *) string1, (const char *) string2, 4758 return strncmp ((const char *) string1, (const char *) string2,
4759 (size_t) count); 4759 (size_t) count);
4760 } 4760 }
4761 4761
4762 DECLARE_INLINE_HEADER (int qxestrncmp_c (const Intbyte *string1, 4762 DECLARE_INLINE_HEADER (int qxestrncmp_c (const Ibyte *string1,
4763 const char *string2, 4763 const char *string2,
4764 Bytecount count)) 4764 Bytecount count))
4765 { 4765 {
4766 return strncmp ((const char *) string1, string2, (size_t) count); 4766 return strncmp ((const char *) string1, string2, (size_t) count);
4767 } 4767 }
4768 4768
4769 DECLARE_INLINE_HEADER (Intbyte *qxestrcpy (Intbyte *strDest, 4769 DECLARE_INLINE_HEADER (Ibyte *qxestrcpy (Ibyte *strDest,
4770 const Intbyte *strSource)) 4770 const Ibyte *strSource))
4771 { 4771 {
4772 return (Intbyte *) strcpy ((char *) strDest, (const char *) strSource); 4772 return (Ibyte *) strcpy ((char *) strDest, (const char *) strSource);
4773 } 4773 }
4774 4774
4775 DECLARE_INLINE_HEADER (Intbyte *qxestrcpy_c (Intbyte *strDest, 4775 DECLARE_INLINE_HEADER (Ibyte *qxestrcpy_c (Ibyte *strDest,
4776 const char *strSource)) 4776 const char *strSource))
4777 { 4777 {
4778 return (Intbyte *) strcpy ((char *) strDest, strSource); 4778 return (Ibyte *) strcpy ((char *) strDest, strSource);
4779 } 4779 }
4780 4780
4781 DECLARE_INLINE_HEADER (Intbyte *qxestrncpy (Intbyte *strDest, 4781 DECLARE_INLINE_HEADER (Ibyte *qxestrncpy (Ibyte *strDest,
4782 const Intbyte *strSource, 4782 const Ibyte *strSource,
4783 Bytecount count)) 4783 Bytecount count))
4784 { 4784 {
4785 return (Intbyte *) strncpy ((char *) strDest, (const char *) strSource, 4785 return (Ibyte *) strncpy ((char *) strDest, (const char *) strSource,
4786 (size_t) count); 4786 (size_t) count);
4787 } 4787 }
4788 4788
4789 DECLARE_INLINE_HEADER (Intbyte *qxestrncpy_c (Intbyte *strDest, 4789 DECLARE_INLINE_HEADER (Ibyte *qxestrncpy_c (Ibyte *strDest,
4790 const char *strSource, 4790 const char *strSource,
4791 Bytecount count)) 4791 Bytecount count))
4792 { 4792 {
4793 return (Intbyte *) strncpy ((char *) strDest, strSource, (size_t) count); 4793 return (Ibyte *) strncpy ((char *) strDest, strSource, (size_t) count);
4794 } 4794 }
4795 4795
4796 DECLARE_INLINE_HEADER (Intbyte *qxestrcat (Intbyte *strDest, 4796 DECLARE_INLINE_HEADER (Ibyte *qxestrcat (Ibyte *strDest,
4797 const Intbyte *strSource)) 4797 const Ibyte *strSource))
4798 { 4798 {
4799 return (Intbyte *) strcat ((char *) strDest, (const char *) strSource); 4799 return (Ibyte *) strcat ((char *) strDest, (const char *) strSource);
4800 } 4800 }
4801 4801
4802 DECLARE_INLINE_HEADER (Intbyte *qxestrcat_c (Intbyte *strDest, 4802 DECLARE_INLINE_HEADER (Ibyte *qxestrcat_c (Ibyte *strDest,
4803 const char *strSource)) 4803 const char *strSource))
4804 { 4804 {
4805 return (Intbyte *) strcat ((char *) strDest, strSource); 4805 return (Ibyte *) strcat ((char *) strDest, strSource);
4806 } 4806 }
4807 4807
4808 DECLARE_INLINE_HEADER (Intbyte *qxestrncat (Intbyte *strDest, 4808 DECLARE_INLINE_HEADER (Ibyte *qxestrncat (Ibyte *strDest,
4809 const Intbyte *strSource, 4809 const Ibyte *strSource,
4810 Bytecount count)) 4810 Bytecount count))
4811 { 4811 {
4812 return (Intbyte *) strncat ((char *) strDest, (const char *) strSource, 4812 return (Ibyte *) strncat ((char *) strDest, (const char *) strSource,
4813 (size_t) count); 4813 (size_t) count);
4814 } 4814 }
4815 4815
4816 DECLARE_INLINE_HEADER (Intbyte *qxestrncat_c (Intbyte *strDest, 4816 DECLARE_INLINE_HEADER (Ibyte *qxestrncat_c (Ibyte *strDest,
4817 const char *strSource, 4817 const char *strSource,
4818 Bytecount count)) 4818 Bytecount count))
4819 { 4819 {
4820 return (Intbyte *) strncat ((char *) strDest, strSource, (size_t) count); 4820 return (Ibyte *) strncat ((char *) strDest, strSource, (size_t) count);
4821 } 4821 }
4822 4822
4823 DECLARE_INLINE_HEADER (Intbyte *qxestrchr (const Intbyte *s, Emchar c)) 4823 DECLARE_INLINE_HEADER (Ibyte *qxestrchr (const Ibyte *s, Ichar c))
4824 { 4824 {
4825 assert (c >= 0 && c <= 255); 4825 assert (c >= 0 && c <= 255);
4826 return (Intbyte *) strchr ((const char *) s, c); 4826 return (Ibyte *) strchr ((const char *) s, c);
4827 } 4827 }
4828 4828
4829 DECLARE_INLINE_HEADER (Intbyte *qxestrrchr (const Intbyte *s, Emchar c)) 4829 DECLARE_INLINE_HEADER (Ibyte *qxestrrchr (const Ibyte *s, Ichar c))
4830 { 4830 {
4831 assert (c >= 0 && c <= 255); 4831 assert (c >= 0 && c <= 255);
4832 return (Intbyte *) strrchr ((const char *) s, c); 4832 return (Ibyte *) strrchr ((const char *) s, c);
4833 } 4833 }
4834 4834
4835 DECLARE_INLINE_HEADER (Intbyte *qxestrstr (const Intbyte *string1, 4835 DECLARE_INLINE_HEADER (Ibyte *qxestrstr (const Ibyte *string1,
4836 const Intbyte *string2)) 4836 const Ibyte *string2))
4837 { 4837 {
4838 return (Intbyte *) strstr ((const char *) string1, (const char *) string2); 4838 return (Ibyte *) strstr ((const char *) string1, (const char *) string2);
4839 } 4839 }
4840 4840
4841 DECLARE_INLINE_HEADER (Bytecount qxestrcspn (const Intbyte *string, 4841 DECLARE_INLINE_HEADER (Bytecount qxestrcspn (const Ibyte *string,
4842 const CIntbyte *strCharSet)) 4842 const CIbyte *strCharSet))
4843 { 4843 {
4844 return (Bytecount) strcspn ((const char *) string, strCharSet); 4844 return (Bytecount) strcspn ((const char *) string, strCharSet);
4845 } 4845 }
4846 4846
4847 DECLARE_INLINE_HEADER (Bytecount qxestrspn (const Intbyte *string, 4847 DECLARE_INLINE_HEADER (Bytecount qxestrspn (const Ibyte *string,
4848 const CIntbyte *strCharSet)) 4848 const CIbyte *strCharSet))
4849 { 4849 {
4850 return (Bytecount) strspn ((const char *) string, strCharSet); 4850 return (Bytecount) strspn ((const char *) string, strCharSet);
4851 } 4851 }
4852 4852
4853 DECLARE_INLINE_HEADER (Intbyte *qxestrpbrk (const Intbyte *string, 4853 DECLARE_INLINE_HEADER (Ibyte *qxestrpbrk (const Ibyte *string,
4854 const CIntbyte *strCharSet)) 4854 const CIbyte *strCharSet))
4855 { 4855 {
4856 return (Intbyte *) strpbrk ((const char *) string, strCharSet); 4856 return (Ibyte *) strpbrk ((const char *) string, strCharSet);
4857 } 4857 }
4858 4858
4859 DECLARE_INLINE_HEADER (Intbyte *qxestrtok (Intbyte *strToken, 4859 DECLARE_INLINE_HEADER (Ibyte *qxestrtok (Ibyte *strToken,
4860 const CIntbyte *strDelimit)) 4860 const CIbyte *strDelimit))
4861 { 4861 {
4862 return (Intbyte *) strtok ((char *) strToken, strDelimit); 4862 return (Ibyte *) strtok ((char *) strToken, strDelimit);
4863 } 4863 }
4864 4864
4865 DECLARE_INLINE_HEADER (double qxestrtod (const Intbyte *nptr, 4865 DECLARE_INLINE_HEADER (double qxestrtod (const Ibyte *nptr,
4866 Intbyte **endptr)) 4866 Ibyte **endptr))
4867 { 4867 {
4868 return strtod ((const char *) nptr, (char **) endptr); 4868 return strtod ((const char *) nptr, (char **) endptr);
4869 } 4869 }
4870 4870
4871 DECLARE_INLINE_HEADER (long qxestrtol (const Intbyte *nptr, Intbyte **endptr, 4871 DECLARE_INLINE_HEADER (long qxestrtol (const Ibyte *nptr, Ibyte **endptr,
4872 int base)) 4872 int base))
4873 { 4873 {
4874 return strtol ((const char *) nptr, (char **) endptr, base); 4874 return strtol ((const char *) nptr, (char **) endptr, base);
4875 } 4875 }
4876 4876
4877 DECLARE_INLINE_HEADER (unsigned long qxestrtoul (const Intbyte *nptr, 4877 DECLARE_INLINE_HEADER (unsigned long qxestrtoul (const Ibyte *nptr,
4878 Intbyte **endptr, 4878 Ibyte **endptr,
4879 int base)) 4879 int base))
4880 { 4880 {
4881 return strtoul ((const char *) nptr, (char **) endptr, base); 4881 return strtoul ((const char *) nptr, (char **) endptr, base);
4882 } 4882 }
4883 4883
4884 DECLARE_INLINE_HEADER (int qxeatoi (const Intbyte *string)) 4884 DECLARE_INLINE_HEADER (int qxeatoi (const Ibyte *string))
4885 { 4885 {
4886 return atoi ((const char *) string); 4886 return atoi ((const char *) string);
4887 } 4887 }
4888 4888
4889 int qxesprintf (Intbyte *buffer, const CIntbyte *format, ...) 4889 int qxesprintf (Ibyte *buffer, const CIbyte *format, ...)
4890 PRINTF_ARGS (2, 3); 4890 PRINTF_ARGS (2, 3);
4891 4891
4892 /* Do not use POSIX locale routines. Not Mule-correct. */ 4892 /* Do not use POSIX locale routines. Not Mule-correct. */
4893 #define qxestrcoll DO NOT USE. 4893 #define qxestrcoll DO NOT USE.
4894 #define qxestrxfrm DO NOT USE. 4894 #define qxestrxfrm DO NOT USE.
4895 4895
4896 int qxestrcasecmp (const Intbyte *s1, const Intbyte *s2); 4896 int qxestrcasecmp (const Ibyte *s1, const Ibyte *s2);
4897 int qxestrcasecmp_c (const Intbyte *s1, const Char_ASCII *s2); 4897 int qxestrcasecmp_c (const Ibyte *s1, const Char_ASCII *s2);
4898 int qxestrcasecmp_i18n (const Intbyte *s1, const Intbyte *s2); 4898 int qxestrcasecmp_i18n (const Ibyte *s1, const Ibyte *s2);
4899 int ascii_strcasecmp (const Char_ASCII *s1, const Char_ASCII *s2); 4899 int ascii_strcasecmp (const Char_ASCII *s1, const Char_ASCII *s2);
4900 int lisp_strcasecmp (Lisp_Object s1, Lisp_Object s2); 4900 int lisp_strcasecmp (Lisp_Object s1, Lisp_Object s2);
4901 int lisp_strcasecmp_i18n (Lisp_Object s1, Lisp_Object s2); 4901 int lisp_strcasecmp_i18n (Lisp_Object s1, Lisp_Object s2);
4902 int qxestrncasecmp (const Intbyte *s1, const Intbyte *s2, Bytecount len); 4902 int qxestrncasecmp (const Ibyte *s1, const Ibyte *s2, Bytecount len);
4903 int qxestrncasecmp_c (const Intbyte *s1, const Char_ASCII *s2, Bytecount len); 4903 int qxestrncasecmp_c (const Ibyte *s1, const Char_ASCII *s2, Bytecount len);
4904 int qxestrncasecmp_i18n (const Intbyte *s1, const Intbyte *s2, Bytecount len); 4904 int qxestrncasecmp_i18n (const Ibyte *s1, const Ibyte *s2, Bytecount len);
4905 int ascii_strncasecmp (const Char_ASCII *s1, const Char_ASCII *s2, 4905 int ascii_strncasecmp (const Char_ASCII *s1, const Char_ASCII *s2,
4906 Bytecount len); 4906 Bytecount len);
4907 int qxememcmp (const Intbyte *s1, const Intbyte *s2, Bytecount len); 4907 int qxememcmp (const Ibyte *s1, const Ibyte *s2, Bytecount len);
4908 int qxememcmp4 (const Intbyte *s1, Bytecount len1, 4908 int qxememcmp4 (const Ibyte *s1, Bytecount len1,
4909 const Intbyte *s2, Bytecount len2); 4909 const Ibyte *s2, Bytecount len2);
4910 int qxememcasecmp (const Intbyte *s1, const Intbyte *s2, Bytecount len); 4910 int qxememcasecmp (const Ibyte *s1, const Ibyte *s2, Bytecount len);
4911 int qxememcasecmp4 (const Intbyte *s1, Bytecount len1, 4911 int qxememcasecmp4 (const Ibyte *s1, Bytecount len1,
4912 const Intbyte *s2, Bytecount len2); 4912 const Ibyte *s2, Bytecount len2);
4913 int qxetextcmp (const Intbyte *s1, Bytecount len1, 4913 int qxetextcmp (const Ibyte *s1, Bytecount len1,
4914 const Intbyte *s2, Bytecount len2); 4914 const Ibyte *s2, Bytecount len2);
4915 int qxetextcmp_matching (const Intbyte *s1, Bytecount len1, 4915 int qxetextcmp_matching (const Ibyte *s1, Bytecount len1,
4916 const Intbyte *s2, Bytecount len2, 4916 const Ibyte *s2, Bytecount len2,
4917 Charcount *matching); 4917 Charcount *matching);
4918 int qxetextcasecmp (const Intbyte *s1, Bytecount len1, 4918 int qxetextcasecmp (const Ibyte *s1, Bytecount len1,
4919 const Intbyte *s2, Bytecount len2); 4919 const Ibyte *s2, Bytecount len2);
4920 int qxetextcasecmp_matching (const Intbyte *s1, Bytecount len1, 4920 int qxetextcasecmp_matching (const Ibyte *s1, Bytecount len1,
4921 const Intbyte *s2, Bytecount len2, 4921 const Ibyte *s2, Bytecount len2,
4922 Charcount *matching); 4922 Charcount *matching);
4923 4923
4924 void buffer_mule_signal_inserted_region (struct buffer *buf, Charbpos start, 4924 void buffer_mule_signal_inserted_region (struct buffer *buf, Charbpos start,
4925 Bytecount bytelength, 4925 Bytecount bytelength,
4926 Charcount charlength); 4926 Charcount charlength);
4952 void record_delete (struct buffer *, Charbpos, Charcount); 4952 void record_delete (struct buffer *, Charbpos, Charcount);
4953 void record_change (struct buffer *, Charbpos, Charcount); 4953 void record_change (struct buffer *, Charbpos, Charcount);
4954 4954
4955 /* Defined in unex*.c */ 4955 /* Defined in unex*.c */
4956 #ifdef WIN32_NATIVE 4956 #ifdef WIN32_NATIVE
4957 int unexec (Intbyte *, Intbyte *, uintptr_t, uintptr_t, uintptr_t); 4957 int unexec (Ibyte *, Ibyte *, uintptr_t, uintptr_t, uintptr_t);
4958 #else 4958 #else
4959 int unexec (Extbyte *, Extbyte *, uintptr_t, uintptr_t, uintptr_t); 4959 int unexec (Extbyte *, Extbyte *, uintptr_t, uintptr_t, uintptr_t);
4960 #endif 4960 #endif
4961 #ifdef RUN_TIME_REMAP 4961 #ifdef RUN_TIME_REMAP
4962 int run_time_remap (char *); 4962 int run_time_remap (char *);