xemacs-beta: src/syntax.c comparison

comparison src/syntax.c @ 20:859a2309aef8 r19-15b93

Import from CVS: tag r19-15b93

author	cvs
date	Mon, 13 Aug 2007 08:50:05 +0200
parents	0293115a14e9
children	131b0175ea99

comparison

equal deleted inserted replaced

-:ac1f612d5250
+:859a2309aef8
 static Bufpos
 find_defun_start (struct buffer *buf, Bufpos pos)
 {
 Bufpos tem;
-Lisp_Object table = buf->syntax_table;
+Lisp_Object syntaxtab = buf->syntax_table;
 /* Use previous finding, if it's valid and applies to this inquiry.  */
 if (buf == find_start_buffer
 /* Reuse the defun-start even if POS is a little farther on.
 	 POS might be in the next defun, but that's ok.
 tem = find_next_newline (buf, pos, -1);
 while (tem > BUF_BEGV (buf))
 {
 /* Open-paren at start of line means we found our defun-start.  */
-if (SYNTAX (table, BUF_FETCH_CHAR (buf, tem)) == Sopen)
+if (SYNTAX (syntaxtab, BUF_FETCH_CHAR (buf, tem)) == Sopen)
 	break;
 /* Move to beg of previous line.  */
 tem = find_next_newline (buf, tem, -2);
 }
 find_start_pos    = pos;
 return find_start_value;
 }
-DEFUN ("syntax-table-p", Fsyntax_table_p, Ssyntax_table_p, 1, 1, 0 /*
+DEFUN ("syntax-table-p", Fsyntax_table_p, 1, 1, 0, /*
 Return t if ARG is a syntax table.
 Any vector of 256 elements will do.
-*/ )
+*/
-(obj)
+(obj))
-Lisp_Object obj;
 {
 if (VECTORP (obj) && vector_length (XVECTOR (obj)) == 0400)
 return Qt;
 return Qnil;
 }
 while (NILP (Fsyntax_table_p (obj)))
 obj = wrong_type_argument (Qsyntax_table_p, obj);
 return (obj);
 }
-DEFUN ("syntax-table", Fsyntax_table, Ssyntax_table, 0, 1, 0 /*
+DEFUN ("syntax-table", Fsyntax_table, 0, 1, 0, /*
 Return the current syntax table.
 This is the one specified by the current buffer, or by BUFFER if it
 is non-nil.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 return decode_buffer (buffer, 0)->syntax_table;
 }
-DEFUN ("standard-syntax-table", Fstandard_syntax_table,
+DEFUN ("standard-syntax-table", Fstandard_syntax_table, 0, 0, 0, /*
-Sstandard_syntax_table, 0, 0, 0 /*
 Return the standard syntax table.
 This is the one used for new buffers.
-*/ )
+*/
-()
+())
 {
 return Vstandard_syntax_table;
 }
-DEFUN ("copy-syntax-table", Fcopy_syntax_table, Scopy_syntax_table, 0, 1, 0 /*
+DEFUN ("copy-syntax-table", Fcopy_syntax_table, 0, 1, 0, /*
 Construct a new syntax table and return it.
 It is a copy of the TABLE, which defaults to the standard syntax table.
-*/ )
+*/
-(table)
+(table))
-Lisp_Object table;
 {
 if (NILP (Vstandard_syntax_table))
 /* Can only be null during initialization */
 return make_vector (0400, Qzero);
 table = check_syntax_table (table, Vstandard_syntax_table);
 return Fcopy_sequence (table);
 }
-DEFUN ("set-syntax-table", Fset_syntax_table, Sset_syntax_table, 1, 2, 0 /*
+DEFUN ("set-syntax-table", Fset_syntax_table, 1, 2, 0, /*
 Select a new syntax table for BUFFER.
 One argument, a syntax table.
 BUFFER defaults to the current buffer if omitted.
-*/ )
+*/
-(table, buffer)
+(table, buffer))
-Lisp_Object table, buffer;
 {
 struct buffer *buf = decode_buffer (buffer, 0);
 table = check_syntax_table (table, Qnil);
 buf->syntax_table = table;
 /* Indicate that this buffer now has a specified syntax table.  */
 {
 ' ', '.', 'w', '_', '(', ')', '\'', '\"', '$', '\\', '/', '<', '>', '@',
 'e', '\0'
 };
-DEFUN ("syntax-designator-chars", Fsyntax_designator_chars,
+DEFUN ("syntax-designator-chars", Fsyntax_designator_chars, 0, 0, 0, /*
-Ssyntax_designator_chars, 0, 0, 0 /*
 Return a string of the recognized syntax designator chars.
 The chars are ordered by their internal syntax codes, which are
 numbered starting at 0.
-*/ )
+*/
-()
+())
 {
 return Vsyntax_designator_chars_string;
 }
-DEFUN ("char-syntax", Fchar_syntax, Schar_syntax, 1, 2, 0 /*
+DEFUN ("char-syntax", Fchar_syntax, 1, 2, 0, /*
 Return the syntax code of CHAR, described by a character.
 For example, if CHAR is a word constituent, the character `?w' is returned.
 The characters that correspond to various syntax codes
 are listed in the documentation of `modify-syntax-entry'.
 Optional second argument TABLE defaults to the current buffer's
 syntax table.
-*/ )
+*/
-(ch, table)
+(ch, table))
-Lisp_Object ch, table;
 {
 CHECK_CHAR_COERCE_INT (ch);
 table = check_syntax_table (table, current_buffer->syntax_table);
 return make_int (syntax_code_spec[(int) SYNTAX (table, XINT (ch))]);
 return Qnil;
 else
 return make_char (stringterm);
 }
-DEFUN ("matching-paren", Fmatching_paren, Smatching_paren, 1, 2, 0 /*
+DEFUN ("matching-paren", Fmatching_paren, 1, 2, 0, /*
 Return the matching parenthesis of CHAR, or nil if none.
 Optional second argument TABLE defaults to the current buffer's
 syntax table.
-*/ )
+*/
-(ch, table)
+(ch, table))
-Lisp_Object ch, table;
 {
 int code;
 CHECK_CHAR_COERCE_INT (ch);
 table = check_syntax_table (table, current_buffer->syntax_table);
 }
 return from;
 }
-DEFUN ("forward-word", Fforward_word, Sforward_word, 1, 2, "_p" /*
+DEFUN ("forward-word", Fforward_word, 1, 2, "_p", /*
 Move point forward ARG words (backward if ARG is negative).
 Normally returns t.
 If an edge of the buffer is reached, point is left there
 and nil is returned.
-*/ )
+*/
-(count, buffer)
+(count, buffer))
-Lisp_Object count, buffer;
 {
 Bufpos val;
 struct buffer *buf = decode_buffer (buffer, 0);
 CHECK_INT (count);
 above, which is part of Fforward_comment() in FSF).  Attempts to port
 that logic made this function break, so I'm leaving it out.  If anyone
 ever complains about this function not working properly, take a look
 at those changes.  --ben */
-DEFUN ("forward-comment", Fforward_comment, Sforward_comment, 1, 2, 0 /*
+DEFUN ("forward-comment", Fforward_comment, 1, 2, 0, /*
 Move forward across up to N comments.  If N is negative, move backward.
 Stop scanning if we find something other than a comment or whitespace.
 Set point to where scanning stops.
 If N comments are found as expected, with nothing except whitespace
 between them, return t; otherwise return nil.
 Point is set in either case.
 Optional argument BUFFER defaults to the current buffer.
-*/ )
+*/
-(n, buffer)
+(n, buffer))
-Lisp_Object n, buffer;
 {
 Bufpos from;
 Bufpos stop;
 Emchar c;
 enum syntaxcode code;
 	     || code == Sescape))
 pos--, quoted = !quoted;
 return quoted;
 }
-DEFUN ("scan-lists", Fscan_lists, Sscan_lists, 3, 5, 0 /*
+DEFUN ("scan-lists", Fscan_lists, 3, 5, 0, /*
 Scan from character number FROM by COUNT lists.
 Returns the character number of the position thus found.
 If DEPTH is nonzero, paren depth begins counting from that value,
 only places where the depth in parentheses becomes zero
 If optional arg BUFFER is non-nil, scanning occurs in that buffer instead
 of in the current buffer.
 If optional arg NOERROR is non-nil, scan-lists will return nil instead of
 signalling an error.
-*/ )
+*/
-(from, count, depth, buffer, no_error)
+(from, count, depth, buffer, no_error))
-Lisp_Object from, count, depth, buffer, no_error;
 {
 struct buffer *buf;
 CHECK_INT (from);
 CHECK_INT (count);
 return scan_lists (buf, XINT (from), XINT (count), XINT (depth), 0,
 		     !NILP (no_error));
 }
-DEFUN ("scan-sexps", Fscan_sexps, Sscan_sexps, 2, 4, 0 /*
+DEFUN ("scan-sexps", Fscan_sexps, 2, 4, 0, /*
 Scan from character number FROM by COUNT balanced expressions.
 If COUNT is negative, scan backwards.
 Returns the character number of the position thus found.
 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.
 If optional arg BUFFER is non-nil, scanning occurs in that buffer instead
 of in the current buffer.
 If optional arg NOERROR is non-nil, scan-sexps will return nil instead of
 signalling an error.
-*/ )
+*/
-(from, count, buffer, no_error)
+(from, count, buffer, no_error))
-Lisp_Object from, count, buffer, no_error;
 {
 struct buffer *buf = decode_buffer (buffer, 0);
 CHECK_INT (from);
 CHECK_INT (count);
 return scan_lists (buf, XINT (from), XINT (count), 0, 1, !NILP (no_error));
 }
-DEFUN ("backward-prefix-chars", Fbackward_prefix_chars, Sbackward_prefix_chars,
+DEFUN ("backward-prefix-chars", Fbackward_prefix_chars, 0, 1, 0, /*
-0, 1, 0 /*
 Move point backward over any number of chars with prefix syntax.
 This includes chars with \"quote\" or \"prefix\" syntax (' or p).
 Optional arg BUFFER defaults to the current buffer.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 struct buffer *buf = decode_buffer (buffer, 0);
 Bufpos beg = BUF_BEGV (buf);
 Bufpos pos = BUF_PT (buf);
 Lisp_Object table = buf->syntax_table;
 state.location = from;
 *stateptr = state;
 }
-DEFUN ("parse-partial-sexp", Fparse_partial_sexp, Sparse_partial_sexp, 2, 7, 0 /*
+DEFUN ("parse-partial-sexp", Fparse_partial_sexp, 2, 7, 0, /*
 Parse Lisp syntax starting at FROM until TO; return status of parse at TO.
 Parsing stops at TO or when certain criteria are met;
 point is set to where parsing stops.
 If fifth arg STATE is omitted or nil,
 parsing assumes that FROM is the beginning of a function.
 any character that starts a sexp.
 Fifth arg STATE is an eight-element list like what this function returns.
 It is used to initialize the state of the parse.  Its second and third
 elements are ignored.
 Sixth arg COMMENTSTOP non-nil means stop at the start of a comment.
-*/ )
+*/
-(from, to, targetdepth, stopbefore, oldstate, commentstop, buffer)
+(from, to, targetdepth, stopbefore, oldstate, commentstop, buffer))
-Lisp_Object from, to, targetdepth, stopbefore, oldstate, commentstop, buffer;
 {
 struct lisp_parse_state state;
 int target;
 Bufpos start, end;
 struct buffer *buf = decode_buffer (buffer, 0);
 void
 syms_of_syntax (void)
 {
 defsymbol (&Qsyntax_table_p, "syntax-table-p");
-defsubr (&Ssyntax_table_p);
+DEFSUBR (Fsyntax_table_p);
-defsubr (&Ssyntax_table);
+DEFSUBR (Fsyntax_table);
-defsubr (&Sstandard_syntax_table);
+DEFSUBR (Fstandard_syntax_table);
-defsubr (&Scopy_syntax_table);
+DEFSUBR (Fcopy_syntax_table);
-defsubr (&Sset_syntax_table);
+DEFSUBR (Fset_syntax_table);
-defsubr (&Ssyntax_designator_chars);
+DEFSUBR (Fsyntax_designator_chars);
-defsubr (&Schar_syntax);
+DEFSUBR (Fchar_syntax);
-defsubr (&Smatching_paren);
+DEFSUBR (Fmatching_paren);
-/* defsubr (&Smodify_syntax_entry); now in Lisp. */
+/* DEFSUBR (Fmodify_syntax_entry); now in Lisp. */
-/* defsubr (&Sdescribe_syntax); now in Lisp. */
+/* DEFSUBR (Fdescribe_syntax); now in Lisp. */
-defsubr (&Sforward_word);
+DEFSUBR (Fforward_word);
-defsubr (&Sforward_comment);
+DEFSUBR (Fforward_comment);
-defsubr (&Sscan_lists);
+DEFSUBR (Fscan_lists);
-defsubr (&Sscan_sexps);
+DEFSUBR (Fscan_sexps);
-defsubr (&Sbackward_prefix_chars);
+DEFSUBR (Fbackward_prefix_chars);
-defsubr (&Sparse_partial_sexp);
+DEFSUBR (Fparse_partial_sexp);
 }
 void
 vars_of_syntax (void)
 {

Mercurial > hg > xemacs-beta

comparison src/syntax.c @ 20:859a2309aef8 r19-15b93