File: | src/gnu/usr.bin/texinfo/makeinfo/node.c |
Warning: | line 986, column 11 Use of memory after it is freed |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* node.c -- nodes for Texinfo. | ||||
2 | $Id: node.c,v 1.3 2006/07/17 16:12:36 espie Exp $ | ||||
3 | |||||
4 | Copyright (C) 1998, 1999, 2000, 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 Foundation, | ||||
19 | Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ | ||||
20 | |||||
21 | #include "system.h" | ||||
22 | #include "cmds.h" | ||||
23 | #include "files.h" | ||||
24 | #include "float.h" | ||||
25 | #include "footnote.h" | ||||
26 | #include "macro.h" | ||||
27 | #include "makeinfo.h" | ||||
28 | #include "node.h" | ||||
29 | #include "html.h" | ||||
30 | #include "sectioning.h" | ||||
31 | #include "insertion.h" | ||||
32 | #include "xml.h" | ||||
33 | |||||
34 | /* See comments in node.h. */ | ||||
35 | NODE_REF *node_references = NULL((void *)0); | ||||
36 | NODE_REF *node_node_references = NULL((void *)0); | ||||
37 | TAG_ENTRY *tag_table = NULL((void *)0); | ||||
38 | int node_number = -1; | ||||
39 | int node_order = 0; | ||||
40 | int current_section = 0; | ||||
41 | int outstanding_node = 0; | ||||
42 | |||||
43 | /* Adding nodes, and making tags. */ | ||||
44 | |||||
45 | /* Start a new tag table. */ | ||||
46 | void | ||||
47 | init_tag_table (void) | ||||
48 | { | ||||
49 | while (tag_table) | ||||
50 | { | ||||
51 | TAG_ENTRY *temp = tag_table; | ||||
52 | free (temp->node); | ||||
53 | free (temp->prev); | ||||
54 | free (temp->next); | ||||
55 | free (temp->up); | ||||
56 | tag_table = tag_table->next_ent; | ||||
57 | free (temp); | ||||
58 | } | ||||
59 | } | ||||
60 | |||||
61 | /* Write out the contents of the existing tag table. | ||||
62 | INDIRECT_P says how to format the output (it depends on whether the | ||||
63 | table is direct or indirect). */ | ||||
64 | static void | ||||
65 | write_tag_table_internal (int indirect_p) | ||||
66 | { | ||||
67 | TAG_ENTRY *node; | ||||
68 | int old_indent = no_indent; | ||||
69 | |||||
70 | if (xml) | ||||
71 | { | ||||
72 | flush_output (); | ||||
73 | return; | ||||
74 | } | ||||
75 | |||||
76 | no_indent = 1; | ||||
77 | filling_enabled = 0; | ||||
78 | must_start_paragraph = 0; | ||||
79 | close_paragraph (); | ||||
80 | |||||
81 | if (!indirect_p) | ||||
82 | { | ||||
83 | no_indent = 1; | ||||
84 | insert ('\n'); | ||||
85 | } | ||||
86 | |||||
87 | add_word_args ("\037\nTag Table:\n%s", indirect_p ? "(Indirect)\n" : ""); | ||||
88 | |||||
89 | /* Do not collapse -- to -, etc., in node names. */ | ||||
90 | in_fixed_width_font++; | ||||
91 | |||||
92 | for (node = tag_table; node; node = node->next_ent) | ||||
93 | { | ||||
94 | if (node->flags & TAG_FLAG_ANCHOR32) | ||||
95 | { /* This reference is to an anchor. */ | ||||
96 | execute_string ("Ref: %s", node->node); | ||||
97 | } | ||||
98 | else | ||||
99 | { /* This reference is to a node. */ | ||||
100 | execute_string ("Node: %s", node->node); | ||||
101 | } | ||||
102 | add_word_args ("\177%d\n", node->position); | ||||
103 | } | ||||
104 | |||||
105 | add_word ("\037\nEnd Tag Table\n"); | ||||
106 | |||||
107 | /* Do not collapse -- to -, etc., in node names. */ | ||||
108 | in_fixed_width_font--; | ||||
109 | |||||
110 | flush_output (); | ||||
111 | no_indent = old_indent; | ||||
112 | } | ||||
113 | |||||
114 | void | ||||
115 | write_tag_table (char *filename) | ||||
116 | { | ||||
117 | output_stream = fopen (filename, "a"); | ||||
118 | if (!output_stream) | ||||
119 | { | ||||
120 | fs_error (filename); | ||||
121 | return; | ||||
122 | } | ||||
123 | |||||
124 | write_tag_table_internal (0); /* Not indirect. */ | ||||
125 | |||||
126 | if (fclose (output_stream) != 0) | ||||
127 | fs_error (filename); | ||||
128 | } | ||||
129 | |||||
130 | static void | ||||
131 | write_tag_table_indirect (void) | ||||
132 | { | ||||
133 | write_tag_table_internal (1); | ||||
134 | } | ||||
135 | |||||
136 | /* Convert "top" and friends into "Top". */ | ||||
137 | static void | ||||
138 | normalize_node_name (char *string) | ||||
139 | { | ||||
140 | if (strcasecmp (string, "Top") == 0) | ||||
141 | strcpy (string, "Top"); | ||||
142 | } | ||||
143 | |||||
144 | static char * | ||||
145 | get_node_token (int expand) | ||||
146 | { | ||||
147 | char *string; | ||||
148 | |||||
149 | get_until_in_line (expand, ",", &string); | ||||
150 | |||||
151 | if (curchar ()input_text[input_text_offset] == ',') | ||||
152 | input_text_offset++; | ||||
153 | |||||
154 | fix_whitespace (string); | ||||
155 | |||||
156 | /* Force all versions of "top" to be "Top". */ | ||||
157 | normalize_node_name (string); | ||||
158 | |||||
159 | return string; | ||||
160 | } | ||||
161 | |||||
162 | /* Expand any macros and other directives in a node name, and | ||||
163 | return the expanded name as an malloc'ed string. */ | ||||
164 | char * | ||||
165 | expand_node_name (char *node) | ||||
166 | { | ||||
167 | char *result = node; | ||||
168 | |||||
169 | if (node) | ||||
170 | { | ||||
171 | /* Don't expand --, `` etc., in case somebody will want | ||||
172 | to print the result. */ | ||||
173 | in_fixed_width_font++; | ||||
174 | result = expansion (node, 0); | ||||
175 | in_fixed_width_font--; | ||||
176 | fix_whitespace (result); | ||||
177 | normalize_node_name (result); | ||||
178 | } | ||||
179 | return result; | ||||
180 | } | ||||
181 | |||||
182 | /* Look up NAME in the tag table, and return the associated | ||||
183 | tag_entry. If the node is not in the table return NULL. */ | ||||
184 | TAG_ENTRY * | ||||
185 | find_node (char *name) | ||||
186 | { | ||||
187 | TAG_ENTRY *tag = tag_table; | ||||
188 | char *expanded_name; | ||||
189 | char n1 = name[0]; | ||||
190 | |||||
191 | while (tag) | ||||
192 | { | ||||
193 | if (tag->node[0] == n1 && strcmp (tag->node, name) == 0) | ||||
194 | return tag; | ||||
195 | tag = tag->next_ent; | ||||
196 | } | ||||
197 | |||||
198 | if (!expensive_validation) | ||||
199 | return NULL((void *)0); | ||||
200 | |||||
201 | /* Try harder. Maybe TAG_TABLE has the expanded NAME, or maybe NAME | ||||
202 | is expanded while TAG_TABLE has its unexpanded form. This may | ||||
203 | slow down the search, but if they want this feature, let them | ||||
204 | pay! If they want it fast, they should write every node name | ||||
205 | consistently (either always expanded or always unexpaned). */ | ||||
206 | expanded_name = expand_node_name (name); | ||||
207 | for (tag = tag_table; tag; tag = tag->next_ent) | ||||
208 | { | ||||
209 | if (STREQ (tag->node, expanded_name)(strcmp (tag->node, expanded_name) == 0)) | ||||
210 | break; | ||||
211 | /* If the tag name doesn't have the command prefix, there's no | ||||
212 | chance it could expand into anything but itself. */ | ||||
213 | if (strchr (tag->node, COMMAND_PREFIX'@')) | ||||
214 | { | ||||
215 | char *expanded_node = expand_node_name (tag->node); | ||||
216 | |||||
217 | if (STREQ (expanded_node, expanded_name)(strcmp (expanded_node, expanded_name) == 0)) | ||||
218 | { | ||||
219 | free (expanded_node); | ||||
220 | break; | ||||
221 | } | ||||
222 | free (expanded_node); | ||||
223 | } | ||||
224 | } | ||||
225 | free (expanded_name); | ||||
226 | return tag; | ||||
227 | } | ||||
228 | |||||
229 | /* Look in the tag table for a node whose file name is FNAME, and | ||||
230 | return the associated tag_entry. If there's no such node in the | ||||
231 | table, return NULL. */ | ||||
232 | static TAG_ENTRY * | ||||
233 | find_node_by_fname (char *fname) | ||||
234 | { | ||||
235 | TAG_ENTRY *tag = tag_table; | ||||
236 | while (tag) | ||||
237 | { | ||||
238 | if (tag->html_fname && FILENAME_CMPstrcmp (tag->html_fname, fname) == 0) | ||||
239 | return tag; | ||||
240 | tag = tag->next_ent; | ||||
241 | } | ||||
242 | |||||
243 | return tag; | ||||
244 | } | ||||
245 | |||||
246 | /* Remember next, prev, etc. references in a @node command, where we | ||||
247 | don't care about most of the entries. */ | ||||
248 | static void | ||||
249 | remember_node_node_reference (char *node) | ||||
250 | { | ||||
251 | NODE_REF *temp = xmalloc (sizeof (NODE_REF)); | ||||
252 | int number; | ||||
253 | |||||
254 | if (!node) return; | ||||
255 | temp->next = node_node_references; | ||||
256 | temp->node = xstrdup (node); | ||||
257 | temp->type = followed_reference; | ||||
258 | number = number_of_node (node); | ||||
259 | if (number) | ||||
260 | temp->number = number; /* Already assigned. */ | ||||
261 | else | ||||
262 | { | ||||
263 | node_number++; | ||||
264 | temp->number = node_number; | ||||
265 | } | ||||
266 | node_node_references = temp; | ||||
267 | } | ||||
268 | |||||
269 | /* Remember NODE and associates. */ | ||||
270 | static void | ||||
271 | remember_node (char *node, char *prev, char *next, char *up, | ||||
272 | int position, int line_no, char *fname, int flags) | ||||
273 | { | ||||
274 | /* Check for existence of this tag already. */ | ||||
275 | if (validating) | ||||
276 | { | ||||
277 | TAG_ENTRY *tag = find_node (node); | ||||
278 | if (tag) | ||||
279 | { | ||||
280 | line_error (_("Node `%s' previously defined at line %d")((const char *) ("Node `%s' previously defined at line %d")), | ||||
281 | node, tag->line_no); | ||||
282 | return; | ||||
283 | } | ||||
284 | } | ||||
285 | |||||
286 | if (!(flags & TAG_FLAG_ANCHOR32)) | ||||
287 | { | ||||
288 | /* Make this the current node. */ | ||||
289 | current_node = node; | ||||
290 | } | ||||
291 | |||||
292 | /* Add it to the list. */ | ||||
293 | { | ||||
294 | int number = number_of_node (node); | ||||
295 | |||||
296 | TAG_ENTRY *new = xmalloc (sizeof (TAG_ENTRY)); | ||||
297 | new->node = node; | ||||
298 | new->prev = prev; | ||||
299 | new->next = next; | ||||
300 | new->up = up; | ||||
301 | new->position = position; | ||||
302 | new->line_no = line_no; | ||||
303 | new->filename = node_filename; | ||||
304 | new->touched = 0; | ||||
305 | new->flags = flags; | ||||
306 | if (number) | ||||
307 | new->number = number; /* Already assigned. */ | ||||
308 | else | ||||
309 | { | ||||
310 | node_number++; | ||||
311 | new->number = node_number; | ||||
312 | } | ||||
313 | if (fname) | ||||
314 | new->html_fname = fname; | ||||
315 | else | ||||
316 | /* This happens for Top node under split-HTML, for example. */ | ||||
317 | new->html_fname | ||||
318 | = normalize_filename (filename_part (current_output_filename)); | ||||
319 | new->next_ent = tag_table; | ||||
320 | |||||
321 | /* Increment the order counter, and save it. */ | ||||
322 | node_order++; | ||||
323 | new->order = node_order; | ||||
324 | |||||
325 | tag_table = new; | ||||
326 | } | ||||
327 | |||||
328 | if (html) | ||||
329 | { /* Note the references to the next etc. nodes too. */ | ||||
330 | remember_node_node_reference (next); | ||||
331 | remember_node_node_reference (prev); | ||||
332 | remember_node_node_reference (up); | ||||
333 | } | ||||
334 | } | ||||
335 | |||||
336 | /* Remember this node name for later validation use. This is used to | ||||
337 | remember menu references while reading the input file. After the | ||||
338 | output file has been written, if validation is on, then we use the | ||||
339 | contents of `node_references' as a list of nodes to validate. */ | ||||
340 | void | ||||
341 | remember_node_reference (char *node, int line, enum reftype type) | ||||
342 | { | ||||
343 | NODE_REF *temp = xmalloc (sizeof (NODE_REF)); | ||||
344 | int number = number_of_node (node); | ||||
345 | |||||
346 | temp->next = node_references; | ||||
347 | temp->node = xstrdup (node); | ||||
348 | temp->line_no = line; | ||||
349 | temp->section = current_section; | ||||
350 | temp->type = type; | ||||
351 | temp->containing_node = xstrdup (current_node ? current_node : ""); | ||||
352 | temp->filename = node_filename; | ||||
353 | if (number) | ||||
354 | temp->number = number; /* Already assigned. */ | ||||
355 | else | ||||
356 | { | ||||
357 | node_number++; | ||||
358 | temp->number = node_number; | ||||
359 | } | ||||
360 | |||||
361 | node_references = temp; | ||||
362 | } | ||||
363 | |||||
364 | static void | ||||
365 | isolate_nodename (char *nodename) | ||||
366 | { | ||||
367 | int i, c; | ||||
368 | int paren_seen, paren; | ||||
369 | |||||
370 | if (!nodename) | ||||
371 | return; | ||||
372 | |||||
373 | canon_white (nodename); | ||||
374 | paren_seen = paren = i = 0; | ||||
375 | |||||
376 | if (*nodename == '.' || !*nodename) | ||||
377 | { | ||||
378 | *nodename = 0; | ||||
379 | return; | ||||
380 | } | ||||
381 | |||||
382 | if (*nodename == '(') | ||||
383 | { | ||||
384 | paren++; | ||||
385 | paren_seen++; | ||||
386 | i++; | ||||
387 | } | ||||
388 | |||||
389 | for (; (c = nodename[i]); i++) | ||||
390 | { | ||||
391 | if (paren) | ||||
392 | { | ||||
393 | if (c == '(') | ||||
394 | paren++; | ||||
395 | else if (c == ')') | ||||
396 | paren--; | ||||
397 | |||||
398 | continue; | ||||
399 | } | ||||
400 | |||||
401 | /* If the character following the close paren is a space, then this | ||||
402 | node has no more characters associated with it. */ | ||||
403 | if (c == '\t' || | ||||
404 | c == '\n' || | ||||
405 | c == ',' || | ||||
406 | ((paren_seen && nodename[i - 1] == ')') && | ||||
407 | (c == ' ' || c == '.')) || | ||||
408 | (c == '.' && | ||||
409 | ((!nodename[i + 1] || | ||||
410 | (cr_or_whitespace (nodename[i + 1])(((nodename[i + 1]) == '\t' || (nodename[i + 1]) == ' ') || ( nodename[i + 1]) == '\r' || (nodename[i + 1]) == '\n')) || | ||||
411 | (nodename[i + 1] == ')'))))) | ||||
412 | break; | ||||
413 | } | ||||
414 | nodename[i] = 0; | ||||
415 | } | ||||
416 | |||||
417 | /* This function gets called at the start of every line while inside a | ||||
418 | menu. It checks to see if the line starts with "* ", and if so and | ||||
419 | REMEMBER_REF is nonzero, remembers the node reference as type | ||||
420 | REF_TYPE that this menu refers to. input_text_offset is at the \n | ||||
421 | just before the menu line. If REMEMBER_REF is zero, REF_TYPE is unused. */ | ||||
422 | #define MENU_STARTER"* " "* " | ||||
423 | char * | ||||
424 | glean_node_from_menu (int remember_ref, enum reftype ref_type) | ||||
425 | { | ||||
426 | int i, orig_offset = input_text_offset; | ||||
427 | char *nodename; | ||||
428 | char *line, *expanded_line; | ||||
429 | char *old_input = input_text; | ||||
430 | int old_size = input_text_length; | ||||
431 | |||||
432 | if (strncmp (&input_text[input_text_offset + 1], | ||||
433 | MENU_STARTER"* ", | ||||
434 | strlen (MENU_STARTER"* ")) != 0) | ||||
435 | return NULL((void *)0); | ||||
436 | else | ||||
437 | input_text_offset += strlen (MENU_STARTER"* ") + 1; | ||||
438 | |||||
439 | /* The menu entry might include macro calls, so we need to expand them. */ | ||||
440 | get_until ("\n", &line); | ||||
441 | only_macro_expansion++; /* only expand macros in menu entries */ | ||||
442 | expanded_line = expansion (line, 0); | ||||
443 | only_macro_expansion--; | ||||
444 | free (line); | ||||
445 | input_text = expanded_line; | ||||
446 | input_text_offset = 0; | ||||
447 | input_text_length = strlen (expanded_line); | ||||
448 | |||||
449 | get_until_in_line (0, ":", &nodename); | ||||
450 | if (curchar ()input_text[input_text_offset] == ':') | ||||
451 | input_text_offset++; | ||||
452 | |||||
453 | if (curchar ()input_text[input_text_offset] != ':') | ||||
454 | { | ||||
455 | free (nodename); | ||||
456 | get_until_in_line (0, "\n", &nodename); | ||||
457 | isolate_nodename (nodename); | ||||
458 | } | ||||
459 | |||||
460 | input_text = old_input; | ||||
461 | input_text_offset = orig_offset; | ||||
462 | input_text_length = old_size; | ||||
463 | free (expanded_line); | ||||
464 | fix_whitespace (nodename); | ||||
465 | normalize_node_name (nodename); | ||||
466 | i = strlen (nodename); | ||||
467 | if (i && nodename[i - 1] == ':') | ||||
468 | nodename[i - 1] = 0; | ||||
469 | |||||
470 | if (remember_ref) | ||||
471 | remember_node_reference (nodename, line_number, ref_type); | ||||
472 | |||||
473 | return nodename; | ||||
474 | } | ||||
475 | |||||
476 | /* Set the name of the current output file. */ | ||||
477 | void | ||||
478 | set_current_output_filename (const char *fname) | ||||
479 | { | ||||
480 | if (current_output_filename) | ||||
481 | free (current_output_filename); | ||||
482 | current_output_filename = xstrdup (fname); | ||||
483 | } | ||||
484 | |||||
485 | |||||
486 | /* Output the <a name="..."></a> constructs for NODE. We output both | ||||
487 | the new-style conversion and the old-style, if they are different. | ||||
488 | See comments at `add_escaped_anchor_name' in html.c. */ | ||||
489 | |||||
490 | static void | ||||
491 | add_html_names (char *node) | ||||
492 | { | ||||
493 | char *tem = expand_node_name (node); | ||||
494 | char *otem = xstrdup (tem); | ||||
495 | |||||
496 | /* Determine if the old and new schemes come up with different names; | ||||
497 | only output the old scheme if that is so. We don't want to output | ||||
498 | the same name twice. */ | ||||
499 | canon_white (otem); | ||||
500 | { | ||||
501 | char *optr = otem; | ||||
502 | int need_old = 0; | ||||
503 | |||||
504 | for (; *optr; optr++) | ||||
505 | { | ||||
506 | if (!cr_or_whitespace (*optr)(((*optr) == '\t' || (*optr) == ' ') || (*optr) == '\r' || (* optr) == '\n') && !URL_SAFE_CHAR (*optr)(isalnum (*optr))) | ||||
507 | { | ||||
508 | need_old = 1; | ||||
509 | break; | ||||
510 | } | ||||
511 | } | ||||
512 | |||||
513 | if (need_old) | ||||
514 | { | ||||
515 | add_word ("<a name=\""); | ||||
516 | add_anchor_name (otem, -1); /* old anchor name conversion */ | ||||
517 | add_word ("\"></a>\n"); | ||||
518 | } | ||||
519 | free (otem); | ||||
520 | } | ||||
521 | |||||
522 | /* Always output the new scheme. */ | ||||
523 | canon_white (tem); | ||||
524 | add_word ("<a name=\""); | ||||
525 | add_anchor_name (tem, 0); | ||||
526 | add_word ("\"></a>\n"); | ||||
527 | |||||
528 | free (tem); | ||||
529 | } | ||||
530 | |||||
531 | |||||
532 | /* The order is: nodename, nextnode, prevnode, upnode. | ||||
533 | If all of the NEXT, PREV, and UP fields are empty, they are defaulted. | ||||
534 | You must follow a node command which has those fields defaulted | ||||
535 | with a sectioning command (e.g., @chapter) giving the "level" of that node. | ||||
536 | It is an error not to do so. | ||||
537 | The defaults come from the menu in this node's parent. */ | ||||
538 | void | ||||
539 | cm_node (void) | ||||
540 | { | ||||
541 | static long epilogue_len = 0L; | ||||
542 | char *node, *prev, *next, *up; | ||||
543 | int new_node_pos, defaulting, this_section; | ||||
544 | int no_warn = 0; | ||||
545 | char *fname_for_this_node = NULL((void *)0); | ||||
546 | char *tem; | ||||
547 | TAG_ENTRY *tag = NULL((void *)0); | ||||
548 | |||||
549 | if (strcmp (command, "nwnode") == 0) | ||||
| |||||
550 | no_warn = TAG_FLAG_NO_WARN8; | ||||
551 | |||||
552 | /* Get rid of unmatched brace arguments from previous commands. */ | ||||
553 | discard_braces (); | ||||
554 | |||||
555 | /* There also might be insertions left lying around that haven't been | ||||
556 | ended yet. Do that also. */ | ||||
557 | discard_insertions (1); | ||||
558 | |||||
559 | if (!html && !already_outputting_pending_notes) | ||||
560 | { | ||||
561 | close_paragraph (); | ||||
562 | output_pending_notes (); | ||||
563 | } | ||||
564 | |||||
565 | new_node_pos = output_position; | ||||
566 | |||||
567 | if (macro_expansion_output_stream && !executing_string) | ||||
568 | append_to_expansion_output (input_text_offset + 1); | ||||
569 | |||||
570 | /* Do not collapse -- to -, etc., in node names. */ | ||||
571 | in_fixed_width_font++; | ||||
572 | |||||
573 | /* While expanding the @node line, leave any non-macros | ||||
574 | intact, so that the macro-expanded output includes them. */ | ||||
575 | only_macro_expansion++; | ||||
576 | node = get_node_token (1); | ||||
577 | only_macro_expansion--; | ||||
578 | next = get_node_token (0); | ||||
579 | prev = get_node_token (0); | ||||
580 | up = get_node_token (0); | ||||
581 | |||||
582 | if (html && splitting | ||||
583 | /* If there is a Top node, it always goes into index.html. So | ||||
584 | don't start a new HTML file for Top. */ | ||||
585 | && (top_node_seen || strcasecmp (node, "Top") != 0)) | ||||
586 | { | ||||
587 | /* We test *node here so that @node without a valid name won't | ||||
588 | start a new file name with a bogus name such as ".html". | ||||
589 | This could happen if we run under "--force", where we cannot | ||||
590 | simply bail out. Continuing to use the same file sounds like | ||||
591 | the best we can do in such cases. */ | ||||
592 | if (current_output_filename && output_stream && *node) | ||||
593 | { | ||||
594 | char *fname_for_prev_node; | ||||
595 | |||||
596 | if (current_node) | ||||
597 | { | ||||
598 | /* NOTE: current_node at this point still holds the name | ||||
599 | of the previous node. */ | ||||
600 | tem = expand_node_name (current_node); | ||||
601 | fname_for_prev_node = nodename_to_filename (tem); | ||||
602 | free (tem); | ||||
603 | } | ||||
604 | else /* could happen if their top node isn't named "Top" */ | ||||
605 | fname_for_prev_node = filename_part (current_output_filename); | ||||
606 | tem = expand_node_name (node); | ||||
607 | fname_for_this_node = nodename_to_filename (tem); | ||||
608 | free (tem); | ||||
609 | /* Don't close current output file, if next output file is | ||||
610 | to have the same name. This may happen at top level, or | ||||
611 | if two nodes produce the same file name under --split. */ | ||||
612 | if (FILENAME_CMPstrcmp (fname_for_this_node, fname_for_prev_node) != 0) | ||||
613 | { | ||||
614 | long pos1 = 0; | ||||
615 | |||||
616 | /* End the current split output file. */ | ||||
617 | close_paragraph (); | ||||
618 | output_pending_notes (); | ||||
619 | start_paragraph (); | ||||
620 | /* Compute the length of the HTML file's epilogue. We | ||||
621 | cannot know the value until run time, due to the | ||||
622 | text/binary nuisance on DOS/Windows platforms, where | ||||
623 | 2 `\r' characters could be added to the epilogue when | ||||
624 | it is written in text mode. */ | ||||
625 | if (epilogue_len == 0) | ||||
626 | { | ||||
627 | flush_output (); | ||||
628 | pos1 = ftell (output_stream); | ||||
629 | } | ||||
630 | add_word ("</body></html>\n"); | ||||
631 | close_paragraph (); | ||||
632 | if (epilogue_len == 0) | ||||
633 | epilogue_len = ftell (output_stream) - pos1; | ||||
634 | fclose (output_stream); | ||||
635 | output_stream = NULL((void *)0); | ||||
636 | output_position = 0; | ||||
637 | tag = find_node_by_fname (fname_for_this_node); | ||||
638 | } | ||||
639 | free (fname_for_prev_node); | ||||
640 | } | ||||
641 | } | ||||
642 | |||||
643 | filling_enabled = indented_fill = 0; | ||||
644 | if (!html
| ||||
645 | current_footnote_number = 1; | ||||
646 | |||||
647 | if (verbose_mode) | ||||
648 | printf (_("Formatting node %s...\n")((const char *) ("Formatting node %s...\n")), node); | ||||
649 | |||||
650 | if (macro_expansion_output_stream && !executing_string) | ||||
651 | remember_itext (input_text, input_text_offset); | ||||
652 | |||||
653 | /* Reset the line number in each node for Info output, so that | ||||
654 | index entries will save the line numbers of parent node. */ | ||||
655 | node_line_number = 0; | ||||
656 | |||||
657 | no_indent = 1; | ||||
658 | if (xml) | ||||
659 | { | ||||
660 | xml_begin_document (current_output_filename); | ||||
661 | xml_begin_node (); | ||||
662 | if (!docbook) | ||||
663 | { | ||||
664 | xml_insert_element (NODENAME, START0); | ||||
665 | if (macro_expansion_output_stream && !executing_string) | ||||
666 | me_execute_string (node); | ||||
667 | else | ||||
668 | execute_string ("%s", node); | ||||
669 | xml_insert_element (NODENAME, END1); | ||||
670 | } | ||||
671 | else | ||||
672 | xml_node_id = xml_id (node); | ||||
673 | } | ||||
674 | else if (!no_headers && !html) | ||||
675 | { | ||||
676 | /* Emacs Info reader cannot grok indented escape sequence. */ | ||||
677 | kill_self_indent (-1); | ||||
678 | |||||
679 | add_word_args ("\037\nFile: %s, Node: ", pretty_output_filename); | ||||
680 | |||||
681 | if (macro_expansion_output_stream && !executing_string) | ||||
682 | me_execute_string (node); | ||||
683 | else | ||||
684 | execute_string ("%s", node); | ||||
685 | filling_enabled = indented_fill = 0; | ||||
686 | } | ||||
687 | |||||
688 | /* Check for defaulting of this node's next, prev, and up fields. */ | ||||
689 | defaulting = (*next == 0 && *prev == 0 && *up == 0); | ||||
690 | |||||
691 | this_section = what_section (input_text + input_text_offset, NULL((void *)0)); | ||||
692 | |||||
693 | /* If we are defaulting, then look at the immediately following | ||||
694 | sectioning command (error if none) to determine the node's | ||||
695 | level. Find the node that contains the menu mentioning this node | ||||
696 | that is one level up (error if not found). That node is the "Up" | ||||
697 | of this node. Default the "Next" and "Prev" from the menu. */ | ||||
698 | if (defaulting
| ||||
699 | { | ||||
700 | NODE_REF *last_ref = NULL((void *)0); | ||||
701 | NODE_REF *ref = node_references; | ||||
702 | |||||
703 | if (this_section < 0 && !STREQ (node, "Top")(strcmp (node, "Top") == 0)) | ||||
704 | { | ||||
705 | char *polite_section_name = "top"; | ||||
706 | int i; | ||||
707 | |||||
708 | for (i = 0; section_alist[i].name; i++) | ||||
709 | if (section_alist[i].level == current_section + 1) | ||||
710 | { | ||||
711 | polite_section_name = section_alist[i].name; | ||||
712 | break; | ||||
713 | } | ||||
714 | |||||
715 | line_error | ||||
716 | (_("Node `%s' requires a sectioning command (e.g., %c%s)")((const char *) ("Node `%s' requires a sectioning command (e.g., %c%s)" )), | ||||
717 | node, COMMAND_PREFIX'@', polite_section_name); | ||||
718 | } | ||||
719 | else | ||||
720 | { | ||||
721 | if (strcmp (node, "Top") == 0) | ||||
722 | { | ||||
723 | /* Default the NEXT pointer to be the first menu item in | ||||
724 | this node, if there is a menu in this node. We have to | ||||
725 | try very hard to find the menu, as it may be obscured | ||||
726 | by execution_strings which are on the filestack. For | ||||
727 | every member of the filestack which has a FILENAME | ||||
728 | member which is identical to the current INPUT_FILENAME, | ||||
729 | search forward from that offset. */ | ||||
730 | int saved_input_text_offset = input_text_offset; | ||||
731 | int saved_input_text_length = input_text_length; | ||||
732 | char *saved_input_text = input_text; | ||||
733 | FSTACK *next_file = filestack; | ||||
734 | |||||
735 | int orig_offset, orig_size; | ||||
736 | |||||
737 | int bye_offset = search_forward ("\n@bye", input_text_offset); | ||||
738 | |||||
739 | /* No matter what, make this file point back at `(dir)'. */ | ||||
740 | free (up); | ||||
741 | up = xstrdup ("(dir)"); /* html fixxme */ | ||||
742 | |||||
743 | while (1) | ||||
744 | { | ||||
745 | orig_offset = input_text_offset; | ||||
746 | orig_size = | ||||
747 | search_forward (node_search_string, orig_offset); | ||||
748 | |||||
749 | if (orig_size < 0) | ||||
750 | orig_size = input_text_length; | ||||
751 | |||||
752 | input_text_offset = search_forward ("\n@menu", orig_offset); | ||||
753 | if (input_text_offset > -1 | ||||
754 | && (bye_offset > -1 && input_text_offset < bye_offset) | ||||
755 | && cr_or_whitespace (input_text[input_text_offset + 6])(((input_text[input_text_offset + 6]) == '\t' || (input_text[ input_text_offset + 6]) == ' ') || (input_text[input_text_offset + 6]) == '\r' || (input_text[input_text_offset + 6]) == '\n' )) | ||||
756 | { | ||||
757 | char *nodename_from_menu = NULL((void *)0); | ||||
758 | |||||
759 | input_text_offset = | ||||
760 | search_forward ("\n* ", input_text_offset); | ||||
761 | |||||
762 | if (input_text_offset != -1) | ||||
763 | nodename_from_menu = glean_node_from_menu (0, 0); | ||||
764 | |||||
765 | if (nodename_from_menu) | ||||
766 | { | ||||
767 | free (next); | ||||
768 | next = nodename_from_menu; | ||||
769 | break; | ||||
770 | } | ||||
771 | } | ||||
772 | |||||
773 | /* We got here, so it hasn't been found yet. Try | ||||
774 | the next file on the filestack if there is one. */ | ||||
775 | if (next_file | ||||
776 | && FILENAME_CMPstrcmp (next_file->filename, input_filename) | ||||
777 | == 0) | ||||
778 | { | ||||
779 | input_text = next_file->text; | ||||
780 | input_text_offset = next_file->offset; | ||||
781 | input_text_length = next_file->size; | ||||
782 | next_file = next_file->next; | ||||
783 | } | ||||
784 | else | ||||
785 | { /* No more input files to check. */ | ||||
786 | break; | ||||
787 | } | ||||
788 | } | ||||
789 | |||||
790 | input_text = saved_input_text; | ||||
791 | input_text_offset = saved_input_text_offset; | ||||
792 | input_text_length = saved_input_text_length; | ||||
793 | } | ||||
794 | } | ||||
795 | |||||
796 | /* Fix the level of the menu references in the Top node, iff it | ||||
797 | was declared with @top, and no subsequent reference was found. */ | ||||
798 | if (top_node_seen && !non_top_node_seen) | ||||
799 | { | ||||
800 | /* Then this is the first non-@top node seen. */ | ||||
801 | int level; | ||||
802 | |||||
803 | level = set_top_section_level (this_section - 1); | ||||
804 | non_top_node_seen = 1; | ||||
805 | |||||
806 | while (ref) | ||||
807 | { | ||||
808 | if (ref->section == level) | ||||
809 | ref->section = this_section - 1; | ||||
810 | ref = ref->next; | ||||
811 | } | ||||
812 | |||||
813 | ref = node_references; | ||||
814 | } | ||||
815 | |||||
816 | while (ref) | ||||
817 | { | ||||
818 | if (ref->section == (this_section - 1) | ||||
819 | && ref->type == menu_reference | ||||
820 | && strcmp (ref->node, node) == 0) | ||||
821 | { | ||||
822 | char *containing_node = ref->containing_node; | ||||
823 | |||||
824 | free (up); | ||||
825 | up = xstrdup (containing_node); | ||||
826 | |||||
827 | if (last_ref | ||||
828 | && last_ref->type == menu_reference | ||||
829 | && strcmp (last_ref->containing_node, containing_node) == 0) | ||||
830 | { | ||||
831 | free (next); | ||||
832 | next = xstrdup (last_ref->node); | ||||
833 | } | ||||
834 | |||||
835 | while (ref->section == this_section - 1 | ||||
836 | && ref->next | ||||
837 | && ref->next->type != menu_reference) | ||||
838 | ref = ref->next; | ||||
839 | |||||
840 | if (ref->next && ref->type == menu_reference | ||||
841 | && strcmp (ref->next->containing_node, containing_node) == 0) | ||||
842 | { | ||||
843 | free (prev); | ||||
844 | prev = xstrdup (ref->next->node); | ||||
845 | } | ||||
846 | else if (!ref->next | ||||
847 | && strcasecmp (ref->containing_node, "Top") == 0) | ||||
848 | { | ||||
849 | free (prev); | ||||
850 | prev = xstrdup (ref->containing_node); | ||||
851 | } | ||||
852 | break; | ||||
853 | } | ||||
854 | last_ref = ref; | ||||
855 | ref = ref->next; | ||||
856 | } | ||||
857 | } | ||||
858 | |||||
859 | /* Insert the correct args if we are expanding macros, and the node's | ||||
860 | pointers weren't defaulted. */ | ||||
861 | if (macro_expansion_output_stream && !executing_string && !defaulting) | ||||
862 | { | ||||
863 | char *temp; | ||||
864 | int op_orig = output_paragraph_offset; | ||||
865 | int meta_pos_orig = meta_char_pos; | ||||
866 | int extra = html ? strlen (node) : 0; | ||||
867 | |||||
868 | temp = xmalloc (7 + extra + strlen (next) + strlen (prev) + strlen (up)); | ||||
869 | sprintf (temp, "%s, %s, %s, %s", html ? node : "", next, prev, up); | ||||
870 | me_execute_string (temp); | ||||
871 | free (temp); | ||||
872 | |||||
873 | output_paragraph_offset = op_orig; | ||||
874 | meta_char_pos = meta_pos_orig; | ||||
875 | } | ||||
876 | |||||
877 | if (!*node) | ||||
878 | { | ||||
879 | line_error (_("No node name specified for `%c%s' command")((const char *) ("No node name specified for `%c%s' command") ), | ||||
880 | COMMAND_PREFIX'@', command); | ||||
881 | free (node); | ||||
882 | free (next); next = NULL((void *)0); | ||||
883 | free (prev); prev= NULL((void *)0); | ||||
884 | free (up); up = NULL((void *)0); | ||||
885 | node_number++; /* else it doesn't get bumped */ | ||||
886 | } | ||||
887 | else | ||||
888 | { | ||||
889 | if (!*next) { free (next); next = NULL((void *)0); } | ||||
890 | if (!*prev) { free (prev); prev = NULL((void *)0); } | ||||
891 | if (!*up) { free (up); up = NULL((void *)0); } | ||||
892 | remember_node (node, prev, next, up, new_node_pos, line_number, | ||||
893 | fname_for_this_node, no_warn); | ||||
894 | outstanding_node = 1; | ||||
895 | } | ||||
896 | |||||
897 | if (html) | ||||
898 | { | ||||
899 | if (splitting && *node && output_stream == NULL((void *)0)) | ||||
900 | { | ||||
901 | char *dirname; | ||||
902 | char filename[PATH_MAX1024]; | ||||
903 | |||||
904 | dirname = pathname_part (current_output_filename); | ||||
905 | strcpy (filename, dirname); | ||||
906 | strcat (filename, fname_for_this_node); | ||||
907 | free (dirname); | ||||
908 | |||||
909 | /* See if the node name converted to a file name clashes | ||||
910 | with other nodes or anchors. If it clashes with an | ||||
911 | anchor, we complain and nuke that anchor's file. */ | ||||
912 | if (!tag) | ||||
913 | { | ||||
914 | output_stream = fopen (filename, "w"); | ||||
915 | html_output_head_p = 0; /* so that we generate HTML preamble */ | ||||
916 | html_output_head (); | ||||
917 | } | ||||
918 | else if ((tag->flags & TAG_FLAG_ANCHOR32) != 0) | ||||
919 | { | ||||
920 | line_error (_("Anchor `%s' and node `%s' map to the same file name")((const char *) ("Anchor `%s' and node `%s' map to the same file name" )), | ||||
921 | tag->node, node); | ||||
922 | file_line_error (tag->filename, tag->line_no, | ||||
923 | _("This @anchor command ignored; references to it will not work")((const char *) ("This @anchor command ignored; references to it will not work" ))); | ||||
924 | file_line_error (tag->filename, tag->line_no, | ||||
925 | _("Rename this anchor or use the `--no-split' option")((const char *) ("Rename this anchor or use the `--no-split' option" ))); | ||||
926 | /* Nuke the file name recorded in anchor's tag. | ||||
927 | Since we are about to nuke the file itself, we | ||||
928 | don't want find_node_by_fname to consider this | ||||
929 | anchor anymore. */ | ||||
930 | free (tag->html_fname); | ||||
931 | tag->html_fname = NULL((void *)0); | ||||
932 | output_stream = fopen (filename, "w"); | ||||
933 | html_output_head_p = 0; /* so that we generate HTML preamble */ | ||||
934 | html_output_head (); | ||||
935 | } | ||||
936 | else | ||||
937 | { | ||||
938 | /* This node's file name clashes with another node. | ||||
939 | We put them both on the same file. */ | ||||
940 | output_stream = fopen (filename, "r+"); | ||||
941 | if (output_stream) | ||||
942 | { | ||||
943 | static char html_end[] = "</body></html>\n"; | ||||
944 | char end_line[sizeof(html_end)]; | ||||
945 | int fpos = fseek (output_stream, -epilogue_len, | ||||
946 | SEEK_END2); | ||||
947 | |||||
948 | if (fpos < 0 | ||||
949 | || fgets (end_line, sizeof (html_end), | ||||
950 | output_stream) == NULL((void *)0) | ||||
951 | /* Paranoia: did someone change the way HTML | ||||
952 | files are finished up? */ | ||||
953 | || strcasecmp (end_line, html_end) != 0) | ||||
954 | { | ||||
955 | line_error (_("Unexpected string at end of split-HTML file `%s'")((const char *) ("Unexpected string at end of split-HTML file `%s'" )), | ||||
956 | fname_for_this_node); | ||||
957 | fclose (output_stream); | ||||
958 | xexit (1); | ||||
959 | } | ||||
960 | fseek (output_stream, -epilogue_len, SEEK_END2); | ||||
961 | } | ||||
962 | } | ||||
963 | if (output_stream == NULL((void *)0)) | ||||
964 | { | ||||
965 | fs_error (filename); | ||||
966 | xexit (1); | ||||
967 | } | ||||
968 | set_current_output_filename (filename); | ||||
969 | } | ||||
970 | |||||
971 | if (!splitting
| ||||
972 | { /* cross refs need a name="#anchor" even if not writing headers */ | ||||
973 | add_html_names (node); | ||||
974 | } | ||||
975 | |||||
976 | if (splitting
| ||||
977 | { /* Navigation bar. */ | ||||
978 | add_html_block_elt ("<div class=\"node\">\n"); | ||||
979 | /* The <p> avoids the links area running on with old Lynxen. */ | ||||
980 | add_word_args ("<p>%s\n", splitting ? "" : "<hr>"); | ||||
981 | |||||
982 | /* In the split HTML case, the filename is wrong for the | ||||
983 | old-style converted names, but we'll add them anyway, for | ||||
984 | consistency. (And we need them in the normal (not | ||||
985 | no_headers) nonsplit case.) */ | ||||
986 | add_html_names (node); | ||||
| |||||
987 | |||||
988 | if (next) | ||||
989 | { | ||||
990 | tem = expansion (next, 0); | ||||
991 | add_word ((char *) _("Next:")((const char *) ("Next:"))); | ||||
992 | add_word (" "); | ||||
993 | |||||
994 | add_word ("<a rel=\"next\" accesskey=\"n\" href=\""); | ||||
995 | add_anchor_name (tem, 1); | ||||
996 | tem = escape_string (tem); | ||||
997 | add_word_args ("\">%s</a>", tem); | ||||
998 | |||||
999 | free (tem); | ||||
1000 | |||||
1001 | if (prev || up) | ||||
1002 | add_word (",\n"); | ||||
1003 | } | ||||
1004 | if (prev) | ||||
1005 | { | ||||
1006 | tem = expansion (prev, 0); | ||||
1007 | add_word ((char *) _("Previous:")((const char *) ("Previous:"))); | ||||
1008 | add_word (" "); | ||||
1009 | add_word ("<a rel=\"previous\" accesskey=\"p\" href=\""); | ||||
1010 | add_anchor_name (tem, 1); | ||||
1011 | tem = escape_string (tem); | ||||
1012 | add_word_args ("\">%s</a>", tem); | ||||
1013 | free (tem); | ||||
1014 | |||||
1015 | if (up) | ||||
1016 | add_word (",\n"); | ||||
1017 | } | ||||
1018 | if (up) | ||||
1019 | { | ||||
1020 | tem = expansion (up, 0); | ||||
1021 | add_word ((char *) _("Up:")((const char *) ("Up:"))); | ||||
1022 | add_word (" "); | ||||
1023 | add_word ("<a rel=\"up\" accesskey=\"u\" href=\""); | ||||
1024 | add_anchor_name (tem, 1); | ||||
1025 | tem = escape_string (tem); | ||||
1026 | add_word_args ("\">%s</a>", tem); | ||||
1027 | free (tem); | ||||
1028 | } | ||||
1029 | /* html fixxme: we want a `top' or `contents' link here. */ | ||||
1030 | |||||
1031 | add_word_args ("\n%s\n", splitting ? "<hr>" : ""); | ||||
1032 | add_word ("</div>\n"); | ||||
1033 | } | ||||
1034 | } | ||||
1035 | else if (docbook) | ||||
1036 | ; | ||||
1037 | else if (xml) | ||||
1038 | { | ||||
1039 | if (next) | ||||
1040 | { | ||||
1041 | xml_insert_element (NODENEXT, START0); | ||||
1042 | execute_string ("%s", next); | ||||
1043 | xml_insert_element (NODENEXT, END1); | ||||
1044 | } | ||||
1045 | if (prev) | ||||
1046 | { | ||||
1047 | xml_insert_element (NODEPREV, START0); | ||||
1048 | execute_string ("%s", prev); | ||||
1049 | xml_insert_element (NODEPREV, END1); | ||||
1050 | } | ||||
1051 | if (up) | ||||
1052 | { | ||||
1053 | xml_insert_element (NODEUP, START0); | ||||
1054 | execute_string ("%s", up); | ||||
1055 | xml_insert_element (NODEUP, END1); | ||||
1056 | } | ||||
1057 | } | ||||
1058 | else if (!no_headers) | ||||
1059 | { | ||||
1060 | if (macro_expansion_output_stream) | ||||
1061 | me_inhibit_expansion++; | ||||
1062 | |||||
1063 | /* These strings are not translatable. */ | ||||
1064 | if (next) | ||||
1065 | { | ||||
1066 | execute_string (", Next: %s", next); | ||||
1067 | filling_enabled = indented_fill = 0; | ||||
1068 | } | ||||
1069 | if (prev) | ||||
1070 | { | ||||
1071 | execute_string (", Prev: %s", prev); | ||||
1072 | filling_enabled = indented_fill = 0; | ||||
1073 | } | ||||
1074 | if (up) | ||||
1075 | { | ||||
1076 | execute_string (", Up: %s", up); | ||||
1077 | filling_enabled = indented_fill = 0; | ||||
1078 | } | ||||
1079 | if (macro_expansion_output_stream) | ||||
1080 | me_inhibit_expansion--; | ||||
1081 | } | ||||
1082 | |||||
1083 | close_paragraph (); | ||||
1084 | no_indent = 0; | ||||
1085 | |||||
1086 | /* Change the section only if there was a sectioning command. */ | ||||
1087 | if (this_section >= 0) | ||||
1088 | current_section = this_section; | ||||
1089 | |||||
1090 | if (current_node && STREQ (current_node, "Top")(strcmp (current_node, "Top") == 0)) | ||||
1091 | top_node_seen = 1; | ||||
1092 | |||||
1093 | filling_enabled = 1; | ||||
1094 | in_fixed_width_font--; | ||||
1095 | } | ||||
1096 | |||||
1097 | /* Cross-reference target at an arbitrary spot. */ | ||||
1098 | void | ||||
1099 | cm_anchor (int arg) | ||||
1100 | { | ||||
1101 | char *anchor; | ||||
1102 | char *fname_for_anchor = NULL((void *)0); | ||||
1103 | |||||
1104 | if (arg == END1) | ||||
1105 | return; | ||||
1106 | |||||
1107 | /* Parse the anchor text. */ | ||||
1108 | anchor = get_xref_token (1); | ||||
1109 | |||||
1110 | /* Force all versions of "top" to be "Top". */ | ||||
1111 | normalize_node_name (anchor); | ||||
1112 | |||||
1113 | /* In HTML mode, need to actually produce some output. */ | ||||
1114 | if (html) | ||||
1115 | { | ||||
1116 | /* If this anchor is at the beginning of a new paragraph, make | ||||
1117 | sure a new paragraph is indeed started. */ | ||||
1118 | if (!paragraph_is_open) | ||||
1119 | { | ||||
1120 | if (!executing_string && html) | ||||
1121 | html_output_head (); | ||||
1122 | start_paragraph (); | ||||
1123 | if (!in_fixed_width_font || in_menu || in_detailmenu) | ||||
1124 | { | ||||
1125 | insert_string ("<p>"); | ||||
1126 | in_paragraph = 1; | ||||
1127 | } | ||||
1128 | } | ||||
1129 | add_word ("<a name=\""); | ||||
1130 | add_anchor_name (anchor, 0); | ||||
1131 | add_word ("\"></a>"); | ||||
1132 | if (splitting) | ||||
1133 | { | ||||
1134 | /* If we are splitting, cm_xref will produce a reference to | ||||
1135 | a file whose name is derived from the anchor name. So we | ||||
1136 | must create a file when we see an @anchor, otherwise | ||||
1137 | xref's to anchors won't work. The file we create simply | ||||
1138 | redirects to the file of this anchor's node. */ | ||||
1139 | TAG_ENTRY *tag; | ||||
1140 | |||||
1141 | fname_for_anchor = nodename_to_filename (anchor); | ||||
1142 | /* See if the anchor name converted to a file name clashes | ||||
1143 | with other anchors or nodes. */ | ||||
1144 | tag = find_node_by_fname (fname_for_anchor); | ||||
1145 | if (tag) | ||||
1146 | { | ||||
1147 | if ((tag->flags & TAG_FLAG_ANCHOR32) != 0) | ||||
1148 | line_error (_("Anchors `%s' and `%s' map to the same file name")((const char *) ("Anchors `%s' and `%s' map to the same file name" )), | ||||
1149 | anchor, tag->node); | ||||
1150 | else | ||||
1151 | line_error (_("Anchor `%s' and node `%s' map to the same file name")((const char *) ("Anchor `%s' and node `%s' map to the same file name" )), | ||||
1152 | anchor, tag->node); | ||||
1153 | line_error (_("@anchor command ignored; references to it will not work")((const char *) ("@anchor command ignored; references to it will not work" ))); | ||||
1154 | line_error (_("Rename this anchor or use the `--no-split' option")((const char *) ("Rename this anchor or use the `--no-split' option" ))); | ||||
1155 | free (fname_for_anchor); | ||||
1156 | /* We will not be creating a file for this anchor, so | ||||
1157 | set its name to NULL, so that remember_node stores a | ||||
1158 | NULL and find_node_by_fname won't consider this | ||||
1159 | anchor for clashes. */ | ||||
1160 | fname_for_anchor = NULL((void *)0); | ||||
1161 | } | ||||
1162 | else | ||||
1163 | { | ||||
1164 | char *dirname, *p; | ||||
1165 | char filename[PATH_MAX1024]; | ||||
1166 | FILE *anchor_stream; | ||||
1167 | |||||
1168 | dirname = pathname_part (current_output_filename); | ||||
1169 | strcpy (filename, dirname); | ||||
1170 | strcat (filename, fname_for_anchor); | ||||
1171 | free (dirname); | ||||
1172 | |||||
1173 | anchor_stream = fopen (filename, "w"); | ||||
1174 | if (anchor_stream == NULL((void *)0)) | ||||
1175 | { | ||||
1176 | fs_error (filename); | ||||
1177 | xexit (1); | ||||
1178 | } | ||||
1179 | /* The HTML magic below will cause the browser to | ||||
1180 | immediately go to the anchor's node's file. Lynx | ||||
1181 | seems not to support this redirection, but it looks | ||||
1182 | like a bug in Lynx, and they can work around it by | ||||
1183 | clicking on the link once more. */ | ||||
1184 | fputs ("<meta http-equiv=\"refresh\" content=\"0; url=", | ||||
1185 | anchor_stream); | ||||
1186 | /* Make the indirect link point to the current node's | ||||
1187 | file and anchor's "<a name" label. If we don't have | ||||
1188 | a valid node name, refer to the current output file | ||||
1189 | instead. */ | ||||
1190 | if (current_node && *current_node) | ||||
1191 | { | ||||
1192 | char *fn, *tem; | ||||
1193 | |||||
1194 | tem = expand_node_name (current_node); | ||||
1195 | fn = nodename_to_filename (tem); | ||||
1196 | free (tem); | ||||
1197 | fputs (fn, anchor_stream); | ||||
1198 | free (fn); | ||||
1199 | } | ||||
1200 | else | ||||
1201 | { | ||||
1202 | char *base = filename_part (current_output_filename); | ||||
1203 | |||||
1204 | fputs (base, anchor_stream); | ||||
1205 | free (base); | ||||
1206 | } | ||||
1207 | fputs ("#", anchor_stream); | ||||
1208 | for (p = anchor; *p; p++) | ||||
1209 | { | ||||
1210 | if (*p == '&') | ||||
1211 | fputs ("&", anchor_stream); | ||||
1212 | else if (!URL_SAFE_CHAR (*p)(isalnum (*p))) | ||||
1213 | fprintf (anchor_stream, "%%%x", (unsigned char) *p); | ||||
1214 | else | ||||
1215 | fputc (*p, anchor_stream); | ||||
1216 | } | ||||
1217 | fputs ("\">\n", anchor_stream); | ||||
1218 | fclose (anchor_stream); | ||||
1219 | } | ||||
1220 | } | ||||
1221 | } | ||||
1222 | else if (xml) | ||||
1223 | { | ||||
1224 | xml_insert_element_with_attribute (ANCHOR, START0, "name=\"%s\"", anchor); | ||||
1225 | xml_insert_element (ANCHOR, END1); | ||||
1226 | } | ||||
1227 | /* Save it in the tag table. */ | ||||
1228 | remember_node (anchor, NULL((void *)0), NULL((void *)0), NULL((void *)0), | ||||
1229 | output_position + output_paragraph_offset, | ||||
1230 | line_number, fname_for_anchor, TAG_FLAG_ANCHOR32); | ||||
1231 | } | ||||
1232 | |||||
1233 | /* Find NODE in REF_LIST. */ | ||||
1234 | static NODE_REF * | ||||
1235 | find_node_reference (char *node, NODE_REF *ref_list) | ||||
1236 | { | ||||
1237 | NODE_REF *orig_ref_list = ref_list; | ||||
1238 | char *expanded_node; | ||||
1239 | |||||
1240 | while (ref_list) | ||||
1241 | { | ||||
1242 | if (strcmp (node, ref_list->node) == 0) | ||||
1243 | break; | ||||
1244 | ref_list = ref_list->next; | ||||
1245 | } | ||||
1246 | |||||
1247 | if (ref_list || !expensive_validation) | ||||
1248 | return ref_list; | ||||
1249 | |||||
1250 | /* Maybe NODE is not expanded yet. This may be SLOW. */ | ||||
1251 | expanded_node = expand_node_name (node); | ||||
1252 | for (ref_list = orig_ref_list; ref_list; ref_list = ref_list->next) | ||||
1253 | { | ||||
1254 | if (STREQ (expanded_node, ref_list->node)(strcmp (expanded_node, ref_list->node) == 0)) | ||||
1255 | break; | ||||
1256 | if (strchr (ref_list->node, COMMAND_PREFIX'@')) | ||||
1257 | { | ||||
1258 | char *expanded_ref = expand_node_name (ref_list->node); | ||||
1259 | |||||
1260 | if (STREQ (expanded_node, expanded_ref)(strcmp (expanded_node, expanded_ref) == 0)) | ||||
1261 | { | ||||
1262 | free (expanded_ref); | ||||
1263 | break; | ||||
1264 | } | ||||
1265 | free (expanded_ref); | ||||
1266 | } | ||||
1267 | } | ||||
1268 | free (expanded_node); | ||||
1269 | return ref_list; | ||||
1270 | } | ||||
1271 | |||||
1272 | void | ||||
1273 | free_node_references (void) | ||||
1274 | { | ||||
1275 | NODE_REF *list, *temp; | ||||
1276 | |||||
1277 | list = node_references; | ||||
1278 | |||||
1279 | while (list) | ||||
1280 | { | ||||
1281 | temp = list; | ||||
1282 | free (list->node); | ||||
1283 | free (list->containing_node); | ||||
1284 | list = list->next; | ||||
1285 | free (temp); | ||||
1286 | } | ||||
1287 | node_references = NULL((void *)0); | ||||
1288 | } | ||||
1289 | |||||
1290 | void | ||||
1291 | free_node_node_references (void) | ||||
1292 | { | ||||
1293 | NODE_REF *list, *temp; | ||||
1294 | |||||
1295 | list = node_references; | ||||
1296 | |||||
1297 | while (list) | ||||
1298 | { | ||||
1299 | temp = list; | ||||
1300 | free (list->node); | ||||
1301 | list = list->next; | ||||
1302 | free (temp); | ||||
1303 | } | ||||
1304 | node_node_references = NULL((void *)0); | ||||
1305 | } | ||||
1306 | |||||
1307 | /* Return the number assigned to a named node in either the tag_table | ||||
1308 | or node_references list or zero if no number has been assigned. */ | ||||
1309 | int | ||||
1310 | number_of_node (char *node) | ||||
1311 | { | ||||
1312 | NODE_REF *temp_ref; | ||||
1313 | TAG_ENTRY *temp_node = find_node (node); | ||||
1314 | |||||
1315 | if (temp_node) | ||||
1316 | return temp_node->number; | ||||
1317 | else if ((temp_ref = find_node_reference (node, node_references))) | ||||
1318 | return temp_ref->number; | ||||
1319 | else if ((temp_ref = find_node_reference (node, node_node_references))) | ||||
1320 | return temp_ref->number; | ||||
1321 | else | ||||
1322 | return 0; | ||||
1323 | } | ||||
1324 | |||||
1325 | /* validation */ | ||||
1326 | |||||
1327 | /* Return 1 if TAG (at LINE) correctly validated, or 0 if not. | ||||
1328 | LABEL is the (translated) description of the type of reference -- | ||||
1329 | Menu, Cross, Next, etc. */ | ||||
1330 | |||||
1331 | static int | ||||
1332 | validate (char *tag, int line, const char *label) | ||||
1333 | { | ||||
1334 | TAG_ENTRY *result; | ||||
1335 | |||||
1336 | /* If there isn't a tag to verify, or if the tag is in another file, | ||||
1337 | then it must be okay. */ | ||||
1338 | if (!tag || !*tag || *tag == '(') | ||||
1339 | return 1; | ||||
1340 | |||||
1341 | /* Otherwise, the tag must exist. */ | ||||
1342 | result = find_node (tag); | ||||
1343 | |||||
1344 | if (!result) | ||||
1345 | { | ||||
1346 | line_number = line; | ||||
1347 | line_error (_("%s reference to nonexistent node `%s' (perhaps incorrect sectioning?)")((const char *) ("%s reference to nonexistent node `%s' (perhaps incorrect sectioning?)" )), label, tag); | ||||
1348 | return 0; | ||||
1349 | } | ||||
1350 | result->touched++; | ||||
1351 | return 1; | ||||
1352 | } | ||||
1353 | |||||
1354 | /* The strings here are followed in the message by `reference to...' in | ||||
1355 | the `validate' routine. They are only used in messages, thus are | ||||
1356 | translated. */ | ||||
1357 | static const char * | ||||
1358 | reftype_type_string (enum reftype type) | ||||
1359 | { | ||||
1360 | switch (type) | ||||
1361 | { | ||||
1362 | case menu_reference: | ||||
1363 | return _("Menu")((const char *) ("Menu")); | ||||
1364 | case followed_reference: | ||||
1365 | return _("Cross")((const char *) ("Cross")); | ||||
1366 | default: | ||||
1367 | return "Internal-bad-reference-type"; | ||||
1368 | } | ||||
1369 | } | ||||
1370 | |||||
1371 | static void | ||||
1372 | validate_other_references (NODE_REF *ref_list) | ||||
1373 | { | ||||
1374 | char *old_input_filename = input_filename; | ||||
1375 | |||||
1376 | while (ref_list) | ||||
1377 | { | ||||
1378 | input_filename = ref_list->filename; | ||||
1379 | validate (ref_list->node, ref_list->line_no, | ||||
1380 | reftype_type_string (ref_list->type)); | ||||
1381 | ref_list = ref_list->next; | ||||
1382 | } | ||||
1383 | input_filename = old_input_filename; | ||||
1384 | } | ||||
1385 | |||||
1386 | /* Validation of an info file. | ||||
1387 | Scan through the list of tag entries touching the Prev, Next, and Up | ||||
1388 | elements of each. It is an error not to be able to touch one of them, | ||||
1389 | except in the case of external node references, such as "(DIR)". | ||||
1390 | |||||
1391 | If the Prev is different from the Up, | ||||
1392 | then the Prev node must have a Next pointing at this node. | ||||
1393 | |||||
1394 | Every node except Top must have an Up. | ||||
1395 | The Up node must contain some sort of reference, other than a Next, | ||||
1396 | to this node. | ||||
1397 | |||||
1398 | If the Next is different from the Next of the Up, | ||||
1399 | then the Next node must have a Prev pointing at this node. */ | ||||
1400 | void | ||||
1401 | validate_file (TAG_ENTRY *tag_table) | ||||
1402 | { | ||||
1403 | char *old_input_filename = input_filename; | ||||
1404 | TAG_ENTRY *tags = tag_table; | ||||
1405 | |||||
1406 | while (tags) | ||||
1407 | { | ||||
1408 | TAG_ENTRY *temp_tag; | ||||
1409 | char *tem1, *tem2; | ||||
1410 | |||||
1411 | input_filename = tags->filename; | ||||
1412 | line_number = tags->line_no; | ||||
1413 | |||||
1414 | /* If this is a "no warn" node, don't validate it in any way. */ | ||||
1415 | if (tags->flags & TAG_FLAG_NO_WARN8) | ||||
1416 | { | ||||
1417 | tags = tags->next_ent; | ||||
1418 | continue; | ||||
1419 | } | ||||
1420 | |||||
1421 | /* If this node has a Next, then make sure that the Next exists. */ | ||||
1422 | if (tags->next) | ||||
1423 | { | ||||
1424 | validate (tags->next, tags->line_no, _("Next")((const char *) ("Next"))); | ||||
1425 | |||||
1426 | /* If the Next node exists, and there is no Up, then make sure | ||||
1427 | that the Prev of the Next points back. But do nothing if | ||||
1428 | we aren't supposed to issue warnings about this node. */ | ||||
1429 | temp_tag = find_node (tags->next); | ||||
1430 | if (temp_tag && !(temp_tag->flags & TAG_FLAG_NO_WARN8)) | ||||
1431 | { | ||||
1432 | char *prev = temp_tag->prev; | ||||
1433 | int you_lose = !prev || !STREQ (prev, tags->node)(strcmp (prev, tags->node) == 0); | ||||
1434 | |||||
1435 | if (you_lose && expensive_validation) | ||||
1436 | { | ||||
1437 | tem1 = expand_node_name (prev); | ||||
1438 | tem2 = expand_node_name (tags->node); | ||||
1439 | |||||
1440 | if (tem1 && tem2 && STREQ (tem1, tem2)(strcmp (tem1, tem2) == 0)) | ||||
1441 | you_lose = 0; | ||||
1442 | free (tem1); | ||||
1443 | free (tem2); | ||||
1444 | } | ||||
1445 | if (you_lose) | ||||
1446 | { | ||||
1447 | line_error (_("Next field of node `%s' not pointed to (perhaps incorrect sectioning?)")((const char *) ("Next field of node `%s' not pointed to (perhaps incorrect sectioning?)" )), | ||||
1448 | tags->node); | ||||
1449 | file_line_error (temp_tag->filename, temp_tag->line_no, | ||||
1450 | _("This node (%s) has the bad Prev")((const char *) ("This node (%s) has the bad Prev")), | ||||
1451 | temp_tag->node); | ||||
1452 | temp_tag->flags |= TAG_FLAG_PREV_ERROR1; | ||||
1453 | } | ||||
1454 | } | ||||
1455 | } | ||||
1456 | |||||
1457 | /* Validate the Prev field if there is one, and we haven't already | ||||
1458 | complained about it in some way. You don't have to have a Prev | ||||
1459 | field at this stage. */ | ||||
1460 | if (!(tags->flags & TAG_FLAG_PREV_ERROR1) && tags->prev) | ||||
1461 | { | ||||
1462 | int valid_p = validate (tags->prev, tags->line_no, _("Prev")((const char *) ("Prev"))); | ||||
1463 | |||||
1464 | if (!valid_p) | ||||
1465 | tags->flags |= TAG_FLAG_PREV_ERROR1; | ||||
1466 | else | ||||
1467 | { /* If the Prev field is not the same as the Up field, | ||||
1468 | then the node pointed to by the Prev field must have | ||||
1469 | a Next field which points to this node. */ | ||||
1470 | int prev_equals_up = !tags->up || STREQ (tags->prev, tags->up)(strcmp (tags->prev, tags->up) == 0); | ||||
1471 | |||||
1472 | if (!prev_equals_up && expensive_validation) | ||||
1473 | { | ||||
1474 | tem1 = expand_node_name (tags->prev); | ||||
1475 | tem2 = expand_node_name (tags->up); | ||||
1476 | prev_equals_up = STREQ (tem1, tem2)(strcmp (tem1, tem2) == 0); | ||||
1477 | free (tem1); | ||||
1478 | free (tem2); | ||||
1479 | } | ||||
1480 | if (!prev_equals_up) | ||||
1481 | { | ||||
1482 | temp_tag = find_node (tags->prev); | ||||
1483 | |||||
1484 | /* If we aren't supposed to issue warnings about the | ||||
1485 | target node, do nothing. */ | ||||
1486 | if (!temp_tag || (temp_tag->flags & TAG_FLAG_NO_WARN8)) | ||||
1487 | /* Do nothing. */ ; | ||||
1488 | else | ||||
1489 | { | ||||
1490 | int you_lose = !temp_tag->next | ||||
1491 | || !STREQ (temp_tag->next, tags->node)(strcmp (temp_tag->next, tags->node) == 0); | ||||
1492 | |||||
1493 | if (temp_tag->next && you_lose && expensive_validation) | ||||
1494 | { | ||||
1495 | tem1 = expand_node_name (temp_tag->next); | ||||
1496 | tem2 = expand_node_name (tags->node); | ||||
1497 | if (STREQ (tem1, tem2)(strcmp (tem1, tem2) == 0)) | ||||
1498 | you_lose = 0; | ||||
1499 | free (tem1); | ||||
1500 | free (tem2); | ||||
1501 | } | ||||
1502 | if (you_lose) | ||||
1503 | { | ||||
1504 | line_error | ||||
1505 | (_("Prev field of node `%s' not pointed to")((const char *) ("Prev field of node `%s' not pointed to")), | ||||
1506 | tags->node); | ||||
1507 | file_line_error (temp_tag->filename, | ||||
1508 | temp_tag->line_no, | ||||
1509 | _("This node (%s) has the bad Next")((const char *) ("This node (%s) has the bad Next")), | ||||
1510 | temp_tag->node); | ||||
1511 | temp_tag->flags |= TAG_FLAG_NEXT_ERROR2; | ||||
1512 | } | ||||
1513 | } | ||||
1514 | } | ||||
1515 | } | ||||
1516 | } | ||||
1517 | |||||
1518 | if (!tags->up | ||||
1519 | && !(tags->flags & TAG_FLAG_ANCHOR32) | ||||
1520 | && strcasecmp (tags->node, "Top") != 0) | ||||
1521 | line_error (_("`%s' has no Up field (perhaps incorrect sectioning?)")((const char *) ("`%s' has no Up field (perhaps incorrect sectioning?)" )), tags->node); | ||||
1522 | else if (tags->up) | ||||
1523 | { | ||||
1524 | int valid_p = validate (tags->up, tags->line_no, _("Up")((const char *) ("Up"))); | ||||
1525 | |||||
1526 | /* If node X has Up: Y, then warn if Y fails to have a menu item | ||||
1527 | or note pointing at X, if Y isn't of the form "(Y)". */ | ||||
1528 | if (valid_p && *tags->up != '(') | ||||
1529 | { | ||||
1530 | NODE_REF *nref; | ||||
1531 | NODE_REF *tref = NULL((void *)0); | ||||
1532 | NODE_REF *list = node_references; | ||||
1533 | |||||
1534 | for (;;) | ||||
1535 | { | ||||
1536 | nref = find_node_reference (tags->node, list); | ||||
1537 | if (!nref) | ||||
1538 | break; | ||||
1539 | |||||
1540 | if (strcmp (nref->containing_node, tags->up) == 0) | ||||
1541 | { | ||||
1542 | if (nref->type != menu_reference) | ||||
1543 | { | ||||
1544 | tref = nref; | ||||
1545 | list = nref->next; | ||||
1546 | } | ||||
1547 | else | ||||
1548 | break; | ||||
1549 | } | ||||
1550 | list = nref->next; | ||||
1551 | } | ||||
1552 | |||||
1553 | if (!nref) | ||||
1554 | { | ||||
1555 | if (!tref && expensive_validation) | ||||
1556 | { | ||||
1557 | /* Sigh... This might be AWFULLY slow, but if | ||||
1558 | they want this feature, they'll have to pay! | ||||
1559 | We do all the loop again expanding each | ||||
1560 | containing_node reference as we go. */ | ||||
1561 | char *tags_up = expand_node_name (tags->up); | ||||
1562 | char *tem; | ||||
1563 | |||||
1564 | list = node_references; | ||||
1565 | |||||
1566 | for (;;) | ||||
1567 | { | ||||
1568 | nref = find_node_reference (tags->node, list); | ||||
1569 | if (!nref) | ||||
1570 | break; | ||||
1571 | tem = expand_node_name (nref->containing_node); | ||||
1572 | if (STREQ (tem, tags_up)(strcmp (tem, tags_up) == 0)) | ||||
1573 | { | ||||
1574 | if (nref->type != menu_reference) | ||||
1575 | tref = nref; | ||||
1576 | else | ||||
1577 | { | ||||
1578 | free (tem); | ||||
1579 | break; | ||||
1580 | } | ||||
1581 | } | ||||
1582 | free (tem); | ||||
1583 | list = nref->next; | ||||
1584 | } | ||||
1585 | } | ||||
1586 | if (!nref && !tref) | ||||
1587 | { | ||||
1588 | temp_tag = find_node (tags->up); | ||||
1589 | file_line_error (temp_tag->filename, temp_tag->line_no, | ||||
1590 | _("Node `%s' lacks menu item for `%s' despite being its Up target")((const char *) ("Node `%s' lacks menu item for `%s' despite being its Up target" )), | ||||
1591 | tags->up, tags->node); | ||||
1592 | } | ||||
1593 | } | ||||
1594 | } | ||||
1595 | } | ||||
1596 | tags = tags->next_ent; | ||||
1597 | } | ||||
1598 | |||||
1599 | validate_other_references (node_references); | ||||
1600 | /* We have told the user about the references which didn't exist. | ||||
1601 | Now tell him about the nodes which aren't referenced. */ | ||||
1602 | |||||
1603 | for (tags = tag_table; tags; tags = tags->next_ent) | ||||
1604 | { | ||||
1605 | /* If this node is a "no warn" node, do nothing. */ | ||||
1606 | if (tags->flags & TAG_FLAG_NO_WARN8) | ||||
1607 | { | ||||
1608 | tags = tags->next_ent; | ||||
1609 | continue; | ||||
1610 | } | ||||
1611 | |||||
1612 | /* Special hack. If the node in question appears to have | ||||
1613 | been referenced more than REFERENCE_WARNING_LIMIT times, | ||||
1614 | give a warning. */ | ||||
1615 | if (tags->touched > reference_warning_limit) | ||||
1616 | { | ||||
1617 | input_filename = tags->filename; | ||||
1618 | line_number = tags->line_no; | ||||
1619 | warning (_("node `%s' has been referenced %d times")((const char *) ("node `%s' has been referenced %d times")), | ||||
1620 | tags->node, tags->touched); | ||||
1621 | } | ||||
1622 | |||||
1623 | if (tags->touched == 0) | ||||
1624 | { | ||||
1625 | input_filename = tags->filename; | ||||
1626 | line_number = tags->line_no; | ||||
1627 | |||||
1628 | /* Notice that the node "Top" is special, and doesn't have to | ||||
1629 | be referenced. Anchors don't have to be referenced | ||||
1630 | either, you might define them for another document. */ | ||||
1631 | if (strcasecmp (tags->node, "Top") != 0 | ||||
1632 | && !(tags->flags & TAG_FLAG_ANCHOR32)) | ||||
1633 | warning (_("unreferenced node `%s'")((const char *) ("unreferenced node `%s'")), tags->node); | ||||
1634 | } | ||||
1635 | } | ||||
1636 | input_filename = old_input_filename; | ||||
1637 | } | ||||
1638 | |||||
1639 | |||||
1640 | /* Splitting */ | ||||
1641 | |||||
1642 | /* Return true if the tag entry pointed to by TAGS is the last node. | ||||
1643 | This means only anchors follow. */ | ||||
1644 | |||||
1645 | static int | ||||
1646 | last_node_p (TAG_ENTRY *tags) | ||||
1647 | { | ||||
1648 | int last = 1; | ||||
1649 | while (tags->next_ent) { | ||||
1650 | tags = tags->next_ent; | ||||
1651 | if (tags->flags & TAG_FLAG_ANCHOR32) | ||||
1652 | ; | ||||
1653 | else | ||||
1654 | { | ||||
1655 | last = 0; | ||||
1656 | break; | ||||
1657 | } | ||||
1658 | } | ||||
1659 | |||||
1660 | return last; | ||||
1661 | } | ||||
1662 | |||||
1663 | |||||
1664 | static char * | ||||
1665 | enumerate_filename (char *pathname, char *basename, int number) | ||||
1666 | { | ||||
1667 | /* Do we need to generate names of subfiles which don't exceed 8+3 limits? */ | ||||
1668 | const int dos_file_names = !HAVE_LONG_FILENAMES (pathname ? pathname : ".")(1); | ||||
1669 | unsigned name_len = strlen (basename); | ||||
1670 | char *filename = xmalloc (10 + strlen (pathname) + name_len); | ||||
1671 | char *base_filename = xmalloc (10 + name_len); | ||||
1672 | |||||
1673 | sprintf (base_filename, "%s-%d", basename, number); | ||||
1674 | |||||
1675 | if (dos_file_names) | ||||
1676 | { | ||||
1677 | char *dot = strchr (base_filename, '.'); | ||||
1678 | unsigned base_len = strlen (base_filename); | ||||
1679 | |||||
1680 | if (dot) | ||||
1681 | { /* Make foobar.i1, .., foobar.i99, foobar.100, ... */ | ||||
1682 | dot[1] = 'i'; | ||||
1683 | memmove (number <= 99 ? dot + 2 : dot + 1, | ||||
1684 | base_filename + name_len + 1, | ||||
1685 | strlen (base_filename + name_len + 1) + 1); | ||||
1686 | } | ||||
1687 | else if (base_len > 8) | ||||
1688 | { | ||||
1689 | /* Make foobar-1, .., fooba-10, .., foob-100, ... */ | ||||
1690 | unsigned numlen = base_len - name_len; | ||||
1691 | |||||
1692 | memmove (base_filename + 8 - numlen, base_filename + name_len, numlen + 1); | ||||
1693 | } | ||||
1694 | } | ||||
1695 | |||||
1696 | sprintf (filename, "%s%s", pathname, base_filename); | ||||
1697 | |||||
1698 | return filename; | ||||
1699 | } | ||||
1700 | |||||
1701 | /* Remove previously split files, to avoid | ||||
1702 | lingering parts of shrinked documents. */ | ||||
1703 | void | ||||
1704 | clean_old_split_files (char *filename) | ||||
1705 | { | ||||
1706 | char *root_filename = filename_part (filename); | ||||
1707 | char *root_pathname = pathname_part (filename); | ||||
1708 | int i; | ||||
1709 | |||||
1710 | /* We break as soon as we hit an inexistent file, | ||||
1711 | so looping until large numbers is harmless. */ | ||||
1712 | for (i = 1; i < 1000; i++) | ||||
1713 | { | ||||
1714 | struct stat st; | ||||
1715 | char *check_file = enumerate_filename (root_pathname, root_filename, i); | ||||
1716 | |||||
1717 | if (stat (check_file, &st) != 0) | ||||
1718 | break; | ||||
1719 | else if (!S_ISDIR (st.st_mode)((st.st_mode & 0170000) == 0040000)) | ||||
1720 | { | ||||
1721 | /* Give feedback if requested, removing a file is important. */ | ||||
1722 | if (verbose_mode) | ||||
1723 | printf (_("Removing %s\n")((const char *) ("Removing %s\n")), check_file); | ||||
1724 | |||||
1725 | /* Warn user that we cannot remove the file. */ | ||||
1726 | if (unlink (check_file) != 0) | ||||
1727 | warning (_("Can't remove file `%s': %s")((const char *) ("Can't remove file `%s': %s")), check_file, strerror (errno(*__errno()))); | ||||
1728 | } | ||||
1729 | |||||
1730 | free (check_file); | ||||
1731 | } | ||||
1732 | } | ||||
1733 | |||||
1734 | |||||
1735 | /* Split large output files into a series of smaller files. Each file | ||||
1736 | is pointed to in the tag table, which then gets written out as the | ||||
1737 | original file. The new files have the same name as the original file | ||||
1738 | with a "-num" attached. SIZE is the largest number of bytes to allow | ||||
1739 | in any single split file. */ | ||||
1740 | void | ||||
1741 | split_file (char *filename, int size) | ||||
1742 | { | ||||
1743 | char *root_filename, *root_pathname; | ||||
1744 | char *the_file; | ||||
1745 | struct stat fileinfo; | ||||
1746 | long file_size; | ||||
1747 | char *the_header; | ||||
1748 | int header_size; | ||||
1749 | |||||
1750 | /* Can only do this to files with tag tables. */ | ||||
1751 | if (!tag_table) | ||||
1752 | return; | ||||
1753 | |||||
1754 | if (size == 0) | ||||
1755 | size = DEFAULT_SPLIT_SIZE300000; | ||||
1756 | |||||
1757 | if ((stat (filename, &fileinfo) != 0) | ||||
1758 | || (((long) fileinfo.st_size) < size)) | ||||
1759 | return; | ||||
1760 | file_size = (long) fileinfo.st_size; | ||||
1761 | |||||
1762 | the_file = find_and_load (filename, 0); | ||||
1763 | if (!the_file) | ||||
1764 | return; | ||||
1765 | |||||
1766 | root_filename = filename_part (filename); | ||||
1767 | root_pathname = pathname_part (filename); | ||||
1768 | |||||
1769 | if (!root_pathname) | ||||
1770 | root_pathname = xstrdup (""); | ||||
1771 | |||||
1772 | /* Start splitting the file. Walk along the tag table | ||||
1773 | outputting sections of the file. When we have written | ||||
1774 | all of the nodes in the tag table, make the top-level | ||||
1775 | pointer file, which contains indirect pointers and | ||||
1776 | tags for the nodes. */ | ||||
1777 | { | ||||
1778 | int which_file = 1; | ||||
1779 | TAG_ENTRY *tags = tag_table; | ||||
1780 | char *indirect_info = NULL((void *)0); | ||||
1781 | |||||
1782 | /* Maybe we want a Local Variables section. */ | ||||
1783 | char *trailer = info_trailer (); | ||||
1784 | int trailer_len = trailer ? strlen (trailer) : 0; | ||||
1785 | |||||
1786 | /* Remember the `header' of this file. The first tag in the file is | ||||
1787 | the bottom of the header; the top of the file is the start. */ | ||||
1788 | the_header = xmalloc (1 + (header_size = tags->position)); | ||||
1789 | memcpy (the_header, the_file, header_size); | ||||
1790 | |||||
1791 | while (tags) | ||||
1792 | { | ||||
1793 | int file_top, file_bot, limit; | ||||
1794 | |||||
1795 | /* Have to include the Control-_. */ | ||||
1796 | file_top = file_bot = tags->position; | ||||
1797 | limit = file_top + size; | ||||
1798 | |||||
1799 | /* If the rest of this file is only one node, then | ||||
1800 | that is the entire subfile. */ | ||||
1801 | if (last_node_p (tags)) | ||||
1802 | { | ||||
1803 | int i = tags->position + 1; | ||||
1804 | char last_char = the_file[i]; | ||||
1805 | |||||
1806 | while (i < file_size) | ||||
1807 | { | ||||
1808 | if ((the_file[i] == '\037') && | ||||
1809 | ((last_char == '\n') || | ||||
1810 | (last_char == '\014'))) | ||||
1811 | break; | ||||
1812 | else | ||||
1813 | last_char = the_file[i]; | ||||
1814 | i++; | ||||
1815 | } | ||||
1816 | file_bot = i; | ||||
1817 | tags = tags->next_ent; | ||||
1818 | goto write_region; | ||||
1819 | } | ||||
1820 | |||||
1821 | /* Otherwise, find the largest number of nodes that can fit in | ||||
1822 | this subfile. */ | ||||
1823 | for (; tags; tags = tags->next_ent) | ||||
1824 | { | ||||
1825 | if (last_node_p (tags)) | ||||
1826 | { | ||||
1827 | /* This entry is the last node. Search forward for the end | ||||
1828 | of this node, and that is the end of this file. */ | ||||
1829 | int i = tags->position + 1; | ||||
1830 | char last_char = the_file[i]; | ||||
1831 | |||||
1832 | while (i < file_size) | ||||
1833 | { | ||||
1834 | if ((the_file[i] == '\037') && | ||||
1835 | ((last_char == '\n') || | ||||
1836 | (last_char == '\014'))) | ||||
1837 | break; | ||||
1838 | else | ||||
1839 | last_char = the_file[i]; | ||||
1840 | i++; | ||||
1841 | } | ||||
1842 | file_bot = i; | ||||
1843 | |||||
1844 | if (file_bot < limit) | ||||
1845 | { | ||||
1846 | tags = tags->next_ent; | ||||
1847 | goto write_region; | ||||
1848 | } | ||||
1849 | else | ||||
1850 | { | ||||
1851 | /* Here we want to write out everything before the last | ||||
1852 | node, and then write the last node out in a file | ||||
1853 | by itself. */ | ||||
1854 | file_bot = tags->position; | ||||
1855 | goto write_region; | ||||
1856 | } | ||||
1857 | } | ||||
1858 | |||||
1859 | /* Write region only if this was a node, not an anchor. */ | ||||
1860 | if (tags->next_ent->position > limit | ||||
1861 | && !(tags->flags & TAG_FLAG_ANCHOR32)) | ||||
1862 | { | ||||
1863 | if (tags->position == file_top) | ||||
1864 | tags = tags->next_ent; | ||||
1865 | |||||
1866 | file_bot = tags->position; | ||||
1867 | |||||
1868 | write_region: | ||||
1869 | { | ||||
1870 | int fd; | ||||
1871 | char *split_filename = enumerate_filename (root_pathname, | ||||
1872 | root_filename, which_file); | ||||
1873 | char *split_basename = filename_part (split_filename); | ||||
1874 | |||||
1875 | fd = open (split_filename, O_WRONLY0x0001|O_TRUNC0x0400|O_CREAT0x0200, 0666); | ||||
1876 | if (fd < 0 | ||||
1877 | || write (fd, the_header, header_size) != header_size | ||||
1878 | || write (fd, the_file + file_top, file_bot - file_top) | ||||
1879 | != (file_bot - file_top) | ||||
1880 | || (trailer_len | ||||
1881 | && write (fd, trailer, trailer_len) != trailer_len) | ||||
1882 | || close (fd) < 0) | ||||
1883 | { | ||||
1884 | perror (split_filename); | ||||
1885 | if (fd != -1) | ||||
1886 | close (fd); | ||||
1887 | xexit (1); | ||||
1888 | } | ||||
1889 | |||||
1890 | if (!indirect_info) | ||||
1891 | { | ||||
1892 | indirect_info = the_file + file_top; | ||||
1893 | sprintf (indirect_info, "\037\nIndirect:\n"); | ||||
1894 | indirect_info += strlen (indirect_info); | ||||
1895 | } | ||||
1896 | |||||
1897 | sprintf (indirect_info, "%s: %d\n", | ||||
1898 | split_basename, file_top); | ||||
1899 | |||||
1900 | free (split_basename); | ||||
1901 | free (split_filename); | ||||
1902 | indirect_info += strlen (indirect_info); | ||||
1903 | which_file++; | ||||
1904 | break; | ||||
1905 | } | ||||
1906 | } | ||||
1907 | } | ||||
1908 | } | ||||
1909 | |||||
1910 | /* We have successfully created the subfiles. Now write out the | ||||
1911 | original again. We must use `output_stream', or | ||||
1912 | write_tag_table_indirect () won't know where to place the output. */ | ||||
1913 | output_stream = fopen (filename, "w"); | ||||
1914 | if (!output_stream) | ||||
1915 | { | ||||
1916 | perror (filename); | ||||
1917 | xexit (1); | ||||
1918 | } | ||||
1919 | |||||
1920 | { | ||||
1921 | int distance = indirect_info - the_file; | ||||
1922 | fwrite (the_file, 1, distance, output_stream); | ||||
1923 | |||||
1924 | /* Inhibit newlines. */ | ||||
1925 | paragraph_is_open = 0; | ||||
1926 | |||||
1927 | /* Write the indirect tag table. */ | ||||
1928 | write_tag_table_indirect (); | ||||
1929 | |||||
1930 | /* preserve local variables in info output. */ | ||||
1931 | if (trailer) | ||||
1932 | { | ||||
1933 | fwrite (trailer, 1, trailer_len, output_stream); | ||||
1934 | free (trailer); | ||||
1935 | } | ||||
1936 | |||||
1937 | fclose (output_stream); | ||||
1938 | free (the_header); | ||||
1939 | free (the_file); | ||||
1940 | return; | ||||
1941 | } | ||||
1942 | } | ||||
1943 | } |