Mercurial > hg > xemacs-beta

comparison src/syntax.c @ 5581:56144c8593a8

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Mechanically change INT to FIXNUM in our sources. src/ChangeLog addition: 2011-10-09 Aidan Kehoe <kehoea@parhasard.net> [...] Mechanically change INT (where it refers to non-bignum Lisp integers) to FIXNUM in our sources. Done for the following functions, enums, and macros: Lisp_Type_Int_Even, Lisp_Type_Int_Odd, INT_GCBITS, INT_VALBITS, make_int(), INTP(), XINT(), CHECK_INT(), XREALINT(), INT_PLUS(), INT_MINUS(), EMACS_INT_MAX (to MOST_POSITIVE_FIXNUM), EMACS_INT_MIN (to MOST_NEGATIVE_FIXNUM), NUMBER_FITS_IN_AN_EMACS_INT() to NUMBER_FITS_IN_A_FIXNUM(), XFLOATINT, XCHAR_OR_INT, INT_OR_FLOAT. The EMACS_INT typedef was not changed, it does not describe non-bignum Lisp integers. Script that did the change available in http://mid.gmane.org/20067.17650.181273.12014@parhasard.net . modules/ChangeLog addition: 2011-10-09 Aidan Kehoe <kehoea@parhasard.net> [...] Mechanically change INT to FIXNUM, where the usage describes non-bignum Lisp integers. See the src/ChangeLog entry for more details. man/ChangeLog addition: 2011-10-09 Aidan Kehoe <kehoea@parhasard.net> * internals/internals.texi (How Lisp Objects Are Represented in C): * internals/internals.texi (Integers and Characters): Mechanically change INT to FIXNUM, where the usage describes non-bignum Lisp integers.
author Aidan Kehoe <kehoea@parhasard.net>
date Sun, 09 Oct 2011 09:51:57 +0100
parents 85210c453a97
children
comparison
equal deleted inserted replaced
5580:a0e81357194e 5581:56144c8593a8
192 */ 192 */
193 (buffer)) 193 (buffer))
194 { 194 {
195 struct buffer *buf = decode_buffer (buffer, 0); 195 struct buffer *buf = decode_buffer (buffer, 0);
196 struct syntax_cache *cache = buf->syntax_cache; 196 struct syntax_cache *cache = buf->syntax_cache;
197 return list4 (cache->start, cache->end, make_int (cache->prev_change), 197 return list4 (cache->start, cache->end, make_fixnum (cache->prev_change),
198 make_int (cache->next_change)); 198 make_fixnum (cache->next_change));
199 } 199 }
200 200
201 #endif /* DEBUG_XEMACS */ 201 #endif /* DEBUG_XEMACS */
202 202
203 DEFUN ("standard-syntax-table", Fstandard_syntax_table, 0, 0, 0, /* 203 DEFUN ("standard-syntax-table", Fstandard_syntax_table, 0, 0, 0, /*
231 syntax_table = check_syntax_table (syntax_table, Qnil); 231 syntax_table = check_syntax_table (syntax_table, Qnil);
232 buf->syntax_table = syntax_table; 232 buf->syntax_table = syntax_table;
233 buf->mirror_syntax_table = XCHAR_TABLE (syntax_table)->mirror_table; 233 buf->mirror_syntax_table = XCHAR_TABLE (syntax_table)->mirror_table;
234 syntax_cache_table_was_changed (buf); 234 syntax_cache_table_was_changed (buf);
235 /* Indicate that this buffer now has a specified syntax table. */ 235 /* Indicate that this buffer now has a specified syntax table. */
236 buf->local_var_flags |= XINT (buffer_local_flags.syntax_table); 236 buf->local_var_flags |= XFIXNUM (buffer_local_flags.syntax_table);
237 return syntax_table; 237 return syntax_table;
238 } 238 }
239 239
240 240
241 241
290 in the life of the cache */ 290 in the life of the cache */
291 { 291 {
292 if (BUFFERP (cache->object)) 292 if (BUFFERP (cache->object))
293 { 293 {
294 /* make known region zero-length and reset insertion behavior */ 294 /* make known region zero-length and reset insertion behavior */
295 Fset_marker (cache->start, make_int (1), cache->object); 295 Fset_marker (cache->start, make_fixnum (1), cache->object);
296 Fset_marker (cache->end, make_int (1), cache->object); 296 Fset_marker (cache->end, make_fixnum (1), cache->object);
297 Fset_marker_insertion_type (cache->start, Qnil); 297 Fset_marker_insertion_type (cache->start, Qnil);
298 Fset_marker_insertion_type (cache->end, Qt); 298 Fset_marker_insertion_type (cache->end, Qt);
299 } 299 }
300 /* #### Should reset "cache->source" here? 300 /* #### Should reset "cache->source" here?
301 If so, also reset tables. */ 301 If so, also reset tables. */
302 if (valid_everywhere) 302 if (valid_everywhere)
303 { 303 {
304 cache->prev_change = EMACS_INT_MIN; 304 cache->prev_change = MOST_NEGATIVE_FIXNUM;
305 cache->next_change = EMACS_INT_MAX; 305 cache->next_change = MOST_POSITIVE_FIXNUM;
306 } 306 }
307 else /* valid nowhere */ 307 else /* valid nowhere */
308 { 308 {
309 cache->prev_change = -1; 309 cache->prev_change = -1;
310 cache->next_change = -1; 310 cache->next_change = -1;
488 /* If we are at the beginning or end of buffer, check to see if there's 488 /* If we are at the beginning or end of buffer, check to see if there's
489 a zero-length `syntax-table' extent there (highly unlikely); if not, 489 a zero-length `syntax-table' extent there (highly unlikely); if not,
490 then we can safely make the end closed, so it will take in newly 490 then we can safely make the end closed, so it will take in newly
491 inserted text. (If such an extent is inserted, we will be informed 491 inserted text. (If such an extent is inserted, we will be informed
492 through signal_syntax_cache_extent_changed().) */ 492 through signal_syntax_cache_extent_changed().) */
493 Fset_marker (cache->start, make_int (cache->prev_change), cache->object); 493 Fset_marker (cache->start, make_fixnum (cache->prev_change), cache->object);
494 Fset_marker_insertion_type 494 Fset_marker_insertion_type
495 (cache->start, 495 (cache->start,
496 at_begin && NILP (extent_at (prev, cache->object, Qsyntax_table, 496 at_begin && NILP (extent_at (prev, cache->object, Qsyntax_table,
497 NULL, EXTENT_AT_AT, 0)) 497 NULL, EXTENT_AT_AT, 0))
498 ? Qnil : Qt); 498 ? Qnil : Qt);
499 Fset_marker (cache->end, make_int (cache->next_change), cache->object); 499 Fset_marker (cache->end, make_fixnum (cache->next_change), cache->object);
500 Fset_marker_insertion_type 500 Fset_marker_insertion_type
501 (cache->end, 501 (cache->end,
502 at_end && NILP (extent_at (next, cache->object, Qsyntax_table, 502 at_end && NILP (extent_at (next, cache->object, Qsyntax_table,
503 NULL, EXTENT_AT_AT, 0)) 503 NULL, EXTENT_AT_AT, 0))
504 ? Qt : Qnil); 504 ? Qt : Qnil);
511 cache->mirror_table = XCHAR_TABLE (tmp_table)->mirror_table; 511 cache->mirror_table = XCHAR_TABLE (tmp_table)->mirror_table;
512 #ifdef NOT_WORTH_THE_EFFORT 512 #ifdef NOT_WORTH_THE_EFFORT
513 update_mirror_syntax_if_dirty (cache->mirror_table); 513 update_mirror_syntax_if_dirty (cache->mirror_table);
514 #endif /* NOT_WORTH_THE_EFFORT */ 514 #endif /* NOT_WORTH_THE_EFFORT */
515 } 515 }
516 else if (CONSP (tmp_table) && INTP (XCAR (tmp_table))) 516 else if (CONSP (tmp_table) && FIXNUMP (XCAR (tmp_table)))
517 { 517 {
518 cache->source = syntax_source_property_code; 518 cache->source = syntax_source_property_code;
519 cache->syntax_code = XINT (XCAR (tmp_table)); 519 cache->syntax_code = XFIXNUM (XCAR (tmp_table));
520 } 520 }
521 else 521 else
522 { 522 {
523 cache->source = syntax_source_buffer_table; 523 cache->source = syntax_source_buffer_table;
524 cache->syntax_table = BUFFER_SYNTAX_TABLE (cache->buffer); 524 cache->syntax_table = BUFFER_SYNTAX_TABLE (cache->buffer);
701 Lisp_Object code = get_char_table (ch, syntax_table); 701 Lisp_Object code = get_char_table (ch, syntax_table);
702 Lisp_Object code2 = code; 702 Lisp_Object code2 = code;
703 703
704 if (CONSP (code)) 704 if (CONSP (code))
705 code2 = XCAR (code); 705 code2 = XCAR (code);
706 if (SYNTAX_FROM_CODE (XINT (code2)) == Sinherit) 706 if (SYNTAX_FROM_CODE (XFIXNUM (code2)) == Sinherit)
707 code = get_char_table (ch, Vstandard_syntax_table); 707 code = get_char_table (ch, Vstandard_syntax_table);
708 708
709 return CONSP (code) ? XCDR (code) : Qnil; 709 return CONSP (code) ? XCDR (code) : Qnil;
710 } 710 }
711 711
865 865
866 if (NILP (count)) 866 if (NILP (count))
867 n = 1; 867 n = 1;
868 else 868 else
869 { 869 {
870 CHECK_INT (count); 870 CHECK_FIXNUM (count);
871 n = XINT (count); 871 n = XFIXNUM (count);
872 } 872 }
873 873
874 val = scan_words (buf, BUF_PT (buf), n); 874 val = scan_words (buf, BUF_PT (buf), n);
875 if (val) 875 if (val)
876 { 876 {
1181 1181
1182 if (NILP (count)) 1182 if (NILP (count))
1183 n = 1; 1183 n = 1;
1184 else 1184 else
1185 { 1185 {
1186 CHECK_INT (count); 1186 CHECK_FIXNUM (count);
1187 n = XINT (count); 1187 n = XFIXNUM (count);
1188 } 1188 }
1189 1189
1190 from = BUF_PT (buf); 1190 from = BUF_PT (buf);
1191 1191
1192 scache = setup_buffer_syntax_cache (buf, from, n); 1192 scache = setup_buffer_syntax_cache (buf, from, n);
1502 { 1502 {
1503 if (noerror) 1503 if (noerror)
1504 return Qnil; 1504 return Qnil;
1505 signal_error_2 (Qscan_error, 1505 signal_error_2 (Qscan_error,
1506 "Containing expression ends prematurely", 1506 "Containing expression ends prematurely",
1507 make_int (last_good), make_int (from)); 1507 make_fixnum (last_good), make_fixnum (from));
1508 } 1508 }
1509 break; 1509 break;
1510 1510
1511 case Sstring_fence: 1511 case Sstring_fence:
1512 case Sstring: 1512 case Sstring:
1676 { 1676 {
1677 if (noerror) 1677 if (noerror)
1678 return Qnil; 1678 return Qnil;
1679 signal_error_2 (Qscan_error, 1679 signal_error_2 (Qscan_error,
1680 "Containing expression ends prematurely", 1680 "Containing expression ends prematurely",
1681 make_int (last_good), make_int (from)); 1681 make_fixnum (last_good), make_fixnum (from));
1682 } 1682 }
1683 break; 1683 break;
1684 1684
1685 case Scomment_fence: 1685 case Scomment_fence:
1686 comstyle = ST_COMMENT_STYLE; 1686 comstyle = ST_COMMENT_STYLE;
1742 done2: 1742 done2:
1743 count++; 1743 count++;
1744 } 1744 }
1745 1745
1746 1746
1747 return (make_int (from)); 1747 return (make_fixnum (from));
1748 1748
1749 lose: 1749 lose:
1750 if (!noerror) 1750 if (!noerror)
1751 signal_error_2 (Qscan_error, "Unbalanced parentheses", 1751 signal_error_2 (Qscan_error, "Unbalanced parentheses",
1752 make_int (last_good), make_int (from)); 1752 make_fixnum (last_good), make_fixnum (from));
1753 return Qnil; 1753 return Qnil;
1754 } 1754 }
1755 1755
1756 int 1756 int
1757 char_quoted (struct buffer *buf, Charbpos pos) 1757 char_quoted (struct buffer *buf, Charbpos pos)
1798 */ 1798 */
1799 (from, count, depth, buffer, noerror)) 1799 (from, count, depth, buffer, noerror))
1800 { 1800 {
1801 struct buffer *buf; 1801 struct buffer *buf;
1802 1802
1803 CHECK_INT (from); 1803 CHECK_FIXNUM (from);
1804 CHECK_INT (count); 1804 CHECK_FIXNUM (count);
1805 CHECK_INT (depth); 1805 CHECK_FIXNUM (depth);
1806 buf = decode_buffer (buffer, 0); 1806 buf = decode_buffer (buffer, 0);
1807 1807
1808 return scan_lists (buf, XINT (from), XINT (count), XINT (depth), 0, 1808 return scan_lists (buf, XFIXNUM (from), XFIXNUM (count), XFIXNUM (depth), 0,
1809 !NILP (noerror)); 1809 !NILP (noerror));
1810 } 1810 }
1811 1811
1812 DEFUN ("scan-sexps", Fscan_sexps, 2, 4, 0, /* 1812 DEFUN ("scan-sexps", Fscan_sexps, 2, 4, 0, /*
1813 Scan from position FROM by COUNT balanced expressions. 1813 Scan from position FROM by COUNT balanced expressions.
1826 but before count is used up, nil is returned. 1826 but before count is used up, nil is returned.
1827 */ 1827 */
1828 (from, count, buffer, noerror)) 1828 (from, count, buffer, noerror))
1829 { 1829 {
1830 struct buffer *buf = decode_buffer (buffer, 0); 1830 struct buffer *buf = decode_buffer (buffer, 0);
1831 CHECK_INT (from); 1831 CHECK_FIXNUM (from);
1832 CHECK_INT (count); 1832 CHECK_FIXNUM (count);
1833 1833
1834 return scan_lists (buf, XINT (from), XINT (count), 0, 1, !NILP (noerror)); 1834 return scan_lists (buf, XFIXNUM (from), XFIXNUM (count), 0, 1, !NILP (noerror));
1835 } 1835 }
1836 1836
1837 DEFUN ("backward-prefix-chars", Fbackward_prefix_chars, 0, 1, 0, /* 1837 DEFUN ("backward-prefix-chars", Fbackward_prefix_chars, 0, 1, 0, /*
1838 Move point backward over any number of chars with quote or prefix syntax. 1838 Move point backward over any number of chars with quote or prefix syntax.
1839 Optional BUFFER defaults to the current buffer. 1839 Optional BUFFER defaults to the current buffer.
1899 } 1899 }
1900 else 1900 else
1901 { 1901 {
1902 tem = Fcar (oldstate); /* elt 0, depth */ 1902 tem = Fcar (oldstate); /* elt 0, depth */
1903 if (!NILP (tem)) 1903 if (!NILP (tem))
1904 depth = XINT (tem); 1904 depth = XFIXNUM (tem);
1905 else 1905 else
1906 depth = 0; 1906 depth = 0;
1907 1907
1908 oldstate = Fcdr (oldstate); 1908 oldstate = Fcdr (oldstate);
1909 oldstate = Fcdr (oldstate); 1909 oldstate = Fcdr (oldstate);
1910 oldstate = Fcdr (oldstate); 1910 oldstate = Fcdr (oldstate);
1911 tem = Fcar (oldstate); /* elt 3, instring */ 1911 tem = Fcar (oldstate); /* elt 3, instring */
1912 state.instring = ( !NILP (tem) 1912 state.instring = ( !NILP (tem)
1913 ? ( INTP (tem) ? XINT (tem) : ST_STRING_STYLE) 1913 ? ( FIXNUMP (tem) ? XFIXNUM (tem) : ST_STRING_STYLE)
1914 : -1); 1914 : -1);
1915 1915
1916 oldstate = Fcdr (oldstate); 1916 oldstate = Fcdr (oldstate);
1917 tem = Fcar (oldstate); /* elt 4, incomment */ 1917 tem = Fcar (oldstate); /* elt 4, incomment */
1918 state.incomment = !NILP (tem); 1918 state.incomment = !NILP (tem);
1930 state.comstyle = NILP (tem) ? 0 : ( EQ (tem, Qsyntax_table) 1930 state.comstyle = NILP (tem) ? 0 : ( EQ (tem, Qsyntax_table)
1931 ? ST_COMMENT_STYLE : 1 ); 1931 ? ST_COMMENT_STYLE : 1 );
1932 1932
1933 oldstate = Fcdr (oldstate); /* elt 8, start of last comment/string */ 1933 oldstate = Fcdr (oldstate); /* elt 8, start of last comment/string */
1934 tem = Fcar (oldstate); 1934 tem = Fcar (oldstate);
1935 state.comstr_start = NILP (tem) ? -1 : XINT (tem); 1935 state.comstr_start = NILP (tem) ? -1 : XFIXNUM (tem);
1936 1936
1937 /* elt 9, char numbers of starts-of-expression of levels 1937 /* elt 9, char numbers of starts-of-expression of levels
1938 (starting from outermost). */ 1938 (starting from outermost). */
1939 oldstate = Fcdr (oldstate); 1939 oldstate = Fcdr (oldstate);
1940 tem = Fcar (oldstate); /* elt 9, intermediate data for 1940 tem = Fcar (oldstate); /* elt 9, intermediate data for
1941 continuation of parsing (subject 1941 continuation of parsing (subject
1942 to change). */ 1942 to change). */
1943 while (!NILP (tem)) /* >= second enclosing sexps. */ 1943 while (!NILP (tem)) /* >= second enclosing sexps. */
1944 { 1944 {
1945 curlevel->last = XINT (Fcar (tem)); 1945 curlevel->last = XFIXNUM (Fcar (tem));
1946 if (++curlevel == endlevel) 1946 if (++curlevel == endlevel)
1947 stack_overflow ("Nesting too deep for parser", 1947 stack_overflow ("Nesting too deep for parser",
1948 make_int (curlevel - levelstart)); 1948 make_fixnum (curlevel - levelstart));
1949 curlevel->prev = -1; 1949 curlevel->prev = -1;
1950 curlevel->last = -1; 1950 curlevel->last = -1;
1951 tem = Fcdr (tem); 1951 tem = Fcdr (tem);
1952 } 1952 }
1953 } 1953 }
2086 if (stopbefore) goto stop; /* this arg means stop at sexp start */ 2086 if (stopbefore) goto stop; /* this arg means stop at sexp start */
2087 depth++; 2087 depth++;
2088 curlevel->last = from - 1; 2088 curlevel->last = from - 1;
2089 if (++curlevel == endlevel) 2089 if (++curlevel == endlevel)
2090 stack_overflow ("Nesting too deep for parser", 2090 stack_overflow ("Nesting too deep for parser",
2091 make_int (curlevel - levelstart)); 2091 make_fixnum (curlevel - levelstart));
2092 curlevel->prev = -1; 2092 curlevel->prev = -1;
2093 curlevel->last = -1; 2093 curlevel->last = -1;
2094 if (targetdepth == depth) goto done; 2094 if (targetdepth == depth) goto done;
2095 break; 2095 break;
2096 2096
2196 state.prevlevelstart 2196 state.prevlevelstart
2197 = (curlevel == levelstart) ? -1 : (curlevel - 1)->last; 2197 = (curlevel == levelstart) ? -1 : (curlevel - 1)->last;
2198 state.location = from; 2198 state.location = from;
2199 state.levelstarts = Qnil; 2199 state.levelstarts = Qnil;
2200 while (--curlevel >= levelstart) 2200 while (--curlevel >= levelstart)
2201 state.levelstarts = Fcons (make_int (curlevel->last), 2201 state.levelstarts = Fcons (make_fixnum (curlevel->last),
2202 state.levelstarts); 2202 state.levelstarts);
2203 2203
2204 *stateptr = state; 2204 *stateptr = state;
2205 } 2205 }
2206 2206
2246 struct buffer *buf = decode_buffer (buffer, 0); 2246 struct buffer *buf = decode_buffer (buffer, 0);
2247 Lisp_Object val; 2247 Lisp_Object val;
2248 2248
2249 if (!NILP (targetdepth)) 2249 if (!NILP (targetdepth))
2250 { 2250 {
2251 CHECK_INT (targetdepth); 2251 CHECK_FIXNUM (targetdepth);
2252 target = XINT (targetdepth); 2252 target = XFIXNUM (targetdepth);
2253 } 2253 }
2254 else 2254 else
2255 target = -100000; /* We won't reach this depth */ 2255 target = -100000; /* We won't reach this depth */
2256 2256
2257 get_buffer_range_char (buf, from, to, &start, &end, 0); 2257 get_buffer_range_char (buf, from, to, &start, &end, 0);
2263 2263
2264 /* reverse order */ 2264 /* reverse order */
2265 val = Qnil; 2265 val = Qnil;
2266 val = Fcons (state.levelstarts, val); 2266 val = Fcons (state.levelstarts, val);
2267 val = Fcons ((state.incomment || (state.instring >= 0)) 2267 val = Fcons ((state.incomment || (state.instring >= 0))
2268 ? make_int (state.comstr_start) : Qnil, val); 2268 ? make_fixnum (state.comstr_start) : Qnil, val);
2269 val = Fcons (state.comstyle ? (state.comstyle == ST_COMMENT_STYLE 2269 val = Fcons (state.comstyle ? (state.comstyle == ST_COMMENT_STYLE
2270 ? Qsyntax_table : Qt) : Qnil, val); 2270 ? Qsyntax_table : Qt) : Qnil, val);
2271 val = Fcons (make_int (state.mindepth), val); 2271 val = Fcons (make_fixnum (state.mindepth), val);
2272 val = Fcons (state.quoted ? Qt : Qnil, val); 2272 val = Fcons (state.quoted ? Qt : Qnil, val);
2273 val = Fcons (state.incomment ? Qt : Qnil, val); 2273 val = Fcons (state.incomment ? Qt : Qnil, val);
2274 val = Fcons (state.instring < 0 2274 val = Fcons (state.instring < 0
2275 ? Qnil 2275 ? Qnil
2276 : (state.instring == ST_STRING_STYLE 2276 : (state.instring == ST_STRING_STYLE
2277 ? Qt : make_int (state.instring)), val); 2277 ? Qt : make_fixnum (state.instring)), val);
2278 val = Fcons (state.thislevelstart < 0 ? Qnil : 2278 val = Fcons (state.thislevelstart < 0 ? Qnil :
2279 make_int (state.thislevelstart), val); 2279 make_fixnum (state.thislevelstart), val);
2280 val = Fcons (state.prevlevelstart < 0 ? Qnil : 2280 val = Fcons (state.prevlevelstart < 0 ? Qnil :
2281 make_int (state.prevlevelstart), val); 2281 make_fixnum (state.prevlevelstart), val);
2282 val = Fcons (make_int (state.depth), val); 2282 val = Fcons (make_fixnum (state.depth), val);
2283 2283
2284 return val; 2284 return val;
2285 } 2285 }
2286 2286
2287 2287
2308 { 2308 {
2309 Lisp_Object mirrortab = GET_LISP_FROM_VOID (arg); 2309 Lisp_Object mirrortab = GET_LISP_FROM_VOID (arg);
2310 2310
2311 if (CONSP (val)) 2311 if (CONSP (val))
2312 val = XCAR (val); 2312 val = XCAR (val);
2313 if (SYNTAX_FROM_CODE (XINT (val)) != Sinherit) 2313 if (SYNTAX_FROM_CODE (XFIXNUM (val)) != Sinherit)
2314 put_char_table (mirrortab, range, val); 2314 put_char_table (mirrortab, range, val);
2315 return 0; 2315 return 0;
2316 } 2316 }
2317 2317
2318 static int 2318 static int
2321 Lisp_Object val, void *arg) 2321 Lisp_Object val, void *arg)
2322 { 2322 {
2323 Lisp_Object mirrortab = GET_LISP_FROM_VOID (arg); 2323 Lisp_Object mirrortab = GET_LISP_FROM_VOID (arg);
2324 if (CONSP (val)) 2324 if (CONSP (val))
2325 val = XCAR (val); 2325 val = XCAR (val);
2326 if (SYNTAX_FROM_CODE (XINT (val)) != Sinherit) 2326 if (SYNTAX_FROM_CODE (XFIXNUM (val)) != Sinherit)
2327 { 2327 {
2328 Lisp_Object existing = 2328 Lisp_Object existing =
2329 updating_mirror_get_range_char_table (range, mirrortab, 2329 updating_mirror_get_range_char_table (range, mirrortab,
2330 Vbogus_syntax_table_value); 2330 Vbogus_syntax_table_value);
2331 if (NILP (existing)) 2331 if (NILP (existing))
2370 standard syntax table */ 2370 standard syntax table */
2371 if (!EQ (table, Vstandard_syntax_table) && !NILP (Vstandard_syntax_table)) 2371 if (!EQ (table, Vstandard_syntax_table) && !NILP (Vstandard_syntax_table))
2372 map_char_table (Vstandard_syntax_table, &range, 2372 map_char_table (Vstandard_syntax_table, &range,
2373 copy_if_not_already_present, STORE_LISP_IN_VOID (mirrortab)); 2373 copy_if_not_already_present, STORE_LISP_IN_VOID (mirrortab));
2374 /* The resetting made the default be Qnil. Put it back to Sword. */ 2374 /* The resetting made the default be Qnil. Put it back to Sword. */
2375 set_char_table_default (mirrortab, make_int (Sword)); 2375 set_char_table_default (mirrortab, make_fixnum (Sword));
2376 XCHAR_TABLE (mirrortab)->dirty = 0; 2376 XCHAR_TABLE (mirrortab)->dirty = 0;
2377 } 2377 }
2378 2378
2379 /* Called from chartab.c when a change is made to a syntax table. 2379 /* Called from chartab.c when a change is made to a syntax table.
2380 If this is the standard syntax table, we need to recompute 2380 If this is the standard syntax table, we need to recompute
2471 2471
2472 static void 2472 static void
2473 define_standard_syntax (const UExtbyte *p, enum syntaxcode syn) 2473 define_standard_syntax (const UExtbyte *p, enum syntaxcode syn)
2474 { 2474 {
2475 for (; *p; p++) 2475 for (; *p; p++)
2476 Fput_char_table (make_char (*p), make_int (syn), Vstandard_syntax_table); 2476 Fput_char_table (make_char (*p), make_fixnum (syn), Vstandard_syntax_table);
2477 } 2477 }
2478 2478
2479 void 2479 void
2480 complex_vars_of_syntax (void) 2480 complex_vars_of_syntax (void)
2481 { 2481 {
2483 const UExtbyte *p; /* Latin-1, not internal format. */ 2483 const UExtbyte *p; /* Latin-1, not internal format. */
2484 2484
2485 #define SET_RANGE_SYNTAX(start, end, syntax) \ 2485 #define SET_RANGE_SYNTAX(start, end, syntax) \
2486 do { \ 2486 do { \
2487 for (i = start; i <= end; i++) \ 2487 for (i = start; i <= end; i++) \
2488 Fput_char_table(make_char(i), make_int(syntax), \ 2488 Fput_char_table(make_char(i), make_fixnum(syntax), \
2489 Vstandard_syntax_table); \ 2489 Vstandard_syntax_table); \
2490 } while (0) 2490 } while (0)
2491 2491
2492 /* Set this now, so first buffer creation can refer to it. 2492 /* Set this now, so first buffer creation can refer to it.
2493 2493
2503 Vsyntax_designator_chars_string = make_string_nocopy (syntax_code_spec, 2503 Vsyntax_designator_chars_string = make_string_nocopy (syntax_code_spec,
2504 Smax); 2504 Smax);
2505 staticpro (&Vsyntax_designator_chars_string); 2505 staticpro (&Vsyntax_designator_chars_string);
2506 2506
2507 /* Default character syntax is word. */ 2507 /* Default character syntax is word. */
2508 set_char_table_default (Vstandard_syntax_table, make_int (Sword)); 2508 set_char_table_default (Vstandard_syntax_table, make_fixnum (Sword));
2509 2509
2510 /* Control 0; treat as punctuation */ 2510 /* Control 0; treat as punctuation */
2511 SET_RANGE_SYNTAX(0, 32, Spunct); 2511 SET_RANGE_SYNTAX(0, 32, Spunct);
2512 2512
2513 /* The whitespace--overwriting some of the above changes. 2513 /* The whitespace--overwriting some of the above changes.
2524 define_standard_syntax ((const UExtbyte *)".,;:?!#@~^'`", Spunct); 2524 define_standard_syntax ((const UExtbyte *)".,;:?!#@~^'`", Spunct);
2525 2525
2526 for (p = (const UExtbyte *)"()[]{}"; *p; p+=2) 2526 for (p = (const UExtbyte *)"()[]{}"; *p; p+=2)
2527 { 2527 {
2528 Fput_char_table (make_char (p[0]), 2528 Fput_char_table (make_char (p[0]),
2529 Fcons (make_int (Sopen), make_char (p[1])), 2529 Fcons (make_fixnum (Sopen), make_char (p[1])),
2530 Vstandard_syntax_table); 2530 Vstandard_syntax_table);
2531 Fput_char_table (make_char (p[1]), 2531 Fput_char_table (make_char (p[1]),
2532 Fcons (make_int (Sclose), make_char (p[0])), 2532 Fcons (make_fixnum (Sclose), make_char (p[0])),
2533 Vstandard_syntax_table); 2533 Vstandard_syntax_table);
2534 } 2534 }
2535 2535
2536 /* Latin 1 "symbols." This contrasts with the FSF, where they're word 2536 /* Latin 1 "symbols." This contrasts with the FSF, where they're word
2537 constituents. */ 2537 constituents. */