freebsd-dev/contrib/texinfo/makeinfo/sectioning.c
2000-01-17 10:39:58 +00:00

692 lines
18 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* sectioning.c -- all related stuff @chapter, @section... @contents
$Id: sectioning.c,v 1.12 1999/08/17 21:06:50 karl Exp $
Copyright (C) 1999 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
Written by Karl Heinz Marbaise <kama@hippo.fido.de>. */
#include "system.h"
#include "cmds.h"
#include "macro.h"
#include "makeinfo.h"
#include "node.h"
#include "toc.h"
#include "sectioning.h"
/* See comment in sectioning.h. */
section_alist_type section_alist[] = {
{ "unnumberedsubsubsec", 5, ENUM_SECT_NO, TOC_YES },
{ "unnumberedsubsec", 4, ENUM_SECT_NO, TOC_YES },
{ "unnumberedsec", 3, ENUM_SECT_NO, TOC_YES },
{ "unnumbered", 2, ENUM_SECT_NO, TOC_YES },
{ "appendixsubsubsec", 5, ENUM_SECT_APP, TOC_YES }, /* numbered like A.X.X.X */
{ "appendixsubsec", 4, ENUM_SECT_APP, TOC_YES },
{ "appendixsec", 3, ENUM_SECT_APP, TOC_YES },
{ "appendixsection", 3, ENUM_SECT_APP, TOC_YES },
{ "appendix", 2, ENUM_SECT_APP, TOC_YES },
{ "subsubsec", 5, ENUM_SECT_YES, TOC_YES },
{ "subsubsection", 5, ENUM_SECT_YES, TOC_YES },
{ "subsection", 4, ENUM_SECT_YES, TOC_YES },
{ "section", 3, ENUM_SECT_YES, TOC_YES },
{ "chapter", 2, ENUM_SECT_YES, TOC_YES },
{ "subsubheading", 5, ENUM_SECT_NO, TOC_NO },
{ "subheading", 4, ENUM_SECT_NO, TOC_NO },
{ "heading", 3, ENUM_SECT_NO, TOC_NO },
{ "chapheading", 2, ENUM_SECT_NO, TOC_NO },
{ "majorheading", 2, ENUM_SECT_NO, TOC_NO },
{ "top", 1, ENUM_SECT_NO, TOC_YES },
{ NULL, 0, 0, 0 }
};
/* The argument of @settitle, used for HTML. */
char *title = NULL;
#define APPENDIX_MAGIC 1024
#define UNNUMBERED_MAGIC 2048
/* Number memory for every level @chapter, @section,
@subsection, @subsubsection. */
static int numbers [] = { 0, 0, 0, 0 };
/* enum_marker == APPENDIX_MAGIC then we are counting appendencies
enum_marker == UNNUMBERED_MAGIC then we are within unnumbered area.
Handling situations like this:
@unnumbered ..
@section ... */
static int enum_marker = 0;
/* Organized by level commands. That is, "*" == chapter, "=" == section. */
static char *scoring_characters = "*=-.";
/* Amount to offset the name of sectioning commands to levels by. */
static int section_alist_offset = 0;
/* num == ENUM_SECT_NO means unnumbered (should never call this)
num == ENUM_SECT_YES means numbered
num == ENUM_SECT_APP means numbered like A.1 and so on */
char *
get_sectioning_number (level, num)
int level;
int num;
{
static char s[100]; /* should ever be enough for 99.99.99.99
Appendix A.1 */
char *p;
int i;
s[0] = 0;
/* create enumeration in front of chapter, section, subsection and so on. */
for (i = 0; i < level; i++)
{
p = s + strlen (s);
if ((i == 0) && (enum_marker == APPENDIX_MAGIC))
sprintf (p, "%c.", numbers[i] + 64); /* Should be changed to
be more portable */
else
sprintf (p, "%d.", numbers[i]);
}
/* the last number is never followed by a dot */
p = s + strlen (s);
if ((num == ENUM_SECT_APP)
&& (i == 0)
&& (enum_marker == APPENDIX_MAGIC))
sprintf (p, _("Appendix %c "), numbers[i] + 64);
else
sprintf (p, "%d ", numbers[i]);
return s;
}
/* Set the level of @top to LEVEL. Return the old level of @top. */
int
set_top_section_level (level)
int level;
{
int i, result = -1;
for (i = 0; section_alist[i].name; i++)
if (strcmp (section_alist[i].name, "top") == 0)
{
result = section_alist[i].level;
section_alist[i].level = level;
break;
}
return result;
}
/* return the index of the given sectioning command in section_alist */
int
search_sectioning (text)
char *text;
{
int i;
char *t;
/* ignore the optional command prefix */
if (text[0] == COMMAND_PREFIX)
text++;
for (i = 0; (t = section_alist[i].name); i++)
{
if (strcmp (t, text) == 0)
{
return i;
}
}
return -1;
}
/* Return an integer which identifies the type section present in TEXT. */
int
what_section (text)
char *text;
{
int index, j;
char *temp;
int return_val;
find_section_command:
for (j = 0; text[j] && cr_or_whitespace (text[j]); j++);
if (text[j] != COMMAND_PREFIX)
return -1;
text = text + j + 1;
/* We skip @c, @comment, and @?index commands. */
if ((strncmp (text, "comment", strlen ("comment")) == 0) ||
(text[0] == 'c' && cr_or_whitespace (text[1])) ||
(strcmp (text + 1, "index") == 0))
{
while (*text++ != '\n');
goto find_section_command;
}
/* Handle italicized sectioning commands. */
if (*text == 'i')
text++;
for (j = 0; text[j] && !cr_or_whitespace (text[j]); j++);
temp = xmalloc (1 + j);
strncpy (temp, text, j);
temp[j] = 0;
index = search_sectioning (temp);
free (temp);
if (index >= 0)
{
return_val = section_alist[index].level + section_alist_offset;
if (return_val < 0)
return_val = 0;
else if (return_val > 5)
return_val = 5;
return return_val;
}
return -1;
}
void
sectioning_underscore (cmd)
char *cmd;
{
char character;
char *temp;
int level;
temp = xmalloc (2 + strlen (cmd));
temp[0] = COMMAND_PREFIX;
strcpy (&temp[1], cmd);
level = what_section (temp);
free (temp);
level -= 2;
if (level < 0)
level = 0;
if (html)
sectioning_html (level, cmd);
else
{
character = scoring_characters[level];
insert_and_underscore (level, character, cmd);
}
}
/* insert_and_underscore and sectioning_html are the
only functions which call this.
I have created this, because it was exactly the same
code in both functions. */
static char *
handle_enum_increment (level, index)
int level;
int index;
{
/* special for unnumbered */
if (number_sections && section_alist[index].num == ENUM_SECT_NO)
{
if (level == 0
&& enum_marker != UNNUMBERED_MAGIC)
enum_marker = UNNUMBERED_MAGIC;
}
/* enumerate only things which are allowed */
if (number_sections && section_alist[index].num)
{
/* reset the marker if we get into enumerated areas */
if (section_alist[index].num == ENUM_SECT_YES
&& level == 0
&& enum_marker == UNNUMBERED_MAGIC)
enum_marker = 0;
/* This is special for appendix; if we got the first
time an appendix command then we are entering appendix.
Thats the point we have to start countint with A, B and so on. */
if (section_alist[index].num == ENUM_SECT_APP
&& level == 0
&& enum_marker != APPENDIX_MAGIC)
{
enum_marker = APPENDIX_MAGIC;
numbers [0] = 0; /* this means we start with Appendix A */
}
/* only increment counters if we are not in unnumbered
area. This handles situations like this:
@unnumbered .... This sets enum_marker to UNNUMBERED_MAGIC
@section .... */
if (enum_marker != UNNUMBERED_MAGIC)
{
int i;
/* reset all counters which are one level deeper */
for (i = level; i < 3; i++)
numbers [i + 1] = 0;
numbers[level]++;
return xstrdup
(get_sectioning_number (level, section_alist[index].num));
}
} /* if (number_sections)... */
return xstrdup ("");
}
/* Insert the text following input_text_offset up to the end of the line
in a new, separate paragraph. Directly underneath it, insert a
line of WITH_CHAR, the same length of the inserted text. */
void
insert_and_underscore (level, with_char, cmd)
int level;
int with_char;
char *cmd;
{
int i, len;
int index;
int old_no_indent;
unsigned char *starting_pos, *ending_pos;
char *temp;
close_paragraph ();
filling_enabled = indented_fill = 0;
old_no_indent = no_indent;
no_indent = 1;
if (macro_expansion_output_stream && !executing_string)
append_to_expansion_output (input_text_offset + 1);
get_rest_of_line (0, &temp);
starting_pos = output_paragraph + output_paragraph_offset;
index = search_sectioning (cmd);
if (index < 0)
{
/* should never happen, but a poor guy, named Murphy ... */
warning (_("Internal error (search_sectioning) \"%s\"!"), cmd);
return;
}
/* This is a bit tricky: we must produce "X.Y SECTION-NAME" in the
Info output and in TOC, but only SECTION-NAME in the macro-expanded
output. */
/* Step 1: produce "X.Y" and add it to Info output. */
add_word (handle_enum_increment (level, index));
/* Step 2: add "SECTION-NAME" to both Info and macro-expanded output. */
if (macro_expansion_output_stream && !executing_string)
{
char *temp1 = xmalloc (2 + strlen (temp));
sprintf (temp1, "%s\n", temp);
remember_itext (input_text, input_text_offset);
me_execute_string (temp1);
free (temp1);
}
else
execute_string ("%s\n", temp);
/* Step 3: pluck "X.Y SECTION-NAME" from the output buffer and
insert it into the TOC. */
ending_pos = output_paragraph + output_paragraph_offset;
if (section_alist[index].toc == TOC_YES)
toc_add_entry (substring (starting_pos, ending_pos - 1),
level, current_node, NULL);
free (temp);
len = (ending_pos - starting_pos) - 1;
for (i = 0; i < len; i++)
add_char (with_char);
insert ('\n');
close_paragraph ();
filling_enabled = 1;
no_indent = old_no_indent;
}
/* Insert the text following input_text_offset up to the end of the
line as an HTML heading element of the appropriate `level' and
tagged as an anchor for the current node.. */
void
sectioning_html (level, cmd)
int level;
char *cmd;
{
static int toc_ref_count = 0;
int index;
int old_no_indent;
unsigned char *starting_pos, *ending_pos;
char *temp, *toc_anchor = NULL;
close_paragraph ();
filling_enabled = indented_fill = 0;
old_no_indent = no_indent;
no_indent = 1;
add_word_args ("<h%d>", level + 1); /* level 0 is <h1> */
/* If we are outside of any node, produce an anchor that
the TOC could refer to. */
if (!current_node || !*current_node)
{
starting_pos = output_paragraph + output_paragraph_offset;
add_word_args ("<a name=\"TOC%d\">", toc_ref_count++);
toc_anchor = substring (starting_pos + 9,
output_paragraph + output_paragraph_offset);
}
starting_pos = output_paragraph + output_paragraph_offset;
if (macro_expansion_output_stream && !executing_string)
append_to_expansion_output (input_text_offset + 1);
get_rest_of_line (0, &temp);
index = search_sectioning (cmd);
if (index < 0)
{
/* should never happen, but a poor guy, named Murphy ... */
warning (_("Internal error (search_sectioning) \"%s\"!"), cmd);
return;
}
/* Produce "X.Y" and add it to HTML output. */
add_word (handle_enum_increment (level, index));
/* add the section name to both HTML and macro-expanded output. */
if (macro_expansion_output_stream && !executing_string)
{
remember_itext (input_text, input_text_offset);
me_execute_string (temp);
write_region_to_macro_output ("\n", 0, 1);
}
else
execute_string ("%s", temp);
ending_pos = output_paragraph + output_paragraph_offset;
/* Pluck ``X.Y SECTION-NAME'' from the output buffer and insert it
into the TOC. */
if (section_alist[index].toc == TOC_YES)
toc_add_entry (substring (starting_pos, ending_pos),
level, current_node, toc_anchor);
free (temp);
if (outstanding_node)
outstanding_node = 0;
add_word_args ("</h%d>", level+1);
close_paragraph();
filling_enabled = 1;
no_indent = old_no_indent;
}
/* Shift the meaning of @section to @chapter. */
void
cm_raisesections ()
{
discard_until ("\n");
section_alist_offset--;
}
/* Shift the meaning of @chapter to @section. */
void
cm_lowersections ()
{
discard_until ("\n");
section_alist_offset++;
}
/* The command still works, but prints a warning message in addition. */
void
cm_ideprecated (arg, start, end)
int arg, start, end;
{
warning (_("%c%s is obsolete; use %c%s instead"),
COMMAND_PREFIX, command, COMMAND_PREFIX, command + 1);
sectioning_underscore (command + 1);
}
/* Treat this just like @unnumbered. The only difference is
in node defaulting. */
void
cm_top ()
{
/* It is an error to have more than one @top. */
if (top_node_seen && strcmp (current_node, "Top") != 0)
{
TAG_ENTRY *tag = tag_table;
line_error (_("Node with %ctop as a section already exists"),
COMMAND_PREFIX);
while (tag)
{
if (tag->flags & TAG_FLAG_IS_TOP)
{
int old_line_number = line_number;
char *old_input_filename = input_filename;
line_number = tag->line_no;
input_filename = tag->filename;
line_error (_("Here is the %ctop node"), COMMAND_PREFIX);
input_filename = old_input_filename;
line_number = old_line_number;
return;
}
tag = tag->next_ent;
}
}
else
{
TAG_ENTRY *top_node = find_node ("Top");
top_node_seen = 1;
/* It is an error to use @top before you have used @node. */
if (!tag_table)
{
char *top_name;
get_rest_of_line (0, &top_name);
line_error (_("%ctop used before %cnode, defaulting to %s"),
COMMAND_PREFIX, COMMAND_PREFIX, top_name);
execute_string ("@node Top, , (dir), (dir)\n@top %s\n", top_name);
free (top_name);
return;
}
else if (html && splitting)
{
char *next = top_node ? top_node->next : NULL;
add_word ("<p>");
if (next)
{
add_word (_("Next:"));
add_word ("<a rel=next href=\"");
add_anchor_name (next, 1);
add_word ("\">");
execute_string (next);
add_word ("</a>\n");
}
}
cm_unnumbered ();
/* The most recently defined node is the top node. */
tag_table->flags |= TAG_FLAG_IS_TOP;
/* Now set the logical hierarchical level of the Top node. */
{
int orig_offset = input_text_offset;
input_text_offset = search_forward (node_search_string, orig_offset);
if (input_text_offset > 0)
{
int this_section;
/* We have encountered a non-top node, so mark that one exists. */
non_top_node_seen = 1;
/* Move to the end of this line, and find out what the
sectioning command is here. */
while (input_text[input_text_offset] != '\n')
input_text_offset++;
if (input_text_offset < input_text_length)
input_text_offset++;
this_section = what_section (input_text + input_text_offset);
/* If we found a sectioning command, then give the top section
a level of this section - 1. */
if (this_section != -1)
set_top_section_level (this_section - 1);
}
input_text_offset = orig_offset;
}
}
}
/* The remainder of the text on this line is a chapter heading. */
void
cm_chapter ()
{
sectioning_underscore ("chapter");
}
/* The remainder of the text on this line is a section heading. */
void
cm_section ()
{
sectioning_underscore ("section");
}
/* The remainder of the text on this line is a subsection heading. */
void
cm_subsection ()
{
sectioning_underscore ("subsection");
}
/* The remainder of the text on this line is a subsubsection heading. */
void
cm_subsubsection ()
{
sectioning_underscore ("subsubsection");
}
/* The remainder of the text on this line is an unnumbered heading. */
void
cm_unnumbered ()
{
sectioning_underscore ("unnumbered");
}
/* The remainder of the text on this line is an unnumbered section heading. */
void
cm_unnumberedsec ()
{
sectioning_underscore ("unnumberedsec");
}
/* The remainder of the text on this line is an unnumbered
subsection heading. */
void
cm_unnumberedsubsec ()
{
sectioning_underscore ("unnumberedsubsec");
}
/* The remainder of the text on this line is an unnumbered
subsubsection heading. */
void
cm_unnumberedsubsubsec ()
{
sectioning_underscore ("unnumberedsubsubsec");
}
/* The remainder of the text on this line is an appendix heading. */
void
cm_appendix ()
{
sectioning_underscore ("appendix");
}
/* The remainder of the text on this line is an appendix section heading. */
void
cm_appendixsec ()
{
sectioning_underscore ("appendixsec");
}
/* The remainder of the text on this line is an appendix subsection heading. */
void
cm_appendixsubsec ()
{
sectioning_underscore ("appendixsubsec");
}
/* The remainder of the text on this line is an appendix
subsubsection heading. */
void
cm_appendixsubsubsec ()
{
sectioning_underscore ("appendixsubsubsec");
}
/* Compatibility functions substitute for chapter, section, etc. */
void
cm_majorheading ()
{
sectioning_underscore ("majorheading");
}
void
cm_chapheading ()
{
sectioning_underscore ("chapheading");
}
void
cm_heading ()
{
sectioning_underscore ("heading");
}
void
cm_subheading ()
{
sectioning_underscore ("subheading");
}
void
cm_subsubheading ()
{
sectioning_underscore ("subsubheading");
}