}
DEFUN ("makunbound", Fmakunbound, Smakunbound, 1, 1, 0,
- doc: /* Make SYMBOL's value be void. */)
+ doc: /* Make SYMBOL's value be void.
+Return SYMBOL. */)
(symbol)
register Lisp_Object symbol;
{
}
DEFUN ("fmakunbound", Ffmakunbound, Sfmakunbound, 1, 1, 0,
- doc: /* Make SYMBOL's function definition be void. */)
+ doc: /* Make SYMBOL's function definition be void.
+Return SYMBOL. */)
(symbol)
register Lisp_Object symbol;
{
DEFUN ("defalias", Fdefalias, Sdefalias, 2, 3, 0,
doc: /* Set SYMBOL's function definition to DEFINITION, and return DEFINITION.
-Associates the function with the current load file, if any. */)
+Associates the function with the current load file, if any.
+The optional third argument DOCSTRING specifies the documentation string
+for SYMBOL; if it is omitted or nil, SYMBOL uses the documentation string
+determined by DEFINITION. */)
(symbol, definition, docstring)
register Lisp_Object symbol, definition, docstring;
{
+ if (CONSP (XSYMBOL (symbol)->function)
+ && EQ (XCAR (XSYMBOL (symbol)->function), Qautoload))
+ LOADHIST_ATTACH (Fcons (Qt, symbol));
definition = Ffset (symbol, definition);
LOADHIST_ATTACH (symbol);
if (!NILP (docstring))
hare = XSYMBOL (hare)->value;
if (!XSYMBOL (hare)->indirect_variable)
break;
-
+
hare = XSYMBOL (hare)->value;
tortoise = XSYMBOL (tortoise)->value;
Lisp_Object symbol;
{
Lisp_Object valcontents, cdr;
-
+
valcontents = SYMBOL_VALUE (symbol);
if (!BUFFER_LOCAL_VALUEP (valcontents)
&& !SOME_BUFFER_LOCAL_VALUEP (valcontents))
/* Unload the previously loaded binding. */
Fsetcdr (XCAR (cdr),
do_symval_forwarding (XBUFFER_LOCAL_VALUE (valcontents)->realvalue));
-
+
/* Select the global binding in the symbol. */
XSETCAR (cdr, cdr);
store_symval_forwarding (symbol, valcontents, XCDR (cdr), NULL);
Lisp_Object symbol, valcontents;
{
register Lisp_Object tem1;
-
+
tem1 = XBUFFER_LOCAL_VALUE (valcontents)->buffer;
if (NILP (tem1)
{
if (XSYMBOL (symbol)->indirect_variable)
symbol = indirect_variable (symbol);
-
+
/* Unload the previously loaded binding. */
tem1 = XCAR (XBUFFER_LOCAL_VALUE (valcontents)->cdr);
Fsetcdr (tem1,
{
register Lisp_Object valcontents;
register Lisp_Object val;
-
+
CHECK_SYMBOL (symbol);
valcontents = SYMBOL_VALUE (symbol);
return Fsignal (Qsetting_constant, Fcons (symbol, Qnil));
innercontents = valcontents = SYMBOL_VALUE (symbol);
-
+
if (BUFFER_OBJFWDP (valcontents))
{
int offset = XBUFFER_OBJFWD (valcontents)->offset;
if (idx > 0)
{
struct buffer *b;
-
+
for (b = all_buffers; b; b = b->next)
if (!PER_BUFFER_VALUE_P (b, idx))
PER_BUFFER_VALUE (b, offset) = value;
DEFUN ("setq-default", Fsetq_default, Ssetq_default, 2, UNEVALLED, 0,
doc: /* Set the default value of variable VAR to VALUE.
VAR, the variable name, is literal (not evaluated);
-VALUE is an expression and it is evaluated.
+VALUE is an expression: it is evaluated and its value returned.
The default value of a variable is seen in buffers
that do not have their own values for the variable.
in which case the default value is in effect.
Note that binding the variable with `let', or setting it while
a `let'-style binding made in this buffer is in effect,
-does not make the variable buffer-local.
+does not make the variable buffer-local. Return VARIABLE.
The function `default-value' gets the default value and `set-default' sets it. */)
(variable)
Other buffers will continue to share a common default value.
\(The buffer-local value of VARIABLE starts out as the same value
VARIABLE previously had. If VARIABLE was void, it remains void.\)
-See also `make-variable-buffer-local'.
+See also `make-variable-buffer-local'. Return VARIABLE.
If the variable is already arranged to become local when set,
this function causes a local value to exist for this buffer,
DEFUN ("kill-local-variable", Fkill_local_variable, Skill_local_variable,
1, 1, "vKill Local Variable: ",
doc: /* Make VARIABLE no longer have a separate value in the current buffer.
-From now on the default value will apply in this buffer. */)
+From now on the default value will apply in this buffer. Return VARIABLE. */)
(variable)
register Lisp_Object variable;
{
doc: /* Enable VARIABLE to have frame-local bindings.
When a frame-local binding exists in the current frame,
it is in effect whenever the current buffer has no buffer-local binding.
-A frame-local binding is actual a frame parameter value;
-thus, any given frame has a local binding for VARIABLE
-if it has a value for the frame parameter named VARIABLE.
-See `modify-frame-parameters'. */)
+A frame-local binding is actually a frame parameter value;
+thus, any given frame has a local binding for VARIABLE if it has
+a value for the frame parameter named VARIABLE. Return VARIABLE.
+See `modify-frame-parameters' for how to set frame parameters. */)
(variable)
register Lisp_Object variable;
{
return make_number ((unsigned char) SREF (array, idxval));
idxval_byte = string_char_to_byte (array, idxval);
- c = STRING_CHAR (&SREF (array, idxval_byte),
+ c = STRING_CHAR (SDATA (array) + idxval_byte,
SBYTES (array) - idxval_byte);
return make_number (c);
}
DEFUN ("aset", Faset, Saset, 3, 3, 0,
doc: /* Store into the element of ARRAY at index IDX the value NEWELT.
-ARRAY may be a vector, a string, a char-table or a bool-vector.
-IDX starts at 0. */)
+Return NEWELT. ARRAY may be a vector, a string, a char-table or a
+bool-vector. IDX starts at 0. */)
(array, idx, newelt)
register Lisp_Object array;
Lisp_Object idx, newelt;
CHECK_NUMBER (newelt);
idxval_byte = string_char_to_byte (array, idxval);
- p1 = &SREF (array, idxval_byte);
+ p1 = SDATA (array) + idxval_byte;
PARSE_MULTIBYTE_SEQ (p1, nbytes - idxval_byte, prev_bytes);
new_bytes = CHAR_STRING (XINT (newelt), p0);
if (prev_bytes != new_bytes)
CHECK_NUMBER (newelt);
if (XINT (newelt) < 0 || SINGLE_BYTE_CHAR_P (XINT (newelt)))
- SREF (array, idxval) = XINT (newelt);
+ SSET (array, idxval, XINT (newelt));
else
{
/* We must relocate the string data while converting it to
}
\f
DEFUN ("number-to-string", Fnumber_to_string, Snumber_to_string, 1, 1, 0,
- doc: /* Convert NUMBER to a string by printing it in decimal.
+ doc: /* Return the decimal representation of NUMBER as a string.
Uses a minus sign if negative.
NUMBER may be an integer or a floating point number. */)
(number)
return -1;
else
return digit;
-}
+}
DEFUN ("string-to-number", Fstring_to_number, Sstring_to_number, 1, 2, 0,
- doc: /* Convert STRING to a number by parsing it as a decimal number.
+ doc: /* Parse STRING as a decimal number and return the number.
This parses both integers and floating point numbers.
It ignores leading spaces and tabs.
}
else if (*p == '+')
p++;
-
+
if (isfloat_string (p) && b == 10)
val = make_float (sign * atof (p));
else
}
DEFUN ("-", Fminus, Sminus, 0, MANY, 0,
- doc: /* Negate number or subtract numbers or markers.
+ doc: /* Negate number or subtract numbers or markers and return the result.
With one arg, negates it. With more than one arg,
subtracts all but the first from the first.
usage: (- &optional NUMBER-OR-MARKER &rest MORE-NUMBERS-OR-MARKERS) */)
DEFUN ("lsh", Flsh, Slsh, 2, 2, 0,
doc: /* Return VALUE with its bits shifted left by COUNT.
If COUNT is negative, shifting is actually to the right.
-In this case, zeros are shifted in on the left. */)
+In this case, zeros are shifted in on the left. */)
(value, count)
register Lisp_Object value, count;
{
DEFVAR_LISP ("most-positive-fixnum", &Vmost_positive_fixnum,
doc: /* The largest value that is representable in a Lisp integer. */);
Vmost_positive_fixnum = make_number (MOST_POSITIVE_FIXNUM);
-
+
DEFVAR_LISP ("most-negative-fixnum", &Vmost_negative_fixnum,
doc: /* The smallest value that is representable in a Lisp integer. */);
Vmost_negative_fixnum = make_number (MOST_NEGATIVE_FIXNUM);
HCoop / bpt / emacs.git / blobdiff