/* Basic character set support.
Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007,
- 2008, 2009 Free Software Foundation, Inc.
+ 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
- 2005, 2006, 2007, 2008, 2009
+ 2005, 2006, 2007, 2008, 2009, 2010, 2011
National Institute of Advanced Industrial Science and Technology (AIST)
Registration Number H14PRO021
#include <unistd.h>
#include <ctype.h>
#include <sys/types.h>
+#include <setjmp.h>
#include "lisp.h"
#include "character.h"
#include "charset.h"
*/
-/* List of all charsets. This variable is used only from Emacs
- Lisp. */
-Lisp_Object Vcharset_list;
-
/* Hash table that contains attributes of each charset. Keys are
charset symbols, and values are vectors of charset attributes. */
Lisp_Object Vcharset_hash_table;
/* List of emacs-mule charsets. */
Lisp_Object Vemacs_mule_charset_list;
-struct charset *emacs_mule_charset[256];
+int emacs_mule_charset[256];
/* Mapping table from ISO2022's charset (specified by DIMENSION,
CHARS, and FINAL-CHAR) to Emacs' charset. */
int iso_charset_table[ISO_MAX_DIMENSION][ISO_MAX_CHARS][ISO_MAX_FINAL];
-Lisp_Object Vcharset_map_path;
-
-/* If nonzero, don't load charset maps. */
-int inhibit_load_charset_map;
-
-Lisp_Object Vcurrent_iso639_language;
-
-/* Defined in chartab.c */
-extern void
-map_char_table_for_charset P_ ((void (*c_function) (Lisp_Object, Lisp_Object),
- Lisp_Object function, Lisp_Object table,
- Lisp_Object arg, struct charset *charset,
- unsigned from, unsigned to));
-
#define CODE_POINT_TO_INDEX(charset, code) \
((charset)->code_linear_p \
? (code) - (charset)->min_code \
*/
static void
-load_charset_map (charset, entries, n_entries, control_flag)
- struct charset *charset;
- struct charset_map_entries *entries;
- int n_entries;
- int control_flag;
+load_charset_map (struct charset *charset, struct charset_map_entries *entries, int n_entries, int control_flag)
{
Lisp_Object vec, table;
unsigned max_code = CHARSET_MAX_CODE (charset);
/* Read a hexadecimal number (preceded by "0x") from the file FP while
- paying attention to comment charcter '#'. */
+ paying attention to comment character '#'. */
static INLINE unsigned
-read_hex (fp, eof)
- FILE *fp;
- int *eof;
+read_hex (FILE *fp, int *eof)
{
int c;
unsigned n;
return n;
}
-extern Lisp_Object Qfile_name_handler_alist;
-
/* Return a mapping vector for CHARSET loaded from MAPFILE.
Each line of MAPFILE has this form
0xAAAA 0xCCCC
Note that this function uses `openp' to open MAPFILE but ignores
`file-name-handler-alist' to avoid running any Lisp code. */
-extern void add_to_log P_ ((char *, Lisp_Object, Lisp_Object));
-
static void
-load_charset_map_from_file (charset, mapfile, control_flag)
- struct charset *charset;
- Lisp_Object mapfile;
- int control_flag;
+load_charset_map_from_file (struct charset *charset, Lisp_Object mapfile, int control_flag)
{
unsigned min_code = CHARSET_MIN_CODE (charset);
unsigned max_code = CHARSET_MAX_CODE (charset);
int eof;
Lisp_Object suffixes;
struct charset_map_entries *head, *entries;
- int n_entries;
- int count = SPECPDL_INDEX ();
+ int n_entries, count;
+ USE_SAFE_ALLOCA;
suffixes = Fcons (build_string (".map"),
Fcons (build_string (".TXT"), Qnil));
+ count = SPECPDL_INDEX ();
specbind (Qfile_name_handler_alist, Qnil);
fd = openp (Vcharset_map_path, mapfile, suffixes, NULL, Qnil);
unbind_to (count, Qnil);
|| ! (fp = fdopen (fd, "r")))
error ("Failure in loading charset map: %S", SDATA (mapfile));
- head = entries = ((struct charset_map_entries *)
- alloca (sizeof (struct charset_map_entries)));
+ /* Use SAFE_ALLOCA instead of alloca, as `charset_map_entries' is
+ large (larger than MAX_ALLOCA). */
+ SAFE_ALLOCA (head, struct charset_map_entries *,
+ sizeof (struct charset_map_entries));
+ entries = head;
+ memset (entries, 0, sizeof (struct charset_map_entries));
+
n_entries = 0;
eof = 0;
while (1)
if (n_entries > 0 && (n_entries % 0x10000) == 0)
{
- entries->next = ((struct charset_map_entries *)
- alloca (sizeof (struct charset_map_entries)));
+ SAFE_ALLOCA (entries->next, struct charset_map_entries *,
+ sizeof (struct charset_map_entries));
entries = entries->next;
+ memset (entries, 0, sizeof (struct charset_map_entries));
}
idx = n_entries % 0x10000;
entries->entry[idx].from = from;
n_entries++;
}
fclose (fp);
- close (fd);
load_charset_map (charset, head, n_entries, control_flag);
+ SAFE_FREE ();
}
static void
-load_charset_map_from_vector (charset, vec, control_flag)
- struct charset *charset;
- Lisp_Object vec;
- int control_flag;
+load_charset_map_from_vector (struct charset *charset, Lisp_Object vec, int control_flag)
{
unsigned min_code = CHARSET_MIN_CODE (charset);
unsigned max_code = CHARSET_MAX_CODE (charset);
int n_entries;
int len = ASIZE (vec);
int i;
+ USE_SAFE_ALLOCA;
if (len % 2 == 1)
{
return;
}
- head = entries = ((struct charset_map_entries *)
- alloca (sizeof (struct charset_map_entries)));
+ /* Use SAFE_ALLOCA instead of alloca, as `charset_map_entries' is
+ large (larger than MAX_ALLOCA). */
+ SAFE_ALLOCA (head, struct charset_map_entries *,
+ sizeof (struct charset_map_entries));
+ entries = head;
+ memset (entries, 0, sizeof (struct charset_map_entries));
+
n_entries = 0;
for (i = 0; i < len; i += 2)
{
if (n_entries > 0 && (n_entries % 0x10000) == 0)
{
- entries->next = ((struct charset_map_entries *)
- alloca (sizeof (struct charset_map_entries)));
+ SAFE_ALLOCA (entries->next, struct charset_map_entries *,
+ sizeof (struct charset_map_entries));
entries = entries->next;
+ memset (entries, 0, sizeof (struct charset_map_entries));
}
idx = n_entries % 0x10000;
entries->entry[idx].from = from;
}
load_charset_map (charset, head, n_entries, control_flag);
+ SAFE_FREE ();
}
map it is (see the comment of load_charset_map for the detail). */
static void
-load_charset (charset, control_flag)
- struct charset *charset;
- int control_flag;
+load_charset (struct charset *charset, int control_flag)
{
Lisp_Object map;
DEFUN ("charsetp", Fcharsetp, Scharsetp, 1, 1, 0,
doc: /* Return non-nil if and only if OBJECT is a charset.*/)
- (object)
- Lisp_Object object;
+ (Lisp_Object object)
{
return (CHARSETP (object) ? Qt : Qnil);
}
-void map_charset_for_dump P_ ((void (*c_function) (Lisp_Object, Lisp_Object),
- Lisp_Object function, Lisp_Object arg,
- unsigned from, unsigned to));
+void map_charset_for_dump (void (*c_function) (Lisp_Object, Lisp_Object),
+ Lisp_Object function, Lisp_Object arg,
+ unsigned from, unsigned to);
void
-map_charset_for_dump (c_function, function, arg, from, to)
- void (*c_function) (Lisp_Object, Lisp_Object);
- Lisp_Object function, arg;
- unsigned from, to;
+map_charset_for_dump (void (*c_function) (Lisp_Object, Lisp_Object), Lisp_Object function, Lisp_Object arg, unsigned int from, unsigned int to)
{
int from_idx = CODE_POINT_TO_INDEX (temp_charset_work->current, from);
int to_idx = CODE_POINT_TO_INDEX (temp_charset_work->current, to);
}
void
-map_charset_chars (c_function, function, arg,
- charset, from, to)
- void (*c_function) P_ ((Lisp_Object, Lisp_Object));
- Lisp_Object function, arg;
- struct charset *charset;
- unsigned from, to;
+map_charset_chars (void (*c_function)(Lisp_Object, Lisp_Object), Lisp_Object function,
+ Lisp_Object arg, struct charset *charset, unsigned from, unsigned to)
{
Lisp_Object range;
int partial;
The optional 4th and 5th arguments FROM-CODE and TO-CODE specify the
range of code points (in CHARSET) of target characters. */)
- (function, charset, arg, from_code, to_code)
- Lisp_Object function, charset, arg, from_code, to_code;
+ (Lisp_Object function, Lisp_Object charset, Lisp_Object arg, Lisp_Object from_code, Lisp_Object to_code)
{
struct charset *cs;
unsigned from, to;
Sdefine_charset_internal, charset_arg_max, MANY, 0,
doc: /* For internal use only.
usage: (define-charset-internal ...) */)
- (nargs, args)
- int nargs;
- Lisp_Object *args;
+ (int nargs, Lisp_Object *args)
{
/* Charset attr vector. */
Lisp_Object attrs;
if (! charset.code_linear_p)
{
charset.code_space_mask = (unsigned char *) xmalloc (256);
- bzero (charset.code_space_mask, 256);
+ memset (charset.code_space_mask, 0, 256);
for (i = 0; i < 4; i++)
for (j = charset.code_space[i * 4]; j <= charset.code_space[i * 4 + 1];
j++)
charset.unified_p = 0;
- bzero (charset.fast_map, sizeof (charset.fast_map));
+ memset (charset.fast_map, 0, sizeof (charset.fast_map));
if (! NILP (args[charset_arg_code_offset]))
{
struct charset *new_table
= (struct charset *) xmalloc (sizeof (struct charset)
* (charset_table_size + 16));
- bcopy (charset_table, new_table,
- sizeof (struct charset) * charset_table_size);
+ memcpy (new_table, charset_table,
+ sizeof (struct charset) * charset_table_size);
charset_table_size += 16;
charset_table = new_table;
}
if (charset.emacs_mule_id >= 0)
{
- emacs_mule_charset[charset.emacs_mule_id] = CHARSET_FROM_ID (id);
+ emacs_mule_charset[charset.emacs_mule_id] = id;
if (charset.emacs_mule_id < 0xA0)
emacs_mule_bytes[charset.emacs_mule_id] = charset.dimension + 1;
else
charset. */
static int
-define_charset_internal (name, dimension, code_space, min_code, max_code,
- iso_final, iso_revision, emacs_mule_id,
- ascii_compatible, supplementary,
- code_offset)
- Lisp_Object name;
- int dimension;
- unsigned char *code_space;
- unsigned min_code, max_code;
- int iso_final, iso_revision, emacs_mule_id;
- int ascii_compatible, supplementary;
- int code_offset;
+define_charset_internal (Lisp_Object name,
+ int dimension,
+ const unsigned char *code_space,
+ unsigned min_code, unsigned max_code,
+ int iso_final, int iso_revision, int emacs_mule_id,
+ int ascii_compatible, int supplementary,
+ int code_offset)
{
Lisp_Object args[charset_arg_max];
Lisp_Object plist[14];
args[charset_arg_superset] = Qnil;
args[charset_arg_unify_map] = Qnil;
- plist[0] = intern (":name");
+ plist[0] = intern_c_string (":name");
plist[1] = args[charset_arg_name];
- plist[2] = intern (":dimension");
+ plist[2] = intern_c_string (":dimension");
plist[3] = args[charset_arg_dimension];
- plist[4] = intern (":code-space");
+ plist[4] = intern_c_string (":code-space");
plist[5] = args[charset_arg_code_space];
- plist[6] = intern (":iso-final-char");
+ plist[6] = intern_c_string (":iso-final-char");
plist[7] = args[charset_arg_iso_final];
- plist[8] = intern (":emacs-mule-id");
+ plist[8] = intern_c_string (":emacs-mule-id");
plist[9] = args[charset_arg_emacs_mule_id];
- plist[10] = intern (":ascii-compatible-p");
+ plist[10] = intern_c_string (":ascii-compatible-p");
plist[11] = args[charset_arg_ascii_compatible_p];
- plist[12] = intern (":code-offset");
+ plist[12] = intern_c_string (":code-offset");
plist[13] = args[charset_arg_code_offset];
args[charset_arg_plist] = Flist (14, plist);
DEFUN ("define-charset-alias", Fdefine_charset_alias,
Sdefine_charset_alias, 2, 2, 0,
doc: /* Define ALIAS as an alias for charset CHARSET. */)
- (alias, charset)
- Lisp_Object alias, charset;
+ (Lisp_Object alias, Lisp_Object charset)
{
Lisp_Object attr;
DEFUN ("charset-plist", Fcharset_plist, Scharset_plist, 1, 1, 0,
doc: /* Return the property list of CHARSET. */)
- (charset)
- Lisp_Object charset;
+ (Lisp_Object charset)
{
Lisp_Object attrs;
DEFUN ("set-charset-plist", Fset_charset_plist, Sset_charset_plist, 2, 2, 0,
doc: /* Set CHARSET's property list to PLIST. */)
- (charset, plist)
- Lisp_Object charset, plist;
+ (Lisp_Object charset, Lisp_Object plist)
{
Lisp_Object attrs;
`define-charset' (which see).
Optional third argument DEUNIFY, if non-nil, means to de-unify CHARSET. */)
- (charset, unify_map, deunify)
- Lisp_Object charset, unify_map, deunify;
+ (Lisp_Object charset, Lisp_Object unify_map, Lisp_Object deunify)
{
int id;
struct charset *cs;
This final char is for private use, thus the range is `0' (48) .. `?' (63).
If there's no unused final char for the specified kind of charset,
return nil. */)
- (dimension, chars)
- Lisp_Object dimension, chars;
+ (Lisp_Object dimension, Lisp_Object chars)
{
int final_char;
}
static void
-check_iso_charset_parameter (dimension, chars, final_char)
- Lisp_Object dimension, chars, final_char;
+check_iso_charset_parameter (Lisp_Object dimension, Lisp_Object chars, Lisp_Object final_char)
{
CHECK_NATNUM (dimension);
CHECK_NATNUM (chars);
On decoding by an ISO-2022 base coding system, when a charset
specified by DIMENSION, CHARS, and FINAL-CHAR is designated, behave as
if CHARSET is designated instead. */)
- (dimension, chars, final_char, charset)
- Lisp_Object dimension, chars, final_char, charset;
+ (Lisp_Object dimension, Lisp_Object chars, Lisp_Object final_char, Lisp_Object charset)
{
int id;
int chars_flag;
*/
int
-string_xstring_p (string)
- Lisp_Object string;
+string_xstring_p (Lisp_Object string)
{
const unsigned char *p = SDATA (string);
const unsigned char *endp = p + SBYTES (string);
It may lookup a translation table TABLE if supplied. */
static void
-find_charsets_in_text (ptr, nchars, nbytes, charsets, table, multibyte)
- const unsigned char *ptr;
- EMACS_INT nchars, nbytes;
- Lisp_Object charsets, table;
- int multibyte;
+find_charsets_in_text (const unsigned char *ptr, EMACS_INT nchars, EMACS_INT nbytes, Lisp_Object charsets, Lisp_Object table, int multibyte)
{
const unsigned char *pend = ptr + nbytes;
If the current buffer is unibyte, the returned list may contain
only `ascii', `eight-bit-control', and `eight-bit-graphic'. */)
- (beg, end, table)
- Lisp_Object beg, end, table;
+ (Lisp_Object beg, Lisp_Object end, Lisp_Object table)
{
Lisp_Object charsets;
EMACS_INT from, from_byte, to, stop, stop_byte;
If STR is unibyte, the returned list may contain
only `ascii', `eight-bit-control', and `eight-bit-graphic'. */)
- (str, table)
- Lisp_Object str, table;
+ (Lisp_Object str, Lisp_Object table)
{
Lisp_Object charsets;
int i;
value of Vchar_unify_table for C; i.e. it is nil, an integer, or a
charset symbol. */
int
-maybe_unify_char (c, val)
- int c;
- Lisp_Object val;
+maybe_unify_char (int c, Lisp_Object val)
{
struct charset *charset;
CHARSET. */
int
-decode_char (charset, code)
- struct charset *charset;
- unsigned code;
+decode_char (struct charset *charset, unsigned int code)
{
int c, char_index;
enum charset_method method = CHARSET_METHOD (charset);
use CHARSET's strict_max_char instead of max_char. */
unsigned
-encode_char (charset, c)
- struct charset *charset;
- int c;
+encode_char (struct charset *charset, int c)
{
unsigned code;
enum charset_method method = CHARSET_METHOD (charset);
Optional argument RESTRICTION specifies a way to map the pair of CCS
and CODE-POINT to a character. Currently not supported and just ignored. */)
- (charset, code_point, restriction)
- Lisp_Object charset, code_point, restriction;
+ (Lisp_Object charset, Lisp_Object code_point, Lisp_Object restriction)
{
int c, id;
unsigned code;
Optional argument RESTRICTION specifies a way to map CH to a
code-point in CCS. Currently not supported and just ignored. */)
- (ch, charset, restriction)
- Lisp_Object ch, charset, restriction;
+ (Lisp_Object ch, Lisp_Object charset, Lisp_Object restriction)
{
int id;
unsigned code;
CODE1 through CODE4 are optional, but if you don't supply sufficient
position codes, it is assumed that the minimum code in each dimension
is specified. */)
- (charset, code1, code2, code3, code4)
- Lisp_Object charset, code1, code2, code3, code4;
+ (Lisp_Object charset, Lisp_Object code1, Lisp_Object code2, Lisp_Object code3, Lisp_Object code4)
{
int id, dimension;
struct charset *charsetp;
Vcharset_ordered_list. */
struct charset *
-char_charset (c, charset_list, code_return)
- int c;
- Lisp_Object charset_list;
- unsigned *code_return;
+char_charset (int c, Lisp_Object charset_list, unsigned int *code_return)
{
int maybe_null = 0;
return charset;
}
charset_list = XCDR (charset_list);
- if (c <= MAX_UNICODE_CHAR
- && EQ (charset_list, Vcharset_non_preferred_head))
+ if (! maybe_null
+ && c <= MAX_UNICODE_CHAR
+ && EQ (charset_list, Vcharset_non_preferred_head))
return CHARSET_FROM_ID (charset_unicode);
}
return (maybe_null ? NULL
The charset is decided by the current priority order of charsets.
A position-code is a byte value of each dimension of the code-point of
CH in the charset. */)
- (ch)
- Lisp_Object ch;
+ (Lisp_Object ch)
{
struct charset *charset;
int c, dimension;
If optional 2nd arg RESTRICTION is non-nil, it is a list of charsets
from which to find the charset. It may also be a coding system. In
that case, find the charset from what supported by that coding system. */)
- (ch, restriction)
- Lisp_Object ch, restriction;
+ (Lisp_Object ch, Lisp_Object restriction)
{
struct charset *charset;
charset = CHAR_CHARSET (XINT (ch));
else
{
- Lisp_Object charset_list;
-
if (CONSP (restriction))
{
- for (charset_list = Qnil; CONSP (restriction);
- restriction = XCDR (restriction))
+ int c = XFASTINT (ch);
+
+ for (; CONSP (restriction); restriction = XCDR (restriction))
{
- int id;
+ struct charset *charset;
- CHECK_CHARSET_GET_ID (XCAR (restriction), id);
- charset_list = Fcons (make_number (id), charset_list);
+ CHECK_CHARSET_GET_CHARSET (XCAR (restriction), charset);
+ if (ENCODE_CHAR (charset, c) != CHARSET_INVALID_CODE (charset))
+ return XCAR (restriction);
}
- charset_list = Fnreverse (charset_list);
+ return Qnil;
}
- else
- charset_list = coding_system_charset_list (restriction);
- charset = char_charset (XINT (ch), charset_list, NULL);
+ restriction = coding_system_charset_list (restriction);
+ charset = char_charset (XINT (ch), restriction, NULL);
if (! charset)
return Qnil;
}
Return charset of a character in the current buffer at position POS.
If POS is nil, it defauls to the current point.
If POS is out of range, the value is nil. */)
- (pos)
- Lisp_Object pos;
+ (Lisp_Object pos)
{
Lisp_Object ch;
struct charset *charset;
whereas Emacs distinguishes them by charset symbol.
See the documentation of the function `charset-info' for the meanings of
DIMENSION, CHARS, and FINAL-CHAR. */)
- (dimension, chars, final_char)
- Lisp_Object dimension, chars, final_char;
+ (Lisp_Object dimension, Lisp_Object chars, Lisp_Object final_char)
{
int id;
int chars_flag;
Internal use only.
Clear temporary charset mapping tables.
It should be called only from temacs invoked for dumping. */)
- ()
+ (void)
{
if (temp_charset_work)
{
Scharset_priority_list, 0, 1, 0,
doc: /* Return the list of charsets ordered by priority.
HIGHESTP non-nil means just return the highest priority one. */)
- (highestp)
- Lisp_Object highestp;
+ (Lisp_Object highestp)
{
Lisp_Object val = Qnil, list = Vcharset_ordered_list;
1, MANY, 0,
doc: /* Assign higher priority to the charsets given as arguments.
usage: (set-charset-priority &rest charsets) */)
- (nargs, args)
- int nargs;
- Lisp_Object *args;
+ (int nargs, Lisp_Object *args)
{
Lisp_Object new_head, old_list, arglist[2];
Lisp_Object list_2022, list_emacs_mule;
0, 1, 0,
doc: /* Internal use only.
Return charset identification number of CHARSET. */)
- (charset)
- Lisp_Object charset;
+ (Lisp_Object charset)
{
int id;
return make_number (id);
}
+struct charset_sort_data
+{
+ Lisp_Object charset;
+ int id;
+ int priority;
+};
+
+static int
+charset_compare (const void *d1, const void *d2)
+{
+ const struct charset_sort_data *data1 = d1, *data2 = d2;
+ return (data1->priority - data2->priority);
+}
+
+DEFUN ("sort-charsets", Fsort_charsets, Ssort_charsets, 1, 1, 0,
+ doc: /* Sort charset list CHARSETS by a priority of each charset.
+Return the sorted list. CHARSETS is modified by side effects.
+See also `charset-priority-list' and `set-charset-priority'. */)
+ (Lisp_Object charsets)
+{
+ Lisp_Object len = Flength (charsets);
+ int n = XFASTINT (len), i, j, done;
+ Lisp_Object tail, elt, attrs;
+ struct charset_sort_data *sort_data;
+ int id, min_id, max_id;
+ USE_SAFE_ALLOCA;
+
+ if (n == 0)
+ return Qnil;
+ SAFE_ALLOCA (sort_data, struct charset_sort_data *, sizeof (*sort_data) * n);
+ for (tail = charsets, i = 0; CONSP (tail); tail = XCDR (tail), i++)
+ {
+ elt = XCAR (tail);
+ CHECK_CHARSET_GET_ATTR (elt, attrs);
+ sort_data[i].charset = elt;
+ sort_data[i].id = id = XINT (CHARSET_ATTR_ID (attrs));
+ if (i == 0)
+ min_id = max_id = id;
+ else if (id < min_id)
+ min_id = id;
+ else if (id > max_id)
+ max_id = id;
+ }
+ for (done = 0, tail = Vcharset_ordered_list, i = 0;
+ done < n && CONSP (tail); tail = XCDR (tail), i++)
+ {
+ elt = XCAR (tail);
+ id = XFASTINT (elt);
+ if (id >= min_id && id <= max_id)
+ for (j = 0; j < n; j++)
+ if (sort_data[j].id == id)
+ {
+ sort_data[j].priority = i;
+ done++;
+ }
+ }
+ qsort (sort_data, n, sizeof *sort_data, charset_compare);
+ for (i = 0, tail = charsets; CONSP (tail); tail = XCDR (tail), i++)
+ XSETCAR (tail, sort_data[i].charset);
+ SAFE_FREE ();
+ return charsets;
+}
+
\f
void
-init_charset ()
+init_charset (void)
{
Lisp_Object tempdir;
tempdir = Fexpand_file_name (build_string ("charsets"), Vdata_directory);
void
-init_charset_once ()
+init_charset_once (void)
{
int i, j, k;
iso_charset_table[i][j][k] = -1;
for (i = 0; i < 256; i++)
- emacs_mule_charset[i] = NULL;
+ emacs_mule_charset[i] = -1;
charset_jisx0201_roman = -1;
charset_jisx0208_1978 = -1;
charset_jisx0208 = -1;
charset_ksc5601 = -1;
-
- for (i = 0; i < 128; i++)
- unibyte_to_multibyte_table[i] = i;
- for (; i < 256; i++)
- unibyte_to_multibyte_table[i] = BYTE8_TO_CHAR (i);
}
#ifdef emacs
void
-syms_of_charset ()
+syms_of_charset (void)
{
DEFSYM (Qcharsetp, "charsetp");
Vemacs_mule_charset_list = Qnil;
/* Don't staticpro them here. It's done in syms_of_fns. */
- QCtest = intern (":test");
- Qeq = intern ("eq");
+ QCtest = intern_c_string (":test");
+ Qeq = intern_c_string ("eq");
staticpro (&Vcharset_hash_table);
{
defsubr (&Scharset_priority_list);
defsubr (&Sset_charset_priority);
defsubr (&Scharset_id_internal);
+ defsubr (&Ssort_charsets);
- DEFVAR_LISP ("charset-map-path", &Vcharset_map_path,
+ DEFVAR_LISP ("charset-map-path", Vcharset_map_path,
doc: /* *List of directories to search for charset map files. */);
Vcharset_map_path = Qnil;
- DEFVAR_BOOL ("inhibit-load-charset-map", &inhibit_load_charset_map,
+ DEFVAR_BOOL ("inhibit-load-charset-map", inhibit_load_charset_map,
doc: /* Inhibit loading of charset maps. Used when dumping Emacs. */);
inhibit_load_charset_map = 0;
- DEFVAR_LISP ("charset-list", &Vcharset_list,
+ DEFVAR_LISP ("charset-list", Vcharset_list,
doc: /* List of all charsets ever defined. */);
Vcharset_list = Qnil;
- DEFVAR_LISP ("current-iso639-language", &Vcurrent_iso639_language,
+ DEFVAR_LISP ("current-iso639-language", Vcurrent_iso639_language,
doc: /* ISO639 language mnemonic symbol for the current language environment.
If the current language environment is for multiple languages (e.g. "Latin-1"),
the value may be a list of mnemonics. */);
#endif /* emacs */
-/* arch-tag: 66a89b8d-4c28-47d3-9ca1-56f78440d69f
- (do not change this comment) */
HCoop / bpt / emacs.git / blobdiff