-/* Multilingual characters handler.
- Ver.1.0
+/* Basic multilingual character support.
+ Copyright (C) 1995, 1997, 1998 Electrotechnical Laboratory, JAPAN.
+ Licensed to the Free Software Foundation.
- Copyright (C) 1995 Free Software Foundation, Inc.
- Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+This file is part of GNU Emacs.
- This program 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 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.
- This program 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.
+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 this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+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. */
/* At first, see the document in `charset.h' to understand the code in
this file. */
#include "buffer.h"
#include "charset.h"
#include "coding.h"
+#include "disptab.h"
#else /* not emacs */
#endif /* emacs */
Lisp_Object Qcharset, Qascii, Qcomposition;
+Lisp_Object Qunknown;
/* Declaration of special leading-codes. */
int leading_code_composition; /* for composite characters */
int charset_big5_1; /* Big5 Level 1 (Chinese Traditional) */
int charset_big5_2; /* Big5 Level 2 (Chinese Traditional) */
+int min_composite_char;
+
Lisp_Object Qcharset_table;
/* A char-table containing information of each character set. */
/* A list of charset symbols ever defined. */
Lisp_Object Vcharset_list;
+/* Vector of translation table ever defined.
+ ID of a translation table is used to index this vector. */
+Lisp_Object Vtranslation_table_vector;
+
+/* A char-table for characters which may invoke auto-filling. */
+Lisp_Object Vauto_fill_chars;
+
+Lisp_Object Qauto_fill_chars;
+
/* Tables used by macros BYTES_BY_CHAR_HEAD and WIDTH_BY_CHAR_HEAD. */
int bytes_by_char_head[256];
int width_by_char_head[256];
CHARS, and FINAL-CHAR) to Emacs' charset. */
int iso_charset_table[2][2][128];
+/* Table of pointers to the structure `cmpchar_info' indexed by
+ CMPCHAR-ID. */
+struct cmpchar_info **cmpchar_table;
+/* The current size of `cmpchar_table'. */
+static int cmpchar_table_size;
+/* Number of the current composite characters. */
+int n_cmpchars;
+
/* Variables used locally in the macro FETCH_MULTIBYTE_CHAR. */
unsigned char *_fetch_multibyte_char_p;
int _fetch_multibyte_char_len;
+/* Offset to add to a non-ASCII value when inserting it. */
+int nonascii_insert_offset;
+
+/* Translation table for converting non-ASCII unibyte characters
+ to multibyte codes, or nil. */
+Lisp_Object Vnonascii_translation_table;
+
+/* List of all possible generic characters. */
+Lisp_Object Vgeneric_character_list;
+
+#define min(X, Y) ((X) < (Y) ? (X) : (Y))
+#define max(X, Y) ((X) > (Y) ? (X) : (Y))
+\f
+void
+invalid_character (c)
+ int c;
+{
+ error ("Invalid character: 0%o, %d, 0x%x", c, c, c);
+}
+
+/* Parse composite character string STR of length LENGTH (>= 2) and
+ set BYTES, CHARSET, C1, and C2 as below.
+
+ It is assumed that *STR is LEADING_CODE_COMPOSITION and the
+ following (LENGTH - 1) bytes satisfy !CHAR_HEAD_P.
+
+ If there is a valid composite character, set CHARSET, C1, and C2 to
+ such values that MAKE_CHAR can make the composite character from
+ them. Otherwise, set CHARSET to CHARSET_COMPOSITION, set C1 to the
+ second byte of the sequence, C2 to -1 so that MAKE_CHAR can make
+ the invalid multibyte character whose string representation is two
+ bytes of STR[0] and STR[1]. In any case, set BYTES to LENGTH.
+
+ This macro should be called only from SPLIT_MULTIBYTE_SEQ. */
+
+#define SPLIT_COMPOSITE_SEQ(str, length, bytes, charset, c1, c2) \
+ do { \
+ int cmpchar_id = str_cmpchar_id ((str), (length)); \
+ \
+ (charset) = CHARSET_COMPOSITION; \
+ (bytes) = (length); \
+ if (cmpchar_id >= 0) \
+ { \
+ (c1) = CHAR_FIELD2 (cmpchar_id); \
+ (c2) = CHAR_FIELD3 (cmpchar_id); \
+ } \
+ else \
+ { \
+ (c1) = (str)[1] & 0x7F; \
+ (c2) = -1; \
+ } \
+ } while (0)
+
+/* Parse non-composite multibyte character string STR of length LENGTH
+ (>= 2) and set BYTES to the length of actual multibyte sequence,
+ CHARSET, C1, and C2 to such values that MAKE_CHAR can make the
+ multibyte character from them.
+
+ It is assumed that *STR is one of base leading codes (excluding
+ LEADING_CODE_COMPOSITION) and the following (LENGTH - 1) bytes
+ satisfy !CHAR_HEAD_P.
+
+ This macro should be called only from SPLIT_MULTIBYTE_SEQ. */
+
+#define SPLIT_CHARACTER_SEQ(str, length, bytes, charset, c1, c2) \
+ do { \
+ (bytes) = 1; \
+ (charset) = (str)[0]; \
+ if ((charset) >= LEADING_CODE_PRIVATE_11 \
+ && (charset) <= LEADING_CODE_PRIVATE_22) \
+ (charset) = (str)[(bytes)++]; \
+ if ((bytes) < (length)) \
+ { \
+ (c1) = (str)[(bytes)++] & 0x7F; \
+ if ((bytes) < (length)) \
+ (c2) = (str)[(bytes)++] & 0x7F; \
+ else \
+ (c2) = -1; \
+ } \
+ else \
+ (c1) = (c2) = -1; \
+ } while (0)
+
+/* Parse string STR of length LENGTH and check if a multibyte
+ characters is at STR. set BYTES to the actual length, CHARSET, C1,
+ C2 to proper values for that character. */
+
+#define SPLIT_MULTIBYTE_SEQ(str, length, bytes, charset, c1, c2) \
+ do { \
+ int i; \
+ if (ASCII_BYTE_P ((str)[0])) \
+ i = 1; \
+ else \
+ for (i = 1; i < (length) && ! CHAR_HEAD_P ((str)[i]); i++); \
+ if (i == 1) \
+ (bytes) = 1, (charset) = CHARSET_ASCII, (c1) = (str)[0] ; \
+ else if ((str)[0] == LEADING_CODE_COMPOSITION) \
+ SPLIT_COMPOSITE_SEQ (str, i, bytes, charset, c1, c2); \
+ else \
+ { \
+ if (i > BYTES_BY_CHAR_HEAD ((str)[0])) \
+ i = BYTES_BY_CHAR_HEAD ((str)[0]); \
+ SPLIT_CHARACTER_SEQ (str, i, bytes, charset, c1, c2); \
+ } \
+ } while (0)
+
+/* 1 if CHARSET, C1, and C2 compose a valid character, else 0. */
+#define CHAR_COMPONENTS_VALID_P(charset, c1, c2) \
+ (CHARSET_DIMENSION (charset) == 1 \
+ ? ((c1) >= 0x20 && (c1) <= 0x7F) \
+ : ((c1) >= 0x20 && (c1) <= 0x7F && (c2) >= 0x20 && (c2) <= 0x7F))
+
/* Set STR a pointer to the multi-byte form of the character C. If C
is not a composite character, the multi-byte form is set in WORKBUF
and STR points WORKBUF. The caller should allocate at least 4-byte
area at WORKBUF in advance. Returns the length of the multi-byte
- form.
+ form. If C is an invalid character, store (C & 0xFF) in WORKBUF[0]
+ and return 1.
Use macro `CHAR_STRING (C, WORKBUF, STR)' instead of calling this
function directly if C can be an ASCII character. */
int c;
unsigned char *workbuf, **str;
{
- int charset;
- unsigned char c1, c2;
+ if (c & CHAR_MODIFIER_MASK) /* This includes the case C is negative. */
+ {
+ /* Multibyte character can't have a modifier bit. */
+ if (! SINGLE_BYTE_CHAR_P ((c & ~CHAR_MODIFIER_MASK)))
+ invalid_character (c);
- if (COMPOSITE_CHAR_P (c))
+ /* For Meta, Shift, and Control modifiers, we need special care. */
+ if (c & CHAR_META)
+ {
+ /* Move the meta bit to the right place for a string. */
+ c = (c & ~CHAR_META) | 0x80;
+ }
+ if (c & CHAR_SHIFT)
+ {
+ /* Shift modifier is valid only with [A-Za-z]. */
+ if ((c & 0377) >= 'A' && (c & 0377) <= 'Z')
+ c &= ~CHAR_SHIFT;
+ else if ((c & 0377) >= 'a' && (c & 0377) <= 'z')
+ c = (c & ~CHAR_SHIFT) - ('a' - 'A');
+ }
+ if (c & CHAR_CTL)
+ {
+ /* Simulate the code in lread.c. */
+ /* Allow `\C- ' and `\C-?'. */
+ if (c == (CHAR_CTL | ' '))
+ c = 0;
+ else if (c == (CHAR_CTL | '?'))
+ c = 127;
+ /* ASCII control chars are made from letters (both cases),
+ as well as the non-letters within 0100...0137. */
+ else if ((c & 0137) >= 0101 && (c & 0137) <= 0132)
+ c &= (037 | (~0177 & ~CHAR_CTL));
+ else if ((c & 0177) >= 0100 && (c & 0177) <= 0137)
+ c &= (037 | (~0177 & ~CHAR_CTL));
+ }
+
+ /* If C still has any modifier bits, it is an invalid character. */
+ if (c & CHAR_MODIFIER_MASK)
+ invalid_character (c);
+
+ *str = workbuf;
+ *workbuf++ = c;
+ }
+ else
{
- int cmpchar_id = COMPOSITE_CHAR_ID (c);
+ int charset, c1, c2;
- if (cmpchar_id < n_cmpchars)
+ SPLIT_NON_ASCII_CHAR (c, charset, c1, c2);
+ if (charset == CHARSET_COMPOSITION)
{
- *str = cmpchar_table[cmpchar_id]->data;
- return cmpchar_table[cmpchar_id]->len;
+ if (c >= MAX_CHAR)
+ invalid_character (c);
+ if (c >= MIN_CHAR_COMPOSITION)
+ {
+ /* Valid composite character. */
+ *str = cmpchar_table[COMPOSITE_CHAR_ID (c)]->data;
+ workbuf = *str + cmpchar_table[COMPOSITE_CHAR_ID (c)]->len;
+ }
+ else
+ {
+ /* Invalid but can have multibyte form. */
+ *str = workbuf;
+ *workbuf++ = LEADING_CODE_COMPOSITION;
+ *workbuf++ = c1 | 0x80;
+ }
}
- else
+ else if (charset > CHARSET_COMPOSITION)
{
*str = workbuf;
- return 0;
+ if (charset >= LEADING_CODE_EXT_11)
+ *workbuf++ = (charset < LEADING_CODE_EXT_12
+ ? LEADING_CODE_PRIVATE_11
+ : (charset < LEADING_CODE_EXT_21
+ ? LEADING_CODE_PRIVATE_12
+ : (charset < LEADING_CODE_EXT_22
+ ? LEADING_CODE_PRIVATE_21
+ : LEADING_CODE_PRIVATE_22)));
+ *workbuf++ = charset;
+ if (c1 > 0 && c1 < 32 || c2 > 0 && c2 < 32)
+ invalid_character (c);
+ if (c1)
+ {
+ *workbuf++ = c1 | 0x80;
+ if (c2 > 0)
+ *workbuf++ = c2 | 0x80;
+ }
}
+ else if (charset == CHARSET_ASCII)
+ *workbuf++= c & 0x7F;
+ else
+ invalid_character (c);
}
- SPLIT_NON_ASCII_CHAR (c, charset, c1, c2);
-
- *str = workbuf;
- *workbuf++ = CHARSET_LEADING_CODE_BASE (charset);
- if (*workbuf = CHARSET_LEADING_CODE_EXT (charset))
- workbuf++;
- *workbuf++ = c1 | 0x80;
- if (c2)
- *workbuf++ = c2 | 0x80;
-
return (workbuf - *str);
}
-/* Return a non-ASCII character of which multi-byte form is at STR of
- length LEN. If ACTUAL_LEN is not NULL, the actual length of the
- character is set to the address ACTUAL_LEN.
+/* Return the non-ASCII character corresponding to multi-byte form at
+ STR of length LEN. If ACTUAL_LEN is not NULL, store the byte
+ length of the multibyte form in *ACTUAL_LEN.
Use macro `STRING_CHAR (STR, LEN)' instead of calling this function
- directly if STR can hold an ASCII character. */
+ directly if you want ot handle ASCII characters as well. */
+int
string_to_non_ascii_char (str, len, actual_len)
- unsigned char *str;
+ const unsigned char *str;
int len, *actual_len;
{
- int charset;
- unsigned char c1, c2;
- register int c;
-
- if (SPLIT_STRING (str, len, charset, c1, c2) == CHARSET_ASCII)
- {
- if (actual_len)
- *actual_len = 1;
- return (int) *str;
- }
-
- c = MAKE_NON_ASCII_CHAR (charset, c1, c2);
+ int c, bytes, charset, c1, c2;
+ SPLIT_MULTIBYTE_SEQ (str, len, bytes, charset, c1, c2);
+ c = MAKE_CHAR (charset, c1, c2);
if (actual_len)
- *actual_len = (charset == CHARSET_COMPOSITION
- ? cmpchar_table[COMPOSITE_CHAR_ID (c)]->len
- : BYTES_BY_CHAR_HEAD (*str));
+ *actual_len = bytes;
return c;
}
-/* Return the length of the multi-byte form at string STR of length LEN. */
+/* Return the length of the multi-byte form at string STR of length LEN.
+ Use the macro MULTIBYTE_FORM_LENGTH instead. */
int
multibyte_form_length (str, len)
- unsigned char *str;
+ const unsigned char *str;
int len;
{
- int charset;
- unsigned char c1, c2;
- register int c;
-
- if (SPLIT_STRING (str, len, charset, c1, c2) == CHARSET_ASCII)
- return 1;
+ int bytes;
- return (charset == CHARSET_COMPOSITION
- ? cmpchar_table[(c1 << 7) | c2]->len
- : BYTES_BY_CHAR_HEAD (*str));
+ PARSE_MULTIBYTE_SEQ (str, len, bytes);
+ return bytes;
}
-/* Check if string STR of length LEN contains valid multi-byte form of
- a character. If valid, charset and position codes of the character
- is set at *CHARSET, *C1, and *C2, and return 0. If not valid,
+/* Check multibyte form at string STR of length LEN and set variables
+ pointed by CHARSET, C1, and C2 to charset and position codes of the
+ character at STR, and return 0. If there's no multibyte character,
return -1. This should be used only in the macro SPLIT_STRING
which checks range of STR in advance. */
+int
split_non_ascii_string (str, len, charset, c1, c2)
- register unsigned char *str, *c1, *c2;
- register int len, *charset;
+ const unsigned char *str;
+ unsigned char *c1, *c2;
+ int len, *charset;
+{
+ register int bytes, cs, code1, code2 = -1;
+
+ SPLIT_MULTIBYTE_SEQ (str, len, bytes, cs, code1, code2);
+ if (cs == CHARSET_ASCII)
+ return -1;
+ *charset = cs;
+ *c1 = code1;
+ *c2 = code2;
+}
+
+/* Return 1 iff character C has valid printable glyph.
+ Use the macro CHAR_PRINTABLE_P instead. */
+int
+char_printable_p (c)
+ int c;
{
- register unsigned int cs = *str++;
+ int charset, c1, c2, chars;
- if (cs == LEADING_CODE_COMPOSITION)
+ if (SINGLE_BYTE_CHAR_P (c))
+ return 1;
+ if (c >= MIN_CHAR_COMPOSITION)
+ return (c < MAX_CHAR);
+
+ SPLIT_NON_ASCII_CHAR (c, charset, c1, c2);
+ if (! CHARSET_DEFINED_P (charset))
+ return 0;
+ if (CHARSET_CHARS (charset) == 94
+ ? c1 <= 32 || c1 >= 127
+ : c1 < 32)
+ return 0;
+ if (CHARSET_DIMENSION (charset) == 2
+ && (CHARSET_CHARS (charset) == 94
+ ? c2 <= 32 || c2 >= 127
+ : c2 < 32))
+ return 0;
+ return 1;
+}
+
+/* Translate character C by translation table TABLE. If C
+ is negative, translate a character specified by CHARSET, C1, and C2
+ (C1 and C2 are code points of the character). If no translation is
+ found in TABLE, return C. */
+int
+translate_char (table, c, charset, c1, c2)
+ Lisp_Object table;
+ int c, charset, c1, c2;
+{
+ Lisp_Object ch;
+ int alt_charset, alt_c1, alt_c2, dimension;
+
+ if (c < 0) c = MAKE_CHAR (charset, c1, c2);
+ if (!CHAR_TABLE_P (table)
+ || (ch = Faref (table, make_number (c)), !NATNUMP (ch)))
+ return c;
+
+ SPLIT_CHAR (XFASTINT (ch), alt_charset, alt_c1, alt_c2);
+ dimension = CHARSET_DIMENSION (alt_charset);
+ if (dimension == 1 && alt_c1 > 0 || dimension == 2 && alt_c2 > 0)
+ /* CH is not a generic character, just return it. */
+ return XFASTINT (ch);
+
+ /* Since CH is a generic character, we must return a specific
+ charater which has the same position codes as C from CH. */
+ if (charset < 0)
+ SPLIT_CHAR (c, charset, c1, c2);
+ if (dimension != CHARSET_DIMENSION (charset))
+ /* We can't make such a character because of dimension mismatch. */
+ return c;
+ return MAKE_CHAR (alt_charset, c1, c2);
+}
+
+/* Convert the unibyte character C to multibyte based on
+ Vnonascii_translation_table or nonascii_insert_offset. If they can't
+ convert C to a valid multibyte character, convert it based on
+ DEFAULT_NONASCII_INSERT_OFFSET which makes C a Latin-1 character. */
+
+int
+unibyte_char_to_multibyte (c)
+ int c;
+{
+ if (c < 0400 && c >= 0200)
{
- int cmpchar_id = str_cmpchar_id (str - 1, len);
+ int c_save = c;
- if (cmpchar_id < 0)
- return -1;
- *charset = cs, *c1 = cmpchar_id >> 7, *c2 = cmpchar_id & 0x7F;
+ if (! NILP (Vnonascii_translation_table))
+ {
+ c = XINT (Faref (Vnonascii_translation_table, make_number (c)));
+ if (c >= 0400 && ! char_valid_p (c, 0))
+ c = c_save + DEFAULT_NONASCII_INSERT_OFFSET;
+ }
+ else if (c >= 0240 && nonascii_insert_offset > 0)
+ {
+ c += nonascii_insert_offset;
+ if (c < 0400 || ! char_valid_p (c, 0))
+ c = c_save + DEFAULT_NONASCII_INSERT_OFFSET;
+ }
+ else if (c >= 0240)
+ c = c_save + DEFAULT_NONASCII_INSERT_OFFSET;
}
- else if ((cs < LEADING_CODE_PRIVATE_11 || (cs = *str++) >= 0xA0)
- && CHARSET_DEFINED_P (cs))
+ return c;
+}
+
+
+/* Convert the multibyte character C to unibyte 8-bit character based
+ on Vnonascii_translation_table or nonascii_insert_offset. If
+ REV_TBL is non-nil, it should be a reverse table of
+ Vnonascii_translation_table, i.e. what given by:
+ Fchar_table_extra_slot (Vnonascii_translation_table, make_number (0)) */
+
+int
+multibyte_char_to_unibyte (c, rev_tbl)
+ int c;
+ Lisp_Object rev_tbl;
+{
+ if (!SINGLE_BYTE_CHAR_P (c))
{
- *charset = cs;
- if (*str < 0xA0)
- return -1;
- *c1 = (*str++) & 0x7F;
- if (CHARSET_DIMENSION (cs) == 2)
+ int c_save = c;
+
+ if (! CHAR_TABLE_P (rev_tbl)
+ && CHAR_TABLE_P (Vnonascii_translation_table))
+ rev_tbl = Fchar_table_extra_slot (Vnonascii_translation_table,
+ make_number (0));
+ if (CHAR_TABLE_P (rev_tbl))
{
- if (*str < 0xA0)
- return -1;
- *c2 = (*str++) & 0x7F;
+ Lisp_Object temp;
+ temp = Faref (rev_tbl, make_number (c));
+ if (INTEGERP (temp))
+ c = XINT (temp);
+ if (c >= 256)
+ c = (c_save & 0177) + 0200;
+ }
+ else
+ {
+ if (nonascii_insert_offset > 0)
+ c -= nonascii_insert_offset;
+ if (c < 128 || c >= 256)
+ c = (c_save & 0177) + 0200;
}
}
- else
- return -1;
- return 0;
+
+ return c;
}
+\f
/* Update the table Vcharset_table with the given arguments (see the
document of `define-charset' for the meaning of each argument).
Several other table contents are also updated. The caller should
int bytes;
unsigned char leading_code_base, leading_code_ext;
- if (NILP (Faref (Vcharset_table, charset_id)))
- Faset (Vcharset_table, charset_id,
- Fmake_vector (make_number (CHARSET_MAX_IDX), Qnil));
+ if (NILP (CHARSET_TABLE_ENTRY (charset)))
+ CHARSET_TABLE_ENTRY (charset)
+ = Fmake_vector (make_number (CHARSET_MAX_IDX), Qnil);
/* Get byte length of multibyte form, base leading-code, and
extended leading-code of the charset. See the comment under the
leading_code_ext = charset;
}
+ if (BYTES_BY_CHAR_HEAD (leading_code_base) != bytes)
+ error ("Invalid dimension for the charset-ID %d", charset);
+
CHARSET_TABLE_INFO (charset, CHARSET_ID_IDX) = charset_id;
CHARSET_TABLE_INFO (charset, CHARSET_BYTES_IDX) = make_number (bytes);
CHARSET_TABLE_INFO (charset, CHARSET_DIMENSION_IDX) = dimension;
is set to nil. */
int i;
- for (i = 0; i < MAX_CHARSET; i++)
+ for (i = 0; i <= MAX_CHARSET; i++)
if (!NILP (CHARSET_TABLE_ENTRY (i)))
{
if (CHARSET_DIMENSION (i) == XINT (dimension)
break;
}
}
- if (i >= MAX_CHARSET)
+ if (i > MAX_CHARSET)
/* No such a charset. */
CHARSET_TABLE_INFO (charset, CHARSET_REVERSE_CHARSET_IDX)
= make_number (-1);
if (charset != CHARSET_ASCII
&& charset < MIN_CHARSET_PRIVATE_DIMENSION1)
{
- /* Update tables bytes_by_char_head and width_by_char_head. */
- bytes_by_char_head[leading_code_base] = bytes;
width_by_char_head[leading_code_base] = XINT (width);
/* Update table emacs_code_class. */
if (width == 1)
from = LEADING_CODE_EXT_21, to = LEADING_CODE_EXT_22;
else
- from = LEADING_CODE_EXT_22, to = LEADING_CODE_EXT_MAX - 1;
+ from = LEADING_CODE_EXT_22, to = LEADING_CODE_EXT_MAX + 1;
}
for (charset = from; charset < to; charset++)
DEFUN ("define-charset", Fdefine_charset, Sdefine_charset, 3, 3, 0,
"Define CHARSET-ID as the identification number of CHARSET with INFO-VECTOR.\n\
-If CHARSET-ID is nil, it is set automatically, which means CHARSET is\n\
+If CHARSET-ID is nil, it is decided automatically, which means CHARSET is\n\
treated as a private charset.\n\
INFO-VECTOR is a vector of the format:\n\
[DIMENSION CHARS WIDTH DIRECTION ISO-FINAL-CHAR ISO-GRAPHIC-PLANE\n\
occupies on the screen: one of 0, 1, and 2.\n\
\n\
DIRECTION (integer) is the rendering direction of characters in the\n\
-charset when rendering. If 0, render from right to left, else\n\
-render from left to right.\n\
+charset when rendering. If 0, render from left to right, else\n\
+render from right to left.\n\
\n\
ISO-FINAL-CHAR (character) is the final character of the\n\
corresponding ISO 2022 charset.\n\
update_charset_table (charset_id, vec[0], vec[1], vec[2], vec[3],
vec[4], vec[5], vec[6], vec[7], vec[8]);
- Fput (charset_symbol, Qcharset, Faref (Vcharset_table, charset_id));
+ Fput (charset_symbol, Qcharset, CHARSET_TABLE_ENTRY (XINT (charset_id)));
CHARSET_SYMBOL (XINT (charset_id)) = charset_symbol;
Vcharset_list = Fcons (charset_symbol, Vcharset_list);
return Qnil;
}
+DEFUN ("generic-character-list", Fgeneric_character_list,
+ Sgeneric_character_list, 0, 0, 0,
+ "Return a list of all possible generic characters.\n\
+It includes a generic character for a charset not yet defined.")
+ ()
+{
+ return Vgeneric_character_list;
+}
+
+DEFUN ("get-unused-iso-final-char", Fget_unused_iso_final_char,
+ Sget_unused_iso_final_char, 2, 2, 0,
+ "Return an unsed ISO's final char for a charset of DIMENISION and CHARS.\n\
+DIMENSION is the number of bytes to represent a character: 1 or 2.\n\
+CHARS is the number of characters in a dimension: 94 or 96.\n\
+\n\
+This final char is for private use, thus the range is `0' (48) .. `?' (63).\n\
+If there's no unused final char for the specified kind of charset,\n\
+return nil.")
+ (dimension, chars)
+ Lisp_Object dimension, chars;
+{
+ int final_char;
+
+ CHECK_NUMBER (dimension, 0);
+ CHECK_NUMBER (chars, 1);
+ if (XINT (dimension) != 1 && XINT (dimension) != 2)
+ error ("Invalid charset dimension %d, it should be 1 or 2",
+ XINT (dimension));
+ if (XINT (chars) != 94 && XINT (chars) != 96)
+ error ("Invalid charset chars %d, it should be 94 or 96",
+ XINT (chars));
+ for (final_char = '0'; final_char <= '?'; final_char++)
+ {
+ if (ISO_CHARSET_TABLE (dimension, chars, make_number (final_char)) < 0)
+ break;
+ }
+ return (final_char <= '?' ? make_number (final_char) : Qnil);
+}
+
DEFUN ("declare-equiv-charset", Fdeclare_equiv_charset, Sdeclare_equiv_charset,
4, 4, 0,
"Declare a charset of DIMENSION, CHARS, FINAL-CHAR is the same as CHARSET.\n\
/* Return number of different charsets in STR of length LEN. In
addition, for each found charset N, CHARSETS[N] is set 1. The
- caller should allocate CHARSETS (MAX_CHARSET bytes) in advance. */
+ caller should allocate CHARSETS (MAX_CHARSET + 1 elements) in advance.
+ It may lookup a translation table TABLE if supplied.
+
+ If CMPCHARP is nonzero and some composite character is found,
+ CHARSETS[128] is also set 1 and the returned number is incremented
+ by 1.
+
+ If MULTIBYTE is zero, do not check multibyte characters, i.e. if
+ any ASCII codes (7-bit) are found, CHARSET[0] is set to 1, if any
+ 8-bit codes are found CHARSET[1] is set to 1. */
int
-find_charset_in_str (str, len, charsets)
- unsigned char *str, *charsets;
- int len;
+find_charset_in_str (str, len, charsets, table, cmpcharp, multibyte)
+ unsigned char *str;
+ int len, *charsets;
+ Lisp_Object table;
+ int cmpcharp;
+ int multibyte;
{
- int num = 0;
+ register int num = 0, c;
+
+ if (! multibyte)
+ {
+ unsigned char *endp = str + len;
+ int maskbits = 0;
+
+ while (str < endp && maskbits != 3)
+ maskbits |= (*str++ < 0x80 ? 1 : 2);
+ if (maskbits & 1)
+ {
+ charsets[0] = 1;
+ num++;
+ }
+ if (maskbits & 2)
+ {
+ charsets[1] = 1;
+ num++;
+ }
+ return num;
+ }
+
+ if (! CHAR_TABLE_P (table))
+ table = Qnil;
while (len > 0)
{
- int bytes = BYTES_BY_CHAR_HEAD (*str);
- int charset = CHARSET_AT (str);
+ int bytes, charset;
+ c = *str;
+
+ if (c == LEADING_CODE_COMPOSITION)
+ {
+ int cmpchar_id = str_cmpchar_id (str, len);
+ GLYPH *glyph;
+
+ if (cmpchar_id >= 0)
+ {
+ struct cmpchar_info *cmp_p = cmpchar_table[cmpchar_id];
+ int i;
+
+ for (i = 0; i < cmp_p->glyph_len; i++)
+ {
+ c = cmp_p->glyph[i];
+ if (!NILP (table))
+ {
+ if ((c = translate_char (table, c, 0, 0, 0)) < 0)
+ c = cmp_p->glyph[i];
+ }
+ if ((charset = CHAR_CHARSET (c)) < 0)
+ charset = CHARSET_ASCII;
+ if (!charsets[charset])
+ {
+ charsets[charset] = 1;
+ num += 1;
+ }
+ }
+ str += cmp_p->len;
+ len -= cmp_p->len;
+ if (cmpcharp && !charsets[CHARSET_COMPOSITION])
+ {
+ charsets[CHARSET_COMPOSITION] = 1;
+ num += 1;
+ }
+ continue;
+ }
+
+ charset = 1; /* This leads to `unknown' charset. */
+ bytes = 1;
+ }
+ else
+ {
+ c = STRING_CHAR_AND_LENGTH (str, len, bytes);
+ if (! NILP (table))
+ {
+ int c1 = translate_char (table, c, 0, 0, 0);
+ if (c1 >= 0)
+ c = c1;
+ }
+ charset = CHAR_CHARSET (c);
+ }
if (!charsets[charset])
{
}
DEFUN ("find-charset-region", Ffind_charset_region, Sfind_charset_region,
- 2, 2, 0,
+ 2, 3, 0,
"Return a list of charsets in the region between BEG and END.\n\
-BEG and END are buffer positions.")
- (beg, end)
- Lisp_Object beg, end;
+BEG and END are buffer positions.\n\
+If the region contains any composite character,\n\
+`composition' is included in the returned list.\n\
+Optional arg TABLE if non-nil is a translation table to look up.\n\
+\n\
+If the region contains invalid multiybte characters,\n\
+`unknown' is included in the returned list.\n\
+\n\
+If the current buffer is unibyte, the returned list contains\n\
+`ascii' if any 7-bit characters are found,\n\
+and `unknown' if any 8-bit characters are found.")
+ (beg, end, table)
+ Lisp_Object beg, end, table;
{
- char charsets[MAX_CHARSET];
- int from, to, stop, i;
+ int charsets[MAX_CHARSET + 1];
+ int from, from_byte, to, stop, stop_byte, i;
Lisp_Object val;
+ int undefined;
+ int multibyte = !NILP (current_buffer->enable_multibyte_characters);
validate_region (&beg, &end);
from = XFASTINT (beg);
stop = to = XFASTINT (end);
+
if (from < GPT && GPT < to)
- stop = GPT;
- bzero (charsets, MAX_CHARSET);
+ {
+ stop = GPT;
+ stop_byte = GPT_BYTE;
+ }
+ else
+ stop_byte = CHAR_TO_BYTE (stop);
+
+ from_byte = CHAR_TO_BYTE (from);
+
+ bzero (charsets, (MAX_CHARSET + 1) * sizeof (int));
while (1)
{
- find_charset_in_str (POS_ADDR (from), stop - from, charsets);
+ find_charset_in_str (BYTE_POS_ADDR (from_byte), stop_byte - from_byte,
+ charsets, table, 1, multibyte);
if (stop < to)
- from = stop, stop = to;
+ {
+ from = stop, from_byte = stop_byte;
+ stop = to, stop_byte = CHAR_TO_BYTE (stop);
+ }
else
break;
}
+
val = Qnil;
- for (i = MAX_CHARSET - 1; i >= 0; i--)
+ undefined = 0;
+ for (i = (multibyte ? MAX_CHARSET : 1); i >= 0; i--)
if (charsets[i])
- val = Fcons (CHARSET_SYMBOL (i), val);
+ {
+ if (CHARSET_DEFINED_P (i) || i == CHARSET_COMPOSITION)
+ val = Fcons (CHARSET_SYMBOL (i), val);
+ else
+ undefined = 1;
+ }
+ if (undefined)
+ val = Fcons (Qunknown, val);
return val;
}
DEFUN ("find-charset-string", Ffind_charset_string, Sfind_charset_string,
- 1, 1, 0,
- "Return a list of charsets in STR.")
- (str)
- Lisp_Object str;
+ 1, 2, 0,
+ "Return a list of charsets in STR.\n\
+If the string contains any composite characters,\n\
+`composition' is included in the returned list.\n\
+Optional arg TABLE if non-nil is a translation table to look up.\n\
+\n\
+If the region contains invalid multiybte characters,\n\
+`unknown' is included in the returned list.\n\
+\n\
+If STR is unibyte, the returned list contains\n\
+`ascii' if any 7-bit characters are found,\n\
+and `unknown' if any 8-bit characters are found.")
+ (str, table)
+ Lisp_Object str, table;
{
- char charsets[MAX_CHARSET];
+ int charsets[MAX_CHARSET + 1];
int i;
Lisp_Object val;
+ int undefined;
+ int multibyte;
CHECK_STRING (str, 0);
- bzero (charsets, MAX_CHARSET);
- find_charset_in_str (XSTRING (str)->data, XSTRING (str)->size, charsets);
+ multibyte = STRING_MULTIBYTE (str);
+
+ bzero (charsets, (MAX_CHARSET + 1) * sizeof (int));
+ find_charset_in_str (XSTRING (str)->data, STRING_BYTES (XSTRING (str)),
+ charsets, table, 1, multibyte);
val = Qnil;
- for (i = MAX_CHARSET - 1; i >= 0; i--)
+ undefined = 0;
+ for (i = (multibyte ? MAX_CHARSET : 1); i >= 0; i--)
if (charsets[i])
- val = Fcons (CHARSET_SYMBOL (i), val);
+ {
+ if (CHARSET_DEFINED_P (i) || i == CHARSET_COMPOSITION)
+ val = Fcons (CHARSET_SYMBOL (i), val);
+ else
+ undefined = 1;
+ }
+ if (undefined)
+ val = Fcons (Qunknown, val);
return val;
}
\f
DEFUN ("make-char-internal", Fmake_char_internal, Smake_char_internal, 1, 3, 0,
- "Return a character of CHARSET and position-codes CODE1 and CODE2.\n\
-CODE1 and CODE2 are optional, but if you don't supply\n\
- sufficient position-codes, return a generic character which stands for\n\
-all characters or group of characters in the character sets.\n\
-A generic character can be an argument of `modify-syntax-entry' and\n\
-`modify-category-entry'.")
+ "")
(charset, code1, code2)
Lisp_Object charset, code1, code2;
{
+ int charset_id, c1, c2;
+
CHECK_NUMBER (charset, 0);
+ charset_id = XINT (charset);
+ if (!CHARSET_DEFINED_P (charset_id))
+ error ("Invalid charset ID: %d", XINT (charset));
if (NILP (code1))
- XSETFASTINT (code1, 0);
+ c1 = 0;
else
- CHECK_NUMBER (code1, 1);
+ {
+ CHECK_NUMBER (code1, 1);
+ c1 = XINT (code1);
+ }
if (NILP (code2))
- XSETFASTINT (code2, 0);
+ c2 = 0;
else
- CHECK_NUMBER (code2, 2);
-
- if (!CHARSET_DEFINED_P (XINT (charset)))
- error ("Invalid charset: %d", XINT (charset));
+ {
+ CHECK_NUMBER (code2, 2);
+ c2 = XINT (code2);
+ }
- return make_number (MAKE_CHAR (XINT (charset), XINT (code1), XINT (code2)));
+ if (c1 < 0 || c1 > 0xFF || c2 < 0 || c2 > 0xFF)
+ error ("Invalid code points: %d %d", c1, c2);
+ c1 &= 0x7F;
+ c2 &= 0x7F;
+ if (c1 == 0
+ ? c2 != 0
+ : (c2 == 0
+ ? !CHAR_COMPONENTS_VALID_P (charset, c1, 0x20)
+ : !CHAR_COMPONENTS_VALID_P (charset, c1, c2)))
+ error ("Invalid code points: %d %d", c1, c2);
+
+ return make_number (MAKE_CHAR (charset_id, c1, c2));
}
DEFUN ("split-char", Fsplit_char, Ssplit_char, 1, 1, 0,
- "Return list of charset and one or two position-codes of CHAR.")
+ "Return list of charset and one or two position-codes of CHAR.\n\
+If CHAR is invalid as a character code,\n\
+return a list of symbol `unknown' and CHAR.")
(ch)
Lisp_Object ch;
{
Lisp_Object val;
- int charset;
- unsigned char c1, c2;
+ int c, charset, c1, c2;
CHECK_NUMBER (ch, 0);
+ c = XFASTINT (ch);
+ if (!CHAR_VALID_P (c, 1))
+ return Fcons (Qunknown, Fcons (ch, Qnil));
SPLIT_CHAR (XFASTINT (ch), charset, c1, c2);
- return ((charset == CHARSET_COMPOSITION || CHARSET_DIMENSION (charset) == 2)
+ return (c2 >= 0
? Fcons (CHARSET_SYMBOL (charset),
Fcons (make_number (c1), Fcons (make_number (c2), Qnil)))
: Fcons (CHARSET_SYMBOL (charset), Fcons (make_number (c1), Qnil)));
return CHARSET_SYMBOL (CHAR_CHARSET (XINT (ch)));
}
+DEFUN ("charset-after", Fcharset_after, Scharset_after, 0, 1, 0,
+ "Return charset of a character in the current buffer at position POS.\n\
+If POS is nil, it defauls to the current point.\n\
+If POS is out of range, the value is nil.")
+ (pos)
+ Lisp_Object pos;
+{
+ register int pos_byte, bytes, charset, c1, c2;
+ register unsigned char *p;
+
+ if (NILP (pos))
+ pos_byte = PT_BYTE;
+ else if (MARKERP (pos))
+ {
+ pos_byte = marker_byte_position (pos);
+ if (pos_byte < BEGV_BYTE || pos_byte >= ZV_BYTE)
+ return Qnil;
+ }
+ else
+ {
+ CHECK_NUMBER (pos, 0);
+ if (XINT (pos) < BEGV || XINT (pos) >= ZV)
+ return Qnil;
+ pos_byte = CHAR_TO_BYTE (XINT (pos));
+ }
+ p = BYTE_POS_ADDR (pos_byte);
+ if (BASE_LEADING_CODE_P (*p))
+ {
+ SPLIT_MULTIBYTE_SEQ (p, Z_BYTE - pos_byte, bytes, charset, c1, c2);
+ if (charset < 0)
+ charset = 1;
+ }
+ else
+ charset = CHARSET_ASCII;
+
+ return CHARSET_SYMBOL (charset);
+}
+
DEFUN ("iso-charset", Fiso_charset, Siso_charset, 3, 3, 0,
- "Return charset of ISO's specification DIMENSION, CHARS, and FINAL-CHAR.")
+ "Return charset of ISO's specification DIMENSION, CHARS, and FINAL-CHAR.\n\
+\n\
+ISO 2022's designation sequence (escape sequence) distinguishes charsets\n\
+by their DIMENSION, CHARS, and FINAL-CHAR,\n\
+where as Emacs distinguishes them by charset symbol.\n\
+See the documentation of the function `charset-info' for the meanings of\n\
+DIMENSION, CHARS, and FINAL-CHAR.")
(dimension, chars, final_char)
Lisp_Object dimension, chars, final_char;
{
return CHARSET_SYMBOL (charset);
}
+/* If GENERICP is nonzero, return nonzero iff C is a valid normal or
+ generic character. If GENERICP is zero, return nonzero iff C is a
+ valid normal character. Do not call this function directly,
+ instead use macro CHAR_VALID_P. */
+int
+char_valid_p (c, genericp)
+ int c, genericp;
+{
+ int charset, c1, c2;
+
+ if (c < 0)
+ return 0;
+ if (SINGLE_BYTE_CHAR_P (c))
+ return 1;
+ SPLIT_NON_ASCII_CHAR (c, charset, c1, c2);
+ if (charset == CHARSET_COMPOSITION)
+ return ((c >= MIN_CHAR_COMPOSITION
+ && c < MIN_CHAR_COMPOSITION + n_cmpchars)
+ || (genericp && c == GENERIC_COMPOSITION_CHAR));
+ if (genericp)
+ {
+ if (c1)
+ {
+ if (c2 <= 0) c2 = 0x20;
+ }
+ else
+ {
+ if (c2 <= 0) c1 = c2 = 0x20;
+ }
+ }
+ return (CHARSET_DEFINED_P (charset)
+ && CHAR_COMPONENTS_VALID_P (charset, c1, c2));
+}
+
+DEFUN ("char-valid-p", Fchar_valid_p, Schar_valid_p, 1, 2, 0,
+ "Return t if OBJECT is a valid normal character.\n\
+If optional arg GENERICP is non-nil, also return t if OBJECT is\n\
+a valid generic character.")
+ (object, genericp)
+ Lisp_Object object, genericp;
+{
+ if (! NATNUMP (object))
+ return Qnil;
+ return (CHAR_VALID_P (XFASTINT (object), !NILP (genericp)) ? Qt : Qnil);
+}
+
+DEFUN ("unibyte-char-to-multibyte", Funibyte_char_to_multibyte,
+ Sunibyte_char_to_multibyte, 1, 1, 0,
+ "Convert the unibyte character CH to multibyte character.\n\
+The conversion is done based on `nonascii-translation-table' (which see)\n\
+ or `nonascii-insert-offset' (which see).")
+ (ch)
+ Lisp_Object ch;
+{
+ int c;
+
+ CHECK_NUMBER (ch, 0);
+ c = XINT (ch);
+ if (c < 0 || c >= 0400)
+ error ("Invalid unibyte character: %d", c);
+ c = unibyte_char_to_multibyte (c);
+ if (c < 0)
+ error ("Can't convert to multibyte character: %d", XINT (ch));
+ return make_number (c);
+}
+
+DEFUN ("multibyte-char-to-unibyte", Fmultibyte_char_to_unibyte,
+ Smultibyte_char_to_unibyte, 1, 1, 0,
+ "Convert the multibyte character CH to unibyte character.\n\
+The conversion is done based on `nonascii-translation-table' (which see)\n\
+ or `nonascii-insert-offset' (which see).")
+ (ch)
+ Lisp_Object ch;
+{
+ int c;
+
+ CHECK_NUMBER (ch, 0);
+ c = XINT (ch);
+ if (! CHAR_VALID_P (c, 0))
+ error ("Invalid multibyte character: %d", c);
+ c = multibyte_char_to_unibyte (c, Qnil);
+ if (c < 0)
+ error ("Can't convert to unibyte character: %d", XINT (ch));
+ return make_number (c);
+}
+
DEFUN ("char-bytes", Fchar_bytes, Schar_bytes, 1, 1, 0,
- "Return byte length of multi-byte form of CHAR.")
+ "Return 1 regardless of the argument CHAR.\n\
+This is now an obsolete function. We keep it just for backward compatibility.")
(ch)
Lisp_Object ch;
{
Lisp_Object val;
- int bytes;
CHECK_NUMBER (ch, 0);
- if (COMPOSITE_CHAR_P (XFASTINT (ch)))
+ return make_number (1);
+}
+
+/* Return how many bytes C will occupy in a multibyte buffer.
+ Don't call this function directly, instead use macro CHAR_BYTES. */
+int
+char_bytes (c)
+ int c;
+{
+ int bytes;
+
+ if (SINGLE_BYTE_CHAR_P (c) || (c & ~GLYPH_MASK_CHAR))
+ return 1;
+
+ if (COMPOSITE_CHAR_P (c))
{
- unsigned int id = COMPOSITE_CHAR_ID (XFASTINT (ch));
+ unsigned int id = COMPOSITE_CHAR_ID (c);
bytes = (id < n_cmpchars ? cmpchar_table[id]->len : 1);
}
else
{
- int charset = CHAR_CHARSET (XFASTINT (ch));
+ int charset = CHAR_CHARSET (c);
bytes = CHARSET_DEFINED_P (charset) ? CHARSET_BYTES (charset) : 1;
}
- XSETFASTINT (val, bytes);
- return val;
+ return bytes;
}
/* Return the width of character of which multi-byte form starts with
#define ONE_BYTE_CHAR_WIDTH(c) \
(c < 0x20 \
? (c == '\t' \
- ? current_buffer->tab_width \
+ ? XFASTINT (current_buffer->tab_width) \
: (c == '\n' ? 0 : (NILP (current_buffer->ctl_arrow) ? 4 : 2))) \
: (c < 0x7f \
? 1 \
: ((! NILP (current_buffer->enable_multibyte_characters) \
&& BASE_LEADING_CODE_P (c)) \
? WIDTH_BY_CHAR_HEAD (c) \
- : 4)))) \
-
+ : 4))))
DEFUN ("char-width", Fchar_width, Schar_width, 1, 1, 0,
"Return width of CHAR when displayed in the current buffer.\n\
(ch)
Lisp_Object ch;
{
- Lisp_Object val;
+ Lisp_Object val, disp;
int c;
+ struct Lisp_Char_Table *dp = buffer_display_table ();
CHECK_NUMBER (ch, 0);
- c = XFASTINT (ch);
- if (SINGLE_BYTE_CHAR_P (c))
- XSETFASTINT (val, ONE_BYTE_CHAR_WIDTH (c));
+ c = XINT (ch);
+
+ /* Get the way the display table would display it. */
+ disp = dp ? DISP_CHAR_VECTOR (dp, c) : Qnil;
+
+ if (VECTORP (disp))
+ XSETINT (val, XVECTOR (disp)->size);
+ else if (SINGLE_BYTE_CHAR_P (c))
+ XSETINT (val, ONE_BYTE_CHAR_WIDTH (c));
else if (COMPOSITE_CHAR_P (c))
{
int id = COMPOSITE_CHAR_ID (XFASTINT (ch));
- XSETFASTINT (val, (id < n_cmpchars ? cmpchar_table[id]->width : 0));
+ XSETFASTINT (val, (id < n_cmpchars ? cmpchar_table[id]->width : 1));
}
else
{
/* Return width of string STR of length LEN when displayed in the
current buffer. The width is measured by how many columns it
occupies on the screen. */
+
int
strwidth (str, len)
unsigned char *str;
{
unsigned char *endp = str + len;
int width = 0;
+ struct Lisp_Char_Table *dp = buffer_display_table ();
- while (str < endp) {
- if (*str == LEADING_CODE_COMPOSITION)
- {
- int id = str_cmpchar_id (str, endp - str);
+ while (str < endp)
+ {
+ if (*str == LEADING_CODE_COMPOSITION)
+ {
+ int id = str_cmpchar_id (str, endp - str);
- if (id < 0)
- {
- width += 4;
- str++;
- }
- else
- {
- width += cmpchar_table[id]->width;
- str += cmpchar_table[id]->len;
- }
- }
- else
- {
- width += ONE_BYTE_CHAR_WIDTH (*str);
- str += BYTES_BY_CHAR_HEAD (*str);
- }
- }
+ if (id < 0)
+ {
+ width += 4;
+ str++;
+ }
+ else
+ {
+ width += cmpchar_table[id]->width;
+ str += cmpchar_table[id]->len;
+ }
+ }
+ else
+ {
+ Lisp_Object disp;
+ int thislen;
+ int c = STRING_CHAR_AND_LENGTH (str, endp - str, thislen);
+
+ /* Get the way the display table would display it. */
+ if (dp)
+ disp = DISP_CHAR_VECTOR (dp, c);
+ else
+ disp = Qnil;
+
+ if (VECTORP (disp))
+ width += XVECTOR (disp)->size;
+ else
+ width += ONE_BYTE_CHAR_WIDTH (*str);
+
+ str += thislen;
+ }
+ }
return width;
}
DEFUN ("string-width", Fstring_width, Sstring_width, 1, 1, 0,
"Return width of STRING when displayed in the current buffer.\n\
Width is measured by how many columns it occupies on the screen.\n\
-When calculating width of a multi-byte character in STRING,\n\
- only the base leading-code is considered and the validity of\n\
- the following bytes are not checked.")
+When calculating width of a multibyte character in STRING,\n\
+only the base leading-code is considered; the validity of\n\
+the following bytes is not checked.")
(str)
Lisp_Object str;
{
Lisp_Object val;
CHECK_STRING (str, 0);
- XSETFASTINT (val, strwidth (XSTRING (str)->data, XSTRING (str)->size));
+ XSETFASTINT (val, strwidth (XSTRING (str)->data,
+ STRING_BYTES (XSTRING (str))));
return val;
}
CHECK_NUMBER (ch, 0);
charset = CHAR_CHARSET (XFASTINT (ch));
if (!CHARSET_DEFINED_P (charset))
- error ("Invalid character: %d", XINT (ch));
+ invalid_character (XINT (ch));
return CHARSET_TABLE_INFO (charset, CHARSET_DIRECTION_IDX);
}
-DEFUN ("chars-in-string", Fchars_in_string, Schars_in_string, 1, 1, 0,
- "Return number of characters in STRING.")
- (str)
- Lisp_Object str;
+DEFUN ("chars-in-region", Fchars_in_region, Schars_in_region, 2, 2, 0,
+ "Return number of characters between BEG and END.")
+ (beg, end)
+ Lisp_Object beg, end;
{
- Lisp_Object val;
- unsigned char *p, *endp;
- int chars;
+ int from, to;
- CHECK_STRING (str, 0);
+ CHECK_NUMBER_COERCE_MARKER (beg, 0);
+ CHECK_NUMBER_COERCE_MARKER (end, 1);
- p = XSTRING (str)->data; endp = p + XSTRING (str)->size;
- chars = 0;
- while (p < endp)
- {
- if (*p == LEADING_CODE_COMPOSITION)
- {
- p++;
- while (p < endp && ! CHAR_HEAD_P (p)) p++;
- }
- else
- p += BYTES_BY_CHAR_HEAD (*p);
- chars++;
- }
+ from = min (XFASTINT (beg), XFASTINT (end));
+ to = max (XFASTINT (beg), XFASTINT (end));
- XSETFASTINT (val, chars);
- return val;
+ return make_number (to - from);
}
-DEFUN ("char-boundary-p", Fchar_boundary_p, Schar_boundary_p, 1, 1, 0,
- "Return non-nil value if POS is at character boundary of multibyte form.\n\
-The return value is:\n\
- 0 if POS is at an ASCII character or at the end of range,\n\
- 1 if POS is at a head of 2-byte length multi-byte form,\n\
- 2 if POS is at a head of 3-byte length multi-byte form,\n\
- 3 if POS is at a head of 4-byte length multi-byte form,\n\
- 4 if POS is at a head of multi-byte form of a composite character.\n\
-If POS is out of range or not at character boundary, return NIL.")
- (pos)
- Lisp_Object pos;
+/* Return the number of characters in the NBYTES bytes at PTR.
+ This works by looking at the contents and checking for multibyte sequences.
+ However, if the current buffer has enable-multibyte-characters = nil,
+ we treat each byte as a character. */
+
+int
+chars_in_text (ptr, nbytes)
+ unsigned char *ptr;
+ int nbytes;
{
- Lisp_Object val;
- int n;
+ /* current_buffer is null at early stages of Emacs initialization. */
+ if (current_buffer == 0
+ || NILP (current_buffer->enable_multibyte_characters))
+ return nbytes;
- CHECK_NUMBER_COERCE_MARKER (pos, 0);
+ return multibyte_chars_in_text (ptr, nbytes);
+}
- n = XINT (pos);
- if (n < BEGV || n > ZV)
- return Qnil;
+/* Return the number of characters in the NBYTES bytes at PTR.
+ This works by looking at the contents and checking for multibyte sequences.
+ It ignores enable-multibyte-characters. */
- if (n == ZV || NILP (current_buffer->enable_multibyte_characters))
- XSETFASTINT (val, 0);
- else
+int
+multibyte_chars_in_text (ptr, nbytes)
+ unsigned char *ptr;
+ int nbytes;
+{
+ unsigned char *endp;
+ int chars, bytes;
+
+ endp = ptr + nbytes;
+ chars = 0;
+
+ while (ptr < endp)
{
- unsigned char *p = POS_ADDR (n);
-
- if (SINGLE_BYTE_CHAR_P (*p))
- XSETFASTINT (val, 0);
- else if (*p == LEADING_CODE_COMPOSITION)
- XSETFASTINT (val, 4);
- else if (BYTES_BY_CHAR_HEAD (*p) > 1)
- XSETFASTINT (val, BYTES_BY_CHAR_HEAD (*p) - 1);
+ if (BASE_LEADING_CODE_P (*ptr))
+ {
+ PARSE_MULTIBYTE_SEQ (ptr, nbytes, bytes);
+ ptr += bytes;
+ nbytes -= bytes;
+ }
else
- val = Qnil;
+ {
+ ptr++;
+ nbytes--;
+ }
+ chars++;
}
- return val;
+
+ return chars;
}
-DEFUN ("concat-chars", Fconcat_chars, Sconcat_chars, 1, MANY, 0,
+DEFUN ("string", Fstring, Sstring, 1, MANY, 0,
"Concatenate all the argument characters and make the result a string.")
- (nargs, args)
- int nargs;
+ (n, args)
+ int n;
Lisp_Object *args;
{
- int i, n = XINT (nargs);
+ int i;
unsigned char *buf
- = (unsigned char *) malloc (MAX_LENGTH_OF_MULTI_BYTE_FORM * n);
+ = (unsigned char *) alloca (MAX_LENGTH_OF_MULTI_BYTE_FORM * n);
unsigned char *p = buf;
Lisp_Object val;
unsigned char *str;
if (!INTEGERP (args[i]))
- {
- free (buf);
- CHECK_NUMBER (args[i], 0);
- }
+ CHECK_NUMBER (args[i], 0);
c = XINT (args[i]);
len = CHAR_STRING (c, p, str);
if (p != str)
p += len;
}
+ /* Here, we can't use make_string_from_bytes because of byte
+ combining problem. */
val = make_string (buf, p - buf);
- free (buf);
return val;
}
}
#endif
-/* Table of pointers to the structure `cmpchar_info' indexed by
- CMPCHAR-ID. */
-struct cmpchar_info **cmpchar_table;
-/* The current size of `cmpchar_table'. */
-static int cmpchar_table_size;
-/* Number of the current composite characters. */
-int n_cmpchars;
-
#define CMPCHAR_HASH_TABLE_SIZE 0xFFF
static int *cmpchar_hash_table[CMPCHAR_HASH_TABLE_SIZE];
is the sole function for assigning CMPCHAR-ID. */
int
str_cmpchar_id (str, len)
- unsigned char *str;
+ const unsigned char *str;
int len;
{
int hash_idx, *hashp;
int i;
struct cmpchar_info *cmpcharp;
- if (len < 5)
- /* Any composite char have at least 3-byte length. */
- return -1;
-
- /* The second byte 0xFF means compostion rule is embedded. */
+ /* The second byte 0xFF means COMPOSITION rule is embedded. */
embedded_rule = (str[1] == 0xFF);
/* At first, get the actual length of the composite character. */
{
- unsigned char *p, *endp = str + 1, *lastp = str + len;
+ const unsigned char *p, *endp = str + 1, *lastp = str + len;
int bytes;
- while (endp < lastp && ! CHAR_HEAD_P (endp)) endp++;
+ while (endp < lastp && ! CHAR_HEAD_P (*endp)) endp++;
+ if (endp - str < 5)
+ /* Any composite char have at least 5-byte length. */
+ return -1;
+
chars = 0;
- p = str + 1 + embedded_rule;
+ p = str + 1;
while (p < endp)
{
+ if (embedded_rule)
+ {
+ p++;
+ if (p >= endp)
+ return -1;
+ }
/* No need of checking if *P is 0xA0 because
- BYTES_BY_CHAR_HEAD (0x80) surely returns 2. */
- p += (bytes = BYTES_BY_CHAR_HEAD (*p - 0x20) + embedded_rule);
+ BYTES_BY_CHAR_HEAD (0x80) surely returns 2. */
+ p += BYTES_BY_CHAR_HEAD (*p - 0x20);
chars++;
}
- len = (p -= embedded_rule) - str;
- if (p > endp)
- len -= - bytes, chars--;
-
- if (chars < 2 || chars > MAX_COMPONENT_COUNT)
- /* Invalid number of components. */
+ if (p > endp || chars < 2 || chars > MAX_COMPONENT_COUNT)
+ /* Invalid components. */
return -1;
+ len = p - str;
}
hash_idx = hash_string (str, len) % CMPCHAR_HASH_TABLE_SIZE;
hashp = cmpchar_hash_table[hash_idx];
}
/* We have to register the composite character in cmpchar_table. */
+ if (n_cmpchars >= (CHAR_FIELD2_MASK | CHAR_FIELD3_MASK))
+ /* No, we have no more room for a new composite character. */
+ return -1;
+
/* Make the entry in hash table. */
if (hashp == NULL)
{
return n_cmpchars++;
}
-/* Return the Nth element of the composite character C. */
+/* Return the Nth element of the composite character C. If NOERROR is
+ nonzero, return 0 on error condition (C is an invalid composite
+ charcter, or N is out of range). */
int
-cmpchar_component (c, n)
- unsigned int c, n;
+cmpchar_component (c, n, noerror)
+ int c, n, noerror;
{
int id = COMPOSITE_CHAR_ID (c);
- if (id >= n_cmpchars /* C is not a valid composite character. */
- || n >= cmpchar_table[id]->glyph_len) /* No such component. */
- return -1;
+ if (id < 0 || id >= n_cmpchars)
+ {
+ /* C is not a valid composite character. */
+ if (noerror) return 0;
+ error ("Invalid composite character: %d", c) ;
+ }
+ if (n >= cmpchar_table[id]->glyph_len)
+ {
+ /* No such component. */
+ if (noerror) return 0;
+ args_out_of_range (make_number (c), make_number (n));
+ }
/* No face data is stored in glyph code. */
return ((int) (cmpchar_table[id]->glyph[n]));
}
DEFUN ("composite-char-component", Fcmpchar_component, Scmpchar_component,
2, 2, 0,
- "Return the IDXth component character of composite character CHARACTER.")
- (character, idx)
- Lisp_Object character, idx;
+ "Return the Nth component character of composite character CHARACTER.")
+ (character, n)
+ Lisp_Object character, n;
{
- int c;
+ int id;
CHECK_NUMBER (character, 0);
- CHECK_NUMBER (idx, 1);
+ CHECK_NUMBER (n, 1);
- if ((c = cmpchar_component (XINT (character), XINT (idx))) < 0)
- args_out_of_range (character, idx);
-
- return make_number (c);
+ return (make_number (cmpchar_component (XINT (character), XINT (n), 0)));
}
DEFUN ("composite-char-composition-rule", Fcmpchar_cmp_rule, Scmpchar_cmp_rule,
2, 2, 0,
- "Return the IDXth composition rule embedded in composite character CHARACTER.
-The returned rule is for composing the IDXth component
-on the (IDX-1)th component. If IDX is 0, the returned value is always 255.")
- (character, idx)
- Lisp_Object character, idx;
+ "Return the Nth composition rule of composite character CHARACTER.\n\
+The returned rule is for composing the Nth component\n\
+on the (N-1)th component.\n\
+If CHARACTER should be composed relatively or N is 0, return 255.")
+ (character, n)
+ Lisp_Object character, n;
{
- int id, i;
+ int id;
CHECK_NUMBER (character, 0);
- CHECK_NUMBER (idx, 1);
+ CHECK_NUMBER (n, 1);
id = COMPOSITE_CHAR_ID (XINT (character));
if (id < 0 || id >= n_cmpchars)
error ("Invalid composite character: %d", XINT (character));
- i = XINT (idx);
- if (i > cmpchar_table[id]->glyph_len)
- args_out_of_range (character, idx);
+ if (XINT (n) < 0 || XINT (n) >= cmpchar_table[id]->glyph_len)
+ args_out_of_range (character, n);
- return make_number (cmpchar_table[id]->cmp_rule[i]);
+ return make_number (cmpchar_table[id]->cmp_rule
+ ? cmpchar_table[id]->cmp_rule[XINT (n)]
+ : 255);
}
DEFUN ("composite-char-composition-rule-p", Fcmpchar_cmp_rule_p,
buf[0] = LEADING_CODE_COMPOSITION;
p = XSTRING (str)->data;
- pend = p + XSTRING (str)->size;
+ pend = p + STRING_BYTES (XSTRING (str));
i = 1;
while (p < pend)
{
- if (*p < 0x20 || *p == 127) /* control code */
+ if (*p < 0x20) /* control code */
error ("Invalid component character: %d", *p);
else if (*p < 0x80) /* ASCII */
{
LEADING_CODE_COMPOSITION, keep the remaining bytes
unchanged. */
p++;
+ if (*p == 255)
+ error ("Can't compose a rule-based composition character");
ptemp = p;
- while (! CHAR_HEAD_P (p)) p++;
+ while (! CHAR_HEAD_P (*p)) p++;
+ if (str_cmpchar_id (ptemp - 1, p - ptemp + 1) < 0)
+ error ("Can't compose an invalid composition character");
if (i + (p - ptemp) >= MAX_LENGTH_OF_MULTI_BYTE_FORM)
error ("Too long string to be composed: %s", XSTRING (str)->data);
bcopy (ptemp, buf + i, p - ptemp);
{
/* Add 0x20 to the base leading-code, keep the remaining
bytes unchanged. */
- len = BYTES_BY_CHAR_HEAD (*p);
+ int c = STRING_CHAR_AND_LENGTH (p, pend - p, len);
+
+ if (len <= 1 || ! CHAR_VALID_P (c, 0))
+ error ("Can't compose an invalid character");
if (i + len >= MAX_LENGTH_OF_MULTI_BYTE_FORM)
error ("Too long string to be composed: %s", XSTRING (str)->data);
bcopy (p, buf + i, len);
/* STR contains only one character, which can't be composed. */
error ("Too short string to be composed: %s", XSTRING (str)->data);
- return make_string (buf, i);
+ return make_string_from_bytes (buf, 1, i);
}
\f
+int
charset_id_internal (charset_name)
char *charset_name;
{
- Lisp_Object val = Fget (intern (charset_name), Qcharset);
+ Lisp_Object val;
+ val= Fget (intern (charset_name), Qcharset);
if (!VECTORP (val))
error ("Charset %s is not defined", charset_name);
return Qnil;
}
+void
init_charset_once ()
{
int i, j, k;
staticpro (&Vcharset_table);
staticpro (&Vcharset_symbol_table);
+ staticpro (&Vgeneric_character_list);
/* This has to be done here, before we call Fmake_char_table. */
Qcharset_table = intern ("charset-table");
Fput (Qcharset_table, Qchar_table_extra_slots, make_number (0));
Vcharset_table = Fmake_char_table (Qcharset_table, Qnil);
- Vcharset_symbol_table = Fmake_vector (make_number (MAX_CHARSET), Qnil);
+ Qunknown = intern ("unknown");
+ staticpro (&Qunknown);
+ Vcharset_symbol_table = Fmake_vector (make_number (MAX_CHARSET + 1),
+ Qunknown);
/* Setup tables. */
for (i = 0; i < 2; i++)
for (i = 0; i < 256; i++)
BYTES_BY_CHAR_HEAD (i) = 1;
+ for (i = MIN_CHARSET_OFFICIAL_DIMENSION1;
+ i <= MAX_CHARSET_OFFICIAL_DIMENSION1; i++)
+ BYTES_BY_CHAR_HEAD (i) = 2;
+ for (i = MIN_CHARSET_OFFICIAL_DIMENSION2;
+ i <= MAX_CHARSET_OFFICIAL_DIMENSION2; i++)
+ BYTES_BY_CHAR_HEAD (i) = 3;
BYTES_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_11) = 3;
BYTES_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_12) = 3;
BYTES_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_21) = 4;
BYTES_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_22) = 4;
- /* The following doesn't reflect the actual bytes, but just to tell
+ /* The followings don't reflect the actual bytes, but just to tell
that it is a start of a multibyte character. */
BYTES_BY_CHAR_HEAD (LEADING_CODE_COMPOSITION) = 2;
+ BYTES_BY_CHAR_HEAD (0x9E) = 2;
+ BYTES_BY_CHAR_HEAD (0x9F) = 2;
for (i = 0; i < 128; i++)
WIDTH_BY_CHAR_HEAD (i) = 1;
WIDTH_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_12) = 2;
WIDTH_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_21) = 1;
WIDTH_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_22) = 2;
+
+ {
+ Lisp_Object val;
+
+ val = Qnil;
+ for (i = 0x81; i < 0x90; i++)
+ val = Fcons (make_number ((i - 0x70) << 7), val);
+ for (; i < 0x9A; i++)
+ val = Fcons (make_number ((i - 0x8F) << 14), val);
+ for (i = 0xA0; i < 0xF0; i++)
+ val = Fcons (make_number ((i - 0x70) << 7), val);
+ for (; i < 0xFF; i++)
+ val = Fcons (make_number ((i - 0xE0) << 14), val);
+ val = Fcons (make_number (GENERIC_COMPOSITION_CHAR), val);
+ Vgeneric_character_list = Fnreverse (val);
+ }
+
+ nonascii_insert_offset = 0;
+ Vnonascii_translation_table = Qnil;
}
#ifdef emacs
+void
syms_of_charset ()
{
Qascii = intern ("ascii");
staticpro (&Qcomposition);
CHARSET_SYMBOL (CHARSET_COMPOSITION) = Qcomposition;
+ Qauto_fill_chars = intern ("auto-fill-chars");
+ staticpro (&Qauto_fill_chars);
+ Fput (Qauto_fill_chars, Qchar_table_extra_slots, make_number (0));
+
defsubr (&Sdefine_charset);
+ defsubr (&Sgeneric_character_list);
+ defsubr (&Sget_unused_iso_final_char);
defsubr (&Sdeclare_equiv_charset);
defsubr (&Sfind_charset_region);
defsubr (&Sfind_charset_string);
defsubr (&Smake_char_internal);
defsubr (&Ssplit_char);
defsubr (&Schar_charset);
+ defsubr (&Scharset_after);
defsubr (&Siso_charset);
+ defsubr (&Schar_valid_p);
+ defsubr (&Sunibyte_char_to_multibyte);
+ defsubr (&Smultibyte_char_to_unibyte);
defsubr (&Schar_bytes);
defsubr (&Schar_width);
defsubr (&Sstring_width);
defsubr (&Schar_direction);
- defsubr (&Schars_in_string);
- defsubr (&Schar_boundary_p);
- defsubr (&Sconcat_chars);
+ defsubr (&Schars_in_region);
+ defsubr (&Sstring);
defsubr (&Scmpcharp);
defsubr (&Scmpchar_component);
defsubr (&Scmpchar_cmp_rule);
"List of charsets ever defined.");
Vcharset_list = Fcons (Qascii, Qnil);
+ DEFVAR_LISP ("translation-table-vector", &Vtranslation_table_vector,
+ "Vector of cons cell of a symbol and translation table ever defined.\n\
+An ID of a translation table is an index of this vector.");
+ Vtranslation_table_vector = Fmake_vector (make_number (16), Qnil);
+
DEFVAR_INT ("leading-code-composition", &leading_code_composition,
"Leading-code of composite characters.");
leading_code_composition = LEADING_CODE_COMPOSITION;
DEFVAR_INT ("leading-code-private-22", &leading_code_private_22,
"Leading-code of private TYPE9Nx9N charset of column-width 2.");
leading_code_private_22 = LEADING_CODE_PRIVATE_22;
+
+ DEFVAR_INT ("nonascii-insert-offset", &nonascii_insert_offset,
+ "Offset for converting non-ASCII unibyte codes 0240...0377 to multibyte.\n\
+This is used for converting unibyte text to multibyte,\n\
+and for inserting character codes specified by number.\n\n\
+This serves to convert a Latin-1 or similar 8-bit character code\n\
+to the corresponding Emacs multibyte character code.\n\
+Typically the value should be (- (make-char CHARSET 0) 128),\n\
+for your choice of character set.\n\
+If `nonascii-translation-table' is non-nil, it overrides this variable.");
+ nonascii_insert_offset = 0;
+
+ DEFVAR_LISP ("nonascii-translation-table", &Vnonascii_translation_table,
+ "Translation table to convert non-ASCII unibyte codes to multibyte.\n\
+This is used for converting unibyte text to multibyte,\n\
+and for inserting character codes specified by number.\n\n\
+Conversion is performed only when multibyte characters are enabled,\n\
+and it serves to convert a Latin-1 or similar 8-bit character code\n\
+to the corresponding Emacs character code.\n\n\
+If this is nil, `nonascii-insert-offset' is used instead.\n\
+See also the docstring of `make-translation-table'.");
+ Vnonascii_translation_table = Qnil;
+
+ DEFVAR_INT ("min-composite-char", &min_composite_char,
+ "Minimum character code of a composite character.");
+ min_composite_char = MIN_CHAR_COMPOSITION;
+
+ DEFVAR_LISP ("auto-fill-chars", &Vauto_fill_chars,
+ "A char-table for characters which invoke auto-filling.\n\
+Such characters has value t in this table.");
+ Vauto_fill_chars = Fmake_char_table (Qauto_fill_chars, Qnil);
+ CHAR_TABLE_SET (Vauto_fill_chars, make_number (' '), Qt);
+ CHAR_TABLE_SET (Vauto_fill_chars, make_number ('\n'), Qt);
}
#endif /* emacs */