ref: 354b56d6bfdca067a6f04a39c4ce4bc9c0160861
dir: /appl/cmd/man2html.b/
implement Man2html;
include "sys.m";
stderr: ref Sys->FD;
sys: Sys;
print, fprint, sprint: import sys;
include "bufio.m";
include "draw.m";
include "daytime.m";
dt: Daytime;
include "string.m";
str: String;
include "arg.m";
Man2html: module
{
init: fn(ctxt: ref Draw->Context, args: list of string);
};
Runeself: con 16r80;
false, true: con iota;
Troffspec: adt {
name: string;
value: string;
};
tspec := array [] of { Troffspec
("ff", "ff"),
("fi", "fi"),
("fl", "fl"),
("Fi", "ffi"),
("ru", "_"),
("em", "—"),
("14", "¼"),
("12", "½"),
("co", "©"),
("de", "°"),
("dg", "¡"),
("fm", "´"),
("rg", "®"),
# ("bu", "*"),
("bu", "•"),
("sq", "¤"),
("hy", "-"),
("pl", "+"),
("mi", "-"),
("mu", "×"),
("di", "÷"),
("eq", "="),
("==", "=="),
(">=", ">="),
("<=", "<="),
("!=", "!="),
("+-", "±"),
("no", "¬"),
("sl", "/"),
("ap", "&"),
("~=", "~="),
("pt", "oc"),
("gr", "GRAD"),
("->", "->"),
("<-", "<-"),
("ua", "^"),
("da", "v"),
("is", "Integral"),
("pd", "DIV"),
("if", "oo"),
("sr", "-/"),
("sb", "(~"),
("sp", "~)"),
("cu", "U"),
("ca", "(^)"),
("ib", "(="),
("ip", "=)"),
("mo", "C"),
("es", "Ø"),
("aa", "´"),
("ga", "`"),
("ci", "O"),
("L1", "Lucent"),
("sc", "§"),
("dd", "++"),
("lh", "<="),
("rh", "=>"),
("lt", "("),
("rt", ")"),
("lc", "|"),
("rc", "|"),
("lb", "("),
("rb", ")"),
("lf", "|"),
("rf", "|"),
("lk", "|"),
("rk", "|"),
("bv", "|"),
("ts", "s"),
("br", "|"),
("or", "|"),
("ul", "_"),
("rn", " "),
("*p", "PI"),
("**", "*"),
};
Entity: adt {
name: string;
value: int;
};
Entities: array of Entity;
Entities = array[] of {
Entity( "¡", '¡' ),
Entity( "¢", '¢' ),
Entity( "£", '£' ),
Entity( "¤", '¤' ),
Entity( "¥", '¥' ),
Entity( "¦", '¦' ),
Entity( "§", '§' ),
Entity( "¨", '¨' ),
Entity( "©", '©' ),
Entity( "ª", 'ª' ),
Entity( "«", '«' ),
Entity( "¬", '¬' ),
Entity( "­", '' ),
Entity( "®", '®' ),
Entity( "¯", '¯' ),
Entity( "°", '°' ),
Entity( "±", '±' ),
Entity( "²", '²' ),
Entity( "³", '³' ),
Entity( "´", '´' ),
Entity( "µ", 'µ' ),
Entity( "¶", '¶' ),
Entity( "·", '·' ),
Entity( "¸", '¸' ),
Entity( "¹", '¹' ),
Entity( "º", 'º' ),
Entity( "»", '»' ),
Entity( "¼", '¼' ),
Entity( "½", '½' ),
Entity( "¾", '¾' ),
Entity( "¿", '¿' ),
Entity( "À", 'À' ),
Entity( "Á", 'Á' ),
Entity( "Â", 'Â' ),
Entity( "Ã", 'Ã' ),
Entity( "Ä", 'Ä' ),
Entity( "Å", 'Å' ),
Entity( "Æ", 'Æ' ),
Entity( "Ç", 'Ç' ),
Entity( "È", 'È' ),
Entity( "É", 'É' ),
Entity( "Ê", 'Ê' ),
Entity( "Ë", 'Ë' ),
Entity( "Ì", 'Ì' ),
Entity( "Í", 'Í' ),
Entity( "Î", 'Î' ),
Entity( "Ï", 'Ï' ),
Entity( "Ð", 'Ð' ),
Entity( "Ñ", 'Ñ' ),
Entity( "Ò", 'Ò' ),
Entity( "Ó", 'Ó' ),
Entity( "Ô", 'Ô' ),
Entity( "Õ", 'Õ' ),
Entity( "Ö", 'Ö' ),
Entity( "&215;", '×' ),
Entity( "Ø", 'Ø' ),
Entity( "Ù", 'Ù' ),
Entity( "Ú", 'Ú' ),
Entity( "Û", 'Û' ),
Entity( "Ü", 'Ü' ),
Entity( "Ý", 'Ý' ),
Entity( "Þ", 'Þ' ),
Entity( "ß", 'ß' ),
Entity( "à", 'à' ),
Entity( "á", 'á' ),
Entity( "â", 'â' ),
Entity( "ã", 'ã' ),
Entity( "ä", 'ä' ),
Entity( "å", 'å' ),
Entity( "æ", 'æ' ),
Entity( "ç", 'ç' ),
Entity( "è", 'è' ),
Entity( "é", 'é' ),
Entity( "ê", 'ê' ),
Entity( "ë", 'ë' ),
Entity( "ì", 'ì' ),
Entity( "í", 'í' ),
Entity( "î", 'î' ),
Entity( "ï", 'ï' ),
Entity( "ð", 'ð' ),
Entity( "ñ", 'ñ' ),
Entity( "ò", 'ò' ),
Entity( "ó", 'ó' ),
Entity( "ô", 'ô' ),
Entity( "õ", 'õ' ),
Entity( "ö", 'ö' ),
Entity( "&247;", '÷' ),
Entity( "ø", 'ø' ),
Entity( "ù", 'ù' ),
Entity( "ú", 'ú' ),
Entity( "û", 'û' ),
Entity( "ü", 'ü' ),
Entity( "ý", 'ý' ),
Entity( "þ", 'þ' ),
Entity( "ÿ", 'ÿ' ), # ÿ
Entity( "&#SPACE;", ' ' ),
Entity( "&#RS;", '\n' ),
Entity( "&#RE;", '\r' ),
Entity( """, '"' ),
Entity( "&", '&' ),
Entity( "<", '<' ),
Entity( ">", '>' ),
Entity( "CAP-DELTA", 'Δ' ),
Entity( "ALPHA", 'α' ),
Entity( "BETA", 'β' ),
Entity( "DELTA", 'δ' ),
Entity( "EPSILON", 'ε' ),
Entity( "THETA", 'θ' ),
Entity( "MU", 'μ' ),
Entity( "PI", 'π' ),
Entity( "TAU", 'τ' ),
Entity( "CHI", 'χ' ),
Entity( "<-", '←' ),
Entity( "^", '↑' ),
Entity( "->", '→' ),
Entity( "v", '↓' ),
Entity( "!=", '≠' ),
Entity( "<=", '≤' ),
Entity( nil, 0 ),
};
Hit: adt {
glob: string;
chap: string;
mtype: string;
page: string;
};
Lnone, Lordered, Lunordered, Ldef, Lother: con iota; # list types
Chaps: adt {
name: string;
primary: int;
};
Types: adt {
name: string;
desc: string;
};
# having two separate flags here allows for inclusion of old-style formatted pages
# under a new-style three-level tree
Oldstyle: adt {
names: int; # two-level directory tree?
fmt: int; # old internal formats: e.g., "B" font means "L"; name in .TH in all caps
};
Href: adt {
title: string;
chap: string;
mtype: string;
man: string;
};
# per-thread global data
Global: adt {
bufio: Bufio;
bin: ref Bufio->Iobuf;
bout: ref Bufio->Iobuf;
topname: string; # name of the top level categories in the manual
chaps: array of Chaps; # names of top-level partitions of this manual
types: array of Types; # names of second-level partitions
oldstyle: Oldstyle;
mantitle: string;
mandir: string;
thisone: Hit; # man page we're displaying
mtime: int; # last modification time of thisone
href: Href; # hrefs of components of this man page
hits: array of Hit;
nhits: int;
list_type: int;
pm: string; # proprietary marking
def_goobie: string; # deferred goobie
sop: int; # output at start of paragraph?
sol: int; # input at start of line?
broken: int; # output at a break?
fill: int; # in fill mode?
pre: int; # in PRE block?
example: int; # an example active?
ipd: int; # emit inter-paragraph distance?
indents: int;
hangingdt: int;
curfont: string; # current font
prevfont: string; # previous font
lastc: int; # previous char from input scanner
def_sm: int; # amount of deferred "make smaller" request
mk_href_chap: fn(g: self ref Global, chap: string);
mk_href_man: fn(g: self ref Global, man: string, oldstyle: int);
mk_href_mtype: fn(g: self ref Global, chap, mtype: string);
dobreak: fn(g: self ref Global);
print: fn(g: self ref Global, s: string);
softbr: fn(g: self ref Global): string;
softp: fn(g: self ref Global): string;
};
header := "<HTML><HEAD>";
initial := "";
trailer := "</BODY></HTML>";
usage()
{
sys->fprint(stderr, "Usage: man2html [-h header] [-i initialtext] [-t trailer] file [section]\n");
raise "fail:usage";
}
init(nil: ref Draw->Context, args: list of string)
{
sys = load Sys Sys->PATH;
stderr = sys->fildes(2);
str = load String String->PATH;
dt = load Daytime Daytime->PATH;
arg := load Arg Arg->PATH;
arg->init(args);
arg->setusage("man2html [-h header] [-t trailer] file [section]");
while((o := arg->opt()) != 0)
case o {
'h' => header = arg->earg();
't' => trailer = arg->earg();
* => arg->usage();
}
args = arg->argv();
if(args == nil)
arg->usage();
arg = nil;
g := Global_init();
page := hd args;
args = tl args;
section := "1";
if(args != nil)
section = hd args;
hit := Hit ("", "man", section, page);
domanpage(g, hit);
g.print(trailer+"\n");
g.bufio->g.bout.flush();
}
# remove markup from a string
# doesn't handle nested/quoted delimiters
demark(s: string): string
{
t: string;
clean := true;
for (i := 0; i < len s; i++) {
case s[i] {
'<' =>
clean = false;
'>' =>
clean = true;
* =>
if (clean)
t[len t] = s[i];
}
}
return t;
}
#
# Convert an individual man page to HTML and output.
#
domanpage(g: ref Global, man: Hit)
{
file := man.page;
g.bin = g.bufio->open(file, Bufio->OREAD);
g.bout = g.bufio->fopen(sys->fildes(1), Bufio->OWRITE);
if (g.bin == nil) {
fprint(stderr, "Cannot open %s: %r\n", file);
return;
}
(err, info) := sys->fstat(g.bin.fd);
if (! err) {
g.mtime = info.mtime;
}
g.thisone = man;
while ((p := getnext(g)) != nil) {
c := p[0];
if (c == '.' && g.sol) {
if (g.pre) {
g.print("</PRE>");
g.pre = false;
}
dogoobie(g, false);
dohangingdt(g);
} else if (g.def_goobie != nil || g.def_sm != 0) {
g.bufio->g.bin.ungetc();
dogoobie(g, true);
} else if (c == '\n') {
g.print(p);
dohangingdt(g);
} else
g.print(p);
}
if (g.pm != nil) {
g.print("<BR><BR><BR><FONT SIZE=-2><CENTER>\n");
g.print(g.pm);
g.print("<BR></CENTER></FONT>\n");
}
closeall(g, 0);
rev(g, g.bin);
}
dogoobie(g: ref Global, deferred: int)
{
# read line, translate special chars
line := getline(g);
if (line == nil || line == "\n")
return;
# parse into arguments
token: string;
argl, rargl: list of string; # create reversed version, then invert
while ((line = str->drop(line, " \t\n")) != nil)
if (line[0] == '"') {
(token, line) = split(line[1:], '"');
rargl = token :: rargl;
} else {
(token, line) = str->splitl(line, " \t");
rargl = token :: rargl;
}
if (rargl == nil && !deferred)
return;
for ( ; rargl != nil; rargl = tl rargl)
argl = hd rargl :: argl;
def_sm := g.def_sm;
if (deferred && def_sm > 0) {
g.print(sprint("<FONT SIZE=-%d>", def_sm));
if (g.def_goobie == nil)
argl = "dS" :: argl; # dS is our own local creation
}
subgoobie(g, argl);
if (deferred && def_sm > 0) {
g.def_sm = 0;
g.print("</FONT>");
}
}
subgoobie(g: ref Global, argl: list of string)
{
if (g.def_goobie != nil) {
argl = g.def_goobie :: argl;
g.def_goobie = nil;
if (tl argl == nil)
return;
}
# the command part is at most two characters, but may be concatenated with the first arg
cmd := hd argl;
argl = tl argl;
if (len cmd > 2) {
cmd = cmd[0:2];
argl = cmd[2:] :: argl;
}
case cmd {
"B" or "I" or "L" or "R" =>
font(g, cmd, argl); # "R" macro implicitly generated by deferred R* macros
"BI" or "BL" or "BR" or
"IB" or "IL" or
"LB" or "LI" or
"RB" or "RI" or "RL" =>
altfont(g, cmd[0:1], cmd[1:2], argl, true);
"IR" or "LR" =>
anchor(g, cmd[0:1], cmd[1:2], argl); # includes man page refs ("IR" is old style, "LR" is new)
"dS" =>
printargs(g, argl);
g.print("\n");
"1C" or "2C" or "DT" or "TF" => # ignore these
return;
"ig" =>
while ((line := getline(g)) != nil){
if(len line > 1 && line[0:2] == "..")
break;
}
return;
"P" or "PP" or "LP" =>
g_PP(g);
"EE" => g_EE(g);
"EX" => g_EX(g);
"HP" => g_HP_TP(g, 1);
"IP" => g_IP(g, argl);
"PD" => g_PD(g, argl);
"PM" => g_PM(g, argl);
"RE" => g_RE(g);
"RS" => g_RS(g);
"SH" => g_SH(g, argl);
"SM" => g_SM(g, argl);
"SS" => g_SS(g, argl);
"TH" => g_TH(g, argl);
"TP" => g_HP_TP(g, 3);
"br" => g_br(g);
"sp" => g_sp(g, argl);
"ti" => g_br(g);
"nf" => g_nf(g);
"fi" => g_fi(g);
"ft" => g_ft(g, argl);
* => return; # ignore unrecognized commands
}
}
g_br(g: ref Global)
{
if (g.hangingdt != 0) {
g.print("<DD>");
g.hangingdt = 0;
} else if (g.fill && ! g.broken)
g.print("<BR>\n");
g.broken = true;
}
g_EE(g: ref Global)
{
g.print("</PRE>\n");
g.fill = true;
g.broken = true;
g.example = false;
}
g_EX(g: ref Global)
{
g.print("<PRE>");
if (! g.broken)
g.print("\n");
g.sop = true;
g.fill = false;
g.broken = true;
g.example = true;
}
g_fi(g: ref Global)
{
if (g.fill)
return;
g.fill = true;
g.print("<P style=\"display: inline; white-space: normal\">\n");
g.broken = true;
g.sop = true;
}
g_ft(g: ref Global, argl: list of string)
{
font: string;
arg: string;
if (argl == nil)
arg = "P";
else
arg = hd argl;
if (g.curfont != nil)
g.print(sprint("</%s>", g.curfont));
case arg {
"2" or "I" =>
font = "I";
"3" or "B" =>
font = "B";
"5" or "L" =>
font = "TT";
"P" =>
font = g.prevfont;
* =>
font = nil;
}
g.prevfont = g.curfont;
g.curfont = font;
if (g.curfont != nil)
if (g.fill)
g.print(sprint("<%s>", g.curfont));
else
g.print(sprint("<%s style=\"white-space: pre\">", g.curfont));
}
# level == 1 is a .HP; level == 3 is a .TP
g_HP_TP(g: ref Global, level: int)
{
case g.list_type {
Ldef =>
if (g.hangingdt != 0)
g.print("<DD>");
g.print(g.softbr() + "<DT>");
* =>
closel(g);
g.list_type = Ldef;
g.print("<DL compact>\n" + g.softbr() + "<DT>");
}
g.hangingdt = level;
g.broken = true;
}
g_IP(g: ref Global, argl: list of string)
{
case g.list_type {
Lordered or Lunordered or Lother =>
; # continue with an existing list
* =>
# figure out the type of a new list and start it
closel(g);
arg := "";
if (argl != nil)
arg = hd argl;
case arg {
"1" or "i" or "I" or "a" or "A" =>
g.list_type = Lordered;
g.print(sprint("<OL type=%s>\n", arg));
"*" or "•" or "•" =>
g.list_type = Lunordered;
g.print("<UL type=disc>\n");
"○" or "○"=>
g.list_type = Lunordered;
g.print("<UL type=circle>\n");
"□" or "□" =>
g.list_type = Lunordered;
g.print("<UL type=square>\n");
* =>
g.list_type = Lother;
g.print("<DL compact>\n");
}
}
# actually do this list item
case g.list_type {
Lother =>
g.print(g.softp()); # make sure there's space before each list item
if (argl != nil) {
g.print("<DT>");
printargs(g, argl);
}
g.print("\n<DD>");
Lordered or Lunordered =>
g.print(g.softp() + "<LI>");
}
g.broken = true;
}
g_nf(g: ref Global)
{
if (! g.fill)
return;
g.fill = false;
g.print("<PRE>\n");
g.broken = true;
g.sop = true;
g.pre = true;
}
g_PD(g: ref Global, argl: list of string)
{
if (len argl == 1 && hd argl == "0")
g.ipd = false;
else
g.ipd = true;
}
g_PM(g: ref Global, argl: list of string)
{
code := "P";
if (argl != nil)
code = hd argl;
case code {
* => # includes "1" and "P"
g.pm = "<B>Lucent Technologies - Proprietary</B>\n" +
"<BR>Use pursuant to Company Instructions.\n";
"2" or "RS" =>
g.pm = "<B>Lucent Technologies - Proprietary (Restricted)</B>\n" +
"<BR>Solely for authorized persons having a need to know\n" +
"<BR>pursuant to Company Instructions.\n";
"3" or "RG" =>
g.pm = "<B>Lucent Technologies - Proprietary (Registered)</B>\n" +
"<BR>Solely for authorized persons having a need to know\n" +
"<BR>and subject to cover sheet instructions.\n";
"4" or "CP" =>
g.pm = "SEE PROPRIETARY NOTICE ON COVER PAGE\n";
"5" or "CR" =>
g.pm = "Copyright xxxx Lucent Technologies\n" + # should fill in the year from the date register
"<BR>All Rights Reserved.\n";
"6" or "UW" =>
g.pm = "THIS DOCUMENT CONTAINS PROPRIETARY INFORMATION OF\n" +
"<BR>LUCENT TECHNOLOGIES INC. AND IS NOT TO BE DISCLOSED OR USED EXCEPT IN\n" +
"<BR>ACCORDANCE WITH APPLICABLE AGREEMENTS.\n" +
"<BR>Unpublished & Not for Publication\n";
}
}
g_PP(g: ref Global)
{
closel(g);
reset_font(g);
p := g.softp();
if (p != nil)
g.print(p);
g.sop = true;
g.broken = true;
}
g_RE(g: ref Global)
{
g.print("</DL>\n");
g.indents--;
g.broken = true;
}
g_RS(g: ref Global)
{
g.print("<DL>\n<DT><DD>");
g.indents++;
g.broken = true;
}
g_SH(g: ref Global, argl: list of string)
{
closeall(g, 1); # .SH is top-level list item
if (g.example)
g_EE(g);
g_fi(g);
if (g.fill && ! g.sop)
g.print("<P>");
g.print("<DT><H4>");
printargs(g, argl);
g.print("</H4>\n");
g.print("<DD>\n");
g.sop = true;
g.broken = true;
}
g_SM(g: ref Global, argl: list of string)
{
g.def_sm++; # can't use def_goobie, lest we collide with a deferred font macro
if (argl == nil)
return;
g.print(sprint("<FONT SIZE=-%d>", g.def_sm));
printargs(g, argl);
g.print("</FONT>\n");
g.def_sm = 0;
}
g_sp(g: ref Global, argl: list of string)
{
if (g.sop && g.fill)
return;
count := 1;
if (argl != nil) {
rcount := real hd argl;
count = int rcount; # may be 0 (e.g., ".sp .5")
if (count == 0 && rcount > 0.0)
count = 1; # force whitespace for fractional lines
}
g.dobreak();
for (i := 0; i < count; i++)
g.print(" <BR>\n");
g.broken = true;
g.sop = count > 0;
}
g_SS(g: ref Global, argl: list of string)
{
closeall(g, 1);
g.indents++;
g.print(g.softp() + "<DL><DT><FONT SIZE=3><B>");
printargs(g, argl);
g.print("</B></FONT>\n");
g.print("<DD>\n");
g.sop = true;
g.broken = true;
}
g_TH(g: ref Global, argl: list of string)
{
if (g.oldstyle.names && len argl > 2)
argl = hd argl :: hd tl argl :: nil; # ignore extra .TH args on pages in oldstyle trees
case len argl {
0 =>
g.oldstyle.fmt = true;
title(g, sprint("%s", g.href.title), false);
1 =>
g.oldstyle.fmt = true;
title(g, sprint("%s", hd argl), false); # any pages use this form?
2 =>
g.oldstyle.fmt = true;
g.thisone.page = hd argl;
g.thisone.mtype = hd tl argl;
g.mk_href_man(hd argl, true);
g.mk_href_mtype(nil, hd tl argl);
title(g, sprint("%s(%s)", g.href.man, g.href.mtype), false);
* =>
g.oldstyle.fmt = false;
chap := hd tl tl argl;
g.mk_href_chap(chap);
g.mk_href_man(hd argl, false);
g.mk_href_mtype(chap, hd tl argl);
title(g, sprint("%s/%s/%s(%s)", g.href.title, g.href.chap, g.href.man, g.href.mtype), false);
}
g.print("[<a href=\"../index.html\">manual index</a>]");
g.print("[<a href=\"INDEX.html\">section index</a>]<p>");
g.print("<DL>\n"); # whole man page is just one big list
g.indents = 1;
g.sop = true;
g.broken = true;
}
dohangingdt(g: ref Global)
{
case g.hangingdt {
3 =>
g.hangingdt--;
2 =>
g.print("<DD>");
g.hangingdt = 0;
g.broken = true;
}
}
# close a list, if there's one active
closel(g: ref Global)
{
case g.list_type {
Lordered =>
g.print("</OL>\n");
g.broken = true;
Lunordered =>
g.print("</UL>\n");
g.broken = true;
Lother or Ldef =>
g.print("</DL>\n");
g.broken = true;
}
g.list_type = Lnone;
}
closeall(g: ref Global, level: int)
{
closel(g);
reset_font(g);
while (g.indents > level) {
g.indents--;
g.print("</DL>\n");
g.broken = true;
}
}
#
# Show last revision date for a file.
#
rev(g: ref Global, filebuf: ref Bufio->Iobuf)
{
if (g.mtime == 0) {
(err, info) := sys->fstat(filebuf.fd);
if (! err)
g.mtime = info.mtime;
}
if (g.mtime != 0) {
g.print("<P><TABLE width=\"100%\" border=0 cellpadding=10 cellspacing=0 bgcolor=\"#E0E0E0\">\n");
g.print("<TR>");
g.print(sprint("<TD align=left><FONT SIZE=-1>"));
g.print(sprint("%s(%s)", g.thisone.page, g.thisone.mtype));
g.print("</FONT></TD>\n");
g.print(sprint("<TD align=right><FONT SIZE=-1><I>Rev: %s</I></FONT></TD></TR></TABLE>\n",
dt->text(dt->gmt(g.mtime))));
}
}
#
# Some font alternation macros are references to other man pages;
# detect them (second arg contains balanced parens) and make them into hot links.
#
anchor(g: ref Global, f1, f2: string, argl: list of string)
{
final := "";
link := false;
if (len argl == 2) {
(s, e) := str->splitl(hd tl argl, ")");
if (str->prefix("(", s) && e != nil) {
# emit href containing search for target first
# if numeric, do old style
link = true;
file := hd argl;
(chap, man) := split(httpunesc(file), '/');
if (man == nil) {
# given no explicit chapter prefix, use current chapter
man = chap;
chap = g.thisone.chap;
}
mtype := s[1:];
if (mtype == nil)
mtype = "-";
(n, toks) := sys->tokenize(mtype, "."); # Fix section 10
if (n > 1) mtype = hd toks;
g.print(sprint("<A href=\"../%s/%s.html\">", mtype, fixlink(man)));
#
# now generate the name the user sees, with terminal punctuation
# moved after the closing </A>.
#
if (len e > 1)
final = e[1:];
argl = hd argl :: s + ")" :: nil;
}
}
altfont(g, f1, f2, argl, false);
if (link) {
g.print("</A>");
font(g, f2, final :: nil);
} else
g.print("\n");
}
#
# Fix up a link
#
fixlink(l: string): string
{
ll := str->tolower(l);
if (ll == "copyright") ll = "1" + ll;
(a, b) := str->splitstrl(ll, "intro");
if (len b == 5) ll = a + "0" + b;
return ll;
}
#
# output argl in font f
#
font(g: ref Global, f: string, argl: list of string)
{
if (argl == nil) {
g.def_goobie = f;
return;
}
case f {
"L" => f = "TT";
"R" => f = nil;
}
if (f != nil) # nil == default (typically Roman)
g.print(sprint("<%s>", f));
printargs(g, argl);
if (f != nil)
g.print(sprint("</%s>", f));
g.print("\n");
g.prevfont = f;
}
#
# output concatenated elements of argl, alternating between fonts f1 and f2
#
altfont(g: ref Global, f1, f2: string, argl: list of string, newline: int)
{
reset_font(g);
if (argl == nil) {
g.def_goobie = f1;
return;
}
case f1 {
"L" => f1 = "TT";
"R" => f1 = nil;
}
case f2 {
"L" => f2 = "TT";
"R" => f2 = nil;
}
f := f1;
for (; argl != nil; argl = tl argl) {
if (f != nil)
g.print(sprint("<%s>%s</%s>", f, hd argl, f));
else
g.print(hd argl);
if (f == f1)
f = f2;
else
f = f1;
}
if (newline)
g.print("\n");
g.prevfont = f;
}
# not yet implemented
map_font(nil: ref Global, nil: string)
{
}
reset_font(g: ref Global)
{
if (g.curfont != nil) {
g.print(sprint("</%s>", g.curfont));
g.prevfont = g.curfont;
g.curfont = nil;
}
}
printargs(g: ref Global, argl: list of string)
{
for (; argl != nil; argl = tl argl)
if (tl argl != nil)
g.print(hd argl + " ");
else
g.print(hd argl);
}
# any parameter can be nil
addhit(g: ref Global, chap, mtype, page: string)
{
# g.print(sprint("Adding %s / %s (%s) . . .", chap, page, mtype)); # debug
# always keep a spare slot at the end
if (g.nhits >= len g.hits - 1)
g.hits = (array[len g.hits + 32] of Hit)[0:] = g.hits;
g.hits[g.nhits].glob = chap + " " + mtype + " " + page;
g.hits[g.nhits].chap = chap;
g.hits[g.nhits].mtype = mtype;
g.hits[g.nhits++].page = page;
}
Global.dobreak(g: self ref Global)
{
if (! g.broken) {
g.broken = true;
g.print("<BR>\n");
}
}
Global.print(g: self ref Global, s: string)
{
g.bufio->g.bout.puts(s);
if (g.sop || g.broken) {
# first non-white space, non-HTML we print takes us past the start of the paragraph & line
# (or even white space, if we're in no-fill mode)
for (i := 0; i < len s; i++) {
case s[i] {
'<' =>
while (++i < len s && s[i] != '>')
;
continue;
' ' or '\t' or '\n' =>
if (g.fill)
continue;
}
g.sop = false;
g.broken = false;
break;
}
}
}
Global.softbr(g: self ref Global): string
{
if (g.broken)
return nil;
g.broken = true;
return "<BR>";
}
# provide a paragraph marker, unless we're already at the start of a section
Global.softp(g: self ref Global): string
{
if (g.sop)
return nil;
else if (! g.ipd)
return "<BR>";
if (g.fill)
return "<P>";
else
return "<P style=\"white-space: pre\">";
}
#
# get (remainder of) a line
#
getline(g: ref Global): string
{
line := "";
while ((token := getnext(g)) != "\n") {
if (token == nil)
return line;
line += token;
}
return line+"\n";
}
#
# Get next logical character. Expand it with escapes.
#
getnext(g: ref Global): string
{
iob := g.bufio;
Iobuf: import iob;
font: string;
token: string;
bin := g.bin;
g.sol = (g.lastc == '\n');
c := bin.getc();
if (c < 0)
return nil;
g.lastc = c;
if (c >= Runeself) {
for (i := 0; i < len Entities; i++)
if (Entities[i].value == c)
return Entities[i].name;
return sprint("&#%d;", c);
}
case c {
'<' =>
return "<";
'>' =>
return ">";
'\\' =>
c = bin.getc();
if (c < 0)
return nil;
g.lastc = c;
case c {
' ' =>
return " ";
# chars to ignore
'|' or '&' or '^' =>
return getnext(g);
# ignore arg
'k' =>
nil = bin.getc();
return getnext(g);
# defined strings
'*' =>
case bin.getc() {
'R' =>
return "®";
}
return getnext(g);
# special chars
'(' =>
token[0] = bin.getc();
token[1] = bin.getc();
for (i := 0; i < len tspec; i++)
if (token == tspec[i].name)
return tspec[i].value;
return "¿";
'c' =>
c = bin.getc();
if (c < 0)
return nil;
else if (c == '\n') {
g.lastc = c;
g.sol = true;
token[0] = bin.getc();
return token;
}
# DEBUG: should there be a "return xxx" here?
'e' =>
return "\\";
'f' =>
g.lastc = c = bin.getc();
if (c < 0)
return nil;
case c {
'2' or 'I' =>
font = "I";
'3' or 'B' =>
font = "B";
'5' or 'L' =>
font = "TT";
'P' =>
font = g.prevfont;
* => # includes '1' and 'R'
font = nil;
}
# There are serious problems with this. We don't know the fonts properly at this stage.
# g.prevfont = g.curfont;
# g.curfont = font;
# if (g.prevfont != nil)
# token = sprint("</%s>", g.prevfont);
# if (g.curfont != nil)
# token += sprint("<%s>", g.curfont);
if (token == nil)
return "<i></i>"; # looks odd but it avoids inserting a space in <pre> text
return token;
's' =>
sign := '+';
size := 0;
relative := false;
getsize:
for (;;) {
c = bin.getc();
if (c < 0)
return nil;
case c {
'+' =>
relative = true;
'-' =>
sign = '-';
relative = true;
'0' to '9' =>
size = size * 10 + (c - '0');
* =>
bin.ungetc();
break getsize;
}
g.lastc = c;
}
if (size == 0)
token = "</FONT>";
else if (relative)
token = sprint("<FONT SIZE=%c%d>", sign, size);
else
token = sprint("<FONT SIZE=%d>", size);
return token;
}
}
token[0] = c;
return token;
}
#
# Return strings before and after the left-most instance of separator;
# (s, nil) if no match or separator is last char in s.
#
split(s: string, sep: int): (string, string)
{
for (i := 0; i < len s; i++)
if (s[i] == sep)
return (s[:i], s[i+1:]); # s[len s:] is a valid slice, with value == nil
return (s, nil);
}
Global_init(): ref Global
{
g := ref Global;
g.bufio = load Bufio Bufio->PATH;
g.chaps = array[20] of Chaps;
g.types = array[20] of Types;
g.mantitle = "";
g.href.title = g.mantitle; # ??
g.mtime = 0;
g.nhits = 0;
g.oldstyle.names = false;
g.oldstyle.fmt = false;
g.topname = "System";
g.list_type = Lnone;
g.def_sm = 0;
g.hangingdt = 0;
g.indents = 0;
g.sop = true;
g.broken = true;
g.ipd = true;
g.fill = true;
g.example = false;
g.pre = false;
g.lastc = '\n';
return g;
}
Global.mk_href_chap(g: self ref Global, chap: string)
{
if (chap != nil)
g.href.chap = sprint("<A href=\"%s/%s?man=*\"><B>%s</B></A>", g.mandir, chap, chap);
}
Global.mk_href_man(g: self ref Global, man: string, oldstyle: int)
{
rman := man;
if (oldstyle)
rman = str->tolower(man); # compensate for tradition of putting titles in all CAPS
g.href.man = sprint("<A href=\"%s?man=%s\"><B>%s</B></A>", g.mandir, rman, man);
}
Global.mk_href_mtype(g: self ref Global, chap, mtype: string)
{
g.href.mtype = sprint("<A href=\"%s/%s/%s\"><B>%s</B></A>", g.mandir, chap, mtype, mtype);
}
# We assume that anything >= Runeself is already in UTF.
#
httpunesc(s: string): string
{
t := "";
for (i := 0; i < len s; i++) {
c := s[i];
if (c == '&' && i + 1 < len s) {
(char, rem) := str->splitl(s[i+1:], ";");
if (rem == nil)
break; # require the terminating ';'
if (char == nil)
continue;
if (char[0] == '#' && len char > 1) {
c = int char[1:];
i += len char;
if (c < 256 && c >= 161) {
t[len t] = Entities[c-161].value;
continue;
}
} else {
for (j := 0; j < len Entities; j++)
if (Entities[j].name == char)
break;
if (j < len Entities) {
i += len char;
t[len t] = Entities[j].value;
continue;
}
}
}
t[len t] = c;
}
return t;
}
title(g: ref Global, t: string, search: int)
{
if(search)
; # not yet used
g.print(header+"\n");
g.print(sprint("<TITLE>Inferno's %s</TITLE>\n", demark(t)));
g.print("</HEAD>\n");
g.print("<BODY>"+initial+"\n");
}