texinfo/info/makedoc.c

   1 /* makedoc.c -- Make doc.c and funs.h from input files.
   2    $Id: makedoc.c,v 1.1.1.2 1998/03/22 20:42:43 law 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
  32 static void fatal_file_error ();
  33
  34 /* Name of the header file which receives the declarations of functions. */
  35 static char *funs_filename = "funs.h";
  36
  37 /* Name of the documentation to function pointer file. */
  38 static char *doc_filename = "doc.c";
  39
  40 static 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
  48 static 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. */
  66 typedef 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
  72 typedef 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
  80 EMACS_TAG_BLOCK **emacs_tags = (EMACS_TAG_BLOCK **)NULL;
  81 int emacs_tags_index = 0;
  82 int emacs_tags_slots = 0;
  83
  84 #define DECLARATION_STRING "\nDECLARE_INFO_COMMAND"
  85
  86 static void process_one_file ();
  87 static void maybe_dump_tags ();
  88 static FILE *must_fopen ();
  89
  90 int
  91 main (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. */
 164 static void
 165 maybe_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. */
 207 static EMACS_TAG_BLOCK *
 208 make_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
 222 static void
 223 add_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. */
 242 static void
 243 process_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
 446 static void
 447 fatal_file_error (filename)
 448      char *filename;
 449 {
 450   fprintf (stderr, _("Couldn't manipulate the file %s.\n"), filename);
 451   exit (2);
 452 }
 453
 454 static FILE *
 455 must_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