src/doc.c

   1 /* Record indices of function doc strings stored in a file.
   2
   3 Copyright (C) 1985-1986, 1993-1995, 1997-2013 Free Software Foundation,
   4 Inc.
   5
   6 This file is part of GNU Emacs.
   7
   8 GNU Emacs is free software: you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation, either version 3 of the License, or
  11 (at your option) any later version.
  12
  13 GNU Emacs is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21
  22 #include <config.h>
  23
  24 #include <sys/types.h>
  25 #include <sys/file.h>   /* Must be after sys/types.h for USG.  */
  26 #include <fcntl.h>
  27 #include <unistd.h>
  28
  29 #include <c-ctype.h>
  30
  31 #include "lisp.h"
  32 #include "character.h"
  33 #include "buffer.h"
  34 #include "keyboard.h"
  35 #include "keymap.h"
  36
  37 Lisp_Object Qfunction_documentation;
  38
  39 /* Buffer used for reading from documentation file.  */
  40 static char *get_doc_string_buffer;
  41 static ptrdiff_t get_doc_string_buffer_size;
  42
  43 static unsigned char *read_bytecode_pointer;
  44
  45 /* `readchar' in lread.c calls back here to fetch the next byte.
  46    If UNREADFLAG is 1, we unread a byte.  */
  47
  48 int
  49 read_bytecode_char (bool unreadflag)
  50 {
  51   if (unreadflag)
  52     {
  53       read_bytecode_pointer--;
  54       return 0;
  55     }
  56   return *read_bytecode_pointer++;
  57 }
  58
  59 /* Extract a doc string from a file.  FILEPOS says where to get it.
  60    If it is an integer, use that position in the standard DOC file.
  61    If it is (FILE . INTEGER), use FILE as the file name
  62    and INTEGER as the position in that file.
  63    But if INTEGER is negative, make it positive.
  64    (A negative integer is used for user variables, so we can distinguish
  65    them without actually fetching the doc string.)
  66
  67    If the location does not point to the beginning of a docstring
  68    (e.g. because the file has been modified and the location is stale),
  69    return nil.
  70
  71    If UNIBYTE, always make a unibyte string.
  72
  73    If DEFINITION, assume this is for reading
  74    a dynamic function definition; convert the bytestring
  75    and the constants vector with appropriate byte handling,
  76    and return a cons cell.  */
  77
  78 Lisp_Object
  79 get_doc_string (Lisp_Object filepos, bool unibyte, bool definition)
  80 {
  81   char *from, *to, *name, *p, *p1;
  82   int fd;
  83   ptrdiff_t minsize;
  84   int offset;
  85   EMACS_INT position;
  86   Lisp_Object file, tem, pos;
  87   USE_SAFE_ALLOCA;
  88
  89   if (INTEGERP (filepos))
  90     {
  91       file = Vdoc_file_name;
  92       pos = filepos;
  93     }
  94   else if (CONSP (filepos))
  95     {
  96       file = XCAR (filepos);
  97       pos = XCDR (filepos);
  98     }
  99   else
 100     return Qnil;
 101
 102   position = eabs (XINT (pos));
 103
 104   if (!STRINGP (Vdoc_directory))
 105     return Qnil;
 106
 107   if (!STRINGP (file))
 108     return Qnil;
 109
 110   /* Put the file name in NAME as a C string.
 111      If it is relative, combine it with Vdoc_directory.  */
 112
 113   tem = Ffile_name_absolute_p (file);
 114   file = ENCODE_FILE (file);
 115   if (NILP (tem))
 116     {
 117       Lisp_Object docdir = ENCODE_FILE (Vdoc_directory);
 118       minsize = SCHARS (docdir);
 119       /* sizeof ("../etc/") == 8 */
 120       if (minsize < 8)
 121         minsize = 8;
 122       name = SAFE_ALLOCA (minsize + SCHARS (file) + 8);
 123       strcpy (name, SSDATA (docdir));
 124       strcat (name, SSDATA (file));
 125     }
 126   else
 127     {
 128       name = SSDATA (file);
 129     }
 130
 131   fd = emacs_open (name, O_RDONLY, 0);
 132   if (fd < 0)
 133     {
 134 #ifndef CANNOT_DUMP
 135       if (!NILP (Vpurify_flag))
 136         {
 137           /* Preparing to dump; DOC file is probably not installed.
 138              So check in ../etc.  */
 139           strcpy (name, "../etc/");
 140           strcat (name, SSDATA (file));
 141
 142           fd = emacs_open (name, O_RDONLY, 0);
 143         }
 144 #endif
 145       if (fd < 0)
 146         return concat3 (build_string ("Cannot open doc string file \""),
 147                         file, build_string ("\"\n"));
 148     }
 149
 150   /* Seek only to beginning of disk block.  */
 151   /* Make sure we read at least 1024 bytes before `position'
 152      so we can check the leading text for consistency.  */
 153   offset = min (position, max (1024, position % (8 * 1024)));
 154   if (TYPE_MAXIMUM (off_t) < position
 155       || lseek (fd, position - offset, 0) < 0)
 156     {
 157       emacs_close (fd);
 158       error ("Position %"pI"d out of range in doc string file \"%s\"",
 159              position, name);
 160     }
 161
 162   SAFE_FREE ();
 163
 164   /* Read the doc string into get_doc_string_buffer.
 165      P points beyond the data just read.  */
 166
 167   p = get_doc_string_buffer;
 168   while (1)
 169     {
 170       ptrdiff_t space_left = (get_doc_string_buffer_size - 1
 171                               - (p - get_doc_string_buffer));
 172       int nread;
 173
 174       /* Allocate or grow the buffer if we need to.  */
 175       if (space_left <= 0)
 176         {
 177           ptrdiff_t in_buffer = p - get_doc_string_buffer;
 178           get_doc_string_buffer
 179             = xpalloc (get_doc_string_buffer, &get_doc_string_buffer_size,
 180                        16 * 1024, -1, 1);
 181           p = get_doc_string_buffer + in_buffer;
 182           space_left = (get_doc_string_buffer_size - 1
 183                         - (p - get_doc_string_buffer));
 184         }
 185
 186       /* Read a disk block at a time.
 187          If we read the same block last time, maybe skip this?  */
 188       if (space_left > 1024 * 8)
 189         space_left = 1024 * 8;
 190       nread = emacs_read (fd, p, space_left);
 191       if (nread < 0)
 192         {
 193           emacs_close (fd);
 194           error ("Read error on documentation file");
 195         }
 196       p[nread] = 0;
 197       if (!nread)
 198         break;
 199       if (p == get_doc_string_buffer)
 200         p1 = strchr (p + offset, '\037');
 201       else
 202         p1 = strchr (p, '\037');
 203       if (p1)
 204         {
 205           *p1 = 0;
 206           p = p1;
 207           break;
 208         }
 209       p += nread;
 210     }
 211   emacs_close (fd);
 212
 213   /* Sanity checking.  */
 214   if (CONSP (filepos))
 215     {
 216       int test = 1;
 217       /* A dynamic docstring should be either at the very beginning of a "#@
 218          comment" or right after a dynamic docstring delimiter (in case we
 219          pack several such docstrings within the same comment).  */
 220       if (get_doc_string_buffer[offset - test] != '\037')
 221         {
 222           if (get_doc_string_buffer[offset - test++] != ' ')
 223             return Qnil;
 224           while (get_doc_string_buffer[offset - test] >= '0'
 225                  && get_doc_string_buffer[offset - test] <= '9')
 226             test++;
 227           if (get_doc_string_buffer[offset - test++] != '@'
 228               || get_doc_string_buffer[offset - test] != '#')
 229             return Qnil;
 230         }
 231     }
 232   else
 233     {
 234       int test = 1;
 235       if (get_doc_string_buffer[offset - test++] != '\n')
 236         return Qnil;
 237       while (get_doc_string_buffer[offset - test] > ' ')
 238         test++;
 239       if (get_doc_string_buffer[offset - test] != '\037')
 240         return Qnil;
 241     }
 242
 243   /* Scan the text and perform quoting with ^A (char code 1).
 244      ^A^A becomes ^A, ^A0 becomes a null char, and ^A_ becomes a ^_.  */
 245   from = get_doc_string_buffer + offset;
 246   to = get_doc_string_buffer + offset;
 247   while (from != p)
 248     {
 249       if (*from == 1)
 250         {
 251           int c;
 252
 253           from++;
 254           c = *from++;
 255           if (c == 1)
 256             *to++ = c;
 257           else if (c == '0')
 258             *to++ = 0;
 259           else if (c == '_')
 260             *to++ = 037;
 261           else
 262             {
 263               unsigned char uc = c;
 264               error ("\
 265 Invalid data in documentation file -- %c followed by code %03o",
 266                      1, uc);
 267             }
 268         }
 269       else
 270         *to++ = *from++;
 271     }
 272
 273   /* If DEFINITION, read from this buffer
 274      the same way we would read bytes from a file.  */
 275   if (definition)
 276     {
 277       read_bytecode_pointer = (unsigned char *) get_doc_string_buffer + offset;
 278       return Fread (Qlambda);
 279     }
 280
 281   if (unibyte)
 282     return make_unibyte_string (get_doc_string_buffer + offset,
 283                                 to - (get_doc_string_buffer + offset));
 284   else
 285     {
 286       /* The data determines whether the string is multibyte.  */
 287       ptrdiff_t nchars
 288         = multibyte_chars_in_text (((unsigned char *) get_doc_string_buffer
 289                                     + offset),
 290                                    to - (get_doc_string_buffer + offset));
 291       return make_string_from_bytes (get_doc_string_buffer + offset,
 292                                      nchars,
 293                                      to - (get_doc_string_buffer + offset));
 294     }
 295 }
 296
 297 /* Get a string from position FILEPOS and pass it through the Lisp reader.
 298    We use this for fetching the bytecode string and constants vector
 299    of a compiled function from the .elc file.  */
 300
 301 Lisp_Object
 302 read_doc_string (Lisp_Object filepos)
 303 {
 304   return get_doc_string (filepos, 0, 1);
 305 }
 306
 307 static bool
 308 reread_doc_file (Lisp_Object file)
 309 {
 310 #if 0
 311   Lisp_Object reply, prompt[3];
 312   struct gcpro gcpro1;
 313   GCPRO1 (file);
 314   prompt[0] = build_string ("File ");
 315   prompt[1] = NILP (file) ? Vdoc_file_name : file;
 316   prompt[2] = build_string (" is out of sync.  Reload? ");
 317   reply = Fy_or_n_p (Fconcat (3, prompt));
 318   UNGCPRO;
 319   if (NILP (reply))
 320     return 0;
 321 #endif
 322
 323   if (NILP (file))
 324     Fsnarf_documentation (Vdoc_file_name);
 325   else
 326     Fload (file, Qt, Qt, Qt, Qnil);
 327
 328   return 1;
 329 }
 330
 331 DEFUN ("documentation", Fdocumentation, Sdocumentation, 1, 2, 0,
 332        doc: /* Return the documentation string of FUNCTION.
 333 Unless a non-nil second argument RAW is given, the
 334 string is passed through `substitute-command-keys'.  */)
 335   (Lisp_Object function, Lisp_Object raw)
 336 {
 337   Lisp_Object fun;
 338   Lisp_Object funcar;
 339   Lisp_Object doc;
 340   bool try_reload = 1;
 341
 342  documentation:
 343
 344   doc = Qnil;
 345
 346   if (SYMBOLP (function))
 347     {
 348       Lisp_Object tem = Fget (function, Qfunction_documentation);
 349       if (!NILP (tem))
 350         return Fdocumentation_property (function, Qfunction_documentation,
 351                                         raw);
 352     }
 353
 354   fun = Findirect_function (function, Qnil);
 355   if (CONSP (fun) && EQ (XCAR (fun), Qmacro))
 356     fun = XCDR (fun);
 357   if (SUBRP (fun))
 358     {
 359       if (XSUBR (fun)->doc == 0)
 360         return Qnil;
 361       /* FIXME: This is not portable, as it assumes that string
 362          pointers have the top bit clear.  */
 363       else if ((intptr_t) XSUBR (fun)->doc >= 0)
 364         doc = build_string (XSUBR (fun)->doc);
 365       else
 366         doc = make_number ((intptr_t) XSUBR (fun)->doc);
 367     }
 368   else if (COMPILEDP (fun))
 369     {
 370       if ((ASIZE (fun) & PSEUDOVECTOR_SIZE_MASK) <= COMPILED_DOC_STRING)
 371         return Qnil;
 372       else
 373         {
 374           Lisp_Object tem = AREF (fun, COMPILED_DOC_STRING);
 375           if (STRINGP (tem))
 376             doc = tem;
 377           else if (NATNUMP (tem) || CONSP (tem))
 378             doc = tem;
 379           else
 380             return Qnil;
 381         }
 382     }
 383   else if (STRINGP (fun) || VECTORP (fun))
 384     {
 385       return build_string ("Keyboard macro.");
 386     }
 387   else if (CONSP (fun))
 388     {
 389       funcar = XCAR (fun);
 390       if (!SYMBOLP (funcar))
 391         xsignal1 (Qinvalid_function, fun);
 392       else if (EQ (funcar, Qkeymap))
 393         return build_string ("Prefix command (definition is a keymap associating keystrokes with commands).");
 394       else if (EQ (funcar, Qlambda)
 395                || (EQ (funcar, Qclosure) && (fun = XCDR (fun), 1))
 396                || EQ (funcar, Qautoload))
 397         {
 398           Lisp_Object tem1 = Fcdr (Fcdr (fun));
 399           Lisp_Object tem = Fcar (tem1);
 400           if (STRINGP (tem))
 401             doc = tem;
 402           /* Handle a doc reference--but these never come last
 403              in the function body, so reject them if they are last.  */
 404           else if ((NATNUMP (tem) || (CONSP (tem) && INTEGERP (XCDR (tem))))
 405                    && !NILP (XCDR (tem1)))
 406             doc = tem;
 407           else
 408             return Qnil;
 409         }
 410       else
 411         goto oops;
 412     }
 413   else
 414     {
 415     oops:
 416       xsignal1 (Qinvalid_function, fun);
 417     }
 418
 419   /* Check for a dynamic docstring.  These come with
 420      a dynamic-docstring-function text property.  */
 421   if (STRINGP (doc))
 422     {
 423       Lisp_Object func
 424         = Fget_text_property (make_number (0),
 425                               intern ("dynamic-docstring-function"),
 426                                       doc);
 427       if (!NILP (func))
 428         /* Pass both `doc' and `function' since `function' can be needed, and
 429            finding `doc' can be annoying: calling `documentation' is not an
 430            option because it would infloop.  */
 431         doc = call2 (func, doc, function);
 432     }
 433
 434   /* If DOC is 0, it's typically because of a dumped file missing
 435      from the DOC file (bug in src/Makefile.in).  */
 436   if (EQ (doc, make_number (0)))
 437     doc = Qnil;
 438   if (INTEGERP (doc) || CONSP (doc))
 439     {
 440       Lisp_Object tem;
 441       tem = get_doc_string (doc, 0, 0);
 442       if (NILP (tem) && try_reload)
 443         {
 444           /* The file is newer, we need to reset the pointers.  */
 445           struct gcpro gcpro1, gcpro2;
 446           GCPRO2 (function, raw);
 447           try_reload = reread_doc_file (Fcar_safe (doc));
 448           UNGCPRO;
 449           if (try_reload)
 450             {
 451               try_reload = 0;
 452               goto documentation;
 453             }
 454         }
 455       else
 456         doc = tem;
 457     }
 458
 459   if (NILP (raw))
 460     doc = Fsubstitute_command_keys (doc);
 461   return doc;
 462 }
 463
 464 DEFUN ("documentation-property", Fdocumentation_property,
 465        Sdocumentation_property, 2, 3, 0,
 466        doc: /* Return the documentation string that is SYMBOL's PROP property.
 467 Third argument RAW omitted or nil means pass the result through
 468 `substitute-command-keys' if it is a string.
 469
 470 This differs from `get' in that it can refer to strings stored in the
 471 `etc/DOC' file; and that it evaluates documentation properties that
 472 aren't strings.  */)
 473   (Lisp_Object symbol, Lisp_Object prop, Lisp_Object raw)
 474 {
 475   bool try_reload = 1;
 476   Lisp_Object tem;
 477
 478  documentation_property:
 479
 480   tem = Fget (symbol, prop);
 481   if (EQ (tem, make_number (0)))
 482     tem = Qnil;
 483   if (INTEGERP (tem) || (CONSP (tem) && INTEGERP (XCDR (tem))))
 484     {
 485       Lisp_Object doc = tem;
 486       tem = get_doc_string (tem, 0, 0);
 487       if (NILP (tem) && try_reload)
 488         {
 489           /* The file is newer, we need to reset the pointers.  */
 490           struct gcpro gcpro1, gcpro2, gcpro3;
 491           GCPRO3 (symbol, prop, raw);
 492           try_reload = reread_doc_file (Fcar_safe (doc));
 493           UNGCPRO;
 494           if (try_reload)
 495             {
 496               try_reload = 0;
 497               goto documentation_property;
 498             }
 499         }
 500     }
 501   else if (!STRINGP (tem))
 502     /* Feval protects its argument.  */
 503     tem = Feval (tem, Qnil);
 504
 505   if (NILP (raw) && STRINGP (tem))
 506     tem = Fsubstitute_command_keys (tem);
 507   return tem;
 508 }
 509 \f
 510 /* Scanning the DOC files and placing docstring offsets into functions.  */
 511
 512 static void
 513 store_function_docstring (Lisp_Object obj, ptrdiff_t offset)
 514 {
 515   /* Don't use indirect_function here, or defaliases will apply their
 516      docstrings to the base functions (Bug#2603).  */
 517   Lisp_Object fun = SYMBOLP (obj) ? XSYMBOL (obj)->function : obj;
 518
 519   /* The type determines where the docstring is stored.  */
 520
 521   /* Lisp_Subrs have a slot for it.  */
 522   if (SUBRP (fun))
 523     {
 524       intptr_t negative_offset = - offset;
 525       XSUBR (fun)->doc = (char *) negative_offset;
 526     }
 527
 528   /* If it's a lisp form, stick it in the form.  */
 529   else if (CONSP (fun))
 530     {
 531       Lisp_Object tem;
 532
 533       tem = XCAR (fun);
 534       if (EQ (tem, Qlambda) || EQ (tem, Qautoload)
 535           || (EQ (tem, Qclosure) && (fun = XCDR (fun), 1)))
 536         {
 537           tem = Fcdr (Fcdr (fun));
 538           if (CONSP (tem) && INTEGERP (XCAR (tem)))
 539             /* FIXME: This modifies typically pure hash-cons'd data, so its
 540                correctness is quite delicate.  */
 541             XSETCAR (tem, make_number (offset));
 542         }
 543       else if (EQ (tem, Qmacro))
 544         store_function_docstring (XCDR (fun), offset);
 545     }
 546
 547   /* Bytecode objects sometimes have slots for it.  */
 548   else if (COMPILEDP (fun))
 549     {
 550       /* This bytecode object must have a slot for the
 551          docstring, since we've found a docstring for it.  */
 552       if ((ASIZE (fun) & PSEUDOVECTOR_SIZE_MASK) > COMPILED_DOC_STRING)
 553         ASET (fun, COMPILED_DOC_STRING, make_number (offset));
 554     }
 555 }
 556
 557
 558 DEFUN ("Snarf-documentation", Fsnarf_documentation, Ssnarf_documentation,
 559        1, 1, 0,
 560        doc: /* Used during Emacs initialization to scan the `etc/DOC...' file.
 561 This searches the `etc/DOC...' file for doc strings and
 562 records them in function and variable definitions.
 563 The function takes one argument, FILENAME, a string;
 564 it specifies the file name (without a directory) of the DOC file.
 565 That file is found in `../etc' now; later, when the dumped Emacs is run,
 566 the same file name is found in the `doc-directory'.  */)
 567   (Lisp_Object filename)
 568 {
 569   int fd;
 570   char buf[1024 + 1];
 571   int filled;
 572   EMACS_INT pos;
 573   Lisp_Object sym;
 574   char *p, *name;
 575   bool skip_file = 0;
 576
 577   CHECK_STRING (filename);
 578
 579   if
 580 #ifndef CANNOT_DUMP
 581     (!NILP (Vpurify_flag))
 582 #else /* CANNOT_DUMP */
 583       (0)
 584 #endif /* CANNOT_DUMP */
 585     {
 586       name = alloca (SCHARS (filename) + 14);
 587       strcpy (name, "../etc/");
 588     }
 589   else
 590     {
 591       CHECK_STRING (Vdoc_directory);
 592       name = alloca (SCHARS (filename) + SCHARS (Vdoc_directory) + 1);
 593       strcpy (name, SSDATA (Vdoc_directory));
 594     }
 595   strcat (name, SSDATA (filename));     /*** Add this line ***/
 596
 597   /* Vbuild_files is nil when temacs is run, and non-nil after that.  */
 598   if (NILP (Vbuild_files))
 599     {
 600       static char const *const buildobj[] =
 601         {
 602           #include "buildobj.h"
 603         };
 604       int i = sizeof buildobj / sizeof *buildobj;
 605       while (0 <= --i)
 606         Vbuild_files = Fcons (build_string (buildobj[i]), Vbuild_files);
 607       Vbuild_files = Fpurecopy (Vbuild_files);
 608     }
 609
 610   fd = emacs_open (name, O_RDONLY, 0);
 611   if (fd < 0)
 612     report_file_error ("Opening doc string file",
 613                        Fcons (build_string (name), Qnil));
 614   Vdoc_file_name = filename;
 615   filled = 0;
 616   pos = 0;
 617   while (1)
 618     {
 619       register char *end;
 620       if (filled < 512)
 621         filled += emacs_read (fd, &buf[filled], sizeof buf - 1 - filled);
 622       if (!filled)
 623         break;
 624
 625       buf[filled] = 0;
 626       end = buf + (filled < 512 ? filled : filled - 128);
 627       p = memchr (buf, '\037', end - buf);
 628       /* p points to ^_Ffunctionname\n or ^_Vvarname\n or ^_Sfilename\n.  */
 629       if (p)
 630         {
 631           end = strchr (p, '\n');
 632
 633           /* See if this is a file name, and if it is a file in build-files.  */
 634           if (p[1] == 'S')
 635             {
 636               skip_file = 0;
 637               if (end - p > 4 && end[-2] == '.'
 638                   && (end[-1] == 'o' || end[-1] == 'c'))
 639                 {
 640                   ptrdiff_t len = end - p - 2;
 641                   char *fromfile = alloca (len + 1);
 642                   memcpy (fromfile, &p[2], len);
 643                   fromfile[len] = 0;
 644                   if (fromfile[len-1] == 'c')
 645                     fromfile[len-1] = 'o';
 646
 647                   skip_file = NILP (Fmember (build_string (fromfile),
 648                                              Vbuild_files));
 649                 }
 650             }
 651
 652           sym = oblookup (Vobarray, p + 2,
 653                           multibyte_chars_in_text ((unsigned char *) p + 2,
 654                                                    end - p - 2),
 655                           end - p - 2);
 656           /* Check skip_file so that when a function is defined several
 657              times in different files (typically, once in xterm, once in
 658              w32term, ...), we only pay attention to the one that
 659              matters.  */
 660           if (! skip_file && SYMBOLP (sym))
 661             {
 662               /* Attach a docstring to a variable?  */
 663               if (p[1] == 'V')
 664                 {
 665                   /* Install file-position as variable-documentation property
 666                      and make it negative for a user-variable
 667                      (doc starts with a `*').  */
 668                   if (!NILP (Fboundp (sym)))
 669                     Fput (sym, Qvariable_documentation,
 670                           make_number ((pos + end + 1 - buf)
 671                                        * (end[1] == '*' ? -1 : 1)));
 672                 }
 673
 674               /* Attach a docstring to a function?  */
 675               else if (p[1] == 'F')
 676                 {
 677                   if (!NILP (Ffboundp (sym)))
 678                     store_function_docstring (sym, pos + end + 1 - buf);
 679                 }
 680               else if (p[1] == 'S')
 681                 ; /* Just a source file name boundary marker.  Ignore it.  */
 682
 683               else
 684                 error ("DOC file invalid at position %"pI"d", pos);
 685             }
 686         }
 687       pos += end - buf;
 688       filled -= end - buf;
 689       memmove (buf, end, filled);
 690     }
 691   emacs_close (fd);
 692   return Qnil;
 693 }
 694 \f
 695 DEFUN ("substitute-command-keys", Fsubstitute_command_keys,
 696        Ssubstitute_command_keys, 1, 1, 0,
 697        doc: /* Substitute key descriptions for command names in STRING.
 698 Each substring of the form \\=\\[COMMAND] is replaced by either a
 699 keystroke sequence that invokes COMMAND, or "M-x COMMAND" if COMMAND
 700 is not on any keys.
 701
 702 Each substring of the form \\=\\{MAPVAR} is replaced by a summary of
 703 the value of MAPVAR as a keymap.  This summary is similar to the one
 704 produced by `describe-bindings'.  The summary ends in two newlines
 705 \(used by the helper function `help-make-xrefs' to find the end of the
 706 summary).
 707
 708 Each substring of the form \\=\\<MAPVAR> specifies the use of MAPVAR
 709 as the keymap for future \\=\\[COMMAND] substrings.
 710 \\=\\= quotes the following character and is discarded;
 711 thus, \\=\\=\\=\\= puts \\=\\= into the output, and \\=\\=\\=\\[ puts \\=\\[ into the output.
 712
 713 Return the original STRING if no substitutions are made.
 714 Otherwise, return a new string, without any text properties.  */)
 715   (Lisp_Object string)
 716 {
 717   char *buf;
 718   bool changed = 0;
 719   unsigned char *strp;
 720   char *bufp;
 721   ptrdiff_t idx;
 722   ptrdiff_t bsize;
 723   Lisp_Object tem;
 724   Lisp_Object keymap;
 725   unsigned char *start;
 726   ptrdiff_t length, length_byte;
 727   Lisp_Object name;
 728   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
 729   bool multibyte;
 730   ptrdiff_t nchars;
 731
 732   if (NILP (string))
 733     return Qnil;
 734
 735   CHECK_STRING (string);
 736   tem = Qnil;
 737   keymap = Qnil;
 738   name = Qnil;
 739   GCPRO4 (string, tem, keymap, name);
 740
 741   multibyte = STRING_MULTIBYTE (string);
 742   nchars = 0;
 743
 744   /* KEYMAP is either nil (which means search all the active keymaps)
 745      or a specified local map (which means search just that and the
 746      global map).  If non-nil, it might come from Voverriding_local_map,
 747      or from a \\<mapname> construct in STRING itself..  */
 748   keymap = Voverriding_local_map;
 749
 750   bsize = SBYTES (string);
 751   bufp = buf = xmalloc (bsize);
 752
 753   strp = SDATA (string);
 754   while (strp < SDATA (string) + SBYTES (string))
 755     {
 756       if (strp[0] == '\\' && strp[1] == '=')
 757         {
 758           /* \= quotes the next character;
 759              thus, to put in \[ without its special meaning, use \=\[.  */
 760           changed = 1;
 761           strp += 2;
 762           if (multibyte)
 763             {
 764               int len;
 765
 766               STRING_CHAR_AND_LENGTH (strp, len);
 767               if (len == 1)
 768                 *bufp = *strp;
 769               else
 770                 memcpy (bufp, strp, len);
 771               strp += len;
 772               bufp += len;
 773               nchars++;
 774             }
 775           else
 776             *bufp++ = *strp++, nchars++;
 777         }
 778       else if (strp[0] == '\\' && strp[1] == '[')
 779         {
 780           ptrdiff_t start_idx;
 781           bool follow_remap = 1;
 782
 783           changed = 1;
 784           strp += 2;            /* skip \[ */
 785           start = strp;
 786           start_idx = start - SDATA (string);
 787
 788           while ((strp - SDATA (string)
 789                   < SBYTES (string))
 790                  && *strp != ']')
 791             strp++;
 792           length_byte = strp - start;
 793
 794           strp++;               /* skip ] */
 795
 796           /* Save STRP in IDX.  */
 797           idx = strp - SDATA (string);
 798           name = Fintern (make_string ((char *) start, length_byte), Qnil);
 799
 800         do_remap:
 801           tem = Fwhere_is_internal (name, keymap, Qt, Qnil, Qnil);
 802
 803           if (VECTORP (tem) && ASIZE (tem) > 1
 804               && EQ (AREF (tem, 0), Qremap) && SYMBOLP (AREF (tem, 1))
 805               && follow_remap)
 806             {
 807               name = AREF (tem, 1);
 808               follow_remap = 0;
 809               goto do_remap;
 810             }
 811
 812           /* Note the Fwhere_is_internal can GC, so we have to take
 813              relocation of string contents into account.  */
 814           strp = SDATA (string) + idx;
 815           start = SDATA (string) + start_idx;
 816
 817           if (NILP (tem))       /* but not on any keys */
 818             {
 819               ptrdiff_t offset = bufp - buf;
 820               if (STRING_BYTES_BOUND - 4 < bsize)
 821                 string_overflow ();
 822               buf = xrealloc (buf, bsize += 4);
 823               bufp = buf + offset;
 824               memcpy (bufp, "M-x ", 4);
 825               bufp += 4;
 826               nchars += 4;
 827               if (multibyte)
 828                 length = multibyte_chars_in_text (start, length_byte);
 829               else
 830                 length = length_byte;
 831               goto subst;
 832             }
 833           else
 834             {                   /* function is on a key */
 835               tem = Fkey_description (tem, Qnil);
 836               goto subst_string;
 837             }
 838         }
 839       /* \{foo} is replaced with a summary of the keymap (symbol-value foo).
 840          \<foo> just sets the keymap used for \[cmd].  */
 841       else if (strp[0] == '\\' && (strp[1] == '{' || strp[1] == '<'))
 842         {
 843           struct buffer *oldbuf;
 844           ptrdiff_t start_idx;
 845           /* This is for computing the SHADOWS arg for describe_map_tree.  */
 846           Lisp_Object active_maps = Fcurrent_active_maps (Qnil, Qnil);
 847           Lisp_Object earlier_maps;
 848
 849           changed = 1;
 850           strp += 2;            /* skip \{ or \< */
 851           start = strp;
 852           start_idx = start - SDATA (string);
 853
 854           while ((strp - SDATA (string) < SBYTES (string))
 855                  && *strp != '}' && *strp != '>')
 856             strp++;
 857
 858           length_byte = strp - start;
 859           strp++;                       /* skip } or > */
 860
 861           /* Save STRP in IDX.  */
 862           idx = strp - SDATA (string);
 863
 864           /* Get the value of the keymap in TEM, or nil if undefined.
 865              Do this while still in the user's current buffer
 866              in case it is a local variable.  */
 867           name = Fintern (make_string ((char *) start, length_byte), Qnil);
 868           tem = Fboundp (name);
 869           if (! NILP (tem))
 870             {
 871               tem = Fsymbol_value (name);
 872               if (! NILP (tem))
 873                 {
 874                   tem = get_keymap (tem, 0, 1);
 875                   /* Note that get_keymap can GC.  */
 876                   strp = SDATA (string) + idx;
 877                   start = SDATA (string) + start_idx;
 878                 }
 879             }
 880
 881           /* Now switch to a temp buffer.  */
 882           oldbuf = current_buffer;
 883           set_buffer_internal (XBUFFER (Vprin1_to_string_buffer));
 884
 885           if (NILP (tem))
 886             {
 887               name = Fsymbol_name (name);
 888               insert_string ("\nUses keymap `");
 889               insert_from_string (name, 0, 0,
 890                                   SCHARS (name),
 891                                   SBYTES (name), 1);
 892               insert_string ("', which is not currently defined.\n");
 893               if (start[-1] == '<') keymap = Qnil;
 894             }
 895           else if (start[-1] == '<')
 896             keymap = tem;
 897           else
 898             {
 899               /* Get the list of active keymaps that precede this one.
 900                  If this one's not active, get nil.  */
 901               earlier_maps = Fcdr (Fmemq (tem, Freverse (active_maps)));
 902               describe_map_tree (tem, 1, Fnreverse (earlier_maps),
 903                                  Qnil, (char *)0, 1, 0, 0, 1);
 904             }
 905           tem = Fbuffer_string ();
 906           Ferase_buffer ();
 907           set_buffer_internal (oldbuf);
 908
 909         subst_string:
 910           start = SDATA (tem);
 911           length = SCHARS (tem);
 912           length_byte = SBYTES (tem);
 913         subst:
 914           {
 915             ptrdiff_t offset = bufp - buf;
 916             if (STRING_BYTES_BOUND - length_byte < bsize)
 917               string_overflow ();
 918             buf = xrealloc (buf, bsize += length_byte);
 919             bufp = buf + offset;
 920             memcpy (bufp, start, length_byte);
 921             bufp += length_byte;
 922             nchars += length;
 923             /* Check STRING again in case gc relocated it.  */
 924             strp = SDATA (string) + idx;
 925           }
 926         }
 927       else if (! multibyte)             /* just copy other chars */
 928         *bufp++ = *strp++, nchars++;
 929       else
 930         {
 931           int len;
 932
 933           STRING_CHAR_AND_LENGTH (strp, len);
 934           if (len == 1)
 935             *bufp = *strp;
 936           else
 937             memcpy (bufp, strp, len);
 938           strp += len;
 939           bufp += len;
 940           nchars++;
 941         }
 942     }
 943
 944   if (changed)                  /* don't bother if nothing substituted */
 945     tem = make_string_from_bytes (buf, nchars, bufp - buf);
 946   else
 947     tem = string;
 948   xfree (buf);
 949   RETURN_UNGCPRO (tem);
 950 }
 951 \f
 952 void
 953 syms_of_doc (void)
 954 {
 955   DEFSYM (Qfunction_documentation, "function-documentation");
 956
 957   DEFVAR_LISP ("internal-doc-file-name", Vdoc_file_name,
 958                doc: /* Name of file containing documentation strings of built-in symbols.  */);
 959   Vdoc_file_name = Qnil;
 960
 961   DEFVAR_LISP ("build-files", Vbuild_files,
 962                doc: /* A list of files used to build this Emacs binary.  */);
 963   Vbuild_files = Qnil;
 964
 965   defsubr (&Sdocumentation);
 966   defsubr (&Sdocumentation_property);
 967   defsubr (&Ssnarf_documentation);
 968   defsubr (&Ssubstitute_command_keys);
 969 }