=========================================================================
SI_TEX.CHA Change file for SISISI-hyphenation in TeX 3.1 16.7.1991
(c) for SISISI-hyphenation: Wilhelm Barth, Heinrich Nirschl
(c) for TeX changes: Heini Hofstaedter, Harald Mueller
additional changes until 10. October 1991 HH
=========================================================================
This is the change file for inclusion of SISISI into TeX V.3.14.
There are three main changes in this file (which are of course quite
intermingled):
1) the replacement of Liang's hyphenation by SISISI.
2) the change of the interface of the actual hyphenation
to the post-hyphenation and the line-break algorithm.
This change is necessary because in original TeX, only the
information "hyphen - no hyphen" can be transmitted to the
line break algorithm because of two "bottlenecks":
1. Hyphenation --> Post-Hyphenation: Here a hyphen at position i
is marked by the 1-bit information odd(hyf[i]).
2. Post-Hyphenation --> Line-Breaking: Here a hyphen is marked
by the existence of a discretionary node.
From SISISI, there must be more information flowing to the
line-break algorithm:
a. Is a hyphen a main hyphen or a "nebenhyphen"? To this end,
a change is made such that a penalty node is allowed as
the first node in the prebreak list of a discretionary
node. This penalty node contains the penalty associated with
this specific hyphen. For "nebenhyphens", this value is set
by an additional primitive "\nebenhyphenpenalty".
Instead of the hyf-array, an array hyfpen is used that
contains the actual penalties; the old "if odd(hyf[i])" now
is converted ti "if hyfpen[i] <> inf_penalty".
b. A hyphen may be more complicated than a single -: ck-hyphens
and triple-consonant-hyphens may be present. To include these,
another array hyf_disc is introduced that contains ready-made
discretionary nodes for such hyphens.
At first, we simply wanted to include these discretionary
during the post-hyphenation into the new node list. But then
Heini felt that the impossiblity of ligatures with parts of such
a discretionary node was not acceptable; therefore he introdiced
the "x-mechanism" (characterized by many variables starting with
"x") and changed the reconstitute function so that more than the
single hyphen_char could be introduced into the reconstitution
process.
3) "Dirty" changes for the hyphenation of words with umlauts.
These changes are necessary because the umlauts in TeX are not
(necessarily) real characters, but something else (see definition
of umlauts in plain.tex or german.tex).
Ordinarily, the hyphenation only accepts sequences of letters,
ligatures (which are expanded to their single characters), and
so-called "implicit kerns". An umlaut, however, is usually
represented as a letter character and another character consisting
of two dots ("dieresis character"), which are connected by
explicit kerns (not implicite ones!). Therefore, words containing
umlauts are not hyphenable words in TeX, which is not acceptable
for german texts.
Therefore, we devised a "bypass" for umlauts as follows: An umlaut
is now represented as a special discretionary node (so-called
"dirty umlaut") as follows:
\discretionary{\kern4321sp m\kern<code>sp\kern<back>sp\kern-1em}%
{}%
{<umlaut>}
where the 4321sp is a "marker" for the "dirty umlaut", the "m"
letter is used to derive the font of the umlaut, <code> is
the font number that should be associated with this umlaut (the
font numbers of the umlauts are given below); and <back> is used
to cancel the preceding kerns, i.e.\ <back> = - (4321 + <code>).
In other words, the prebreak list contains the information that
this is an umlaut (albeit a "dirty" one) and some more
information needed for the hyphenation, the postbreak list is
empty, and the main list contains the umlaut proper. By a
special if-statement in the line-break algorithm, a hyphenation
at a discretionary node of this format is suppressed, so that
always the umlaut of the main list is printed.
The font numbers for the lowercase umlauts (which are given
in the second \kern node) must be:
ae 228
oe 246
ue 252
The codes for the uppercase umlauts can be chosen arbitrarily.
In order to get the hyphenation for these "dirty umlauts"
running, one must include lccode assignments of the form
\lccode<code>=<lccode>
for each of the new letters (see example below).
A typical declaration of the "dirty umlauts" runs like this:
%%%%%%%%%%%%%%%%%%%%% declaration of dirty umlauts %%%%%%%%%%%%%%%%%%%%%%
\def\A"{\discretionary{\kern 4321sp m\kern 196sp\kern-4517sp\kern-1em}{}{\"A}}
\def\a"{\discretionary{\kern 4321sp m\kern 228sp\kern-4549sp\kern-1em}{}{\"a}}
\def\O"{\discretionary{\kern 4321sp m\kern 214sp\kern-4535sp\kern-1em}{}{\"O}}
\def\o"{\discretionary{\kern 4321sp m\kern 246sp\kern-4567sp\kern-1em}{}{\"o}}
\def\U"{\discretionary{\kern 4321sp m\kern 220sp\kern-4541sp\kern-1em}{}{\"U}}
\def\u"{\discretionary{\kern 4321sp m\kern 252sp\kern-4573sp\kern-1em}{}{\"u}}
\lccode196=228 % uppercase umlaut A
\lccode214=246 % uppercase umlaut O
\lccode220=252 % uppercase umlaut U
\lccode228=228 % uppercase umlaut a
\lccode246=246 % uppercase umlaut o
\lccode252=252 % uppercase umlaut u
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
When (if?) one day N.Schwarz's DC/EC fonts arrive, the changes of the
third kind can be eliminated. How long this will take ... well, wait and
see.
But when they arrive, it's not longer possible to choose the codes for
uppercase umlauts arbitrarily. The codes for uppercase umlauts will
then be those, shown in the example above.
=========================================================================
At first, we add a control sequence \SISISI.
@x
\def\PASCAL{Pascal}
@y
\def\SISISI{{\sl SISISI}}
\def\PASCAL{Pascal}
\let\maybe=\iffalse % print only changed modules
@z
-------------------------------------------------------------------------
@x
@d banner=='This is TeX, Version 3.14' {printed when \TeX\ starts}
@y
@d banner=='This is TeX, Version 3.14 (+SISISI 1.0)'
@z
-------------------------------------------------------------------------
A number of procedures of SISISI are declared after the TeX program. As
these procedures are used in the hyphenation, of course, they must be
declared as `forward'.
In web2c gibt es keine forward's !!!!
%@x
%procedure initialize; {this procedure gets things started properly}
%@y
%@<forward declarations@>
%procedure initialize; {this procedure gets things started properly}
%@z
-------------------------------------------------------------------------
%@x
%@d pool_name_length=8
%@y
%@d pool_name_length=11
% {number of characters of ``pool_f_name''}
%@z
%see the following change of the pool file name "pool_f_name"
-------------------------------------------------------------------------
@x
@!pool_name='TeXformats:TEX.POOL ';
@y
@!pool_name='TeXformats:SITEX3.POOL ';
@z
-------------------------------------------------------------------------
@x
else bad_pool('! I can''t read TEX.POOL.')
@.I can't read TEX.POOL@>
@y
else bad_pool('! I can''t read SITEX3.POOL.');
@.I can't read TEX.POOL@>
@z
=========================================================================
To have all messages, coming from SI_TEX, displayed on screen
and written to the log-file simultanously, we make the following,
additional definitions.
temp nicht mehr vorhanden, in log ve�ndert.
@x
@d wlog_ln(#)==write_ln(log_file,#)
@d wlog_cr==write_ln(log_file)
@y
@d wlog_ln(#)==write_ln(log_file,#)
@d wlog_cr==write_ln(log_file)
@d si_put(#) == @+ begin
if (file_offset<>0)or(term_offset<>0) then print_ln;
if selector<>log_only then wterm(#);
if (selector=log_only)or(selector=term_and_log) then
wlog(#);
end
@d si_put_ln(#) == @+ begin
if (file_offset<>0)or(term_offset<>0) then print_ln;
if selector<>log_only then wterm_ln(#);
if (selector=log_only)or(selector=term_and_log) then
wlog_ln(#);
end
@d si_put_cr == print_ln
@d dbg_put(#) == {}
@d dbg_put_ln(#) == {}
@d dbg_put_cr == {}
@z
=========================================================================
We add a new primitive \nebenhyphenpenalty for setting the penalty of a
minor hyphen:
@x
@d int_pars=55 {total number of integer parameters}
@d count_base=int_base+int_pars {256 user \.{\\count} registers}
@y
@d neben_hyphen_penalty_code=55 {penalty for break after neben-hyphen}
@d si_debug_code=56 {value is treated as an set of active debugging sections}
@d supress_debug_mark_code=57 {same as above; if a section number is set, then
the output of the section number and the debugging output banner
of this section is supressed}
@d int_pars=58 {total number of integer parameters}
@d count_base=int_base+int_pars {256 user \.{\\count} registers}
@z
-------------------------------------------------------------------------
@x
@<Assign the values |depth_threshold:=show_box_depth|...@>=
@y
@d neben_hyphen_penalty==int_par(neben_hyphen_penalty_code)
@d si_debug(#) == if odd(int_par(si_debug_code) div #) then begin
if not odd(int_par(supress_debug_mark_code)div #) then
begin
si_put_cr;
si_put_ln(' <* debugging output section #',#:#,' *>');
end; {marking supression}
{ dig_count entfernt !!! }
@d gubed_si == end
@f si_debug == begin
@f gubed_si == end
@f gubed == nil
@<Assign the values |depth_threshold:=show_box_depth|...@>=
@z
-------------------------------------------------------------------------
@x
othercases print("[unknown integer parameter!]")
@y
neben_hyphen_penalty_code:print_esc("nebenhyphenpenalty");
si_debug_code:print_esc("sidebug");
supress_debug_mark_code:print_esc("supressdebugmark");
othercases print("[unknown integer parameter!]")
@z
-------------------------------------------------------------------------
@x
@ @<Cases of |print_cmd_chr|...@>=
@y
primitive("nebenhyphenpenalty",assign_int,int_base+neben_hyphen_penalty_code);@/
@!@:neben_hyphen_penalty_}{\.{\\nebenhyphenpenalty} primitive@>
primitive("sidebug",assign_int,int_base+si_debug_code);
primitive("supressdebugmark",assign_int,int_base+supress_debug_mark_code);
@ @<Cases of |print_cmd_chr|...@>=
@z
=========================================================================
As now hyphens may have different penalties, we must somehow associate
a penalty with a discretionary node. We do this by allowing a penalty
node as the first node in the prebreak list of a discretionary node.
The following changes are in two case statements that check the nodes
in the sublists of a discretionary node; we add an empty case for
penalty nodes (two more case statements follow a little bit later).
@x
othercases confusion("disc1")
@y
penalty_node: ;
othercases confusion("disc1")
@z
-------------------------------------------------------------------------
@x
othercases confusion("disc2")
@y
penalty_node: ;
othercases confusion("disc2")
@z
=========================================================================
MAIN CHANGE 2)
The following change is in the line-break section, where try_break is
given the penalty stored in the penalty node. This change is the reason
for all other changes concerning penalties. Moreover, in this change
a line break is suppressed if the discretionary node is actually
a "dirty umlaut" (via "if not is_dirty_umlaut(cur_p) then ... try_break").
@x
begin s:=pre_break(cur_p); disc_width:=0;
if s=null then try_break(ex_hyphen_penalty,hyphenated)
else begin repeat @<Add the width of node |s| to |disc_width|@>;
s:=link(s);
until s=null;
act_width:=act_width+disc_width;
try_break(hyphen_penalty,hyphenated);
act_width:=act_width-disc_width;
end;
r:=replace_count(cur_p); s:=link(cur_p);
while r>0 do
begin @<Add the width of node |s| to |act_width|@>;
decr(r); s:=link(s);
end;
prev_p:=cur_p; cur_p:=s; goto done5;
end
@y
begin
s:=pre_break(cur_p); disc_width:=0;
if s=null then try_break(ex_hyphen_penalty,hyphenated)
else if (type(s)=penalty_node) and (link(s)=null) then begin
flush_node_list(s); s := null;
try_break(ex_hyphen_penalty,hyphenated); end
else if not is_dirty_umlaut(cur_p) then begin
if type(s)=penalty_node then s:=link(s);
repeat @<Add the width of node |s| to |disc_width|@>;
s:=link(s);
until s=null;
act_width:=act_width+disc_width;
if type(pre_break(cur_p))=penalty_node then begin
try_break(penalty(pre_break(cur_p)),hyphenated) end
else begin try_break(hyphen_penalty,hyphenated); end;
act_width:=act_width-disc_width;
end;
r:=replace_count(cur_p); s:=link(cur_p);
while r>0 do begin
@<Add the width of node |s| to |act_width|@>;
decr(r); s:=link(s);
end;
prev_p:=cur_p; cur_p:=s; goto done5;
end
@z
=========================================================================
Two more case statements.
@x
othercases confusion("disc3")
@y
penalty_node: ;
othercases confusion("disc3")
@z
-------------------------------------------------------------------------
@x
othercases confusion("disc4")
@y
penalty_node: ;
othercases confusion("disc4")
@z
=========================================================================
There's a little problem, converting a device independent (``.dvi'')
to a post script file (``.ps''). I think that this program part could
cause this problem. so let's see...
!a <-- = --> @x With this, i want to try to reproduce this error.
Because, after i had inserted this change, that error didn`t occur
again!
@<Modify the end of the line...@>=
q:=cur_break(cur_p); disc_break:=false; post_disc_break:=false;
if q<>null then {|q| cannot be a |char_node|}
if type(q)=glue_node then
begin delete_glue_ref(glue_ptr(q));
glue_ptr(q):=right_skip;
subtype(q):=right_skip_code+1; add_glue_ref(right_skip);
goto done;
end
else begin if type(q)=disc_node then
@<Change discretionary to compulsory and set
|disc_break:=true|@>
else if (type(q)=math_node)or(type(q)=kern_node) then width(q):=0;
end
else begin q:=temp_head;
while link(q)<>null do q:=link(q);
end;
@<Put the \(r)\.{\\rightskip} glue after node |q|@>;
done:
!a <-- = --> @y
@<Modify the end of the line...@>=
q:=cur_break(cur_p); disc_break:=false; post_disc_break:=false;
if q<>null then {|q| cannot be a |char_node|}
if type(q)=glue_node then
begin delete_glue_ref(glue_ptr(q));
glue_ptr(q):=right_skip;
subtype(q):=right_skip_code+1; add_glue_ref(right_skip);
goto done;
end
else begin
if type(q)=disc_node then begin
hyfdeb_b:=false;
if is_dirty_umlaut(q) then begin
si_debug(64) hyfdeb_b:=true; gubed_si;
si_put_cr;
si_put_ln(' ??? There's a line break at a dirty umlaut!?');
end;
if not hyfdeb_b then begin
@<Change discretionary to compulsory and set |disc_break:=true|@>
end;
end else
if (type(q)=math_node)or(type(q)=kern_node) then width(q):=0;
end else begin
q:=temp_head;
while link(q)<>null do q:=link(q);
end;
@<Put the \(r)\.{\\rightskip} glue after node |q|@>;
done:
!a <-- = --> @z
=========================================================================
If the break actually occurs, the penalty node is made a separate list
with only one node, which is immediately flushed.
@x
begin s:=pre_break(q); link(q):=s;
while link(s)<>null do s:=link(s);
pre_break(q):=null; q:=s;
end
@y
begin
s:=pre_break(q);
if type(s)=penalty_node then begin
s:=link(s);
link(pre_break(q)):= null;
flush_node_list(pre_break(q));
end;
link(q):=s;
while link(s)<>null do s:=link(s);
pre_break(q):=null; q:=s;
end
@z
=========================================================================
The type `array[0..65] of 0..256' is needed more often, so we make it
an explicit type (see big SISISI change at end of change file). hc is
now declared of this type.
@x
@!hc:array[0..65] of 0..256; {word to be hyphenated}
@!hn:small_number; {the number of positions occupied in |hc|}
@!ha,@!hb:pointer; {nodes |ha..hb| should be replaced by the hyphenated result}
@y
@!hc:a_word; {word to be hyphenated}
@!hn:small_number; {the number of positions occupied in |hc|}
@!ha,@!hb:pointer; {nodes |ha..hb| should be replaced by the hyphenated result}
{ some variables for debugging output }
@!hyfdeb_i,hyfdeb_j: integer;
@!hyfdeb_b:boolean;
@!si_p, si_q, si_r, si_s: pointer;
@z
-------------------------------------------------------------------------
Our hyphenation routines need even more "more local variables".
@x
@ Hyphenation routines need a few more local variables.
@y
@!dirty_umlaut:array [-1..64] of pointer; {the [-1] field is used, if a
whatsit node occurs inbetween a word. This can happen due to
Partl's changes in ``german.sty'' }
@ Hyphenation routines need a few more local variables.
@z
-------------------------------------------------------------------------
@x
@!j:small_number; {an index into |hc| or |hu|}
@y
@!qq:pointer;
@!j:small_number; {two indices into |hc| or |hu|}
@!jj:integer;
@z
=========================================================================
The dirty_umlaut array must be initialized for each word.
And we enable watching the node list, representing the word
to be hyphenated.
@x
if s<>null then
begin @<Skip to node |ha|, or |goto done1| if no hyphenation
@y
si_p:=cur_p; si_q:=null;
for jj:=-1 to 64 do dirty_umlaut[jj] := null;
if s<>null then begin
si_debug(1)
{ hyfdeb_i:=depth_threshold; depth_threshold:=100;
hyfdeb_j:=breadth_max; breadth_max:=100;
}
show_node_list(si_p);
{ depth_threshold:=hyfdeb_i; breadth_max:=hyfdeb_j; }
gubed_si;
@<Skip to node |ha|, or |goto done1| if no hyphenation
@z
-------------------------------------------------------------------------
@x
hyphenate;
end;
done1: end
@y
hyphenate;
end;
done1:
si_debug(32)
hyfdeb_i := depth_threshold; hyfdeb_j := breadth_max;
if si_q<>null then begin
depth_threshold:=100; {show all levels of a list}
breadth_max:=200; {show all nodes of one level of a list}
si_r:=link(si_q); link(si_q):=null;
end else begin
(* take the values, set by the user, for this variables! *)
breadth_max:=show_box_breadth; depth_threshold:=show_box_depth;
end;
show_node_list(si_p);
si_put_cr;
if si_q <> null then link( si_q ) := si_r;
depth_threshold:=hyfdeb_i; breadth_max:=hyfdeb_j;
gubed_si;
end
@z
=========================================================================
MAIN CHANGE 1)
Here, we add the SISISI-procedure abteilen for use in hyphenate and
another label done1.
@x
procedure hyphenate;
label common_ending,done,found,found1,found2,not_found,exit;
var @<Local variables for hyphenation@>@;
@y
@<Handling of dirty umlauts@>
procedure hyphenate;
label common_ending,done,done1,found,found1,found2,not_found,exit;
var @<Local variables for hyphenation@>@;
@z
=========================================================================
MAIN CHANGE 3)
The prehyphenation loop must now also skip over the "dirty umlauts".
@x
loop@+ begin if is_char_node(s) then
begin c:=qo(character(s)); hf:=font(s);
end
else if type(s)=ligature_node then
if lig_ptr(s)=null then goto continue
else begin q:=lig_ptr(s); c:=qo(character(q)); hf:=font(q);
end
else if (type(s)=kern_node)and(subtype(s)=normal) then goto continue
else if type(s)=whatsit_node then
begin @<Advance \(p)past a whatsit node in the \(p)pre-hyphenation loop@>;
goto continue;
end
else goto done1;
if lc_code(c)<>0 then
if (lc_code(c)=c)or(uc_hyph>0) then goto done2
@y
loop@+ begin
if is_char_node(s) then begin
c:=qo(character(s)); hf:=font(s);
end else if type(s)=ligature_node then begin
if lig_ptr(s)=null then goto continue
else begin
q:=lig_ptr(s); c:=qo(character(q)); hf:=font(q);
end
end else if is_dirty_umlaut(s) then begin
c:=get_char_of(s); hf:=get_font_of(s);
end else if (type(s)=kern_node)and(subtype(s)=normal) then goto continue
else if type(s)=whatsit_node then begin
@<Advance \(p)past a whatsit node in the \(p)pre-hyphenation loop@>;
goto continue;
end else goto done1;
if lc_code(c)<>0 then
if (lc_code(c)=c)or(uc_hyph>0) then goto done2
@z
=========================================================================
MAIN CHANGE 2)
The interface variables for the hyphenation are extended: hyfpen[i]
holds the actual penalty of a hyphen at position i, hyf_disc[i]
contains a "special discretionary" for triple-consonant-hyphens and
ck-hyphens. hc_si is the word as given to the SISISI algorithm;
hyf_si is returned from SISISI and contains markers for the hyphens.
After this change, there are many changes where `odd(hyf[i])' is
simply replaced by `hyfpen[i]<>inf_penalty'.
Another procedure to be changed is `reconstitute': It now has to handle
special dicretionary nodes. For a detailed feeling about the code changes
in reconstitute, either (1) look through it bit by bit, or (2) ask Heini
Hofstaedter.
@x
end
else if type(s)=ligature_node then
@<Move the characters of a ligature node to |hu| and |hc|;
but |goto done3| if they are not all letters@>
@y
end else if is_dirty_umlaut(s) then begin
if get_font_of(s)<>hf then goto done3;
c:=get_char_of(s);
if lc_code(c)=0 then goto done3;
if hn=63 then goto done3;
hb:=s; incr(hn); hu[hn]:=c; hc[hn]:=lc_code(c);
dirty_umlaut[hn]:=s;
for jj:=1 to replace_count(s) do s:=link(s);
end else if type(s)=whatsit_node then begin
@<Advance \(p)past a whatsit node in the \(p)pre-hyphenation loop@>;
dirty_umlaut[-1]:=s;
end else if type(s)=ligature_node then
@<Move the characters of a ligature node to |hu| and |hc|;
but |goto done3| if they are not all letters@>
@z
=========================================================================
MAIN CHANGE 3)
Also in the conversion loop (where the node list is shuffled into the
hc array), we must skip a "dirty umlaut".
@x
loop@+ begin if not(is_char_node(s)) then
case type(s) of
ligature_node: do_nothing;
@y
loop@+ begin
if not(is_char_node(s)) then
if is_dirty_umlaut(s) then begin
for jj:=1 to replace_count(s)-1 do s:=link(s);
end else
case type(s) of
ligature_node: do_nothing;
@z
=========================================================================
Well, there are a lot of new variables that are necessary for the new
hyphenation. Most of them are necessary for Heini's change in the
reconstitute function, where now discretionary nodes for hyphens with
more than one character (e.g. the german ck-hyphens or
three-consonant-hyphens) can be inserted.
@x
@ @<Local variables for hyphenation@>=
@!i,@!j,@!l:0..65; {indices into |hc| or |hu|}
@!q,@!r,@!s:pointer; {temporary registers for list manipulation}
@!bchar:halfword; {right boundary character of hyphenated word, or |non_char|}
@y
@!hyfpen:array [0..64] of integer; {penalties for possible discretionary
hyphens}
@!hyf_si:trennvektor;
@!hc_si:wort;
@!hyf_disc:array [0..64] of pointer;
@ @<Local variables for hyphenation@>=
@!i,@!j,@!l,@!kk:0..65; {indices into |hc| or |hu|}
@!q,@!r,@!s,@!qq,@!qr,@!hold_r:pointer; {temporary registers for list manipulation}
@!bchar:halfword; {right boundary character of hyphenated word, or |non_char|}
@!xchg_char:array [0..10] of 0..256; {type of |hu| and |hc|}
@!add_char, {additional characters when hyphenating e.g.\
Schiffahrt $\rightarrow$ Schif{\sl f}-fahrt: here
|add_char| = 1}
@!xchg_i,xchg_k,xchg_hu: 0..65; {type like |i|, |j| and |l| }
@!spec_hyf: pointer; {special hyphen; causes different spelling of the
word, when it is hyphenated at this point}
@!si_j:integer;
@z
=========================================================================
An odd->inf_penalty change.
@x
for j:=l_hyf to hn-r_hyf do if odd(hyf[j]) then goto found1;
@y
for j:=l_hyf to hn-r_hyf do if hyfpen[j]<>inf_penalty then goto found1;
@z
=========================================================================
The new variable hold_r is initialized (the kern node is a dummy node,
as far as I can see).
@x
if not is_char_node(hb) then
if type(hb)=ligature_node then if odd(subtype(hb)) then
@y
hold_r := new_kern(1235); link(hold_r):=r;
if not is_char_node(hb) then
if type(hb)=ligature_node then if odd(subtype(hb)) then
@z
=========================================================================
Initialize some variables if the list starts with a "dirty umlaut".
@x
else if type(ha)=ligature_node then
if font(lig_char(ha))<>hf then goto found2
else begin init_list:=lig_ptr(ha); init_lig:=true; init_lft:=(subtype(ha)>1);
@y
else if is_dirty_umlaut(ha) then begin
if get_font_of(ha) <> hf then goto found2
else begin init_list:=ha; init_lig := false; hu[0]:=get_char_of(ha);
end
end else if type(ha)=ligature_node then
if font(lig_char(ha))<>hf then goto found2
else begin init_list:=lig_ptr(ha); init_lig:=true; init_lft:=(subtype(ha)>1);
@z
=========================================================================
MAIN CHANGE 3)
unhinge all "dirty umlauts".
@x
common_ending: flush_node_list(r);
@<Reconstitute nodes for the hyphenated word, inserting discretionary hyphens@>;
flush_list(init_list)
@y
common_ending:
qq:=hold_r;
for kk:={1}j to hn do if dirty_umlaut[kk] <> null then begin
while link(qq) <> dirty_umlaut[kk] do qq := link(qq);
qr := link(qq);
for i:=1 to replace_count(qr) do
if qr<>null then qr:=link(qr)
else begin {test:}
si_put_ln('...??..X --> ????? !');
end; {:test}
if qr<>null then begin
link(qq):=link(qr); link(qr):=null;
end else link(qq):=null;
end;
if dirty_umlaut[-1]<>null then begin
qq:=hold_r;
while (link(qq)<>dirty_umlaut[-1])and(link(qq)<>null) do qq:=link(qq);
if link(qq)=dirty_umlaut[-1] then begin
link(qq):=link(dirty_umlaut[-1]);
link(dirty_umlaut[-1]):=null;
end else begin
si_put(' *** ERROR: node list is damaged! ');
si_put_ln('(post hyphenation - unhinge a whatsit node)');
end;
end;
{}
r:=hold_r;
while link(r)<>null do begin
if (mem_min<=link(r))and(link(r)<=mem_max) then r:=link(r)
else begin
wlog_cr; wterm_cr;
wlog_ln('???$ - ERROR in node list!');
wterm_ln('???$ - ERROR in node list!');
kk:=depth_threshold; l:=breadth_max;
depth_threshold:=100; breadth_max:=100;
show_node_list(hold_r);
link(r):=null;
depth_threshold:=kk; breadth_max:=l;
end;
end;
{}
flush_node_list(hold_r);
@<Reconstitute nodes for the hyphenated word, inserting discretionary hyphens@>;
flush_list(init_list)
@z
------------------------------------------------------------------------
Another odd->inf_penalty change (this time only textual).
@x
If there exists an index |k| in the range $j\le k\le m$ such that |hyf[k]|
is odd and such that the result of |reconstitute| would have been different
if $x_{k+1}$ had been |hchar|, then |reconstitute| sets |hyphen_passed|
to the smallest such~|k|. Otherwise it sets |hyphen_passed| to zero.
@y
If there exists an index |k| in the range $j\le k\le m$ such that
|hyfpen[k]<>inf_penalty| and such that the result of |reconstitute|
would have been different if $x_{k+1}$ had been |hchar|, then |reconstitute|
sets |hyphen_passed| to the smallest such~|k|. Otherwise it sets
|hyphen_passed| to zero.
@z
-------------------------------------------------------------------------
In the reconstitute function, we set the boundary value n immediately
before the next "dirty umlaut" by a simple for-loop starting at the
original n.
@x
begin hyphen_passed:=0; t:=hold_head; w:=0; link(hold_head):=null;
@y
@!ii:small_number;
begin hyphen_passed:=0; t:=hold_head; w:=0; link(hold_head):=null;
for ii:=n downto j do
if dirty_umlaut[ii] <> null then n:=ii-1;
@z
-------------------------------------------------------------------------
Another odd->inf_penalty change.
@x
if odd(hyf[j]) then cur_rh:=hchar@+else cur_rh:=non_char;
@y
if hyfpen[j]<>inf_penalty then cur_rh:=hchar@+else cur_rh:=non_char;
@z
=========================================================================
A first change in the reconstitute function.
@x
else begin if hchar<non_char then if odd(hyf[j]) then
begin hyphen_passed:=j; hchar:=non_char;
end;
if op_byte(q)<kern_flag then
@<Carry out a ligature replacement, updating the cursor structure
@y
else begin if hchar<non_char then if hyfpen[j]<>inf_penalty then
begin hyphen_passed:=j; hchar:=non_char;
end;
if op_byte(q)<kern_flag then
@<Carry out a ligature replacement, updating the cursor structure
@z
-------------------------------------------------------------------------
Now we are in the post-hyphenation's main loop; here must append a
"dirty umlaut" to the growing node list. This is simply done by an
if-statement that checks for the presence of a "dirty umlaut" and
appends it.
Moreover, we have another textual odd->inf_penalty change.
@x
repeat l:=j; j:=reconstitute(j,hn,bchar,qi(hyf_char))+1;
if hyphen_passed=0 then
begin link(s):=link(hold_head);
while link(s)>null do s:=link(s);
if odd(hyf[j-1]) then
begin l:=j; hyphen_passed:=j-1; link(hold_head):=null;
end;
end;
if hyphen_passed>0 then
@<Create and append a discretionary node as an alternative to the
unhyphenated word, and continue to develop both branches until they
become equivalent@>;
until j>hn;
link(s):=q
@ In this repeat loop we will insert another discretionary if |hyf[j-1]| is
odd, when both branches of the previous discretionary end at position |j-1|.
@y
if dirty_umlaut[-1]<>null then begin
{hook in the previous saved whatsit node before the first
character of the hyphenated word}
link(s):=dirty_umlaut[-1];
s:=link(s);
end;
repeat
if dirty_umlaut[j]<>null then begin
link(s):=dirty_umlaut[j];
while link(s)>null do s:=link(s);
link(hold_head):=null;
j:=j+1; hyphen_passed:=0;
if hyfpen[j-1]<>inf_penalty then begin
l:=j; hyphen_passed:=j-1;
si_debug(16)
si_put_ln(' *** append a hyphen immediatly after a dirty umlaut!');
gubed_si;
end;
end else begin
l:=j; j:=reconstitute(j,hn,bchar,qi(hyf_char))+1;
if hyphen_passed=0 then begin
link(s):=link(hold_head);
while link(s)>null do s:=link(s);
if hyfpen[j-1]<>inf_penalty then begin
l:=j; hyphen_passed:=j-1; link(hold_head):=null;
end;
end;
end; {if dirty_umlaut[j]<>null then-else}
if hyphen_passed>0 then
@<Create and append a discretionary node as an alternative to the
unhyphenated word, and continue to develop both branches until they
become equivalent@>;
until j>hn;
link(s):=q;
si_q:=s; {save the last node of the hyphenated word for debugging output}
for j:=0 to 64 do if hyf_disc[j]<>null then begin
flush_node_list( hyf_disc[j]);
end
@ In this repeat loop we will insert another discretionary if
|hyfpen[j-1]<>inf_penalty|, when both branches of the previous
discretionary end at position |j-1|.
@z
=========================================================================
Another odd->inf_penalty change.
@x
hyphen_passed:=j-1; link(hold_head):=null;
until not odd(hyf[j-1])
@y
hyphen_passed:=j-1; link(hold_head):=null;
until (hyfpen[j-1]=inf_penalty)
@z
=========================================================================
Here comes the big reconstitution action (cheers to Heini!).
@x
@<Put the \(c)characters |hu[l..i]| and a hyphen into |pre_break(r)|@>=
minor_tail:=null; pre_break(r):=null; hyf_node:=new_character(hf,hyf_char);
if hyf_node<>null then
begin incr(i); c:=hu[i]; hu[i]:=hyf_char; free_avail(hyf_node);
end;
while l<=i do
begin l:=reconstitute(l,i,font_bchar[hf],non_char)+1;
if link(hold_head)>null then
begin if minor_tail=null then pre_break(r):=link(hold_head)
@y
As the value of |hyfpen[i]| is necessary for creating a penalty node,
we must create this node before we ``kill'' the hyphenation information in
|hyfpen[i]| by assigning |inf_penalty|. |minor_tail| contains the
pointer to the penalty node or |null|, if no such node has been created.
@<Put the \(c)characters |hu[l..i]| and a hyphen into |pre_break(r)|@>=
if (hyfpen[i]<>inf_penalty) and (hyfpen[i]<>hyphen_penalty)
then minor_tail:=new_penalty(hyfpen[i])
else minor_tail:=null;
hyfpen[i]:=inf_penalty;
pre_break(r):=minor_tail;
hyf_node:=new_character(hf,hyf_char);
{Exchange |pre_break|-list of the selfbuilt |disc_node| with |hu|}
xchg_k:=i;
if hyf_disc[xchg_k]<>null then begin
spec_hyf:=pre_break(hyf_disc[xchg_k]);
add_char:=subtype(spec_hyf);
xchg_i:=1;
repeat
spec_hyf:=link(spec_hyf);
if spec_hyf<>null then begin
xchg_char[xchg_i]:=qo(character(spec_hyf));
incr(xchg_i);
end;{if}
until spec_hyf=null;
if hyf_node<>null then begin
xchg_char[xchg_i]:=hyf_char;
free_avail(hyf_node);
end else decr(xchg_i);
xchg_hu:=i-xchg_i+add_char+2; {this is the index of |hu| where the first
character is replaced by a character of the
|pre_break|-list of |spec_hyf|}
for xchg_k:=1 to xchg_i do begin
xchg_char[0]:=hu[xchg_hu];
hu[xchg_hu]:=xchg_char[xchg_k];
xchg_char[xchg_k]:=xchg_char[0];
incr(xchg_hu);
end; {|for|}
xchg_k:=i;
i:=xchg_hu-1;
xchg_hu:=xchg_hu-xchg_i;
end {|if hyf_disc[]<>null|}
else if hyf_node<>null then begin
incr(i); c:=hu[i]; hu[i]:=hyf_char; free_avail(hyf_node);
end;
while l<=i do begin
l:=reconstitute(l,i,font_bchar[hf],non_char)+1;
if link(hold_head)>null then
begin if minor_tail=null then pre_break(r):=link(hold_head)
@z
-------------------------------------------------------------------------
.. continued:
@x
if hyf_node<>null then
begin hu[i]:=c; {restore the character in the hyphen position}
l:=i; decr(i);
end
@y
if hyf_disc[xchg_k]<>null then begin
{ Restore the original word in |hu| }
i:=xchg_k; l:=i+1;
for xchg_k:=1 to xchg_i do begin
hu[xchg_hu]:=xchg_char[xchg_k];
incr(xchg_hu);
end;{for}
end else if hyf_node<>null then begin
hu[i]:=c; {restore the character in the hyphen position}
l:=i; decr(i);
end
@z
=========================================================================
MAIN CHANGE 1)
Finally, we come to the SISISI hyphenation. At first, we define two
variables:
@x
@ Assuming that these auxiliary tables have been set up properly, the
@y
@!funktioniert: boolean;
@!zerleg: integer;
@ Assuming that these auxiliary tables have been set up properly, the
@z
-------------------------------------------------------------------------
And off we go; at first only slowly, ...
@x
@<Find hyphen locations for the word in |hc|...@>=
@y
{\sl Here, the German Hyphenation of W.Barth and H.Nirschl has been added!}
@<Find hyphen locations for the word in |hc|...@>=
@z
-------------------------------------------------------------------------
.. but now we kill all of Liang's code and replace it by some re- and
back-en- and decoding, a call to abteilen, and the construction of the
special discretionaries. Then we go right into the SISISI hyphenation.
=========================================================================
@x
if trie_char(cur_lang+1)<>qi(cur_lang) then return; {no patterns for |cur_lang|}
hc[0]:=0; hc[hn+1]:=0; hc[hn+2]:=256; {insert delimiters}
for j:=0 to hn-r_hyf+1 do
begin z:=trie_link(cur_lang+1)+hc[j]; l:=j;
while hc[l]=qo(trie_char(z)) do
begin if trie_op(z)<>min_quarterword then
@<Store \(m)maximum values in the |hyf| table@>;
incr(l); z:=trie_link(z)+hc[l];
end;
end;
found: for j:=0 to l_hyf-1 do hyf[j]:=0;
for j:=0 to r_hyf-1 do hyf[hn-j]:=0
@ @<Store \(m)maximum values in the |hyf| table@>=
begin v:=trie_op(z);
repeat v:=v+op_start[cur_lang]; i:=l-hyf_distance[v];
if hyf_num[v]>hyf[i] then hyf[i]:=hyf_num[v];
v:=hyf_next[v];
until v=min_quarterword;
end
@ The exception table that is built by \TeX's \.{\\hyphenation} primitive is
@y
for j:=0 to hn do
hc_si[j] := ktab[hc[j]];
si_debug(2)
si_put(' hc:');
for j:=0 to hn do si_put( xchr[hc[j]] );
si_put_ln(':');
si_put(' hc_si:');
for j:=0 to hn do si_put( xchr[rev_tab[hc_si[j]]] );
si_put_ln(':');
gubed_si;
si_debug(4)
si_put_ln('< decimal character codes >');
si_put(' hc:');
for j:=0 to hn do begin
si_put(hc[j]:3,'-');
if ((j+1) mod 16)=0 then begin
si_put_cr; si_put(' ');
end;
end;
si_put_cr;
si_put(' hc_si:');
for j:=0 to hn do begin
si_put( rev_tab[hc_si[j]]:3,'-' );
if ((j+1) mod 16)=0 then begin
si_put_cr; si_put(' ');
end;
end;
si_put_cr; si_put_cr;
gubed_si;
abteilen(hc_si,hyf_si,hn,funktioniert,zerleg);
for j:=0 to 64 do begin
hyf_disc[j]:=null; hyfpen[j]:=inf_penalty;
end;
if funktioniert then
for j:=0 to hn do begin
if hyf_si[j]=neben then hyfpen[j] := neben_hyphen_penalty
else if hyf_si[j]=haupt then hyfpen[j] := hyphen_penalty
else if hyf_si[j]=nebenck then begin
hyfpen[j+1] := neben_hyphen_penalty;
s:=get_node(small_node_size); {discretionary node erzeugen}
type(s):=disc_node;
hyf_disc[j+1]:=s;
{|pre_break|-Liste: }
pre_break(s):=new_penalty(neben_hyphen_penalty); s:=pre_break(s);
subtype(s):=0; { number of additional characters }
link(s):=new_character(hf,hu[j+2]); {'k' oder'K'}
link(link(s)):=null;
s:=hyf_disc[j+1];
post_break(s):=null; link(s):=null;
end
else if hyf_si[j]=haupt3 then begin
hyfpen[j-1]:=hyphen_penalty;
s:=get_node(small_node_size); {discretionary node erzeugen}
type(s):=disc_node;
hyf_disc[j-1]:=s;
{|pre_break|-Liste: }
pre_break(s):=new_penalty(hyphen_penalty); s:=pre_break(s);
subtype(s):=1;
link(s):=new_character(hf,hu[j]); { Dreifachkonsonant }
link(link(s)):=null;
{|post_break|- und |link|-Liste: }
s:=hyf_disc[j-1];
post_break(s):=null;
link(s):=null;
end
end; {|if funktioniert|}
si_debug(8)
if funktioniert then begin
for j:=0 to hn do
if hyfpen[j]<>inf_penalty then begin
if hyf_disc[j]<>null then begin
if subtype(pre_break(hyf_disc[j]))=0 then
si_put( xchr[hu[j+1]], '-' )
else {if subty...}
si_put( xchr[hu[j+1]], xchr[hu[j+1]], '=' );
{ i hope so }
end else begin
si_put( xchr[hu[j]] );
if hyfpen[j]=hyphen_penalty then
si_put('=')
else si_put('-');
end;
end else begin
si_put( xchr[hu[j]] );
end;
end else begin
si_put_ln(' no hyphens were found in this word!');
end;
si_put_cr;
gubed_si;
goto done1;
found:
hyfpen[0]:=inf_penalty;
for j:=1 to hn do
if odd(hyf[j]) then hyfpen[j]:=hyphen_penalty
else hyfpen[j]:=inf_penalty;
done1:
@ Das folgende Modul ersetzt die gesamte Liang'sche Trennung. Aufgabe
dieses Modules ist es, ein in hc (ein Array of 0..255 ) liegendes Wort
nach Trennstellen zu untersuchen und die gefundenen Trennstellen in
hyf (ebenfalls ein Array of neben...) an den entsprechenden Stellen
einzutragen. Die genaue Beschreibung der Vorgangsweise findet man im
INSTITUTSBERICHT NR. 26, TECHNISCHE UNIVERSIT\"AT WIEN, INSTITUT
F\"UR PRAKTISCHE INFORMATIK.
Alle Prozeduren f\"ur die Silbentrennung \SISISI, die bei jedem
Start von TeX aufgerufen werden.
@ Dieser Modul beinhaltet alle f\"ur die neue Silbentrennung |abteilen|
n\"otigen Initialisierungen bzw. Prozeduren, die nur einmal am Anfang
ausgef\"uhrt werden sollen.
@<Set initial values of ...@>=
inittrennen;
@ @<Constants in the outer block@>=
maxwl = 64; { Maximale Wortlaenge }
sonderzeichen= 0;
bst_a= 1; bst_b= 2; bst_c= 3; bst_d= 4; bst_e= 5; bst_f= 6; bst_g= 7;
bst_h= 8; bst_i= 9; bst_j=10; bst_k=11; bst_l=12; bst_m=13; bst_n=14;
bst_o=15; bst_p=16; bst_q=17; bst_r=18; bst_s=19; bst_t=20; bst_u=21;
bst_v=22; bst_w=23; bst_x=24; bst_y=25; bst_z=26; bst_ae=27;
bst_oe=28; bst_ue=29; bst_sz=30; trennzeichen=31;
keine = 1; neben = 2; nebenck = 3; haupt = 4 ; haupt3 = 5;
tabsize = 8191; { 2**13 - 1 }
spec_letter_ID = 4321;
{ const definitionen }
vok_a = 1;
vok_e = 2;
vok_i = 3;
vok_o = 4;
vok_u = 5;
vok_ae = 6;
vok_oe = 7;
vok_ue = 8;
vok_ie = 9;
vok_ai = 10;
vok_ei = 11;
vok_au = 12;
vok_aeu= 13;
vok_eu = 14;
vok_y = 15;
kons = 16;
@
@<Types in the outer block@>=
string80 = packed array [0..80] of eight_bits;
buchstabe = eight_bits;
a_word = array[0..maxwl] of 0..256;
wort = a_word;
sperrvektor=array [0..maxwl] of boolean;
dudt=array [0..maxwl] of boolean;{frueher kein type !!}
{ trennung = (keine, neben, nebenck, haupt, haupt3); }
trennvektor = array [0..maxwl] of integer; { Trennstelle bei i ==>
zwischen Buchstabe i und i+1 wird getrennt }
ktabtype = packed array [0..255] of buchstabe;
verdschlue = 0..8388647; { 2**23 - 1 } { -PRAK!- unsigned long in C }
varr = array [0..maxwl] of verdschlue;
intarr = array [0..maxwl] of integer;
{ darf nicht als var Parameter uebergeben werden !!}
infotype = record
{ frueher ein variantenRecord }
ausnahme:boolean;
untrennbar:boolean;
{ erste :0..7;
zweite:0..7; }
erste :integer;
zweite:integer;
endung,vorsilbe,stamm,ehervor,stammallein:boolean;
end;
infobyte = eight_bits;
{ darf nicht als var Parameter uebergeben werden !!}
tableentry=record
tabv:verdschlue;
tabb:infobyte;
frei:boolean;
wiederfrei:boolean;
end;
hashelement = packed array [0..3] of eight_bits;
htabtype = packed array [0..tabsize] of hashelement;
@
@<Global variables@>=
ktab : ktabtype;
htab : htabtype;
anzahl : integer;
hashfile : alpha_file;
kombtab : array [1..5, 1..5] of integer;
konsonant : array [1 .. 30] of boolean; {array [bst_a .. bst_sz]}
rev_tab: array[0..255]of integer;
@ Prozedurdefinitionen
function dig_count( v: integer): integer;
{ calculates the number of decimal digits of ``v'' }
var x, e, c: integer;
begin
x := v div 10; e:=1; c:=1;
while e<=x do begin
e := e * 10; incr(c);
end;
dig_count:=c;
end;
@<Handling of dirty umlauts@>=
procedure hashfunk (var w:wort; anfang,ende:integer;
var v:varr; var ind,k:intarr );
{ -PRAK!- in C long statt integer }
var vacc, indacc, kacc : integer;
i : integer;
begin
vacc := 31415; indacc := 152; kacc := 271;
dbg_put_ln(' * HFNC =');
for i := anfang to ende do begin
dbg_put(' * HFNC ',i-anfang:3,' A');
vacc := (vacc * 31 + w [i]) mod 8388648;
dbg_put('B');
v[i] := vacc;
dbg_put('C');
indacc := (indacc * 33 + w[i]) mod (tabsize+1);
dbg_put('D');
ind[i] := indacc;
dbg_put('E');
kacc := (kacc * 15 + w[i]) mod ((tabsize+1) div 2);
dbg_put('F');
k[i] := 2*kacc + 1;
dbg_put_ln('G');
end; {|for|}
end; {|hashfunk|}
procedure unpackinfo ( b:infobyte;
{ var i:infotype }
var iausnahme :boolean;
var iuntrennbar :boolean;
var ierste :integer;
var izweite :integer;
var iendung :boolean;
var ivorsilbe :boolean;
var istamm :boolean;
var iehervor :boolean;
var istammallein:boolean );
begin
{ with i do begin }
if odd(b) then begin { 87654321 }
iausnahme:= true;
b:= b div 2; { 08765432 }
if odd(b) then iuntrennbar:= true
else iuntrennbar:= false;
b:=b div 2; { 00876543 }
ierste := b mod 8; { 00876xxx }
izweite := b div 8; { 00000876 }
end else begin
iausnahme:= false; { 87654321 }
b:= b div 2; { 08765432 }
if odd(b) then iendung:= true
else iendung:= false;
b:= b div 2; { 00876543 }
if odd(b) then ivorsilbe:= true
else ivorsilbe:= false;
b:= b div 2; { 00087654 }
if odd(b) then istamm:= true
else istamm:= false;
b:= b div 2; { 00008765 }
if odd(b) then iehervor:= true
else iehervor:= false;
b:= b div 2; { 00000876 }
if odd(b) then istammallein:= true
else istammallein:= false;
end; {|if-then-else|}
{ end; |with|}
end; {|unpackinfo|}
procedure unpackentry( h:hashelement;
{ var e:tableentry }
var etabv:verdschlue;
var etabb:infobyte;
var efrei:boolean;
var ewiederfrei:boolean );
begin
{ with e do begin }
dbg_put_cr;
dbg_put(' ==> UPCKNTY 1');
etabv:= h[0]+h[1]*256+h[2]*256*256;
dbg_put(' 2');
if odd(h[3]) then begin { Ausnahme }
dbg_put(' 3 A');
etabb:= h[3];
dbg_put('1');
efrei:= false;
ewiederfrei:= false;
end
else begin
dbg_put(' 3 B');
etabb:= h[3] mod 64;
dbg_put('1');
{ h[3]:=h[3] div 64;} {-PRAK!- in C ein var-Paramter, darf daher
nicht ver�ndert werden. }
dbg_put('2');
{ durch folgende 2 Abfragen ersetzt. -PRAK!- }
if odd(h[3] div 64) then efrei := true
else efrei := false;
if odd(h[3] div 128) then ewiederfrei := true
else ewiederfrei := false;
end;
dbg_put_ln('- 4');
{ end; |with|}
end; {|unpackentry|}
procedure hashsuch ( v:verdschlue;
ind,k : integer;
{ var i:infotype; }
var iausnahme :boolean;
var iuntrennbar :boolean;
var ierste :integer;
var izweite :integer;
var iendung :boolean;
var ivorsilbe :boolean;
var istamm :boolean;
var iehervor :boolean;
var istammallein:boolean;
var g:boolean );
{ sucht Eintragung in der Hashtabelle, g ist TRUE falls gefunden }
var
gef,ngef:boolean;
j:integer;
entry : tableentry;
begin
gef := false; ngef := false; j := ind;
repeat
unpackentry(htab[j],entry.tabv,entry.tabb,entry.frei,entry.wiederfrei);
if entry.frei then ngef := true
else if (v = entry.tabv) and not entry.wiederfrei then begin
unpackinfo(entry.tabb,iausnahme,iuntrennbar,ierste,izweite,
iendung,ivorsilbe,istamm,iehervor,istammallein);
gef := true;
end else
j := (j+k) mod (tabsize + 1)
until gef or ngef;
g := gef;
end; {|hashsuch|}
procedure hashload ( var status:integer );
{ einlesen der Hash-Tabelle von file fn }
var i : integer;
e : tableentry;
begin
{ Orginal sitex3.cha -PRAK!-
for i:=1 to file_name_size do name_of_file:= ' ';
name_of_file[1]:='h';
name_of_file[2]:='f';
name_of_file[3]:='3';
name_length := 3;
anzahl := 0;
if a_open_in(hashfile) then begin
}
{ geaendert !! -PRAK!- }
for i:=1 to file_name_size do name_of_file[i]:= ' ';
name_of_file[1]:='h';
name_of_file[2]:='f';
name_of_file[3]:='3';
name_length := 3;
anzahl := 0;
{ -PRAK!- texinputpath f�r C notwendig }
if a_open_in(hashfile, TEX_INPUT_PATH) then begin
for i := 0 to tabsize do begin
{ -PRAK!- in C Probleme mit den typen beim einlesen }
read (hashfile, htab[i][0]); { htab = packed array [0..tabsize] of }
read (hashfile, htab[i][1]); { hashelement, und }
read (hashfile, htab[i][2]); { hashelement = packed array 0..3 }
read (hashfile, htab[i][3]);
unpackentry (htab[i],e.tabv,e.tabb,e.frei,e.wiederfrei);
if not e.frei and not e.wiederfrei then anzahl := anzahl + 1;
end; {|for|}
status:= 0;
a_close(hashfile);
end else status:= 1;
end; {|hashload|}
procedure inittrennen;
var ch: 0..255;
bst: buchstabe;
i, status: integer;
is_iniTeX: boolean;
begin
{ Konversionstabelle |ktab| initialisieren }
{ ======================================== }
for ch := 0 to 255 do begin
{ if (ch in [" ",",",";",":","-","/","?","!","(",")",".","""","'","^"]) then }
case ch of
" ",",",";",":","-","/","?","!","(",")",".","""","'","^":
if ch="." then ktab[ch]:= "."
else ktab[ch] := trennzeichen
{ else ktab[ch] := sonderzeichen geht nicht !!}
end; { case }
if (ktab[ch] <> ".") and (ktab[ch] <> trennzeichen) then ktab[ch] := sonderzeichen;
end; { for }
for bst := bst_a to bst_z do begin
ktab[ord('A')+ord(bst)-ord(bst_a)]:=bst;
ktab[ord('a')+ord(bst)-ord(bst_a)]:=bst
end;
{ Umlaute und scharfes s - f\"ur ``production \TeX version'' }
ktab[255]:=bst_sz;
ktab[246]:=bst_oe;
ktab[252]:=bst_ue;
ktab[228]:=bst_ae;
{ Umlaute und scharfes s - f\"ur ``initialization \TeX version'' }
ktab["1"]:=bst_sz;
ktab["2"]:=bst_ue;
ktab["3"]:=bst_oe;
ktab["4"]:=bst_ae;
ktab[25]:=bst_sz; {?-wieso? HH}
{testing:}
for i:=0 to 255 do rev_tab[ktab[i]]:=i;
rev_tab[ktab[255]]:=223;
xchr[223]:=chr(223); xchr[228]:=chr(228); xchr[246]:=chr(246);
xchr[252]:=chr(252); xchr[255]:=chr(223); xchr[ 25]:=chr(223);
{:end of testing}
{ Kombinationstabelle |kombtab| initialisieren }
{ ============================================ }
{ Diese Tabelle muss symetrisch sein,
kombtab[a,b] = kombtab[b,a] }
kombtab[ keine, keine] := keine;
kombtab[ keine, neben] := keine;
kombtab[ keine,nebenck] := keine;
kombtab[ keine, haupt] := keine;
kombtab[ keine, haupt3] := keine;
kombtab[ neben, keine] := keine;
kombtab[ neben, neben] := neben;
kombtab[ neben,nebenck] := keine;
kombtab[ neben, haupt] := neben;
kombtab[ neben, haupt3] := keine;
kombtab[nebenck, keine] := keine;
kombtab[nebenck, neben] := keine;
kombtab[nebenck,nebenck] := nebenck;
kombtab[nebenck, haupt] := keine;
kombtab[nebenck, haupt3] := keine;
kombtab[ haupt, keine] := keine;
kombtab[ haupt, neben] := neben;
kombtab[ haupt,nebenck] := keine;
kombtab[ haupt, haupt] := haupt;
kombtab[ haupt, haupt3] := keine;
kombtab[ haupt3, keine] := keine;
kombtab[ haupt3, neben] := keine;
kombtab[ haupt3,nebenck] := keine;
kombtab[ haupt3, haupt] := keine;
kombtab[ haupt3, haupt3] := haupt3;
{ Konsonantentabelle initialisieren }
for bst:=bst_a to bst_sz do konsonant[bst] := true;
konsonant[bst_a] := false;
konsonant[bst_e] := false;
konsonant[bst_i] := false;
konsonant[bst_o] := false;
konsonant[bst_u] := false;
konsonant[bst_ae] := false;
konsonant[bst_oe] := false;
konsonant[bst_ue] := false;
{ ================== Hashtabelle |htab| initialisieren ======================
Die Prozedur ``hashload'' darf im Initialisierungslauf von TeX auf
keinen Fall aufgerufen werden. Deshalb wird zun\"achst festgestellt, ob
dieser Programmlauf ein Initialisierungslauf ist oder nicht. Abh\"angig
davon wird ``hashload'' nur aufgerufen, wenn dies ein ``Arbeits''-lauf
(production-version) von \TeX ist.
=============================================================================}
is_iniTeX:=false;
init is_iniTeX:=true; tini
if not is_iniTeX then begin
hashload(status);
if status <> 0 then begin
si_put_cr;
si_put_ln
(' * * * * * * * * * *!');
si_put_ln('**** ERROR: Can not read hash-file!');
si_put_cr;
jump_out;
end;
end; {|not iniTeX|}
end; {|inittrennen|}
procedure packinfo ( i:infotype; var b : infobyte );
{ Byte: /zweite/zweite/zweite/erste/erste/erste/untrennbar/ausnahm/ }
{ bzw.: /0 /0 /stall /eherv/stamm/vors /endung /0 / }
begin
b:=0;
dbg_put_cr;
{ with i do begin }
if i.ausnahme then
begin
dbg_put(' ### PCKINF 1A utr:');
if i.untrennbar then dbg_put('Y') else dbg_put('N');
dbg_put_ln(',',ord(i.untrennbar):3,' 1.',i.erste:3,' 2.',i.zweite:3);
b:=1+2*ord(i.untrennbar)+4*i.erste+32*i.zweite
; dbg_put('B');
end
else
begin
dbg_put(' ### PCKINF 2A');
b:= 2*ord(i.endung)+4*ord(i.vorsilbe)+8*ord(i.stamm)+16*ord(i.ehervor)
+32*ord(i.stammallein);
dbg_put('B');
end;
{ end; with }
dbg_put_ln('-3');
end; {|packinfo|}
procedure packentry( e:tableentry; var h:hashelement );
{ /infobyte+frei,wiederfrei/verdschhigh/verdschmiddle/verdschllow/ }
begin
{ with e do begin }
dbg_put_cr;
dbg_put(' +++ PCKNTY A');
h[0]:= e.tabv mod 256; { 87654321abcdefghxxxxxxxx}
dbg_put('B');
e.tabv:= e.tabv div 256; { 0000000087654321abcdefgh}
dbg_put('C');
h[1]:= e.tabv mod 256; { 0000000087654321xxxxxxxx}
dbg_put('D');
h[2]:= e.tabv div 256; { 000000000000000087654321}
dbg_put('E');
if odd(e.tabb) then h[3]:= e.tabb { Ausnahme !! }
else
begin
dbg_put('F1');
h[3]:=e.tabb+64*ord(e.frei)+128*ord(e.wiederfrei); { wfxxxxxx }
dbg_put('-2');
end;
dbg_put_ln('G');
{ end; |with|}
end; {|packentry|}
procedure hashetr ( var w:wort; laenge:integer; i:infotype;
var g:boolean );
var v1: varr;
ind1, k1: intarr;
v: verdschlue;
ind, k, j, e: integer;
gef,ngef:boolean;
entry: tableentry;
helem: hashelement;
begin
dbg_put_ln(' ** HTR 1');
if anzahl >= tabsize then begin
dbg_put_ln(' ** HTR 2a');
g := false;
end
else begin
dbg_put_ln(' ** HTR 2b');
if (anzahl < 10) or (anzahl mod 100 = 0) then begin
si_put_cr; si_put(' -Anzahl:',anzahl,'. ');
end;
dbg_put_ln(' ** HTR 3');
hashfunk(w,1,laenge,v1,ind1,k1);
dbg_put_ln(' ** HTR 4');
v := v1[laenge];
ind := ind1[laenge];
k := k1[laenge];
gef := false; ngef := false;
repeat
dbg_put_ln(' ** HTR 5 A');
unpackentry(htab[ind],entry.tabv,entry.tabb,entry.frei,entry.wiederfrei);
dbg_put_ln(' ** HTR B');
if entry.frei or entry.wiederfrei then begin
anzahl := anzahl + 1;
ngef := true;
entry.tabv := v;
dbg_put_ln(' ** HTR C1');
packinfo (i,entry.tabb);
dbg_put_ln(' ** HTR D1');
entry.frei := false;
entry.wiederfrei := false;
dbg_put_ln(' ** HTR E1');
packentry(entry,helem);
dbg_put_ln(' ** HTR F1');
htab[ind] := helem; { -PRAK!- in C memcpy() }
end else begin
dbg_put_ln(' ** HTR C2');
gef := v = entry.tabv;
if not gef then ind := (ind+k) mod (tabsize + 1);
dbg_put_ln(' ** HTR D2');
end;
until gef or ngef;
dbg_put_ln(' ** HTR 6');
g := ngef;
end
end; {|hashetr|}
procedure hashempty;
var i:integer;
elem : tableentry;
he : hashelement;
begin
{ with elem do begin }
elem.tabv:=0;
elem.tabb := 0; { !!!!!! Irgend ein Affe hat diese Initialisierung vergessen.
( Und dies ist eine Beleidigung fuer jeden Affen ) HM }
elem.frei := true;
elem.wiederfrei := false;
{ end; }
packentry (elem, he);
for i := 0 to tabsize do htab[i] := he; { -PRAK!- in C memcpy() }
anzahl := 0;
end; {|hashempty|}
procedure hashsave (var status:integer);
{ abspeichern der Hash-Tabelle auf file }
var i: integer;
begin
for i:=1 to file_name_size do name_of_file[i]:=' ';
name_of_file[1]:='h';
name_of_file[2]:='f';
name_of_file[3]:='3';
name_length:=3;
if a_open_out(hashfile) then begin
for i := 0 to tabsize do begin
write (hashfile, htab[i][0]:4);
write (hashfile, htab[i][1]:4);
write (hashfile, htab[i][2]:4);
write (hashfile, htab[i][3]:4);
write_ln (hashfile);
end;
status:=0;
a_close(hashfile);
end else status:=1;
end; {|hashsave|}
function hashsize :integer;
begin
hashsize:=anzahl;
end;
procedure zahl(line:string80;var i:integer; ende:integer; var j:integer);
var aus: boolean;
begin
j:=0;
repeat
if i<=ende then
if ktab[line[i]]="." then i:=i+1
else aus:=true
else aus:=true
until aus;
repeat
if i<=ende then begin
{ if line[i] in ["0".."9"] then begin }
case line[i] of
"0","1","2","3","4","5","6","7","8","9":
begin j:=10*j+line[i]-"0";i:=i+1
end;
{ else aus:=true geht nicht !!! }
end;
if (line[i] <> "0") and
(line[i] <> "1") and
(line[i] <> "2") and
(line[i] <> "3") and
(line[i] <> "4") and
(line[i] <> "5") and
(line[i] <> "6") and
(line[i] <> "7") and
(line[i] <> "8") and
(line[i] <> "9") then aus :=true;
end else aus:=true
until aus;
end; {|zahl|}
procedure infobau(line: string80; anfang,ende: integer;
{ var inform: infotype;}
var informausnahme :boolean;
var informuntrennbar :boolean;
var informerste :integer;
var informzweite :integer;
var informendung :boolean;
var informvorsilbe :boolean;
var informstamm :boolean;
var informehervor :boolean;
var informstammallein:boolean;
var g: boolean);
var i,j:integer;ok,fehler:boolean;
b:buchstabe;
begin
g:=false;
{ with inform do begin } { initialisierung }
informausnahme:=false;
informendung:=false;
informvorsilbe:=false;
informehervor:=false;
informstamm:=false;
informstammallein:=false;
i:=anfang; ok:=false; fehler:=false;
repeat
if i<=ende then
if line[i]="." then i:=i+1 else ok:=true
else fehler:=true
until ok or fehler;
if not fehler then begin
b:=ktab[line[i]];
if b = bst_a then begin
{ausnahme}
informausnahme:=true;
i:=i+1;
if ktab[line[i]] = bst_u then begin
i := i + 1; informuntrennbar := true;
end else informuntrennbar := false;
zahl(line,i,ende,j);
if j=0 then begin
informerste:=7; informzweite:=7;
{ Record-komponente ``zweite'' wird }
{ initialisiert, damit beim packen keine }
{ undefinierten Ergebnisse entstehen (die u.U. zu }
{ RUN-TIME-ERRORS f\"uhren k\"onnen!) }
end else begin
j:=j-2;
if (j>=0) and (j<=6) then informerste:=j
else fehler:=true;
zahl(line,i,ende,j);
if j=0 then informzweite:=7
else begin
j:=j-informerste-4;
if (j>=0) and (j<=6) then informzweite:=j
else fehler:=true;
end;
end;
if not fehler then g:=true;
end {|if b = bst_a |}
else begin
ok:=false;
repeat
case b of
{bst_v} 22: informvorsilbe:=true;
{bst_e} 5: informendung:=true;
{bst_s} 19: informstamm:=true;
{bst_b} 2: informehervor:=true;
{bst_t} 20: informstammallein:=true;
{trennzeichen} 31:;
othercases fehler:=true
endcases;
if i=ende then ok:=true
else begin
i:=i+1;
b:=ktab[line[i]]
end
until ok or fehler;
if not fehler then
g := (informvorsilbe or informendung or informstamm)
and (not informehervor or informvorsilbe and informendung)
and (not informstammallein or informstamm);
end; {|if b = bst_a then-else|}
end {|if not fehler|}
{ end |with inform|}
end; {|infobau|}
procedure eintragen (line: string80; l: integer );
var i, laenge: integer;
inform: infotype;
w: wort;
g: boolean;
begin
laenge := 1;
while line [laenge] <> "." do laenge := laenge + 1;
laenge := laenge -1;
if laenge >= 1 then begin
if laenge <= maxwl then begin
infobau(line,laenge+1,l,
inform.ausnahme,inform.untrennbar,
inform.erste,inform.zweite,inform.endung,
inform.vorsilbe,inform.stamm,inform.ehervor,
inform.stammallein,g);
if not g then begin
si_put_cr; si_put(' Info falsch: ')
end else begin
for i:= 1 to laenge do w[i]:=ktab[line[i]];
hashetr(w,laenge,inform,g);
if not g then begin
si_put_cr; si_put(' Tabellenfehler: ');
end;
end;
if not g then begin
for i:=1 to l do si_put( xchr[line[i]] );
si_put_cr;
end
end {|if laenge <= maxwl|}
else begin
si_put_cr; si_put_ln(' zu langes Wort: ');
for i:=1 to l do si_put( xchr[line[i]] );
si_put_cr;
end
end {|if laenge >= 1|}
else begin
si_put_cr; si_put_ln(' Falsche Zeile: ');
for i:=1 to l do si_put( xchr[line[i]] );
si_put_cr;
end
end; {|eintragen|}
{---------------------------------------------------------------------------}
{ naechsterbst -> naechsterbst(i,tr,dudstop,b,w) }
procedure naechsterbst(var i:integer;var tr:trennvektor;
var dudstop:sperrvektor;var b:buchstabe;
var w:wort);
begin
if (i>0) and (tr[i]=keine) and not dudstop[i]
then begin b:=w[i];i:=i-1 end
else b:=trennzeichen
end;
{---------------------------------------------------------------------------}
{ duden(tr) -> duden(tr,w,tr1,dudtr,dud,dudstop,laenge,ok,zerlegungen) }
procedure duden (tr:trennvektor;
var w:wort;
var tr1 :trennvektor;
var dudtr:trennvektor;
dud :dudt; { array [0..maxwl] of boolean; }
var dudstop:sperrvektor;
laenge : integer;
var ok :boolean;
var zerlegungen:integer );
{ traegt in dudtr die Trennstellen nach Dudenregeln ein }
{ frueher mtype laut = (.....) }
var i:integer;
j:integer;
zust:integer;
aus:boolean;
tre:integer;
letzte:integer;
l,lalt:integer;{ vormals laut }
b:buchstabe;
begin { duden }
i:=laenge;
for j := 0 to laenge do dudtr[j] := tr[j];
while (i>0) and not dud [i] do i:=i-1;
while i>0 do begin
zust:=1; aus:=false; letzte := 0;
l:=kons;
b:=w[i];
i:=i-1;
repeat
{naechsten Laut lesen}
{ procedure nlaut; }
begin { nlaut }
tre:=i+1;
lalt:=l;
case b of
{bst_a } 1:begin l:=vok_a; naechsterbst(i,tr,dudstop,b,w) end;
{bst_o } 15:begin l:=vok_o; naechsterbst(i,tr,dudstop,b,w) end;
{bst_ue} 29:begin l:=vok_ue; naechsterbst(i,tr,dudstop,b,w) end;
{bst_oe} 28:begin l:=vok_oe; naechsterbst(i,tr,dudstop,b,w) end;
{bst_ae} 27:begin l:=vok_ae; naechsterbst(i,tr,dudstop,b,w) end;
{bst_e } 5:begin
l:=vok_e; naechsterbst(i,tr,dudstop,b,w);
if b = bst_i then begin
l:=vok_ie;
naechsterbst(i,tr,dudstop,b,w);
if b = bst_e then begin
{ungetbst = } i := i + 1;
l:=vok_e;
b := bst_i;
end;
end
end;
{bst_i} 9:begin
l:=vok_i; naechsterbst(i,tr,dudstop,b,w);
if b = bst_e then begin l:=vok_ei; naechsterbst(i,tr,dudstop,b,w) end
else if b = bst_a then begin l:=vok_ai; naechsterbst(i,tr,dudstop,b,w) end
end;
{bst_u} 21:begin
l:=vok_u; naechsterbst(i,tr,dudstop,b,w);
if b = bst_e then begin l:=vok_eu; naechsterbst(i,tr,dudstop,b,w) end
else if b = bst_a then begin l:=vok_au; naechsterbst(i,tr,dudstop,b,w) end
else if b = bst_ae then begin l:=vok_aeu; naechsterbst(i,tr,dudstop,b,w) end
else if b = bst_q then begin l:=kons; naechsterbst(i,tr,dudstop,b,w) end
end;
{bst_t} 20:begin
l:=kons; naechsterbst(i,tr,dudstop,b,w);
if b = bst_s then naechsterbst(i,tr,dudstop,b,w)
end;
{bst_h} 8:begin
l:=kons; naechsterbst(i,tr,dudstop,b,w);
if b = bst_c then begin
naechsterbst(i,tr,dudstop,b,w);
if b = bst_s then naechsterbst(i,tr,dudstop,b,w)
end
else if b = bst_p then naechsterbst(i,tr,dudstop,b,w)
else if b = bst_t then naechsterbst(i,tr,dudstop,b,w)
end;
{bst_b, bst_c, bst_d, bst_f, bst_g, bst_j, bst_k, bst_l, bst_m,
bst_n, bst_p,
bst_q, bst_r, bst_s, bst_v, bst_w, bst_x, bst_z, bst_sz }
2,3,4,6,7,10,11,12,13,14,16,17,18,19,22,23,24,26,30 :
begin l:=kons; naechsterbst(i,tr,dudstop,b,w) end;
{bst_y} 25:begin
l:=vok_y;
naechsterbst(i,tr,dudstop,b,w);
end;
{trennzeichen,sonderzeichen}
31,0 :aus:=true
end;
end; { nlaut }
if not aus then
{Naechster Zustand}
case zust of
1:if l=kons then zust:=2
else zust:=4;
2:if l<>kons then zust:=3;
3:if l=kons then zust:=6
else if l<>lalt then begin
zust:=4;
letzte:=tre;
dudtr[letzte]:=neben
end;
4:if l=kons then zust:=6
else zust:=3;
6:if l=kons then begin
zust:=2;
letzte:=tre;
if (w[tre]=bst_c) and (w[tre+1] = bst_k) then
dudtr[letzte]:=nebenck
else dudtr[letzte]:=neben
end
else begin
zust:=4;
letzte:=tre;
dudtr[letzte]:=neben
end
end
until aus;
if zust=2 then dudtr[letzte]:=keine
else if zust=4 then
{ if not (lalt in [vok_ai,vok_ei,vok_au,vok_aeu,vok_eu,vok_ie]) then }
if (lalt < vok_ie) or (lalt > vok_eu) then
dudtr[letzte]:=keine;
while (i>0) and not dud[i] do i:=i-1
end;
end { duden };
{---------------------------------------------------------------------------}
{ procedure trennen (zustand : integer; anfang: integer; spv:sperrvektor;
var ok1 : boolean);
}
procedure trennen (
{ trennen }
zustand : integer;
anfang : integer;
spv : sperrvektor;
var ok1 : boolean;
{ abteilen }
var tr :trennvektor;
var dudtr:trennvektor;
var zerlegungen:integer ;
var dud:dudt; { array [0..maxwl] of boolean; }
var v:varr;
var ind,k:intarr;
var dudstop:sperrvektor;
{ abteilen aufruf }
var w:wort;
var tr1:trennvektor;
laenge : integer );
{ Zustand : 1 ... Es kann nur Vorsilbe oder Stamm kommen,
rechts muss noch ein Stamm kommen.
2 ... Es kann Endung, Vorsilbe oder Stamm kommen.
3 ... Es kann nur Vorsilbe oder Stamm kommen, im linken
Teil muessen noch Trennstellen eingefuegt werden,
rechts muss noch ein Stamm kommen.
4 ... Es kann nur Vorsilbe oder Stamm kommen, im linken
Teil muessen noch Trennstellen eingefuegt werden.
5 ... Trennstelle mit entfallenem Konsonanten }
var
gef, nichtok:boolean;
schnitt:integer;
inform:infotype;
i:integer;
ok_stamm, ok_vor, ok_end, ok_help:boolean;
tri:integer;
{ p_stamm }
i1,tre:integer;
ok : boolean;
stop_ptr :integer;
spvtmp :sperrvektor; { lokale Kopie des Sperrvektors,
fr die bersetzung nach C notwendig.
-PRAK!- }
{ procedure p_endung(var endok:boolean); }
{ procedure p_vorsilbe(var vorok:boolean); }
{ procedure p_stamm(var stok:boolean); }
{ procedure p_stammallein (var staok:boolean); }
begin { trennen }
spvtmp := spv;
ok1:=false;
if anfang = laenge + 1
then { Ende des Wortes erreicht}
if (zustand = 2) or (zustand=4) then {erfolgreich zerschnitten }
begin
dud[anfang-1]:=true;
{duden(tr);}
duden(tr,w,tr1,dudtr,dud,dudstop,laenge,ok,zerlegungen);
for i := laenge downto 1 do
begin
if dudtr[i-1] = haupt3 then
begin
dudtr[i-1] := keine;
tri := haupt3;
end
else
tri := dudtr[i];
if zerlegungen = 0 then
tr1[i] := tri
else
tr1[i] := kombtab[tr1[i],tri];
end;
zerlegungen:=zerlegungen+1;
ok1:= true
end
else { kein Stamm im Wortrest ok1 = false }
else { restlichen Teil zerschneiden }
begin
hashfunk (w,anfang,laenge,v,ind,k);
schnitt := laenge;
nichtok := false;
repeat
{ links abschneiden }
repeat
if spv[schnitt] then { Schnittstelle gesperrt }
gef:=false
else
begin
hashsuch (v[schnitt],ind[schnitt],k[schnitt],
inform.ausnahme,inform.untrennbar,
inform.erste,inform.zweite,inform.endung,
inform.vorsilbe,inform.stamm,inform.ehervor,
inform.stammallein,gef);
end;
if gef then
spv[schnitt]:=true
else
schnitt := schnitt - 1
until gef or (schnitt = anfang - 1);
if gef then { teilwortanfang ist bekanntes wort }
begin
if not inform.ausnahme then
begin
if inform.endung and (zustand=2) then
begin
{ --- p_endung(ok_end); --- }
ok_end:=false;
if (w[anfang]=bst_c) or (w[anfang]=bst_h) then
begin
dud[anfang-1]:=true;
tr[anfang-1]:=neben
end;
{ Fugen 's' bevorzugen }
if schnitt < laenge then
if (w[schnitt+1] = bst_s) and not spv[schnitt+1]
then begin
spv[schnitt+1]:=true;
trennen (2, schnitt+2, spv, ok_help,
tr,dudtr,zerlegungen,dud,v,ind,k,
dudstop,w,tr1,laenge);
ok_end := ok_help
end;
trennen (2, schnitt+1, spv, ok_help,
tr,dudtr,zerlegungen,dud,v,ind,k,
dudstop,w,tr1,laenge);
ok_end := ok_end or ok_help;
{eingetragene Trennstellen loeschen}
tr[anfang-1]:=keine;
dud[anfang-1]:=false;
{ --- p_endung(ok_end) - ende --- }
ok1 := ok1 or ok_end
end
else
ok_end:=false;
if inform.vorsilbe
then begin
{ --- p_vorsilbe(ok_vor); --- }
{ Trennstelle(n) vor der Vorsilbe eintragen }
if zustand = 1 then
tr[anfang-1]:=neben
else begin
dud[anfang-1]:=true;
if zustand = 5 then
tr[anfang-1] := haupt3
else
tr[anfang-1]:=haupt;
end;
{ Trennstellen innerhalb der Vorsilbe eintragen }
dud[schnitt]:=true;
{ Rest des Wortes zerschneiden }
trennen(1, schnitt+1, spv, ok_vor,
tr,dudtr,zerlegungen,dud,v,ind,k,
dudstop,w,tr1,laenge);
{eingetragene Trennstellen loeschen}
tr[anfang-1]:=keine;
dud[anfang-1]:=false;
dud[schnitt]:=false;
{ --- p_vorsilbe(ok_vor) - ende --- }
ok1 := ok1 or ok_vor
end
else
ok_vor := false;
if inform.stamm and not ok_vor
then begin
if not inform.stammallein
then begin
{ --- p_stamm(ok_stamm); --- }
ok_stamm := false;
stop_ptr := 0;
if zustand = 1 then
tr[anfang-1]:=neben
else begin
dud[anfang-1]:=true;
if zustand = 5 then
tr[anfang-1] := haupt3
else
tr[anfang-1]:=haupt
end;
{ev. Ausnahmetrennstellen eintragen}
if inform.ausnahme then begin
if inform.erste<>7 then begin
tre:=anfang+inform.erste+1;
tr[tre]:=neben;
if inform.zweite<>7 then begin
tre:=tre+inform.zweite+2;
if inform.untrennbar then begin
stop_ptr := tre;
dudstop[stop_ptr] := true;
end
else
tr[tre]:=neben
end
else begin
if inform.untrennbar then begin
tr[tre] := keine;
stop_ptr := tre;
dudstop[tre]:=true;
end
end
end
else begin {inform.erste = 7}
stop_ptr := schnitt-1;
dudstop[stop_ptr] := true
end
end;
{ Fugen 's' bevorzugen }
if schnitt < laenge then
if (w[schnitt+1] = bst_s) and not spv[schnitt+1]
then begin
spv [schnitt+1] := true;
trennen (2, schnitt+2, spv, ok_help,tr,dudtr,
zerlegungen,dud,v,ind,k,
dudstop,w,tr1,laenge);
ok_stamm := ok_help
end;
{ Sonderbehandlung eines in der Wortfuge entfallenen mitlauts }
if (schnitt >=2) and (schnitt < laenge) then
if konsonant[w[schnitt]] and not konsonant[w[schnitt+1]] and
(w[schnitt] = w[schnitt-1]) then begin
trennen(5, schnitt, spv, ok_help,tr,dudtr,
zerlegungen,dud,v,ind,k,
dudstop,w,tr1,laenge);
ok_stamm := ok_stamm or ok_help;
end;
{ restlichen Teil zerschneiden }
trennen (2, schnitt+1, spv, ok_help,tr,dudtr,
zerlegungen,dud,v,ind,k,
dudstop,w,tr1,laenge);
ok_stamm := ok_stamm or ok_help;
{ eingetragene Trennstellen entfernen }
if inform.ausnahme then
for i1:=anfang-1 to schnitt do
begin
tr[i1]:=keine;
dud[i1]:=false;
dudstop[stop_ptr] := false;
end
else begin
tr[anfang-1]:=keine;
dud[anfang-1]:=false;
end;
{ --- p_stamm(ok_stamm) - ende --- }
ok1 := ok1 or ok_stamm;
end
else
if (anfang=1) and (schnitt=laenge)
then begin
{ --- p_stammallein(ok_stamm); --- }
dud[anfang-1]:=true;
tr[anfang-1]:=haupt;
trennen (4, schnitt+1, spv, ok_stamm,tr,dudtr,
zerlegungen,dud,v,ind,k,
dudstop,w,tr1,laenge);
{eingetragene Trennstellen loeschen}
tr[anfang-1]:=keine;
dud[anfang-1]:=false;
{ --- p_stammallein(ok_stamm) - ende --- }
ok1 := ok1 or ok_stamm;
end;
end
end
else begin
{ --- p_stamm(ok_stamm); --- }
ok_stamm := false;
stop_ptr := 0;
if zustand = 1 then
tr[anfang-1]:=neben
else begin
dud[anfang-1]:=true;
if zustand = 5 then
tr[anfang-1] := haupt3
else
tr[anfang-1]:=haupt
end;
{ev. Ausnahmetrennstellen eintragen}
if inform.ausnahme then begin
if inform.erste<>7 then begin
tre:=anfang+inform.erste+1;
tr[tre]:=neben;
if inform.zweite<>7 then begin
tre:=tre+inform.zweite+2;
if inform.untrennbar then begin
stop_ptr := tre;
dudstop[stop_ptr] := true;
end
else
tr[tre]:=neben
end
else begin
if inform.untrennbar then begin
tr[tre] := keine;
stop_ptr := tre;
dudstop[tre]:=true;
end
end
end
else begin {inform.erste = 7}
stop_ptr := schnitt-1;
dudstop[stop_ptr] := true;
end;
end;
{ Fugen 's' bevorzugen }
if schnitt < laenge then
if (w[schnitt+1] = bst_s) and not spv[schnitt+1]
then begin
spv [schnitt+1] := true;
trennen (2, schnitt+2, spv, ok_help,tr,dudtr,
zerlegungen,dud,v,ind,k,
dudstop,w,tr1,laenge);
ok_stamm := ok_help
end;
{ Sonderbehandlung eines in der Wortfuge entfallenen mitlauts }
if (schnitt >=2) and (schnitt < laenge) then
if konsonant[w[schnitt]] and not konsonant[w[schnitt+1]] and
(w[schnitt] = w[schnitt-1]) then begin
trennen(5, schnitt, spv, ok_help,tr,dudtr,
zerlegungen,dud,v,ind,k,
dudstop,w,tr1,laenge);
ok_stamm := ok_stamm or ok_help;
end;
{ restlichen Teil zerschneiden }
trennen (2, schnitt+1, spv, ok_help,tr,dudtr,
zerlegungen,dud,v,ind,k,
dudstop,w,tr1,laenge);
ok_stamm := ok_stamm or ok_help;
{ eingetragene Trennstellen entfernen }
if inform.ausnahme then
for i1:=anfang-1 to schnitt do
begin
tr[i1]:=keine;
dud[i1]:=false;
dudstop[stop_ptr] := false;
end
else begin
tr[anfang-1]:=keine;
dud[anfang-1]:=false;
end;
{ --- p_stamm(ok_stamm) - ende --- }
ok1 := ok1 or ok_stamm;
end;
{naechsten Schleifendurchlauf vorbereiten}
schnitt := schnitt - 1;
nichtok := schnitt = anfang - 1
end
else { kein bekanntes Wort am Beginn des Teilwortes }
nichtok := true;
until nichtok
end;
spv := spvtmp; { spv wiederherstellen, fr die C Version. -PRAK!- }
end { trennen };
{----------------------------------------------------------------------------}
procedure abteilen ( var w:wort; var tr1:trennvektor;
laenge : integer; var ok:boolean;
var zerlegungen:integer );
label 99;
{ kommt in den outer Block }
{ mtype sperrvektor=array [0..maxwl] of boolean; }
var
i:integer;
dud:dudt; { array [0..maxwl] of boolean; }
v:varr;
ind,k:intarr;
spv,dudstop:sperrvektor;
tr, dudtr:trennvektor;
begin { abteilen }
tr1[0] := keine;
for i:=0 to laenge do begin
tr[i]:=keine; spv[i]:=false; dudstop[i]:=false; dud[i]:=false;
if i > 0 then
if (w[i] = trennzeichen) or (w[i] = sonderzeichen)
then begin
zerlegungen := 0;
ok := false;
goto 99;
end;
end;
zerlegungen:=0;
trennen(3, 1, spv, ok,
tr,dudtr,zerlegungen,dud,v,ind,k,
dudstop,w,tr1,laenge);
for i:=0 to laenge do
if tr1[i]=nebenck then begin
tr1[i]:=keine; { c-k wird zu -ck da sp\"ater dement- }
tr1[i-1]:=nebenck; {sprechend getrennt wird }
end;
99:
end;{ abteilen }
{----------------------------------------------------------------------------}
{identification number for dirty umlauts; see description in
change file}
function is_dirty_umlaut(p:pointer):boolean;
var res:boolean;
q:pointer;
begin
res:=false;
if p<>null then
if type(p)=disc_node then
if pre_break(p)<>null then
if link(pre_break(p))<>null then
if link(link(pre_break(p)))<>null then begin
q:=pre_break(p);
if type(q)=penalty_node then q:=link(q);
if (type(q)=kern_node)and(width(q)=spec_letter_ID)and
is_char_node(link(q))and(type(link(link(q)))=kern_node) then res:=true;
end;
is_dirty_umlaut:=res;
end; {|is_dirty_umlaut|}
function get_char_of(s:pointer):integer;
var q:pointer;
begin
q:=pre_break(s);
if type(q)=penalty_node then q:=link(q);
get_char_of:=width(link(link(q)));
end; {|get_char_of|}
function get_font_of(s:pointer):integer;
var q:pointer;
begin
q:=pre_break(s);
if type(q)=penalty_node then q:=link(q);
get_font_of:=font(link(q));
end; {|get_font_of|}
{----------------------------------------------------------------------------}
@ Ende ...
@z
=========================================================================
@x
@ Now let's go back to the easier problem, of building the linked
trie. When \.{INITEX} has scanned the `\.{\\patterns}' control
sequence, it calls on |new_patterns| to do the right thing.
@<Declare procedures for preprocessing hyph...@>=
procedure new_patterns; {initializes the hyphenation pattern data}
label done, done1;
var k,@!l:small_number; {indices into |hc| and |hyf|}
@!digit_sensed:boolean; {should the next digit be treated as a letter?}
@!v:quarterword; {trie op code}
@!p,@!q:trie_pointer; {nodes of trie traversed during insertion}
@!first_child:boolean; {is |p=trie_l[q]|?}
@!c:ASCII_code; {character being inserted}
begin if trie_not_ready then
begin set_cur_lang; scan_left_brace; {a left brace must follow \.{\\patterns}}
@<Enter all of the patterns into a linked trie, until coming to a right
brace@>;
end
else begin print_err("Too late for "); print_esc("patterns");
help1("All patterns must be given before typesetting begins.");
error; link(garbage):=scan_toks(false,false); flush_list(def_ref);
end;
end;
@y
@ We do not build a trie (wether a linked nor a packed). Instead, we
create a hash table for the \SISISI-hyphenation algorithm. But we
still use the data provided by the `\.{\\patterns}' primitive.
@<Declare procedures for preprocessing hyph...@>=
procedure new_patterns; {initializes the hyphenation pattern data}
label done;
var k: small_number; {index into |zeile|}
@!zeile:string80; { Silbe <space> Type <,> als Eintrag der Hashtabelle }
@!status:integer;
@!c:ASCII_code; {character being inserted}
begin
if trie_not_ready then begin
set_cur_lang; scan_left_brace; {a left brace must follow \.{\\patterns}}
hashempty; { create the empty hash table }
@<Enter all of the patterns into a hash table, until coming to a right
brace; then skip an optional space@>;
hashsave(status);
if status<>0 then begin
wterm_ln('Fehler bei hash save !!!!!'{?});
wlog_ln( 'Fehler bei hash save !!!!!'{?});
end;
end else begin
print_err("Too late for "); print_esc("patterns");
help1("All patterns must be given before typesetting begins.");
error; link(garbage):=scan_toks(false,false); flush_list(def_ref);
end;
end;
@z
--------------------------------------------------------------------------
@x
@ Novices are not supposed to be using \.{\\patterns}, so the error
messages are terse. (Note that all error messages appear in \TeX's string
pool, even if they are used only by \.{INITEX}.)
@<Enter all of the patterns into a linked trie...@>=
k:=0; hyf[0]:=0; digit_sensed:=false;
loop@+ begin get_x_token;
case cur_cmd of
letter,other_char:@<Append a new letter or a hyphen level@>;
spacer,right_brace: begin if k>0 then
@<Insert a new pattern into the linked trie@>;
if cur_cmd=right_brace then goto done;
k:=0; hyf[0]:=0; digit_sensed:=false;
end;
othercases begin print_err("Bad "); print_esc("patterns");
@.Bad \\patterns@>
help1("(See Appendix H.)"); error;
end
endcases;
end;
done:
@y
@ Here we build the hash table for the \SISISI-hyphenation.
@<Enter all of the patterns into a hash table, until coming to a right...@>=
for k:=0 to maxwl do zeile[k]:=" ";
k:=0;
loop@+ begin
get_x_token; { \SISISI Worttabelle hat das Format 'Text.Type,'.
Der Beistrich wird eigens abgefragt, da er in TeX
umdefiniert werden kann. }
if (cur_cmd = right_brace)or(cur_chr = ",") then
begin
{ Ein Eintrag der Worttabelle - letzter
(|cur_cmd|=|right_brace|) - gelesen }
if k>0 then eintragen(zeile,k); { ein Eintrag vorhanden }
if cur_cmd = right_brace then goto done;
k := 0; { hyf[] ist \"uberfl\"ussig, da die
Trenninformation in zeile mitverpackt ist. }
end
else { Das Wort ist noch nicht fertig gelesen }
if (cur_cmd = letter) or (cur_cmd = other_char)
or (cur_cmd = spacer) or (cur_chr = ".")
then begin
@<Append a new letter or a hyphen level@>;
end else begin
print_err("Bad "); print_esc("patterns");
@.Bad \\patterns@>
help1("(See Appendix H.)"); error;
end;
end; {|loop|}
done:
@z
-----------------------------------------------------------------------------
@x
@ @<Append a new letter or a hyphen level@>=
if digit_sensed or(cur_chr<"0")or(cur_chr>"9") then
begin if cur_chr="." then cur_chr:=0 {edge-of-word delimiter}
else begin cur_chr:=lc_code(cur_chr);
if cur_chr=0 then
begin print_err("Nonletter");
@.Nonletter@>
help1("(See Appendix H.)"); error;
end;
end;
if k<63 then
begin incr(k); hc[k]:=cur_chr; hyf[k]:=0; digit_sensed:=false;
end;
end
else if k<63 then
begin hyf[k]:=cur_chr-"0"; digit_sensed:=true;
end
@y
@ @<Append a new letter or a hyphen level@>=
if (cur_chr<>" ")then begin
{ Das Leerzeichen wird \"uberlesen! }
if (cur_chr <> ".") then begin
{ der Punkt trennt die Silbe von der Silbenart und bleibt erhalten }
if (cur_chr<"0")or(cur_chr>"9") then begin
cur_chr:=lc_code(cur_chr);
if cur_chr=0 then begin
print_err("Nonletter");
@.Nonletter@>
help1("(See Appendix H.)"); error; cur_chr:=128;
end;
end;
end;
if k<63 then begin
incr(k); zeile[k]:=cur_chr;
end;
end;
@z
----------------------------------------------------------------------------
@x
@ When the following code comes into play, the pattern $p_1\ldots p_k$
appears in |hc[1..k]|, and the corresponding sequence of numbers $n_0\ldots
n_k$ appears in |hyf[0..k]|.
@<Insert a new pattern into the linked trie@>=
begin @<Compute the trie op code, |v|, and set |l:=0|@>;
q:=0; hc[0]:=cur_lang;
while l<=k do
begin c:=hc[l]; incr(l); p:=trie_l[q]; first_child:=true;
while (p>0)and(c>so(trie_c[p])) do
begin q:=p; p:=trie_r[q]; first_child:=false;
end;
if (p=0)or(c<so(trie_c[p])) then
@<Insert a new trie node between |q| and |p|, and
make |p| point to it@>;
q:=p; {now node |q| represents $p_1\ldots p_l$}
end;
if trie_o[q]<>min_quarterword then
begin print_err("Duplicate pattern");
@.Duplicate pattern@>
help1("(See Appendix H.)"); error;
end;
trie_o[q]:=v;
end
@y
@ Well, that was everything about the initialization of the \SISISI hash
table (at this place).
All following sections, describing the initialization of the trie are
replaced by ``empty sections'' in order to have same section numbering
in SI\TeX as in \TeX.
@z
----------------------------------------------------------------------------
@x
@ @<Insert a new trie node between |q| and |p|...@>=
begin if trie_ptr=trie_size then overflow("pattern memory",trie_size);
@:TeX capacity exceeded pattern memory}{\quad pattern memory@>
incr(trie_ptr); trie_r[trie_ptr]:=p; p:=trie_ptr; trie_l[p]:=0;
if first_child then trie_l[q]:=p@+else trie_r[q]:=p;
trie_c[p]:=si(c); trie_o[p]:=min_quarterword;
end
@y
@ ``Empty section''.
@z
------------------------------------------------------------------------------
@x
@ @<Compute the trie op code, |v|...@>=
if hc[1]=0 then hyf[0]:=0;
if hc[k]=0 then hyf[k]:=0;
l:=k; v:=min_quarterword;
loop@+ begin if hyf[l]<>0 then v:=new_trie_op(k-l,hyf[l],v);
if l>0 then decr(l)@+else goto done1;
end;
done1:
@y
@ Further ``empty section''.
@z
@x
@ Finally we put everything together: Here is how the trie gets to its
final, efficient form.
The following packing routine is rigged so that the root of the linked
tree gets mapped into location 1 of |trie|, as required by the hyphenation
algorithm. This happens because the first call of |first_fit| will
``take'' location~1.
@<Declare procedures for preprocessing hyphenation patterns@>=
procedure init_trie;
var @!p:trie_pointer; {pointer for initialization}
@!j,@!k,@!t:integer; {all-purpose registers for initialization}
@!r,@!s:trie_pointer; {used to clean up the packed |trie|}
@!h:two_halves; {template used to zero out |trie|'s holes}
begin @<Get ready to compress the trie@>;
if trie_root<>0 then
begin first_fit(trie_root); trie_pack(trie_root);
end;
@y
@ Because we do not use the trie, we fill it with dummy data.
But the main reason, why we do not remove this procedure is, that
it is called and the used variables are referenced somewhere in \TeX.
@<Declare procedures for preprocessing hyphenation patterns@>=
procedure init_trie;
var @!p:trie_pointer; {pointer for initialization}
@!j,@!k,@!t:integer; {all-purpose registers for initialization}
@!r,@!s:trie_pointer; {used to clean up the packed |trie|}
@!h:two_halves; {template used to zero out |trie|'s holes}
begin
trie_root:=0;
@z
=========================================================================
