Lisp_Object Qfunction_documentation;
+extern Lisp_Object Qclosure;
/* Buffer used for reading from documentation file. */
static char *get_doc_string_buffer;
static int get_doc_string_buffer_size;
static unsigned char *read_bytecode_pointer;
-Lisp_Object Fsnarf_documentation (Lisp_Object);
+static Lisp_Object Fdocumentation_property (Lisp_Object, Lisp_Object,
+ Lisp_Object);
+static Lisp_Object Fsnarf_documentation (Lisp_Object);
/* readchar in lread.c calls back here to fetch the next byte.
If UNREADFLAG is 1, we unread a byte. */
if (0 > lseek (fd, position - offset, 0))
{
emacs_close (fd);
- error ("Position %ld out of range in doc string file \"%s\"",
+ error ("Position %"pI"d out of range in doc string file \"%s\"",
position, name);
}
else if (c == '_')
*to++ = 037;
else
- error ("Invalid data in documentation file -- ^A followed by code 0%o", c);
+ error ("\
+Invalid data in documentation file -- %c followed by code %03o",
+ 1, (unsigned)c);
}
else
*to++ = *from++;
the same way we would read bytes from a file. */
if (definition)
{
- read_bytecode_pointer = get_doc_string_buffer + offset;
+ read_bytecode_pointer = (unsigned char *) get_doc_string_buffer + offset;
return Fread (Qlambda);
}
else
{
/* The data determines whether the string is multibyte. */
- EMACS_INT nchars = multibyte_chars_in_text (get_doc_string_buffer + offset,
- to - (get_doc_string_buffer + offset));
+ EMACS_INT nchars =
+ multibyte_chars_in_text (((unsigned char *) get_doc_string_buffer
+ + offset),
+ to - (get_doc_string_buffer + offset));
return make_string_from_bytes (get_doc_string_buffer + offset,
nchars,
to - (get_doc_string_buffer + offset));
{
Lisp_Object fun;
Lisp_Object funcar;
- Lisp_Object tem, doc;
+ Lisp_Object doc;
int try_reload = 1;
documentation:
doc = Qnil;
- if (SYMBOLP (function)
- && (tem = Fget (function, Qfunction_documentation),
- !NILP (tem)))
- return Fdocumentation_property (function, Qfunction_documentation, raw);
+ if (SYMBOLP (function))
+ {
+ Lisp_Object tem = Fget (function, Qfunction_documentation);
+ if (!NILP (tem))
+ return Fdocumentation_property (function, Qfunction_documentation,
+ raw);
+ }
fun = Findirect_function (function, Qnil);
if (SUBRP (fun))
{
if ((ASIZE (fun) & PSEUDOVECTOR_SIZE_MASK) <= COMPILED_DOC_STRING)
return Qnil;
- tem = AREF (fun, COMPILED_DOC_STRING);
- if (STRINGP (tem))
- doc = tem;
- else if (NATNUMP (tem) || CONSP (tem))
- doc = tem;
else
- return Qnil;
+ {
+ Lisp_Object tem = AREF (fun, COMPILED_DOC_STRING);
+ if (STRINGP (tem))
+ doc = tem;
+ else if (NATNUMP (tem) || CONSP (tem))
+ doc = tem;
+ else
+ return Qnil;
+ }
}
else if (STRINGP (fun) || VECTORP (fun))
{
else if (EQ (funcar, Qkeymap))
return build_string ("Prefix command (definition is a keymap associating keystrokes with commands).");
else if (EQ (funcar, Qlambda)
+ || (EQ (funcar, Qclosure) && (fun = XCDR (fun), 1))
|| EQ (funcar, Qautoload))
{
- Lisp_Object tem1;
- tem1 = Fcdr (Fcdr (fun));
- tem = Fcar (tem1);
+ Lisp_Object tem1 = Fcdr (Fcdr (fun));
+ Lisp_Object tem = Fcar (tem1);
if (STRINGP (tem))
doc = tem;
/* Handle a doc reference--but these never come last
}
else if (!STRINGP (tem))
/* Feval protects its argument. */
- tem = Feval (tem);
+ tem = Feval (tem, Qnil);
if (NILP (raw) && STRINGP (tem))
tem = Fsubstitute_command_keys (tem);
Lisp_Object tem;
tem = XCAR (fun);
- if (EQ (tem, Qlambda) || EQ (tem, Qautoload))
+ if (EQ (tem, Qlambda) || EQ (tem, Qautoload)
+ || (EQ (tem, Qclosure) && (fun = XCDR (fun), 1)))
{
tem = Fcdr (Fcdr (fun));
if (CONSP (tem) && INTEGERP (XCAR (tem)))
char buf[1024 + 1];
register EMACS_INT filled;
register EMACS_INT pos;
- register char *p, *end;
+ register char *p;
Lisp_Object sym;
char *name;
int skip_file = 0;
pos = 0;
while (1)
{
+ register char *end;
if (filled < 512)
filled += emacs_read (fd, &buf[filled], sizeof buf - 1 - filled);
if (!filled)
}
sym = oblookup (Vobarray, p + 2,
- multibyte_chars_in_text (p + 2, end - p - 2),
+ multibyte_chars_in_text ((unsigned char *) p + 2,
+ end - p - 2),
end - p - 2);
/* Check skip_file so that when a function is defined several
times in different files (typically, once in xterm, once in
; /* Just a source file name boundary marker. Ignore it. */
else
- error ("DOC file invalid at position %d", pos);
+ error ("DOC file invalid at position %"pI"d", pos);
}
}
pos += end - buf;
a new string, without any text properties, is returned. */)
(Lisp_Object string)
{
- unsigned char *buf;
+ char *buf;
int changed = 0;
register unsigned char *strp;
- register unsigned char *bufp;
+ register char *bufp;
EMACS_INT idx;
EMACS_INT bsize;
Lisp_Object tem;
or a specified local map (which means search just that and the
global map). If non-nil, it might come from Voverriding_local_map,
or from a \\<mapname> construct in STRING itself.. */
- keymap = current_kboard->Voverriding_terminal_local_map;
+ keymap = KVAR (current_kboard, Voverriding_terminal_local_map);
if (NILP (keymap))
keymap = Voverriding_local_map;
bsize = SBYTES (string);
- bufp = buf = (unsigned char *) xmalloc (bsize);
+ bufp = buf = (char *) xmalloc (bsize);
strp = SDATA (string);
while (strp < SDATA (string) + SBYTES (string))
/* Save STRP in IDX. */
idx = strp - SDATA (string);
- name = Fintern (make_string (start, length_byte), Qnil);
+ name = Fintern (make_string ((char *) start, length_byte), Qnil);
do_remap:
tem = Fwhere_is_internal (name, keymap, Qt, Qnil, Qnil);
- if (VECTORP (tem) && XVECTOR (tem)->size > 1
+ if (VECTORP (tem) && ASIZE (tem) > 1
&& EQ (AREF (tem, 0), Qremap) && SYMBOLP (AREF (tem, 1))
&& follow_remap)
{
if (NILP (tem)) /* but not on any keys */
{
EMACS_INT offset = bufp - buf;
- buf = (unsigned char *) xrealloc (buf, bsize += 4);
+ buf = (char *) xrealloc (buf, bsize += 4);
bufp = buf + offset;
memcpy (bufp, "M-x ", 4);
bufp += 4;
/* Get the value of the keymap in TEM, or nil if undefined.
Do this while still in the user's current buffer
in case it is a local variable. */
- name = Fintern (make_string (start, length_byte), Qnil);
+ name = Fintern (make_string ((char *) start, length_byte), Qnil);
tem = Fboundp (name);
if (! NILP (tem))
{
subst:
{
EMACS_INT offset = bufp - buf;
- buf = (unsigned char *) xrealloc (buf, bsize += length_byte);
+ buf = (char *) xrealloc (buf, bsize += length_byte);
bufp = buf + offset;
memcpy (bufp, start, length_byte);
bufp += length_byte;
HCoop / bpt / emacs.git / blobdiff