/* An email reference. */
void
cm_email (int arg)
{
if (arg == START)
{
char *addr = get_xref_token (1); /* expands all macros in email */
char *name = get_xref_token (0);
if (xml && docbook)
{
xml_insert_element_with_attribute (EMAIL, START, "url=\"mailto:%s\"", addr);
if (*name)
execute_string ("%s", name);
xml_insert_element (EMAIL, END);
}
else if (xml)
{
xml_insert_element (EMAIL, START);
xml_insert_element (EMAILADDRESS, START);
execute_string ("%s", addr);
xml_insert_element (EMAILADDRESS, END);
if (*name)
{
xml_insert_element (EMAILNAME, START);
execute_string ("%s", name);
xml_insert_element (EMAILNAME, END);
}
xml_insert_element (EMAIL, END);
}
else if (html)
{
add_html_elt ("<a href=");
/* don't collapse `--' etc. in the address */
in_fixed_width_font++;
execute_string ("\"mailto:%s\"", addr);
in_fixed_width_font--;
add_word (">");
execute_string ("%s", *name ? name : addr);
add_word ("</a>");
}
else
{
execute_string ("%s%s", name, *name ? " " : "");
in_fixed_width_font++;
execute_string ("<%s>", addr);
in_fixed_width_font--;
}
if (addr)
free (addr);
if (name)
free (name);
}
}
static void
process_defun_args (char **defun_args, int auto_var_p)
{
int pending_space = 0;
if (xml)
{
xml_process_defun_args (defun_args, auto_var_p);
return;
}
for (;;)
{
char *defun_arg = *defun_args++;
if (defun_arg == NULL)
break;
if (defun_arg[0] == ' ')
{
pending_space = 1;
continue;
}
if (pending_space)
{
add_char (' ');
pending_space = 0;
}
if (DEFUN_SELF_DELIMITING (defun_arg[0]))
{
/* Within @deffn and friends, texinfo.tex makes parentheses
sans serif and brackets bold. We use roman instead. */
if (html)
insert_html_tag (START, "");
add_char (defun_arg[0]);
if (html)
insert_html_tag (END, "");
}
/* else if (defun_arg[0] == '&' || defun_arg[0] == COMMAND_PREFIX) */
/* execute_string ("%s", defun_arg); */
/* else if (auto_var_p) */
/* execute_string ("%s", defun_arg); */
else
execute_string ("%s", defun_arg);
}
}
ehval_p EHI::parse_interactive() {
while(1) {
char *cmd = eh_getline();
if(cmd == nullptr) {
return Integer::make(0);
}
try {
execute_string(cmd);
} catch(eh_exception &e) {
handle_uncaught(e);
} catch(quit_exception &) {
return Integer::make(0);
}
}
}
/* Output the footnotes. We are at the end of the current node. */
void
output_pending_notes (void)
{
FN *footnote = pending_notes;
if (!pending_notes)
return;
if (html)
{
add_html_block_elt ("<div class=\"footnote\">\n<hr>\n");
/* We add an anchor here so @printindex can refer to this point
(as the node name) for entries defined in footnotes. */
if (!splitting)
add_word ("<a name=\"texinfo-footnotes-in-document\"></a>");
add_word_args ("<h4>%s</h4>", (char *) _("Footnotes"));
}
else
switch (footnote_style)
{
case separate_node:
{
char *old_current_node = current_node;
char *old_command = xstrdup (command);
already_outputting_pending_notes++;
execute_string ("%cnode %s-Footnotes,,,%s\n",
COMMAND_PREFIX, current_node, current_node);
already_outputting_pending_notes--;
current_node = old_current_node;
free (command);
command = old_command;
}
break;
case end_node:
close_paragraph ();
in_fixed_width_font++;
/* This string should be translated according to the
@documentlanguage, not the current LANG. We can't do that
yet, so leave it in English. */
execute_string ("---------- Footnotes ----------\n\n");
in_fixed_width_font--;
break;
}
/* Handle the footnotes in reverse order. */
{
int save_in_fixed_width_font = in_fixed_width_font;
FN **array = xmalloc ((footnote_count + 1) * sizeof (FN *));
array[footnote_count] = NULL;
while (--footnote_count > -1)
{
array[footnote_count] = footnote;
footnote = footnote->next;
}
filling_enabled = 1;
indented_fill = 1;
in_fixed_width_font = 0;
while ((footnote = array[++footnote_count]))
{
if (html)
{
/* Make the text of every footnote begin a separate paragraph. */
add_html_block_elt ("<p class=\"footnote\"><small>");
/* Make footnote number a link to its definition. */
add_word_args ("[<a name=\"fn-%d\" href=\"#fnd-%d\">%d</a>]",
footnote->number, footnote->number, footnote->number);
add_word ("</small> ");
already_outputting_pending_notes++;
execute_string ("%s", footnote->note);
already_outputting_pending_notes--;
add_word ("</p>\n");
}
else
{
char *old_current_node = current_node;
char *old_command = xstrdup (command);
already_outputting_pending_notes++;
execute_string ("%canchor{%s-Footnote-%d}(%s) %s",
COMMAND_PREFIX, current_node, footnote->number,
footnote->marker, footnote->note);
already_outputting_pending_notes--;
current_node = old_current_node;
free (command);
command = old_command;
}
close_paragraph ();
}
if (html)
add_html_block_elt ("<hr></div>");
close_paragraph ();
free (array);
in_fixed_width_font = save_in_fixed_width_font;
}
free_pending_notes ();
}
/* Handle a "footnote".
footnote *{this is a footnote}
where "*" is the (optional) marker character for this note. */
void
cm_footnote (void)
{
char *marker;
char *note;
get_until ("{", &marker);
canon_white (marker);
if (macro_expansion_output_stream && !executing_string)
append_to_expansion_output (input_text_offset + 1); /* include the { */
/* Read the argument in braces. */
if (curchar () != '{')
{
line_error (_("`%c%s' needs an argument `{...}', not just `%s'"),
COMMAND_PREFIX, command, marker);
free (marker);
return;
}
else
{
int len;
int braces = 1;
int loc = ++input_text_offset;
while (braces)
{
if (loc == input_text_length)
{
line_error (_("No closing brace for footnote `%s'"), marker);
return;
}
if (input_text[loc] == '{')
braces++;
else if (input_text[loc] == '}')
braces--;
else if (input_text[loc] == '\n')
line_number++;
loc++;
}
len = (loc - input_text_offset) - 1;
note = xmalloc (len + 1);
memcpy (note, &input_text[input_text_offset], len);
note[len] = 0;
input_text_offset = loc;
}
/* Must write the macro-expanded argument to the macro expansion
output stream. This is like the case in index_add_arg. */
if (macro_expansion_output_stream && !executing_string)
{
/* Calling me_execute_string on a lone } provokes an error, since
as far as the reader knows there is no matching {. We wrote
the { above in the call to append_to_expansion_output. */
me_execute_string_keep_state (note, "}");
}
if (!current_node || !*current_node)
{
line_error (_("Footnote defined without parent node"));
free (marker);
free (note);
return;
}
/* output_pending_notes is non-reentrant (it uses a global data
structure pending_notes, which it frees before it returns), and
TeX doesn't grok footnotes inside footnotes anyway. Disallow
that. */
if (already_outputting_pending_notes)
{
line_error (_("Footnotes inside footnotes are not allowed"));
free (marker);
free (note);
return;
}
if (!*marker)
{
free (marker);
if (number_footnotes)
{
marker = xmalloc (10);
sprintf (marker, "%d", current_footnote_number);
}
else
marker = xstrdup ("*");
}
if (xml)
xml_insert_footnote (note);
else
{
remember_note (marker, note);
/* fixme: html: footnote processing needs work; we currently ignore
the style requested; we could clash with a node name of the form
`fn-<n>', though that's unlikely. */
if (html)
{
/* Hyperlink also serves as an anchor (mnemonic: fnd is footnote
definition.) */
add_html_elt ("<a rel=\"footnote\" href=");
add_word_args ("\"#fn-%d\" name=\"fnd-%d\"><sup>%s</sup></a>",
current_footnote_number, current_footnote_number,
marker);
}
else
/* Your method should at least insert MARKER. */
switch (footnote_style)
{
case separate_node:
add_word_args ("(%s)", marker);
execute_string (" (*note %s-Footnote-%d::)",
current_node, current_footnote_number);
if (first_footnote_this_node)
{
char *temp_string, *expanded_ref;
temp_string = xmalloc (strlen (current_node)
+ strlen ("-Footnotes") + 1);
strcpy (temp_string, current_node);
strcat (temp_string, "-Footnotes");
expanded_ref = expansion (temp_string, 0);
remember_node_reference (expanded_ref, line_number,
followed_reference);
free (temp_string);
free (expanded_ref);
first_footnote_this_node = 0;
}
break;
case end_node:
add_word_args ("(%s)", marker);
break;
default:
break;
}
current_footnote_number++;
}
free (marker);
free (note);
}
/* Make the defun type insertion.
TYPE says which insertion this is.
X_P, if nonzero, says not to start a new insertion. */
static void
defun_internal (int type, int x_p)
{
int base_type;
char **defun_args, **scan_args;
const char *category;
char *defined_name;
char *type_name = NULL;
char *type_name2 = NULL;
{
char *line;
/* The @def.. line is the only place in Texinfo where you are
allowed to use unquoted braces that don't delimit arguments of
a command or a macro; in any other place it will trigger an
error message from the reader loop. The special handling of
this case inside `args_from_string' is an extra special hack
which allows this. The side effect is that if we try to expand
the rest of the line below, the recursive reader loop will
signal an error if there are brace-delimited arguments on that line.
The best solution to this would be to change the syntax of
@def.. commands so that it doesn't violate Texinfo's own rules.
But it's probably too late for this now, as it will break a lot
of existing manuals.
Unfortunately, this means that you can't call macros, use @value, etc.
inside @def.. commands, sigh. */
get_rest_of_line (0, &line);
/* Basic line continuation. If a line ends with \s*@\s* concatanate
the next line. */
{
char *next_line, *new_line;
int i;
line_continuation:
i = strlen (line) - 1;
if (line[i] == '@' && line[i-1] != '@')
{
get_rest_of_line (0, &next_line);
new_line = (char *) xmalloc (i + strlen (next_line) + 2);
strncpy (new_line, line, i);
new_line[i] = '\0';
free (line);
strcat (new_line, " ");
strcat (new_line, next_line);
line = xstrdup (new_line);
free (next_line);
free (new_line);
goto line_continuation;
}
}
defun_args = (args_from_string (line));
free (line);
}
scan_args = defun_args;
/* Get base type and category string. */
base_type = get_base_type (type);
/* xx all these const strings should be determined upon
documentlanguage argument and NOT via gettext (kama). */
switch (type)
{
case defun:
case deftypefun:
category = _("Function");
break;
case defmac:
category = _("Macro");
break;
case defspec:
category = _("Special Form");
break;
case defvar:
case deftypevar:
category = _("Variable");
break;
case defopt:
category = _("User Option");
break;
case defivar:
case deftypeivar:
category = _("Instance Variable");
break;
case defmethod:
case deftypemethod:
category = _("Method");
break;
default:
category = next_nonwhite_defun_arg (&scan_args);
break;
}
/* The class name. */
if ((base_type == deftypecv)
|| (base_type == deftypefn)
|| (base_type == deftypevr)
|| (base_type == defcv)
|| (base_type == defop)
|| (base_type == deftypeivar)
|| (base_type == deftypemethod)
|| (base_type == deftypeop)
)
type_name = next_nonwhite_defun_arg (&scan_args);
/* The type name for typed languages. */
if ((base_type == deftypecv)
|| (base_type == deftypeivar)
|| (base_type == deftypemethod)
|| (base_type == deftypeop)
)
type_name2 = next_nonwhite_defun_arg (&scan_args);
/* The function or whatever that's actually being defined. */
defined_name = next_nonwhite_defun_arg (&scan_args);
/* This hack exists solely for the purposes of formatting the Texinfo
manual. I couldn't think of a better way. The token might be a
simple @@ followed immediately by more text. If this is the case,
then the next defun arg is part of this one, and we should
concatenate them. */
if (*scan_args && **scan_args && !whitespace (**scan_args)
&& STREQ (defined_name, "@@"))
{
char *tem = xmalloc (3 + strlen (scan_args[0]));
sprintf (tem, "@@%s", scan_args[0]);
free (scan_args[0]);
scan_args[0] = tem;
scan_args++;
defined_name = tem;
}
/* It's easy to write @defun foo(arg1 arg2), but a following ( is
misparsed by texinfo.tex and this is next to impossible to fix.
Warn about it. */
if (*scan_args && **scan_args && **scan_args == '(')
warning ("`%c' follows defined name `%s' instead of whitespace",
**scan_args, defined_name);
if (!x_p)
begin_insertion (type);
/* Write the definition header line.
This should start at the normal indentation. */
current_indent -= default_indentation_increment;
start_paragraph ();
if (!html && !xml)
switch (base_type)
{
case deffn:
case defvr:
case deftp:
execute_string (" --- %s: %s", category, defined_name);
break;
case deftypefn:
case deftypevr:
execute_string (" --- %s: %s %s", category, type_name, defined_name);
break;
case defcv:
execute_string (" --- %s %s %s: %s", category, _("of"), type_name,
defined_name);
break;
case deftypecv:
case deftypeivar:
execute_string (" --- %s %s %s: %s %s", category, _("of"), type_name,
type_name2, defined_name);
break;
case defop:
execute_string (" --- %s %s %s: %s", category, _("on"), type_name,
defined_name);
break;
case deftypeop:
execute_string (" --- %s %s %s: %s %s", category, _("on"), type_name,
type_name2, defined_name);
break;
case deftypemethod:
execute_string (" --- %s %s %s: %s %s", category, _("on"), type_name,
type_name2, defined_name);
break;
}
else if (html)
{
/* If this is not a @def...x version, it could only
be a normal version @def.... So start the table here. */
if (!x_p)
insert_string ("<div class=\"defun\">\n");
else
rollback_empty_tag ("blockquote");
/* xx The single words (on, off) used here, should depend on
documentlanguage and NOT on gettext --kama. */
switch (base_type)
{
case deffn:
case defvr:
case deftp:
case deftypefn:
case deftypevr:
execute_string ("--- %s: ", category);
break;
case defcv:
case deftypecv:
case deftypeivar:
execute_string ("--- %s %s %s: ", category, _("of"), type_name);
break;
case defop:
case deftypemethod:
case deftypeop:
execute_string ("--- %s %s %s: ", category, _("on"), type_name);
break;
} /* switch (base_type)... */
switch (base_type)
{
case deffn:
case defvr:
case deftp:
/* <var> is for the following function arguments. */
insert_html_tag (START, "b");
execute_string ("%s", defined_name);
insert_html_tag (END, "b");
insert_html_tag (START, "var");
break;
case deftypefn:
case deftypevr:
execute_string ("%s ", type_name);
insert_html_tag (START, "b");
execute_string ("%s", defined_name);
insert_html_tag (END, "b");
insert_html_tag (START, "var");
break;
case defcv:
case defop:
insert_html_tag (START, "b");
execute_string ("%s", defined_name);
insert_html_tag (END, "b");
insert_html_tag (START, "var");
break;
case deftypecv:
case deftypeivar:
case deftypemethod:
case deftypeop:
execute_string ("%s ", type_name2);
insert_html_tag (START, "b");
execute_string ("%s", defined_name);
insert_html_tag (END, "b");
insert_html_tag (START, "var");
break;
}
}
else if (xml)
xml_begin_def_term (base_type, category, defined_name, type_name,
type_name2);
current_indent += default_indentation_increment;
/* Now process the function arguments, if any. If these carry onto
the next line, they should be indented by two increments to
distinguish them from the body of the definition, which is indented
by one increment. */
current_indent += default_indentation_increment;
switch (base_type)
{
case deffn:
case defop:
process_defun_args (scan_args, 1);
break;
/* Through Makeinfo 1.67 we processed remaining args only for deftp,
deftypefn, and deftypemethod. But the libc manual, for example,
needs to say:
@deftypevar {char *} tzname[2]
And simply allowing the extra text seems far simpler than trying
to invent yet more defn commands. In any case, we should either
output it or give an error, not silently ignore it. */
default:
process_defun_args (scan_args, 0);
break;
}
current_indent -= default_indentation_increment;
if (!html)
close_single_paragraph ();
/* Make an entry in the appropriate index. (XML and
Docbook already got their entries, so skip them.) */
if (!xml)
switch (base_type)
{
case deffn:
case deftypefn:
execute_string ("@findex %s\n", defined_name);
break;
case defcv:
case deftypecv:
case deftypevr:
case defvr:
execute_string ("@vindex %s\n", defined_name);
break;
case deftypeivar:
execute_string ("@vindex %s %s %s\n", defined_name, _("of"),
type_name);
break;
case defop:
case deftypeop:
case deftypemethod:
execute_string ("@findex %s %s %s\n", defined_name, _("on"),
type_name);
break;
case deftp:
execute_string ("@tindex %s\n", defined_name);
break;
}
if (xml)
xml_end_def_term ();
else if (html)
{
inhibit_paragraph_indentation = 1;
no_indent = 1;
insert_html_tag (END, "var");
insert_string ("<br>\n");
/* Indent the definition a bit. */
add_html_block_elt ("<blockquote>");
no_indent = 0;
inhibit_paragraph_indentation = 0;
paragraph_is_open = 0;
}
/* Deallocate the token list. */
scan_args = defun_args;
while (1)
{
char * arg = (*scan_args++);
if (arg == NULL)
break;
free (arg);
}
free (defun_args);
}
/* A URL reference. */
void
cm_uref (int arg)
{
if (arg == START)
{
extern int printing_index;
char *url = get_xref_token (1); /* expands all macros in uref */
char *desc = get_xref_token (0);
char *replacement = get_xref_token (0);
if (docbook)
{
xml_insert_element_with_attribute (UREF, START, "url=\"%s\"",
text_expansion (url));
if (*replacement)
execute_string ("%s", replacement);
else if (*desc)
execute_string ("%s", desc);
else
execute_string ("%s", url);
xml_insert_element (UREF, END);
}
else if (xml)
{
xml_insert_element (UREF, START);
xml_insert_element (UREFURL, START);
execute_string ("%s", url);
xml_insert_element (UREFURL, END);
if (*desc)
{
xml_insert_element (UREFDESC, START);
execute_string ("%s", desc);
xml_insert_element (UREFDESC, END);
}
if (*replacement)
{
xml_insert_element (UREFREPLACEMENT, START);
execute_string ("%s", replacement);
xml_insert_element (UREFREPLACEMENT, END);
}
xml_insert_element (UREF, END);
}
else if (html)
{ /* never need to show the url */
add_html_elt ("<a href=");
/* don't collapse `--' etc. in the url */
in_fixed_width_font++;
execute_string ("\"%s\"", url);
in_fixed_width_font--;
add_word (">");
execute_string ("%s", *replacement ? replacement
: (*desc ? desc : url));
add_word ("</a>");
}
else if (*replacement) /* do not show the url */
execute_string ("%s", replacement);
else if (*desc) /* show both text and url */
{
execute_string ("%s ", desc);
in_fixed_width_font++;
execute_string ("(%s)", url);
in_fixed_width_font--;
}
else /* no text at all, so have the url to show */
{
in_fixed_width_font++;
execute_string ("%s%s%s",
printing_index ? "" : "`",
url,
printing_index ? "" : "'");
in_fixed_width_font--;
}
if (url)
free (url);
if (desc)
free (desc);
if (replacement)
free (replacement);
}
}
void
cm_inforef (int arg)
{
if (arg == START)
{
char *node = get_xref_token (1); /* expands all macros in inforef */
char *pname = get_xref_token (0);
char *file = get_xref_token (0);
/* (see comments at cm_xref). */
if (!*node)
line_error (_("First argument to @inforef may not be empty"));
if (xml && !docbook)
{
xml_insert_element (INFOREF, START);
xml_insert_element (INFOREFNODENAME, START);
execute_string ("%s", node);
xml_insert_element (INFOREFNODENAME, END);
if (*pname)
{
xml_insert_element (INFOREFREFNAME, START);
execute_string ("%s", pname);
xml_insert_element (INFOREFREFNAME, END);
}
xml_insert_element (INFOREFINFONAME, START);
execute_string ("%s", file);
xml_insert_element (INFOREFINFONAME, END);
xml_insert_element (INFOREF, END);
}
else if (html)
{
char *tem;
add_word ((char *) _("see "));
/* html fixxme: revisit this */
add_html_elt ("<a href=");
if (splitting)
execute_string ("\"../%s/", file);
else
execute_string ("\"%s.html", file);
tem = expansion (node, 0);
add_anchor_name (tem, 1);
add_word ("\">");
execute_string ("%s", *pname ? pname : tem);
add_word ("</a>");
free (tem);
}
else
{
if (*pname)
execute_string ("*note %s: (%s)%s", pname, file, node);
else
execute_string ("*note (%s)%s::", file, node);
}
free (node);
free (pname);
free (file);
}
}
/* Make a cross reference. */
void
cm_xref (int arg)
{
if (arg == START)
{
char *arg1 = get_xref_token (1); /* expands all macros in xref */
char *arg2 = get_xref_token (0);
char *arg3 = get_xref_token (0);
char *arg4 = get_xref_token (0);
char *arg5 = get_xref_token (0);
char *tem;
/* "@xref{,Foo,, Bar, Baz} is not valid usage of @xref. The
first argument must never be blank." --rms.
We hereby comply by disallowing such constructs. */
if (!*arg1)
line_error (_("First argument to cross-reference may not be empty"));
if (docbook)
{
if (!ref_flag)
add_word (px_ref_flag || printing_index
? (char *) _("see ") : (char *) _("See "));
if (!*arg4 && !*arg5)
{
char *arg1_id = xml_id (arg1);
if (*arg2 || *arg3)
{
xml_insert_element_with_attribute (XREFNODENAME, START,
"linkend=\"%s\"", arg1_id);
free (arg1_id);
execute_string ("%s", *arg3 ? arg3 : arg2);
xml_insert_element (XREFNODENAME, END);
}
else
{
xml_insert_element_with_attribute (XREF, START,
"linkend=\"%s\"", arg1_id);
xml_insert_element (XREF, END);
free (arg1_id);
}
}
else if (*arg5)
{
add_word_args (_("See section ``%s'' in "), *arg3 ? arg3 : arg1);
xml_insert_element (CITE, START);
add_word (arg5);
xml_insert_element (CITE, END);
}
else if (*arg4)
{
/* Very sad, we are losing xrefs made to ``info only'' books. */
}
}
else if (xml)
{
if (!ref_flag)
add_word_args ("%s", px_ref_flag ? _("see ") : _("See "));
xml_insert_element (XREF, START);
xml_insert_element (XREFNODENAME, START);
execute_string ("%s", arg1);
xml_insert_element (XREFNODENAME, END);
if (*arg2)
{
xml_insert_element (XREFINFONAME, START);
execute_string ("%s", arg2);
xml_insert_element (XREFINFONAME, END);
}
if (*arg3)
{
xml_insert_element (XREFPRINTEDDESC, START);
execute_string ("%s", arg3);
xml_insert_element (XREFPRINTEDDESC, END);
}
if (*arg4)
{
xml_insert_element (XREFINFOFILE, START);
execute_string ("%s", arg4);
xml_insert_element (XREFINFOFILE, END);
}
if (*arg5)
{
xml_insert_element (XREFPRINTEDNAME, START);
execute_string ("%s", arg5);
xml_insert_element (XREFPRINTEDNAME, END);
}
xml_insert_element (XREF, END);
}
else if (html)
{
if (!ref_flag)
add_word_args ("%s", px_ref_flag ? _("see ") : _("See "));
}
else
add_word_args ("%s", px_ref_flag ? "*note " : "*Note ");
if (!xml)
{
if (*arg5 || *arg4)
{
/* arg1 - node name
arg2 - reference name
arg3 - title or topic (and reference name if arg2 is NULL)
arg4 - info file name
arg5 - printed manual title */
char *ref_name;
if (!*arg2)
{
if (*arg3)
ref_name = arg3;
else
ref_name = arg1;
}
else
ref_name = arg2;
if (html)
{ /* More to do eventually, down to Unicode
Normalization Form C. See the HTML Xref nodes in
the manual. */
char *file_arg = arg4;
add_html_elt ("<a href=");
{
/* If there's a directory part, ignore it. */
char *p = strrchr (file_arg, '/');
if (p)
file_arg = p + 1;
/* If there's a dot, make it a NULL terminator, so the
extension does not get into the way. */
p = strrchr (file_arg , '.');
if (p != NULL)
*p = 0;
}
if (! *file_arg)
warning (_("Empty file name for HTML cross reference in `%s'"),
arg4);
/* Note that if we are splitting, and the referenced
tag is an anchor rather than a node, we will
produce a reference to a file whose name is
derived from the anchor name. However, only
nodes create files, so we are referencing a
non-existent file. cm_anchor, which see, deals
with that problem. */
if (splitting)
execute_string ("\"../%s/", file_arg);
else
execute_string ("\"%s.html", file_arg);
/* Do not collapse -- to -, etc., in references. */
in_fixed_width_font++;
tem = expansion (arg1, 0); /* expand @-commands in node */
in_fixed_width_font--;
add_anchor_name (tem, 1);
free (tem);
add_word ("\">");
execute_string ("%s",ref_name);
add_word ("</a>");
}
else
{
execute_string ("%s:", ref_name);
in_fixed_width_font++;
execute_string (" (%s)%s", arg4, arg1);
add_xref_punctuation ();
in_fixed_width_font--;
}
/* Free all of the arguments found. */
if (arg1) free (arg1);
if (arg2) free (arg2);
if (arg3) free (arg3);
if (arg4) free (arg4);
if (arg5) free (arg5);
return;
}
else
remember_node_reference (arg1, line_number, followed_reference);
if (*arg3)
{
if (html)
{
add_html_elt ("<a href=\"");
in_fixed_width_font++;
tem = expansion (arg1, 0);
in_fixed_width_font--;
add_anchor_name (tem, 1);
free (tem);
add_word ("\">");
execute_string ("%s", *arg2 ? arg2 : arg3);
add_word ("</a>");
}
else
{
execute_string ("%s:", *arg2 ? arg2 : arg3);
in_fixed_width_font++;
execute_string (" %s", arg1);
add_xref_punctuation ();
in_fixed_width_font--;
}
}
else
{
if (html)
{
add_html_elt ("<a href=\"");
in_fixed_width_font++;
tem = expansion (arg1, 0);
in_fixed_width_font--;
add_anchor_name (tem, 1);
free (tem);
add_word ("\">");
if (*arg2)
execute_string ("%s", arg2);
else
{
char *fref = get_float_ref (arg1);
execute_string ("%s", fref ? fref : arg1);
free (fref);
}
add_word ("</a>");
}
else
{
if (*arg2)
{
execute_string ("%s:", arg2);
in_fixed_width_font++;
execute_string (" %s", arg1);
add_xref_punctuation ();
in_fixed_width_font--;
}
else
{
char *fref = get_float_ref (arg1);
if (fref)
{ /* Reference is being made to a float. */
execute_string ("%s:", fref);
in_fixed_width_font++;
execute_string (" %s", arg1);
add_xref_punctuation ();
in_fixed_width_font--;
}
else
{
in_fixed_width_font++;
execute_string ("%s::", arg1);
in_fixed_width_font--;
}
}
}
}
}
/* Free all of the arguments found. */
if (arg1) free (arg1);
if (arg2) free (arg2);
if (arg3) free (arg3);
if (arg4) free (arg4);
if (arg5) free (arg5);
}
else
{ /* Check that the next non-whitespace character is valid to follow
an xref (so Info readers can find the node names).
`input_text_offset' is pointing at the "}" which ended the xref
command. This is not used for @pxref or @ref, since we insert
the necessary punctuation above, if needed. */
int temp = next_nonwhitespace_character ();
if (temp == -1)
warning (_("End of file reached while looking for `.' or `,'"));
else if (temp != '.' && temp != ',')
warning (_("`.' or `,' must follow @%s, not `%c'"), command, temp);
}
}
/* Treat this just like @unnumbered. The only difference is
in node defaulting. */
void
cm_top (void)
{
/* 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)
{
file_line_error (tag->filename, tag->line_no,
_("Here is the %ctop node"), COMMAND_PREFIX);
return;
}
tag = tag->next_ent;
}
}
else
{
top_node_seen = 1;
/* It is an error to use @top before using @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;
}
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,
NULL);
/* 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;
}
}
}
void
sectioning_html (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;
/* level 0 (chapter) is <h2>, and we go down from there. */
add_html_block_elt_args ("<h%d class=\"%s\">", level + 2, cmd);
/* If we are outside of any node, produce an anchor that
the TOC could refer to. */
if (!current_node || !*current_node)
{
static const char a_name[] = "<a name=\"";
starting_pos = output_paragraph + output_paragraph_offset;
add_word_args ("%sTOC%d\">", a_name, toc_ref_count++);
toc_anchor = substring (starting_pos + sizeof (a_name) - 1,
output_paragraph + output_paragraph_offset);
/* This must be added after toc_anchor is extracted, since
toc_anchor cannot include the closing </a>. For details,
see toc.c:toc_add_entry and toc.c:contents_update_html.
Also, the anchor close must be output before the section name
in case the name itself contains an anchor. */
add_word ("</a>");
}
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);
/* Use @settitle value if @top parameter is empty. */
if (STREQ (command, "top") && strlen(temp) == 0)
temp = xstrdup (title ? title : "");
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. */
{
char *title_number = handle_enum_increment (level, index);
if (strlen (title_number) > 0)
add_word_args ("%s ", title_number);
}
/* 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 + 2);
close_paragraph();
filling_enabled = 1;
no_indent = old_no_indent;
}
/* 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 (int level, char *cmd)
{
int i, len;
int index;
int old_no_indent;
unsigned char *starting_pos, *ending_pos;
char *temp;
char with_char = scoring_characters[level];
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);
/* Use @settitle value if @top parameter is empty. */
if (STREQ (command, "top") && strlen(temp) == 0)
temp = xstrdup (title ? title : "");
starting_pos = output_paragraph + output_paragraph_offset;
/* Poor man's cache for section title. */
if (strlen (last_sectioning_title))
free (last_sectioning_title);
last_sectioning_title = xstrdup (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;
}
/* 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_args ("%s ", 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;
}
void
sectioning_underscore (char *cmd)
{
char *temp, *secname;
int level;
/* If we're not indenting the first paragraph, we shall make it behave
like @noindent is called directly after the section heading. */
if (! do_first_par_indent)
cm_noindent ();
temp = xmalloc (2 + strlen (cmd));
temp[0] = COMMAND_PREFIX;
strcpy (&temp[1], cmd);
level = what_section (temp, &secname);
level -= 2;
if (level < 0)
level = 0;
free (temp);
/* If the argument to @top is empty, we try using the one from @settitle.
Warn if both are unusable. */
if (STREQ (command, "top"))
{
int save_input_text_offset = input_text_offset;
get_rest_of_line (0, &temp);
/* Due to get_rest_of_line ... */
line_number--;
if (strlen (temp) == 0 && (!title || strlen (title) == 0))
warning ("Must specify a title with least one of @settitle or @top");
input_text_offset = save_input_text_offset;
}
if (xml)
{
/* If the section appears in the toc, it means it's a real section
unlike majorheading, chapheading etc. */
if (section_alist[search_sectioning (cmd)].toc == TOC_YES)
{
xml_close_sections (level);
/* Mark the beginning of the section
If the next command is printindex, we will remove
the section and put an Index instead */
flush_output ();
xml_last_section_output_position = output_paragraph_offset;
get_rest_of_line (0, &temp);
/* Use @settitle value if @top parameter is empty. */
if (STREQ (command, "top") && strlen(temp) == 0)
temp = xstrdup (title ? title : "");
/* Docbook does not support @unnumbered at all. So we provide numbers
that other formats use. @appendix seems to be fine though, so we let
Docbook handle that as usual. */
if (docbook && enum_marker != APPENDIX_MAGIC)
{
if (section_alist[search_sectioning (cmd)].num == ENUM_SECT_NO
&& section_alist[search_sectioning (cmd)].toc == TOC_YES)
xml_insert_element_with_attribute (xml_element (secname),
START, "label=\"%s\" xreflabel=\"%s\"",
handle_enum_increment (level, search_sectioning (cmd)),
text_expansion (temp));
else
xml_insert_element_with_attribute (xml_element (secname),
START, "label=\"%s\"",
handle_enum_increment (level, search_sectioning (cmd)));
}
else
xml_insert_element (xml_element (secname), START);
xml_insert_element (TITLE, START);
xml_open_section (level, secname);
execute_string ("%s", temp);
xml_insert_element (TITLE, END);
free (temp);
}
else
{
if (docbook)
{
if (level > 0)
xml_insert_element_with_attribute (xml_element (secname), START,
"renderas=\"sect%d\"", level);
else
xml_insert_element_with_attribute (xml_element (secname), START,
"renderas=\"other\"");
}
else
xml_insert_element (xml_element (secname), START);
get_rest_of_line (0, &temp);
execute_string ("%s", temp);
free (temp);
xml_insert_element (xml_element (secname), END);
}
}
else if (html)
sectioning_html (level, secname);
else
insert_and_underscore (level, secname);
}
int main( int argc, char *argv[])
{
//direct linked numbers - these change during runtime
double minutes, seconds;
int stack_size = 0;
char *string = NULL;
pstack_t *ex_stack;
FILE *file = fopen( READ_FILE, "r");
if( !file ) {
printf( "No file!\n");
return 1;
}
// associate direct links
runtime_vars[0].stuff.ptr = (void*)&seconds;
runtime_vars[1].stuff.ptr = (void*)&minutes;
if( read_file( file, &stack_size) == -1 )
return 1;
fclose( file);
while( 1 ) {
var_t *var;
time_t tim;
struct tm *br_tim;
ex_stack = stack_init( stack_size);
printf( "Variable: ");
string = get_string();
if( (var = get_var( string, varlist)) != NULL ) {
if( var->stuff.prog == NULL ) {
printf( "'%s' is uninitialized.\n", string);
continue;
}
tim = time( NULL);
br_tim = gmtime( &tim);
minutes = br_tim->tm_min;
seconds = br_tim->tm_sec;
printf( " Address: %p\n", var->stuff.prog);
print_program( var->stuff.prog);
if( var->type == DATA_NUMBER )
printf( "Result: %f\n\n", *execute_number( var->stuff.prog, ex_stack));
else if( var->type == DATA_STRING )
printf( "Result: %s\n\n", execute_string( var->stuff.prog, ex_stack));
else if( var->type == DATA_ALIGN ) {
int align = *execute_align( var->stuff.prog, ex_stack);
if ( align == ALIGN_LEFT ) printf( "Result: 'left'\n\n");
else if( align == ALIGN_RIGHT ) printf( "Result: 'right'\n\n");
else if( align == ALIGN_CENTER ) printf( "Result: 'center'\n\n");
}
}
stack_free( ex_stack);
}
return 0;
};
