diff options
Diffstat (limited to 'info/makedoc.c')
| -rw-r--r-- | info/makedoc.c | 584 |
1 files changed, 584 insertions, 0 deletions
diff --git a/info/makedoc.c b/info/makedoc.c new file mode 100644 index 0000000..21fcb3b --- /dev/null +++ b/info/makedoc.c @@ -0,0 +1,584 @@ +/* makedoc.c -- make doc.c and funs.h from input files. + $Id: makedoc.c,v 1.10 2008/06/11 09:55:42 gray Exp $ + + Copyright (C) 1993, 1997, 1998, 1999, 2001, 2002, 2003, 2004, 2007, + 2008 Free Software Foundation, Inc. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + + Originally written by Brian Fox (bfox@ai.mit.edu). */ + +/* This program grovels the contents of the source files passed as arguments + and writes out a file of function pointers and documentation strings, and + a header file which describes the contents. This only does the functions + declared with DECLARE_INFO_COMMAND. */ + +#include "info.h" +#include "infokey.h" + +char *program_name = "makedoc"; + +static void fatal_file_error (char *filename); + +/* Name of the header file which receives the declarations of functions. */ +static char *funs_filename = "funs.h"; + +/* Name of the documentation to function pointer file. */ +static char *doc_filename = "doc.c"; +static char *key_filename = "key.c"; + +static char *doc_header[] = { + "/* doc.c -- Generated structure containing function names and doc strings.", + "", + " This file was automatically made from various source files with the", + " command `%s'. DO NOT EDIT THIS FILE, only `%s.c'.", + NULL +}; + +static char *doc_header_1[] = { + " An entry in the array FUNCTION_DOC_ARRAY is made for each command", + " found in the above files; each entry consists of a function pointer,", +#if defined (NAMED_FUNCTIONS) + " a string which is the user-visible name of the function,", +#endif /* NAMED_FUNCTIONS */ + " and a string which documents its purpose. */", + "", + "#include \"info.h\"", + "#include \"funs.h\"", + "", + "FUNCTION_DOC function_doc_array[] = {", + "", + NULL +}; + +static char *key_header[] = { + "/* key.c -- Generated array containing function names.", + "", + " This file was automatically made from various source files with the", + " command \"%s\". DO NOT EDIT THIS FILE, only \"%s.c\".", + "", + NULL +}; + +static char *key_header_1[] = { + " An entry in the array FUNCTION_KEY_ARRAY is made for each command", + " found in the above files; each entry consists of", + " a string which is the user-visible name of the function. */", + "", + "#include \"key.h\"", + "#include \"funs.h\"", + "", + "FUNCTION_KEY function_key_array[] = {", + "", + NULL +}; + +/* How to remember the locations of the functions found so that Emacs + can use the information in a tag table. */ +typedef struct { + char *name; /* Name of the tag. */ + int line; /* Line number at which it appears. */ + long char_offset; /* Character offset at which it appears. */ +} EMACS_TAG; + +typedef struct { + char *filename; /* Name of the file containing entries. */ + long entrylen; /* Total number of characters in tag block. */ + EMACS_TAG **entries; /* Entries found in FILENAME. */ + int entries_index; + int entries_slots; +} EMACS_TAG_BLOCK; + +EMACS_TAG_BLOCK **emacs_tags = NULL; +int emacs_tags_index = 0; +int emacs_tags_slots = 0; + +#define DECLARATION_STRING "\nDECLARE_INFO_COMMAND" + +static void process_one_file (char *filename, FILE *doc_stream, + FILE *key_stream, FILE *funs_stream); +static void maybe_dump_tags (FILE *stream); +static FILE *must_fopen (char *filename, char *mode); +static void init_func_key (unsigned int val); +static unsigned int next_func_key (void); + +int +main (int argc, char **argv) +{ + register int i; + int tags_only = 0; + FILE *funs_stream, *doc_stream; + FILE *key_stream; + +#if STRIP_DOT_EXE + { + char *dot = strrchr (argv[0], '.'); + + if (dot && FILENAME_CMP (dot, ".exe") == 0) + *dot = 0; + } +#endif + + for (i = 1; i < argc; i++) + if (strcmp (argv[i], "-tags") == 0) + { + tags_only++; + break; + } + + if (tags_only) + { + funs_filename = NULL_DEVICE; + doc_filename = NULL_DEVICE; + key_filename = NULL_DEVICE; + } + + /* The order of these calls depends exactly on the order in the + Makefile.{in,am}, or they might fail on filesystems with + high-precision times; see also the fclose calls below. */ + funs_stream = must_fopen (funs_filename, "w"); + key_stream = must_fopen (key_filename, "w"); + doc_stream = must_fopen (doc_filename, "w"); + + fprintf (funs_stream, + "/* %s -- Generated declarations for Info commands. */\n\n\ +#include \"info.h\"\n", + funs_filename); + + for (i = 0; doc_header[i]; i++) + { + fprintf (doc_stream, doc_header[i], argv[0], argv[0]); + fprintf (doc_stream, "\n"); + } + + fprintf (doc_stream, + _(" Source files groveled to make this file include:\n\n")); + + for (i = 0; key_header[i]; i++) + { + fprintf (key_stream, key_header[i], argv[0], argv[0]); + fprintf (key_stream, "\n"); + } + fprintf (key_stream, + _(" Source files groveled to make this file include:\n\n")); + + for (i = 1; i < argc; i++) + { + fprintf (doc_stream, "\t%s\n", argv[i]); + fprintf (key_stream, "\t%s\n", argv[i]); + } + + fprintf (doc_stream, "\n"); + for (i = 0; doc_header_1[i]; i++) + fprintf (doc_stream, "%s\n", doc_header_1[i]); + + fprintf (key_stream, "\n"); + for (i = 0; key_header_1[i]; i++) + fprintf (key_stream, "%s\n", key_header_1[i]); + + init_func_key(0); + + for (i = 1; i < argc; i++) + { + char *curfile; + curfile = argv[i]; + + if (*curfile == '-') + continue; + + fprintf (doc_stream, "/* Commands found in \"%s\". */\n", curfile); + fprintf (key_stream, "/* Commands found in \"%s\". */\n", curfile); + fprintf (funs_stream, "\n/* Functions declared in \"%s\". */\n", + curfile); + + process_one_file (curfile, doc_stream, key_stream, funs_stream); + } + +#if defined (INFOKEY) + +#if defined (NAMED_FUNCTIONS) + fprintf (doc_stream, + " { NULL, NULL, NULL, NULL }\n};\n"); +#else /* !NAMED_FUNCTIONS */ + fprintf (doc_stream, " { NULL, NULL, NULL }\n};\n"); +#endif /* !NAMED_FUNCTIONS */ + +#else /* !INFOKEY */ + +#if defined (NAMED_FUNCTIONS) + fprintf (doc_stream, + " { NULL, NULL, NULL }\n};\n"); +#else /* !NAMED_FUNCTIONS */ + fprintf (doc_stream, " { NULL, NULL }\n};\n"); +#endif /* !NAMED_FUNCTIONS */ + +#endif /* !INFOKEY */ + + fprintf (key_stream, " { NULL, 0 }\n};\n"); + fprintf (funs_stream, "\n#define A_NCOMMANDS %u\n", next_func_key()); + + /* The order of these calls also depends exactly on the order in the + * Makefile.{in,am}; see the must_fopen calls above. */ + fclose (funs_stream); + fclose (key_stream); + fclose (doc_stream); + + if (tags_only) + maybe_dump_tags (stdout); + return 0; +} + +/* Dumping out the contents of an Emacs tags table. */ +static void +maybe_dump_tags (FILE *stream) +{ + register int i; + + /* Emacs needs its TAGS file to be in Unix text format (i.e., only + newline at end of every line, no CR), so when we generate a + TAGS table, we must switch the output stream to binary mode. + (If the table is written to a terminal, this is obviously not needed.) */ + SET_BINARY (fileno (stream)); + + /* Print out the information for each block. */ + for (i = 0; i < emacs_tags_index; i++) + { + register int j; + register EMACS_TAG_BLOCK *block; + register EMACS_TAG *etag; + long block_len; + + block_len = 0; + block = emacs_tags[i]; + + /* Calculate the length of the dumped block first. */ + for (j = 0; j < block->entries_index; j++) + { + char digits[30]; + etag = block->entries[j]; + block_len += 3 + strlen (etag->name); + sprintf (digits, "%d,%ld", etag->line, etag->char_offset); + block_len += strlen (digits); + } + + /* Print out the defining line. */ + fprintf (stream, "\f\n%s,%ld\n", block->filename, block_len); + + /* Print out the individual tags. */ + for (j = 0; j < block->entries_index; j++) + { + etag = block->entries[j]; + + fprintf (stream, "%s,\177%d,%ld\n", + etag->name, etag->line, etag->char_offset); + } + } +} + +/* Keeping track of names, line numbers and character offsets of functions + found in source files. */ +static EMACS_TAG_BLOCK * +make_emacs_tag_block (char *filename) +{ + EMACS_TAG_BLOCK *block; + + block = xmalloc (sizeof (EMACS_TAG_BLOCK)); + block->filename = xstrdup (filename); + block->entrylen = 0; + block->entries = NULL; + block->entries_index = 0; + block->entries_slots = 0; + return block; +} + +static void +add_tag_to_block (EMACS_TAG_BLOCK *block, + char *name, int line, long int char_offset) +{ + EMACS_TAG *tag; + + tag = xmalloc (sizeof (EMACS_TAG)); + tag->name = name; + tag->line = line; + tag->char_offset = char_offset; + add_pointer_to_array (tag, block->entries_index, block->entries, + block->entries_slots, 50, EMACS_TAG *); +} + +/* Read the file represented by FILENAME into core, and search it for Info + function declarations. Output the declarations in various forms to the + DOC_STREAM, KEY_STREAM, and FUNS_STREAM. */ +static void +process_one_file (char *filename, FILE *doc_stream, + FILE *key_stream, FILE *funs_stream) +{ + int descriptor, decl_len; + char *buffer, *decl_str; + struct stat finfo; + long offset; + long file_size; + EMACS_TAG_BLOCK *block; + + if (stat (filename, &finfo) == -1) + fatal_file_error (filename); + + descriptor = open (filename, O_RDONLY, 0666); + + if (descriptor == -1) + fatal_file_error (filename); + + file_size = (long) finfo.st_size; + buffer = xmalloc (1 + file_size); + /* On some systems, the buffer will actually contain + less characters than the full file's size, because + the CR characters are removed from line endings. */ + file_size = read (descriptor, buffer, file_size); + close (descriptor); + + offset = 0; + decl_str = DECLARATION_STRING; + decl_len = strlen (decl_str); + + block = make_emacs_tag_block (filename); + + while (1) + { + long point = 0; + long line_start = 0; + int line_number = 0; + + char *func, *doc; +#if defined (INFOKEY) || defined (NAMED_FUNCTIONS) + char *func_name; +#endif /* INFOKEY || NAMED_FUNCTIONS */ + + for (; offset < (file_size - decl_len); offset++) + { + if (buffer[offset] == '\n') + { + line_number++; + line_start = offset + 1; + } + + if (strncmp (buffer + offset, decl_str, decl_len) == 0) + { + offset += decl_len; + point = offset; + break; + } + } + + if (!point) + break; + + /* Skip forward until we find the open paren. */ + while (point < file_size) + { + if (buffer[point] == '\n') + { + line_number++; + line_start = point + 1; + } + else if (buffer[point] == '(') + break; + + point++; + } + + while (point++ < file_size) + { + if (!whitespace_or_newline (buffer[point])) + break; + else if (buffer[point] == '\n') + { + line_number++; + line_start = point + 1; + } + } + + if (point >= file_size) + break; + + /* Now looking at name of function. Get it. */ + for (offset = point; buffer[offset] != ','; offset++); + func = xmalloc (1 + (offset - point)); + strncpy (func, buffer + point, offset - point); + func[offset - point] = '\0'; + + /* Remember this tag in the current block. */ + { + char *tag_name; + + tag_name = xmalloc (1 + (offset - line_start)); + strncpy (tag_name, buffer + line_start, offset - line_start); + tag_name[offset - line_start] = '\0'; + add_tag_to_block (block, tag_name, line_number, point); + } + +#if defined (INFOKEY) || defined (NAMED_FUNCTIONS) + /* Generate the user-visible function name from the function's name. */ + { + register int i; + char *name_start; + + name_start = func; + + if (strncmp (name_start, "info_", 5) == 0) + name_start += 5; + + func_name = xstrdup (name_start); + + /* Fix up "ea" commands. */ + if (strncmp (func_name, "ea_", 3) == 0) + { + char *temp_func_name; + + temp_func_name = xmalloc (10 + strlen (func_name)); + strcpy (temp_func_name, "echo_area_"); + strcat (temp_func_name, func_name + 3); + free (func_name); + func_name = temp_func_name; + } + + for (i = 0; func_name[i]; i++) + if (func_name[i] == '_') + func_name[i] = '-'; + } +#endif /* INFOKEY || NAMED_FUNCTIONS */ + + /* Find doc string. */ + point = offset + 1; + + while (point < file_size) + { + if (buffer[point] == '\n') + { + line_number++; + line_start = point + 1; + } + + if (buffer[point] == '"') + break; + else + point++; + } + + offset = point + 1; + + while (offset < file_size) + { + if (buffer[offset] == '\n') + { + line_number++; + line_start = offset + 1; + } + + if (buffer[offset] == '\\') + offset += 2; + else if (buffer[offset] == '"') + break; + else + offset++; + } + + offset++; + if (offset >= file_size) + break; + + doc = xmalloc (1 + (offset - point)); + strncpy (doc, buffer + point, offset - point); + doc[offset - point] = '\0'; + +#if defined (INFOKEY) + +#if defined (NAMED_FUNCTIONS) + fprintf (doc_stream, + " { (VFunction *)%s, \"%s\", (FUNCTION_KEYSEQ *)0, %s },\n", + func, func_name, doc); +#else /* !NAMED_FUNCTIONS */ + fprintf (doc_stream, + " { (VFunction *) %s, (FUNCTION_KEYSEQ *)0, %s },\n", func, doc); +#endif /* !NAMED_FUNCTIONS */ + + fprintf (key_stream, " { \"%s\", A_%s },\n", func_name, func); + +#else /* !INFOKEY */ + +#if defined (NAMED_FUNCTIONS) + fprintf (doc_stream, " { %s, \"%s\", %s },\n", func, func_name, doc); +#else /* !NAMED_FUNCTIONS */ + fprintf (doc_stream, " { %s, %s },\n", func, doc); +#endif /* !NAMED_FUNCTIONS */ + +#endif /* !INFOKEY */ + +#if defined (INFOKEY) || defined (NAMED_FUNCTIONS) + free (func_name); +#endif /* INFOKEY || NAMED_FUNCTIONS */ + +#if defined (INFOKEY) + fprintf (funs_stream, "#define A_%s %u\n", func, next_func_key()); +#endif /* INFOKEY */ + fprintf (funs_stream, + "extern void %s (WINDOW *window, int count, unsigned char key);\n", + func); + free (func); + free (doc); + } + free (buffer); + + /* If we created any tags, remember this file on our global list. Otherwise, + free the memory already allocated to it. */ + if (block->entries) + add_pointer_to_array (block, emacs_tags_index, emacs_tags, + emacs_tags_slots, 10, EMACS_TAG_BLOCK *); + else + { + free (block->filename); + free (block); + } +} + +static void +fatal_file_error (char *filename) +{ + fprintf (stderr, _("Couldn't manipulate the file %s.\n"), filename); + xexit (2); +} + +static FILE * +must_fopen (char *filename, char *mode) +{ + FILE *stream; + + stream = fopen (filename, mode); + if (!stream) + fatal_file_error (filename); + + return stream; +} + +static unsigned int func_key; + +static void +init_func_key(unsigned int val) +{ + func_key = val; +} + +static unsigned int +next_func_key(void) +{ + return func_key++; +} |