% TeX-REDUCE-Interface 0.70
% set GREEK asserted
% set LOWERCASE asserted
% \tolerance 10
% \hsize=150mm
module tri;
% ======================================================================
% T h e T e X - R e d u c e - I n t e r f a c e
% ======================================================================
% (C) 1987/1988 by Rechenzentrum der Universitaet zu Koeln
% (University of Cologne Computer Center)
% Abt. Anwendungssoftware
% (Application Software Department)
% ATTN: Werner Antweiler
% Robert-Koch-Str. 10
% 5000 Koeln 41
% Federal Republic of Germany
% E-Mail: reduce@rrz.Uni-Koeln.DE
% All rights reserved. Permission to copy without fee all or part of
% this software product is hereby granted provided that the copies are
% not made or distributed for direct commercial advantage, this copy-
% right notice and its date appear, and notice is given that copying is
% by permission of the authors. To copy otherwise requires a fee and/or
% specific permission. This software product has been developed by
% WERNER ANTWEILER at the University of Cologne Computer Center, West
% Germany. The TeX-Reduce-Interface has been totally written in REDUCE-
% LISP.
% ======================================================================
% Authors: Werner Antweiler, Andreas Strotmann, Volker Winkelmann.
% Modifications: David Hartley.
%
% Last Update: 14-Jul-96 Version 0.70
% ======================================================================
%
% Section Survey
% ----------------------------------------------------------------------
% Section Contents Page
% ----------------------------------------------------------------------
% 0 Main Procedure (and Interfacing) 2
% 1 Creating a TeX item list 5
% 1.1 Operator Administration Routines 5
% 1.2 Prefix to Infix Conversion 6
% 1.3 Making a TeX item 9
% 2 Inserting Glue Items 16
% 3 Line Breaking 18
% 3.1 Resolving Fraction Expressions 20
% 3.2 Creating a Break List 21
% 3.3 Major Line Breaking Routine 23
% 4 TeX-Output Routines 28
% 5 User Interface 30
% ----------------------------------------------------------------------
% Note: page breaks (form feeds) are indicated by "%ff" lines
%ff
% ----------------------------------------------------------------------
% Section 0: Global Variables, Main Procedure and Interfacing
% ----------------------------------------------------------------------
% IMPORTANT NOTICE FOR REDUCE 3.2 USERS:
% This code was written to run under REDUCE 3.3. Users of REDUCE 3.2
% therefore have to change two lines of this code before compiling it:
% 1) the line `switch ...;` must be deleted
% 2) the construct `FOR EACH ... IN ... JOIN ...` must be changed
% to `FOR EACH ... IN ... CONC ...` because only the latter is
% accepted by REDUCE 3.2.
% Furthermore, the TRI supports features of REDUCE that are new in ver-
% sion 3.3. You cannot take advantage of them under version 3.2. In
% particular, some of the examples in the accompanying test file may
% fail.
create!-package('(tri),'(contrib misc));
fluid '(
% -----------------+---------------------------------------------------+
% FLUID VARIABLES | EXPLANATION |
% -----------------+---------------------------------------------------+
!*tex % flag to be switched ON and OFF (TeX Output Mode)
!*texbreak % flag to be switched ON and OFF (Break Facility)
!*texindent % flag to be switched ON and OFF (Indentation Mode)
texstack!* % stack to save expressions for an unfilled line
hsize!* % total page width in scaled points (sp)
% note: 65536sp = 1pt = 1/72.27 inch
hss!* % total line stretchability/shrinkability (in sp)
hww!* % optimum page fit width (= 3/4 hsize) (in sp)
tolerance!* % value within break points are considered to be
% feasible (range: 0..10000)
!*lower % used in REDUCE 3.5 to make everything lower case
% -----------------+---------------------------------------------------+
);
global '(
% ------------------+---------------------------------------------------+
% GLOBAL VARIABLES | EXPLANATION |
% ------------------+---------------------------------------------------+
metricu!* % EXCALC
indxl!* % EXCALC
% ------------------+---------------------------------------------------+
);
% declare switches:
switch tex,texbreak,texindent;
% declare switch dependencies:
put('texindent,'simpfg,'((t (progn (setq !*tex t)
(setq !*texbreak t))) ));
put('texbreak,'simpfg,'((t (setq !*tex t)) ));
put('tex,'simpfg,'((nil (progn (setq !*texbreak nil)
(setq !*texindent nil))) ));
symbolic procedure tri!-error(strlst,errclass);
<< for each x in strlst do prin2 x; terpri();
if errclass='fatal then
rederr "Aborting."
>>;
% Code called by ASSGNPRI.
symbolic procedure texpri(u,v,w);
(if x and get(x,'texprifn) then apply3(get(x,'texprifn),u,v,w)
else texvarpri(u,v,w)) where x = getrtype u;
symbolic procedure texvarpri(u,v,w); % same parameters as above
begin scalar !*lower;
if w memq '(first only) then texstack!*:=nil;
if v then for each x in reverse v do u:=list('setq,x,u);
texstack!* := nconc(texstack!*,mktag(u,0,nil));
if (w=t) or (w='only) or (w='last) then
<< if !*texbreak then
<< texstack!* := insertglue(texstack!*);
texstack!* := trybreak(texstack!*,breaklist(texstack!*))
>>;
texout(texstack!*,!*texbreak); texstack!*:=nil
>>;
%if (null w) or (w eq 'first) then
% texstack!* := nconc(texstack!*,list '!\!q!u!a!d! );
nil
end;
%ff
% The following procedure interfaces to E. Schruefer's EXCALC package.
% Courtesy: E. Schruefer.
put('form!-with!-free!-indices,'texprifn,'texindxpri);
symbolic procedure texindxpri(u,v,w);
begin scalar metricu,il,dnlist,uplist,r,x,y,z;
if v then go to a;
metricu := metricu!*;
metricu!* := nil;
il := allind !*t2f lt numr simp0 u;
for each j in il do
if atom revalind j
then uplist := j . uplist
else dnlist := cadr j . dnlist;
for each j in intersection(uplist,dnlist) do
il := delete(j,delete(revalind
lowerind j,il));
metricu!* := metricu;
y := flatindxl il;
r := simp!* u;
for each j in mkaindxc(y,nil) do
<<x := pair(y,j);
z := exc!-mk!*sq2 multsq(subfindices(numr r,x),1 ./ denr r);
if null(!*nero and (z = 0))
then texvarpri(z,list subla(x,'ns . il),'only)>>;
return u;
a: v := car v;
y := flatindxl allindk v;
for each j in if flagp(car v,'antisymmetric) and
coposp cdr v then comb(indxl!*,length y)
else mkaindxc(y,nil) do
<<x := pair(y,j);
z := aeval subla(x,v);
if null(!*nero and (z = 0))
then texvarpri(z,list subla(x,v),'only)>>;
return u
end;
%ff
% ----------------------------------------------------------------------
% Section 1: Creating a TeX item list
% ----------------------------------------------------------------------
%
% Linearization is performed by expanding REDUCE prefix expressions into
% a so called "TeX item list". Any TeX item is a readable TeX primitive
% or macro (i.e. a LISP atom), with properties 'CLASS, 'TEXTAG, 'TEXNAME
% and eventually 'TEXPREC, 'TEXPATT and 'TEXUBY bound to them, depending
% on what kind of TeX item it actually is. (See Section 1.3 for further
% information.)
% A REDUCE expression is expanded using the two functions "mktag"
% and "makefunc". Function "mktag" identifies the operator and is able
% to put some brackets around the expression if necessary. "makefunc" is
% a pattern oriented 'unification' function, which matches the arguments
% of a REDUCE expression in order of appearance with so called 'unifica-
% tion tags', as explained below. "mktag" and "makefunc" are highly
% recursive functions.
% The patterns mentioned above are lists (consisting of 'tags') asso-
% ciated with each REDUCE operator. A tag is defined as either an atom
% declared as a TeX item or one of the following 'unification tags':
% (F) ............ insert operator
% (X) ............ insert non-associative argument
% (Y) ............ insert (left/right-) associative argument
% (Z) ............ insert superscript/subscript argument
% (R) ............ use tail recursion to unify remaining arguments
% (associativity depends on previous (X) or (Y) )
% (L) ............ insert a list of arguments (eat up all arguments)
% (M) ............ insert a matrix (and eat up all arguments)
% (APPLY <fun>) ... apply function <fun> to remaining argument list
% ----------------------------------------------------------------------
% ----------------------------------------------------------------------
% Section 1.1: Operator Administration Routines
% ----------------------------------------------------------------------
symbolic procedure makeop(op,prec,patt,uby);
<< put(op,'texprec,prec); put(op,'texpatt,patt);
put(op,'texuby,if uby then (car uby).(cadr uby) else nil.nil)
>>;
symbolic procedure makeops(l);
for each w in l do makeop(car w,cadr w,caddr w,cadddr w);
%ff
makeops('(
%-----------+----------+---------------------+-------------------------+
% Name |Precedence|Expansion List |Unary/Binary Interchange |
%-----------+----------+---------------------+-------------------------+
(setq 1 ((x) (f) !\![ (x) !\!]) nil)
(or 30 ((x) (f) (r)) nil)
(and 40 ((x) (f) (r)) nil)
(equal 50 ((x) (f) !\![ (x) !\!]) nil)
(replaceby 50 ((x) (f) !\![ (x) !\!]) nil)
(greaterp 50 ((x) (f) !\![ (x) !\!]) nil)
(lessp 50 ((x) (f) !\![ (x) !\!]) nil)
(geq 50 ((x) (f) !\![ (x) !\!]) nil)
(leq 50 ((x) (f) !\![ (x) !\!]) nil)
(neq 50 ((x) (f) !\![ (x) !\!]) nil)
(member 50 ((x) (f) (x)) nil)
(when 50 ((x) (f) (x)) nil)
(plus 100 ((x) (f) (r)) (minus difference))
(minus 100 ((f) (y)) nil)
(difference 100 ((x) (f) (y)) nil)
(union 100 ((x) (f) (r)) nil)
(setdiff 100 ((x) (f) (y)) nil)
(taylor!* 100 ((apply maketaylor)) nil) % precedence like plus
(times 200 ((x) (f) (r)) (recip quotient))
(wedge 200 ((x) (f) (r)) nil) % EXCALC
(quotient 200 ((f) (z) !}!{ (z) !}) nil)
(intersection 200 ((x) (f) (r)) nil)
(!*sq 200 ((apply make!*sq)) nil) % precedence like quotient
(recip 700 ((f) !1 !}!{ (z) !}) nil)
(expt 850 ((x) !^!{ (z) !}) nil)
(sqrt 800 ((f) ! ! ! (z) !}) nil)
(!:rd!: 999 ((apply make!:rd!:)) nil)
(!:cr!: 999 ((apply makedomain)) nil)
(!:gi!: 999 ((apply makedomain)) nil)
(!:rn!: 999 ((apply makedomain)) nil)
(!:crn!: 999 ((apply makedomain)) nil)
(!:mod!: 999 ((apply makedomain)) nil)
(!:dn!: 999 ((apply makedomain)) nil)
(!:int!: 999 ((apply makedomain)) nil)
(not 999 ((f) (y)) nil)
(mat 999 ((f) (m !\!c!r! !&) !}) nil)
(list 999 (!\!{ (l !\co! ) !\!}) nil)
(df 999 ((apply makedf)) nil)
(int 999 ((apply makeint)) nil)
(limit 999 ((apply makelimit)) nil)
(limit!+ 999 ((apply makelimit)) nil)
(limit!- 999 ((apply makelimit)) nil)
(sum 999 ((apply makelimit)) nil)
(prod 999 ((apply makelimit)) nil)
(!~ 999 ((f) (y)) nil)
(!*interval!* 999 ((x) !. !. (x)) nil)
(innerprod 999 (!{ !\!r!m! !i !}
!_!{ (z) !} (x)) nil) % EXCALC
(liedf 999 (!\!h!b!o!x! !{ !\!i!t! !\!$ !}
!_!{ (z) !} (x)) nil) % EXCALC
(hodge 999 ((f) (y)) nil) % EXCALC
(partdf 999 ((f) (apply makepartdf)) nil) % EXCALC
(d 999 (!\!d! (x)) nil) % EXCALC
(!:ps!: 999 ((apply make!:ps!:)) nil) % TPS
(rest!_order 999 (!{ !\!r!m! !O !} (x)) nil) % TPS
%-----------+----------+----------------------+------------------------+
));
% ----------------------------------------------------------------------
% Section 1.2 : Prefix to Infix Conversion
% ----------------------------------------------------------------------
symbolic procedure mktag(tag,prec,assf);
% analyze an operator and decide what to do
% parameters: tag ....... the term itself
% prec ...... outer precedence
% assf ...... outer associativity flag
if null tag then nil else
if atom tag then texexplode(tag) else
begin
scalar tagprec,term;
tagprec:=get(car tag,'texprec) or 999; % get the operator's precedence
term:=makefunc(car tag,cdr tag,tagprec); % expand expression and if it
% is necessary, put a left and a right bracket around the expression.
if (assf and (prec = tagprec)) or (tagprec < prec)
then term:=nconc('!\!( . term , '!\!) . nil);
return(term)
end;
symbolic procedure makearg(l,s);
% collect arguments from a list <l> and put seperators <s> between them
if null l then nil
else if null cdr l then mktag(car l,0,nil)
else nconc(mktag(car l,0,nil), s . makearg(cdr l,s));
symbolic procedure makemat(m,v,h);
% make a matrix <m> and use <h> as a horizontal seperator and <v> as
% a vertical terminator.
if null m then nil else nconc(makearg(car m,h), v . makemat(cdr m,v,h));
%ff
smacro procedure istag(v,w); car v=w;
smacro procedure unary(uby); car uby;
smacro procedure binary(uby); cdr uby;
smacro procedure lcopy(a); for each x in a collect x;
symbolic procedure makefunc(op,arg,prec);
begin
scalar term,tag,a,pattern,uby;
term:=nil;
pattern:=get(op,'texpatt)
or ( if flagp(op,'indexvar) then '((apply makeexcinx))
else '( (f) !\!( (l !,) !\!) ));
uby:=get(op,'texuby);
while pattern do
<< tag:=car pattern; pattern:=cdr pattern;
if (atom tag) then a:=tag.nil
else if (not atom car tag) then a:=nil
else if istag(tag,'f) then
% test for unary to binary operator interchange
if arg and (not atom car arg) and uby and (caar arg=unary(uby))
then << a:=texexplode(binary(uby)); arg:=cadar arg.cdr arg >>
else a:=texexplode(op)
else if istag(tag,'apply)
then << a:=apply3(cadr tag,op,arg,prec); arg:=nil >>
else if null arg then a:=nil
else if istag(tag,'x)
then << a:=mktag(car arg,prec,nil); arg:=cdr arg >>
else if istag(tag,'y)
then << a:=mktag(car arg,prec,t); arg:=cdr arg >>
else if istag(tag,'z)
then << a:=mktag(car arg,0,nil); arg:=cdr arg >>
else if istag(tag,'r) then
if cdr arg % more than one argument ?
then << pattern:=get(op,'texpatt); a:=nil >>
else << a:=mktag(car arg,prec,nil); arg:=cdr arg >>
else if istag(tag,'l)
then << a:=makearg(arg,cadr tag); arg:=nil >>
else if istag(tag,'m)
then << a:=makemat(arg,cadr tag,caddr tag); arg:=nil >>
else a:=nil;
if a then term:=nconc(term,a)
>>;
return(term)
end;
%ff
symbolic procedure make!*sq(op,arg,prec);
% Convert !*sq's to true prefix form
mktag(prepreform prepsq!* sqhorner!* car arg,0,nil);
symbolic procedure makedf(op,arg,prec); % DF operators are tricky
begin
scalar dfx,f,vvv; integer degree;
dfx:=lcopy(f:=texexplode op); degree:=0;
nconc(dfx,mktag(car arg,prec,nil)); dfx:=nconc(dfx,list '!}!{);
for each item in cdr arg do
if numberp(item) then
<< dfx:= nconc(dfx,'!^!{ .texexplode(item));
dfx:= nconc(dfx,list '!});
degree:=degree+item-1;
>>
else
<< dfx:= nconc(dfx,append(f,mktag(item,prec,nil))); degree:=degree+1
>>;
if degree>1 then
<< vvv:=nconc(texexplode(degree), '!} . cdr dfx);
rplacd(dfx,'!^!{ . vvv)
>>;
return ('!\!f!r!a!c!{ . nconc(dfx, list '!}))
end;
symbolic procedure makepartdf(op,arg,prec); % EXCALC extension
if cdr arg then
('!_!{ . nconc(makearg(cdr arg,'!,), '!} . mktag(car arg,prec,nil)))
else ('!_!{ . nconc(mktag(car arg,prec,nil), list '!}));
smacro procedure inxextend(item,ld,rd);
nconc(result,ld.nconc(texexplode(item),list rd));
symbolic procedure makeexcinx(op,arg,prec); % EXCALC extension
begin scalar result;
result:=nconc('!{.nil,texexplode(op));
for each item in arg do
if numberp item then
if minusp item then inxextend(-item,'!{!}!_!{,'!})
else inxextend(item ,'!{!}!^!{,'!}) else
if atom item then inxextend(item ,'!{!}!^!{,'!}) else
if car item='minus then inxextend(cadr item ,'!{!}!_!{,'!})
else inxextend('! ,'!{!}!_!{,'!});
return nconc(result,'!}.nil)
end;
symbolic procedure make!:rd!:(op,arg,prec);
begin scalar digits,str; integer dotpos,xp;
op := rd!:explode(op . arg);
digits := car op; xp := cadr op; dotpos := caddr op;
for i:=1:dotpos do
<< str := car digits . str;
digits := cdr digits; if null digits then digits := '(!0) >>;
str := '!. . str;
for each c in digits do str := c . str;
if not(xp=0) then
<< for each c in '(!\!, !1 !0 !^!{) do str := c . str;
for each c in explode2 xp do str := c . str;
str := '!} . str >>;
return reverse str;
end;
symbolic procedure makedomain(op,arg,prec);
if get(op,'prepfn) then
mktag(apply1(get(op,'prepfn),op . arg),prec,nil)
else if get(op,'prepfn2) then
mktag(apply1(get(op,'prepfn2),op . arg),prec,nil)
else if get(op,'simpfn) then
mktag(apply1(get(op,'simpfn),op . arg),prec,nil)
else rerror(tri,000,
{"Don't know how to print domain",get(op,'dname) or op});
symbolic procedure makelimit(op,arg,prec);
% for operators like limit, sum and prod which may have limit scripts
begin scalar a,term,limits;
if arg then limits := cdr arg;
term := texexplode(op);
if limits then
<< a := '!_!{ . mktag(car limits,0,nil);
limits := cdr limits;
term := nconc(term,a) >>;
if limits then
<< a :=
if op = 'limit then '!\!t!o! % spaces critical
else if op = 'limit!+ then '!\!u!p!a!r!r!o!w! %
else if op = 'limit!- then '!\!d!o!w!n!a!r!r!o!w! %
else '!=;
a := a . mktag(car limits,0,nil);
limits := cdr limits;
term := nconc(term,a) >>;
if limits then
<< a := '!} . '!^!{ . mktag(car limits,0,nil);
term := nconc(term,a) >>;
a := '!{ . if arg then mktag(car arg,prec,nil) else nil;
if arg and cdr arg then a := '!} . a;
term := nconc(term,a);
term := nconc(term,'!} . nil);
return term;
end;
symbolic procedure texgroup u;
% surround u by TeX {}
% NB Destructive!!
nconc('!{ . if null u or listp u then u else {u},'!} . nil);
symbolic procedure makeint(op,arg,prec);
% for operators like int which may have limit scripts
begin scalar a,term,limits;
if arg and cdr arg then limits := cddr arg;
term := texexplode(op);
if limits then
<< a := '!_!{ . cdr texgroup mktag(car limits,0,nil);
limits := cdr limits;
term := nconc(term,a) >>;
if limits then
<< a := '!^!{ . cdr texgroup mktag(car limits,0,nil);
limits := cdr limits;
term := nconc(term,a) >>;
a := if arg then mktag(car arg,0,nil);
a := nconc(a,if arg and cdr arg then '!\!, . '!d . mktag(cadr arg,0,nil));
term := nconc(term,texgroup a);
return term;
end;
symbolic procedure maketaylor(op,arg,prec);
mktag(apply1(get(op,'fancy!-reform),op . arg),prec,nil);
% The following is part of the interface to TPS.
% Andreas Strotmann, 19 Mar 93
% ps:numberp smacro required for compilation; copied over from tps.red
symbolic smacro procedure ps!:numberp u;
numberp u or (car u neq '!:ps!: and get(car u,'dname));
% fluid declaration to avoid compiler warnings
fluid '(ps!:exp!-lim);
% symbolic procedure ps!:prin!: p;
symbolic procedure make!:ps!:(op, arg, prec); % TPS interface,
% (lambda (first,u,delta,symbolic!-exp!-pt,about,atinf);
(lambda (first,u,delta,symbolic!-exp!-pt,about,atinf,texps,p);
<< % if !*nat and posn!*<20 then orig!*:=posn!*;
atinf:=(about='ps!:inf);
ps!:find!-order p;
delta:=prepf((ps!:depvar p) .** 1 .*1 .+
(negf if atinf then nil
% expansion about infinity
else if idp about then !*k2f about
else if ps!:numberp about then !*n2f about
else if (u:=!*pre2dp about) then !*n2f u
else !*k2f(symbolic!-exp!-pt:= compress
append(explode ps!:depvar p, explode '0))));
% if symbolic!-exp!-pt then prin2!* "[";
% prin2!* "{";
texps := nconc(texps, list '!\!{ );
%
for i:=(ps!:order p): ps!:exp!-lim do
<< u:=ps!:term(p,i);
if not null numr u then
<<if minusf numr u then <<u:=negsq u; % prin2!* " - ">>
texps := nconc(texps, list '!-)
>>
else if not first then % prin2!* " + ";
texps := nconc(texps, list '!+);
first := nil;
% if posn!*>55 then <<terpri!* nil;prin2!* " ">>;
if denr u neq 1 then % prin2!* "(";
texps := nconc(texps, list '!\!( );
if u neq '(1 . 1) then
% maprint(prepsq u,get('times,'infix))
texps := nconc(texps,
mktag(prepsq u,
get('times, 'texprec),
nil))
else if i=0 then % prin2!* 1;
texps := nconc(texps, list '!1);
if denr u neq 1 then % prin2!* ")";
texps := nconc(texps, list '!\!) );
if i neq 0 and u neq '(1 . 1) then % prin2!* "*";
texps := nconc(texps,list get('times,'texname));
if i neq 0 then
% xprinf(!*p2f mksp(delta,
% if atinf then -i else i),nil,nil)
texps := (lambda i;
nconc(texps,
mktag (if (i = 1) then delta
else list('expt, delta, i),
get('times, 'texprec),
nil)))
(if atinf then -i else i);
>>
>>;
if first then % prin2!* "0";
texps := nconc(texps, list '!0 );
% if posn!*>55 then terpri!* nil;
u:=ps!:exp!-lim +1;
texps := (lambda u;
nconc(texps,
'!+ . mktag(list('rest!_order,
if (u = 1) then delta
else list('expt, delta, u)),
get('plus, 'texprec),
nil)))
(if atinf then -u else u);
%if (u=1) and not atinf and (about neq 0) then
% prin2!* " + O"
%else prin2!* " + O(";
%xprinf(!*p2f mksp(delta,if atinf then -u else u),nil,nil);
%if (u=1) and not atinf and (about neq 0) then
% prin2!* "}"
% else prin2!* ")}";
texps := nconc(texps, list '!\!} );
if symbolic!-exp!-pt then
<< %if posn!*>45 then terpri!* nil;
%prin2!* " where ";
texps := nconc(texps, list '!_!{ );
%prin2!* symbolic!-exp!-pt;
texps := nconc(texps, texexplode symbolic!-exp!-pt);
%prin2!* " = ";
texps := nconc(texps, list '!= );
%maprin about;
texps := nconc(texps, mktag(makeprefix about,
get('equal, 'texprec), nil));
texps := nconc(texps, list '!} );
%prin2!* "]"
>>;
texps
>>)
% (t,nil,nil,nil,ps!:expansion!-point p,nil);
(t,nil,nil,nil,ps!:expansion!-point(op . arg),nil,nil,op . arg);
%ff
% ----------------------------------------------------------------------
% Section 1.3 : Making a TeX Item
% ----------------------------------------------------------------------
% Properties of TeX items:
% 'CLASS ..... one of the following class specifiers
% 'ORD .... ordinary symbols
% 'LOP .... large operators
% 'BIN .... binary operators
% 'REL .... relational operators
% 'OPN .... opening symbols (left parenthesis)
% 'CLO .... closing symbols (right parenthesis)
% 'PCT .... punctuation symbols
% 'INN .... inner TeX group delimiters
% 'TEXTAG ..... one of the following lists or atoms
% <kind> .. an atom describing an 'INN class group delimiter
% (<w1> <w2> <w3>) ... where is
% <w1> ..... width for text style (cmmi10)
% <w2> ..... width for scriptstyle (cmmi8)
% <w3> ..... width for scriptscriptstyle (cmmi5)
% The parital lists of the list which is passed to makeitems have the
% following general structure:
% (<TeX-item> <class> <TeX-tag> <v1> <v2> ... )
% where is
% <TeX-item> .... the atom which actually is the TeX code
% <class> ....... the 'CLASS property as explained above
% <TeX-tag> ..... the 'TEXTAG property as explained above
% <v1> etc. ..... atoms which will be bound to specific TeX items
% by its property 'TEXNAME
% ----------------------------------------------------------------------
smacro procedure triassert(name,item); put(name,'texname,item);
smacro procedure assertl(l); for each v in l do triassert(car v,cadr v);
smacro procedure retract(name); put(name,'texname,nil);
smacro procedure retractl(l); for each v in l do retract(car v);
smacro procedure gettexitem(a); get(a,'texname) or (get(a,'class)and a);
put ('texitem,'stat,'rlis); % handle argument passing for func. TeXitem
symbolic procedure texitem(arglist);
begin scalar x,ok,item,class,tag;
if length arglist neq 3
then rederr "Usage: TeXitem(item,class,width-list);";
item:=car arglist; class:= cadr arglist; tag:= caddr arglist;
ok:=memq(class,'(ord bin rel pct opn clo lop));
if not ok then << prin2 "% illegal item class "; print class >>;
if atom tag then ok:=nil else
<< if car(tag)='list then tag:=cdr tag; % accept algebraic lists
for each x in tag do if not numberp x then ok:=nil
>>;
if not ok then << prin2 "% illegal width tag "; print tag >>;
if ok then
<< item:=intern(item); put(item,'class,class); put(item,'textag,tag)
>>;
prin2 "% Item "; prin2 item;
if not ok then prin2 "not "; prin2 " added"; terpri();
return nil
end;
%ff
symbolic procedure makeitems(l);
for each w in l do
begin scalar iw;
iw:=intern(car w);
put(iw,'class,cadr w); put(iw,'textag,caddr w);
for each v in cdddr w do triassert(v,iw);
end;
fluid '(texunknowncounter!*);
texunknowncounter!*:= 0;
symbolic procedure unknownitem(a);
<< texunknowncounter!* := texunknowncounter!* +1;
prin2 "% non-fatal error: unknown atom "; prin2 a;
prin2 " replaced by ?_{"; prin2 texunknowncounter!*;
prin2 "}"; terpri();
'!? . '!_!{ . nconc(explode texunknowncounter!*, list '!})
>>;
symbolic procedure texexplode(a);
begin scalar b;
b:=if a and (atom a) then
(gettexitem(a)
or if numberp(a) then texcollect(explode(a))
else if stringp(a) then strcollect(explode2(a))
else texexplist(texcollect(explode2(a))));
b:=if null b then list '! else if not atom b then b else list b;
return b
end;
symbolic procedure texcollect(l);
for each el in l join
if null gettexitem(el) then unknownitem(el)
else gettexitem(el).nil;
smacro procedure strtexitem(e);
if e='! then list '!\! % space after ! is necessary
else if e='! then list '!\! % there is a tab before the "then"
else if liter(e) then {e}
else if gettexitem(e) then {gettexitem(e)}
else unknownitem(e); % or '! ;
symbolic procedure strcollect(l);
for each el in l join strtexitem el;
symbolic procedure texexplist(r);
begin scalar r,v;
v:=nil;
for each rl on r do
if digit(car rl) and not v then v:=rl
else if v and not digit(car rl) then v:=nil;
if v then
<< rplacd(v,car v.cdr v); rplaca(v,'!_!{); nconc(r,'!}.nil) >>;
return r
end;
%ff
makeitems('(
(! inn dmy) % no nonsense dummy item
(!{ inn beg) % begin of a TeX inner group
(!^!{ inn sup) % superscript
(!_!{ inn sub) % subscript nolimits
(!{!}!^!{ inn sup) % spread superscript
(!{!}!_!{ inn sub) % spread subscript
(!}!{ inn sep) % general group seperator
(!}!^!{ inn esp) % end of group and superscript
(!}!_!{ inn esb) % end of group and subscript
(!} inn end) % end of TeX inner group
(!\!f!r!a!c!{ inn frc recip quotient) % fraction group
(!\!s!q!r!t!{ inn frc sqrt) % square root
(!\!p!m!a!t!r!i!x!{ inn mat mat) % matrix group
(!& inn tab) % horizontal tabulation
(!\!c!r! inn cr ) % vertical tabulation
(!\!n!l! inn cr ) % vertical tabulation (special)
(!\!( opn (327680 276707 241208)) % test value
(!\!) clo (327680 276707 241208)) % ...
(!\!{ opn (327680 276707 241208)) % ...
(!\!} clo (327680 276707 241208)) % ...
(!\![ opn (0))
(!\!] clo (0))
(!\!< opn (254863 212082 195700))
(!\!> clo (254863 212082 195700))
(!\!, ord (80960))
(!\!q!u!a!d! rel (655360))
(! ord (0)) % dummy item
(!\!r!m! ord (0)) % dummy def of font change
(!\!i!t! ord (0)) % dummy def of font change
(!\!b!f! ord (0)) % dummy def of font change
(!\!h!b!o!x! ord (0)) % dummy def of box opening
(!! ord (182045 148367 131984))
(!? ord (309476 247127 211630))
(!\!l!b!r!a!c!e! ord (327681 268516 241211) !{)
(!\!r!b!r!a!c!e! ord (327681 268516 241211) !})
(!\!l!b!r!a!c!k! ord (182045 148367 131984) ![)
(!\!r!b!r!a!c!k! ord (182045 148367 131984) !])
(!\!b!a!c!k!s!l!a!s!h! ord (327681 268516 241211) !\)
(!\!% ord (546135 430537 359544) !%)
(!\!# ord (546135 430537 359544) !#)
(!\!& ord (509726 402320 336788) !&)
(!@ ord (509726 402320 336788))
(!\!_ ord (235930) !_)
(!\!$ ord (327681 261235 223008) !$)
(!; ord (182045 148367 131984))
(!: ord (182045 148367 131984))
(!. ord (182045 148367 131984))
(!, ord (182045 148367 131984))
(!| ord (182045 148367 131984))
(!' ord (183865 177267))
(!` ord (182045 148367 131984))
(!\! ord (218453))
%ff
% Fonts ammi10, ammi7, ammi5; ordered by index number
(!\!G!a!m!m!a! ord (394126 317121 266467))
(!\!D!e!l!t!a! ord (546133 451470 377742))
(!\!T!h!e!t!a! ord (481689 395400 331866))
(!\!L!a!m!b!d!a! ord (418702 346612 293546))
(!\!X!i! ord (447374 366819 309020))
(!\!P!i! ord (553870 446190 368185))
(!\!S!i!g!m!a! ord (511090 417791 348842))
(!\!U!p!s!i!l!o!n! ord (382293 320398 275342))
(!\!P!h!i! ord (436906 364088 309475))
(!\!P!s!i! ord (419430 354622 304150))
(!\!O!m!e!g!a ord (461596 382217 322806))
(!\!a!l!p!h!a! ord (419233 350253 299280))
(!\!b!e!t!a! ord (370688 303376 259231))
(!\!g!a!m!m!a! ord (353318 296277 256227))
(!\!d!e!l!t!a! ord (273066 229467 203070))
(!\!e!p!s!i!l!o!n! ord (266012 222822 197791))
(!\!z!e!t!a! ord (223686 195060 178221))
(!\!e!t!a! ord (352407 300373 261688))
(!\!t!h!e!t!a! ord (298553 247580 216177))
(!\!i!o!t!a! ord (231955 198883 180224))
(!\!k!a!p!p!a! ord (377590 315392 271246))
(!\!l!a!m!b!d!a! ord (382293 320398 275342))
(!\!m!u! ord (394885 326314 278528))
(!\!n!u! ord (341940 283534 244849))
(!\!x!i! ord (327680 276707 241208))
(!\!p!i! ord (370293 312456 270222))
(!\!r!h!o! ord (329728 269699 232379))
(!\!s!i!g!m!a! ord (361737 300646 258776))
(!\!t!a!u! ord (250083 220910 200430))
(!\!u!p!s!i!l!o!n! ord (354076 299008 259413))
(!\!p!h!i! ord (390485 322764 275888))
(!\!c!h!i! ord (410055 334506 283534))
(!\!p!s!i! ord (426894 357262 304924))
(!\!o!m!e!g!a! ord (407931 339968 290360))
(!\!v!a!r!e!p!s!i!l!o!n! ord (312433 358776 225097))
(!\!v!a!r!t!h!e!t!a! ord (388513 326997 281713))
(!\!v!a!r!p!i! ord (504945 424800 359719))
(!\!v!a!r!r!h!o! ord (329728 369699 232379))
(!\!v!a!r!s!i!g!m!a! ord (312433 258776 225097))
(!\!v!a!r!p!h!i! ord (465123 383749 323675))
% omitted: codes 40-47
(!0 ord (327680 276707 241208))
(!1 ord (327680 276707 241208))
(!2 ord (327680 276707 241208))
(!3 ord (327680 276707 241208))
(!4 ord (327680 276707 241208))
(!5 ord (327680 276707 241208))
(!6 ord (327680 276707 241208))
(!7 ord (327680 276707 241208))
(!8 ord (327680 276707 241208))
(!9 ord (327680 276707 241208))
(!. pct (182044 160198 150186) cons)
(!, rel (182044 160198 150186))
(!\co! rel (182044 160198 150186))
%ff
% omitted: code 60
(!/ bin (327680 262143 204800))
% omitted : codes 62,63
(!\!p!a!r!t!i!a!l! ord (384341 314982 268105) partdf df)
(!A ord (491520 404866 339057))
(!B ord (497095 406550 339569))
(!C ord (542583 439273 363451))
(!D ord (542583 439273 363451))
(!E ord (468400 387026 326360))
(!F ord (412330 331684 277845))
(!G ord (515276 418884 348660))
(!H ord (544768 439409 363520))
(!I ord (288085 236475 204913))
(!J ord (371825 302512 257706))
(!K ord (556373 450104 371598))
(!L ord (446008 369914 312888))
(!M ord (635790 512227 420408))
(!N ord (526563 424846 352142))
(!O ord (499893 409964 343244))
(!P ord (420750 341242 286606))
(!Q ord (518098 424527 354622))
(!R ord (482417 399041 335644))
(!S ord (392760 323128 274887))
(!T ord (382976 318122 272270))
(!U ord (447465 366409 309179))
(!V ord (375011 304014 260266))
(!W ord (577991 469310 389973))
(!X ord (533845 433811 359651))
(!Y ord (388210 317485 270506))
(!Z ord (429170 352256 397642))
% omitted: codes 91-96
(!a ord (346415 291999 253770))
(!b ord (281258 235383 207621))
(!c ord (283610 240571 212810))
(!d ord (341105 277890 242392))
(!e ord (283610 240571 212810))
(!f ord (320853 260778 224369))
(!g ord (300980 247580 215995))
(!h ord (377590 315392 271246))
(!i ord (231500 191601 174762))
(!j ord (238933 198883 177493))
(!k ord (341181 296265 248490))
(!l ord (195546 169756 157468))
(!m ord (575411 479687 402318))
(!n ord (393367 334051 288540))
(!o ord (317667 264510 230377))
(!p ord (329728 277435 242392))
(!q ord (292560 245577 215995))
(!r ord (277466 235292 208668))
(!s ord (307200 253041 219818))
(!t ord (234837 204799 186595))
(!u ord (375163 319487 277162))
(!v ord (317667 269881 236657))
(!w ord (463303 386389 327680))
(!x ord (361813 296732 253951))
(!y ord (321308 273066 239388))
(!z ord (304772 257137 225735))
% omitted: codes 123-127
%ff
% Fonts amsy10, amsy7, amsy5; not ordered.
(!+ bin (509724 422343 354986) plus)
(!- bin (509724 422343 354986) difference minus)
(!* ord (509724 422343 354986) hodge)
(!" ord (509724 422343 354986))
(!\!c!d!o!t! bin (182044 160198 150186) times)
(!= rel (509724 422343 354986) eq equal)
(!:!= rel (691771 550687 468772) setq)
(!\!s!u!m! lop (1000000 700000 500000) sum)
(!\!p!r!o!d! lop (1000000 700000 500000) prod)
(!\!i!n!t! lop (1000000 700000 500000) int)
(!\!l!i!m! ord (910221 771866 678114) limit limit!+ limit!-)
(!\!s!i!n! ord (804635 687398 612123) sin)
(!\!c!o!s! ord (877454 745653 657634) cos)
(!\!t!a!n! ord (946630 800994 700869) tan)
(!\!l!n! ord (700000 600000 500000) log)
(!\!e!x!p! ord (1001243 844685 735003) exp)
(!\!a!r!c!t!a!n! ord (1824539 1543734 1356227) atan)
(!\!w!e!d!g!e! ord (436908 353167 309480) wedge !^)
(!\!b!a!c!k!s!l!a!s!h! ord (327681 268516 241211) !\ setdiff)
(!\!d! ord (364090))
(!\!l!a!n!d! bin (436908 353167 309480) and)
(!\!l!o!r! bin (436908 353167 309480) or)
(!\!l!n!o!t! ord (436908 353167 309480) not)
(!\!c!a!p! bin (436908 353167 309480) intersection)
(!\!c!u!p! bin (436908 353167 309480) union)
(!\!i!n! rel (436908 353167 309480) member)
(!\!t!o! rel (655361 522469 446015))
(!\!u!p!a!r!r!o!w! rel (327681 268516 241211))
(!\!d!o!w!n!a!r!r!o!w! rel (327681 268516 241211))
(!< rel (509726 409601 354991) lessp)
(!> rel (509726 409601 354991) greaterp)
(!\!l!e!q! rel (509726 409601 354991) leq)
(!\!g!e!q! rel (509726 409601 354991) geq)
(!\!n!e!q! rel (509726 402230 336788) neq)
(!\!m!i!d! rel (182045 155648 150188) when)
(!\!f!o!r!a!l!l! ord (364090 296733 263968) !~)
(!\!R!i!g!h!t!a!r!r!o!w! rel (655361 522469 446015) replaceby)
(!( ord (254863 204801 177495))
(!) ord (254863 204801 177495))
(!\!i!n!f!t!y! ord (655361 522469 446015) infinity)
% The rest are non-standard TeX macros defined in tridefs.tex
(!\!c!d!o!t! ord (109224 89505 80403) times)
(!\!a!s!i!n! ord (1132319 906677 780527) asin)
(!\!a!c!o!s! ord (1205136 963111 826038) acos)
(!\!a!t!a!n! ord (1274315 1016723 869275) atan)
(!\!A!l!p!h!a! ord (491521 386847 321314))
(!\!B!e!t!a! ord (464215 366366 306295))
(!\!E!p!s!i!l!o!n! ord (446010 352257 294916))
(!\!Z!e!t!a! ord (400498 317669 268520))
(!\!E!t!a! ord (491521 386847 321314))
(!\!I!o!t!a! ord (236658 189328 162021))
(!\!K!a!p!p!a! ord (509726 400956 332691))
(!\!M!u! ord (600748 471498 389581))
(!\!N!u! ord (491521 386847 321314))
(!\!R!h!o! ord (446010 352257 294916))
(!\!T!a!u! ord (473316 374103 314031))
(!\!C!h!i! ord (491521 386847 321314))
(!\!O!m!e!g!a! ord (473316 374103 314031))
));
%ff
% ----------------------------------------------------------------------
% You can choose to have some default TEXNAME properties for your
% variables. Function "trimakeset" defines a set of such default names.
% If you want to activate the set, call "TeXassertset(<setname>)" , or
% if you want to deactivate the set, call "TeXretractset(<setname>)" .
% The current <setname>s available are:
% * GREEK : lowercase greek letters
% * LOWERCASE: roman lowercase letters
% ----------------------------------------------------------------------
% handle argument passing
deflist( '((texassertset rlis) (texretractset rlis)), 'stat);
symbolic procedure texassertset(arglist);
if length arglist neq 1 then rederr "Usage: TeXassertset(setname);"
else begin scalar sym; sym:= car arglist;
if get('texsym,sym) then
<< assertl(get('texsym,sym)); prin2 "% set ";
prin2 sym; prin2 " asserted"; terpri()
>> else << prin2 "% no such set"; terpri() >>
end;
symbolic procedure texretractset(arglist);
if length arglist neq 1 then rederr "Usage: TeXretractset(setname);"
else begin scalar sym; sym := car arglist;
if get('texsym,sym) then
<< retractl(get('texsym,sym)); prin2 "% set ";
prin2 sym; prin2 " retracted"; terpri()
>> else << prin2 "% no such set"; terpri() >>
end;
symbolic procedure trimakeset(sym,a!_set);
<<put('texsym,sym,a!_set); nil>>;
trimakeset('greek,'(
(alpha !\!a!l!p!h!a! )
(beta !\!b!e!t!a! )
(gamma !\!g!a!m!m!a! )
(delta !\!d!e!l!t!a! )
(epsilon !\!e!p!s!i!l!o!n! )
(zeta !\!z!e!t!a! )
(eta !\!e!t!a! )
(theta !\!t!h!e!t!a! )
(iota !\!i!o!t!a! )
(kappa !\!k!a!p!p!a! )
(lambda !\!l!a!m!b!d!a! )
(mu !\!m!u! )
(nu !\!n!u! )
(xi !\!x!i! )
(pi !\!p!i! )
(rho !\!r!h!o! )
(sigma !\!s!i!g!m!a! )
(tau !\!t!a!u! )
(upsilon !\!u!p!s!i!l!o!n! )
(phi !\!p!h!i! )
(chi !\!c!h!i! )
(psi !\!p!s!i! )
(omega !\!o!m!e!g!a! ) ));
trimakeset('lowercase,'(
(a !a) (b !b) (c !c) (d !d) (e !e) (f !f) (g !g) (h !h) (i !i) (j !j)
(k !k) (l !l) (m !m) (n !n) (o !o) (p !p) (q !q) (r !r) (s !s) (t !t)
(u !u) (v !v) (w !w) (x !x) (y !y) (z !z) ));
trimakeset('!Greek,'(
(!Alpha !\!A!l!p!h!a! )
(!Beta !\!B!e!t!a! )
(!Gamma !\!G!a!m!m!a! )
(!Delta !\!D!e!l!t!a! )
(!Epsilon !\!E!p!s!i!l!o!n! )
(!Zeta !\!Z!e!t!a! )
(!Eta !\!E!t!a! )
(!Theta !\!T!h!e!t!a! )
(!Iota !\!I!o!t!a! )
(!Kappa !\!K!a!p!p!a! )
(!Lambda !\!L!a!m!b!d!a! )
(!Mu !\!M!u! )
(!Nu !\!N!u! )
(!Xi !\!X!i! )
(!Pi !\!P!i! )
(!Rho !\!R!h!o! )
(!Sigma !\!S!i!g!m!a! )
(!Tau !\!T!a!u! )
(!Upsilon !\!U!p!s!i!l!o!n! )
(!Phi !\!P!h!i! )
(!Chi !\!C!h!i! )
(!Psi !\!P!s!i! )
(!Omega !\!O!m!e!g!a! ) ));
trimakeset('!Uppercase,'(
(!A !A) (!B !B) (!C !C) (!D !D) (!E !E) (!F !F) (!G !G) (!H !H) (!I !I)
(!J !J) (!K !K) (!L !L) (!M !M) (!N !N) (!O !O) (!P !P) (!Q !Q) (!R !R)
(!S !S) (!T !T) (!U !U) (!V !V) (!W !W) (!X !X) (!Y !Y) (!Z !Z) ));
%ff
% ----------------------------------------------------------------------
% Section 2: Inserting Glue into a TeX-Item-List
% ----------------------------------------------------------------------
%
% Glue Items to be inserted between consecutive TeX-Items (similar to
% what TeX does with its items, but this table is slightly modified.)
%
% Class|ORD|LOP|BIN|REL|OPN|CLO|PCT|INN|
% -----+---+---+---+---+---+---+---+---+
% ORD | 0 | 1 |(2)|(3)| 0 | 0 | 0 | 0 |
% LOP | 1 | 1 | * |(3)| 0 | 0 | 0 |(1)|
% BIN |(2)|(2)| * | * |(2)| * | * |(2)|
% REL |(3)|(3)| * | 0 |(3)| 0 | 0 |(3)| columns: right items
% OPN | 0 | 0 | * | 0 | 0 | 0 | 0 | 0 | lines: left items
% CLO | 0 | 1 |(2)|(3)| 0 | 0 | 0 | 0 |
% PCT |(1)|(1)| * |(1)|(1)|(1)|(1)|(1)|
% INN | 0 | 1 |(2)|(3)|(1)| 0 |(1)| 0 |
% -----+---+---+---+---+---+---+---+---+
%
% The glue items and its meanings:
% 0 ......... no space
% 1 (1) ..... thin space (no space if sub-/superscript)
% 2 (2) ..... medium space (no space if sub-/superscript)
% 3 (3) ..... thick space (no space if sub-/superscript)
% * ......... this case never arises (really?)
% ----------------------------------------------------------------------
symbolic procedure makeglue(mx);
if null mx then nil else
begin
scalar id1,id2,row,col;
row:=cdr mx; id1:=car mx;
while(row) do
<< id2:=car mx; col:=car row;
while (col) do
<< put(car id1,car id2,car col);
col:=cdr col; id2:=cdr id2
>>;
row:=cdr row; id1:=cdr id1
>>
end;
makeglue('(
(ord lop bin rel opn clo pct inn)
( 0 1 -2 -3 0 0 0 0 )
( 1 1 0 -3 0 0 0 -1 )
(-2 -2 0 0 -2 0 0 -2 )
(-3 -3 0 0 -3 0 0 -3 )
( 0 0 0 0 0 0 0 0 )
( 0 1 -2 -3 0 0 0 0 )
(-1 -1 0 -1 -1 -1 -1 -1 )
( 0 1 -2 -3 -1 0 -1 0 )
));
smacro procedure kindof(item); get(item,'textag);
smacro procedure classof(item); get(item,'class);
%ff
smacro procedure groupbeg(kind); % beginning of a group
memq(kind,'(beg sup sub frc mat));
smacro procedure groupend(kind); (kind='end);
smacro procedure grouphs(kind); (kind='tab);
smacro procedure groupvs(kind); % vertical group seperator
memq(kind,'(esp esb sep cr));
symbolic procedure interglue(left,right,depth,nesting);
% compute the glue to be inserted between two TeX items
% parameters: left,right .......... left/right TeX item
% depth ............... superscript/subscript level
% nesting ............. depth of parenthesis level
% a glue item is a list consisting of two numbers, i.e.
% (<width> <penalty>)
% where <width> is the width of the glue in scaled points and <penalty>
% is a negative numeric value indicating 'merits' for a breakpoint.
if (null left)or(null right)or(not atom left)or(not atom right) then nil
else begin
scalar glue,lc,rc; % glue code and item classes
lc:=classof(left); rc:=classof(right); glue:=get(lc,rc);
if null(glue) then return nil;
if (left='!\co! ) then return(list(0,-10000));
if glue<0 then if depth>0 then return nil else glue:=(-glue);
if glue=1 then return(list(80960,nesting*10 +20))
else if glue=2 then
<< if (left='!+ or left='!-) then return nil;
if (right='!+) then return(list(163840,nesting*30-390));
if (right='!- and (lc='ord or lc='clo))
then return(list(163840,nesting*30-210));
if (left='!\!c!d!o!t! ) then return(list(163840,nesting*10+50));
if (right='!\!c!d!o!t! ) then return nil;
return(list(163840,nesting*10))
>>
else if glue=3 then return(list(655360,nesting*10-50)) else return nil
end;
symbolic procedure insertglue(term);
% insert glue into a TeX-Item-List
begin
scalar glueitem,succ,pred,prev,backup; integer depth,nesting;
depth:=nesting:=0; succ:=nil; backup:=term;
while term do
<< pred:=succ; succ:=car term;
glueitem:=interglue(pred,succ,depth,nesting);
if glueitem then rplacd(prev,glueitem.term);
prev:=term; term:=cdr term;
if classof(succ)='inn then
<< if (groupbeg kindof succ) and
(not ((kindof(succ)='frc) and (depth=0)))
then depth:=depth+1
else if (groupend kindof succ) and (depth>0) then depth:=depth-1
>>
else if classof(succ)='opn then nesting:=nesting+1
else if classof(succ)='clo then nesting:=nesting-1
>>;
return(backup)
end;
%ff
% ----------------------------------------------------------------------
% Section 3 : Line Breaking
% ----------------------------------------------------------------------
%
% How to break up a TeX item list into several independent lines
% ----------------------------------------------------------------------
% Setting break points requires "breaklists". A breaklist is a sequence
% of passive and active nodes, where each active node is followed by an
% pasive node and vice versa. Active nodes represent glue items. Passive
% nodes are integer atoms which represent the width of a sequence of or-
% dinary TeX items. This sequence must not be interspersed with glue
% items. Every breaklist consists of at least one passive node surroun-
% ded by delta nodes representing the beginning and ending of the list.
% <breaklist> ::= ( <delta-node> <passive-node> <active-node> ...
% <passive-node> <active_node> ...
% <passive-node> <delta-node>)
% <active-node> ::= ( <width> <penalty> <offset> )
% <passive-node> ::= <width>
% <delta-node> ::= ( <width> <penalty> <offset>
% <id-num> <ptr> <demerits> <indentation> )
% The breaklist will be created using the function "breaklist". Setting
% the break points (i.e. break items) in the breaklist is done using the
% functions "trybreak". During this phase, some active nodes are con-
% sidered to be "feasible" break points. Thus, they will be extended and
% named "delta nodes" furtheron. By default the first and last node in a
% breaklist are delta nodes. When trybreak has finished, the <ptr>'s of
% the delta nodes recursively pointed to from the last delta node's
% <ptr> represent the best path for breaking the whole breaklist.
% It is:
% <width> : width of item (including glue items)
% <penalty> : a numeric value which prohibits line breaking (if
% negative, line breaking will be merited)
% <offset> : distance to most previous opening bracket
% <id-num> : the identity number of the delta node {1,2,3,...}
% <ptr> : pointer to the best delta node to come from with
% respect to the minimal demerits path. note: a zero
% pointer indicates the very bottom of the stack
% <demerits> : total demerits distance to delta node which is
% pointed to by <ptr>
% <indentation>: amount of indentation when breaking at this point
% ----------------------------------------------------------------------
%ff
symbolic procedure width(item,style);
begin scalar tag;
tag:=get(item,'textag);
if null tag then tri!-error(list("cannot find item ",item),'fatal);
while (style>0)and(cdr tag) do << tag:=cdr tag; style:=style-1 >>;
return car tag or 0
end;
smacro procedure sp2mm(x); (x/186468); % scaled points to millimeters
symbolic procedure settolerance(tol);
<< if tol<0 then tol:=0 else if tol>10000 then tol:=10000;
prin2 "% \tolerance "; print tol; tolerance!*:=tol; nil
>>;
symbolic procedure setpagewidth(hsize);
% hsize can be given either in millimeters or scaled points.
<< if hsize>400 then hsize!*:=hsize else hsize!*:=hsize*186468;
prin2 "% \hsize="; prin2 sp2mm(hsize!*); prin2 "mm"; terpri();
hss!*:=float hsize!*/6; % default stretch/shrink width
hww!*:=float (3*hsize!*)/4; % optimum line width
>>;
symbolic procedure setbreak(hsize,tol);
<< settolerance(tol); setpagewidth(hsize) >>;
smacro procedure badness(hlen,ibadness);
% The badness is 100*(hlen/hss)**3, corrected for indentation badness
begin
real r;
r:=abs(hlen-hww!*)/hss!*;
return fix min(10000.0,r*r*r*100.0+ibadness)
end;
smacro procedure isglue(l); (not atom l) and (numberp car l);
smacro procedure isactive(x); not numberp x;
smacro procedure ispassive(x); numberp x;
smacro procedure isdelta(x); cdddr x;
smacro procedure addup(x); if x then eval('plus.x) else 0;
smacro procedure tpush(stack,item); stack:=item.stack;
smacro procedure tpop(stack);
if null stack then nil % Error
else begin scalar z; z:=car stack; stack:=cdr stack; return(z) end;
smacro procedure poke(stack,ptr,val);
if null ptr then stack:=nconc(stack,val.nil)
else << if val>car(ptr) then rplaca(ptr,val); ptr:=cdr ptr >>;
smacro procedure concatenate(l);
begin scalar r;
for each e in l do r:=nconc(r,explode e);
return compress r
end;
%ff
% ----------------------------------------------------------------------
% Section 3.1: Resolving Fraction Expressions
% ----------------------------------------------------------------------
symbolic procedure resolve(term);
% resolve a \frac{...}{...} sequence and transform it into a .../...
% sequence, where any ... argument may become parenthesized depending on
% the question if there is any non-ORD-class item within this argument.
% Furthermore, resolve a \sqrt{...} expression to \(...\)^{\frac{1}{2}}.
begin
scalar item,l,m,r,lflag,rflag;
integer depth;
l:=term; % save pointer to functor
depth:=0; m:=r:=lflag:=rflag:=nil; item:=t;
while term and item do
<< item:=car term; % take first item from list
if classof(item)='inn then % check inner class item
<< item:=kindof(item);
if groupbeg(item) then depth:=depth+1
else if groupend(item) then
if depth=1 then % outermost level ?
<< r:=term; item:=nil % save pointer to right bracket
>> % and quit using item as a flag
else depth:=depth-1
else if groupvs(item) then % if outermost level then save
if (depth=1) then m:=term % pointer to intermediate brackets
>>
else if not(classof(item)='ord) then % non-ORD-class item ?
<< if m then rflag:=t else lflag:=t
>>;
term:=cdr term % step ahead
>>;
if car l='!\!f!r!a!c!{ then
<< if lflag and rflag
then item:=list('!/,list(655360,-10000))
else item:=list('!/);
if lflag then << rplaca(l,'!\!(); item:='!\!).item >>
else rplaca(l,'! );
if rflag then << rplaca(r,'!\!)); nconc(item,'!\!(.nil) >>
else rplaca(r,'! );
rplaca(m,car item); item:=cdr item;
if item then rplacd(m,nconc(item,cdr m))
>> else if car l='!\!s!q!r!t!{ then
<< rplaca(l,'!\!(); rplaca(r,'!\!));
rplacd(r,'!^!{ . '!1 . '!/ . '!2 . '!} . cdr r)
>>;
return(l) % return changed list pointer
end;
%ff
% ----------------------------------------------------------------------
% Section 3.2 : Create a Break List
% ----------------------------------------------------------------------
symbolic procedure breaklist(term);
begin
scalar item,result,kind,vstack,hstack,fstack,pstack,p,flag,backup;
integer depth,acc,aux,lopw,total,indent;
p:=result:=vstack:=hstack:=fstack:=nil; backup:=term;
depth:=total:=acc:=lopw:=indent:=0;
while term do
<< item:=car term; flag:=t; % get first item from term
if null item
then tri!-error(list("found NIL in term : ",backup),'fatal);
if (isglue(item)) then % do we have glue ahead ?
if (depth<1) then % are we on the top level ?
<< % insert a passive node followed by an active node, clear acc.
total:=total+acc+car item; nconc(item,indent.nil);
result:=nconc(result,acc.item.nil); acc:=0
>>
else acc:=acc+car item % add up glue width
else if (classof(item)='lop) then lopw:=width(item,depth)
else if classof(item)='inn then
<< kind:=kindof(item);
if kind='frc then
<< tpush(fstack,term); tpush(fstack,depth)
>>;
if groupend(kind) then % end of TeX group ?
<< depth:=depth-1; % decrement term depth
if acc>0 % if <acc> hasn't been poked
then poke(vstack,p,acc); % yet, then poke it
acc:=tpop(hstack); % get old acc value
aux:=addup(vstack); % compute vstack width
if fstack and (depth=car fstack) then
<< tpop(fstack); % first waste depth info
if aux>hww!* then % check if it doesn't fit
<< term:=resolve tpop fstack;% resolve fraction
flag:=nil % evaluate new list
>>
else % waste fraction term pointer
<< tpop(fstack); acc:=acc+aux
>>
>> else acc:=acc+aux;
p:=tpop(hstack); vstack:=tpop(hstack) % reset old status
>>
else if groupbeg(kind) then % begin of TeX group ?
<< depth:=depth+1; % increment term depth
tpush(hstack,vstack); % save current <vstack> and
tpush(hstack,p); % current <p> as well as
tpush(hstack,acc); % current <acc> to <hstack>
acc:=0; p:=vstack:=nil; % clear vertical stack
if lopw>0 then poke(vstack,p,lopw); lopw:=0
>>
else if grouphs(kind) then % horizontal separator ?
<< poke(vstack,p,acc); acc:=0 % poke <acc> to <vstack>
>>
else if groupvs(kind) then % vertical separator ?
<< poke(vstack,p,acc); acc:=0; p:=vstack % reset
>>
>>
%ff
else if depth<1 then
<< aux:=width(item,depth); % add up item width
if classof(item)='opn then
<< tpush(pstack,indent); indent:=total+acc+aux
>>;
if classof(item)='clo then indent:=tpop(pstack) or 0;
acc:=acc+aux
>>
else acc:=acc+width(item,depth); % add up item width
if lopw>0 then << acc:=acc+lopw; lopw:=0 >>;
if flag then term:=cdr term
>>;
if acc then total:=total+acc;
if (total<hsize!*) then return nil % need no breaking
else return(list(0,0,0,0,0,0,0).nconc(result,acc.
list(0,0,total,-1,0,2147483647,0).nil)) % return break list
end;
%ff
% ----------------------------------------------------------------------
% Section 3.3 : Major Line Breaking Routine
% ----------------------------------------------------------------------
smacro procedure widthof(deltanode); car deltanode;
smacro procedure penaltyof(deltanode); cadr deltanode;
smacro procedure totalof(deltanode); cadr deltanode;
smacro procedure offsetof(deltanode); caddr deltanode;
smacro procedure idof(deltanode); cadddr deltanode;
smacro procedure ptrof(deltanode); car cddddr deltanode;
smacro procedure indentof(deltanode); caddr cddddr deltanode;
smacro procedure tailof(deltanode); cddddr deltanode;
symbolic procedure offsetitem(item);
concatenate list('!\!o!f!f!{,item,'!} );
smacro procedure stepahead(ptr,val);
<< if ispassive car ptr then val:=val+car ptr else val:=val+caar ptr;
ptr:=cdr ptr
>>;
smacro procedure findindent(offt,ptr);
if offt=lastoff and ptr=lastptr then lastindent else
begin % search the deltastack for previous indentation
scalar node,p,stack; integer tot;
stack:=deltastack; p:=lastptr:=ptr; lastoff:=offt;
while stack do
<< if p=idof (node:=car stack) then
<< p:=ptrof node; tot:=totalof node;
if tot<offt then stack:=nil
>>;
if stack then stack:=cdr stack;
>>;
return(lastindent:=offt-tot+indentof node)
end;
%ff
symbolic procedure trybreak(term,brkl);
% parameters: term .... TeX item list, as created by "interglue"
% brkl .... the breaklist to be processed by this routine
begin
scalar bottom,top,base,item,deltastack,pred;
integer depth; % depth of expression when rebuilding
integer feasible,id; % number of feasible delta node
integer len,total; % current and total length so far
integer dm,basedm; % current and base demerits
integer bd; % current badness
integer penalty;
integer offset,baseoffset; % current and base parenthesis offset
integer baseptr; % pointer to best way to come from
integer indent,baseindent; % current and base indentation
integer lastoff,lastindent,lastptr; % temp. var. for speedup
real indentbadness; % correction for indentation badness
if null brkl then goto retain;
bottom:=brkl;
lastoff:=lastptr:=lastindent:=feasible:=indent:=total:=0;
while bottom do
<< top:=cdr bottom; base:=car bottom; pred:=tailof base;
id:=idof base; % id of current delta node
if penaltyof base=-10000 % break item ?
then rplaca(cdr pred,0); % new line
basedm:=cadr pred; % demerits so far
% save the delta node to the delta-stack. thus deltastack holds
% all the feasible breakpoints in reverse order.
deltastack:=base.deltastack;
len:=baseindent:=indentof(base); % indentation for this line
indentbadness:=2500.0*(float(baseindent)/float(hww!*));
baseoffset:=offsetof base;% current offset amount
baseptr:=car pred; % pointer to best node to come from
total:=total+widthof base;% correct total length
%--- debug ---
% prin2 "Base ["; prin2 id; prin2 "] basedm="; prin2 basedm;
% prin2 " ibd="; prin2 indentbadness;
% prin2 " indent="; prin2 baseindent; terpri();
%--- debug ---
%ff
while top and len<hsize!* do % loop once thru a potential line
% note that we use the local hsize instead of the full hsize
<< item:=car top;
if ispassive(item) then len:=len+item else
<< bd:=badness(len,indentbadness);
penalty:=penaltyof item;
offset:=offsetof item;
if (bd<tolerance!*) % is the breakpoint feasible?
or (bd+penalty<1) % got a break bonus ?
or (null cdr top) then % or did we reach last delta node?
<< dm:=bd*bd+basedm+penalty*abs(penalty);
if isdelta(item) then
<< pred:=tailof item;
if dm<cadr pred then % found a better path?
<< % save the pointer to best breakpoint to come from
% and the minimum demerits to reach it
rplaca(pred,id); rplaca(cdr pred,dm);
if !*texindent then % save the current indentation
<< if offset>total
then indent:=offset-total+baseindent
else if offset<baseoffset
then indent:=findindent(offset,baseptr)
else indent:=baseindent;
rplaca(cddr pred,indent)
>>
>>
>>
else % create a new delta node
<< feasible:=feasible+1;
if !*texindent then
if offset>total
then indent:=offset-total+baseindent
else if offset<baseoffset
then indent:=findindent(offset,baseptr)
else indent:=baseindent
else indent:=0;
rplacd(cddr item,feasible.id.dm.indent.nil)
>>;
%--- debug ---
% prin2 "-->["; prin2 idof item; prin2 "] dm="; prin2 dm;
% prin2 " bd="; prin2 bd; prin2 " p="; prin2 penalty;
% if !*TeXindent then << prin2 " ind="; prin2 indent >>; terpri();
%--- debug ---
if penalty=-10000 then top:=nil
>>;
len:=len+car item % count the length anyway
>>;
if top then top:=cdr top
>>;
%ff
rplaca(cdr base,total); % replace penalty by total width so far
bottom:=cdr bottom; % depart from this delta node
while bottom and (ispassive(car bottom) or not isdelta(car bottom))
do stepahead(bottom,total); % move to next delta node in list
>>;
bottom:=deltastack; feasible:=-1; top:=nil;
while bottom do % loop thru the delta-node stack
<< id:=idof car bottom; % id is the current id number
if id=feasible then % is this node the one pointed to?
<< feasible:=ptrof car bottom; % feasible is the new back-pointer
top:=id.top; % save the path element
>>;
bottom:=cdr bottom % step ahead
>>; % now deltastack contains the best path
deltastack:=cdr top; % in forward order
%--- debug ---
% print term; print deltastack;
%--- debug ---
if car deltastack= -1 then
<< prin2 "% Warning: no suitable way of breaking found"; terpri();
prin2 "% ======== retry with a greater tolerance..."; terpri();
prin2 "% (output will produce overfull box if printed)"; terpri()
>>;
brkl:=cdr brkl; % strip the dummy node at the list's head
%ff
% --------------------------------------------------------------------
% now remove all glue items but retain all break items
retain: % ------------------------------------------------------------
offset:=depth:=0; bottom:=term;
if brkl then brkl:=cdr brkl; % ensure first item is an active node
while term and (cdr term) do
<< item:=car term;
if isglue(item) then % if this is a glue item
if (depth=0) and brkl then % and we are on the top level
<< top:=car brkl;
if isdelta(top) then % consider delta nodes only
<< if (idof top=car deltastack) then % break point?
<< deltastack:=cdr deltastack;
%--- debug ---
% prin2 "% ["; prin2 idof top; prin2 "] ";
% prin2 sp2mm(totalof(top)+indentof(top)-offset); terpri();
% offset:=totalof(top);
%--- debug ---
if (len:=indentof top)>0
then rplacd(pred,'!\!n!l! . offsetitem(len) . cdr term)
else rplacd(pred,'!\!n!l! . cdr term)
>>
else rplacd(pred,cdr term)
>>
else rplacd(pred,cdr term);
if brkl and (cdr brkl) % check for next active node
then brkl:=cddr brkl % skip to next active node
>>
else rplacd(pred,cdr term) % remove glue item
else if classof(item)='inn then
<< if groupbeg(kindof(item)) then depth:=depth+1 else
if groupend(kindof(item)) then depth:=depth-1
>>;
pred:=term; term:=cdr term
>>;
%--- debug ---
% top:=car term; prin2 "% [-1] ";
% prin2 sp2mm(totalof(top)+indentof(top)-offset); terpri();
%--- debug ---
return(bottom)
end;
%ff
% ----------------------------------------------------------------------
% Section 4 : Output of TeX-Code
% ----------------------------------------------------------------------
symbolic procedure texstrlen(s);
begin
integer length;
scalar flag;
length:=0; flag:=nil;
for each c in s do
if not flag and c='!! then flag:=t
else << length:=length+1; flag:=nil >>;
return length
end;
smacro procedure newline();
if nlflag then cc:=indent
else if (cc>indent) then << terpri(); cc:=indent; nlflag:=t >>;
%ff
symbolic procedure texout(itemlist,flag);
if null itemlist then nil else
begin
integer cc,len,indent,ccmax,lines;
scalar item,class,tag,oldtag,lasttag,indentstack,ispd,nlflag;
ccmax:=64; cc:=indent:=lines:=0; % initializations
tag:=ispd:=nlflag:=indentstack:=nil; % initializations
prin2('!$!$); % begin TeX math group
if flag then prin2('!\!d!i!s!p!l!a!y!l!i!n!e!s!{!\!q!d!d);
terpri(); % start new line
while itemlist do
<< item:=car itemlist; itemlist:=cdr itemlist;
len:=texstrlen(explode(item)); oldtag:=nil; lasttag:=tag or class;
class:=classof(item); tag:=(class='inn)and(kindof(item));
%ispd:=(class='ORD)and itemlist and(classof(car itemlist)='OPN);
if (tag='mat)or(tag='frc)or(class='opn) %or ispd
then newline(); % start new line
if (groupbeg(tag))or(class='opn) then
<< tpush(indentstack,indent); % push it to the stack
tpush(indentstack,lasttag); % the reason for pushing
if (cc+cc < ccmax) % within left half of page ?
then if ((class='opn)and(lasttag='ord))or % predicate?
(groupbeg(tag)and not((tag='frc)or(tag='mat)))
then indent:=cc+len % take current position
else indent:=indent+len % compute new indentation
>>
else if (groupend(tag))or(class='clo) then
<< oldtag:=tpop(indentstack); indent:=tpop(indentstack)
>>;
if (cc+len > ccmax) or % beyond right margin ?
(item='!+)or(item='!-)or(class='clo) % important item?
then newline();
if nlflag then << nlflag:=nil; spaces(cc) >>;
if tag='cr then lines:=lines+1;
if not(item='! ) then prin2(item); % print the item and
cc:=cc+len; % count the characters
if groupvs(tag) or % vertical seperator ?
(groupend(tag) and % end of a large group,
((oldtag='frc) or (oldtag='mat)))% i.e. fraction, matrix ?
or (class='clo) or % closing parenthesis ?
(((class='rel)or(class='bin))and % binary/relational operator?
(cc+cc+cc > ccmax+ccmax)) % within last third of page?
or item='!, or null class
then newline()
>>;
newline(); % start final line
if flag then
if lines=0 then prin2('!\!c!r!})
else prin2('!\!N!l!}); % end multi-line output
prin2('!$!$); terpri(); return(nil) % end math group
end;
%ff
% ----------------------------------------------------------------------
% Section 5: User Interface
% ----------------------------------------------------------------------
% handle argument passing for following the functions, compelling that
% properties are used during compile time
deflist( '((texdisplay rlis) (texlet rlis)), 'stat);
algebraic procedure texsetbreak(hsize,tol); lisp setbreak(hsize,tol);
algebraic procedure textolerance(tol); lisp settolerance(tol);
algebraic procedure texpagewidth(hsize); lisp setpagewidth(hsize);
symbolic procedure texlet(arglist);
begin scalar class,sym,item;
if length arglist neq 2 then rederr "Usage: TeXlet(symbol,item);";
sym:= car arglist; item:=intern cadr arglist; class:=classof(item);
if null class then
<< prin2 "% No such TeX symbol available"; terpri()
>>
else if (class='inn) then % prevent from TeXequiv'ing inner symbols
<< prin2 "% cannot assign inner TeX symbols yet"; terpri()
>>
else triassert(sym,item);
return nil
end;
symbolic procedure texdisplay(arglist);
begin scalar item,tag,class;
if length arglist neq 1 then rederr "Usage: TeXdisplay(item);";
item:=get(car arglist,'texname);
if not item then
<< prin2 "% "; prin2 car arglist; prin2 " is not defined"; terpri()
>>;
if not item then return nil;
tag:=get(item,'textag); class:=get(item,'class);
prin2 "% TeX item "; prin2 item; prin2 " is of class "; prin2 class;
prin2 " and has following widths: "; terpri(); prin2 "% ";
for each w in tag do
begin real v; v:=w/65536.0; prin2 v; prin2 "pt " end;
terpri(); return nil
end;
% ----------------------- share name between both modes ----------------
symbolic operator texlet;
symbolic operator texitem;
symbolic operator texdisplay;
symbolic operator texassertset;
symbolic operator texretractset;
% ------------------------ Default Initializations ---------------------
<< prin2 "% TeX-REDUCE-Interface 0.70"; terpri() >>;
texassertset(greek); texassertset(lowercase);
texassertset '!Greek; texassertset '!Uppercase;
textolerance(10); texpagewidth(150);
endmodule;
end;