Merge: lib-src changes mostly to avoid GCC warnings
[bpt/emacs.git] / lib-src / make-docfile.c
1 /* Generate doc-string file for GNU Emacs from source files.
2 Copyright (C) 1985-1986, 1992-1994, 1997, 1999-2011
3 Free Software Foundation, Inc.
4
5 This file is part of GNU Emacs.
6
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
11
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
19
20
21 /* The arguments given to this program are all the C and Lisp source files
22 of GNU Emacs. .elc and .el and .c files are allowed.
23 A .o file can also be specified; the .c file it was made from is used.
24 This helps the makefile pass the correct list of files.
25 Option -d DIR means change to DIR before looking for files.
26
27 The results, which go to standard output or to a file
28 specified with -a or -o (-a to append, -o to start from nothing),
29 are entries containing function or variable names and their documentation.
30 Each entry starts with a ^_ character.
31 Then comes F for a function or V for a variable.
32 Then comes the function or variable name, terminated with a newline.
33 Then comes the documentation for that function or variable.
34 */
35
36 #include <config.h>
37
38 /* defined to be emacs_main, sys_fopen, etc. in config.h */
39 #undef main
40 #undef fopen
41 #undef chdir
42
43 #include <stdio.h>
44 #include <stdlib.h>
45 #ifdef MSDOS
46 #include <fcntl.h>
47 #endif /* MSDOS */
48 #ifdef WINDOWSNT
49 #include <fcntl.h>
50 #include <direct.h>
51 #endif /* WINDOWSNT */
52
53 #ifdef DOS_NT
54 #define READ_TEXT "rt"
55 #define READ_BINARY "rb"
56 #else /* not DOS_NT */
57 #define READ_TEXT "r"
58 #define READ_BINARY "r"
59 #endif /* not DOS_NT */
60
61 #ifndef DIRECTORY_SEP
62 #define DIRECTORY_SEP '/'
63 #endif
64
65 #ifndef IS_DIRECTORY_SEP
66 #define IS_DIRECTORY_SEP(_c_) ((_c_) == DIRECTORY_SEP)
67 #endif
68
69 static int scan_file (char *filename);
70 static int scan_lisp_file (const char *filename, const char *mode);
71 static int scan_c_file (char *filename, const char *mode);
72 static void fatal (const char *s1, const char *s2) NO_RETURN;
73 static void start_globals (void);
74 static void write_globals (void);
75
76 #ifdef MSDOS
77 /* s/msdos.h defines this as sys_chdir, but we're not linking with the
78 file where that function is defined. */
79 #undef chdir
80 #endif
81
82 #include <unistd.h>
83
84 /* Stdio stream for output to the DOC file. */
85 FILE *outfile;
86
87 /* Name this program was invoked with. */
88 char *progname;
89
90 /* Nonzero if this invocation is generating globals.h. */
91 int generate_globals;
92
93 /* Print error message. `s1' is printf control string, `s2' is arg for it. */
94
95 /* VARARGS1 */
96 static void
97 error (const char *s1, const char *s2)
98 {
99 fprintf (stderr, "%s: ", progname);
100 fprintf (stderr, s1, s2);
101 fprintf (stderr, "\n");
102 }
103
104 /* Print error message and exit. */
105
106 /* VARARGS1 */
107 static void
108 fatal (const char *s1, const char *s2)
109 {
110 error (s1, s2);
111 exit (EXIT_FAILURE);
112 }
113
114 /* Like malloc but get fatal error if memory is exhausted. */
115
116 static void *
117 xmalloc (unsigned int size)
118 {
119 void *result = (void *) malloc (size);
120 if (result == NULL)
121 fatal ("virtual memory exhausted", 0);
122 return result;
123 }
124
125 /* Like realloc but get fatal error if memory is exhausted. */
126
127 static void *
128 xrealloc (void *arg, unsigned int size)
129 {
130 void *result = (void *) realloc (arg, size);
131 if (result == NULL)
132 fatal ("virtual memory exhausted", 0);
133 return result;
134 }
135
136 \f
137 int
138 main (int argc, char **argv)
139 {
140 int i;
141 int err_count = 0;
142 int first_infile;
143
144 progname = argv[0];
145
146 outfile = stdout;
147
148 /* Don't put CRs in the DOC file. */
149 #ifdef MSDOS
150 _fmode = O_BINARY;
151 #if 0 /* Suspicion is that this causes hanging.
152 So instead we require people to use -o on MSDOS. */
153 (stdout)->_flag &= ~_IOTEXT;
154 _setmode (fileno (stdout), O_BINARY);
155 #endif
156 outfile = 0;
157 #endif /* MSDOS */
158 #ifdef WINDOWSNT
159 _fmode = O_BINARY;
160 _setmode (fileno (stdout), O_BINARY);
161 #endif /* WINDOWSNT */
162
163 /* If first two args are -o FILE, output to FILE. */
164 i = 1;
165 if (argc > i + 1 && !strcmp (argv[i], "-o"))
166 {
167 outfile = fopen (argv[i + 1], "w");
168 i += 2;
169 }
170 if (argc > i + 1 && !strcmp (argv[i], "-a"))
171 {
172 outfile = fopen (argv[i + 1], "a");
173 i += 2;
174 }
175 if (argc > i + 1 && !strcmp (argv[i], "-d"))
176 {
177 if (chdir (argv[i + 1]) != 0)
178 {
179 perror (argv[i + 1]);
180 return EXIT_FAILURE;
181 }
182 i += 2;
183 }
184 if (argc > i && !strcmp (argv[i], "-g"))
185 {
186 generate_globals = 1;
187 ++i;
188 }
189
190 if (outfile == 0)
191 fatal ("No output file specified", "");
192
193 if (generate_globals)
194 start_globals ();
195
196 first_infile = i;
197 for (; i < argc; i++)
198 {
199 int j;
200 /* Don't process one file twice. */
201 for (j = first_infile; j < i; j++)
202 if (! strcmp (argv[i], argv[j]))
203 break;
204 if (j == i)
205 err_count += scan_file (argv[i]);
206 }
207
208 if (err_count == 0 && generate_globals)
209 write_globals ();
210
211 return (err_count > 0 ? EXIT_FAILURE : EXIT_SUCCESS);
212 }
213
214 /* Add a source file name boundary marker in the output file. */
215 static void
216 put_filename (char *filename)
217 {
218 char *tmp;
219
220 for (tmp = filename; *tmp; tmp++)
221 {
222 if (IS_DIRECTORY_SEP(*tmp))
223 filename = tmp + 1;
224 }
225
226 putc (037, outfile);
227 putc ('S', outfile);
228 fprintf (outfile, "%s\n", filename);
229 }
230
231 /* Read file FILENAME and output its doc strings to outfile. */
232 /* Return 1 if file is not found, 0 if it is found. */
233
234 static int
235 scan_file (char *filename)
236 {
237
238 size_t len = strlen (filename);
239
240 if (!generate_globals)
241 put_filename (filename);
242 if (len > 4 && !strcmp (filename + len - 4, ".elc"))
243 return scan_lisp_file (filename, READ_BINARY);
244 else if (len > 3 && !strcmp (filename + len - 3, ".el"))
245 return scan_lisp_file (filename, READ_TEXT);
246 else
247 return scan_c_file (filename, READ_TEXT);
248 }
249
250 static void
251 start_globals (void)
252 {
253 fprintf (outfile, "/* This file was auto-generated by make-docfile. */\n");
254 fprintf (outfile, "/* DO NOT EDIT. */\n");
255 fprintf (outfile, "struct emacs_globals {\n");
256 }
257 \f
258 static char input_buffer[128];
259
260 /* Some state during the execution of `read_c_string_or_comment'. */
261 struct rcsoc_state
262 {
263 /* A count of spaces and newlines that have been read, but not output. */
264 unsigned pending_spaces, pending_newlines;
265
266 /* Where we're reading from. */
267 FILE *in_file;
268
269 /* If non-zero, a buffer into which to copy characters. */
270 char *buf_ptr;
271 /* If non-zero, a file into which to copy characters. */
272 FILE *out_file;
273
274 /* A keyword we look for at the beginning of lines. If found, it is
275 not copied, and SAW_KEYWORD is set to true. */
276 const char *keyword;
277 /* The current point we've reached in an occurrence of KEYWORD in
278 the input stream. */
279 const char *cur_keyword_ptr;
280 /* Set to true if we saw an occurrence of KEYWORD. */
281 int saw_keyword;
282 };
283
284 /* Output CH to the file or buffer in STATE. Any pending newlines or
285 spaces are output first. */
286
287 static INLINE void
288 put_char (int ch, struct rcsoc_state *state)
289 {
290 int out_ch;
291 do
292 {
293 if (state->pending_newlines > 0)
294 {
295 state->pending_newlines--;
296 out_ch = '\n';
297 }
298 else if (state->pending_spaces > 0)
299 {
300 state->pending_spaces--;
301 out_ch = ' ';
302 }
303 else
304 out_ch = ch;
305
306 if (state->out_file)
307 putc (out_ch, state->out_file);
308 if (state->buf_ptr)
309 *state->buf_ptr++ = out_ch;
310 }
311 while (out_ch != ch);
312 }
313
314 /* If in the middle of scanning a keyword, continue scanning with
315 character CH, otherwise output CH to the file or buffer in STATE.
316 Any pending newlines or spaces are output first, as well as any
317 previously scanned characters that were thought to be part of a
318 keyword, but were in fact not. */
319
320 static void
321 scan_keyword_or_put_char (int ch, struct rcsoc_state *state)
322 {
323 if (state->keyword
324 && *state->cur_keyword_ptr == ch
325 && (state->cur_keyword_ptr > state->keyword
326 || state->pending_newlines > 0))
327 /* We might be looking at STATE->keyword at some point.
328 Keep looking until we know for sure. */
329 {
330 if (*++state->cur_keyword_ptr == '\0')
331 /* Saw the whole keyword. Set SAW_KEYWORD flag to true. */
332 {
333 state->saw_keyword = 1;
334
335 /* Reset the scanning pointer. */
336 state->cur_keyword_ptr = state->keyword;
337
338 /* Canonicalize whitespace preceding a usage string. */
339 state->pending_newlines = 2;
340 state->pending_spaces = 0;
341
342 /* Skip any whitespace between the keyword and the
343 usage string. */
344 do
345 ch = getc (state->in_file);
346 while (ch == ' ' || ch == '\n');
347
348 /* Output the open-paren we just read. */
349 put_char (ch, state);
350
351 /* Skip the function name and replace it with `fn'. */
352 do
353 ch = getc (state->in_file);
354 while (ch != ' ' && ch != ')');
355 put_char ('f', state);
356 put_char ('n', state);
357
358 /* Put back the last character. */
359 ungetc (ch, state->in_file);
360 }
361 }
362 else
363 {
364 if (state->keyword && state->cur_keyword_ptr > state->keyword)
365 /* We scanned the beginning of a potential usage
366 keyword, but it was a false alarm. Output the
367 part we scanned. */
368 {
369 const char *p;
370
371 for (p = state->keyword; p < state->cur_keyword_ptr; p++)
372 put_char (*p, state);
373
374 state->cur_keyword_ptr = state->keyword;
375 }
376
377 put_char (ch, state);
378 }
379 }
380
381
382 /* Skip a C string or C-style comment from INFILE, and return the
383 character that follows. COMMENT non-zero means skip a comment. If
384 PRINTFLAG is positive, output string contents to outfile. If it is
385 negative, store contents in buf. Convert escape sequences \n and
386 \t to newline and tab; discard \ followed by newline.
387 If SAW_USAGE is non-zero, then any occurrences of the string `usage:'
388 at the beginning of a line will be removed, and *SAW_USAGE set to
389 true if any were encountered. */
390
391 static int
392 read_c_string_or_comment (FILE *infile, int printflag, int comment, int *saw_usage)
393 {
394 register int c;
395 struct rcsoc_state state;
396
397 state.in_file = infile;
398 state.buf_ptr = (printflag < 0 ? input_buffer : 0);
399 state.out_file = (printflag > 0 ? outfile : 0);
400 state.pending_spaces = 0;
401 state.pending_newlines = 0;
402 state.keyword = (saw_usage ? "usage:" : 0);
403 state.cur_keyword_ptr = state.keyword;
404 state.saw_keyword = 0;
405
406 c = getc (infile);
407 if (comment)
408 while (c == '\n' || c == '\r' || c == '\t' || c == ' ')
409 c = getc (infile);
410
411 while (c != EOF)
412 {
413 while (c != EOF && (comment ? c != '*' : c != '"'))
414 {
415 if (c == '\\')
416 {
417 c = getc (infile);
418 if (c == '\n' || c == '\r')
419 {
420 c = getc (infile);
421 continue;
422 }
423 if (c == 'n')
424 c = '\n';
425 if (c == 't')
426 c = '\t';
427 }
428
429 if (c == ' ')
430 state.pending_spaces++;
431 else if (c == '\n')
432 {
433 state.pending_newlines++;
434 state.pending_spaces = 0;
435 }
436 else
437 scan_keyword_or_put_char (c, &state);
438
439 c = getc (infile);
440 }
441
442 if (c != EOF)
443 c = getc (infile);
444
445 if (comment)
446 {
447 if (c == '/')
448 {
449 c = getc (infile);
450 break;
451 }
452
453 scan_keyword_or_put_char ('*', &state);
454 }
455 else
456 {
457 if (c != '"')
458 break;
459
460 /* If we had a "", concatenate the two strings. */
461 c = getc (infile);
462 }
463 }
464
465 if (printflag < 0)
466 *state.buf_ptr = 0;
467
468 if (saw_usage)
469 *saw_usage = state.saw_keyword;
470
471 return c;
472 }
473
474
475 \f
476 /* Write to file OUT the argument names of function FUNC, whose text is in BUF.
477 MINARGS and MAXARGS are the minimum and maximum number of arguments. */
478
479 static void
480 write_c_args (FILE *out, char *func, char *buf, int minargs, int maxargs)
481 {
482 register char *p;
483 int in_ident = 0;
484 char *ident_start;
485 size_t ident_length = 0;
486
487 fprintf (out, "(fn");
488
489 if (*buf == '(')
490 ++buf;
491
492 for (p = buf; *p; p++)
493 {
494 char c = *p;
495
496 /* Notice when a new identifier starts. */
497 if ((('A' <= c && c <= 'Z')
498 || ('a' <= c && c <= 'z')
499 || ('0' <= c && c <= '9')
500 || c == '_')
501 != in_ident)
502 {
503 if (!in_ident)
504 {
505 in_ident = 1;
506 ident_start = p;
507 }
508 else
509 {
510 in_ident = 0;
511 ident_length = p - ident_start;
512 }
513 }
514
515 /* Found the end of an argument, write out the last seen
516 identifier. */
517 if (c == ',' || c == ')')
518 {
519 if (ident_length == 0)
520 {
521 error ("empty arg list for `%s' should be (void), not ()", func);
522 continue;
523 }
524
525 if (strncmp (ident_start, "void", ident_length) == 0)
526 continue;
527
528 putc (' ', out);
529
530 if (minargs == 0 && maxargs > 0)
531 fprintf (out, "&optional ");
532
533 minargs--;
534 maxargs--;
535
536 /* In C code, `default' is a reserved word, so we spell it
537 `defalt'; unmangle that here. */
538 if (ident_length == 6 && strncmp (ident_start, "defalt", 6) == 0)
539 fprintf (out, "DEFAULT");
540 else
541 while (ident_length-- > 0)
542 {
543 c = *ident_start++;
544 if (c >= 'a' && c <= 'z')
545 /* Upcase the letter. */
546 c += 'A' - 'a';
547 else if (c == '_')
548 /* Print underscore as hyphen. */
549 c = '-';
550 putc (c, out);
551 }
552 }
553 }
554
555 putc (')', out);
556 }
557 \f
558 /* The types of globals. */
559 enum global_type
560 {
561 EMACS_INTEGER,
562 BOOLEAN,
563 LISP_OBJECT,
564 INVALID
565 };
566
567 /* A single global. */
568 struct global
569 {
570 enum global_type type;
571 char *name;
572 };
573
574 /* All the variable names we saw while scanning C sources in `-g'
575 mode. */
576 int num_globals;
577 int num_globals_allocated;
578 struct global *globals;
579
580 static void
581 add_global (enum global_type type, char *name)
582 {
583 /* Ignore the one non-symbol that can occur. */
584 if (strcmp (name, "..."))
585 {
586 ++num_globals;
587
588 if (num_globals_allocated == 0)
589 {
590 num_globals_allocated = 100;
591 globals = xmalloc (num_globals_allocated * sizeof (struct global));
592 }
593 else if (num_globals == num_globals_allocated)
594 {
595 num_globals_allocated *= 2;
596 globals = xrealloc (globals,
597 num_globals_allocated * sizeof (struct global));
598 }
599
600 globals[num_globals - 1].type = type;
601 globals[num_globals - 1].name = name;
602 }
603 }
604
605 static int
606 compare_globals (const void *a, const void *b)
607 {
608 const struct global *ga = a;
609 const struct global *gb = b;
610 return strcmp (ga->name, gb->name);
611 }
612
613 static void
614 write_globals (void)
615 {
616 int i;
617 qsort (globals, num_globals, sizeof (struct global), compare_globals);
618 for (i = 0; i < num_globals; ++i)
619 {
620 char const *type;
621
622 switch (globals[i].type)
623 {
624 case EMACS_INTEGER:
625 type = "EMACS_INT";
626 break;
627 case BOOLEAN:
628 type = "int";
629 break;
630 case LISP_OBJECT:
631 type = "Lisp_Object";
632 break;
633 default:
634 fatal ("not a recognized DEFVAR_", 0);
635 }
636
637 fprintf (outfile, " %s f_%s;\n", type, globals[i].name);
638 fprintf (outfile, "#define %s globals.f_%s\n",
639 globals[i].name, globals[i].name);
640 while (i + 1 < num_globals
641 && !strcmp (globals[i].name, globals[i + 1].name))
642 ++i;
643 }
644
645 fprintf (outfile, "};\n");
646 fprintf (outfile, "extern struct emacs_globals globals;\n");
647 }
648
649 \f
650 /* Read through a c file. If a .o file is named,
651 the corresponding .c or .m file is read instead.
652 Looks for DEFUN constructs such as are defined in ../src/lisp.h.
653 Accepts any word starting DEF... so it finds DEFSIMPLE and DEFPRED. */
654
655 static int
656 scan_c_file (char *filename, const char *mode)
657 {
658 FILE *infile;
659 register int c;
660 register int commas;
661 int minargs, maxargs;
662 int extension = filename[strlen (filename) - 1];
663
664 if (extension == 'o')
665 filename[strlen (filename) - 1] = 'c';
666
667 infile = fopen (filename, mode);
668
669 if (infile == NULL && extension == 'o')
670 {
671 /* try .m */
672 filename[strlen (filename) - 1] = 'm';
673 infile = fopen (filename, mode);
674 if (infile == NULL)
675 filename[strlen (filename) - 1] = 'c'; /* don't confuse people */
676 }
677
678 /* No error if non-ex input file */
679 if (infile == NULL)
680 {
681 perror (filename);
682 return 0;
683 }
684
685 /* Reset extension to be able to detect duplicate files. */
686 filename[strlen (filename) - 1] = extension;
687
688 c = '\n';
689 while (!feof (infile))
690 {
691 int doc_keyword = 0;
692 int defunflag = 0;
693 int defvarperbufferflag = 0;
694 int defvarflag = 0;
695 enum global_type type = INVALID;
696
697 if (c != '\n' && c != '\r')
698 {
699 c = getc (infile);
700 continue;
701 }
702 c = getc (infile);
703 if (c == ' ')
704 {
705 while (c == ' ')
706 c = getc (infile);
707 if (c != 'D')
708 continue;
709 c = getc (infile);
710 if (c != 'E')
711 continue;
712 c = getc (infile);
713 if (c != 'F')
714 continue;
715 c = getc (infile);
716 if (c != 'V')
717 continue;
718 c = getc (infile);
719 if (c != 'A')
720 continue;
721 c = getc (infile);
722 if (c != 'R')
723 continue;
724 c = getc (infile);
725 if (c != '_')
726 continue;
727
728 defvarflag = 1;
729
730 c = getc (infile);
731 defvarperbufferflag = (c == 'P');
732 if (generate_globals)
733 {
734 if (c == 'I')
735 type = EMACS_INTEGER;
736 else if (c == 'L')
737 type = LISP_OBJECT;
738 else if (c == 'B')
739 type = BOOLEAN;
740 }
741
742 c = getc (infile);
743 /* We need to distinguish between DEFVAR_BOOL and
744 DEFVAR_BUFFER_DEFAULTS. */
745 if (generate_globals && type == BOOLEAN && c != 'O')
746 type = INVALID;
747 }
748 else if (c == 'D')
749 {
750 c = getc (infile);
751 if (c != 'E')
752 continue;
753 c = getc (infile);
754 if (c != 'F')
755 continue;
756 c = getc (infile);
757 defunflag = c == 'U';
758 }
759 else continue;
760
761 if (generate_globals && (!defvarflag || defvarperbufferflag
762 || type == INVALID))
763 continue;
764
765 while (c != '(')
766 {
767 if (c < 0)
768 goto eof;
769 c = getc (infile);
770 }
771
772 /* Lisp variable or function name. */
773 c = getc (infile);
774 if (c != '"')
775 continue;
776 c = read_c_string_or_comment (infile, -1, 0, 0);
777
778 if (generate_globals)
779 {
780 int i = 0;
781 char *name;
782
783 /* Skip "," and whitespace. */
784 do
785 {
786 c = getc (infile);
787 }
788 while (c == ',' || c == ' ' || c == '\t' || c == '\n' || c == '\r');
789
790 /* Read in the identifier. */
791 do
792 {
793 input_buffer[i++] = c;
794 c = getc (infile);
795 }
796 while (! (c == ',' || c == ' ' || c == '\t' ||
797 c == '\n' || c == '\r'));
798 input_buffer[i] = '\0';
799
800 name = xmalloc (i + 1);
801 memcpy (name, input_buffer, i + 1);
802 add_global (type, name);
803 continue;
804 }
805
806 /* DEFVAR_LISP ("name", addr, "doc")
807 DEFVAR_LISP ("name", addr /\* doc *\/)
808 DEFVAR_LISP ("name", addr, doc: /\* doc *\/) */
809
810 if (defunflag)
811 commas = 5;
812 else if (defvarperbufferflag)
813 commas = 3;
814 else if (defvarflag)
815 commas = 1;
816 else /* For DEFSIMPLE and DEFPRED */
817 commas = 2;
818
819 while (commas)
820 {
821 if (c == ',')
822 {
823 commas--;
824
825 if (defunflag && (commas == 1 || commas == 2))
826 {
827 int scanned = 0;
828 do
829 c = getc (infile);
830 while (c == ' ' || c == '\n' || c == '\r' || c == '\t');
831 if (c < 0)
832 goto eof;
833 ungetc (c, infile);
834 if (commas == 2) /* pick up minargs */
835 scanned = fscanf (infile, "%d", &minargs);
836 else /* pick up maxargs */
837 if (c == 'M' || c == 'U') /* MANY || UNEVALLED */
838 maxargs = -1;
839 else
840 scanned = fscanf (infile, "%d", &maxargs);
841 if (scanned < 0)
842 goto eof;
843 }
844 }
845
846 if (c == EOF)
847 goto eof;
848 c = getc (infile);
849 }
850
851 while (c == ' ' || c == '\n' || c == '\r' || c == '\t')
852 c = getc (infile);
853
854 if (c == '"')
855 c = read_c_string_or_comment (infile, 0, 0, 0);
856
857 while (c != EOF && c != ',' && c != '/')
858 c = getc (infile);
859 if (c == ',')
860 {
861 c = getc (infile);
862 while (c == ' ' || c == '\n' || c == '\r' || c == '\t')
863 c = getc (infile);
864 while ((c >= 'a' && c <= 'z') || (c >= 'Z' && c <= 'Z'))
865 c = getc (infile);
866 if (c == ':')
867 {
868 doc_keyword = 1;
869 c = getc (infile);
870 while (c == ' ' || c == '\n' || c == '\r' || c == '\t')
871 c = getc (infile);
872 }
873 }
874
875 if (c == '"'
876 || (c == '/'
877 && (c = getc (infile),
878 ungetc (c, infile),
879 c == '*')))
880 {
881 int comment = c != '"';
882 int saw_usage;
883
884 putc (037, outfile);
885 putc (defvarflag ? 'V' : 'F', outfile);
886 fprintf (outfile, "%s\n", input_buffer);
887
888 if (comment)
889 getc (infile); /* Skip past `*' */
890 c = read_c_string_or_comment (infile, 1, comment, &saw_usage);
891
892 /* If this is a defun, find the arguments and print them. If
893 this function takes MANY or UNEVALLED args, then the C source
894 won't give the names of the arguments, so we shouldn't bother
895 trying to find them.
896
897 Various doc-string styles:
898 0: DEFUN (..., "DOC") (args) [!comment]
899 1: DEFUN (..., /\* DOC *\/ (args)) [comment && !doc_keyword]
900 2: DEFUN (..., doc: /\* DOC *\/) (args) [comment && doc_keyword]
901 */
902 if (defunflag && maxargs != -1 && !saw_usage)
903 {
904 char argbuf[1024], *p = argbuf;
905
906 if (!comment || doc_keyword)
907 while (c != ')')
908 {
909 if (c < 0)
910 goto eof;
911 c = getc (infile);
912 }
913
914 /* Skip into arguments. */
915 while (c != '(')
916 {
917 if (c < 0)
918 goto eof;
919 c = getc (infile);
920 }
921 /* Copy arguments into ARGBUF. */
922 *p++ = c;
923 do
924 *p++ = c = getc (infile);
925 while (c != ')');
926 *p = '\0';
927 /* Output them. */
928 fprintf (outfile, "\n\n");
929 write_c_args (outfile, input_buffer, argbuf, minargs, maxargs);
930 }
931 else if (defunflag && maxargs == -1 && !saw_usage)
932 /* The DOC should provide the usage form. */
933 fprintf (stderr, "Missing `usage' for function `%s'.\n",
934 input_buffer);
935 }
936 }
937 eof:
938 fclose (infile);
939 return 0;
940 }
941 \f
942 /* Read a file of Lisp code, compiled or interpreted.
943 Looks for
944 (defun NAME ARGS DOCSTRING ...)
945 (defmacro NAME ARGS DOCSTRING ...)
946 (defsubst NAME ARGS DOCSTRING ...)
947 (autoload (quote NAME) FILE DOCSTRING ...)
948 (defvar NAME VALUE DOCSTRING)
949 (defconst NAME VALUE DOCSTRING)
950 (fset (quote NAME) (make-byte-code ... DOCSTRING ...))
951 (fset (quote NAME) #[... DOCSTRING ...])
952 (defalias (quote NAME) #[... DOCSTRING ...])
953 (custom-declare-variable (quote NAME) VALUE DOCSTRING ...)
954 starting in column zero.
955 (quote NAME) may appear as 'NAME as well.
956
957 We also look for #@LENGTH CONTENTS^_ at the beginning of the line.
958 When we find that, we save it for the following defining-form,
959 and we use that instead of reading a doc string within that defining-form.
960
961 For defvar, defconst, and fset we skip to the docstring with a kludgy
962 formatting convention: all docstrings must appear on the same line as the
963 initial open-paren (the one in column zero) and must contain a backslash
964 and a newline immediately after the initial double-quote. No newlines
965 must appear between the beginning of the form and the first double-quote.
966 For defun, defmacro, and autoload, we know how to skip over the
967 arglist, but the doc string must still have a backslash and newline
968 immediately after the double quote.
969 The only source files that must follow this convention are preloaded
970 uncompiled ones like loaddefs.el and bindings.el; aside
971 from that, it is always the .elc file that we look at, and they are no
972 problem because byte-compiler output follows this convention.
973 The NAME and DOCSTRING are output.
974 NAME is preceded by `F' for a function or `V' for a variable.
975 An entry is output only if DOCSTRING has \ newline just after the opening "
976 */
977
978 static void
979 skip_white (FILE *infile)
980 {
981 char c = ' ';
982 while (c == ' ' || c == '\t' || c == '\n' || c == '\r')
983 c = getc (infile);
984 ungetc (c, infile);
985 }
986
987 static void
988 read_lisp_symbol (FILE *infile, char *buffer)
989 {
990 char c;
991 char *fillp = buffer;
992
993 skip_white (infile);
994 while (1)
995 {
996 c = getc (infile);
997 if (c == '\\')
998 *(++fillp) = getc (infile);
999 else if (c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '(' || c == ')')
1000 {
1001 ungetc (c, infile);
1002 *fillp = 0;
1003 break;
1004 }
1005 else
1006 *fillp++ = c;
1007 }
1008
1009 if (! buffer[0])
1010 fprintf (stderr, "## expected a symbol, got '%c'\n", c);
1011
1012 skip_white (infile);
1013 }
1014
1015 static int
1016 scan_lisp_file (const char *filename, const char *mode)
1017 {
1018 FILE *infile;
1019 register int c;
1020 char *saved_string = 0;
1021
1022 if (generate_globals)
1023 fatal ("scanning lisp file when -g specified", 0);
1024
1025 infile = fopen (filename, mode);
1026 if (infile == NULL)
1027 {
1028 perror (filename);
1029 return 0; /* No error */
1030 }
1031
1032 c = '\n';
1033 while (!feof (infile))
1034 {
1035 char buffer[BUFSIZ];
1036 char type;
1037
1038 /* If not at end of line, skip till we get to one. */
1039 if (c != '\n' && c != '\r')
1040 {
1041 c = getc (infile);
1042 continue;
1043 }
1044 /* Skip the line break. */
1045 while (c == '\n' || c == '\r')
1046 c = getc (infile);
1047 /* Detect a dynamic doc string and save it for the next expression. */
1048 if (c == '#')
1049 {
1050 c = getc (infile);
1051 if (c == '@')
1052 {
1053 size_t length = 0;
1054 size_t i;
1055
1056 /* Read the length. */
1057 while ((c = getc (infile),
1058 c >= '0' && c <= '9'))
1059 {
1060 length *= 10;
1061 length += c - '0';
1062 }
1063
1064 if (length <= 1)
1065 fatal ("invalid dynamic doc string length", "");
1066
1067 if (c != ' ')
1068 fatal ("space not found after dynamic doc string length", "");
1069
1070 /* The next character is a space that is counted in the length
1071 but not part of the doc string.
1072 We already read it, so just ignore it. */
1073 length--;
1074
1075 /* Read in the contents. */
1076 free (saved_string);
1077 saved_string = (char *) xmalloc (length);
1078 for (i = 0; i < length; i++)
1079 saved_string[i] = getc (infile);
1080 /* The last character is a ^_.
1081 That is needed in the .elc file
1082 but it is redundant in DOC. So get rid of it here. */
1083 saved_string[length - 1] = 0;
1084 /* Skip the line break. */
1085 while (c == '\n' || c == '\r')
1086 c = getc (infile);
1087 /* Skip the following line. */
1088 while (c != '\n' && c != '\r')
1089 c = getc (infile);
1090 }
1091 continue;
1092 }
1093
1094 if (c != '(')
1095 continue;
1096
1097 read_lisp_symbol (infile, buffer);
1098
1099 if (! strcmp (buffer, "defun")
1100 || ! strcmp (buffer, "defmacro")
1101 || ! strcmp (buffer, "defsubst"))
1102 {
1103 type = 'F';
1104 read_lisp_symbol (infile, buffer);
1105
1106 /* Skip the arguments: either "nil" or a list in parens */
1107
1108 c = getc (infile);
1109 if (c == 'n') /* nil */
1110 {
1111 if ((c = getc (infile)) != 'i'
1112 || (c = getc (infile)) != 'l')
1113 {
1114 fprintf (stderr, "## unparsable arglist in %s (%s)\n",
1115 buffer, filename);
1116 continue;
1117 }
1118 }
1119 else if (c != '(')
1120 {
1121 fprintf (stderr, "## unparsable arglist in %s (%s)\n",
1122 buffer, filename);
1123 continue;
1124 }
1125 else
1126 while (c != ')')
1127 c = getc (infile);
1128 skip_white (infile);
1129
1130 /* If the next three characters aren't `dquote bslash newline'
1131 then we're not reading a docstring.
1132 */
1133 if ((c = getc (infile)) != '"'
1134 || (c = getc (infile)) != '\\'
1135 || ((c = getc (infile)) != '\n' && c != '\r'))
1136 {
1137 #ifdef DEBUG
1138 fprintf (stderr, "## non-docstring in %s (%s)\n",
1139 buffer, filename);
1140 #endif
1141 continue;
1142 }
1143 }
1144
1145 else if (! strcmp (buffer, "defvar")
1146 || ! strcmp (buffer, "defconst"))
1147 {
1148 char c1 = 0, c2 = 0;
1149 type = 'V';
1150 read_lisp_symbol (infile, buffer);
1151
1152 if (saved_string == 0)
1153 {
1154
1155 /* Skip until the end of line; remember two previous chars. */
1156 while (c != '\n' && c != '\r' && c >= 0)
1157 {
1158 c2 = c1;
1159 c1 = c;
1160 c = getc (infile);
1161 }
1162
1163 /* If two previous characters were " and \,
1164 this is a doc string. Otherwise, there is none. */
1165 if (c2 != '"' || c1 != '\\')
1166 {
1167 #ifdef DEBUG
1168 fprintf (stderr, "## non-docstring in %s (%s)\n",
1169 buffer, filename);
1170 #endif
1171 continue;
1172 }
1173 }
1174 }
1175
1176 else if (! strcmp (buffer, "custom-declare-variable")
1177 || ! strcmp (buffer, "defvaralias")
1178 )
1179 {
1180 char c1 = 0, c2 = 0;
1181 type = 'V';
1182
1183 c = getc (infile);
1184 if (c == '\'')
1185 read_lisp_symbol (infile, buffer);
1186 else
1187 {
1188 if (c != '(')
1189 {
1190 fprintf (stderr,
1191 "## unparsable name in custom-declare-variable in %s\n",
1192 filename);
1193 continue;
1194 }
1195 read_lisp_symbol (infile, buffer);
1196 if (strcmp (buffer, "quote"))
1197 {
1198 fprintf (stderr,
1199 "## unparsable name in custom-declare-variable in %s\n",
1200 filename);
1201 continue;
1202 }
1203 read_lisp_symbol (infile, buffer);
1204 c = getc (infile);
1205 if (c != ')')
1206 {
1207 fprintf (stderr,
1208 "## unparsable quoted name in custom-declare-variable in %s\n",
1209 filename);
1210 continue;
1211 }
1212 }
1213
1214 if (saved_string == 0)
1215 {
1216 /* Skip to end of line; remember the two previous chars. */
1217 while (c != '\n' && c != '\r' && c >= 0)
1218 {
1219 c2 = c1;
1220 c1 = c;
1221 c = getc (infile);
1222 }
1223
1224 /* If two previous characters were " and \,
1225 this is a doc string. Otherwise, there is none. */
1226 if (c2 != '"' || c1 != '\\')
1227 {
1228 #ifdef DEBUG
1229 fprintf (stderr, "## non-docstring in %s (%s)\n",
1230 buffer, filename);
1231 #endif
1232 continue;
1233 }
1234 }
1235 }
1236
1237 else if (! strcmp (buffer, "fset") || ! strcmp (buffer, "defalias"))
1238 {
1239 char c1 = 0, c2 = 0;
1240 type = 'F';
1241
1242 c = getc (infile);
1243 if (c == '\'')
1244 read_lisp_symbol (infile, buffer);
1245 else
1246 {
1247 if (c != '(')
1248 {
1249 fprintf (stderr, "## unparsable name in fset in %s\n",
1250 filename);
1251 continue;
1252 }
1253 read_lisp_symbol (infile, buffer);
1254 if (strcmp (buffer, "quote"))
1255 {
1256 fprintf (stderr, "## unparsable name in fset in %s\n",
1257 filename);
1258 continue;
1259 }
1260 read_lisp_symbol (infile, buffer);
1261 c = getc (infile);
1262 if (c != ')')
1263 {
1264 fprintf (stderr,
1265 "## unparsable quoted name in fset in %s\n",
1266 filename);
1267 continue;
1268 }
1269 }
1270
1271 if (saved_string == 0)
1272 {
1273 /* Skip to end of line; remember the two previous chars. */
1274 while (c != '\n' && c != '\r' && c >= 0)
1275 {
1276 c2 = c1;
1277 c1 = c;
1278 c = getc (infile);
1279 }
1280
1281 /* If two previous characters were " and \,
1282 this is a doc string. Otherwise, there is none. */
1283 if (c2 != '"' || c1 != '\\')
1284 {
1285 #ifdef DEBUG
1286 fprintf (stderr, "## non-docstring in %s (%s)\n",
1287 buffer, filename);
1288 #endif
1289 continue;
1290 }
1291 }
1292 }
1293
1294 else if (! strcmp (buffer, "autoload"))
1295 {
1296 type = 'F';
1297 c = getc (infile);
1298 if (c == '\'')
1299 read_lisp_symbol (infile, buffer);
1300 else
1301 {
1302 if (c != '(')
1303 {
1304 fprintf (stderr, "## unparsable name in autoload in %s\n",
1305 filename);
1306 continue;
1307 }
1308 read_lisp_symbol (infile, buffer);
1309 if (strcmp (buffer, "quote"))
1310 {
1311 fprintf (stderr, "## unparsable name in autoload in %s\n",
1312 filename);
1313 continue;
1314 }
1315 read_lisp_symbol (infile, buffer);
1316 c = getc (infile);
1317 if (c != ')')
1318 {
1319 fprintf (stderr,
1320 "## unparsable quoted name in autoload in %s\n",
1321 filename);
1322 continue;
1323 }
1324 }
1325 skip_white (infile);
1326 if ((c = getc (infile)) != '\"')
1327 {
1328 fprintf (stderr, "## autoload of %s unparsable (%s)\n",
1329 buffer, filename);
1330 continue;
1331 }
1332 read_c_string_or_comment (infile, 0, 0, 0);
1333 skip_white (infile);
1334
1335 if (saved_string == 0)
1336 {
1337 /* If the next three characters aren't `dquote bslash newline'
1338 then we're not reading a docstring. */
1339 if ((c = getc (infile)) != '"'
1340 || (c = getc (infile)) != '\\'
1341 || ((c = getc (infile)) != '\n' && c != '\r'))
1342 {
1343 #ifdef DEBUG
1344 fprintf (stderr, "## non-docstring in %s (%s)\n",
1345 buffer, filename);
1346 #endif
1347 continue;
1348 }
1349 }
1350 }
1351
1352 #ifdef DEBUG
1353 else if (! strcmp (buffer, "if")
1354 || ! strcmp (buffer, "byte-code"))
1355 ;
1356 #endif
1357
1358 else
1359 {
1360 #ifdef DEBUG
1361 fprintf (stderr, "## unrecognized top-level form, %s (%s)\n",
1362 buffer, filename);
1363 #endif
1364 continue;
1365 }
1366
1367 /* At this point, we should either use the previous
1368 dynamic doc string in saved_string
1369 or gobble a doc string from the input file.
1370
1371 In the latter case, the opening quote (and leading
1372 backslash-newline) have already been read. */
1373
1374 putc (037, outfile);
1375 putc (type, outfile);
1376 fprintf (outfile, "%s\n", buffer);
1377 if (saved_string)
1378 {
1379 fputs (saved_string, outfile);
1380 /* Don't use one dynamic doc string twice. */
1381 free (saved_string);
1382 saved_string = 0;
1383 }
1384 else
1385 read_c_string_or_comment (infile, 1, 0, 0);
1386 }
1387 fclose (infile);
1388 return 0;
1389 }
1390
1391
1392 /* make-docfile.c ends here */