1/* makedoc.c -- Make doc.c and funs.h from input files.
2   $Id: makedoc.c,v 1.1 2004/10/28 18:14:09 zooey Exp $
3
4   This file is part of GNU Info, a program for reading online documentation
5   stored in Info format.
6
7   Copyright (C) 1993, 97 Free Software Foundation, Inc.
8
9   This program is free software; you can redistribute it and/or modify
10   it under the terms of the GNU General Public License as published by
11   the Free Software Foundation; either version 2, or (at your option)
12   any later version.
13
14   This program is distributed in the hope that it will be useful,
15   but WITHOUT ANY WARRANTY; without even the implied warranty of
16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17   GNU General Public License for more details.
18
19   You should have received a copy of the GNU General Public License
20   along with this program; if not, write to the Free Software
21   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22
23   Written by Brian Fox (bfox@ai.mit.edu). */
24
25/* This program grovels the contents of the source files passed as arguments
26   and writes out a file of function pointers and documentation strings, and
27   a header file which describes the contents.  This only does the functions
28   declared with DECLARE_INFO_COMMAND. */
29
30#include "info.h"
31
32static void fatal_file_error ();
33
34/* Name of the header file which receives the declarations of functions. */
35static char *funs_filename = "funs.h";
36
37/* Name of the documentation to function pointer file. */
38static char *doc_filename = "doc.c";
39
40static char *doc_header[] = {
41  "/* doc.c -- Generated structure containing function names and doc strings.",
42  "",
43  "   This file was automatically made from various source files with the",
44  "   command \"%s\".  DO NOT EDIT THIS FILE, only \"%s.c\".",
45  (char *)NULL
46};
47
48static char *doc_header_1[] = {
49  "   An entry in the array FUNCTION_DOC_ARRAY is made for each command",
50  "   found in the above files; each entry consists of a function pointer,",
51#if defined (NAMED_FUNCTIONS)
52  "   a string which is the user-visible name of the function,",
53#endif /* NAMED_FUNCTIONS */
54  "   and a string which documents its purpose. */",
55  "",
56  "#include \"doc.h\"",
57  "#include \"funs.h\"",
58  "",
59  "FUNCTION_DOC function_doc_array[] = {",
60  "",
61  (char *)NULL
62};
63
64/* How to remember the locations of the functions found so that Emacs
65   can use the information in a tag table. */
66typedef struct {
67  char *name;                   /* Name of the tag. */
68  int line;                     /* Line number at which it appears. */
69  long char_offset;             /* Character offset at which it appears. */
70} EMACS_TAG;
71
72typedef struct {
73  char *filename;               /* Name of the file containing entries. */
74  long entrylen;                /* Total number of characters in tag block. */
75  EMACS_TAG **entries;          /* Entries found in FILENAME. */
76  int entries_index;
77  int entries_slots;
78} EMACS_TAG_BLOCK;
79
80EMACS_TAG_BLOCK **emacs_tags = (EMACS_TAG_BLOCK **)NULL;
81int emacs_tags_index = 0;
82int emacs_tags_slots = 0;
83
84#define DECLARATION_STRING "\nDECLARE_INFO_COMMAND"
85
86static void process_one_file ();
87static void maybe_dump_tags ();
88static FILE *must_fopen ();
89
90int
91main (argc, argv)
92     int argc;
93     char **argv;
94{
95  register int i;
96  int tags_only = 0;
97  FILE *funs_stream, *doc_stream;
98
99  for (i = 1; i < argc; i++)
100    if (strcmp (argv[i], "-tags") == 0)
101      {
102        tags_only++;
103        break;
104      }
105
106  if (tags_only)
107    {
108      funs_filename = "/dev/null";
109      doc_filename = "/dev/null";
110    }
111
112  funs_stream = must_fopen (funs_filename, "w");
113  doc_stream = must_fopen (doc_filename, "w");
114
115  fprintf (funs_stream,
116           "/* %s -- Generated declarations for Info commands. */\n",
117           funs_filename);
118
119  for (i = 0; doc_header[i]; i++)
120    {
121      fprintf (doc_stream, doc_header[i], argv[0], argv[0]);
122      fprintf (doc_stream, "\n");
123    }
124
125  fprintf (doc_stream,
126           _("   Source files groveled to make this file include:\n\n"));
127
128  for (i = 1; i < argc; i++)
129    fprintf (doc_stream, "\t%s\n", argv[i]);
130
131  fprintf (doc_stream, "\n");
132
133  for (i = 0; doc_header_1[i]; i++)
134    fprintf (doc_stream, "%s\n", doc_header_1[i]);
135
136
137  for (i = 1; i < argc; i++)
138    {
139      char *curfile;
140      curfile = argv[i];
141
142      if (*curfile == '-')
143        continue;
144
145      fprintf (doc_stream, "/* Commands found in \"%s\". */\n", curfile);
146      fprintf (funs_stream, "\n/* Functions declared in \"%s\". */\n",
147               curfile);
148
149      process_one_file (curfile, doc_stream, funs_stream);
150    }
151
152  fprintf (doc_stream,
153           "   { (VFunction *)NULL, (char *)NULL, (char *)NULL }\n};\n");
154
155  fclose (funs_stream);
156  fclose (doc_stream);
157
158  if (tags_only)
159    maybe_dump_tags (stdout);
160  exit (0);
161}
162
163/* Dumping out the contents of an Emacs tags table. */
164static void
165maybe_dump_tags (stream)
166     FILE *stream;
167{
168  register int i;
169
170  /* Print out the information for each block. */
171  for (i = 0; i < emacs_tags_index; i++)
172    {
173      register int j;
174      register EMACS_TAG_BLOCK *block;
175      register EMACS_TAG *etag;
176      long block_len;
177
178      block_len = 0;
179      block = emacs_tags[i];
180
181      /* Calculate the length of the dumped block first. */
182      for (j = 0; j < block->entries_index; j++)
183        {
184          char digits[30];
185          etag = block->entries[j];
186          block_len += 3 + strlen (etag->name);
187          sprintf (digits, "%d,%ld", etag->line, etag->char_offset);
188          block_len += strlen (digits);
189        }
190
191      /* Print out the defining line. */
192      fprintf (stream, "\f\n%s,%ld\n", block->filename, block_len);
193
194      /* Print out the individual tags. */
195      for (j = 0; j < block->entries_index; j++)
196        {
197          etag = block->entries[j];
198
199          fprintf (stream, "%s,\177%d,%ld\n",
200                   etag->name, etag->line, etag->char_offset);
201        }
202    }
203}
204
205/* Keeping track of names, line numbers and character offsets of functions
206   found in source files. */
207static EMACS_TAG_BLOCK *
208make_emacs_tag_block (filename)
209     char *filename;
210{
211  EMACS_TAG_BLOCK *block;
212
213  block = (EMACS_TAG_BLOCK *)xmalloc (sizeof (EMACS_TAG_BLOCK));
214  block->filename = xstrdup (filename);
215  block->entrylen = 0;
216  block->entries = (EMACS_TAG **)NULL;
217  block->entries_index = 0;
218  block->entries_slots = 0;
219  return (block);
220}
221
222static void
223add_tag_to_block (block, name, line, char_offset)
224     EMACS_TAG_BLOCK *block;
225     char *name;
226     int line;
227     long char_offset;
228{
229  EMACS_TAG *tag;
230
231  tag = (EMACS_TAG *)xmalloc (sizeof (EMACS_TAG));
232  tag->name = name;
233  tag->line = line;
234  tag->char_offset = char_offset;
235  add_pointer_to_array (tag, block->entries_index, block->entries,
236                        block->entries_slots, 50, EMACS_TAG *);
237}
238
239/* Read the file represented by FILENAME into core, and search it for Info
240   function declarations.  Output the declarations in various forms to the
241   DOC_STREAM and FUNS_STREAM. */
242static void
243process_one_file (filename, doc_stream, funs_stream)
244     char *filename;
245     FILE *doc_stream, *funs_stream;
246{
247  int descriptor, decl_len;
248  char *buffer, *decl_str;
249  struct stat finfo;
250  long offset;
251  long file_size;
252  EMACS_TAG_BLOCK *block;
253
254  if (stat (filename, &finfo) == -1)
255    fatal_file_error (filename);
256
257  descriptor = open (filename, O_RDONLY, 0666);
258
259  if (descriptor == -1)
260    fatal_file_error (filename);
261
262  file_size = (long) finfo.st_size;
263  buffer = (char *)xmalloc (1 + file_size);
264  read (descriptor, buffer, file_size);
265  close (descriptor);
266
267  offset = 0;
268  decl_str = DECLARATION_STRING;
269  decl_len = strlen (decl_str);
270
271  block = make_emacs_tag_block (filename);
272
273  while (1)
274    {
275      long point = 0;
276      long line_start = 0;
277      int line_number = 0;
278
279      char *func, *doc;
280#if defined (NAMED_FUNCTIONS)
281      char *func_name;
282#endif /* NAMED_FUNCTIONS */
283
284      for (; offset < (file_size - decl_len); offset++)
285        {
286          if (buffer[offset] == '\n')
287            {
288              line_number++;
289              line_start = offset + 1;
290            }
291
292          if (strncmp (buffer + offset, decl_str, decl_len) == 0)
293            {
294              offset += decl_len;
295              point = offset;
296              break;
297            }
298        }
299
300      if (!point)
301        break;
302
303      /* Skip forward until we find the open paren. */
304      while (point < file_size)
305        {
306          if (buffer[point] == '\n')
307            {
308              line_number++;
309              line_start = point + 1;
310            }
311          else if (buffer[point] == '(')
312            break;
313
314          point++;
315        }
316
317      while (point++ < file_size)
318        {
319          if (!whitespace_or_newline (buffer[point]))
320            break;
321          else if (buffer[point] == '\n')
322            {
323              line_number++;
324              line_start = point + 1;
325            }
326        }
327
328      if (point >= file_size)
329        break;
330
331      /* Now looking at name of function.  Get it. */
332      for (offset = point; buffer[offset] != ','; offset++);
333      func = (char *)xmalloc (1 + (offset - point));
334      strncpy (func, buffer + point, offset - point);
335      func[offset - point] = '\0';
336
337      /* Remember this tag in the current block. */
338      {
339        char *tag_name;
340
341        tag_name = (char *)xmalloc (1 + (offset - line_start));
342        strncpy (tag_name, buffer + line_start, offset - line_start);
343        tag_name[offset - line_start] = '\0';
344        add_tag_to_block (block, tag_name, line_number, point);
345      }
346
347#if defined (NAMED_FUNCTIONS)
348      /* Generate the user-visible function name from the function's name. */
349      {
350        register int i;
351        char *name_start;
352
353        name_start = func;
354
355        if (strncmp (name_start, "info_", 5) == 0)
356          name_start += 5;
357
358        func_name = xstrdup (name_start);
359
360        /* Fix up "ea" commands. */
361        if (strncmp (func_name, "ea_", 3) == 0)
362          {
363            char *temp_func_name;
364
365            temp_func_name = (char *)xmalloc (10 + strlen (func_name));
366            strcpy (temp_func_name, "echo_area_");
367            strcat (temp_func_name, func_name + 3);
368            free (func_name);
369            func_name = temp_func_name;
370          }
371
372        for (i = 0; func_name[i]; i++)
373          if (func_name[i] == '_')
374            func_name[i] = '-';
375      }
376#endif /* NAMED_FUNCTIONS */
377
378      /* Find doc string. */
379      point = offset + 1;
380
381      while (point < file_size)
382        {
383          if (buffer[point] == '\n')
384            {
385              line_number++;
386              line_start = point + 1;
387            }
388
389          if (buffer[point] == '"')
390            break;
391          else
392            point++;
393        }
394
395      offset = point + 1;
396
397      while (offset < file_size)
398        {
399          if (buffer[offset] == '\n')
400            {
401              line_number++;
402              line_start = offset + 1;
403            }
404
405          if (buffer[offset] == '\\')
406            offset += 2;
407          else if (buffer[offset] == '"')
408            break;
409          else
410            offset++;
411        }
412
413      offset++;
414      if (offset >= file_size)
415        break;
416
417      doc = (char *)xmalloc (1 + (offset - point));
418      strncpy (doc, buffer + point, offset - point);
419      doc[offset - point] = '\0';
420
421#if defined (NAMED_FUNCTIONS)
422      fprintf (doc_stream, "   { %s, \"%s\", %s },\n", func, func_name, doc);
423      free (func_name);
424#else /* !NAMED_FUNCTIONS */
425      fprintf (doc_stream, "   { %s, %s },\n", func, doc);
426#endif /* !NAMED_FUNCTIONS */
427
428      fprintf (funs_stream, "extern void %s ();\n", func);
429      free (func);
430      free (doc);
431    }
432  free (buffer);
433
434  /* If we created any tags, remember this file on our global list.  Otherwise,
435     free the memory already allocated to it. */
436  if (block->entries)
437    add_pointer_to_array (block, emacs_tags_index, emacs_tags,
438                          emacs_tags_slots, 10, EMACS_TAG_BLOCK *);
439  else
440    {
441      free (block->filename);
442      free (block);
443    }
444}
445
446static void
447fatal_file_error (filename)
448     char *filename;
449{
450  fprintf (stderr, _("Couldn't manipulate the file %s.\n"), filename);
451  exit (2);
452}
453
454static FILE *
455must_fopen (filename, mode)
456     char *filename, *mode;
457{
458  FILE *stream;
459
460  stream = fopen (filename, mode);
461  if (!stream)
462    fatal_file_error (filename);
463
464  return (stream);
465}
466
467