X-Git-Url: http://git.hcoop.net/bpt/emacs.git/blobdiff_plain/9d3d8cba5a8430544f433330a0c8b3bc727b0d50..47092217997cdb4cf1af20dd0ba887f0c1f9abed:/src/charset.c diff --git a/src/charset.c b/src/charset.c index 7d8716e134..5812324448 100644 --- a/src/charset.c +++ b/src/charset.c @@ -1,5 +1,5 @@ /* Basic multilingual character support. - Copyright (C) 1995, 1997 Electrotechnical Laboratory, JAPAN. + Copyright (C) 1995, 1997, 1998 Electrotechnical Laboratory, JAPAN. Licensed to the Free Software Foundation. This file is part of GNU Emacs. @@ -22,15 +22,19 @@ Boston, MA 02111-1307, USA. */ /* At first, see the document in `charset.h' to understand the code in this file. */ +#ifdef emacs +#include +#endif + #include #ifdef emacs #include -#include #include "lisp.h" #include "buffer.h" #include "charset.h" +#include "composite.h" #include "coding.h" #include "disptab.h" @@ -40,18 +44,17 @@ Boston, MA 02111-1307, USA. */ #endif /* emacs */ -Lisp_Object Qcharset, Qascii, Qcomposition; +Lisp_Object Qcharset, Qascii, Qeight_bit_control, Qeight_bit_graphic; +Lisp_Object Qunknown; /* Declaration of special leading-codes. */ -int leading_code_composition; /* for composite characters */ int leading_code_private_11; /* for private DIMENSION1 of 1-column */ int leading_code_private_12; /* for private DIMENSION1 of 2-column */ int leading_code_private_21; /* for private DIMENSION2 of 1-column */ int leading_code_private_22; /* for private DIMENSION2 of 2-column */ -/* Declaration of special charsets. */ -int charset_ascii; /* ASCII */ -int charset_composition; /* for a composite character */ +/* Declaration of special charsets. The values are set by + Fsetup_special_charsets. */ int charset_latin_iso8859_1; /* ISO8859-1 (Latin-1) */ int charset_jisx0208_1978; /* JISX0208.1978 (Japanese Kanji old set) */ int charset_jisx0208; /* JISX0208.1983 (Japanese Kanji) */ @@ -72,6 +75,15 @@ Lisp_Object Vcharset_symbol_table; /* 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]; @@ -80,173 +92,269 @@ 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)) -/* 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. If C is an invalid character to have a multi-byte form, +void +invalid_character (c) + int c; +{ + error ("Invalid character: 0%o, %d, 0x%x", c, c, c); +} + +/* Parse string STR of length LENGTH and fetch information of a + character at STR. Set BYTES to the byte length the character + occupies, CHARSET, C1, C2 to proper values of the character. */ + +#define SPLIT_MULTIBYTE_SEQ(str, length, bytes, charset, c1, c2) \ + do { \ + (c1) = *(str); \ + (bytes) = BYTES_BY_CHAR_HEAD (c1); \ + if ((bytes) == 1) \ + (charset) = ASCII_BYTE_P (c1) ? CHARSET_ASCII : CHARSET_8_BIT_GRAPHIC; \ + else if ((bytes) == 2) \ + { \ + if ((c1) == LEADING_CODE_8_BIT_CONTROL) \ + (charset) = CHARSET_8_BIT_CONTROL, (c1) = (str)[1] - 0x20; \ + else \ + (charset) = (c1), (c1) = (str)[1] & 0x7F; \ + } \ + else if ((bytes) == 3) \ + { \ + if ((c1) < LEADING_CODE_PRIVATE_11) \ + (charset) = (c1), (c1) = (str)[1] & 0x7F, (c2) = (str)[2] & 0x7F; \ + else \ + (charset) = (str)[1], (c1) = (str)[2] & 0x7F; \ + } \ + else \ + (charset) = (str)[1], (c1) = (str)[2] & 0x7F, (c2) = (str)[3] & 0x7F; \ + } while (0) + +/* 1 if CHARSET, C1, and C2 compose a valid character, else 0. */ +#define CHAR_COMPONENTS_VALID_P(charset, c1, c2) \ + ((charset) == CHARSET_ASCII \ + ? ((c1) >= 0 && (c1) <= 0x7F) \ + : ((charset) == CHARSET_8_BIT_CONTROL \ + ? ((c1) >= 0x80 && (c1) <= 0x9F) \ + : ((charset) == CHARSET_8_BIT_GRAPHIC \ + ? ((c1) >= 0x80 && (c1) <= 0xFF) \ + : (CHARSET_DIMENSION (charset) == 1 \ + ? ((c1) >= 0x20 && (c1) <= 0x7F) \ + : ((c1) >= 0x20 && (c1) <= 0x7F \ + && (c2) >= 0x20 && (c2) <= 0x7F))))) + +/* Store multi-byte form of the character C in STR. The caller should + allocate at least 4-byte area at STR in advance. Returns the + length of the multi-byte form. If C is an invalid character code, signal an error. - Use macro `CHAR_STRING (C, WORKBUF, STR)' instead of calling this - function directly if C can be an ASCII character. */ + Use macro `CHAR_STRING (C, STR)' instead of calling this function + directly if C can be an ASCII character. */ int -non_ascii_char_to_string (c, workbuf, str) +char_to_string (c, str) int c; - unsigned char *workbuf, **str; + unsigned char *str; { - int charset, c1, c2; + unsigned char *p = str; - if (COMPOSITE_CHAR_P (c)) + if (c & CHAR_MODIFIER_MASK) /* This includes the case C is negative. */ { - int cmpchar_id = COMPOSITE_CHAR_ID (c); + /* Multibyte character can't have a modifier bit. */ + if (! SINGLE_BYTE_CHAR_P ((c & ~CHAR_MODIFIER_MASK))) + invalid_character (c); - if (cmpchar_id < n_cmpchars) + /* 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) { - *str = cmpchar_table[cmpchar_id]->data; - return cmpchar_table[cmpchar_id]->len; + /* 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); + } + if (SINGLE_BYTE_CHAR_P (c)) + { + if (ASCII_BYTE_P (c) || c >= 0xA0) + *p++ = c; else { - error ("Invalid character: %d", c); + *p++ = LEADING_CODE_8_BIT_CONTROL; + *p++ = c + 0x20; + } + } + else if (CHAR_VALID_P (c, 0)) + { + int charset, c1, c2; + + SPLIT_CHAR (c, charset, c1, c2); + + if (charset >= LEADING_CODE_EXT_11) + *p++ = (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))); + *p++ = charset; + if (c1 > 0 && c1 < 32 || c2 > 0 && c2 < 32) + invalid_character (c); + if (c1) + { + *p++ = c1 | 0x80; + if (c2 > 0) + *p++ = c2 | 0x80; } } + else + invalid_character (c); - SPLIT_NON_ASCII_CHAR (c, charset, c1, c2); - if (!charset - || ! CHARSET_DEFINED_P (charset) - || c1 >= 0 && c1 < 32 - || c2 >= 0 && c2 < 32) - error ("Invalid character: %d", c); - - *str = workbuf; - *workbuf++ = CHARSET_LEADING_CODE_BASE (charset); - if (*workbuf = CHARSET_LEADING_CODE_EXT (charset)) - workbuf++; - *workbuf++ = c1 | 0x80; - if (c2 >= 0) - *workbuf++ = c2 | 0x80; - - return (workbuf - *str); + return (p - 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. */ + Use macros STRING_CHAR or STRING_CHAR_AND_LENGTH instead of calling + this function directly if you want ot handle ASCII characters as + well. */ -string_to_non_ascii_char (str, len, actual_len) - unsigned char *str; +int +string_to_char (str, len, actual_len) + 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. */ -split_non_ascii_string (str, len, charset, c1, c2) - register unsigned char *str, *c1, *c2; - register int len, *charset; +int +split_string (str, len, charset, c1, c2) + const unsigned char *str; + unsigned char *c1, *c2; + int len, *charset; { - register unsigned int cs = *str++; + register int bytes, cs, code1, code2 = -1; - if (cs == LEADING_CODE_COMPOSITION) - { - int cmpchar_id = str_cmpchar_id (str - 1, len); - - if (cmpchar_id < 0) - return -1; - *charset = cs, *c1 = cmpchar_id >> 7, *c2 = cmpchar_id & 0x7F; - } - else if ((cs < LEADING_CODE_PRIVATE_11 || (cs = *str++) >= 0xA0) - && CHARSET_DEFINED_P (cs)) - { - *charset = cs; - if (*str < 0xA0) - return -1; - *c1 = (*str++) & 0x7F; - if (CHARSET_DIMENSION (cs) == 2) - { - if (*str < 0xA0) - return -1; - *c2 = (*str++) & 0x7F; - } - } - else + SPLIT_MULTIBYTE_SEQ (str, len, bytes, cs, code1, code2); + if (cs == CHARSET_ASCII) return -1; + *charset = cs; + *c1 = code1; + *c2 = code2; return 0; } -/* Return a character unified with C (or a character made of CHARSET, - C1, and C2) in unification table TABLE. If no unification is found - in TABLE, return C. */ -unify_char (table, c, charset, c1, c2) +/* Return 1 iff character C has valid printable glyph. + Use the macro CHAR_PRINTABLE_P instead. */ +int +char_printable_p (c) + int c; +{ + int charset, c1, c2, chars; + + if (ASCII_BYTE_P (c)) + return 1; + else if (SINGLE_BYTE_CHAR_P (c)) + return 0; + else if (c >= MAX_CHAR) + return 0; + + SPLIT_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 (c < 0) c = MAKE_CHAR (charset, (c1 & 0x7F) , (c2 & 0x7F)); if (!CHAR_TABLE_P (table) - || (ch = Faref (table, make_number (c)), !INTEGERP (ch)) - || XINT (ch) < 0) + || (ch = Faref (table, make_number (c)), !NATNUMP (ch))) return c; SPLIT_CHAR (XFASTINT (ch), alt_charset, alt_c1, alt_c2); @@ -262,11 +370,82 @@ unify_char (table, c, charset, c1, c2) if (dimension != CHARSET_DIMENSION (charset)) /* We can't make such a character because of dimension mismatch. */ return c; - if (!alt_c1) alt_c1 = c1; - if (!alt_c2) alt_c2 = c2; 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 c_save = c; + + 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; + } + 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)) + { + 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)) + { + 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; + } + } + + return c; +} + + /* 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 @@ -289,6 +468,11 @@ update_charset_table (charset_id, dimension, chars, width, direction, CHARSET_TABLE_ENTRY (charset) = Fmake_vector (make_number (CHARSET_MAX_IDX), Qnil); + if (NILP (long_name)) + long_name = short_name; + if (NILP (description)) + description = long_name; + /* Get byte length of multibyte form, base leading-code, and extended leading-code of the charset. See the comment under the title "GENERAL NOTE on CHARACTER SET (CHARSET)" in charset.h. */ @@ -296,7 +480,7 @@ update_charset_table (charset_id, dimension, chars, width, direction, if (charset < MIN_CHARSET_PRIVATE_DIMENSION1) { /* Official charset, it doesn't have an extended leading-code. */ - if (charset != CHARSET_ASCII) + if (charset != CHARSET_ASCII && charset != CHARSET_8_BIT_GRAPHIC) bytes += 1; /* For a base leading-code. */ leading_code_base = charset; leading_code_ext = 0; @@ -314,7 +498,9 @@ update_charset_table (charset_id, dimension, chars, width, direction, ? LEADING_CODE_PRIVATE_21 : LEADING_CODE_PRIVATE_22))); 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); @@ -362,10 +548,9 @@ update_charset_table (charset_id, dimension, chars, width, direction, = make_number (-1); } - if (charset != CHARSET_ASCII + if (charset != CHARSET_ASCII && charset != CHARSET_8_BIT_GRAPHIC && 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); @@ -378,7 +563,8 @@ update_charset_table (charset_id, dimension, chars, width, direction, } /* Update table iso_charset_table. */ - if (ISO_CHARSET_TABLE (dimension, chars, iso_final_char) < 0) + if (XINT (iso_final_char) >= 0 + && ISO_CHARSET_TABLE (dimension, chars, iso_final_char) < 0) ISO_CHARSET_TABLE (dimension, chars, iso_final_char) = charset; } @@ -411,17 +597,13 @@ get_new_private_charset_id (dimension, width) if (dimension == 1) { - if (width == 1) - from = LEADING_CODE_EXT_11, to = LEADING_CODE_EXT_12; - else - from = LEADING_CODE_EXT_12, to = LEADING_CODE_EXT_21; + from = LEADING_CODE_EXT_11; + to = LEADING_CODE_EXT_21; } else { - 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_21; + to = LEADING_CODE_EXT_MAX + 1; } for (charset = from; charset < to; charset++) @@ -444,15 +626,17 @@ WIDTH (integer) is the number of columns a character in the charset\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\ +It may be -1 if the charset is internal use only.\n\ \n\ ISO-GRAPHIC-PLANE (integer) is the graphic plane to be invoked\n\ while encoding to variants of ISO 2022 coding system, one of the\n\ following: 0/graphic-plane-left(GL), 1/graphic-plane-right(GR).\n\ +It may be -1 if the charset is internal use only.\n\ \n\ SHORT-NAME (string) is the short name to refer to the charset.\n\ \n\ @@ -483,8 +667,10 @@ DESCRIPTION (string) is the description string of the charset.") || !INTEGERP (vec[1]) || !(XINT (vec[1]) == 94 || XINT (vec[1]) == 96) || !INTEGERP (vec[2]) || !(XINT (vec[2]) == 1 || XINT (vec[2]) == 2) || !INTEGERP (vec[3]) || !(XINT (vec[3]) == 0 || XINT (vec[3]) == 1) - || !INTEGERP (vec[4]) || !(XINT (vec[4]) >= '0' && XINT (vec[4]) <= '~') - || !INTEGERP (vec[5]) || !(XINT (vec[5]) == 0 || XINT (vec[5]) == 1) + || !INTEGERP (vec[4]) + || !(XINT (vec[4]) == -1 || XINT (vec[4]) >= '0' && XINT (vec[4]) <= '~') + || !INTEGERP (vec[5]) + || !(XINT (vec[5]) == -1 || XINT (vec[5]) == 0 || XINT (vec[5]) == 1) || !STRINGP (vec[6]) || !STRINGP (vec[7]) || !STRINGP (vec[8])) @@ -507,6 +693,45 @@ DESCRIPTION (string) is the description string of the charset.") 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\ @@ -534,117 +759,154 @@ CHARSET should be defined by `defined-charset' in advance.") return Qnil; } -/* 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 + 1 elements) in advance. - It may lookup a unification table TABLE if supplied. */ +/* Return information about charsets in the text at PTR of NBYTES + bytes, which are NCHARS characters. The value is: + + 0: Each character is represented by one byte. This is always + true for unibyte text. + 1: No charsets other than ascii eight-bit-control, + eight-bit-graphic, and latin-1 are found. + 2: Otherwise. + + In addition, if CHARSETS is nonzero, for each found charset N, set + CHARSETS[N] to 1. For that, callers should allocate CHARSETS + (MAX_CHARSET + 1 elements) in advance. It may lookup a translation + table TABLE if supplied. For invalid charsets, set CHARSETS[1] to + 1 (note that there's no charset whose ID is 1). */ int -find_charset_in_str (str, len, charsets, table) - unsigned char *str; - int len, *charsets; +find_charset_in_text (ptr, nchars, nbytes, charsets, table) + unsigned char *ptr; + int nchars, nbytes, *charsets; Lisp_Object table; { - int num = 0; - int cmpcharp = 0; - unsigned char str_work[4], *str_tmp; - - if (! CHAR_TABLE_P (table)) - table = Qnil; - - while (len > 0) + if (nchars == nbytes) { - int bytes, charset; - - if (*str == LEADING_CODE_COMPOSITION) + if (charsets && nbytes > 0) { - str++; - len--; - cmpcharp = 1; - } - else if (CHAR_HEAD_P (str)) - cmpcharp = 0; + unsigned char *endp = ptr + nbytes; + int maskbits = 0; - if (cmpcharp) - { - if (*str == 0xA0) + while (ptr < endp && maskbits != 7) { - str++; - len--; - str_work[0] = *str & 0x7F; - } - else - { - bcopy (str, str_work, min (4, len)); - str_work[0] -= 0x20; - } - str_tmp = str_work; + maskbits |= (*ptr < 0x80 ? 1 : *ptr < 0xA0 ? 2 : 4); + ptr++; + } + + if (maskbits & 1) + charsets[CHARSET_ASCII] = 1; + if (maskbits & 2) + charsets[CHARSET_8_BIT_CONTROL] = 1; + if (maskbits & 4) + charsets[CHARSET_8_BIT_GRAPHIC] = 1; } - else - str_tmp = str; - - bytes = BYTES_BY_CHAR_HEAD (*str_tmp); + return 0; + } + else + { + int return_val = 1; + int bytes, charset, c1, c2; - if (NILP (table)) - charset = CHARSET_AT (str_tmp); - else + if (! CHAR_TABLE_P (table)) + table = Qnil; + + while (nchars-- > 0) { - int c; - unsigned char c1, c2; + SPLIT_MULTIBYTE_SEQ (ptr, len, bytes, charset, c1, c2); + ptr += bytes; - SPLIT_STRING(str_tmp, bytes, charset, c1, c2); - if ((c = unify_char (table, -1, charset, c1, c2)) >= 0) - charset = CHAR_CHARSET (c); - } + if (!CHARSET_DEFINED_P (charset)) + charset = 1; + else if (! NILP (table)) + { + int c = translate_char (table, -1, charset, c1, c2); + if (c >= 0) + charset = CHAR_CHARSET (c); + } - if (!charsets[charset]) - { - charsets[charset] = 1; - num += 1; + if (return_val == 1 + && charset != CHARSET_ASCII + && charset != CHARSET_8_BIT_CONTROL + && charset != CHARSET_8_BIT_GRAPHIC + && charset != charset_latin_iso8859_1) + return_val = 2; + + if (charsets) + charsets[charset] = 1; + else if (return_val == 2) + break; } - str += bytes; - len -= bytes; + return return_val; } - return num; } DEFUN ("find-charset-region", Ffind_charset_region, Sfind_charset_region, 2, 3, 0, "Return a list of charsets in the region between BEG and END.\n\ BEG and END are buffer positions.\n\ -Optional arg TABLE if non-nil is a unification table to look up.") +Optional arg TABLE if non-nil is a translation table to look up.\n\ +\n\ +If the region contains invalid multibyte characters,\n\ +`unknown' is included in the returned list.\n\ +\n\ +If the current buffer is unibyte, the returned list may contain\n\ +only `ascii', `eight-bit-control', and `eight-bit-graphic'.") (beg, end, table) Lisp_Object beg, end, table; { int charsets[MAX_CHARSET + 1]; - int from, to, stop, i; + int from, from_byte, to, stop, stop_byte, i; Lisp_Object val; validate_region (&beg, &end); from = XFASTINT (beg); stop = to = XFASTINT (end); + if (from < GPT && GPT < to) - stop = GPT; + { + 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, table); + find_charset_in_text (BYTE_POS_ADDR (from_byte), stop - from, + stop_byte - from_byte, charsets, table); 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; i >= 0; i--) + if (charsets[1]) + val = Fcons (Qunknown, val); + for (i = MAX_CHARSET; i >= MIN_CHARSET_OFFICIAL_DIMENSION1; i--) if (charsets[i]) val = Fcons (CHARSET_SYMBOL (i), val); + if (charsets[0]) + val = Fcons (Qascii, val); return val; } DEFUN ("find-charset-string", Ffind_charset_string, Sfind_charset_string, 1, 2, 0, "Return a list of charsets in STR.\n\ -Optional arg TABLE if non-nil is a unification table to look up.") +Optional arg TABLE if non-nil is a translation table to look up.\n\ +\n\ +If the string contains invalid multibyte characters,\n\ +`unknown' is included in the returned list.\n\ +\n\ +If STR is unibyte, the returned list may contain\n\ +only `ascii', `eight-bit-control', and `eight-bit-graphic'.") (str, table) Lisp_Object str, table; { @@ -653,47 +915,98 @@ Optional arg TABLE if non-nil is a unification table to look up.") Lisp_Object val; CHECK_STRING (str, 0); + bzero (charsets, (MAX_CHARSET + 1) * sizeof (int)); - find_charset_in_str (XSTRING (str)->data, XSTRING (str)->size, - charsets, table); + find_charset_in_text (XSTRING (str)->data, XSTRING (str)->size, + STRING_BYTES (XSTRING (str)), charsets, table); + val = Qnil; - for (i = MAX_CHARSET; i >= 0; i--) + if (charsets[1]) + val = Fcons (Qunknown, val); + for (i = MAX_CHARSET; i >= MIN_CHARSET_OFFICIAL_DIMENSION1; i--) if (charsets[i]) val = Fcons (CHARSET_SYMBOL (i), val); + if (charsets[0]) + val = Fcons (Qascii, val); return val; } + DEFUN ("make-char-internal", Fmake_char_internal, Smake_char_internal, 1, 3, 0, "") (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 (charset_id == CHARSET_ASCII) + { + if (c1 < 0 || c1 > 0x7F) + goto invalid_code_posints; + return make_number (c1); + } + else if (charset_id == CHARSET_8_BIT_CONTROL) + { + if (c1 < 0x80 || c1 > 0x9F) + goto invalid_code_posints; + return make_number (c1); + } + else if (charset_id == CHARSET_8_BIT_GRAPHIC) + { + if (c1 < 0xA0 || c1 > 0xFF) + goto invalid_code_posints; + return make_number (c1); + } + else if (c1 < 0 || c1 > 0xFF || c2 < 0 || c2 > 0xFF) + goto invalid_code_posints; + c1 &= 0x7F; + c2 &= 0x7F; + if (c1 == 0 + ? c2 != 0 + : (c2 == 0 + ? !CHAR_COMPONENTS_VALID_P (charset_id, c1, 0x20) + : !CHAR_COMPONENTS_VALID_P (charset_id, c1, c2))) + goto invalid_code_posints; + return make_number (MAKE_CHAR (charset_id, c1, c2)); + + invalid_code_posints: + error ("Invalid code points for charset ID %d: %d %d", 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, 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 (c2 >= 0 ? Fcons (CHARSET_SYMBOL (charset), @@ -711,8 +1024,31 @@ DEFUN ("char-charset", Fchar_charset, Schar_charset, 1, 1, 0, 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; +{ + Lisp_Object ch; + int charset; + + ch = Fchar_after (pos); + if (! INTEGERP (ch)) + return ch; + charset = CHAR_CHARSET (XINT (ch)); + 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; { @@ -737,25 +1073,29 @@ char_valid_p (c, genericp) { int charset, c1, c2; - if (c < 0) + if (c < 0 || c >= MAX_CHAR) return 0; if (SINGLE_BYTE_CHAR_P (c)) return 1; - SPLIT_NON_ASCII_CHAR (c, charset, c1, c2); - if (!CHARSET_VALID_P (charset)) - return 0; - return (c < MIN_CHAR_COMPOSITION - ? ((c & CHAR_FIELD1_MASK) /* i.e. dimension of C is two. */ - ? (genericp && c1 == 0 && c2 == 0 - || c1 >= 32 && c2 >= 32) - : (genericp && c1 == 0 - || c1 >= 32)) - : c < MIN_CHAR_COMPOSITION + n_cmpchars); + SPLIT_CHAR (c, charset, c1, c2); + 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. -If optional arg GENERICP is non-nil, also return t if OBJECT is + "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; @@ -765,30 +1105,73 @@ a valid generic character.") 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))) - { - unsigned int id = COMPOSITE_CHAR_ID (XFASTINT (ch)); + return make_number (1); +} - bytes = (id < n_cmpchars ? cmpchar_table[id]->len : 1); - } - else - { - int charset = CHAR_CHARSET (XFASTINT (ch)); +/* 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 charset; - bytes = CHARSET_DEFINED_P (charset) ? CHARSET_BYTES (charset) : 1; - } + if (ASCII_BYTE_P (c) || (c & ~((1 << CHARACTERBITS) -1))) + return 1; + if (SINGLE_BYTE_CHAR_P (c) && c >= 0xA0) + return 1; - XSETFASTINT (val, bytes); - return val; + charset = CHAR_CHARSET (c); + return (CHARSET_DEFINED_P (charset) ? CHARSET_BYTES (charset) : 1); } /* Return the width of character of which multi-byte form starts with @@ -807,12 +1190,12 @@ DEFUN ("char-bytes", Fchar_bytes, Schar_bytes, 1, 1, 0, : ((! 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\ -The width is measured by how many columns it occupies on the screen.") +The width is measured by how many columns it occupies on the screen.\n\ +Tab is taken to occupy `tab-width' columns.") (ch) Lisp_Object ch; { @@ -831,11 +1214,6 @@ The width is measured by how many columns it occupies on the screen.") 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)); - } else { int charset = CHAR_CHARSET (c); @@ -856,44 +1234,63 @@ strwidth (str, len) { unsigned char *endp = str + len; int width = 0; - struct Lisp_Char_Table *dp = buffer_display_table (current_buffer); + struct Lisp_Char_Table *dp = buffer_display_table (); while (str < endp) { - if (*str == LEADING_CODE_COMPOSITION) - { - int id = str_cmpchar_id (str, endp - str); + Lisp_Object disp; + int thislen; + int c = STRING_CHAR_AND_LENGTH (str, endp - str, thislen); - if (id < 0) - { - width += 4; - str++; - } - else + /* 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; +} + +int +lisp_string_width (str) + Lisp_Object str; +{ + int len = XSTRING (str)->size, len_byte = STRING_BYTES (XSTRING (str)); + int i = 0, i_byte; + int width = 0; + int start, end, start_byte; + Lisp_Object prop; + int cmp_id; + + while (i < len) + { + if (find_composition (i, len, &start, &end, &prop, str)) + { + start_byte = string_char_to_byte (str, start); + if (i < start) { - width += cmpchar_table[id]->width; - str += cmpchar_table[id]->len; + i_byte = string_char_to_byte (str, i); + width += strwidth (XSTRING (str)->data + i_byte, + start_byte - i_byte); } + cmp_id + = get_composition_id (start, start_byte, end - start, prop, str); + if (cmp_id >= 0) + width += composition_table[cmp_id]->width; + i = end; } else { - Lisp_Object disp; - int thiswidth; - int c = STRING_CHAR (str, endp - str); - - /* Get the way the display table would display it. */ - if (dp) - disp = DISP_CHAR_VECTOR (dp, c); - else - disp = Qnil; - - if (VECTORP (disp)) - thiswidth = XVECTOR (disp)->size; - else - thiswidth = ONE_BYTE_CHAR_WIDTH (*str); - - width += thiswidth; - str += BYTES_BY_CHAR_HEAD (*str); + i_byte = string_char_to_byte (str, i); + width += strwidth (XSTRING (str)->data + i_byte, len_byte - i_byte); + i = len; } } return width; @@ -904,14 +1301,15 @@ DEFUN ("string-width", Fstring_width, Sstring_width, 1, 1, 0, Width is measured by how many columns it occupies on the screen.\n\ 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.") +the following bytes is not checked. Tabs in STRING are always\n\ +taken to occupy `tab-width' columns.") (str) Lisp_Object str; { Lisp_Object val; CHECK_STRING (str, 0); - XSETFASTINT (val, strwidth (XSTRING (str)->data, XSTRING (str)->size)); + XSETFASTINT (val, lisp_string_width (str)); return val; } @@ -926,595 +1324,231 @@ The returned value is 0 for left-to-right and 1 for right-to-left.") 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.\n\ -When using multibyte characters, this is not the necessarily same as\n\ -the length of STRING; the length counts a multibyte characters as\n\ -several bytes, but this function counts a multibyte character as one\n\ -character.") - (str) - Lisp_Object str; -{ - Lisp_Object val; - unsigned char *p, *endp; - int chars; - - CHECK_STRING (str, 0); - - 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++; - } - - XSETFASTINT (val, chars); - return val; -} - DEFUN ("chars-in-region", Fchars_in_region, Schars_in_region, 2, 2, 0, - "Return number of characters between BEG and END.\n\ -When using multibyte characters, this is not the necessarily same\n\ -as (- END BEG); that subtraction gives you the number of bytes, which\n\ -may be more than the number of characters.") + "Return number of characters between BEG and END.") (beg, end) Lisp_Object beg, end; { - int from, to, stop; - Lisp_Object val; - int chars = 0; - unsigned char *p, *endp; + int from, to; - validate_region (&beg, &end); + CHECK_NUMBER_COERCE_MARKER (beg, 0); + CHECK_NUMBER_COERCE_MARKER (end, 1); from = min (XFASTINT (beg), XFASTINT (end)); to = max (XFASTINT (beg), XFASTINT (end)); - p = POS_ADDR (from); - if (from < GPT && GPT <= to) - { - stop = GPT; - endp = GPT_ADDR; - } - else - { - stop = to; - endp = POS_ADDR (stop); - } + return make_number (to - from); +} - while (1) - { - if (p == endp) - { - if (stop == to) - break; +/* 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. */ - p = POS_ADDR (stop); - stop = to; - endp = POS_ADDR (stop); - } +int +chars_in_text (ptr, nbytes) + unsigned char *ptr; + int nbytes; +{ + /* current_buffer is null at early stages of Emacs initialization. */ + if (current_buffer == 0 + || NILP (current_buffer->enable_multibyte_characters)) + return nbytes; - if (*p == LEADING_CODE_COMPOSITION) - { - p++; - while (p < endp && ! CHAR_HEAD_P (p)) p++; - } - else - p += BYTES_BY_CHAR_HEAD (*p); + return multibyte_chars_in_text (ptr, nbytes); +} + +/* 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. */ + +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) + { + PARSE_MULTIBYTE_SEQ (ptr, endp - ptr, bytes); + ptr += bytes; chars++; } - return make_number (chars); + return chars; } -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\ -When the value is non-nil, it contains some additional information:\n\ - 0 if POS is at an ASCII character or at the end of range,\n\ - 1 if POS is before a 2-byte length multi-byte form,\n\ - 2 if POS is before a 3-byte length multi-byte form,\n\ - 3 if POS is before a 4-byte length multi-byte form,\n\ - 4 if POS is before a composite character.\n\ -If POS is out of range or not at character boundary, return NIL.") - (pos) - Lisp_Object pos; +/* Parse unibyte text at STR of LEN bytes as a multibyte text, and + count the numbers of characters and bytes in it. On counting + bytes, pay attention to that 8-bit characters in the range + 0x80..0x9F are represented by 2-byte in a multibyte text. */ +void +parse_str_as_multibyte (str, len, nchars, nbytes) + unsigned char *str; + int len, *nchars, *nbytes; { - Lisp_Object val; - int n; - - CHECK_NUMBER_COERCE_MARKER (pos, 0); - - n = XINT (pos); - if (n < BEGV || n > ZV) - return Qnil; + unsigned char *endp = str + len; + int n, chars = 0, bytes = 0; - if (n == ZV || NILP (current_buffer->enable_multibyte_characters)) - XSETFASTINT (val, 0); - else + while (str < 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 (UNIBYTE_STR_AS_MULTIBYTE_P (str, endp - str, n)) + str += n, bytes += n; else - val = Qnil; + str++, bytes += 2; + chars++; } - return val; + *nchars = chars; + *nbytes = bytes; + return; } -DEFUN ("concat-chars", Fconcat_chars, Sconcat_chars, 1, MANY, 0, - "Concatenate all the argument characters and make the result a string.") - (n, args) - int n; - Lisp_Object *args; +/* Arrange unibyte text at STR of NBYTES bytes as a multibyte text. + It actually converts only 8-bit characters in the range 0x80..0x9F + that don't contruct multibyte characters to multibyte forms. If + NCHARS is nonzero, set *NCHARS to the number of characters in the + text. It is assured that we can use LEN bytes at STR as a work + area and that is enough. Return the number of bytes of the + resulting text. */ + +int +str_as_multibyte (str, len, nbytes, nchars) + unsigned char *str; + int len, nbytes, *nchars; { - int i; - unsigned char *buf - = (unsigned char *) alloca (MAX_LENGTH_OF_MULTI_BYTE_FORM * n); - unsigned char *p = buf; - Lisp_Object val; + unsigned char *p = str, *endp = str + nbytes; + unsigned char *to; + int chars = 0; + int n; - for (i = 0; i < n; i++) + while (p < endp && UNIBYTE_STR_AS_MULTIBYTE_P (p, endp - p, n)) + p += n, chars++; + if (nchars) + *nchars = chars; + if (p == endp) + return nbytes; + + to = p; + nbytes = endp - p; + endp = str + len; + safe_bcopy (p, endp - nbytes, nbytes); + p = endp - nbytes; + while (p < endp) { - int c, len; - unsigned char *str; - - if (!INTEGERP (args[i])) + if (UNIBYTE_STR_AS_MULTIBYTE_P (p, endp - p, n)) { - free (buf); - CHECK_NUMBER (args[i], 0); + while (n--) + *to++ = *p++; + } + else + { + *to++ = LEADING_CODE_8_BIT_CONTROL; + *to++ = *p++ + 0x20; } - c = XINT (args[i]); - len = CHAR_STRING (c, p, str); - if (p != str) - /* C is a composite character. */ - bcopy (str, p, len); - p += len; + chars++; } - - val = make_string (buf, p - buf); - return val; + if (nchars) + *nchars = chars; + return (to - str); } -#endif /* emacs */ - -/*** Composite characters staffs ***/ - -/* Each composite character is identified by CMPCHAR-ID which is - assigned when Emacs needs the character code of the composite - character (e.g. when displaying it on the screen). See the - document "GENERAL NOTE on COMPOSITE CHARACTER" in `charset.h' how a - composite character is represented in Emacs. */ - -/* If `static' is defined, it means that it is defined to null string. */ -#ifndef static -/* The following function is copied from lread.c. */ -static int -hash_string (ptr, len) - unsigned char *ptr; - int len; +/* Convert unibyte text at STR of NBYTES bytes to a multibyte text + that contains the same single-byte characters. It actually + converts all 8-bit characters to multibyte forms. It is assured + that we can use LEN bytes at STR as a work area and that is + enough. */ + +int +str_to_multibyte (str, len, bytes) + unsigned char *str; + int len, bytes; { - register unsigned char *p = ptr; - register unsigned char *end = p + len; - register unsigned char c; - register int hash = 0; + unsigned char *p = str, *endp = str + bytes; + unsigned char *to; + int c; - while (p != end) + while (p < endp && (*p < 0x80 || *p >= 0xA0)) p++; + if (p == endp) + return bytes; + to = p; + bytes = endp - p; + endp = str + len; + safe_bcopy (p, endp - bytes, bytes); + p = endp - bytes; + while (p < endp) { - c = *p++; - if (c >= 0140) c -= 40; - hash = ((hash<<3) + (hash>>28) + c); + if (*p < 0x80 || *p >= 0xA0) + *to++ = *p++; + else + *to++ = LEADING_CODE_8_BIT_CONTROL, *to++ = *p++ + 0x20; } - return hash & 07777777777; + return (to - str); } -#endif - -#define CMPCHAR_HASH_TABLE_SIZE 0xFFF -static int *cmpchar_hash_table[CMPCHAR_HASH_TABLE_SIZE]; +/* Arrange multibyte text at STR of LEN bytes as a unibyte text. It + actually converts only 8-bit characters in the range 0x80..0x9F to + unibyte forms. */ -/* Each element of `cmpchar_hash_table' is a pointer to an array of - integer, where the 1st element is the size of the array, the 2nd - element is how many elements are actually used in the array, and - the remaining elements are CMPCHAR-IDs of composite characters of - the same hash value. */ -#define CMPCHAR_HASH_SIZE(table) table[0] -#define CMPCHAR_HASH_USED(table) table[1] -#define CMPCHAR_HASH_CMPCHAR_ID(table, i) table[i] - -/* Return CMPCHAR-ID of the composite character in STR of the length - LEN. If the composite character has not yet been registered, - register it in `cmpchar_table' and assign new CMPCHAR-ID. This - is the sole function for assigning CMPCHAR-ID. */ int -str_cmpchar_id (str, len) +str_as_unibyte (str, bytes) unsigned char *str; - int len; + int bytes; { - int hash_idx, *hashp; - unsigned char *buf; - int embedded_rule; /* 1 if composition rule is embedded. */ - int chars; /* number of components. */ - 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. */ - embedded_rule = (str[1] == 0xFF); - - /* At first, get the actual length of the composite character. */ - { - unsigned char *p, *endp = str + 1, *lastp = str + len; - int bytes; - - while (endp < lastp && ! CHAR_HEAD_P (endp)) endp++; - chars = 0; - p = str + 1 + embedded_rule; - while (p < endp) - { - /* 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); - chars++; - } - len = (p -= embedded_rule) - str; - if (p > endp) - len -= - bytes, chars--; - - if (chars < 2 || chars > MAX_COMPONENT_COUNT) - /* Invalid number of components. */ - return -1; - } - hash_idx = hash_string (str, len) % CMPCHAR_HASH_TABLE_SIZE; - hashp = cmpchar_hash_table[hash_idx]; - - /* Then, look into the hash table. */ - if (hashp != NULL) - /* Find the correct one among composite characters of the same - hash value. */ - for (i = 2; i < CMPCHAR_HASH_USED (hashp); i++) - { - cmpcharp = cmpchar_table[CMPCHAR_HASH_CMPCHAR_ID (hashp, i)]; - if (len == cmpcharp->len - && ! bcmp (str, cmpcharp->data, len)) - return CMPCHAR_HASH_CMPCHAR_ID (hashp, i); - } - - /* 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) - { - /* Make a table for 8 composite characters initially. */ - hashp = (cmpchar_hash_table[hash_idx] - = (int *) xmalloc (sizeof (int) * (2 + 8))); - CMPCHAR_HASH_SIZE (hashp) = 10; - CMPCHAR_HASH_USED (hashp) = 2; - } - else if (CMPCHAR_HASH_USED (hashp) >= CMPCHAR_HASH_SIZE (hashp)) - { - CMPCHAR_HASH_SIZE (hashp) += 8; - hashp = (cmpchar_hash_table[hash_idx] - = (int *) xrealloc (hashp, - sizeof (int) * CMPCHAR_HASH_SIZE (hashp))); - } - CMPCHAR_HASH_CMPCHAR_ID (hashp, CMPCHAR_HASH_USED (hashp)) = n_cmpchars; - CMPCHAR_HASH_USED (hashp)++; - - /* Set information of the composite character in cmpchar_table. */ - if (cmpchar_table_size == 0) - { - /* This is the first composite character to be registered. */ - cmpchar_table_size = 256; - cmpchar_table - = (struct cmpchar_info **) xmalloc (sizeof (cmpchar_table[0]) - * cmpchar_table_size); - } - else if (cmpchar_table_size <= n_cmpchars) - { - cmpchar_table_size += 256; - cmpchar_table - = (struct cmpchar_info **) xrealloc (cmpchar_table, - sizeof (cmpchar_table[0]) - * cmpchar_table_size); - } - - cmpcharp = (struct cmpchar_info *) xmalloc (sizeof (struct cmpchar_info)); + unsigned char *p = str, *endp = str + bytes; + unsigned char *to = str; - cmpcharp->len = len; - cmpcharp->data = (unsigned char *) xmalloc (len + 1); - bcopy (str, cmpcharp->data, len); - cmpcharp->data[len] = 0; - cmpcharp->glyph_len = chars; - cmpcharp->glyph = (GLYPH *) xmalloc (sizeof (GLYPH) * chars); - if (embedded_rule) + while (p < endp && *p != LEADING_CODE_8_BIT_CONTROL) p++; + to = p; + while (p < endp) { - cmpcharp->cmp_rule = (unsigned char *) xmalloc (chars); - cmpcharp->col_offset = (float *) xmalloc (sizeof (float) * chars); - } - else - { - cmpcharp->cmp_rule = NULL; - cmpcharp->col_offset = NULL; + if (*p == LEADING_CODE_8_BIT_CONTROL) + *to++ = *(p + 1) - 0x20, p += 2; + else + *to++ = *p++; } - - /* Setup GLYPH data and composition rules (if any) so as not to make - them every time on displaying. */ - { - unsigned char *bufp; - int width; - float leftmost = 0.0, rightmost = 1.0; - - if (embedded_rule) - /* At first, col_offset[N] is set to relative to col_offset[0]. */ - cmpcharp->col_offset[0] = 0; - - for (i = 0, bufp = cmpcharp->data + 1; i < chars; i++) - { - if (embedded_rule) - cmpcharp->cmp_rule[i] = *bufp++; - - if (*bufp == 0xA0) /* This is an ASCII character. */ - { - cmpcharp->glyph[i] = FAST_MAKE_GLYPH ((*++bufp & 0x7F), 0); - width = 1; - bufp++; - } - else /* Multibyte character. */ - { - /* Make `bufp' point normal multi-byte form temporally. */ - *bufp -= 0x20; - cmpcharp->glyph[i] - = FAST_MAKE_GLYPH (string_to_non_ascii_char (bufp, 4, 0), 0); - width = WIDTH_BY_CHAR_HEAD (*bufp); - *bufp += 0x20; - bufp += BYTES_BY_CHAR_HEAD (*bufp - 0x20); - } - - if (embedded_rule && i > 0) - { - /* Reference points (global_ref and new_ref) are - encoded as below: - - 0--1--2 -- ascent - | | - | | - | 4 -+--- center - -- 3 5 -- baseline - | | - 6--7--8 -- descent - - Now, we calculate the column offset of the new glyph - from the left edge of the first glyph. This can avoid - the same calculation everytime displaying this - composite character. */ - - /* Reference points of global glyph and new glyph. */ - int global_ref = (cmpcharp->cmp_rule[i] - 0xA0) / 9; - int new_ref = (cmpcharp->cmp_rule[i] - 0xA0) % 9; - /* Column offset relative to the first glyph. */ - float left = (leftmost - + (global_ref % 3) * (rightmost - leftmost) / 2.0 - - (new_ref % 3) * width / 2.0); - - cmpcharp->col_offset[i] = left; - if (left < leftmost) - leftmost = left; - if (left + width > rightmost) - rightmost = left + width; - } - else - { - if (width > rightmost) - rightmost = width; - } - } - if (embedded_rule) - { - /* Now col_offset[N] are relative to the left edge of the - first component. Make them relative to the left edge of - overall glyph. */ - for (i = 0; i < chars; i++) - cmpcharp->col_offset[i] -= leftmost; - /* Make rightmost holds width of overall glyph. */ - rightmost -= leftmost; - } - - cmpcharp->width = rightmost; - if (cmpcharp->width < rightmost) - /* To get a ceiling integer value. */ - cmpcharp->width++; - } - - cmpchar_table[n_cmpchars] = cmpcharp; - - return n_cmpchars++; -} - -/* Return the Nth element of the composite character C. */ -int -cmpchar_component (c, n) - unsigned int c, n; -{ - 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; - /* No face data is stored in glyph code. */ - return ((int) (cmpchar_table[id]->glyph[n])); -} - -DEFUN ("cmpcharp", Fcmpcharp, Scmpcharp, 1, 1, 0, - "T if CHAR is a composite character.") - (ch) - Lisp_Object ch; -{ - CHECK_NUMBER (ch, 0); - return (COMPOSITE_CHAR_P (XINT (ch)) ? Qt : Qnil); + return (to - str); } -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; + +DEFUN ("string", Fstring, Sstring, 1, MANY, 0, + "Concatenate all the argument characters and make the result a string.") + (n, args) + int n; + Lisp_Object *args; { + int i; + unsigned char *buf = (unsigned char *) alloca (MAX_MULTIBYTE_LENGTH * n); + unsigned char *p = buf; int c; - CHECK_NUMBER (character, 0); - CHECK_NUMBER (idx, 1); - - if ((c = cmpchar_component (XINT (character), XINT (idx))) < 0) - args_out_of_range (character, idx); - - return make_number (c); -} - -DEFUN ("composite-char-composition-rule", Fcmpchar_cmp_rule, Scmpchar_cmp_rule, - 2, 2, 0, - "Return the Nth composition rule embedded in composite character CHARACTER.\n\ -The returned rule is for composing the Nth component\n\ -on the (N-1)th component. If N is 0, the returned value is always 255.") - (character, n) - Lisp_Object character, n; -{ - int id, i; - - CHECK_NUMBER (character, 0); - 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 (n); - if (i > cmpchar_table[id]->glyph_len) - args_out_of_range (character, n); - - return make_number (cmpchar_table[id]->cmp_rule[i]); -} - -DEFUN ("composite-char-composition-rule-p", Fcmpchar_cmp_rule_p, - Scmpchar_cmp_rule_p, 1, 1, 0, - "Return non-nil if composite character CHARACTER contains a embedded rule.") - (character) - Lisp_Object character; -{ - int id; - - CHECK_NUMBER (character, 0); - id = COMPOSITE_CHAR_ID (XINT (character)); - if (id < 0 || id >= n_cmpchars) - error ("Invalid composite character: %d", XINT (character)); - - return (cmpchar_table[id]->cmp_rule ? Qt : Qnil); -} - -DEFUN ("composite-char-component-count", Fcmpchar_cmp_count, - Scmpchar_cmp_count, 1, 1, 0, - "Return number of compoents of composite character CHARACTER.") - (character) - Lisp_Object character; -{ - int id; - - CHECK_NUMBER (character, 0); - id = COMPOSITE_CHAR_ID (XINT (character)); - if (id < 0 || id >= n_cmpchars) - error ("Invalid composite character: %d", XINT (character)); - - return (make_number (cmpchar_table[id]->glyph_len)); -} - -DEFUN ("compose-string", Fcompose_string, Scompose_string, - 1, 1, 0, - "Return one char string composed from all characters in STRING.") - (str) - Lisp_Object str; -{ - unsigned char buf[MAX_LENGTH_OF_MULTI_BYTE_FORM], *p, *pend, *ptemp; - int len, i; - - CHECK_STRING (str, 0); - - buf[0] = LEADING_CODE_COMPOSITION; - p = XSTRING (str)->data; - pend = p + XSTRING (str)->size; - i = 1; - while (p < pend) + for (i = 0; i < n; i++) { - if (*p < 0x20 || *p == 127) /* control code */ - error ("Invalid component character: %d", *p); - else if (*p < 0x80) /* ASCII */ - { - if (i + 2 >= MAX_LENGTH_OF_MULTI_BYTE_FORM) - error ("Too long string to be composed: %s", XSTRING (str)->data); - /* Prepend an ASCII charset indicator 0xA0, set MSB of the - code itself. */ - buf[i++] = 0xA0; - buf[i++] = *p++ + 0x80; - } - else if (*p == LEADING_CODE_COMPOSITION) /* composite char */ - { - /* Already composed. Eliminate the heading - LEADING_CODE_COMPOSITION, keep the remaining bytes - unchanged. */ - p++; - ptemp = p; - while (! CHAR_HEAD_P (p)) p++; - 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); - i += p - ptemp; - } - else /* multibyte char */ - { - /* Add 0x20 to the base leading-code, keep the remaining - bytes unchanged. */ - len = BYTES_BY_CHAR_HEAD (*p); - 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); - buf[i] += 0x20; - p += len, i += len; - } + CHECK_NUMBER (args[i], 0); + c = XINT (args[i]); + p += CHAR_STRING (c, p); } - if (i < 5) - /* 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, n, p - buf); } +#endif /* emacs */ +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); @@ -1535,12 +1569,14 @@ DEFUN ("setup-special-charsets", Fsetup_special_charsets, 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"); @@ -1556,7 +1592,10 @@ init_charset_once () 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 + 1), 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++) @@ -1564,40 +1603,60 @@ init_charset_once () for (k = 0; k < 128; k++) iso_charset_table [i][j][k] = -1; - bzero (cmpchar_hash_table, sizeof cmpchar_hash_table); - cmpchar_table_size = n_cmpchars = 0; - for (i = 0; i < 256; i++) - BYTES_BY_CHAR_HEAD (i) = 1; - 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 - that it is a start of a multibyte character. */ - BYTES_BY_CHAR_HEAD (LEADING_CODE_COMPOSITION) = 2; + bytes_by_char_head[i] = 1; + 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; for (i = 0; i < 128; i++) - WIDTH_BY_CHAR_HEAD (i) = 1; + width_by_char_head[i] = 1; for (; i < 256; i++) - WIDTH_BY_CHAR_HEAD (i) = 4; - WIDTH_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_11) = 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; + width_by_char_head[i] = 4; + width_by_char_head[LEADING_CODE_PRIVATE_11] = 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); + Vgeneric_character_list = Fnreverse (val); + } + + nonascii_insert_offset = 0; + Vnonascii_translation_table = Qnil; } #ifdef emacs +void syms_of_charset () { + Qcharset = intern ("charset"); + staticpro (&Qcharset); + Qascii = intern ("ascii"); staticpro (&Qascii); - Qcharset = intern ("charset"); - staticpro (&Qcharset); + Qeight_bit_control = intern ("eight-bit-control"); + staticpro (&Qeight_bit_control); - /* Define ASCII charset now. */ + Qeight_bit_graphic = intern ("eight-bit-graphic"); + staticpro (&Qeight_bit_graphic); + + /* Define special charsets ascii, eight-bit-control, and + eight-bit-graphic. */ update_charset_table (make_number (CHARSET_ASCII), make_number (1), make_number (94), make_number (1), @@ -1605,47 +1664,72 @@ syms_of_charset () make_number ('B'), make_number (0), build_string ("ASCII"), - build_string ("ASCII"), + Qnil, /* same as above */ build_string ("ASCII (ISO646 IRV)")); CHARSET_SYMBOL (CHARSET_ASCII) = Qascii; Fput (Qascii, Qcharset, CHARSET_TABLE_ENTRY (CHARSET_ASCII)); - Qcomposition = intern ("composition"); - staticpro (&Qcomposition); - CHARSET_SYMBOL (CHARSET_COMPOSITION) = Qcomposition; + update_charset_table (make_number (CHARSET_8_BIT_CONTROL), + make_number (1), make_number (96), + make_number (4), + make_number (0), + make_number (-1), + make_number (-1), + build_string ("8-bit control code (0x80..0x9F)"), + Qnil, /* same as above */ + Qnil); /* same as above */ + CHARSET_SYMBOL (CHARSET_8_BIT_CONTROL) = Qeight_bit_control; + Fput (Qeight_bit_control, Qcharset, + CHARSET_TABLE_ENTRY (CHARSET_8_BIT_CONTROL)); + + update_charset_table (make_number (CHARSET_8_BIT_GRAPHIC), + make_number (1), make_number (96), + make_number (4), + make_number (0), + make_number (-1), + make_number (-1), + build_string ("8-bit graphic char (0xA0..0xFF)"), + Qnil, /* same as above */ + Qnil); /* same as above */ + CHARSET_SYMBOL (CHARSET_8_BIT_GRAPHIC) = Qeight_bit_graphic; + Fput (Qeight_bit_graphic, Qcharset, + CHARSET_TABLE_ENTRY (CHARSET_8_BIT_GRAPHIC)); + + 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 (&Schars_in_region); - defsubr (&Schar_boundary_p); - defsubr (&Sconcat_chars); - defsubr (&Scmpcharp); - defsubr (&Scmpchar_component); - defsubr (&Scmpchar_cmp_rule); - defsubr (&Scmpchar_cmp_rule_p); - defsubr (&Scmpchar_cmp_count); - defsubr (&Scompose_string); + defsubr (&Sstring); defsubr (&Ssetup_special_charsets); DEFVAR_LISP ("charset-list", &Vcharset_list, "List of charsets ever defined."); - Vcharset_list = Fcons (Qascii, Qnil); + Vcharset_list = Fcons (Qascii, Fcons (Qeight_bit_control, + Fcons (Qeight_bit_graphic, Qnil))); - DEFVAR_INT ("leading-code-composition", &leading_code_composition, - "Leading-code of composite characters."); - leading_code_composition = LEADING_CODE_COMPOSITION; + 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-private-11", &leading_code_private_11, "Leading-code of private TYPE9N charset of column-width 1."); @@ -1662,6 +1746,35 @@ syms_of_charset () 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_LISP ("auto-fill-chars", &Vauto_fill_chars, + "A char-table for characters which invoke auto-filling.\n\ +Such characters have 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 */