662 lines
23 KiB
Text
662 lines
23 KiB
Text
[TeX::] TeX Format.
|
|
|
|
To provide for weaving in the standard maths and science typesetting
|
|
software, TeX.
|
|
|
|
@ \section{Creation.}
|
|
|
|
<<*>>=
|
|
void TeX::create(void) {
|
|
weave_format *wf = Formats::create_weave_format(I"TeX", I".tex");
|
|
METHOD_ADD(wf, RENDER_FOR_MTID, TeX::render_TeX);
|
|
METHOD_ADD(wf, PREFORM_DOCUMENT_FOR_MTID, TeX::preform_document);
|
|
}
|
|
|
|
@ \section{Rendering.}
|
|
At present, this renderer only makes the dialect of TeX needed for [[pdftex]],
|
|
which involves various extension commands: the curse of modern TeX is the
|
|
combination of an outdated original, and a proliferation of non-canonical
|
|
extensions, but [[pdftex]] is pretty good. All the same, we should perhaps
|
|
consider adding LaTeX, or XeTeX.
|
|
|
|
<<*>>=
|
|
enum PDFTEX_TEX_FORM from 1
|
|
|
|
<<*>>=
|
|
void TeX::render_TeX(weave_format *self, text_stream *OUT, heterogeneous_tree *tree) {
|
|
TeX::render_inner(OUT, tree, PDFTEX_TEX_FORM);
|
|
}
|
|
|
|
@ From here on, then, the renderer, which should generate TeX which is as
|
|
generic as possible, but with special features depending on [[trs->TeX_form]].
|
|
|
|
<<*>>=
|
|
typedef struct TeX_render_state {
|
|
struct text_stream *OUT;
|
|
struct weave_order *wv;
|
|
int TeX_form;
|
|
} TeX_render_state;
|
|
|
|
void TeX::render_inner(text_stream *OUT, heterogeneous_tree *tree, int form) {
|
|
weave_document_node *C = RETRIEVE_POINTER_weave_document_node(tree->root->content);
|
|
TeX_render_state trs;
|
|
trs.OUT = OUT;
|
|
trs.wv = C->wv;
|
|
trs.TeX_form = form;
|
|
Trees::traverse_from(tree->root, &TeX::render_visit, (void *) &trs, 0);
|
|
}
|
|
|
|
@ For the reason why footnotes are omitted, see below: they aren't really.
|
|
|
|
<<*>>=
|
|
int TeX::render_visit(tree_node *N, void *state, int L) {
|
|
TeX_render_state *trs = (TeX_render_state *) state;
|
|
text_stream *OUT = trs->OUT;
|
|
if ((N->type == weave_document_node_type) ||
|
|
(N->type == weave_body_node_type) ||
|
|
(N->type == weave_chapter_title_page_node_type) ||
|
|
(N->type == weave_chapter_footer_node_type) ||
|
|
(N->type == weave_section_footer_node_type) ||
|
|
(N->type == weave_audio_node_type) ||
|
|
(N->type == weave_video_node_type) ||
|
|
(N->type == weave_download_node_type) ||
|
|
(N->type == weave_chapter_node_type) ||
|
|
(N->type == weave_carousel_slide_node_type) ||
|
|
(N->type == weave_begin_footnote_text_node_type)) <<Render nothing>>
|
|
|
|
else if (N->type == weave_head_node_type) <<Render head>>
|
|
else if (N->type == weave_tail_node_type) <<Render tail>>
|
|
else if (N->type == weave_verbatim_node_type) <<Render verbatim>>
|
|
else if (N->type == weave_chapter_header_node_type) <<Render chapter header>>
|
|
else if (N->type == weave_section_header_node_type) <<Render header>>
|
|
else if (N->type == weave_section_purpose_node_type) <<Render purpose>>
|
|
else if (N->type == weave_subheading_node_type) <<Render subheading>>
|
|
else if (N->type == weave_bar_node_type) <<Render bar>>
|
|
else if (N->type == weave_pagebreak_node_type) <<Render pagebreak>>
|
|
else if (N->type == weave_linebreak_node_type) <<Render linebreak>>
|
|
else if (N->type == weave_paragraph_heading_node_type) <<Render paragraph heading>>
|
|
else if (N->type == weave_endnote_node_type) <<Render endnote>>
|
|
else if (N->type == weave_figure_node_type) <<Render figure>>
|
|
else if (N->type == weave_material_node_type) <<Render material>>
|
|
else if (N->type == weave_embed_node_type) <<Render embed>>
|
|
else if (N->type == weave_pmac_node_type) <<Render pmac>>
|
|
else if (N->type == weave_vskip_node_type) <<Render vskip>>
|
|
else if (N->type == weave_section_node_type) <<Render section>>
|
|
else if (N->type == weave_code_line_node_type) <<Render code line>>
|
|
else if (N->type == weave_function_usage_node_type) <<Render function usage>>
|
|
else if (N->type == weave_commentary_node_type) <<Render commentary>>
|
|
else if (N->type == weave_toc_node_type) <<Render toc>>
|
|
else if (N->type == weave_toc_line_node_type) <<Render toc line>>
|
|
else if (N->type == weave_defn_node_type) <<Render defn>>
|
|
else if (N->type == weave_source_code_node_type) <<Render source code>>
|
|
else if (N->type == weave_url_node_type) <<Render URL>>
|
|
else if (N->type == weave_footnote_cue_node_type) <<Render footnote cue>>
|
|
else if (N->type == weave_display_line_node_type) <<Render display line>>
|
|
else if (N->type == weave_function_defn_node_type) <<Render function defn>>
|
|
else if (N->type == weave_item_node_type) <<Render item>>
|
|
else if (N->type == weave_grammar_index_node_type) <<Render grammar index>>
|
|
else if (N->type == weave_inline_node_type) <<Render inline>>
|
|
else if (N->type == weave_locale_node_type) <<Render locale>>
|
|
else if (N->type == weave_maths_node_type) <<Render maths>>
|
|
|
|
else internal_error("unable to render unknown node");
|
|
return TRUE;
|
|
}
|
|
|
|
<<Render head>>=
|
|
weave_head_node *C = RETRIEVE_POINTER_weave_head_node(N->content);
|
|
WRITE("%% %S\n", C->banner);
|
|
|
|
<<Render tail>>=
|
|
weave_tail_node *C = RETRIEVE_POINTER_weave_tail_node(N->content);
|
|
WRITE("%% %S\n", C->rennab);
|
|
WRITE("\\end\n");
|
|
|
|
<<Render chapter header>>=
|
|
weave_chapter_header_node *C = RETRIEVE_POINTER_weave_chapter_header_node(N->content);
|
|
if (Str::ne(C->chap->md->ch_range, I"S")) {
|
|
TeX::general_heading(OUT, trs->wv,
|
|
FIRST_IN_LINKED_LIST(section, C->chap->sections), NULL, C->chap->md->ch_title,
|
|
3, FALSE);
|
|
WRITE("%S\\medskip\n", C->chap->md->rubric);
|
|
section *S;
|
|
LOOP_OVER_LINKED_LIST(S, section, C->chap->sections) {
|
|
WRITE("\\smallskip\\noindent ");
|
|
if (trs->wv->pattern->number_sections) WRITE("%d. ", S->printed_number);
|
|
WRITE("{\\it %S}\\qquad\n%S", S->md->sect_title, S->sect_purpose);
|
|
}
|
|
}
|
|
|
|
<<Render header>>=
|
|
weave_section_header_node *C = RETRIEVE_POINTER_weave_section_header_node(N->content);
|
|
TeX::general_heading(OUT, trs->wv, C->sect, NULL,
|
|
C->sect->md->sect_title, 2, FALSE);
|
|
|
|
<<Render purpose>>=
|
|
weave_section_purpose_node *C = RETRIEVE_POINTER_weave_section_purpose_node(N->content);
|
|
WRITE("\\smallskip\\par\\noindent{\\it %S}\\smallskip\\noindent\n", C->purpose);
|
|
|
|
<<Render subheading>>=
|
|
weave_subheading_node *C = RETRIEVE_POINTER_weave_subheading_node(N->content);
|
|
WRITE("\\par\\noindent{\\bf %S}\\mark{%S}\\medskip\n", C->text, NULL);
|
|
|
|
<<Render bar>>=
|
|
WRITE("\\par\\medskip\\noindent\\hrule\\medskip\\noindent\n");
|
|
|
|
<<Render pagebreak>>=
|
|
WRITE("\\vfill\\eject\n");
|
|
|
|
<<Render linebreak>>=
|
|
WRITE("\n");
|
|
|
|
<<Render paragraph heading>>=
|
|
weave_paragraph_heading_node *C =
|
|
RETRIEVE_POINTER_weave_paragraph_heading_node(N->content);
|
|
TeX::general_heading(OUT, trs->wv, C->para->under_section,
|
|
C->para, I"", 0, FALSE);
|
|
|
|
<<Render endnote>>=
|
|
WRITE("\\par\\noindent\\penalty10000\n");
|
|
WRITE("{\\usagefont ");
|
|
<<Recurse tne renderer through children nodes>>;
|
|
WRITE("}\\smallskip\n");
|
|
return FALSE;
|
|
|
|
@ TeX itself has an almost defiant lack of support for anything pictorial,
|
|
which is one reason it didn't live up to its hope of being the definitive basis
|
|
for typography; even today the loose confederation of TeX-like programs and
|
|
extensions lack standard approaches. Here we're going to use [[pdftex]] features,
|
|
having nothing better. All we're trying for is to insert a picture, scaled
|
|
to a given width, into the text at the current position.
|
|
|
|
<<Render figure>>=
|
|
weave_figure_node *C = RETRIEVE_POINTER_weave_figure_node(N->content);
|
|
filename *F = Filenames::in(
|
|
Pathnames::down(trs->wv->weave_web->md->path_to_web, I"Figures"),
|
|
C->figname);
|
|
WRITE("\\pdfximage");
|
|
if (C->w >= 0) WRITE(" width %d cm{%f}\n", C->w/POINTS_PER_CM, F);
|
|
else if (C->h >= 0) WRITE(" height %d cm{%f}\n", C->h/POINTS_PER_CM, F);
|
|
else WRITE("{%f}\n", F);
|
|
WRITE("\\smallskip\\noindent"
|
|
"\\hbox to\\hsize{\\hfill\\pdfrefximage \\pdflastximage\\hfill}"
|
|
"\\smallskip\n");
|
|
|
|
<<Render material>>=
|
|
weave_material_node *C = RETRIEVE_POINTER_weave_material_node(N->content);
|
|
paragraph *first_in_para = NULL;
|
|
if ((N == N->parent->child) &&
|
|
(N->parent->type == weave_paragraph_heading_node_type)) {
|
|
weave_paragraph_heading_node *PC =
|
|
RETRIEVE_POINTER_weave_paragraph_heading_node(N->parent->content);
|
|
first_in_para = PC->para;
|
|
}
|
|
if (C->material_type == COMMENTARY_MATERIAL)
|
|
<<Deal with a commentary material node>>
|
|
else if (C->material_type == CODE_MATERIAL)
|
|
<<Deal with a code material node>>
|
|
else if (C->material_type == FOOTNOTES_MATERIAL)
|
|
<<Deal with a footnotes material node>>
|
|
else if (C->material_type == ENDNOTES_MATERIAL)
|
|
<<Deal with a endnotes material node>>
|
|
else if (C->material_type == MACRO_MATERIAL)
|
|
<<Deal with a macro material node>>
|
|
else if (C->material_type == DEFINITION_MATERIAL)
|
|
<<Deal with a definition material node>>;
|
|
return FALSE;
|
|
|
|
<<Deal with a commentary material node>>=
|
|
<<Recurse tne renderer through children nodes>>;
|
|
WRITE("\n");
|
|
|
|
<<Deal with a code material node>>=
|
|
WRITE("\\beginlines\n");
|
|
<<Recurse tne renderer through children nodes>>;
|
|
WRITE("\\endlines\n");
|
|
|
|
<<Deal with a footnotes material node>>=
|
|
return FALSE;
|
|
|
|
<<Deal with a endnotes material node>>=
|
|
<<Recurse tne renderer through children nodes>>;
|
|
|
|
<<Deal with a macro material node>>=
|
|
<<Recurse tne renderer through children nodes>>;
|
|
WRITE("\n");
|
|
|
|
<<Deal with a definition material node>>=
|
|
WRITE("\\beginlines\n");
|
|
<<Recurse tne renderer through children nodes>>;
|
|
WRITE("\\endlines\n");
|
|
|
|
<<Render verbatim>>=
|
|
weave_verbatim_node *C = RETRIEVE_POINTER_weave_verbatim_node(N->content);
|
|
WRITE("%S", C->content);
|
|
|
|
<<Render nothing>>=
|
|
;
|
|
|
|
<<Render embed>>=
|
|
weave_embed_node *C = RETRIEVE_POINTER_weave_embed_node(N->content);
|
|
LOG("It was %d\n", C->allocation_id);
|
|
|
|
<<Render pmac>>=
|
|
weave_pmac_node *C = RETRIEVE_POINTER_weave_pmac_node(N->content);
|
|
TeX::para_macro(OUT, trs->wv, C->pmac, C->defn);
|
|
|
|
<<Render vskip>>=
|
|
weave_vskip_node *C = RETRIEVE_POINTER_weave_vskip_node(N->content);
|
|
if (C->in_comment) WRITE("\\smallskip\\par\\noindent%%\n");
|
|
else WRITE("\\smallskip\n");
|
|
|
|
<<Render section>>=
|
|
weave_section_node *C = RETRIEVE_POINTER_weave_section_node(N->content);
|
|
LOG("It was %d\n", C->allocation_id);
|
|
|
|
<<Render code line>>=
|
|
WRITE("\\smallskip\\par\\noindent ");
|
|
WRITE("|");
|
|
<<Recurse tne renderer through children nodes>>;
|
|
WRITE("|");
|
|
WRITE("\n");
|
|
return FALSE;
|
|
|
|
<<Render function usage>>=
|
|
weave_function_usage_node *C =
|
|
RETRIEVE_POINTER_weave_function_usage_node(N->content);
|
|
WRITE("%S", C->fn->function_name);
|
|
return FALSE;
|
|
|
|
<<Render commentary>>=
|
|
weave_commentary_node *C =
|
|
RETRIEVE_POINTER_weave_commentary_node(N->content);
|
|
if (C->in_code) WRITE(" |\\hfill{\\ttninepoint\\it ");
|
|
TeX::commentary_text(OUT, trs->wv, C->text);
|
|
if (C->in_code) WRITE("}|");
|
|
|
|
<<Render toc>>=
|
|
WRITE("\\medskip\\hrule\\smallskip\\par\\noindent{\\usagefont ");
|
|
for (tree_node *M = N->child; M; M = M->next) {
|
|
Trees::traverse_from(M, &TeX::render_visit, (void *) trs, L+1);
|
|
if (M->next) WRITE("; ");
|
|
}
|
|
WRITE("}\\par\\medskip\\hrule\\bigskip\n");
|
|
return FALSE;
|
|
|
|
<<Render toc line>>=
|
|
weave_toc_line_node *C = RETRIEVE_POINTER_weave_toc_line_node(N->content);
|
|
WRITE("%S~%S", C->text1, C->text2);
|
|
|
|
<<Render defn>>=
|
|
weave_defn_node *C = RETRIEVE_POINTER_weave_defn_node(N->content);
|
|
WRITE("[[{\\ninebf %S} ]]", C->keyword);
|
|
|
|
<<Render source code>>=
|
|
weave_source_code_node *C =
|
|
RETRIEVE_POINTER_weave_source_code_node(N->content);
|
|
int starts = FALSE;
|
|
if (N == N->parent->child) starts = TRUE;
|
|
TeX::source_code(OUT, trs->wv,
|
|
C->matter, C->colouring, starts);
|
|
|
|
<<Render URL>>=
|
|
weave_url_node *C = RETRIEVE_POINTER_weave_url_node(N->content);
|
|
WRITE("%S", C->url);
|
|
|
|
@ The TeX macro for footnotes means that the text has to accompany the cue,
|
|
which is tricky for us now because the footnote text is somewhere else in
|
|
the weave tree -- so, we go for a little walk:
|
|
|
|
<<Render footnote cue>>=
|
|
weave_footnote_cue_node *C = RETRIEVE_POINTER_weave_footnote_cue_node(N->content);
|
|
WRITE("\\footnote{${}^{%S}$}{", C->cue_text);
|
|
tree_node *M = N;
|
|
while ((M) && (M->type != weave_paragraph_heading_node_type)) M = M->parent;
|
|
if (M == NULL) internal_error("tree without section nodes");
|
|
M = M->child;
|
|
int found = FALSE;
|
|
while (M) {
|
|
if (M->type == weave_material_node_type) {
|
|
weave_material_node *MC = RETRIEVE_POINTER_weave_material_node(M->content);
|
|
if (MC->material_type == FOOTNOTES_MATERIAL) {
|
|
tree_node *F = M->child;
|
|
while (F) {
|
|
if (F->type == weave_begin_footnote_text_node_type) {
|
|
weave_begin_footnote_text_node *FC =
|
|
RETRIEVE_POINTER_weave_begin_footnote_text_node(F->content);
|
|
if (Str::eq(FC->cue_text, C->cue_text))
|
|
<<Found the right footnote text at last>>;
|
|
}
|
|
F = F->next;
|
|
}
|
|
}
|
|
}
|
|
M = M->next;
|
|
}
|
|
WRITE("}");
|
|
if (found == FALSE) internal_error("cue without text");
|
|
|
|
@ And so here's the text. Note that we render only its second and subsequent
|
|
child nodes: that's because the first child is a copy of the footnote cue,
|
|
and TeX renders that automatically.
|
|
|
|
(The TeX renderer otherwise ignores footnote texts, so if these nodes
|
|
are not rendered here, they never will be.)
|
|
|
|
<<Found the right footnote text at last>>=
|
|
for (tree_node *X = F->child->next; X; X = X->next)
|
|
Trees::traverse_from(X, &TeX::render_visit, (void *) trs, L+1);
|
|
found = TRUE;
|
|
|
|
<<Render display line>>=
|
|
weave_display_line_node *C =
|
|
RETRIEVE_POINTER_weave_display_line_node(N->content);
|
|
WRITE("\\quotesource{%S}\n", C->text);
|
|
|
|
<<Render function defn>>=
|
|
weave_function_defn_node *C =
|
|
RETRIEVE_POINTER_weave_function_defn_node(N->content);
|
|
TeX::change_colour_PDF(OUT, FUNCTION_COLOUR, TRUE);
|
|
WRITE("%S", C->fn->function_name);
|
|
TeX::change_colour_PDF(OUT, PLAIN_COLOUR, TRUE);
|
|
return FALSE;
|
|
|
|
<<Render item>>=
|
|
weave_item_node *C = RETRIEVE_POINTER_weave_item_node(N->content);
|
|
if (Str::len(C->label) > 0) {
|
|
if (C->depth == 1) WRITE("\\item{(%S)}", C->label);
|
|
else WRITE("\\itemitem{(%S)}", C->label);
|
|
} else {
|
|
if (C->depth == 1) WRITE("\\item{}");
|
|
else WRITE("\\itemitem{}");
|
|
}
|
|
|
|
<<Render grammar index>>=
|
|
InCSupport::weave_grammar_index(OUT);
|
|
|
|
<<Render inline>>=
|
|
WRITE("|");
|
|
<<Recurse tne renderer through children nodes>>;
|
|
WRITE("|");
|
|
return FALSE;
|
|
|
|
<<Render locale>>=
|
|
weave_locale_node *C = RETRIEVE_POINTER_weave_locale_node(N->content);
|
|
WRITE("$\\%S$%S", C->par1->ornament, C->par1->paragraph_number);
|
|
if (C->par2) WRITE("-%S", C->par2->paragraph_number);
|
|
|
|
<<Render maths>>=
|
|
weave_maths_node *C = RETRIEVE_POINTER_weave_maths_node(N->content);
|
|
if (C->displayed) WRITE("$$"); else WRITE("$");
|
|
WRITE("%S", C->content);
|
|
if (C->displayed) WRITE("$$"); else WRITE("$");
|
|
|
|
<<Recurse tne renderer through children nodes>>=
|
|
for (tree_node *M = N->child; M; M = M->next)
|
|
Trees::traverse_from(M, &TeX::render_visit, (void *) trs, L+1);
|
|
|
|
<<*>>=
|
|
text_stream *P_literal = NULL;
|
|
void TeX::general_heading(text_stream *OUT, weave_order *wv,
|
|
section *S, paragraph *P, text_stream *heading_text, int weight, int no_skip) {
|
|
text_stream *TeX_macro = NULL;
|
|
<<Choose which TeX macro to use in order to typeset the new paragraph heading>>;
|
|
|
|
if (P_literal == NULL) P_literal = Str::new_from_wide_string(L"P");
|
|
text_stream *orn = (P)?(P->ornament):P_literal;
|
|
text_stream *N = (P)?(P->paragraph_number):NULL;
|
|
TEMPORARY_TEXT(mark)
|
|
<<Work out the next mark to place into the TeX vertical list>>;
|
|
TEMPORARY_TEXT(modified)
|
|
Str::copy(modified, heading_text);
|
|
match_results mr = Regexp::create_mr();
|
|
if (Regexp::match(&mr, modified, L"(%c*?): (%c*)")) {
|
|
Str::clear(modified);
|
|
WRITE_TO(modified, "{\\sinchhigh %S}\\quad %S", mr.exp[0], mr.exp[1]);
|
|
}
|
|
if (weight == 2)
|
|
WRITE("\\%S{%S}{%S}{%S}{\\%S}{%S}%%\n",
|
|
TeX_macro, N, modified, mark, orn, NULL);
|
|
else
|
|
WRITE("\\%S{%S}{%S}{%S}{\\%S}{%S}%%\n",
|
|
TeX_macro, N, modified, mark, orn, S->md->sect_range);
|
|
DISCARD_TEXT(mark)
|
|
DISCARD_TEXT(modified)
|
|
Regexp::dispose_of(&mr);
|
|
}
|
|
|
|
@ We want to have different heading styles for different weights, and TeX is
|
|
horrible at using macro parameters as function arguments, so we don't want
|
|
to pass the weight that way. Instead we use
|
|
|
|
\weavesection
|
|
\weavesections
|
|
\weavesectionss
|
|
\weavesectionsss
|
|
|
|
where the weight is the number of terminal [[s]]s, 0 to 3. (TeX macros,
|
|
lamentably, are not allowed digits in their name.) In the cases 0 and 1, we
|
|
also have variants [[\nsweavesection]] and [[\nsweavesections]] which are
|
|
the same, but with the initial vertical spacing removed; these allow us to
|
|
prevent unsightly excess white space in certain configurations of a section.
|
|
|
|
<<Choose which TeX macro to use in order to typeset the new paragraph heading>>=
|
|
switch (weight) {
|
|
case 0: TeX_macro = I"weavesection"; break;
|
|
case 1: TeX_macro = I"weavesections"; break;
|
|
case 2: TeX_macro = I"weavesectionss"; break;
|
|
default: TeX_macro = I"weavesectionsss"; break;
|
|
}
|
|
if (wv->theme_match) {
|
|
switch (weight) {
|
|
case 0: TeX_macro = I"tweavesection"; break;
|
|
case 1: TeX_macro = I"tweavesections"; break;
|
|
case 2: TeX_macro = I"tweavesectionss"; break;
|
|
default: TeX_macro = I"tweavesectionsss"; break;
|
|
}
|
|
}
|
|
if (no_skip) {
|
|
switch (weight) {
|
|
case 0: TeX_macro = I"nsweavesection"; break;
|
|
case 1: TeX_macro = I"nsweavesections"; break;
|
|
}
|
|
}
|
|
|
|
@ "Marks" are the contrivance by which TeX produces running heads on pages
|
|
which follow the material on those pages: so that the running head for a page
|
|
can show the paragraph range for the material which tops it, for instance.
|
|
|
|
The ornament has to be set in math mode, even in the mark. [[\S]] and [[\P]],
|
|
making a section sign and a pilcrow respectively, only work in math mode
|
|
because they abbreviate characters found in math fonts but not regular ones,
|
|
in TeX's deeply peculiar font encoding system.
|
|
|
|
<<Work out the next mark to place into the TeX vertical list>>=
|
|
text_stream *chaptermark = Str::new();
|
|
text_stream *sectionmark = Str::new();
|
|
if (weight == 3) {
|
|
Str::copy(chaptermark, S->owning_chapter->md->ch_title);
|
|
Str::clear(sectionmark);
|
|
}
|
|
if (weight == 2) {
|
|
Str::copy(sectionmark, S->md->sect_title);
|
|
Str::clear(chaptermark);
|
|
if (Str::len(chaptermark) > 0) {
|
|
Str::clear(sectionmark);
|
|
WRITE_TO(sectionmark, " - %S", S->md->sect_title);
|
|
}
|
|
}
|
|
WRITE_TO(mark, "%S%S\\quad$\\%S$%S", chaptermark, sectionmark, orn, N);
|
|
|
|
@ Code is typeset by TeX within vertical strokes; these switch a sort of
|
|
typewriter-type verbatim mode on and off. To get an actual stroke, we must
|
|
escape from code mode, escape it using a backslash, then re-enter code
|
|
mode once again:
|
|
|
|
<<*>>=
|
|
void TeX::source_code(text_stream *OUT, weave_order *wv,
|
|
text_stream *matter, text_stream *colouring, int starts) {
|
|
int current_colour = PLAIN_COLOUR, colour_wanted = PLAIN_COLOUR;
|
|
for (int i=0; i < Str::len(matter); i++) {
|
|
colour_wanted = Str::get_at(colouring, i);
|
|
<<Adjust code colour as necessary>>;
|
|
if (Str::get_at(matter, i) == '[[') WRITE("|\\|]]");
|
|
else WRITE("%c", Str::get_at(matter, i));
|
|
}
|
|
colour_wanted = PLAIN_COLOUR; <<Adjust code colour as necessary>>;
|
|
}
|
|
|
|
<<Adjust code colour as necessary>>=
|
|
if (colour_wanted != current_colour) {
|
|
TeX::change_colour_PDF(OUT, colour_wanted, TRUE);
|
|
current_colour = colour_wanted;
|
|
}
|
|
|
|
<<*>>=
|
|
void TeX::change_colour_PDF(text_stream *OUT, int col, int in_code) {
|
|
char *inout = "";
|
|
if (in_code) inout = "|";
|
|
switch (col) {
|
|
case DEFINITION_COLOUR:
|
|
WRITE("%s\\pdfliteral direct{1 1 0 0 k}%s", inout, inout); break;
|
|
case FUNCTION_COLOUR:
|
|
WRITE("%s\\pdfliteral direct{0 1 1 0 k}%s", inout, inout); break;
|
|
case PLAIN_COLOUR:
|
|
WRITE("%s\\special{PDF:0 g}%s", inout, inout); break;
|
|
case EXTRACT_COLOUR:
|
|
WRITE("%s\\special{PDF:0 g}%s", inout, inout); break;
|
|
}
|
|
}
|
|
|
|
@ Any usage of angle-macros is highlighted in several cute ways: first,
|
|
we make use of colour and we drop in the paragraph number of the definition
|
|
of the macro in small type; and second, we use cross-reference links.
|
|
|
|
In the PDF format, these three are all called, in sequence below; in TeX
|
|
or DVI, only the middle one is.
|
|
|
|
<<*>>=
|
|
void TeX::para_macro(text_stream *OUT, weave_order *wv, para_macro *pmac, int defn) {
|
|
if (defn)
|
|
WRITE("|\\pdfdest num %d fit ",
|
|
pmac->allocation_id + 100);
|
|
else
|
|
WRITE("|\\pdfstartlink attr{/C [0.9 0 0] /Border [0 0 0]} goto num %d ",
|
|
pmac->allocation_id + 100);
|
|
WRITE("$\\langle${\\xreffont");
|
|
TeX::change_colour_PDF(OUT, DEFINITION_COLOUR, FALSE);
|
|
WRITE("%S ", pmac->macro_name);
|
|
WRITE("{\\sevenss %S}}", pmac->defining_paragraph->paragraph_number);
|
|
TeX::change_colour_PDF(OUT, PLAIN_COLOUR, FALSE);
|
|
WRITE("$\\rangle$ ");
|
|
if (defn)
|
|
WRITE("$\\equiv$|");
|
|
else
|
|
WRITE("\\pdfendlink|");
|
|
}
|
|
|
|
<<*>>=
|
|
void TeX::commentary_text(text_stream *OUT, weave_order *wv, text_stream *id) {
|
|
int math_mode = FALSE;
|
|
for (int i=0; i < Str::len(id); i++) {
|
|
switch (Str::get_at(id, i)) {
|
|
case '$': math_mode = (math_mode)?FALSE:TRUE;
|
|
WRITE("%c", Str::get_at(id, i)); break;
|
|
case '_': if (math_mode) WRITE("_"); else WRITE("\\_"); break;
|
|
case '"':
|
|
if ((Str::get_at(id, i) == '"') &&
|
|
((i==0) [[| (Str::get_at(id, i-1) == ' ') |]]
|
|
(Str::get_at(id, i-1) == '(')))
|
|
WRITE("``");
|
|
else
|
|
WRITE("''");
|
|
break;
|
|
default: WRITE("%c", Str::get_at(id, i));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
@ The following is called only when the language is InC, and the weave is of
|
|
the special Preform grammar document.
|
|
|
|
<<*>>=
|
|
int TeX::preform_document(weave_format *self, text_stream *OUT, web *W,
|
|
weave_order *wv, chapter *C, section *S, source_line *L, text_stream *matter,
|
|
text_stream *concluding_comment) {
|
|
if (L->preform_nonterminal_defined) {
|
|
preform_production_count = 0;
|
|
<<Weave the opening line of the nonterminal definition>>;
|
|
return TRUE;
|
|
} else {
|
|
if (L->category == PREFORM_GRAMMAR_LCAT) {
|
|
<<Weave a line from the body of the nonterminal definition>>;
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
<<Weave the opening line of the nonterminal definition>>=
|
|
WRITE("\\nonterminal{%S} [[::=]]",
|
|
L->preform_nonterminal_defined->unangled_name);
|
|
if (L->preform_nonterminal_defined->as_function) {
|
|
WRITE("\\quad{\\it internal definition");
|
|
if (L->preform_nonterminal_defined->voracious)
|
|
WRITE(" (voracious)");
|
|
else if (L->preform_nonterminal_defined->min_word_count ==
|
|
L->preform_nonterminal_defined->max_word_count)
|
|
WRITE(" (%d word%s)",
|
|
L->preform_nonterminal_defined->min_word_count,
|
|
(L->preform_nonterminal_defined->min_word_count != 1)?"s":"");
|
|
WRITE("}");
|
|
}
|
|
WRITE("\n");
|
|
|
|
<<Weave a line from the body of the nonterminal definition>>=
|
|
TEMPORARY_TEXT(problem)
|
|
match_results mr = Regexp::create_mr();
|
|
if (Regexp::match(&mr, matter, L"Issue (%c*?) problem"))
|
|
Str::copy(problem, mr.exp[0]);
|
|
else if (Regexp::match(&mr, matter, L"FAIL_NONTERMINAL %+"))
|
|
WRITE_TO(problem, "fail and skip");
|
|
else if (Regexp::match(&mr, matter, L"FAIL_NONTERMINAL"))
|
|
WRITE_TO(problem, "fail");
|
|
preform_production_count++;
|
|
WRITE_TO(matter, "[[%S]]", L->text_operand);
|
|
while (Regexp::match(&mr, matter, L"(%c+?)|(%c+)")) {
|
|
Str::clear(matter);
|
|
WRITE_TO(matter, "%S___stroke___%S", mr.exp[0], mr.exp[1]);
|
|
}
|
|
while (Regexp::match(&mr, matter, L"(%c*?)___stroke___(%c*)")) {
|
|
Str::clear(matter);
|
|
WRITE_TO(matter, "%S[[\\|]]%S", mr.exp[0], mr.exp[1]);
|
|
}
|
|
while (Regexp::match(&mr, matter, L"(%c*)<(%c*?)>(%c*)")) {
|
|
Str::clear(matter);
|
|
WRITE_TO(matter, "%S[[\\nonterminal{%S}]]%S",
|
|
mr.exp[0], mr.exp[1], mr.exp[2]);
|
|
}
|
|
TEMPORARY_TEXT(label)
|
|
int N = preform_production_count;
|
|
int L = ((N-1)%26) + 1;
|
|
if (N <= 26) WRITE_TO(label, "%c", 'a'+L-1);
|
|
else if (N <= 52) WRITE_TO(label, "%c%c", 'a'+L-1, 'a'+L-1);
|
|
else if (N <= 78) WRITE_TO(label, "%c%c%c", 'a'+L-1, 'a'+L-1, 'a'+L-1);
|
|
else {
|
|
int n = (N-1)/26;
|
|
WRITE_TO(label, "%c${}^{%d}$", 'a'+L-1, n);
|
|
}
|
|
WRITE("\\qquad {\\hbox to 0.4in{\\it %S\\hfil}}%S", label, matter);
|
|
if (Str::len(problem) > 0)
|
|
WRITE("\\hfill$\\longrightarrow$ {\\ttninepoint\\it %S}", problem);
|
|
else if (Str::len(concluding_comment) > 0) {
|
|
WRITE(" \\hfill{\\ttninepoint\\it ");
|
|
if (Str::len(concluding_comment) > 0)
|
|
TeX::commentary_text(OUT, wv, concluding_comment);
|
|
WRITE("}");
|
|
}
|
|
WRITE("\n");
|
|
DISCARD_TEXT(label)
|
|
DISCARD_TEXT(problem)
|
|
Regexp::dispose_of(&mr);
|