[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_min_code,
    charset_arg_max_code,
    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;

  /* Byte code range of each dimension.  <code_space>[4N] is a mininum
     byte code of the (N+1)th dimension, <code_space>[4N+1] is a
     maximum byte code of the (N+1)th dimension, <code_space>[4N+2] is
     (<code_space>[4N+1] - <code_space>[4N] + 1), <code_space>[4N+3]
     is a number of characters containd in the first to (N+1)th
     dismesions.  We get `char-index' of a `code-point' from this
     information.  */
  int code_space[16];

  /* If B is a byte of Nth dimension of a code-point, the (N-1)th bit
     of code_space_mask[B] is set.  This array is used to quickly
     check if a code-point is in a valid range.  */
  unsigned char *code_space_mask;

  /* 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;

  /* Offset value used by macros CODE_POINT_TO_INDEX and
      INDEX_TO_CODE_POINT. .  */
  unsigned char_index_offset;

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