| File: | src/gnu/usr.bin/texinfo/info/makedoc.c |
| Warning: | line 462, column 15 Value stored to 'line_start' is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
| 1 | /* makedoc.c -- make doc.c and funs.h from input files. |
| 2 | $Id: makedoc.c,v 1.5 2006/07/17 16:12:36 espie Exp $ |
| 3 | |
| 4 | Copyright (C) 1993, 1997, 1998, 1999, 2001, 2002, 2003, 2004 Free Software |
| 5 | Foundation, Inc. |
| 6 | |
| 7 | This program 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 2, or (at your option) |
| 10 | any later version. |
| 11 | |
| 12 | This program 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 this program; if not, write to the Free Software |
| 19 | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
| 20 | |
| 21 | Originally written by Brian Fox (bfox@ai.mit.edu). */ |
| 22 | |
| 23 | /* This program grovels the contents of the source files passed as arguments |
| 24 | and writes out a file of function pointers and documentation strings, and |
| 25 | a header file which describes the contents. This only does the functions |
| 26 | declared with DECLARE_INFO_COMMAND. */ |
| 27 | |
| 28 | #include "info.h" |
| 29 | #include "infokey.h" |
| 30 | |
| 31 | static void fatal_file_error (char *filename); |
| 32 | |
| 33 | /* Name of the header file which receives the declarations of functions. */ |
| 34 | static char *funs_filename = "funs.h"; |
| 35 | |
| 36 | /* Name of the documentation to function pointer file. */ |
| 37 | static char *doc_filename = "doc.c"; |
| 38 | static char *key_filename = "key.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((void *)0) |
| 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 \"info.h\"", |
| 57 | "#include \"funs.h\"", |
| 58 | "", |
| 59 | "FUNCTION_DOC function_doc_array[] = {", |
| 60 | "", |
| 61 | (char *)NULL((void *)0) |
| 62 | }; |
| 63 | |
| 64 | static char *key_header[] = { |
| 65 | "/* key.c -- Generated array containing function names.", |
| 66 | "", |
| 67 | " This file was automatically made from various source files with the", |
| 68 | " command \"%s\". DO NOT EDIT THIS FILE, only \"%s.c\".", |
| 69 | "", |
| 70 | (char *)NULL((void *)0) |
| 71 | }; |
| 72 | |
| 73 | static char *key_header_1[] = { |
| 74 | " An entry in the array FUNCTION_KEY_ARRAY is made for each command", |
| 75 | " found in the above files; each entry consists of", |
| 76 | " a string which is the user-visible name of the function. */", |
| 77 | "", |
| 78 | "#include \"key.h\"", |
| 79 | "#include \"funs.h\"", |
| 80 | "", |
| 81 | "FUNCTION_KEY function_key_array[] = {", |
| 82 | "", |
| 83 | (char *)NULL((void *)0) |
| 84 | }; |
| 85 | |
| 86 | /* How to remember the locations of the functions found so that Emacs |
| 87 | can use the information in a tag table. */ |
| 88 | typedef struct { |
| 89 | char *name; /* Name of the tag. */ |
| 90 | int line; /* Line number at which it appears. */ |
| 91 | long char_offset; /* Character offset at which it appears. */ |
| 92 | } EMACS_TAG; |
| 93 | |
| 94 | typedef struct { |
| 95 | char *filename; /* Name of the file containing entries. */ |
| 96 | long entrylen; /* Total number of characters in tag block. */ |
| 97 | EMACS_TAG **entries; /* Entries found in FILENAME. */ |
| 98 | int entries_index; |
| 99 | int entries_slots; |
| 100 | } EMACS_TAG_BLOCK; |
| 101 | |
| 102 | EMACS_TAG_BLOCK **emacs_tags = (EMACS_TAG_BLOCK **)NULL((void *)0); |
| 103 | int emacs_tags_index = 0; |
| 104 | int emacs_tags_slots = 0; |
| 105 | |
| 106 | #define DECLARATION_STRING"\nDECLARE_INFO_COMMAND" "\nDECLARE_INFO_COMMAND" |
| 107 | |
| 108 | static void process_one_file (char *filename, FILE *doc_stream, |
| 109 | FILE *key_stream, FILE *funs_stream); |
| 110 | static void maybe_dump_tags (FILE *stream); |
| 111 | static FILE *must_fopen (char *filename, char *mode); |
| 112 | static void init_func_key (unsigned int val); |
| 113 | static unsigned int next_func_key (void); |
| 114 | |
| 115 | int |
| 116 | main (int argc, char **argv) |
| 117 | { |
| 118 | register int i; |
| 119 | int tags_only = 0; |
| 120 | FILE *funs_stream, *doc_stream; |
| 121 | FILE *key_stream; |
| 122 | |
| 123 | #if STRIP_DOT_EXE0 |
| 124 | { |
| 125 | char *dot = strrchr (argv[0], '.'); |
| 126 | |
| 127 | if (dot && FILENAME_CMPstrcmp (dot, ".exe") == 0) |
| 128 | *dot = 0; |
| 129 | } |
| 130 | #endif |
| 131 | |
| 132 | for (i = 1; i < argc; i++) |
| 133 | if (strcmp (argv[i], "-tags") == 0) |
| 134 | { |
| 135 | tags_only++; |
| 136 | break; |
| 137 | } |
| 138 | |
| 139 | if (tags_only) |
| 140 | { |
| 141 | funs_filename = NULL_DEVICE"/dev/null"; |
| 142 | doc_filename = NULL_DEVICE"/dev/null"; |
| 143 | key_filename = NULL_DEVICE"/dev/null"; |
| 144 | } |
| 145 | |
| 146 | funs_stream = must_fopen (funs_filename, "w"); |
| 147 | doc_stream = must_fopen (doc_filename, "w"); |
| 148 | key_stream = must_fopen (key_filename, "w"); |
| 149 | |
| 150 | fprintf (funs_stream, |
| 151 | "/* %s -- Generated declarations for Info commands. */\n\n\ |
| 152 | #include \"info.h\"\n", |
| 153 | funs_filename); |
| 154 | |
| 155 | for (i = 0; doc_header[i]; i++) |
| 156 | { |
| 157 | fprintf (doc_stream, doc_header[i], argv[0], argv[0]); |
| 158 | fprintf (doc_stream, "\n"); |
| 159 | } |
| 160 | |
| 161 | fprintf (doc_stream, |
| 162 | _(" Source files groveled to make this file include:\n\n")((const char *) (" Source files groveled to make this file include:\n\n" ))); |
| 163 | |
| 164 | for (i = 0; key_header[i]; i++) |
| 165 | { |
| 166 | fprintf (key_stream, key_header[i], argv[0], argv[0]); |
| 167 | fprintf (key_stream, "\n"); |
| 168 | } |
| 169 | fprintf (key_stream, |
| 170 | _(" Source files groveled to make this file include:\n\n")((const char *) (" Source files groveled to make this file include:\n\n" ))); |
| 171 | |
| 172 | for (i = 1; i < argc; i++) |
| 173 | { |
| 174 | fprintf (doc_stream, "\t%s\n", argv[i]); |
| 175 | fprintf (key_stream, "\t%s\n", argv[i]); |
| 176 | } |
| 177 | |
| 178 | fprintf (doc_stream, "\n"); |
| 179 | for (i = 0; doc_header_1[i]; i++) |
| 180 | fprintf (doc_stream, "%s\n", doc_header_1[i]); |
| 181 | |
| 182 | fprintf (key_stream, "\n"); |
| 183 | for (i = 0; key_header_1[i]; i++) |
| 184 | fprintf (key_stream, "%s\n", key_header_1[i]); |
| 185 | |
| 186 | init_func_key(0); |
| 187 | |
| 188 | for (i = 1; i < argc; i++) |
| 189 | { |
| 190 | char *curfile; |
| 191 | curfile = argv[i]; |
| 192 | |
| 193 | if (*curfile == '-') |
| 194 | continue; |
| 195 | |
| 196 | fprintf (doc_stream, "/* Commands found in \"%s\". */\n", curfile); |
| 197 | fprintf (key_stream, "/* Commands found in \"%s\". */\n", curfile); |
| 198 | fprintf (funs_stream, "\n/* Functions declared in \"%s\". */\n", |
| 199 | curfile); |
| 200 | |
| 201 | process_one_file (curfile, doc_stream, key_stream, funs_stream); |
| 202 | } |
| 203 | |
| 204 | #if defined (INFOKEY) |
| 205 | |
| 206 | #if defined (NAMED_FUNCTIONS) |
| 207 | fprintf (doc_stream, |
| 208 | " { (VFunction *)NULL, (char *)NULL, (FUNCTION_KEYSEQ *)NULL, (char *)NULL }\n};\n"); |
| 209 | #else /* !NAMED_FUNCTIONS */ |
| 210 | fprintf (doc_stream, " { (VFunction *)NULL, (FUNCTION_KEYSEQ *)NULL, (char *)NULL }\n};\n"); |
| 211 | #endif /* !NAMED_FUNCTIONS */ |
| 212 | |
| 213 | #else /* !INFOKEY */ |
| 214 | |
| 215 | #if defined (NAMED_FUNCTIONS) |
| 216 | fprintf (doc_stream, |
| 217 | " { (VFunction *)NULL, (char *)NULL, (char *)NULL }\n};\n"); |
| 218 | #else /* !NAMED_FUNCTIONS */ |
| 219 | fprintf (doc_stream, " { (VFunction *)NULL, (char *)NULL }\n};\n"); |
| 220 | #endif /* !NAMED_FUNCTIONS */ |
| 221 | |
| 222 | #endif /* !INFOKEY */ |
| 223 | |
| 224 | fprintf (key_stream, " { (char *)NULL, 0 }\n};\n"); |
| 225 | fprintf (funs_stream, "\n#define A_NCOMMANDS %u\n", next_func_key()); |
| 226 | |
| 227 | fclose (funs_stream); |
| 228 | fclose (doc_stream); |
| 229 | fclose (key_stream); |
| 230 | |
| 231 | if (tags_only) |
| 232 | maybe_dump_tags (stdout(&__sF[1])); |
| 233 | return 0; |
| 234 | } |
| 235 | |
| 236 | /* Dumping out the contents of an Emacs tags table. */ |
| 237 | static void |
| 238 | maybe_dump_tags (FILE *stream) |
| 239 | { |
| 240 | register int i; |
| 241 | |
| 242 | /* Emacs needs its TAGS file to be in Unix text format (i.e., only |
| 243 | newline at end of every line, no CR), so when we generate a |
| 244 | TAGS table, we must switch the output stream to binary mode. |
| 245 | (If the table is written to a terminal, this is obviously not needed.) */ |
| 246 | SET_BINARY (fileno (stream))(void)0; |
| 247 | |
| 248 | /* Print out the information for each block. */ |
| 249 | for (i = 0; i < emacs_tags_index; i++) |
| 250 | { |
| 251 | register int j; |
| 252 | register EMACS_TAG_BLOCK *block; |
| 253 | register EMACS_TAG *etag; |
| 254 | long block_len; |
| 255 | |
| 256 | block_len = 0; |
| 257 | block = emacs_tags[i]; |
| 258 | |
| 259 | /* Calculate the length of the dumped block first. */ |
| 260 | for (j = 0; j < block->entries_index; j++) |
| 261 | { |
| 262 | char digits[30]; |
| 263 | etag = block->entries[j]; |
| 264 | block_len += 3 + strlen (etag->name); |
| 265 | sprintf (digits, "%d,%ld", etag->line, etag->char_offset); |
| 266 | block_len += strlen (digits); |
| 267 | } |
| 268 | |
| 269 | /* Print out the defining line. */ |
| 270 | fprintf (stream, "\f\n%s,%ld\n", block->filename, block_len); |
| 271 | |
| 272 | /* Print out the individual tags. */ |
| 273 | for (j = 0; j < block->entries_index; j++) |
| 274 | { |
| 275 | etag = block->entries[j]; |
| 276 | |
| 277 | fprintf (stream, "%s,\177%d,%ld\n", |
| 278 | etag->name, etag->line, etag->char_offset); |
| 279 | } |
| 280 | } |
| 281 | } |
| 282 | |
| 283 | /* Keeping track of names, line numbers and character offsets of functions |
| 284 | found in source files. */ |
| 285 | static EMACS_TAG_BLOCK * |
| 286 | make_emacs_tag_block (char *filename) |
| 287 | { |
| 288 | EMACS_TAG_BLOCK *block; |
| 289 | |
| 290 | block = (EMACS_TAG_BLOCK *)xmalloc (sizeof (EMACS_TAG_BLOCK)); |
| 291 | block->filename = xstrdup (filename); |
| 292 | block->entrylen = 0; |
| 293 | block->entries = (EMACS_TAG **)NULL((void *)0); |
| 294 | block->entries_index = 0; |
| 295 | block->entries_slots = 0; |
| 296 | return (block); |
| 297 | } |
| 298 | |
| 299 | static void |
| 300 | add_tag_to_block (EMACS_TAG_BLOCK *block, |
| 301 | char *name, int line, long int char_offset) |
| 302 | { |
| 303 | EMACS_TAG *tag; |
| 304 | |
| 305 | tag = (EMACS_TAG *)xmalloc (sizeof (EMACS_TAG)); |
| 306 | tag->name = name; |
| 307 | tag->line = line; |
| 308 | tag->char_offset = char_offset; |
| 309 | add_pointer_to_array (tag, block->entries_index, block->entries,do { if (block->entries_index + 2 >= block->entries_slots ) block->entries = (EMACS_TAG * *)(xrealloc (block->entries , (block->entries_slots += 50) * sizeof (EMACS_TAG *))); block ->entries[block->entries_index++] = (EMACS_TAG *)tag; block ->entries[block->entries_index] = (EMACS_TAG *)((void * )0); } while (0) |
| 310 | block->entries_slots, 50, EMACS_TAG *)do { if (block->entries_index + 2 >= block->entries_slots ) block->entries = (EMACS_TAG * *)(xrealloc (block->entries , (block->entries_slots += 50) * sizeof (EMACS_TAG *))); block ->entries[block->entries_index++] = (EMACS_TAG *)tag; block ->entries[block->entries_index] = (EMACS_TAG *)((void * )0); } while (0); |
| 311 | } |
| 312 | |
| 313 | /* Read the file represented by FILENAME into core, and search it for Info |
| 314 | function declarations. Output the declarations in various forms to the |
| 315 | DOC_STREAM, KEY_STREAM, and FUNS_STREAM. */ |
| 316 | static void |
| 317 | process_one_file (char *filename, FILE *doc_stream, |
| 318 | FILE *key_stream, FILE *funs_stream) |
| 319 | { |
| 320 | int descriptor, decl_len; |
| 321 | char *buffer, *decl_str; |
| 322 | struct stat finfo; |
| 323 | long offset; |
| 324 | long file_size; |
| 325 | EMACS_TAG_BLOCK *block; |
| 326 | |
| 327 | if (stat (filename, &finfo) == -1) |
| 328 | fatal_file_error (filename); |
| 329 | |
| 330 | descriptor = open (filename, O_RDONLY0x0000, 0666); |
| 331 | |
| 332 | if (descriptor == -1) |
| 333 | fatal_file_error (filename); |
| 334 | |
| 335 | file_size = (long) finfo.st_size; |
| 336 | buffer = (char *)xmalloc (1 + file_size); |
| 337 | /* On some systems, the buffer will actually contain |
| 338 | less characters than the full file's size, because |
| 339 | the CR characters are removed from line endings. */ |
| 340 | file_size = read (descriptor, buffer, file_size); |
| 341 | close (descriptor); |
| 342 | |
| 343 | offset = 0; |
| 344 | decl_str = DECLARATION_STRING"\nDECLARE_INFO_COMMAND"; |
| 345 | decl_len = strlen (decl_str); |
| 346 | |
| 347 | block = make_emacs_tag_block (filename); |
| 348 | |
| 349 | while (1) |
| 350 | { |
| 351 | long point = 0; |
| 352 | long line_start = 0; |
| 353 | int line_number = 0; |
| 354 | |
| 355 | char *func, *doc; |
| 356 | #if defined (INFOKEY) || defined (NAMED_FUNCTIONS) |
| 357 | char *func_name; |
| 358 | #endif /* INFOKEY || NAMED_FUNCTIONS */ |
| 359 | |
| 360 | for (; offset < (file_size - decl_len); offset++) |
| 361 | { |
| 362 | if (buffer[offset] == '\n') |
| 363 | { |
| 364 | line_number++; |
| 365 | line_start = offset + 1; |
| 366 | } |
| 367 | |
| 368 | if (strncmp (buffer + offset, decl_str, decl_len) == 0) |
| 369 | { |
| 370 | offset += decl_len; |
| 371 | point = offset; |
| 372 | break; |
| 373 | } |
| 374 | } |
| 375 | |
| 376 | if (!point) |
| 377 | break; |
| 378 | |
| 379 | /* Skip forward until we find the open paren. */ |
| 380 | while (point < file_size) |
| 381 | { |
| 382 | if (buffer[point] == '\n') |
| 383 | { |
| 384 | line_number++; |
| 385 | line_start = point + 1; |
| 386 | } |
| 387 | else if (buffer[point] == '(') |
| 388 | break; |
| 389 | |
| 390 | point++; |
| 391 | } |
| 392 | |
| 393 | while (point++ < file_size) |
| 394 | { |
| 395 | if (!whitespace_or_newline (buffer[point])(((buffer[point] == ' ') || (buffer[point] == '\t')) || (buffer [point] == '\n'))) |
| 396 | break; |
| 397 | else if (buffer[point] == '\n') |
| 398 | { |
| 399 | line_number++; |
| 400 | line_start = point + 1; |
| 401 | } |
| 402 | } |
| 403 | |
| 404 | if (point >= file_size) |
| 405 | break; |
| 406 | |
| 407 | /* Now looking at name of function. Get it. */ |
| 408 | for (offset = point; buffer[offset] != ','; offset++); |
| 409 | func = (char *)xmalloc (1 + (offset - point)); |
| 410 | strncpy (func, buffer + point, offset - point); |
| 411 | func[offset - point] = '\0'; |
| 412 | |
| 413 | /* Remember this tag in the current block. */ |
| 414 | { |
| 415 | char *tag_name; |
| 416 | |
| 417 | tag_name = (char *)xmalloc (1 + (offset - line_start)); |
| 418 | strncpy (tag_name, buffer + line_start, offset - line_start); |
| 419 | tag_name[offset - line_start] = '\0'; |
| 420 | add_tag_to_block (block, tag_name, line_number, point); |
| 421 | } |
| 422 | |
| 423 | #if defined (INFOKEY) || defined (NAMED_FUNCTIONS) |
| 424 | /* Generate the user-visible function name from the function's name. */ |
| 425 | { |
| 426 | register int i; |
| 427 | char *name_start; |
| 428 | |
| 429 | name_start = func; |
| 430 | |
| 431 | if (strncmp (name_start, "info_", 5) == 0) |
| 432 | name_start += 5; |
| 433 | |
| 434 | func_name = xstrdup (name_start); |
| 435 | |
| 436 | /* Fix up "ea" commands. */ |
| 437 | if (strncmp (func_name, "ea_", 3) == 0) |
| 438 | { |
| 439 | char *temp_func_name; |
| 440 | |
| 441 | temp_func_name = (char *)xmalloc (10 + strlen (func_name)); |
| 442 | strcpy (temp_func_name, "echo_area_"); |
| 443 | strcat (temp_func_name, func_name + 3); |
| 444 | free (func_name); |
| 445 | func_name = temp_func_name; |
| 446 | } |
| 447 | |
| 448 | for (i = 0; func_name[i]; i++) |
| 449 | if (func_name[i] == '_') |
| 450 | func_name[i] = '-'; |
| 451 | } |
| 452 | #endif /* INFOKEY || NAMED_FUNCTIONS */ |
| 453 | |
| 454 | /* Find doc string. */ |
| 455 | point = offset + 1; |
| 456 | |
| 457 | while (point < file_size) |
| 458 | { |
| 459 | if (buffer[point] == '\n') |
| 460 | { |
| 461 | line_number++; |
| 462 | line_start = point + 1; |
Value stored to 'line_start' is never read | |
| 463 | } |
| 464 | |
| 465 | if (buffer[point] == '"') |
| 466 | break; |
| 467 | else |
| 468 | point++; |
| 469 | } |
| 470 | |
| 471 | offset = point + 1; |
| 472 | |
| 473 | while (offset < file_size) |
| 474 | { |
| 475 | if (buffer[offset] == '\n') |
| 476 | { |
| 477 | line_number++; |
| 478 | line_start = offset + 1; |
| 479 | } |
| 480 | |
| 481 | if (buffer[offset] == '\\') |
| 482 | offset += 2; |
| 483 | else if (buffer[offset] == '"') |
| 484 | break; |
| 485 | else |
| 486 | offset++; |
| 487 | } |
| 488 | |
| 489 | offset++; |
| 490 | if (offset >= file_size) |
| 491 | break; |
| 492 | |
| 493 | doc = (char *)xmalloc (1 + (offset - point)); |
| 494 | strncpy (doc, buffer + point, offset - point); |
| 495 | doc[offset - point] = '\0'; |
| 496 | |
| 497 | #if defined (INFOKEY) |
| 498 | |
| 499 | #if defined (NAMED_FUNCTIONS) |
| 500 | fprintf (doc_stream, |
| 501 | " { (VFunction *)%s, \"%s\", (FUNCTION_KEYSEQ *)0, %s },\n", |
| 502 | func, func_name, doc); |
| 503 | #else /* !NAMED_FUNCTIONS */ |
| 504 | fprintf (doc_stream, |
| 505 | " { (VFunction *) %s, (FUNCTION_KEYSEQ *)0, %s },\n", func, doc); |
| 506 | #endif /* !NAMED_FUNCTIONS */ |
| 507 | |
| 508 | fprintf (key_stream, " { \"%s\", A_%s },\n", func_name, func); |
| 509 | |
| 510 | #else /* !INFOKEY */ |
| 511 | |
| 512 | #if defined (NAMED_FUNCTIONS) |
| 513 | fprintf (doc_stream, " { %s, \"%s\", %s },\n", func, func_name, doc); |
| 514 | #else /* !NAMED_FUNCTIONS */ |
| 515 | fprintf (doc_stream, " { %s, %s },\n", func, doc); |
| 516 | #endif /* !NAMED_FUNCTIONS */ |
| 517 | |
| 518 | #endif /* !INFOKEY */ |
| 519 | |
| 520 | #if defined (INFOKEY) || defined (NAMED_FUNCTIONS) |
| 521 | free (func_name); |
| 522 | #endif /* INFOKEY || NAMED_FUNCTIONS */ |
| 523 | |
| 524 | #if defined (INFOKEY) |
| 525 | fprintf (funs_stream, "#define A_%s %u\n", func, next_func_key()); |
| 526 | #endif /* INFOKEY */ |
| 527 | fprintf (funs_stream, |
| 528 | "extern void %s (WINDOW *window, int count, unsigned char key);\n", |
| 529 | func); |
| 530 | free (func); |
| 531 | free (doc); |
| 532 | } |
| 533 | free (buffer); |
| 534 | |
| 535 | /* If we created any tags, remember this file on our global list. Otherwise, |
| 536 | free the memory already allocated to it. */ |
| 537 | if (block->entries) |
| 538 | add_pointer_to_array (block, emacs_tags_index, emacs_tags,do { if (emacs_tags_index + 2 >= emacs_tags_slots) emacs_tags = (EMACS_TAG_BLOCK * *)(xrealloc (emacs_tags, (emacs_tags_slots += 10) * sizeof (EMACS_TAG_BLOCK *))); emacs_tags[emacs_tags_index ++] = (EMACS_TAG_BLOCK *)block; emacs_tags[emacs_tags_index] = (EMACS_TAG_BLOCK *)((void *)0); } while (0) |
| 539 | emacs_tags_slots, 10, EMACS_TAG_BLOCK *)do { if (emacs_tags_index + 2 >= emacs_tags_slots) emacs_tags = (EMACS_TAG_BLOCK * *)(xrealloc (emacs_tags, (emacs_tags_slots += 10) * sizeof (EMACS_TAG_BLOCK *))); emacs_tags[emacs_tags_index ++] = (EMACS_TAG_BLOCK *)block; emacs_tags[emacs_tags_index] = (EMACS_TAG_BLOCK *)((void *)0); } while (0); |
| 540 | else |
| 541 | { |
| 542 | free (block->filename); |
| 543 | free (block); |
| 544 | } |
| 545 | } |
| 546 | |
| 547 | static void |
| 548 | fatal_file_error (char *filename) |
| 549 | { |
| 550 | fprintf (stderr(&__sF[2]), _("Couldn't manipulate the file %s.\n")((const char *) ("Couldn't manipulate the file %s.\n")), filename); |
| 551 | xexit (2); |
| 552 | } |
| 553 | |
| 554 | static FILE * |
| 555 | must_fopen (char *filename, char *mode) |
| 556 | { |
| 557 | FILE *stream; |
| 558 | |
| 559 | stream = fopen (filename, mode); |
| 560 | if (!stream) |
| 561 | fatal_file_error (filename); |
| 562 | |
| 563 | return (stream); |
| 564 | } |
| 565 | |
| 566 | static unsigned int func_key; |
| 567 | |
| 568 | static void |
| 569 | init_func_key(unsigned int val) |
| 570 | { |
| 571 | func_key = val; |
| 572 | } |
| 573 | |
| 574 | static unsigned int |
| 575 | next_func_key(void) |
| 576 | { |
| 577 | return func_key++; |
| 578 | } |