DEFUN ("syntax-table-p", Fsyntax_table_p, Ssyntax_table_p, 1, 1, 0,
doc: /* Return t if OBJECT is a syntax table.
Currently, any char-table counts as a syntax table. */)
- (object)
- Lisp_Object object;
+ (Lisp_Object object)
{
if (CHAR_TABLE_P (object)
&& EQ (XCHAR_TABLE (object)->purpose, Qsyntax_table))
DEFUN ("syntax-table", Fsyntax_table, Ssyntax_table, 0, 0, 0,
doc: /* Return the current syntax table.
This is the one specified by the current buffer. */)
- ()
+ (void)
{
return current_buffer->syntax_table;
}
Sstandard_syntax_table, 0, 0, 0,
doc: /* Return the standard syntax table.
This is the one used for new buffers. */)
- ()
+ (void)
{
return Vstandard_syntax_table;
}
DEFUN ("copy-syntax-table", Fcopy_syntax_table, Scopy_syntax_table, 0, 1, 0,
doc: /* Construct a new syntax table and return it.
It is a copy of the TABLE, which defaults to the standard syntax table. */)
- (table)
- Lisp_Object table;
+ (Lisp_Object table)
{
Lisp_Object copy;
DEFUN ("set-syntax-table", Fset_syntax_table, Sset_syntax_table, 1, 1, 0,
doc: /* Select a new syntax table for the current buffer.
One argument, a syntax table. */)
- (table)
- Lisp_Object table;
+ (Lisp_Object table)
{
int idx;
check_syntax_table (table);
character `w' (119) is returned.
The characters that correspond to various syntax codes
are listed in the documentation of `modify-syntax-entry'. */)
- (character)
- Lisp_Object character;
+ (Lisp_Object character)
{
int char_int;
CHECK_CHARACTER (character);
DEFUN ("matching-paren", Fmatching_paren, Smatching_paren, 1, 1, 0,
doc: /* Return the matching parenthesis of CHARACTER, or nil if none. */)
- (character)
- Lisp_Object character;
+ (Lisp_Object character)
{
int char_int, code;
CHECK_NUMBER (character);
`modify-syntax-entry'. Value is the equivalent cons cell
\(CODE . MATCHING-CHAR) that can be used as value of a `syntax-table'
text property. */)
- (string)
- Lisp_Object string;
+ (Lisp_Object string)
{
register const unsigned char *p;
register enum syntaxcode code;
such characters are treated as whitespace when they occur
between expressions.
usage: (modify-syntax-entry CHAR NEWENTRY &optional SYNTAX-TABLE) */)
- (c, newentry, syntax_table)
- Lisp_Object c, newentry, syntax_table;
+ (Lisp_Object c, Lisp_Object newentry, Lisp_Object syntax_table)
{
if (CONSP (c))
{
DEFUN ("internal-describe-syntax-value", Finternal_describe_syntax_value,
Sinternal_describe_syntax_value, 1, 1, 0,
doc: /* Insert a description of the internal syntax description SYNTAX at point. */)
- (syntax)
- Lisp_Object syntax;
+ (Lisp_Object syntax)
{
register enum syntaxcode code;
char desc, start1, start2, end1, end2, prefix, comstyle, comnested;
If an edge of the buffer or a field boundary is reached, point is left there
and the function returns nil. Field boundaries are not noticed if
`inhibit-field-text-motion' is non-nil. */)
- (arg)
- Lisp_Object arg;
+ (Lisp_Object arg)
{
Lisp_Object tmp;
int orig_val, val;
Char classes, e.g. `[:alpha:]', are supported.
Returns the distance traveled, either zero or positive. */)
- (string, lim)
- Lisp_Object string, lim;
+ (Lisp_Object string, Lisp_Object lim)
{
return skip_chars (1, string, lim, 1);
}
doc: /* Move point backward, stopping after a char not in STRING, or at pos LIM.
See `skip-chars-forward' for details.
Returns the distance traveled, either zero or negative. */)
- (string, lim)
- Lisp_Object string, lim;
+ (Lisp_Object string, Lisp_Object lim)
{
return skip_chars (0, string, lim, 1);
}
Stop before a char whose syntax is not in SYNTAX, or at position LIM.
If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.
This function returns the distance traveled, either zero or positive. */)
- (syntax, lim)
- Lisp_Object syntax, lim;
+ (Lisp_Object syntax, Lisp_Object lim)
{
return skip_syntaxes (1, syntax, lim);
}
Stop on reaching a char whose syntax is not in SYNTAX, or at position LIM.
If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.
This function returns the distance traveled, either zero or negative. */)
- (syntax, lim)
- Lisp_Object syntax, lim;
+ (Lisp_Object syntax, Lisp_Object lim)
{
return skip_syntaxes (0, syntax, lim);
}
&& (XINT (lim) - PT != CHAR_TO_BYTE (XINT (lim)) - PT_BYTE));
string_multibyte = SBYTES (string) > SCHARS (string);
- bzero (fastmap, sizeof fastmap);
+ memset (fastmap, 0, sizeof fastmap);
str = SDATA (string);
size_byte = SBYTES (string);
|| *class_end != ':' || class_end[1] != ']')
goto not_a_class_name;
- bcopy (class_beg, class_name, class_end - class_beg);
+ memcpy (class_name, class_beg, class_end - class_beg);
class_name[class_end - class_beg] = 0;
cc = re_wctype (class_name);
unsigned char fastmap2[0400];
int range_start_byte, range_start_char;
- bcopy (fastmap2 + 0200, fastmap + 0200, 0200);
- bzero (fastmap + 0200, 0200);
+ memcpy (fastmap + 0200, fastmap2 + 0200, 0200);
+ memset (fastmap + 0200, 0, 0200);
/* We are sure that this loop stops. */
for (i = 0200; ! fastmap2[i]; i++);
c = BYTE8_TO_CHAR (i);
|| *class_end != ':' || class_end[1] != ']')
goto not_a_class_name_multibyte;
- bcopy (class_beg, class_name, class_end - class_beg);
+ memcpy (class_name, class_beg, class_end - class_beg);
class_name[class_end - class_beg] = 0;
cc = re_wctype (class_name);
if (! multibyte && n_char_ranges > 0)
{
- bzero (fastmap + 0200, 0200);
+ memset (fastmap + 0200, 0, 0200);
for (i = 0; i < n_char_ranges; i += 2)
{
int c1 = char_ranges[i];
multibyte = (!NILP (current_buffer->enable_multibyte_characters)
&& (XINT (lim) - PT != CHAR_TO_BYTE (XINT (lim)) - PT_BYTE));
- bzero (fastmap, sizeof fastmap);
+ memset (fastmap, 0, sizeof fastmap);
if (SBYTES (string) > SCHARS (string))
/* As this is very rare case (syntax spec is ASCII only), don't
Set point to where scanning stops.
If COUNT comments are found as expected, with nothing except whitespace
between them, return t; otherwise return nil. */)
- (count)
- Lisp_Object count;
+ (Lisp_Object count)
{
register EMACS_INT from;
EMACS_INT from_byte;
If the beginning or end of (the accessible part of) the buffer is reached
and the depth is wrong, an error is signaled.
If the depth is right but the count is not used up, nil is returned. */)
- (from, count, depth)
- Lisp_Object from, count, depth;
+ (Lisp_Object from, Lisp_Object count, Lisp_Object depth)
{
CHECK_NUMBER (from);
CHECK_NUMBER (count);
in the middle of a parenthetical grouping, an error is signaled.
If the beginning or end is reached between groupings
but before count is used up, nil is returned. */)
- (from, count)
- Lisp_Object from, count;
+ (Lisp_Object from, Lisp_Object count)
{
CHECK_NUMBER (from);
CHECK_NUMBER (count);
0, 0, 0,
doc: /* Move point backward over any number of chars with prefix syntax.
This includes chars with "quote" or "prefix" syntax (' or p). */)
- ()
+ (void)
{
int beg = BEGV;
int opoint = PT;
after the beginning of a string, or after the end of a string. */
static void
-scan_sexps_forward (stateptr, from, from_byte, end, targetdepth,
- stopbefore, oldstate, commentstop)
- struct lisp_parse_state *stateptr;
- register EMACS_INT from;
- EMACS_INT from_byte, end;
- int targetdepth, stopbefore;
- Lisp_Object oldstate;
- int commentstop;
+scan_sexps_forward (struct lisp_parse_state *stateptr,
+ EMACS_INT from, EMACS_INT from_byte, EMACS_INT end,
+ int targetdepth, int stopbefore,
+ Lisp_Object oldstate, int commentstop)
{
struct lisp_parse_state state;
Sixth arg COMMENTSTOP non-nil means stop at the start of a comment.
If it is symbol `syntax-table', stop after the start of a comment or a
string, or after end of a comment or a string. */)
- (from, to, targetdepth, stopbefore, oldstate, commentstop)
- Lisp_Object from, to, targetdepth, stopbefore, oldstate, commentstop;
+ (Lisp_Object from, Lisp_Object to, Lisp_Object targetdepth, Lisp_Object stopbefore, Lisp_Object oldstate, Lisp_Object commentstop)
{
struct lisp_parse_state state;
int target;