[bpt/emacs.git] / src / charset.h

/* Header for charset handler.
   Copyright (C) 1995, 1997, 1998 Electrotechnical Laboratory, JAPAN.
   Licensed to the Free Software Foundation.
   Copyright (C) 2001 Free Software Foundation, Inc.
   Copyright (C) 2001, 2002
     National Institute of Advanced Industrial Science and Technology (AIST)
     Registration Number H13PRO009

This file is part of GNU Emacs.

GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING.  If not, write to
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.  */

#ifndef EMACS_CHARSET_H
#define EMACS_CHARSET_H

/* Index to arguments of Fdefine_charset_internal.  */

enum define_charset_arg_index
  {
    charset_arg_name,
    charset_arg_dimension,
    charset_arg_code_space,
    charset_arg_iso_final,
    charset_arg_iso_revision,
    charset_arg_emacs_mule_id,
    charset_arg_ascii_compatible_p,
    charset_arg_supplementary_p,
    charset_arg_invalid_code,
    charset_arg_code_offset,
    charset_arg_map,
    charset_arg_parents,
    charset_arg_unify_map,
    charset_arg_plist,
    charset_arg_max
  };


/* Indices to charset attributes vector.  */

enum charset_attr_index
  {
    /* ID number of the charset.  */
    charset_id,

    /* Name of the charset (symbol).  */
    charset_name,

    /* Property list of the charset.  */
    charset_plist,

    /* If the method of the charset is `MAP_DEFERRED', the value is a
       mapping vector or a file name that contains mapping vector.
       Otherwise, nil.  */
    charset_map,

    /* If the method of the charset is `MAP', the value is a vector
       that maps code points of the charset to characters.  The vector
       is indexed by a character index.  A character index is
       calculated from a code point and the code-space table of the
       charset.  */
    charset_decoder,

    /* If the method of the charset is `MAP', the value is a
       char-table that maps characters of the charset to code
       points.  */
    charset_encoder,

    /* If the method of the charset is `INHERIT', the value is a list
       of the form (PARENT-CHARSET-ID .  CODE-OFFSET).  */
    charset_parents,

    /* The value is a mapping vector or a file name that contains
       mapping vector.  This provide how characters in the charset
       should be unified with Unicode.  The value of the member
       `charset_deunifier' is created from this information.  */
    charset_unify_map,

    /* If characters in the charset must be unified Unicode, the value
       is a char table that maps a character code in the charset to
       the corresponding Unicode character.  */
    charset_deunifier,

    /* The length of charset attribute vector.  */
    charset_attr_max
  };

/* Methods for converting code points and characters of charsets.  */

enum charset_method
  {
    /* For a charset of this method, a character code is calculated
       from a character index (which is calculated from a code point)
       simply by adding an offset value.  */
    CHARSET_METHOD_OFFSET,

    /* For a charset of this method, a decoder vector and an encoder
       char-table is used for code point <-> character code
       conversion.  */
    CHARSET_METHOD_MAP,

    /* Same as above but decoder and encoder are loaded from a file on
       demand.  Once loaded, the method is changed to
       CHARSET_METHOD_MAP.  */
    CHARSET_METHOD_MAP_DEFERRED,

    /* A charset of this method inherits characters from the other
       charsets.  */
    CHARSET_METHOD_INHERIT
  };

struct charset
{
  /* Index to charset_table.  */
  int id;

  /* Index to Vcharset_hash_table.  */
  int hash_index;

  /* Dimension of the charset: 1, 2, 3, or 4.  */
  int dimension;

  /* Minimum byte code in each dimension.  */
  int code_space[16];

  /* 1 if there's no gap in code-points.  */
  int code_linear_p;

  /* If the charset is treated as 94-chars in ISO-2022, the value is 0.
     If the charset is treated as 96-chars in ISO-2022, the value is 1.  */
  int iso_chars_96;

  /* ISO final byte of the charset: 48..127.  It may be -1 if the
     charset doesn't conform to ISO-2022.  */
  int iso_final;

  /* ISO revision number of the charset.  */
  int iso_revision;

  /* If the charset is identical to what supported by Emacs 21 and the
     priors, the identification number of the charset used in those
     version.  Otherwise, -1.  */
  int emacs_mule_id;

  /* Nonzero iff the charset is compatible with ASCII.  */
  int ascii_compatible_p;

  /* Nonzero iff the charset is supplementary.  */
  int supplementary_p;

  /* Nonzero iff all the code points are representable by Lisp_Int.  */
  int compact_codes_p;

  /* The method for encoding/decoding characters of the charset.  */
  enum charset_method method;

  /* Mininum and Maximum code points of the charset.  */
  unsigned min_code, max_code;

  /* Mininum and Maximum character codes of the charset.  If the
     charset is compatible with ASCII, min_char is a minimum non-ASCII
     character of the charset.  */
  int min_char, max_char;

  /* The code returned by ENCODE_CHAR if a character is not encodable
     by the charset.  */
  unsigned invalid_code;

  /* If the method of the charset is CHARSET_METHOD_MAP, this is a
     table of bits used to quickly and roughly guess if a character
     belongs to the charset.

     The first 64 elements are 512 bits for characters less than
     0x10000.  Each bit corresponds to 128-character block.  The last
     126 elements are 1008 bits for the greater characters
     (0x10000..0x3FFFFF).  Each bit corresponds to 4096-character
     block.

     If a bit is 1, at least one character in the corresponds block is
     in this charset.  */
  unsigned char fast_map[190];

  /* Offset value to calculate a character code from code-point, and
     visa versa.  */
  int code_offset;

  int unified_p;
};

/* Hash table of charset symbols vs. the correponding attribute
   vectors.  */
extern Lisp_Object Vcharset_hash_table;

/* Table of struct charset.  */
extern struct charset *charset_table;
extern int charset_table_used;

#define CHARSET_FROM_ID(id) (charset_table + (id))

extern Lisp_Object Vcharset_list;
extern Lisp_Object Viso_2022_charset_list;
extern Lisp_Object Vemacs_mule_charset_list;

extern struct charset *emacs_mule_charset[256];


/* Macros to access information about charset.  */

/* Return the attribute vector of charset whose symbol is SYMBOL.  */
#define CHARSET_SYMBOL_ATTRIBUTES(symbol)	\
  Fgethash ((symbol), Vcharset_hash_table, Qnil)

#define CHARSET_ATTR_ID(attrs)		AREF ((attrs), charset_id)
#define CHARSET_ATTR_NAME(attrs)	AREF ((attrs), charset_name)
#define CHARSET_ATTR_PLIST(attrs)	AREF ((attrs), charset_plist)
#define CHARSET_ATTR_MAP(attrs)		AREF ((attrs), charset_map)
#define CHARSET_ATTR_DECODER(attrs)	AREF ((attrs), charset_decoder)
#define CHARSET_ATTR_ENCODER(attrs)	AREF ((attrs), charset_encoder)
#define CHARSET_ATTR_PARENTS(attrs)	AREF ((attrs), charset_parents)
#define CHARSET_ATTR_UNIFY_MAP(attrs)	AREF ((attrs), charset_unify_map)
#define CHARSET_ATTR_DEUNIFIER(attrs)	AREF ((attrs), charset_deunifier)

#define CHARSET_SYMBOL_ID(symbol)	\
  CHARSET_ATTR_ID (CHARSET_SYMBOL_ATTRIBUTES (symbol))

/* Return an index to Vcharset_hash_table of the charset whose symbol
   is SYMBOL.  */
#define CHARSET_SYMBOL_HASH_INDEX(symbol)	\
  hash_lookup (XHASH_TABLE (Vcharset_hash_table), symbol, NULL)

/* Return the attribute vector of CHARSET.  */
#define CHARSET_ATTRIBUTES(charset)	\
  (HASH_VALUE (XHASH_TABLE (Vcharset_hash_table), (charset)->hash_index))

#define CHARSET_ID(charset)		((charset)->id)
#define CHARSET_HASH_INDEX(charset)	((charset)->hash_index)
#define CHARSET_DIMENSION(charset)	((charset)->dimension)
#define CHARSET_CODE_SPACE(charset)	((charset)->code_space)
#define CHARSET_CODE_LINEAR_P(charset)	((charset)->code_linear_p)
#define CHARSET_ISO_CHARS_96(charset)	((charset)->iso_chars_96)
#define CHARSET_ISO_FINAL(charset)	((charset)->iso_final)
#define CHARSET_ISO_PLANE(charset)	((charset)->iso_plane)
#define CHARSET_ISO_REVISION(charset)	((charset)->iso_revision)
#define CHARSET_EMACS_MULE_ID(charset)	((charset)->emacs_mule_id)
#define CHARSET_ASCII_COMPATIBLE_P(charset) ((charset)->ascii_compatible_p)
#define CHARSET_COMPACT_CODES_P(charset) ((charset)->compact_codes_p)
#define CHARSET_METHOD(charset)		((charset)->method)
#define CHARSET_MIN_CODE(charset)	((charset)->min_code)
#define CHARSET_MAX_CODE(charset)	((charset)->max_code)
#define CHARSET_INVALID_CODE(charset)	((charset)->invalid_code)
#define CHARSET_MIN_CHAR(charset)	((charset)->min_char)
#define CHARSET_MAX_CHAR(charset)	((charset)->max_char)
#define CHARSET_CODE_OFFSET(charset)	((charset)->code_offset)
#define CHARSET_UNIFIED_P(charset)	((charset)->unified_p)

#define CHARSET_NAME(charset)		\
  (CHARSET_ATTR_NAME (CHARSET_ATTRIBUTES (charset)))
#define CHARSET_MAP(charset)	\
  (CHARSET_ATTR_MAP (CHARSET_ATTRIBUTES (charset)))
#define CHARSET_DECODER(charset)	\
  (CHARSET_ATTR_DECODER (CHARSET_ATTRIBUTES (charset)))
#define CHARSET_ENCODER(charset)	\
  (CHARSET_ATTR_ENCODER (CHARSET_ATTRIBUTES (charset)))
#define CHARSET_PARENTS(charset)	\
  (CHARSET_ATTR_PARENTS (CHARSET_ATTRIBUTES (charset)))
#define CHARSET_UNIFY_MAP(charset)	\
  (CHARSET_ATTR_UNIFY_MAP (CHARSET_ATTRIBUTES (charset)))
#define CHARSET_DEUNIFIER(charset)	\
  (CHARSET_ATTR_DEUNIFIER (CHARSET_ATTRIBUTES (charset)))


/* Nonzero iff OBJ is a valid charset symbol.  */
#define CHARSETP(obj) (CHARSET_SYMBOL_HASH_INDEX (obj) >= 0)

/* Check if X is a valid charset symbol.  If not, signal an error.  */
#define CHECK_CHARSET(x)					\
  do {								\
    if (! SYMBOLP (x) || CHARSET_SYMBOL_HASH_INDEX (x) < 0)	\
      x = wrong_type_argument (Qcharsetp, (x));			\
  } while (0)


/* Check if X is a valid charset symbol.  If valid, set ID to the id
   number of the charset.  Otherwise, signal an error. */
#define CHECK_CHARSET_GET_ID(x, id)					\
  do {									\
    int idx;								\
									\
    if (! SYMBOLP (x) || (idx = CHARSET_SYMBOL_HASH_INDEX (x)) < 0)	\
      x = wrong_type_argument (Qcharsetp, (x));				\
    id = AREF (HASH_VALUE (XHASH_TABLE (Vcharset_hash_table), idx),	\
	       charset_id);						\
  } while (0)


/* Check if X is a valid charset symbol.  If valid, set ATTR to the
   attr vector of the charset.  Otherwise, signal an error. */
#define CHECK_CHARSET_GET_ATTR(x, attr)				\
  do {									\
    if (!SYMBOLP (x) || NILP (attr = CHARSET_SYMBOL_ATTRIBUTES (x)))	\
      x = wrong_type_argument (Qcharsetp, (x));				\
  } while (0)


#define CHECK_CHARSET_GET_CHARSET(x, charset)	\
  do {						\
    int id;					\
    CHECK_CHARSET_GET_ID (x, id);		\
    charset = CHARSET_FROM_ID (id);		\
  } while (0)


/* Lookup Vcharset_order_list and return the first charset that
   contains the character C.  */
#define CHAR_CHARSET(c) \
  char_charset ((c), Qnil, NULL)

#if 0
/* Char-table of charset-sets.  Each element is a bool vector indexed
   by a charset ID.  */
extern Lisp_Object Vchar_charset_set;

/* Charset-bag of character C.  */
#define CHAR_CHARSET_SET(c) \
  CHAR_TABLE_REF (Vchar_charset_set, c)

/* Check if two characters C1 and C2 belong to the same charset.  */
#define SAME_CHARSET_P(c1, c2)	\
  intersection_p (CHAR_CHARSET_SET (c1), CHAR_CHARSET_SET (c2))

#endif


/* Return a character correponding to the code-point CODE of CHARSET.
   Try some optimization before calling decode_char.  */

#define DECODE_CHAR(charset, code)					\
  ((ASCII_BYTE_P (code) && (charset)->ascii_compatible_p)		\
   ? (code)								\
   : ((code) < (charset)->min_code || (code) > (charset)->max_code)	\
   ? -1									\
   : (charset)->unified_p						\
   ? decode_char ((charset), (code))					\
   : (charset)->method == CHARSET_METHOD_OFFSET				\
   ? ((charset)->code_linear_p						\
      ? (code) - (charset)->min_code + (charset)->code_offset		\
      : decode_char ((charset), (code)))				\
   : (charset)->method == CHARSET_METHOD_MAP				\
   ? ((charset)->code_linear_p						\
      ? XINT (AREF (CHARSET_DECODER (charset),				\
			(code) - (charset)->min_code))			\
      : decode_char ((charset), (code)))				\
   : decode_char ((charset), (code)))


/* Return a code point of CHAR in CHARSET.
   Try some optimization before calling encode_char.  */

#define ENCODE_CHAR(charset, c)						\
  ((ASCII_CHAR_P (c) && (charset)->ascii_compatible_p)			\
   ? (c)								\
   : (charset)->unified_p						\
   ? encode_char ((charset), (c))					\
   : ((c) < (charset)->min_char || (c) > (charset)->max_char)		\
   ? (charset)->invalid_code						\
   : (charset)->method == CHARSET_METHOD_OFFSET				\
   ? ((charset)->code_linear_p						\
      ? (c) - (charset)->code_offset + (charset)->min_code		\
      : encode_char ((charset), (c)))					\
   : (charset)->method == CHARSET_METHOD_MAP				\
   ? ((charset)->compact_codes_p					\
      ? XFASTINT (CHAR_TABLE_REF (CHARSET_ENCODER (charset), (c)))	\
      : encode_char ((charset), (c)))					\
   : encode_char ((charset), (c)))


/* Set to 1 when a charset map is loaded to warn that a buffer text
   and a string data may be relocated.  */
extern int charset_map_loaded;


/* Set CHARSET to the charset highest priority of C, CODE to the
   code-point of C in CHARSET.  */
#define SPLIT_CHAR(c, charset, code)	\
  ((charset) = char_charset ((c), Qnil, &(code)))


#define ISO_MAX_DIMENSION 3
#define ISO_MAX_CHARS 2
#define ISO_MAX_FINAL 0x80	/* only 0x30..0xFF are used */

/* Mapping table from ISO2022's charset (specified by DIMENSION,
   CHARS, and FINAL_CHAR) to Emacs' charset ID.  Should be accessed by
   macro ISO_CHARSET_TABLE (DIMENSION, CHARS, FINAL_CHAR).  */
extern int iso_charset_table[ISO_MAX_DIMENSION][ISO_MAX_CHARS][ISO_MAX_FINAL];

/* A charset of type iso2022 who has DIMENSION, CHARS, and FINAL
   (final character).  */
#define ISO_CHARSET_TABLE(dimension, chars_96, final)	\
  iso_charset_table[(dimension) - 1][(chars_96)][(final)]

/* Nonzero iff the charset who has FAST_MAP may contain C.  */
#define CHARSET_FAST_MAP_REF(c, fast_map)		\
  ((c) < 0x10000					\
   ? fast_map[(c) >> 10] & (1 << (((c) >> 7) & 7))	\
   : fast_map[((c) >> 15) + 62] & (1 << (((c) >> 12) & 7)))

#define CHARSET_FAST_MAP_SET(c, fast_map)			\
  do {								\
    if ((c) < 0x10000)						\
      (fast_map)[(c) >> 10] |= 1 << (((c) >> 7) & 7);		\
    else							\
      (fast_map)[((c) >> 15) + 62] |= 1 << (((c) >> 12) & 7);	\
  } while (0)


/* 1 iff CHARSET may contain the character C.  */
#define CHAR_CHARSET_P(c, charset)					    \
  ((ASCII_CHAR_P (c) && (charset)->ascii_compatible_p)			    \
   || (CHARSET_UNIFIED_P (charset)					    \
       ? encode_char ((charset), (c)) != (charset)->invalid_code	    \
       : (CHARSET_FAST_MAP_REF ((c), (charset)->fast_map)		    \
	  && ((charset)->method == CHARSET_METHOD_OFFSET		    \
	      ? (c) >= (charset)->min_char && (c) <= (charset)->max_char    \
	      : ((charset)->method == CHARSET_METHOD_MAP		    \
		 && (charset)->compact_codes_p)				    \
	      ? (XFASTINT (CHAR_TABLE_REF (CHARSET_ENCODER (charset), (c))) \
		 != (charset)->invalid_code)				    \
	      : encode_char ((charset), (c)) != (charset)->invalid_code))))


extern Lisp_Object Qcharsetp;

extern Lisp_Object Qascii, Qunicode;
extern int charset_ascii, charset_8_bit_control, charset_8_bit_graphic;
extern int charset_iso_8859_1;
extern int charset_primary;

extern struct charset *char_charset P_ ((int, Lisp_Object, unsigned *));
extern Lisp_Object charset_attributes P_ ((int));

extern int decode_char P_ ((struct charset *, unsigned));
extern unsigned encode_char P_ ((struct charset *, int));
extern int string_xstring_p P_ ((Lisp_Object));

EXFUN (Funify_charset, 2);

#endif /* EMACS_CHARSET_H */
Commit	Line	Data
3263d5a2	1	/* Header for charset handler.
4a2f9c6a	2	Copyright (C) 1995, 1997, 1998 Electrotechnical Laboratory, JAPAN.
75c8c592	3	Licensed to the Free Software Foundation.
e06aa1f9	4	Copyright (C) 2001 Free Software Foundation, Inc.
3263d5a2 KH	5	Copyright (C) 2001, 2002
	6	National Institute of Advanced Industrial Science and Technology (AIST)
	7	Registration Number H13PRO009
4ed46869	8
369314dc KH	9	This file is part of GNU Emacs.
	10
	11	GNU Emacs is free software; you can redistribute it and/or modify
	12	it under the terms of the GNU General Public License as published by
	13	the Free Software Foundation; either version 2, or (at your option)
	14	any later version.
4ed46869	15
369314dc KH	16	GNU Emacs is distributed in the hope that it will be useful,
	17	but WITHOUT ANY WARRANTY; without even the implied warranty of
	18	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	19	GNU General Public License for more details.
4ed46869	20
369314dc KH	21	You should have received a copy of the GNU General Public License
	22	along with GNU Emacs; see the file COPYING. If not, write to
	23	the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
	24	Boston, MA 02111-1307, USA. */
4ed46869	25
aa01a892 KH	26	#ifndef EMACS_CHARSET_H
aa01a892 KH	27	#define EMACS_CHARSET_H
4ed46869	28
3263d5a2 KH	29	/* Index to arguments of Fdefine_charset_internal. */
	30
	31	enum define_charset_arg_index
	32	{
	33	charset_arg_name,
	34	charset_arg_dimension,
	35	charset_arg_code_space,
	36	charset_arg_iso_final,
	37	charset_arg_iso_revision,
	38	charset_arg_emacs_mule_id,
	39	charset_arg_ascii_compatible_p,
	40	charset_arg_supplementary_p,
	41	charset_arg_invalid_code,
	42	charset_arg_code_offset,
	43	charset_arg_map,
	44	charset_arg_parents,
	45	charset_arg_unify_map,
	46	charset_arg_plist,
	47	charset_arg_max
	48	};
	49
	50
	51	/* Indices to charset attributes vector. */
	52
	53	enum charset_attr_index
	54	{
	55	/* ID number of the charset. */
	56	charset_id,
4ed46869	57
3263d5a2 KH	58	/* Name of the charset (symbol). */
	59	charset_name,
	60
	61	/* Property list of the charset. */
	62	charset_plist,
	63
	64	/* If the method of the charset is `MAP_DEFERRED', the value is a
3e4abc9e	65	mapping vector or a file name that contains mapping vector.
3263d5a2 KH	66	Otherwise, nil. */
	67	charset_map,
	68
	69	/* If the method of the charset is `MAP', the value is a vector
	70	that maps code points of the charset to characters. The vector
	71	is indexed by a character index. A character index is
	72	calculated from a code point and the code-space table of the
	73	charset. */
	74	charset_decoder,
	75
	76	/* If the method of the charset is `MAP', the value is a
	77	char-table that maps characters of the charset to code
	78	points. */
	79	charset_encoder,
	80
	81	/* If the method of the charset is `INHERIT', the value is a list
	82	of the form (PARENT-CHARSET-ID . CODE-OFFSET). */
	83	charset_parents,
	84
3e4abc9e KH	85	/* The value is a mapping vector or a file name that contains
	86	mapping vector. This provide how characters in the charset
	87	should be unified with Unicode. The value of the member
	88	`charset_deunifier' is created from this information. */
3263d5a2 KH	89	charset_unify_map,
3263d5a2 KH	90
3e4abc9e KH	91	/* If characters in the charset must be unified Unicode, the value
	92	is a char table that maps a character code in the charset to
	93	the corresponding Unicode character. */
3263d5a2 KH	94	charset_deunifier,
	95
	96	/* The length of charset attribute vector. */
	97	charset_attr_max
	98	};
	99
	100	/* Methods for converting code points and characters of charsets. */
	101
	102	enum charset_method
	103	{
	104	/* For a charset of this method, a character code is calculated
	105	from a character index (which is calculated from a code point)
	106	simply by adding an offset value. */
	107	CHARSET_METHOD_OFFSET,
	108
	109	/* For a charset of this method, a decoder vector and an encoder
	110	char-table is used for code point <-> character code
	111	conversion. */
	112	CHARSET_METHOD_MAP,
	113
	114	/* Same as above but decoder and encoder are loaded from a file on
	115	demand. Once loaded, the method is changed to
	116	CHARSET_METHOD_MAP. */
	117	CHARSET_METHOD_MAP_DEFERRED,
	118
	119	/* A charset of this method inherits characters from the other
	120	charsets. */
3e4abc9e	121	CHARSET_METHOD_INHERIT
3263d5a2 KH	122	};
	123
	124	struct charset
	125	{
3e4abc9e	126	/* Index to charset_table. */
3263d5a2 KH	127	int id;
3263d5a2 KH	128
3e4abc9e	129	/* Index to Vcharset_hash_table. */
3263d5a2 KH	130	int hash_index;
	131
	132	/* Dimension of the charset: 1, 2, 3, or 4. */
	133	int dimension;
	134
	135	/* Minimum byte code in each dimension. */
	136	int code_space[16];
	137
	138	/* 1 if there's no gap in code-points. */
	139	int code_linear_p;
	140
	141	/* If the charset is treated as 94-chars in ISO-2022, the value is 0.
	142	If the charset is treated as 96-chars in ISO-2022, the value is 1. */
	143	int iso_chars_96;
	144
3e4abc9e KH	145	/* ISO final byte of the charset: 48..127. It may be -1 if the
3e4abc9e KH	146	charset doesn't conform to ISO-2022. */
3263d5a2 KH	147	int iso_final;
3263d5a2 KH	148
3e4abc9e	149	/* ISO revision number of the charset. */
3263d5a2 KH	150	int iso_revision;
	151
	152	/* If the charset is identical to what supported by Emacs 21 and the
	153	priors, the identification number of the charset used in those
	154	version. Otherwise, -1. */
	155	int emacs_mule_id;
	156
	157	/* Nonzero iff the charset is compatible with ASCII. */
	158	int ascii_compatible_p;
	159
	160	/* Nonzero iff the charset is supplementary. */
	161	int supplementary_p;
	162
	163	/* Nonzero iff all the code points are representable by Lisp_Int. */
	164	int compact_codes_p;
	165
	166	/* The method for encoding/decoding characters of the charset. */
	167	enum charset_method method;
	168
	169	/* Mininum and Maximum code points of the charset. */
	170	unsigned min_code, max_code;
	171
	172	/* Mininum and Maximum character codes of the charset. If the
	173	charset is compatible with ASCII, min_char is a minimum non-ASCII
	174	character of the charset. */
	175	int min_char, max_char;
	176
	177	/* The code returned by ENCODE_CHAR if a character is not encodable
	178	by the charset. */
	179	unsigned invalid_code;
	180
	181	/* If the method of the charset is CHARSET_METHOD_MAP, this is a
	182	table of bits used to quickly and roughly guess if a character
	183	belongs to the charset.
	184
	185	The first 64 elements are 512 bits for characters less than
	186	0x10000. Each bit corresponds to 128-character block. The last
	187	126 elements are 1008 bits for the greater characters
	188	(0x10000..0x3FFFFF). Each bit corresponds to 4096-character
	189	block.
	190
	191	If a bit is 1, at least one character in the corresponds block is
	192	in this charset. */
	193	unsigned char fast_map[190];
	194
	195	/* Offset value to calculate a character code from code-point, and
	196	visa versa. */
	197	int code_offset;
	198
	199	int unified_p;
	200	};
	201
	202	/* Hash table of charset symbols vs. the correponding attribute
	203	vectors. */
	204	extern Lisp_Object Vcharset_hash_table;
	205
	206	/* Table of struct charset. */
	207	extern struct charset *charset_table;
	208	extern int charset_table_used;
	209
	210	#define CHARSET_FROM_ID(id) (charset_table + (id))
	211
	212	extern Lisp_Object Vcharset_list;
	213	extern Lisp_Object Viso_2022_charset_list;
214	extern Lisp_Object Vemacs_mule_charset_list;
215
216	extern struct charset *emacs_mule_charset[256];
217
218
219	/* Macros to access information about charset. */
220
221	/* Return the attribute vector of charset whose symbol is SYMBOL. */
222	#define CHARSET_SYMBOL_ATTRIBUTES(symbol) \
223	Fgethash ((symbol), Vcharset_hash_table, Qnil)
224
225	#define CHARSET_ATTR_ID(attrs) AREF ((attrs), charset_id)
226	#define CHARSET_ATTR_NAME(attrs) AREF ((attrs), charset_name)
227	#define CHARSET_ATTR_PLIST(attrs) AREF ((attrs), charset_plist)
228	#define CHARSET_ATTR_MAP(attrs) AREF ((attrs), charset_map)
229	#define CHARSET_ATTR_DECODER(attrs) AREF ((attrs), charset_decoder)
230	#define CHARSET_ATTR_ENCODER(attrs) AREF ((attrs), charset_encoder)
231	#define CHARSET_ATTR_PARENTS(attrs) AREF ((attrs), charset_parents)
232	#define CHARSET_ATTR_UNIFY_MAP(attrs) AREF ((attrs), charset_unify_map)
233	#define CHARSET_ATTR_DEUNIFIER(attrs) AREF ((attrs), charset_deunifier)
234
235	#define CHARSET_SYMBOL_ID(symbol) \
236	CHARSET_ATTR_ID (CHARSET_SYMBOL_ATTRIBUTES (symbol))
237
238	/* Return an index to Vcharset_hash_table of the charset whose symbol
239	is SYMBOL. */
240	#define CHARSET_SYMBOL_HASH_INDEX(symbol) \
241	hash_lookup (XHASH_TABLE (Vcharset_hash_table), symbol, NULL)
242
243	/* Return the attribute vector of CHARSET. */
244	#define CHARSET_ATTRIBUTES(charset) \
245	(HASH_VALUE (XHASH_TABLE (Vcharset_hash_table), (charset)->hash_index))
246
247	#define CHARSET_ID(charset) ((charset)->id)
248	#define CHARSET_HASH_INDEX(charset) ((charset)->hash_index)
249	#define CHARSET_DIMENSION(charset) ((charset)->dimension)
250	#define CHARSET_CODE_SPACE(charset) ((charset)->code_space)
251	#define CHARSET_CODE_LINEAR_P(charset) ((charset)->code_linear_p)
252	#define CHARSET_ISO_CHARS_96(charset) ((charset)->iso_chars_96)
253	#define CHARSET_ISO_FINAL(charset) ((charset)->iso_final)
254	#define CHARSET_ISO_PLANE(charset) ((charset)->iso_plane)
255	#define CHARSET_ISO_REVISION(charset) ((charset)->iso_revision)
256	#define CHARSET_EMACS_MULE_ID(charset) ((charset)->emacs_mule_id)
257	#define CHARSET_ASCII_COMPATIBLE_P(charset) ((charset)->ascii_compatible_p)
258	#define CHARSET_COMPACT_CODES_P(charset) ((charset)->compact_codes_p)
259	#define CHARSET_METHOD(charset) ((charset)->method)
260	#define CHARSET_MIN_CODE(charset) ((charset)->min_code)
261	#define CHARSET_MAX_CODE(charset) ((charset)->max_code)
262	#define CHARSET_INVALID_CODE(charset) ((charset)->invalid_code)
263	#define CHARSET_MIN_CHAR(charset) ((charset)->min_char)
264	#define CHARSET_MAX_CHAR(charset) ((charset)->max_char)
265	#define CHARSET_CODE_OFFSET(charset) ((charset)->code_offset)
266	#define CHARSET_UNIFIED_P(charset) ((charset)->unified_p)
267
268	#define CHARSET_NAME(charset) \
269	(CHARSET_ATTR_NAME (CHARSET_ATTRIBUTES (charset)))
270	#define CHARSET_MAP(charset) \
271	(CHARSET_ATTR_MAP (CHARSET_ATTRIBUTES (charset)))
272	#define CHARSET_DECODER(charset) \
273	(CHARSET_ATTR_DECODER (CHARSET_ATTRIBUTES (charset)))
274	#define CHARSET_ENCODER(charset) \
275	(CHARSET_ATTR_ENCODER (CHARSET_ATTRIBUTES (charset)))
276	#define CHARSET_PARENTS(charset) \
277	(CHARSET_ATTR_PARENTS (CHARSET_ATTRIBUTES (charset)))
278	#define CHARSET_UNIFY_MAP(charset) \
279	(CHARSET_ATTR_UNIFY_MAP (CHARSET_ATTRIBUTES (charset)))
280	#define CHARSET_DEUNIFIER(charset) \
281	(CHARSET_ATTR_DEUNIFIER (CHARSET_ATTRIBUTES (charset)))
282
283
284	/* Nonzero iff OBJ is a valid charset symbol. */
285	#define CHARSETP(obj) (CHARSET_SYMBOL_HASH_INDEX (obj) >= 0)
286
287	/* Check if X is a valid charset symbol. If not, signal an error. */
288	#define CHECK_CHARSET(x) \
384107f2	289	do { \
3263d5a2 KH	290	if (! SYMBOLP (x) \|\| CHARSET_SYMBOL_HASH_INDEX (x) < 0) \
3263d5a2 KH	291	x = wrong_type_argument (Qcharsetp, (x)); \
384107f2	292	} while (0)
54e15bb9	293
4ed46869	294
3263d5a2 KH	295	/* Check if X is a valid charset symbol. If valid, set ID to the id
	296	number of the charset. Otherwise, signal an error. */
	297	#define CHECK_CHARSET_GET_ID(x, id) \
	298	do { \
	299	int idx; \
	300	\
	301	if (! SYMBOLP (x) \|\| (idx = CHARSET_SYMBOL_HASH_INDEX (x)) < 0) \
	302	x = wrong_type_argument (Qcharsetp, (x)); \
	303	id = AREF (HASH_VALUE (XHASH_TABLE (Vcharset_hash_table), idx), \
	304	charset_id); \
4ed46869 KH	305	} while (0)
4ed46869 KH	306
6e4dc3e1	307
3263d5a2 KH	308	/* Check if X is a valid charset symbol. If valid, set ATTR to the
	309	attr vector of the charset. Otherwise, signal an error. */
	310	#define CHECK_CHARSET_GET_ATTR(x, attr) \
	311	do { \
	312	if (!SYMBOLP (x) \|\| NILP (attr = CHARSET_SYMBOL_ATTRIBUTES (x))) \
	313	x = wrong_type_argument (Qcharsetp, (x)); \
6e4dc3e1 KH	314	} while (0)
6e4dc3e1 KH	315
6e4dc3e1	316
3263d5a2 KH	317	#define CHECK_CHARSET_GET_CHARSET(x, charset) \
	318	do { \
	319	int id; \
	320	CHECK_CHARSET_GET_ID (x, id); \
	321	charset = CHARSET_FROM_ID (id); \
c399b461 RS	322	} while (0)
c399b461 RS	323
c399b461	324
3263d5a2 KH	325	/* Lookup Vcharset_order_list and return the first charset that
	326	contains the character C. */
	327	#define CHAR_CHARSET(c) \
	328	char_charset ((c), Qnil, NULL)
	329
	330	#if 0
	331	/* Char-table of charset-sets. Each element is a bool vector indexed
	332	by a charset ID. */
	333	extern Lisp_Object Vchar_charset_set;
	334
	335	/* Charset-bag of character C. */
	336	#define CHAR_CHARSET_SET(c) \
	337	CHAR_TABLE_REF (Vchar_charset_set, c)
	338
	339	/* Check if two characters C1 and C2 belong to the same charset. */
	340	#define SAME_CHARSET_P(c1, c2) \
	341	intersection_p (CHAR_CHARSET_SET (c1), CHAR_CHARSET_SET (c2))
	342
	343	#endif
	344
	345
	346	/* Return a character correponding to the code-point CODE of CHARSET.
	347	Try some optimization before calling decode_char. */
	348
	349	#define DECODE_CHAR(charset, code) \
	350	((ASCII_BYTE_P (code) && (charset)->ascii_compatible_p) \
	351	? (code) \
	352	: ((code) < (charset)->min_code \|\| (code) > (charset)->max_code) \
	353	? -1 \
	354	: (charset)->unified_p \
	355	? decode_char ((charset), (code)) \
	356	: (charset)->method == CHARSET_METHOD_OFFSET \
	357	? ((charset)->code_linear_p \
	358	? (code) - (charset)->min_code + (charset)->code_offset \
	359	: decode_char ((charset), (code))) \
	360	: (charset)->method == CHARSET_METHOD_MAP \
	361	? ((charset)->code_linear_p \
	362	? XINT (AREF (CHARSET_DECODER (charset), \
	363	(code) - (charset)->min_code)) \
	364	: decode_char ((charset), (code))) \
	365	: decode_char ((charset), (code)))
	366
	367
	368	/* Return a code point of CHAR in CHARSET.
	369	Try some optimization before calling encode_char. */
	370
	371	#define ENCODE_CHAR(charset, c) \
	372	((ASCII_CHAR_P (c) && (charset)->ascii_compatible_p) \
	373	? (c) \
	374	: (charset)->unified_p \
	375	? encode_char ((charset), (c)) \
	376	: ((c) < (charset)->min_char \|\| (c) > (charset)->max_char) \
	377	? (charset)->invalid_code \
	378	: (charset)->method == CHARSET_METHOD_OFFSET \
	379	? ((charset)->code_linear_p \
	380	? (c) - (charset)->code_offset + (charset)->min_code \
	381	: encode_char ((charset), (c))) \
	382	: (charset)->method == CHARSET_METHOD_MAP \
	383	? ((charset)->compact_codes_p \
	384	? XFASTINT (CHAR_TABLE_REF (CHARSET_ENCODER (charset), (c))) \
	385	: encode_char ((charset), (c))) \
	386	: encode_char ((charset), (c)))
	387
	388
389	/* Set to 1 when a charset map is loaded to warn that a buffer text
390	and a string data may be relocated. */
391	extern int charset_map_loaded;
392
393
394	/* Set CHARSET to the charset highest priority of C, CODE to the
395	code-point of C in CHARSET. */
396	#define SPLIT_CHAR(c, charset, code) \
397	((charset) = char_charset ((c), Qnil, &(code)))
398
399
400	#define ISO_MAX_DIMENSION 3
401	#define ISO_MAX_CHARS 2
402	#define ISO_MAX_FINAL 0x80 /* only 0x30..0xFF are used */
403
404	/* Mapping table from ISO2022's charset (specified by DIMENSION,
405	CHARS, and FINAL_CHAR) to Emacs' charset ID. Should be accessed by
406	macro ISO_CHARSET_TABLE (DIMENSION, CHARS, FINAL_CHAR). */
407	extern int iso_charset_table[ISO_MAX_DIMENSION][ISO_MAX_CHARS][ISO_MAX_FINAL];
c399b461	408
3263d5a2 KH	409	/* A charset of type iso2022 who has DIMENSION, CHARS, and FINAL
	410	(final character). */
	411	#define ISO_CHARSET_TABLE(dimension, chars_96, final) \
	412	iso_charset_table[(dimension) - 1][(chars_96)][(final)]
6e4dc3e1	413
3263d5a2 KH	414	/* Nonzero iff the charset who has FAST_MAP may contain C. */
	415	#define CHARSET_FAST_MAP_REF(c, fast_map) \
	416	((c) < 0x10000 \
	417	? fast_map[(c) >> 10] & (1 << (((c) >> 7) & 7)) \
	418	: fast_map[((c) >> 15) + 62] & (1 << (((c) >> 12) & 7)))
6e4dc3e1	419
3263d5a2	420	#define CHARSET_FAST_MAP_SET(c, fast_map) \
384107f2	421	do { \
3263d5a2 KH	422	if ((c) < 0x10000) \
3263d5a2 KH	423	(fast_map)[(c) >> 10] \|= 1 << (((c) >> 7) & 7); \
384107f2	424	else \
3263d5a2	425	(fast_map)[((c) >> 15) + 62] \|= 1 << (((c) >> 12) & 7); \
384107f2 KH	426	} while (0)
384107f2 KH	427
6e4dc3e1	428
6e4dc3e1	429
3263d5a2 KH	430	/* 1 iff CHARSET may contain the character C. */
	431	#define CHAR_CHARSET_P(c, charset) \
	432	((ASCII_CHAR_P (c) && (charset)->ascii_compatible_p) \
	433	\|\| (CHARSET_UNIFIED_P (charset) \
	434	? encode_char ((charset), (c)) != (charset)->invalid_code \
	435	: (CHARSET_FAST_MAP_REF ((c), (charset)->fast_map) \
	436	&& ((charset)->method == CHARSET_METHOD_OFFSET \
	437	? (c) >= (charset)->min_char && (c) <= (charset)->max_char \
	438	: ((charset)->method == CHARSET_METHOD_MAP \
	439	&& (charset)->compact_codes_p) \
	440	? (XFASTINT (CHAR_TABLE_REF (CHARSET_ENCODER (charset), (c))) \
	441	!= (charset)->invalid_code) \
	442	: encode_char ((charset), (c)) != (charset)->invalid_code))))
6e4dc3e1	443
4ed46869	444
3263d5a2 KH	445	extern Lisp_Object Qcharsetp;
	446
	447	extern Lisp_Object Qascii, Qunicode;
	448	extern int charset_ascii, charset_8_bit_control, charset_8_bit_graphic;
	449	extern int charset_iso_8859_1;
	450	extern int charset_primary;
	451
	452	extern struct charset char_charset P_ ((int, Lisp_Object, unsigned ));
	453	extern Lisp_Object charset_attributes P_ ((int));
	454
	455	extern int decode_char P_ ((struct charset *, unsigned));
	456	extern unsigned encode_char P_ ((struct charset *, int));
	457	extern int string_xstring_p P_ ((Lisp_Object));
	458
	459	EXFUN (Funify_charset, 2);
c1f6608b	460
aa01a892	461	#endif /* EMACS_CHARSET_H */