207 |
(string) |
(string) |
208 |
Lisp_Object string; |
Lisp_Object string; |
209 |
{ |
{ |
210 |
CHECK_STRING (string, 1); |
CHECK_STRING (string); |
211 |
return make_number (STRING_BYTES (XSTRING (string))); |
return make_number (STRING_BYTES (XSTRING (string))); |
212 |
} |
} |
213 |
|
|
222 |
XSETSTRING (s1, XSYMBOL (s1)->name); |
XSETSTRING (s1, XSYMBOL (s1)->name); |
223 |
if (SYMBOLP (s2)) |
if (SYMBOLP (s2)) |
224 |
XSETSTRING (s2, XSYMBOL (s2)->name); |
XSETSTRING (s2, XSYMBOL (s2)->name); |
225 |
CHECK_STRING (s1, 0); |
CHECK_STRING (s1); |
226 |
CHECK_STRING (s2, 1); |
CHECK_STRING (s2); |
227 |
|
|
228 |
if (XSTRING (s1)->size != XSTRING (s2)->size |
if (XSTRING (s1)->size != XSTRING (s2)->size |
229 |
|| STRING_BYTES (XSTRING (s1)) != STRING_BYTES (XSTRING (s2)) |
|| STRING_BYTES (XSTRING (s1)) != STRING_BYTES (XSTRING (s2)) |
253 |
register int end1_char, end2_char; |
register int end1_char, end2_char; |
254 |
register int i1, i1_byte, i2, i2_byte; |
register int i1, i1_byte, i2, i2_byte; |
255 |
|
|
256 |
CHECK_STRING (str1, 0); |
CHECK_STRING (str1); |
257 |
CHECK_STRING (str2, 1); |
CHECK_STRING (str2); |
258 |
if (NILP (start1)) |
if (NILP (start1)) |
259 |
start1 = make_number (0); |
start1 = make_number (0); |
260 |
if (NILP (start2)) |
if (NILP (start2)) |
261 |
start2 = make_number (0); |
start2 = make_number (0); |
262 |
CHECK_NATNUM (start1, 2); |
CHECK_NATNUM (start1); |
263 |
CHECK_NATNUM (start2, 3); |
CHECK_NATNUM (start2); |
264 |
if (! NILP (end1)) |
if (! NILP (end1)) |
265 |
CHECK_NATNUM (end1, 4); |
CHECK_NATNUM (end1); |
266 |
if (! NILP (end2)) |
if (! NILP (end2)) |
267 |
CHECK_NATNUM (end2, 4); |
CHECK_NATNUM (end2); |
268 |
|
|
269 |
i1 = XINT (start1); |
i1 = XINT (start1); |
270 |
i2 = XINT (start2); |
i2 = XINT (start2); |
349 |
XSETSTRING (s1, XSYMBOL (s1)->name); |
XSETSTRING (s1, XSYMBOL (s1)->name); |
350 |
if (SYMBOLP (s2)) |
if (SYMBOLP (s2)) |
351 |
XSETSTRING (s2, XSYMBOL (s2)->name); |
XSETSTRING (s2, XSYMBOL (s2)->name); |
352 |
CHECK_STRING (s1, 0); |
CHECK_STRING (s1); |
353 |
CHECK_STRING (s2, 1); |
CHECK_STRING (s2); |
354 |
|
|
355 |
i1 = i1_byte = i2 = i2_byte = 0; |
i1 = i1_byte = i2 = i2_byte = 0; |
356 |
|
|
791 |
XVECTOR (val)->contents[toindex++] = elt; |
XVECTOR (val)->contents[toindex++] = elt; |
792 |
else |
else |
793 |
{ |
{ |
794 |
CHECK_NUMBER (elt, 0); |
CHECK_NUMBER (elt); |
795 |
if (SINGLE_BYTE_CHAR_P (XINT (elt))) |
if (SINGLE_BYTE_CHAR_P (XINT (elt))) |
796 |
{ |
{ |
797 |
if (some_multibyte) |
if (some_multibyte) |
1061 |
(string) |
(string) |
1062 |
Lisp_Object string; |
Lisp_Object string; |
1063 |
{ |
{ |
1064 |
CHECK_STRING (string, 0); |
CHECK_STRING (string); |
1065 |
|
|
1066 |
return string_make_multibyte (string); |
return string_make_multibyte (string); |
1067 |
} |
} |
1074 |
(string) |
(string) |
1075 |
Lisp_Object string; |
Lisp_Object string; |
1076 |
{ |
{ |
1077 |
CHECK_STRING (string, 0); |
CHECK_STRING (string); |
1078 |
|
|
1079 |
return string_make_unibyte (string); |
return string_make_unibyte (string); |
1080 |
} |
} |
1090 |
(string) |
(string) |
1091 |
Lisp_Object string; |
Lisp_Object string; |
1092 |
{ |
{ |
1093 |
CHECK_STRING (string, 0); |
CHECK_STRING (string); |
1094 |
|
|
1095 |
if (STRING_MULTIBYTE (string)) |
if (STRING_MULTIBYTE (string)) |
1096 |
{ |
{ |
1116 |
(string) |
(string) |
1117 |
Lisp_Object string; |
Lisp_Object string; |
1118 |
{ |
{ |
1119 |
CHECK_STRING (string, 0); |
CHECK_STRING (string); |
1120 |
|
|
1121 |
if (! STRING_MULTIBYTE (string)) |
if (! STRING_MULTIBYTE (string)) |
1122 |
{ |
{ |
1150 |
{ |
{ |
1151 |
register Lisp_Object tem; |
register Lisp_Object tem; |
1152 |
|
|
1153 |
CHECK_LIST (alist, 0); |
CHECK_LIST (alist); |
1154 |
if (NILP (alist)) |
if (NILP (alist)) |
1155 |
return alist; |
return alist; |
1156 |
alist = concat (1, &alist, Lisp_Cons, 0); |
alist = concat (1, &alist, Lisp_Cons, 0); |
1185 |
if (! (STRINGP (string) || VECTORP (string))) |
if (! (STRINGP (string) || VECTORP (string))) |
1186 |
wrong_type_argument (Qarrayp, string); |
wrong_type_argument (Qarrayp, string); |
1187 |
|
|
1188 |
CHECK_NUMBER (from, 1); |
CHECK_NUMBER (from); |
1189 |
|
|
1190 |
if (STRINGP (string)) |
if (STRINGP (string)) |
1191 |
{ |
{ |
1202 |
} |
} |
1203 |
else |
else |
1204 |
{ |
{ |
1205 |
CHECK_NUMBER (to, 2); |
CHECK_NUMBER (to); |
1206 |
|
|
1207 |
to_char = XINT (to); |
to_char = XINT (to); |
1208 |
if (to_char < 0) |
if (to_char < 0) |
1285 |
register Lisp_Object list; |
register Lisp_Object list; |
1286 |
{ |
{ |
1287 |
register int i, num; |
register int i, num; |
1288 |
CHECK_NUMBER (n, 0); |
CHECK_NUMBER (n); |
1289 |
num = XINT (n); |
num = XINT (n); |
1290 |
for (i = 0; i < num && !NILP (list); i++) |
for (i = 0; i < num && !NILP (list); i++) |
1291 |
{ |
{ |
1311 |
(sequence, n) |
(sequence, n) |
1312 |
register Lisp_Object sequence, n; |
register Lisp_Object sequence, n; |
1313 |
{ |
{ |
1314 |
CHECK_NUMBER (n, 0); |
CHECK_NUMBER (n); |
1315 |
while (1) |
while (1) |
1316 |
{ |
{ |
1317 |
if (CONSP (sequence) || NILP (sequence)) |
if (CONSP (sequence) || NILP (sequence)) |
1891 |
(symbol, propname) |
(symbol, propname) |
1892 |
Lisp_Object symbol, propname; |
Lisp_Object symbol, propname; |
1893 |
{ |
{ |
1894 |
CHECK_SYMBOL (symbol, 0); |
CHECK_SYMBOL (symbol); |
1895 |
return Fplist_get (XSYMBOL (symbol)->plist, propname); |
return Fplist_get (XSYMBOL (symbol)->plist, propname); |
1896 |
} |
} |
1897 |
|
|
1937 |
(symbol, propname, value) |
(symbol, propname, value) |
1938 |
Lisp_Object symbol, propname, value; |
Lisp_Object symbol, propname, value; |
1939 |
{ |
{ |
1940 |
CHECK_SYMBOL (symbol, 0); |
CHECK_SYMBOL (symbol); |
1941 |
XSYMBOL (symbol)->plist |
XSYMBOL (symbol)->plist |
1942 |
= Fplist_put (XSYMBOL (symbol)->plist, propname, value); |
= Fplist_put (XSYMBOL (symbol)->plist, propname, value); |
1943 |
return value; |
return value; |
2098 |
else if (STRINGP (array)) |
else if (STRINGP (array)) |
2099 |
{ |
{ |
2100 |
register unsigned char *p = XSTRING (array)->data; |
register unsigned char *p = XSTRING (array)->data; |
2101 |
CHECK_NUMBER (item, 1); |
CHECK_NUMBER (item); |
2102 |
charval = XINT (item); |
charval = XINT (item); |
2103 |
size = XSTRING (array)->size; |
size = XSTRING (array)->size; |
2104 |
if (STRING_MULTIBYTE (array)) |
if (STRING_MULTIBYTE (array)) |
2148 |
(char_table) |
(char_table) |
2149 |
Lisp_Object char_table; |
Lisp_Object char_table; |
2150 |
{ |
{ |
2151 |
CHECK_CHAR_TABLE (char_table, 0); |
CHECK_CHAR_TABLE (char_table); |
2152 |
|
|
2153 |
return XCHAR_TABLE (char_table)->purpose; |
return XCHAR_TABLE (char_table)->purpose; |
2154 |
} |
} |
2163 |
(char_table) |
(char_table) |
2164 |
Lisp_Object char_table; |
Lisp_Object char_table; |
2165 |
{ |
{ |
2166 |
CHECK_CHAR_TABLE (char_table, 0); |
CHECK_CHAR_TABLE (char_table); |
2167 |
|
|
2168 |
return XCHAR_TABLE (char_table)->parent; |
return XCHAR_TABLE (char_table)->parent; |
2169 |
} |
} |
2177 |
{ |
{ |
2178 |
Lisp_Object temp; |
Lisp_Object temp; |
2179 |
|
|
2180 |
CHECK_CHAR_TABLE (char_table, 0); |
CHECK_CHAR_TABLE (char_table); |
2181 |
|
|
2182 |
if (!NILP (parent)) |
if (!NILP (parent)) |
2183 |
{ |
{ |
2184 |
CHECK_CHAR_TABLE (parent, 0); |
CHECK_CHAR_TABLE (parent); |
2185 |
|
|
2186 |
for (temp = parent; !NILP (temp); temp = XCHAR_TABLE (temp)->parent) |
for (temp = parent; !NILP (temp); temp = XCHAR_TABLE (temp)->parent) |
2187 |
if (EQ (temp, char_table)) |
if (EQ (temp, char_table)) |
2199 |
(char_table, n) |
(char_table, n) |
2200 |
Lisp_Object char_table, n; |
Lisp_Object char_table, n; |
2201 |
{ |
{ |
2202 |
CHECK_CHAR_TABLE (char_table, 1); |
CHECK_CHAR_TABLE (char_table); |
2203 |
CHECK_NUMBER (n, 2); |
CHECK_NUMBER (n); |
2204 |
if (XINT (n) < 0 |
if (XINT (n) < 0 |
2205 |
|| XINT (n) >= CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (char_table))) |
|| XINT (n) >= CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (char_table))) |
2206 |
args_out_of_range (char_table, n); |
args_out_of_range (char_table, n); |
2215 |
(char_table, n, value) |
(char_table, n, value) |
2216 |
Lisp_Object char_table, n, value; |
Lisp_Object char_table, n, value; |
2217 |
{ |
{ |
2218 |
CHECK_CHAR_TABLE (char_table, 1); |
CHECK_CHAR_TABLE (char_table); |
2219 |
CHECK_NUMBER (n, 2); |
CHECK_NUMBER (n); |
2220 |
if (XINT (n) < 0 |
if (XINT (n) < 0 |
2221 |
|| XINT (n) >= CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (char_table))) |
|| XINT (n) >= CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (char_table))) |
2222 |
args_out_of_range (char_table, n); |
args_out_of_range (char_table, n); |
2233 |
(char_table, range) |
(char_table, range) |
2234 |
Lisp_Object char_table, range; |
Lisp_Object char_table, range; |
2235 |
{ |
{ |
2236 |
CHECK_CHAR_TABLE (char_table, 0); |
CHECK_CHAR_TABLE (char_table); |
2237 |
|
|
2238 |
if (EQ (range, Qnil)) |
if (EQ (range, Qnil)) |
2239 |
return XCHAR_TABLE (char_table)->defalt; |
return XCHAR_TABLE (char_table)->defalt; |
2244 |
Lisp_Object charset_info; |
Lisp_Object charset_info; |
2245 |
|
|
2246 |
charset_info = Fget (range, Qcharset); |
charset_info = Fget (range, Qcharset); |
2247 |
CHECK_VECTOR (charset_info, 0); |
CHECK_VECTOR (charset_info); |
2248 |
|
|
2249 |
return Faref (char_table, |
return Faref (char_table, |
2250 |
make_number (XINT (XVECTOR (charset_info)->contents[0]) |
make_number (XINT (XVECTOR (charset_info)->contents[0]) |
2281 |
{ |
{ |
2282 |
int i; |
int i; |
2283 |
|
|
2284 |
CHECK_CHAR_TABLE (char_table, 0); |
CHECK_CHAR_TABLE (char_table); |
2285 |
|
|
2286 |
if (EQ (range, Qt)) |
if (EQ (range, Qt)) |
2287 |
for (i = 0; i < CHAR_TABLE_ORDINARY_SLOTS; i++) |
for (i = 0; i < CHAR_TABLE_ORDINARY_SLOTS; i++) |
2293 |
Lisp_Object charset_info; |
Lisp_Object charset_info; |
2294 |
|
|
2295 |
charset_info = Fget (range, Qcharset); |
charset_info = Fget (range, Qcharset); |
2296 |
CHECK_VECTOR (charset_info, 0); |
CHECK_VECTOR (charset_info); |
2297 |
|
|
2298 |
return Faset (char_table, |
return Faset (char_table, |
2299 |
make_number (XINT (XVECTOR (charset_info)->contents[0]) |
make_number (XINT (XVECTOR (charset_info)->contents[0]) |
2335 |
int c, charset, code1, code2; |
int c, charset, code1, code2; |
2336 |
Lisp_Object temp; |
Lisp_Object temp; |
2337 |
|
|
2338 |
CHECK_CHAR_TABLE (char_table, 0); |
CHECK_CHAR_TABLE (char_table); |
2339 |
CHECK_NUMBER (ch, 1); |
CHECK_NUMBER (ch); |
2340 |
|
|
2341 |
c = XINT (ch); |
c = XINT (ch); |
2342 |
SPLIT_CHAR (c, charset, code1, code2); |
SPLIT_CHAR (c, charset, code1, code2); |
2424 |
int dim; |
int dim; |
2425 |
int i, j; |
int i, j; |
2426 |
|
|
2427 |
CHECK_CHAR_TABLE (table, 0); |
CHECK_CHAR_TABLE (table); |
2428 |
|
|
2429 |
for (i = CHAR_TABLE_SINGLE_BYTE_SLOTS; i < CHAR_TABLE_ORDINARY_SLOTS; i++) |
for (i = CHAR_TABLE_SINGLE_BYTE_SLOTS; i < CHAR_TABLE_ORDINARY_SLOTS; i++) |
2430 |
{ |
{ |
2533 |
/* The depth of char table is at most 3. */ |
/* The depth of char table is at most 3. */ |
2534 |
Lisp_Object indices[3]; |
Lisp_Object indices[3]; |
2535 |
|
|
2536 |
CHECK_CHAR_TABLE (char_table, 1); |
CHECK_CHAR_TABLE (char_table); |
2537 |
|
|
2538 |
map_char_table (NULL, function, char_table, char_table, 0, indices); |
map_char_table (NULL, function, char_table, char_table, 0, indices); |
2539 |
return Qnil; |
return Qnil; |
2817 |
|
|
2818 |
map = Fsymbol_value (intern ("query-replace-map")); |
map = Fsymbol_value (intern ("query-replace-map")); |
2819 |
|
|
2820 |
CHECK_STRING (prompt, 0); |
CHECK_STRING (prompt); |
2821 |
xprompt = prompt; |
xprompt = prompt; |
2822 |
GCPRO2 (prompt, xprompt); |
GCPRO2 (prompt, xprompt); |
2823 |
|
|
2947 |
Lisp_Object args[2]; |
Lisp_Object args[2]; |
2948 |
struct gcpro gcpro1; |
struct gcpro gcpro1; |
2949 |
|
|
2950 |
CHECK_STRING (prompt, 0); |
CHECK_STRING (prompt); |
2951 |
|
|
2952 |
#ifdef HAVE_MENUS |
#ifdef HAVE_MENUS |
2953 |
if ((NILP (last_nonmenu_event) || CONSP (last_nonmenu_event)) |
if ((NILP (last_nonmenu_event) || CONSP (last_nonmenu_event)) |
3043 |
Lisp_Object feature, subfeature; |
Lisp_Object feature, subfeature; |
3044 |
{ |
{ |
3045 |
register Lisp_Object tem; |
register Lisp_Object tem; |
3046 |
CHECK_SYMBOL (feature, 0); |
CHECK_SYMBOL (feature); |
3047 |
tem = Fmemq (feature, Vfeatures); |
tem = Fmemq (feature, Vfeatures); |
3048 |
if (!NILP (tem) && !NILP (subfeature)) |
if (!NILP (tem) && !NILP (subfeature)) |
3049 |
tem = Fmemq (subfeature, Fget (feature, Qsubfeatures)); |
tem = Fmemq (subfeature, Fget (feature, Qsubfeatures)); |
3058 |
Lisp_Object feature, subfeatures; |
Lisp_Object feature, subfeatures; |
3059 |
{ |
{ |
3060 |
register Lisp_Object tem; |
register Lisp_Object tem; |
3061 |
CHECK_SYMBOL (feature, 0); |
CHECK_SYMBOL (feature); |
3062 |
if (!NILP (Vautoload_queue)) |
if (!NILP (Vautoload_queue)) |
3063 |
Vautoload_queue = Fcons (Fcons (Vfeatures, Qnil), Vautoload_queue); |
Vautoload_queue = Fcons (Fcons (Vfeatures, Qnil), Vautoload_queue); |
3064 |
tem = Fmemq (feature, Vfeatures); |
tem = Fmemq (feature, Vfeatures); |
3106 |
register Lisp_Object tem; |
register Lisp_Object tem; |
3107 |
struct gcpro gcpro1, gcpro2; |
struct gcpro gcpro1, gcpro2; |
3108 |
|
|
3109 |
CHECK_SYMBOL (feature, 0); |
CHECK_SYMBOL (feature); |
3110 |
|
|
3111 |
tem = Fmemq (feature, Vfeatures); |
tem = Fmemq (feature, Vfeatures); |
3112 |
|
|
3194 |
(widget, property, value) |
(widget, property, value) |
3195 |
Lisp_Object widget, property, value; |
Lisp_Object widget, property, value; |
3196 |
{ |
{ |
3197 |
CHECK_CONS (widget, 1); |
CHECK_CONS (widget); |
3198 |
XSETCDR (widget, Fplist_put (XCDR (widget), property, value)); |
XSETCDR (widget, Fplist_put (XCDR (widget), property, value)); |
3199 |
return value; |
return value; |
3200 |
} |
} |
3212 |
{ |
{ |
3213 |
if (NILP (widget)) |
if (NILP (widget)) |
3214 |
return Qnil; |
return Qnil; |
3215 |
CHECK_CONS (widget, 1); |
CHECK_CONS (widget); |
3216 |
tmp = Fplist_member (XCDR (widget), property); |
tmp = Fplist_member (XCDR (widget), property); |
3217 |
if (CONSP (tmp)) |
if (CONSP (tmp)) |
3218 |
{ |
{ |
3410 |
char *encoded; |
char *encoded; |
3411 |
Lisp_Object encoded_string; |
Lisp_Object encoded_string; |
3412 |
|
|
3413 |
CHECK_STRING (string, 1); |
CHECK_STRING (string); |
3414 |
|
|
3415 |
/* We need to allocate enough room for encoding the text. |
/* We need to allocate enough room for encoding the text. |
3416 |
We need 33 1/3% more space, plus a newline every 76 |
We need 33 1/3% more space, plus a newline every 76 |
3616 |
int length, decoded_length; |
int length, decoded_length; |
3617 |
Lisp_Object decoded_string; |
Lisp_Object decoded_string; |
3618 |
|
|
3619 |
CHECK_STRING (string, 1); |
CHECK_STRING (string); |
3620 |
|
|
3621 |
length = STRING_BYTES (XSTRING (string)); |
length = STRING_BYTES (XSTRING (string)); |
3622 |
/* We need to allocate enough room for decoding the text. */ |
/* We need to allocate enough room for decoding the text. */ |
3825 |
check_hash_table (obj) |
check_hash_table (obj) |
3826 |
Lisp_Object obj; |
Lisp_Object obj; |
3827 |
{ |
{ |
3828 |
CHECK_HASH_TABLE (obj, 0); |
CHECK_HASH_TABLE (obj); |
3829 |
return XHASH_TABLE (obj); |
return XHASH_TABLE (obj); |
3830 |
} |
} |
3831 |
|
|
5109 |
|
|
5110 |
if (!NILP (start)) |
if (!NILP (start)) |
5111 |
{ |
{ |
5112 |
CHECK_NUMBER (start, 1); |
CHECK_NUMBER (start); |
5113 |
|
|
5114 |
start_char = XINT (start); |
start_char = XINT (start); |
5115 |
|
|
5126 |
} |
} |
5127 |
else |
else |
5128 |
{ |
{ |
5129 |
CHECK_NUMBER (end, 2); |
CHECK_NUMBER (end); |
5130 |
|
|
5131 |
end_char = XINT (end); |
end_char = XINT (end); |
5132 |
|
|
5142 |
} |
} |
5143 |
else |
else |
5144 |
{ |
{ |
5145 |
CHECK_BUFFER (object, 0); |
CHECK_BUFFER (object); |
5146 |
|
|
5147 |
bp = XBUFFER (object); |
bp = XBUFFER (object); |
5148 |
|
|
5150 |
b = BUF_BEGV (bp); |
b = BUF_BEGV (bp); |
5151 |
else |
else |
5152 |
{ |
{ |
5153 |
CHECK_NUMBER_COERCE_MARKER (start, 0); |
CHECK_NUMBER_COERCE_MARKER (start); |
5154 |
b = XINT (start); |
b = XINT (start); |
5155 |
} |
} |
5156 |
|
|
5158 |
e = BUF_ZV (bp); |
e = BUF_ZV (bp); |
5159 |
else |
else |
5160 |
{ |
{ |
5161 |
CHECK_NUMBER_COERCE_MARKER (end, 1); |
CHECK_NUMBER_COERCE_MARKER (end); |
5162 |
e = XINT (end); |
e = XINT (end); |
5163 |
} |
} |
5164 |
|
|