Lisp_Object Qunknown;
/* Declaration of special leading-codes. */
-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 */
+EMACS_INT leading_code_private_11; /* for private DIMENSION1 of 1-column */
+EMACS_INT leading_code_private_12; /* for private DIMENSION1 of 2-column */
+EMACS_INT leading_code_private_21; /* for private DIMENSION2 of 1-column */
+EMACS_INT leading_code_private_22; /* for private DIMENSION2 of 2-column */
/* Declaration of special charsets. The values are set by
Fsetup_special_charsets. */
int _fetch_multibyte_char_len;
/* Offset to add to a non-ASCII value when inserting it. */
-int nonascii_insert_offset;
+EMACS_INT nonascii_insert_offset;
/* Translation table for converting non-ASCII unibyte characters
to multibyte codes, or nil. */
(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. */
+/* 1 if CHARSET, C1, and C2 compose a valid character, else 0.
+ Note that this intentionally allows invalid components, such
+ as 0xA0 0xA0, because there exist many files that contain
+ such invalid byte sequences, especially in EUC-GB. */
#define CHAR_COMPONENTS_VALID_P(charset, c1, c2) \
((charset) == CHARSET_ASCII \
? ((c1) >= 0 && (c1) <= 0x7F) \
/* If C still has any modifier bits, just ignore it. */
c &= ~CHAR_MODIFIER_MASK;
}
-
+
if (SINGLE_BYTE_CHAR_P (c))
{
if (ASCII_BYTE_P (c) || c >= 0xA0)
? LEADING_CODE_PRIVATE_21
: LEADING_CODE_PRIVATE_22)));
*p++ = charset;
- if (c1 > 0 && c1 < 32 || c2 > 0 && c2 < 32)
+ if ((c1 > 0 && c1 < 32) || (c2 > 0 && c2 < 32))
return -1;
if (c1)
{
return 0;
else if (c >= MAX_CHAR)
return 0;
-
+
SPLIT_CHAR (c, charset, c1, c2);
if (! CHARSET_DEFINED_P (charset))
return 0;
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)
+ if ((dimension == 1 && alt_c1 > 0) || (dimension == 2 && alt_c2 > 0))
/* CH is not a generic character, just return it. */
return XFASTINT (ch);
Lisp_Object val;
int charset;
- return ((SYMBOLP (charset_symbol)
- && (val = Fget (charset_symbol, Qcharset), VECTORP (val))
- && (charset = XINT (XVECTOR (val)->contents[CHARSET_ID_IDX]),
- CHARSET_VALID_P (charset)))
- ? charset : -1);
+ /* This originally used a ?: operator, but reportedly the HP-UX
+ compiler version HP92453-01 A.10.32.22 miscompiles that. */
+ if (SYMBOLP (charset_symbol)
+ && VECTORP (val = Fget (charset_symbol, Qcharset))
+ && CHARSET_VALID_P (charset =
+ XINT (XVECTOR (val)->contents[CHARSET_ID_IDX])))
+ return charset;
+ else
+ return -1;
}
/* Return an identification number for a new private charset of
Lisp_Object *vec;
if (!NILP (charset_id))
- CHECK_NUMBER (charset_id, 0);
- CHECK_SYMBOL (charset_symbol, 1);
- CHECK_VECTOR (info_vector, 2);
+ CHECK_NUMBER (charset_id);
+ CHECK_SYMBOL (charset_symbol);
+ CHECK_VECTOR (info_vector);
if (! NILP (charset_id))
{
|| !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]) == -1 || XINT (vec[4]) >= '0' && XINT (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]))
error ("Invalid info-vector argument for defining charset %s",
- XSYMBOL (charset_symbol)->name->data);
+ SDATA (SYMBOL_NAME (charset_symbol)));
if (NILP (charset_id))
{
charset_id = get_new_private_charset_id (XINT (vec[0]), XINT (vec[2]));
if (XINT (charset_id) == 0)
error ("There's no room for a new private charset %s",
- XSYMBOL (charset_symbol)->name->data);
+ SDATA (SYMBOL_NAME (charset_symbol)));
}
update_charset_table (charset_id, vec[0], vec[1], vec[2], vec[3],
Fput (charset_symbol, Qcharset, CHARSET_TABLE_ENTRY (XINT (charset_id)));
CHARSET_SYMBOL (XINT (charset_id)) = charset_symbol;
Vcharset_list = Fcons (charset_symbol, Vcharset_list);
+ Fupdate_coding_systems_internal ();
return Qnil;
}
{
int final_char;
- CHECK_NUMBER (dimension, 0);
- CHECK_NUMBER (chars, 1);
+ CHECK_NUMBER (dimension);
+ CHECK_NUMBER (chars);
if (XINT (dimension) != 1 && XINT (dimension) != 2)
error ("Invalid charset dimension %d, it should be 1 or 2",
XINT (dimension));
{
int charset;
- CHECK_NUMBER (dimension, 0);
- CHECK_NUMBER (chars, 1);
- CHECK_NUMBER (final_char, 2);
- CHECK_SYMBOL (charset_symbol, 3);
+ CHECK_NUMBER (dimension);
+ CHECK_NUMBER (chars);
+ CHECK_NUMBER (final_char);
+ CHECK_SYMBOL (charset_symbol);
if (XINT (dimension) != 1 && XINT (dimension) != 2)
error ("Invalid DIMENSION %d, it should be 1 or 2", XINT (dimension));
if (XINT (final_char) < '0' || XFASTINT (final_char) > '~')
error ("Invalid FINAL-CHAR %c, it should be `0'..`~'", XINT (chars));
if ((charset = get_charset_id (charset_symbol)) < 0)
- error ("Invalid charset %s", XSYMBOL (charset_symbol)->name->data);
+ error ("Invalid charset %s", SDATA (SYMBOL_NAME (charset_symbol)));
ISO_CHARSET_TABLE (dimension, chars, final_char) = charset;
return Qnil;
int
find_charset_in_text (ptr, nchars, nbytes, charsets, table)
- unsigned char *ptr;
+ const unsigned char *ptr;
int nchars, nbytes, *charsets;
Lisp_Object table;
{
{
if (charsets && nbytes > 0)
{
- unsigned char *endp = ptr + nbytes;
+ const unsigned char *endp = ptr + nbytes;
int maskbits = 0;
while (ptr < endp && maskbits != 7)
{
maskbits |= (*ptr < 0x80 ? 1 : *ptr < 0xA0 ? 2 : 4);
ptr++;
- }
+ }
if (maskbits & 1)
charsets[CHARSET_ASCII] = 1;
int i;
Lisp_Object val;
- CHECK_STRING (str, 0);
+ CHECK_STRING (str);
bzero (charsets, (MAX_CHARSET + 1) * sizeof (int));
- find_charset_in_text (XSTRING (str)->data, XSTRING (str)->size,
- STRING_BYTES (XSTRING (str)), charsets, table);
+ find_charset_in_text (SDATA (str), SCHARS (str),
+ SBYTES (str), charsets, table);
val = Qnil;
if (charsets[1])
{
int charset_id, c1, c2;
- CHECK_NUMBER (charset, 0);
+ CHECK_NUMBER (charset);
charset_id = XINT (charset);
if (!CHARSET_DEFINED_P (charset_id))
error ("Invalid charset ID: %d", XINT (charset));
c1 = 0;
else
{
- CHECK_NUMBER (code1, 1);
+ CHECK_NUMBER (code1);
c1 = XINT (code1);
}
if (NILP (code2))
c2 = 0;
else
{
- CHECK_NUMBER (code2, 2);
+ CHECK_NUMBER (code2);
c2 = XINT (code2);
}
{
int c, charset, c1, c2;
- CHECK_NUMBER (ch, 0);
+ CHECK_NUMBER (ch);
c = XFASTINT (ch);
if (!CHAR_VALID_P (c, 1))
return Fcons (Qunknown, Fcons (ch, Qnil));
(ch)
Lisp_Object ch;
{
- CHECK_NUMBER (ch, 0);
+ CHECK_NUMBER (ch);
return CHARSET_SYMBOL (CHAR_CHARSET (XINT (ch)));
}
{
int charset;
- CHECK_NUMBER (dimension, 0);
- CHECK_NUMBER (chars, 1);
- CHECK_NUMBER (final_char, 2);
+ CHECK_NUMBER (dimension);
+ CHECK_NUMBER (chars);
+ CHECK_NUMBER (final_char);
if ((charset = ISO_CHARSET_TABLE (dimension, chars, final_char)) < 0)
return Qnil;
{
int c;
- CHECK_NUMBER (ch, 0);
+ CHECK_NUMBER (ch);
c = XINT (ch);
if (c < 0 || c >= 0400)
error ("Invalid unibyte character: %d", c);
{
int c;
- CHECK_NUMBER (ch, 0);
+ CHECK_NUMBER (ch);
c = XINT (ch);
if (! CHAR_VALID_P (c, 0))
error ("Invalid multibyte character: %d", c);
}
DEFUN ("char-bytes", Fchar_bytes, Schar_bytes, 1, 1, 0,
- doc: /* Return 1 regardless of the argument CHAR.
-This is now an obsolete function. We keep it just for backward compatibility. */)
+ doc: /* Return 1 regardless of the argument CHAR. */)
(ch)
Lisp_Object ch;
{
- CHECK_NUMBER (ch, 0);
+ CHECK_NUMBER (ch);
return make_number (1);
}
int c;
struct Lisp_Char_Table *dp = buffer_display_table ();
- CHECK_NUMBER (ch, 0);
+ CHECK_NUMBER (ch);
c = XINT (ch);
int
c_string_width (str, len, precision, nchars, nbytes)
- unsigned char *str;
- int precision, *nchars, *nbytes;
+ const unsigned char *str;
+ int len, precision, *nchars, *nbytes;
{
int i = 0, i_byte = 0;
int width = 0;
Lisp_Object string;
int precision, *nchars, *nbytes;
{
- int len = XSTRING (string)->size;
- int len_byte = STRING_BYTES (XSTRING (string));
- unsigned char *str = XSTRING (string)->data;
+ int len = SCHARS (string);
+ int len_byte = SBYTES (string);
+ const unsigned char *str = SDATA (string);
int i = 0, i_byte = 0;
int width = 0;
struct Lisp_Char_Table *dp = buffer_display_table ();
{
Lisp_Object val;
- CHECK_STRING (str, 0);
+ CHECK_STRING (str);
XSETFASTINT (val, lisp_string_width (str, -1, NULL, NULL));
return val;
}
{
int charset;
- CHECK_NUMBER (ch, 0);
+ CHECK_NUMBER (ch);
charset = CHAR_CHARSET (XFASTINT (ch));
if (!CHARSET_DEFINED_P (charset))
invalid_character (XINT (ch));
{
int from, to;
- CHECK_NUMBER_COERCE_MARKER (beg, 0);
- CHECK_NUMBER_COERCE_MARKER (end, 1);
+ CHECK_NUMBER_COERCE_MARKER (beg);
+ CHECK_NUMBER_COERCE_MARKER (end);
from = min (XFASTINT (beg), XFASTINT (end));
to = max (XFASTINT (beg), XFASTINT (end));
int
chars_in_text (ptr, nbytes)
- unsigned char *ptr;
+ const unsigned char *ptr;
int nbytes;
{
/* current_buffer is null at early stages of Emacs initialization. */
int
multibyte_chars_in_text (ptr, nbytes)
- unsigned char *ptr;
+ const unsigned char *ptr;
int nbytes;
{
- unsigned char *endp;
+ const unsigned char *endp;
int chars, bytes;
endp = ptr + nbytes;
0x80..0x9F are represented by 2 bytes in multibyte text. */
void
parse_str_as_multibyte (str, len, nchars, nbytes)
- unsigned char *str;
+ const unsigned char *str;
int len, *nchars, *nbytes;
{
- unsigned char *endp = str + len;
+ const unsigned char *endp = str + len;
int n, chars = 0, bytes = 0;
while (str < endp)
{
while (n--)
*to++ = *p++;
- }
+ }
else
{
*to++ = LEADING_CODE_8_BIT_CONTROL;
endp = str + len;
safe_bcopy (p, endp - bytes, bytes);
p = endp - bytes;
- while (p < endp)
+ while (p < endp)
{
if (*p < 0x80 || *p >= 0xA0)
*to++ = *p++;
while (p < endp && *p != LEADING_CODE_8_BIT_CONTROL) p++;
to = p;
- while (p < endp)
+ while (p < endp)
{
if (*p == LEADING_CODE_8_BIT_CONTROL)
*to++ = *(p + 1) - 0x20, p += 2;
}
\f
-DEFUN ("string", Fstring, Sstring, 1, MANY, 0,
- doc: /* Concatenate all the argument characters and make the result a string. */)
+DEFUN ("string", Fstring, Sstring, 0, MANY, 0,
+ doc: /* Concatenate all the argument characters and make the result a string.
+usage: (string &rest CHARACTERS) */)
(n, args)
int n;
Lisp_Object *args;
for (i = 0; i < n; i++)
{
- CHECK_NUMBER (args[i], 0);
+ CHECK_NUMBER (args[i]);
if (!multibyte && !SINGLE_BYTE_CHAR_P (XFASTINT (args[i])))
multibyte = 1;
}