#define EXTERN extern

#define EXTERN extern
#include "texd.h"

void zpostlinebreak ( finalwidowpenalty )
integer finalwidowpenalty ;
{/* 30 31 */ postlinebreak_regmem
halfword q, r, s ;
boolean discbreak ;
boolean postdiscbreak ;
scaled curwidth ;
scaled curindent ;
quarterword t ;
integer pen ;
halfword curline ;
q = mem [ bestbet + 1 ] .hh .v.RH ;
curp = 0 ;
do {
r = q ;
q = mem [ q + 1 ] .hh .v.LH ;
mem [ r + 1 ] .hh .v.LH = curp ;
curp = r ;
} while ( ! ( q == 0 ) ) ;
curline = curlist .pgfield + 1 ;
do {
q = mem [ curp + 1 ] .hh .v.RH ;
discbreak = false ;
postdiscbreak = false ;
if ( q != 0 )
if ( mem [ q ] .hh.b0 == 10 )
{
deleteglueref ( mem [ q + 1 ] .hh .v.LH ) ;
mem [ q + 1 ] .hh .v.LH = eqtb [ 10290 ] .hh .v.RH ;
mem [ q ] .hh.b1 = 9 ;
incr ( mem [ eqtb [ 10290 ] .hh .v.RH ] .hh .v.RH ) ;
goto lab30 ;
}
else {

if ( mem [ q ] .hh.b0 == 7 )
{
t = mem [ q ] .hh.b1 ;
if ( t == 0 )
r = mem [ q ] .hh .v.RH ;
else {

r = q ;
while ( t > 1 ) {

r = mem [ r ] .hh .v.RH ;
decr ( t ) ;
}
s = mem [ r ] .hh .v.RH ;
r = mem [ s ] .hh .v.RH ;
mem [ s ] .hh .v.RH = 0 ;
flushnodelist ( mem [ q ] .hh .v.RH ) ;
mem [ q ] .hh.b1 = 0 ;
}
if ( mem [ q + 1 ] .hh .v.RH != 0 )
{
s = mem [ q + 1 ] .hh .v.RH ;
while ( mem [ s ] .hh .v.RH != 0 ) s = mem [ s ] .hh .v.RH ;
mem [ s ] .hh .v.RH = r ;
r = mem [ q + 1 ] .hh .v.RH ;
mem [ q + 1 ] .hh .v.RH = 0 ;
postdiscbreak = true ;
}
if ( mem [ q + 1 ] .hh .v.LH != 0 )
{
s = mem [ q + 1 ] .hh .v.LH ;
if ( mem [ s ] .hh.b0 == 12 )
{
s = mem [ s ] .hh .v.RH ;
mem [ mem [ q + 1 ] .hh .v.LH ] .hh .v.RH = 0 ;
flushnodelist ( mem [ q + 1 ] .hh .v.LH ) ;
}
mem [ q ] .hh .v.RH = s ;
while ( mem [ s ] .hh .v.RH != 0 ) s = mem [ s ] .hh .v.RH ;
mem [ q + 1 ] .hh .v.LH = 0 ;
q = s ;
}
mem [ q ] .hh .v.RH = r ;
discbreak = true ;
}
else if ( ( mem [ q ] .hh.b0 == 9 ) || ( mem [ q ] .hh.b0 == 11 ) )
mem [ q + 1 ] .cint = 0 ;
}
else {

q = memtop - 3 ;
while ( mem [ q ] .hh .v.RH != 0 ) q = mem [ q ] .hh .v.RH ;
}
r = newparamglue ( 8 ) ;
mem [ r ] .hh .v.RH = mem [ q ] .hh .v.RH ;
mem [ q ] .hh .v.RH = r ;
q = r ;
lab30: ;
r = mem [ q ] .hh .v.RH ;
mem [ q ] .hh .v.RH = 0 ;
q = mem [ memtop - 3 ] .hh .v.RH ;
mem [ memtop - 3 ] .hh .v.RH = r ;
if ( eqtb [ 10289 ] .hh .v.RH != 0 )
{
r = newparamglue ( 7 ) ;
mem [ r ] .hh .v.RH = q ;
q = r ;
}
if ( curline > lastspecialline )
{
curwidth = secondwidth ;
curindent = secondindent ;
}
else if ( eqtb [ 10812 ] .hh .v.RH == 0 )
{
curwidth = firstwidth ;
curindent = firstindent ;
}
else {

curwidth = mem [ eqtb [ 10812 ] .hh .v.RH + 2 * curline ] .cint ;
curindent = mem [ eqtb [ 10812 ] .hh .v.RH + 2 * curline - 1 ] .cint ;
}
adjusttail = memtop - 5 ;
justbox = hpack ( q , curwidth , 0 ) ;
mem [ justbox + 4 ] .cint = curindent ;
appendtovlist ( justbox ) ;
if ( memtop - 5 != adjusttail )
{
mem [ curlist .tailfield ] .hh .v.RH = mem [ memtop - 5 ] .hh .v.RH ;
curlist .tailfield = adjusttail ;
}
adjusttail = 0 ;
if ( curline + 1 != bestline )
{
pen = eqtb [ 12676 ] .cint ;
if ( curline == curlist .pgfield + 1 )
pen = pen + eqtb [ 12668 ] .cint ;
if ( curline + 2 == bestline )
pen = pen + finalwidowpenalty ;
if ( discbreak )
pen = pen + eqtb [ 12671 ] .cint ;
if ( pen != 0 )
{
r = newpenalty ( pen ) ;
mem [ curlist .tailfield ] .hh .v.RH = r ;
curlist .tailfield = r ;
}
}
incr ( curline ) ;
curp = mem [ curp + 1 ] .hh .v.LH ;
if ( curp != 0 )
if ( ! postdiscbreak )
{
r = memtop - 3 ;
while ( true ) {

q = mem [ r ] .hh .v.RH ;
if ( q == mem [ curp + 1 ] .hh .v.RH )
goto lab31 ;
if ( ( q >= himemmin ) )
goto lab31 ;
if ( ( mem [ q ] .hh.b0 < 9 ) )
goto lab31 ;
if ( mem [ q ] .hh.b1 == 2 )
if ( mem [ q ] .hh.b0 == 11 )
goto lab31 ;
r = q ;
}
lab31: if ( r != memtop - 3 )
{
mem [ r ] .hh .v.RH = 0 ;
flushnodelist ( mem [ memtop - 3 ] .hh .v.RH ) ;
mem [ memtop - 3 ] .hh .v.RH = q ;
}
}
} while ( ! ( curp == 0 ) ) ;
if ( ( curline != bestline ) || ( mem [ memtop - 3 ] .hh .v.RH != 0 ) )
confusion ( 935 ) ;
curlist .pgfield = bestline - 1 ;
}
smallnumber zreconstitute ( j , n , bchar , hchar )
smallnumber j ;
smallnumber n ;
halfword bchar ;
halfword hchar ;
{/* 22 30 */ register smallnumber Result; reconstitute_regmem
halfword p ;
halfword t ;
fourquarters q ;
halfword currh ;
halfword testchar ;
scaled w ;
fontindex k ;
smallnumber ii ;
hyphenpassed = 0 ;
t = memtop - 4 ;
w = 0 ;
mem [ memtop - 4 ] .hh .v.RH = 0 ;
{register integer for_end; ii = n ; for_end = j ; if ( ii >= for_end) do
if ( dirtyumlaut [ ii ] != 0 )
n = ii - 1 ;
while ( ii-- > for_end ) ; }
curl = hu [ j ] ;
curq = t ;
if ( j == 0 )
{
ligaturepresent = initlig ;
p = initlist ;
if ( ligaturepresent )
lfthit = initlft ;
while ( p > 0 ) {

{
mem [ t ] .hh .v.RH = getavail () ;
t = mem [ t ] .hh .v.RH ;
mem [ t ] .hh.b0 = hf ;
mem [ t ] .hh.b1 = mem [ p ] .hh.b1 ;
}
p = mem [ p ] .hh .v.RH ;
}
}
else if ( curl < 256 )
{
mem [ t ] .hh .v.RH = getavail () ;
t = mem [ t ] .hh .v.RH ;
mem [ t ] .hh.b0 = hf ;
mem [ t ] .hh.b1 = curl ;
}
ligstack = 0 ;
{
if ( j < n )
curr = hu [ j + 1 ] ;
else curr = bchar ;
if ( hyfpen [ j ] != 10000 )
currh = hchar ;
else currh = 256 ;
}
lab22: if ( curl == 256 )
{
k = bcharlabel [ hf ] ;
if ( k == fontmemsize )
goto lab30 ;
else q = fontinfo [ k ] .qqqq ;
}
else {

q = fontinfo [ charbase [ hf ] + curl ] .qqqq ;
if ( ( ( q .b2 ) % 4 ) != 1 )
goto lab30 ;
k = ligkernbase [ hf ] + q .b3 ;
q = fontinfo [ k ] .qqqq ;
if ( q .b0 > 128 )
{
k = ligkernbase [ hf ] + 256 * q .b2 + q .b3 + 32768L - 256 * ( 128 ) ;
q = fontinfo [ k ] .qqqq ;
}
}
if ( currh < 256 )
testchar = currh ;
else testchar = curr ;
while ( true ) {

if ( q .b1 == testchar )
if ( q .b0 <= 128 )
if ( currh < 256 )
{
hyphenpassed = j ;
hchar = 256 ;
currh = 256 ;
goto lab22 ;
}
else {

if ( hchar < 256 )
if ( hyfpen [ j ] != 10000 )
{
hyphenpassed = j ;
hchar = 256 ;
}
if ( q .b2 < 128 )
{
if ( curl == 256 )
lfthit = true ;
if ( j == n )
if ( ligstack == 0 )
rthit = true ;
{
if ( interrupt != 0 )
pauseforinstructions () ;
}
switch ( q .b2 )
{case 1 :
case 5 :
{
curl = q .b3 ;
ligaturepresent = true ;
}
break ;
case 2 :
case 6 :
{
curr = q .b3 ;
if ( ligstack > 0 )
mem [ ligstack ] .hh.b1 = curr ;
else {

ligstack = newligitem ( curr ) ;
if ( j == n )
bchar = 256 ;
else {

p = getavail () ;
mem [ ligstack + 1 ] .hh .v.RH = p ;
mem [ p ] .hh.b1 = hu [ j + 1 ] ;
mem [ p ] .hh.b0 = hf ;
}
}
}
break ;
case 3 :
{
curr = q .b3 ;
p = ligstack ;
ligstack = newligitem ( curr ) ;
mem [ ligstack ] .hh .v.RH = p ;
}
break ;
case 7 :
case 11 :
{
if ( ligaturepresent )
{
p = newligature ( hf , curl , mem [ curq ] .hh .v.RH ) ;
if ( lfthit )
{
mem [ p ] .hh.b1 = 2 ;
lfthit = false ;
}
if ( false )
if ( ligstack == 0 )
{
incr ( mem [ p ] .hh.b1 ) ;
rthit = false ;
}
mem [ curq ] .hh .v.RH = p ;
t = p ;
ligaturepresent = false ;
}
curq = t ;
curl = q .b3 ;
ligaturepresent = true ;
}
break ;
default:
{
curl = q .b3 ;
ligaturepresent = true ;
if ( ligstack > 0 )
{
if ( mem [ ligstack + 1 ] .hh .v.RH > 0 )
{
mem [ t ] .hh .v.RH = mem [ ligstack + 1 ] .hh .v.RH ;
t = mem [ t ] .hh .v.RH ;
incr ( j ) ;
}
p = ligstack ;
ligstack = mem [ p ] .hh .v.RH ;
freenode ( p , 2 ) ;
if ( ligstack == 0 )
{
if ( j < n )
curr = hu [ j + 1 ] ;
else curr = bchar ;
if ( hyfpen [ j ] != 10000 )
currh = hchar ;
else currh = 256 ;
}
else curr = mem [ ligstack ] .hh.b1 ;
}
else if ( j == n )
goto lab30 ;
else {

{
mem [ t ] .hh .v.RH = getavail () ;
t = mem [ t ] .hh .v.RH ;
mem [ t ] .hh.b0 = hf ;
mem [ t ] .hh.b1 = curr ;
}
incr ( j ) ;
{
if ( j < n )
curr = hu [ j + 1 ] ;
else curr = bchar ;
if ( hyfpen [ j ] != 10000 )
currh = hchar ;
else currh = 256 ;
}
}
}
break ;
}
if ( q .b2 > 4 )
if ( q .b2 != 7 )
goto lab30 ;
goto lab22 ;
}
w = fontinfo [ kernbase [ hf ] + 256 * q .b2 + q .b3 ] .cint ;
goto lab30 ;
}
if ( q .b0 >= 128 )
if ( currh == 256 )
goto lab30 ;
else {

currh = 256 ;
goto lab22 ;
}
k = k + q .b0 + 1 ;
q = fontinfo [ k ] .qqqq ;
}
lab30: ;
if ( ligaturepresent )
{
p = newligature ( hf , curl , mem [ curq ] .hh .v.RH ) ;
if ( lfthit )
{
mem [ p ] .hh.b1 = 2 ;
lfthit = false ;
}
if ( rthit )
if ( ligstack == 0 )
{
incr ( mem [ p ] .hh.b1 ) ;
rthit = false ;
}
mem [ curq ] .hh .v.RH = p ;
t = p ;
ligaturepresent = false ;
}
if ( w != 0 )
{
mem [ t ] .hh .v.RH = newkern ( w ) ;
t = mem [ t ] .hh .v.RH ;
w = 0 ;
}
if ( ligstack > 0 )
{
curq = t ;
curl = mem [ ligstack ] .hh.b1 ;
ligaturepresent = true ;
{
if ( mem [ ligstack + 1 ] .hh .v.RH > 0 )
{
mem [ t ] .hh .v.RH = mem [ ligstack + 1 ] .hh .v.RH ;
t = mem [ t ] .hh .v.RH ;
incr ( j ) ;
}
p = ligstack ;
ligstack = mem [ p ] .hh .v.RH ;
freenode ( p , 2 ) ;
if ( ligstack == 0 )
{
if ( j < n )
curr = hu [ j + 1 ] ;
else curr = bchar ;
if ( hyfpen [ j ] != 10000 )
currh = hchar ;
else currh = 256 ;
}
else curr = mem [ ligstack ] .hh.b1 ;
}
goto lab22 ;
}
Result = j ;
return(Result) ;
}
void zhashfunk ( w , anfang , ende , v , ind , k )
wort w ;
integer anfang ;
integer ende ;
varr v ;
intarr ind ;
intarr k ;
{hashfunk_regmem
long vacc, indacc, kacc ;
integer i ;
vacc = 31415L ;
indacc = 152L ;
kacc = 271L ;
{register integer for_end; i = anfang ; for_end = ende ; if ( i <= for_end)
do
{
;
vacc = ( vacc * 31 + w [ i ] ) % 8388648L ;
v [ i ] = vacc ;
indacc = ( indacc * 33 + w [ i ] ) % ( tabsize + 1 ) ;
ind [ i ] = indacc ;
kacc = ( kacc * 15 + w [ i ] ) % ( ( tabsize + 1 ) / 2 ) ;
k [ i ] = 2 * kacc + 1 ;
}
while ( i++ < for_end ) ; }
}
void zunpackinfo ( b , iausnahme , iuntrennbar , ierste , izweite , iendung ,
ivorsilbe , istamm , iehervor , istammallein )
infobyte b ;
boolean * iausnahme ;
boolean * iuntrennbar ;
integer * ierste ;
integer * izweite ;
boolean * iendung ;
boolean * ivorsilbe ;
boolean * istamm ;
boolean * iehervor ;
boolean * istammallein ;
{unpackinfo_regmem
if ( odd ( b ) )
{
(* iausnahme )= true ;
b = b / 2 ;
if ( odd ( b ) )
(* iuntrennbar )= true ;
else (*iuntrennbar )= false ;
b = b / 2 ;
(* ierste )= b % 8 ;
(* izweite )= b / 8 ;
}
else {

(* iausnahme )= false ;
b = b / 2 ;
if ( odd ( b ) )
(* iendung )= true ;
else (*iendung )= false ;
b = b / 2 ;
if ( odd ( b ) )
(* ivorsilbe )= true ;
else (*ivorsilbe )= false ;
b = b / 2 ;
if ( odd ( b ) )
(* istamm )= true ;
else (*istamm )= false ;
b = b / 2 ;
if ( odd ( b ) )
(* iehervor )= true ;
else (*iehervor )= false ;
b = b / 2 ;
if ( odd ( b ) )
(* istammallein )= true ;
else (*istammallein )= false ;
}
}
void zunpackentry ( h , etabv , etabb , efrei , ewiederfrei )
hashelement h ;
verdschlue * etabv ;
infobyte * etabb ;
boolean * efrei ;
boolean * ewiederfrei ;
{unpackentry_regmem
;
(* etabv )= h [ 0 ] + h [ 1 ] * 256 + h [ 2 ] * 256 * 256 ;
if ( odd ( h [ 3 ] ) )
{
;
(* etabb )= h [ 3 ] ;
(* efrei )= false ;
(* ewiederfrei )= false ;
}
else {

;
(* etabb )= h [ 3 ] % 64 ;
if ( odd ( h [ 3 ] / 64 ) )
(* efrei )= true ;
else (*efrei )= false ;
if ( odd ( h [ 3 ] / 128 ) )
(* ewiederfrei )= true ;
else (*ewiederfrei )= false ;
}
}
void zhashsuch ( v , ind , k , iausnahme , iuntrennbar , ierste , izweite ,
iendung , ivorsilbe , istamm , iehervor , istammallein , g )
verdschlue v ;
integer ind ;
integer k ;
boolean * iausnahme ;
boolean * iuntrennbar ;
integer * ierste ;
integer * izweite ;
boolean * iendung ;
boolean * ivorsilbe ;
boolean * istamm ;
boolean * iehervor ;
boolean * istammallein ;
boolean * g ;
{hashsuch_regmem
boolean gef, ngef ;
integer j ;
tableentry entry ;
gef = false ;
ngef = false ;
j = ind ;
do {
unpackentry ( htab [ j ] , entry .tabv , entry .tabb , entry .frei ,
entry .wiederfrei ) ;
if ( entry .frei )
ngef = true ;
else if ( ( v == entry .tabv ) && ! entry .wiederfrei )
{
unpackinfo ( entry .tabb , (*iausnahme ), (*iuntrennbar ), (*ierste ), (*izweite ), (*
iendung ), (*ivorsilbe ), (*istamm ), (*iehervor ), (*istammallein )) ;
gef = true ;
}
else j = ( j + k ) % ( tabsize + 1 ) ;
} while ( ! ( gef || ngef ) ) ;
(* g )= gef ;
}
void zhashload ( status )
integer * status ;
{hashload_regmem
integer i ;
tableentry e ;
{register integer for_end; i = 1 ; for_end = FILENAMESIZE ; if ( i <=
for_end) do
nameoffile [ i ] = ' ' ;
while ( i++ < for_end ) ; }
nameoffile [ 1 ] = 'h' ;
nameoffile [ 2 ] = 'f' ;
nameoffile [ 3 ] = '3' ;
namelength = 3 ;
anzahl = 0 ;
if ( aopenin ( hashfile , TEXINPUTPATH ) )
{
{register integer for_end; i = 0 ; for_end = tabsize ; if ( i <= for_end)
do
{
int help;
fscanf ( hashfile, "%d", &help );
htab [i][0] = (eightbits) help;
fscanf ( hashfile, "%d", &help );
htab [i][1] = (eightbits) help;
fscanf ( hashfile, "%d", &help );
htab [i][2] = (eightbits) help;
fscanf ( hashfile, "%d", &help );
htab [i][3] = (eightbits) help;
unpackentry ( htab [ i ] , e .tabv , e .tabb , e .frei , e .wiederfrei
) ;
if ( ! e .frei && ! e .wiederfrei )
anzahl = anzahl + 1 ;
}
while ( i++ < for_end ) ; }
(* status )= 0 ;
aclose ( hashfile ) ;
}
else (*status )= 1 ;
}
void zpackinfo ( i , b )
infotype i ;
infobyte * b ;
{packinfo_regmem
(* b )= 0 ;
if ( i .ausnahme )
{
;
if ( i .untrennbar )
;
else ;
(* b )= 1 + 2 * ord ( i .untrennbar ) + 4 * i .erste + 32 * i .zweite ;
}
else {

;
(* b )= 2 * ord ( i .endung ) + 4 * ord ( i .vorsilbe ) + 8 * ord ( i .stamm )
+ 16 * ord ( i .ehervor ) + 32 * ord ( i .stammallein ) ;
}
}
void zpackentry ( e , h )
tableentry e ;
hashelement h ;
{packentry_regmem
;
h [ 0 ] = e .tabv % 256 ;
e .tabv = e .tabv / 256 ;
h [ 1 ] = e .tabv % 256 ;
h [ 2 ] = e .tabv / 256 ;
if ( odd ( e .tabb ) )
h [ 3 ] = e .tabb ;
else {

;
h [ 3 ] = e .tabb + 64 * ord ( e .frei ) + 128 * ord ( e .wiederfrei ) ;
}
}
void zhashetr ( w , laenge , i , g )
wort w ;
integer laenge ;
infotype i ;
boolean * g ;
{hashetr_regmem
varr v1 ;
intarr ind1, k1 ;
verdschlue v ;
integer ind, k, j, e ;
boolean gef, ngef ;
tableentry entry ;
hashelement helem ;
if ( anzahl >= tabsize )
{
;
(* g )= false ;
}
else {

;
if ( ( anzahl < 10 ) || ( anzahl % 100 == 0 ) )
{
println () ;
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) fprintf( stdout , "%s%ld%s", " -Anzahl:" , (long)anzahl , ". " ) ;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) fprintf( logfile , "%s%ld%s", " -Anzahl:" , (long)anzahl , ". " ) ;
}
}
hashfunk ( w , 1 , laenge , v1 , ind1 , k1 ) ;
v = v1 [ laenge ] ;
ind = ind1 [ laenge ] ;
k = k1 [ laenge ] ;
gef = false ;
ngef = false ;
do {
;
unpackentry ( htab [ ind ] , entry .tabv , entry .tabb , entry .frei ,
entry .wiederfrei ) ;
if ( entry .frei || entry .wiederfrei )
{
anzahl = anzahl + 1 ;
ngef = true ;
entry .tabv = v ;
packinfo ( i , entry .tabb ) ;
entry .frei = false ;
entry .wiederfrei = false ;
packentry ( entry , helem ) ;
memcpy((void *)htab [ ind ] , (void *)helem , sizeof(hashelement));
}
else {

;
gef = v == entry .tabv ;
if ( ! gef )
ind = ( ind + k ) % ( tabsize + 1 ) ;
}
} while ( ! ( gef || ngef ) ) ;
(* g )= ngef ;
}
}
void hashempty ( )
{hashempty_regmem
integer i ;
tableentry elem ;
hashelement he ;
elem .tabv = 0 ;
elem .tabb = 0 ;
elem .frei = true ;
elem .wiederfrei = false ;
packentry ( elem , he ) ;
{register integer for_end; i = 0 ; for_end = tabsize ; if ( i <= for_end)
do
memcpy((void *)htab [ i ] , (void *)he, sizeof(hashelement));
while ( i++ < for_end ) ; }
anzahl = 0 ;
}
void zhashsave ( status )
integer * status ;
{hashsave_regmem
integer i ;
{register integer for_end; i = 1 ; for_end = FILENAMESIZE ; if ( i <=
for_end) do
nameoffile [ i ] = ' ' ;
while ( i++ < for_end ) ; }
nameoffile [ 1 ] = 'h' ;
nameoffile [ 2 ] = 'f' ;
nameoffile [ 3 ] = '3' ;
namelength = 3 ;
if ( aopenout ( hashfile ) )
{
{register integer for_end; i = 0 ; for_end = tabsize ; if ( i <= for_end)
do
{
(void) fprintf( hashfile , "%4ld", (long)htab [ i ] [ 0 ] ) ;
(void) fprintf( hashfile , "%4ld", (long)htab [ i ] [ 1 ] ) ;
(void) fprintf( hashfile , "%4ld", (long)htab [ i ] [ 2 ] ) ;
(void) fprintf( hashfile , "%4ld", (long)htab [ i ] [ 3 ] ) ;
(void) putc('\n', hashfile );
}
while ( i++ < for_end ) ; }
(* status )= 0 ;
aclose ( hashfile ) ;
}
else (*status )= 1 ;
}
integer hashsize ( )
{register integer Result; hashsize_regmem
Result = anzahl ;
return(Result) ;
}
void zzahl ( line , i , ende , j )
string80 line ;
integer * i ;
integer ende ;
integer * j ;
{zahl_regmem
boolean aus ;
(* j )= 0 ;
do {
if ( (*i )<= ende )
if ( ktab [ line [ (*i )] ] == 46 )
(* i )= (*i )+ 1 ;
else aus = true ;
else aus = true ;
} while ( ! ( aus ) ) ;
do {
if ( (*i )<= ende )
{
switch ( line [ (*i )] )
{case 48 :
case 49 :
case 50 :
case 51 :
case 52 :
case 53 :
case 54 :
case 55 :
case 56 :
case 57 :
{
(* j )= 10 * (*j )+ line [ (*i )] - 48 ;
(* i )= (*i )+ 1 ;
}
break ;
}
if ( ( line [ (*i )] != 48 ) && ( line [ (*i )] != 49 ) && ( line [ (*i )] != 50
) && ( line [ (*i )] != 51 ) && ( line [ (*i )] != 52 ) && ( line [ (*i )] != 53
) && ( line [ (*i )] != 54 ) && ( line [ (*i )] != 55 ) && ( line [ (*i )] != 56
) && ( line [ (*i )] != 57 ) )
aus = true ;
}
else aus = true ;
} while ( ! ( aus ) ) ;
}
void zinfobau ( line , anfang , ende , informausnahme , informuntrennbar ,
informerste , informzweite , informendung , informvorsilbe , informstamm ,
informehervor , informstammallein , g )
string80 line ;
integer anfang ;
integer ende ;
boolean * informausnahme ;
boolean * informuntrennbar ;
integer * informerste ;
integer * informzweite ;
boolean * informendung ;
boolean * informvorsilbe ;
boolean * informstamm ;
boolean * informehervor ;
boolean * informstammallein ;
boolean * g ;
{infobau_regmem
integer i, j ;
boolean ok, fehler ;
buchstabe b ;
(* g )= false ;
(* informausnahme )= false ;
(* informendung )= false ;
(* informvorsilbe )= false ;
(* informehervor )= false ;
(* informstamm )= false ;
(* informstammallein )= false ;
i = anfang ;
ok = false ;
fehler = false ;
do {
if ( i <= ende )
if ( line [ i ] == 46 )
i = i + 1 ;
else ok = true ;
else fehler = true ;
} while ( ! ( ok || fehler ) ) ;
if ( ! fehler )
{
b = ktab [ line [ i ] ] ;
if ( b == bsta )
{
(* informausnahme )= true ;
i = i + 1 ;
if ( ktab [ line [ i ] ] == bstu )
{
i = i + 1 ;
(* informuntrennbar )= true ;
}
else (*informuntrennbar )= false ;
zahl ( line , i , ende , j ) ;
if ( j == 0 )
{
(* informerste )= 7 ;
(* informzweite )= 7 ;
}
else {

j = j - 2 ;
if ( ( j >= 0 ) && ( j <= 6 ) )
(* informerste )= j ;
else fehler = true ;
zahl ( line , i , ende , j ) ;
if ( j == 0 )
(* informzweite )= 7 ;
else {

j = j - (*informerste )- 4 ;
if ( ( j >= 0 ) && ( j <= 6 ) )
(* informzweite )= j ;
else fehler = true ;
}
}
if ( ! fehler )
(* g )= true ;
}
else {

ok = false ;
do {
switch ( b )
{case 22 :
(* informvorsilbe )= true ;
break ;
case 5 :
(* informendung )= true ;
break ;
case 19 :
(* informstamm )= true ;
break ;
case 2 :
(* informehervor )= true ;
break ;
case 20 :
(* informstammallein )= true ;
break ;
case 31 :
;
break ;
default:
fehler = true ;
break ;
}
if ( i == ende )
ok = true ;
else {

i = i + 1 ;
b = ktab [ line [ i ] ] ;
}
} while ( ! ( ok || fehler ) ) ;
if ( ! fehler )
(* g )= ( (*informvorsilbe )|| (*informendung )|| (*informstamm )) && ( ! (*
informehervor )|| (*informvorsilbe )&& (*informendung )) && ( ! (*
informstammallein )|| (*informstamm )) ;
}
}
}
void zeintragen ( line , l )
string80 line ;
integer l ;
{eintragen_regmem
integer i, laenge ;
infotype inform ;
wort w ;
boolean g ;
laenge = 1 ;
while ( line [ laenge ] != 46 ) laenge = laenge + 1 ;
laenge = laenge - 1 ;
if ( laenge >= 1 )
{
if ( laenge <= maxwl )
{
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 ( ! g )
{
println () ;
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) Fputs( stdout , " Info falsch: " ) ;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) Fputs( logfile , " Info falsch: " ) ;
}
}
else {

{register integer for_end; i = 1 ; for_end = laenge ; if ( i <=
for_end) do
w [ i ] = ktab [ line [ i ] ] ;
while ( i++ < for_end ) ; }
hashetr ( w , laenge , inform , g ) ;
if ( ! g )
{
println () ;
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) Fputs( stdout , " Tabellenfehler: " ) ;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) Fputs( logfile , " Tabellenfehler: " ) ;
}
}
}
if ( ! g )
{
{register integer for_end; i = 1 ; for_end = l ; if ( i <= for_end)
do
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) putc( Xchr ( line [ i ] ) , stdout );
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) putc( Xchr ( line [ i ] ) , logfile );
}
while ( i++ < for_end ) ; }
println () ;
}
}
else {

println () ;
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) fprintf( stdout , "%s\n", " zu langes Wort: " ) ;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) fprintf( logfile , "%s\n", " zu langes Wort: " ) ;
}
{register integer for_end; i = 1 ; for_end = l ; if ( i <= for_end) do
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) putc( Xchr ( line [ i ] ) , stdout );
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) putc( Xchr ( line [ i ] ) , logfile );
}
while ( i++ < for_end ) ; }
println () ;
}
}
else {

println () ;
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) fprintf( stdout , "%s\n", " Falsche Zeile: " ) ;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) fprintf( logfile , "%s\n", " Falsche Zeile: " ) ;
}
{register integer for_end; i = 1 ; for_end = l ; if ( i <= for_end) do
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) putc( Xchr ( line [ i ] ) , stdout );
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) putc( Xchr ( line [ i ] ) , logfile );
}
while ( i++ < for_end ) ; }
println () ;
}
}
void znaechsterbst ( i , tr , dudstop , b , w )
integer * i ;
trennvektor tr ;
sperrvektor dudstop ;
buchstabe * b ;
wort w ;
{naechsterbst_regmem
if ( ( (*i )> 0 ) && ( tr [ (*i )] == keine ) && ! dudstop [ (*i )] )
{
(* b )= w [ (*i )] ;
(* i )= (*i )- 1 ;
}
else (*b )= trennzeichen ;
}
void zduden ( tr , w , tr1 , dudtr , dud , dudstop , laenge , ok , zerlegungen
)
trennvektor tr ;
wort w ;
trennvektor tr1 ;
trennvektor dudtr ;
dudt dud ;
sperrvektor dudstop ;
integer laenge ;
boolean * ok ;
integer * zerlegungen ;
{duden_regmem
integer i ;
integer j ;
integer zust ;
boolean aus ;
integer tre ;
integer letzte ;
integer l, lalt ;
buchstabe b ;
i = laenge ;
{register integer for_end; j = 0 ; for_end = laenge ; if ( j <= for_end) do
dudtr [ j ] = tr [ j ] ;
while ( j++ < for_end ) ; }
while ( ( i > 0 ) && ! dud [ i ] ) i = i - 1 ;
while ( i > 0 ) {

zust = 1 ;
aus = false ;
letzte = 0 ;
l = kons ;
b = w [ i ] ;
i = i - 1 ;
do {
{
tre = i + 1 ;
lalt = l ;
switch ( b )
{case 1 :
{
l = voka ;
naechsterbst ( i , tr , dudstop , b , w ) ;
}
break ;
case 15 :
{
l = voko ;
naechsterbst ( i , tr , dudstop , b , w ) ;
}
break ;
case 29 :
{
l = vokue ;
naechsterbst ( i , tr , dudstop , b , w ) ;
}
break ;
case 28 :
{
l = vokoe ;
naechsterbst ( i , tr , dudstop , b , w ) ;
}
break ;
case 27 :
{
l = vokae ;
naechsterbst ( i , tr , dudstop , b , w ) ;
}
break ;
case 5 :
{
l = voke ;
naechsterbst ( i , tr , dudstop , b , w ) ;
if ( b == bsti )
{
l = vokie ;
naechsterbst ( i , tr , dudstop , b , w ) ;
if ( b == bste )
{
i = i + 1 ;
l = voke ;
b = bsti ;
}
}
}
break ;
case 9 :
{
l = voki ;
naechsterbst ( i , tr , dudstop , b , w ) ;
if ( b == bste )
{
l = vokei ;
naechsterbst ( i , tr , dudstop , b , w ) ;
}
else if ( b == bsta )
{
l = vokai ;
naechsterbst ( i , tr , dudstop , b , w ) ;
}
}
break ;
case 21 :
{
l = voku ;
naechsterbst ( i , tr , dudstop , b , w ) ;
if ( b == bste )
{
l = vokeu ;
naechsterbst ( i , tr , dudstop , b , w ) ;
}
else if ( b == bsta )
{
l = vokau ;
naechsterbst ( i , tr , dudstop , b , w ) ;
}
else if ( b == bstae )
{
l = vokaeu ;
naechsterbst ( i , tr , dudstop , b , w ) ;
}
else if ( b == bstq )
{
l = kons ;
naechsterbst ( i , tr , dudstop , b , w ) ;
}
}
break ;
case 20 :
{
l = kons ;
naechsterbst ( i , tr , dudstop , b , w ) ;
if ( b == bsts )
naechsterbst ( i , tr , dudstop , b , w ) ;
}
break ;
case 8 :
{
l = kons ;
naechsterbst ( i , tr , dudstop , b , w ) ;
if ( b == bstc )
{
naechsterbst ( i , tr , dudstop , b , w ) ;
if ( b == bsts )
naechsterbst ( i , tr , dudstop , b , w ) ;
}
else if ( b == bstp )
naechsterbst ( i , tr , dudstop , b , w ) ;
else if ( b == bstt )
naechsterbst ( i , tr , dudstop , b , w ) ;
}
break ;
case 2 :
case 3 :
case 4 :
case 6 :
case 7 :
case 10 :
case 11 :
case 12 :
case 13 :
case 14 :
case 16 :
case 17 :
case 18 :
case 19 :
case 22 :
case 23 :
case 24 :
case 26 :
case 30 :
{
l = kons ;
naechsterbst ( i , tr , dudstop , b , w ) ;
}
break ;
case 25 :
{
l = voky ;
naechsterbst ( i , tr , dudstop , b , w ) ;
}
break ;
case 31 :
case 0 :
aus = true ;
break ;
}
}
if ( ! aus )
switch ( zust )
{case 1 :
if ( l == kons )
zust = 2 ;
else zust = 4 ;
break ;
case 2 :
if ( l != kons )
zust = 3 ;
break ;
case 3 :
if ( l == kons )
zust = 6 ;
else if ( l != lalt )
{
zust = 4 ;
letzte = tre ;
dudtr [ letzte ] = neben ;
}
break ;
case 4 :
if ( l == kons )
zust = 6 ;
else zust = 3 ;
break ;
case 6 :
if ( l == kons )
{
zust = 2 ;
letzte = tre ;
if ( ( w [ tre ] == bstc ) && ( w [ tre + 1 ] == bstk ) )
dudtr [ letzte ] = nebenck ;
else dudtr [ letzte ] = neben ;
}
else {

zust = 4 ;
letzte = tre ;
dudtr [ letzte ] = neben ;
}
break ;
}
} while ( ! ( aus ) ) ;
if ( zust == 2 )
dudtr [ letzte ] = keine ;
else if ( zust == 4 )
if ( ( lalt < vokie ) || ( lalt > vokeu ) )
dudtr [ letzte ] = keine ;
while ( ( i > 0 ) && ! dud [ i ] ) i = i - 1 ;
}
}
void ztrennen ( zustand , anfang , spv , ok1 , alletr , tr , dudtr ,
zerlegungen , dud , v , ind , k , dudstop , w , tr1 , laenge )
integer zustand ;
integer anfang ;
sperrvektor spv ;
boolean * ok1 ;
trenn16 alletr ;
trennvektor tr ;
trennvektor dudtr ;
integer * zerlegungen ;
dudt dud ;
varr v ;
intarr ind ;
intarr k ;
sperrvektor dudstop ;
wort w ;
trennvektor tr1 ;
integer laenge ;
{trennen_regmem
boolean gef, nichtok ;
integer schnitt ;
infotype inform ;
integer i ;
boolean okstamm, okvor, okend, okhelp ;
integer tri ;
integer i1, tre ;
boolean ok ;
integer stopptr ;
sperrvektor spvtmp ;
trennvektor trlast ;
memcpy((void *)spvtmp, (void *)spv, sizeof(sperrvektor)) ;
(* ok1 )= false ;
if ( anfang == laenge + 1 )
if ( ( zustand == 2 ) || ( zustand == 4 ) )
{
dud [ anfang - 1 ] = true ;
duden ( tr , w , tr1 , dudtr , dud , dudstop , laenge , ok , (*zerlegungen ))
;
{register integer for_end; i = laenge ; for_end = 1 ; if ( i >= for_end)
do
{
if ( dudtr [ i - 1 ] == haupt3 )
{
dudtr [ i - 1 ] = keine ;
tri = haupt3 ;
}
else tri = dudtr [ i ] ;
if ( (*zerlegungen )== 0 )
tr1 [ i ] = tri ;
else tr1 [ i ] = kombtab [ tr1 [ i ] ][ tri ] ;
trlast [ i ] = tri ;
}
while ( i-- > for_end ) ; }
(* zerlegungen )= (*zerlegungen )+ 1 ;
memcpy((void *)alletr[(*zerlegungen)],(void *)trlast,sizeof(trennvektor));
(* ok1 )= true ;
}
else ;
else {

hashfunk ( w , anfang , laenge , v , ind , k ) ;
schnitt = laenge ;
nichtok = false ;
do {
do { if ( spv [ schnitt ] )
gef = false ;
else {

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 ) ;
}
if ( gef )
spv [ schnitt ] = true ;
else schnitt = schnitt - 1 ;
} while ( ! ( gef || ( schnitt == anfang - 1 ) ) ) ;
if ( gef )
{
if ( ! inform .ausnahme )
{
if ( inform .endung && ( zustand == 2 ) )
{
okend = false ;
if ( ( w [ anfang ] == bstc ) || ( w [ anfang ] == bsth ) )
{
dud [ anfang - 1 ] = true ;
tr [ anfang - 1 ] = neben ;
}
if ( schnitt < laenge )
if ( ( w [ schnitt + 1 ] == bsts ) && ! spv [ schnitt + 1 ] )
{
spv [ schnitt + 1 ] = true ;
trennen ( 2 , schnitt + 2 , spv , okhelp , alletr , tr , dudtr , (*
zerlegungen ), dud , v , ind , k , dudstop , w , tr1 , laenge ) ;
okend = okhelp ;
}
trennen ( 2 , schnitt + 1 , spv , okhelp , alletr , tr , dudtr , (*
zerlegungen ), dud , v , ind , k , dudstop , w , tr1 , laenge ) ;
okend = okend || okhelp ;
tr [ anfang - 1 ] = keine ;
dud [ anfang - 1 ] = false ;
(* ok1 )= (*ok1 )|| okend ;
}
else okend = false ;
if ( inform .vorsilbe )
{
if ( zustand == 1 )
tr [ anfang - 1 ] = neben ;
else {

dud [ anfang - 1 ] = true ;
if ( zustand == 5 )
tr [ anfang - 1 ] = haupt3 ;
else tr [ anfang - 1 ] = haupt ;
}
dud [ schnitt ] = true ;
trennen ( 1 , schnitt + 1 , spv , okvor , alletr , tr , dudtr , (*
zerlegungen ), dud , v , ind , k , dudstop , w , tr1 , laenge ) ;
tr [ anfang - 1 ] = keine ;
dud [ anfang - 1 ] = false ;
dud [ schnitt ] = false ;
(* ok1 )= (*ok1 )|| okvor ;
}
else okvor = false ;
if ( inform .stamm && ! okvor )
{
if ( ! inform .stammallein )
{
okstamm = false ;
stopptr = 0 ;
if ( zustand == 1 )
tr [ anfang - 1 ] = neben ;
else {

dud [ anfang - 1 ] = true ;
if ( zustand == 5 )
tr [ anfang - 1 ] = haupt3 ;
else tr [ anfang - 1 ] = haupt ;
}
if ( inform .ausnahme )
{
if ( inform .erste != 7 )
{
tre = anfang + inform .erste + 1 ;
tr [ tre ] = neben ;
if ( inform .zweite != 7 )
{
tre = tre + inform .zweite + 2 ;
if ( inform .untrennbar )
{
stopptr = tre ;
dudstop [ stopptr ] = true ;
}
else tr [ tre ] = neben ;
}
else {

if ( inform .untrennbar )
{
tr [ tre ] = keine ;
stopptr = tre ;
dudstop [ tre ] = true ;
}
}
}
else {

stopptr = schnitt - 1 ;
dudstop [ stopptr ] = true ;
}
}
if ( schnitt < laenge )
if ( ( w [ schnitt + 1 ] == bsts ) && ! spv [ schnitt + 1 ] )
{
spv [ schnitt + 1 ] = true ;
trennen ( 2 , schnitt + 2 , spv , okhelp , alletr , tr , dudtr
, (*zerlegungen ), dud , v , ind , k , dudstop , w , tr1 , laenge
) ;
okstamm = okhelp ;
}
if ( ( schnitt >= 2 ) && ( schnitt < laenge ) )
if ( konsonant [ w [ schnitt ] ] && ! konsonant [ w [ schnitt +
1 ] ] && ( w [ schnitt ] == w [ schnitt - 1 ] ) )
{
trennen ( 5 , schnitt , spv , okhelp , alletr , tr , dudtr , (*
zerlegungen ), dud , v , ind , k , dudstop , w , tr1 , laenge )
;
okstamm = okstamm || okhelp ;
}
trennen ( 2 , schnitt + 1 , spv , okhelp , alletr , tr , dudtr , (*
zerlegungen ), dud , v , ind , k , dudstop , w , tr1 , laenge ) ;
okstamm = okstamm || okhelp ;
if ( inform .ausnahme )
{register integer for_end; i1 = anfang - 1 ; for_end = schnitt
; if ( i1 <= for_end) do
{
tr [ i1 ] = keine ;
dud [ i1 ] = false ;
dudstop [ stopptr ] = false ;
}
while ( i1++ < for_end ) ; }
else {

tr [ anfang - 1 ] = keine ;
dud [ anfang - 1 ] = false ;
}
(* ok1 )= (*ok1 )|| okstamm ;
}
else if ( ( anfang == 1 ) && ( schnitt == laenge ) )
{
dud [ anfang - 1 ] = true ;
tr [ anfang - 1 ] = haupt ;
trennen ( 4 , schnitt + 1 , spv , okstamm , alletr , tr , dudtr
, (*zerlegungen ), dud , v , ind , k , dudstop , w , tr1 , laenge )
;
tr [ anfang - 1 ] = keine ;
dud [ anfang - 1 ] = false ;
(* ok1 )= (*ok1 )|| okstamm ;
}
}
}
else {

okstamm = false ;
stopptr = 0 ;
if ( zustand == 1 )
tr [ anfang - 1 ] = neben ;
else {

dud [ anfang - 1 ] = true ;
if ( zustand == 5 )
tr [ anfang - 1 ] = haupt3 ;
else tr [ anfang - 1 ] = haupt ;
}
if ( inform .ausnahme )
{
if ( inform .erste != 7 )
{
tre = anfang + inform .erste + 1 ;
tr [ tre ] = neben ;
if ( inform .zweite != 7 )
{
tre = tre + inform .zweite + 2 ;
if ( inform .untrennbar )
{
stopptr = tre ;
dudstop [ stopptr ] = true ;
}
else tr [ tre ] = neben ;
}
else {

if ( inform .untrennbar )
{
tr [ tre ] = keine ;
stopptr = tre ;
dudstop [ tre ] = true ;
}
}
}
else {

stopptr = schnitt - 1 ;
dudstop [ stopptr ] = true ;
}
}
if ( schnitt < laenge )
if ( ( w [ schnitt + 1 ] == bsts ) && ! spv [ schnitt + 1 ] )
{
spv [ schnitt + 1 ] = true ;
trennen ( 2 , schnitt + 2 , spv , okhelp , alletr , tr , dudtr , (*
zerlegungen ), dud , v , ind , k , dudstop , w , tr1 , laenge ) ;
okstamm = okhelp ;
}
if ( ( schnitt >= 2 ) && ( schnitt < laenge ) )
if ( konsonant [ w [ schnitt ] ] && ! konsonant [ w [ schnitt + 1 ]
] && ( w [ schnitt ] == w [ schnitt - 1 ] ) )
{
trennen ( 5 , schnitt , spv , okhelp , alletr , tr , dudtr , (*
zerlegungen ), dud , v , ind , k , dudstop , w , tr1 , laenge ) ;
okstamm = okstamm || okhelp ;
}
trennen ( 2 , schnitt + 1 , spv , okhelp , alletr , tr , dudtr , (*
zerlegungen ), dud , v , ind , k , dudstop , w , tr1 , laenge ) ;
okstamm = okstamm || okhelp ;
if ( inform .ausnahme )
{register integer for_end; i1 = anfang - 1 ; for_end = schnitt
; if ( i1 <= for_end) do
{
tr [ i1 ] = keine ;
dud [ i1 ] = false ;
dudstop [ stopptr ] = false ;
}
while ( i1++ < for_end ) ; }
else {

tr [ anfang - 1 ] = keine ;
dud [ anfang - 1 ] = false ;
}
(* ok1 )= (*ok1 )|| okstamm ;
}
schnitt = schnitt - 1 ;
nichtok = schnitt == anfang - 1 ;
}
else nichtok = true ;
} while ( ! ( nichtok ) ) ;
}
memcpy((void *)spv, (void *)spvtmp, sizeof(sperrvektor)) ;
}
void zwchar ( c )
halfword c ;
{wchar_regmem
if ( c == 27 )
{
(void) Fputs( stdout , "\"a" ) ;
}
else if ( c == 28 )
{
(void) Fputs( stdout , "\"o" ) ;
}
else if ( c == 29 )
{
(void) Fputs( stdout , "\"u" ) ;
}
else if ( c == 30 )
{
(void) Fputs( stdout , "\"s" ) ;
}
else {

(void) putc( Xchr ( c + 96 ) , stdout );
}
}
void zwwort ( w , l )
wort w ;
integer l ;
{wwort_regmem
integer i ;
{register integer for_end; i = 1 ; for_end = l ; if ( i <= for_end) do
{
wchar ( w [ i ] ) ;
}
while ( i++ < for_end ) ; }
}
void zwritewt ( w , l , tr )
wort w ;
integer l ;
trennvektor tr ;
{writewt_regmem
integer i ;
wchar ( w [ 1 ] ) ;
{register integer for_end; i = 2 ; for_end = l - 1 ; if ( i <= for_end) do
{
if ( ( tr [ i - 1 ] == nebenck ) )
{
(void) putc( 'k' , stdout );
(void) putc( '-' , stdout );
}
else if ( ( tr [ i ] == haupt3 ) )
{
(void) putc( Xchr ( w [ i ] + 96 ) , stdout );
(void) putc( '=' , stdout );
(void) putc( Xchr ( w [ i ] + 96 ) , stdout );
}
else if ( ( tr [ i ] == haupt ) )
{
wchar ( w [ i ] ) ;
(void) putc( '=' , stdout );
}
else if ( ( tr [ i ] == neben ) )
{
wchar ( w [ i ] ) ;
(void) putc( '-' , stdout );
}
else {

wchar ( w [ i ] ) ;
}
}
while ( i++ < for_end ) ; }
wchar ( w [ l ] ) ;
}
void wjob ( )
{wjob_regmem
integer i ;
{register integer for_end; i = strstart [ jobname ] ; for_end = strstart [
jobname + 1 ] - 1 ; if ( i <= for_end) do
{
(void) putc( Xchr ( strpool [ i ] ) , stdout );
}
while ( i++ < for_end ) ; }
}
integer zvergl ( wrt1 , l1 , wrt2 , l2 )
wort wrt1 ;
integer l1 ;
wort wrt2 ;
integer l2 ;
{/* 99 */ register integer Result; vergl_regmem
integer i ;
i = 1 ;
while ( ( i <= l1 ) && ( i <= l2 ) ) {

if ( wrt1 [ i ] < wrt2 [ i ] )
{
Result = -1 ;
goto lab99 ;
}
else if ( wrt1 [ i ] > wrt2 [ i ] )
{
Result = 1 ;
goto lab99 ;
}
i = i + 1 ;
}
if ( l1 < l2 )
{
Result = -1 ;
goto lab99 ;
}
else if ( l1 > l2 )
{
Result = 1 ;
goto lab99 ;
}
else {

Result = 0 ;
goto lab99 ;
}
lab99: ;
return(Result) ;
}
void zgleicheweg ( alletr , zerleg , laenge )
trenn16 alletr ;
integer * zerleg ;
integer laenge ;
{gleicheweg_regmem
integer i, j, k ;
boolean gleich ;
i = 1 ;
do {
j = i + 1 ;
do {
gleich = true ;
k = 1 ;
do {
if ( alletr [ i ] [ k ] == alletr [ j ] [ k ] )
{
k = k + 1 ;
}
else {

gleich = false ;
}
} while ( ! ( ( k > laenge ) || ( gleich == false ) ) ) ;
if ( gleich )
{
{register integer for_end; k = j ; for_end = (*zerleg )- 1 ; if ( k <=
for_end) do
{
memcpy((void *)alletr[k],(void *)alletr[k+1],sizeof(trennvektor));
}
while ( k++ < for_end ) ; }
(* zerleg )= (*zerleg )- 1 ;
}
else {

j = j + 1 ;
}
} while ( ! ( j > (*zerleg )) ) ;
i = i + 1 ;
} while ( ! ( i > (*zerleg )- 1 ) ) ;
}
void zmdbeintragen ( w , l , tr , neu , used , mdb )
wort w ;
integer l ;
trennvektor tr ;
boolean neu ;
boolean used ;
mdbknoten * mdb ;
{mdbeintragen_regmem
integer test ;
if ( (*mdb )== nil )
{
(* mdb )= (mdbknoten) malloc ( sizeof ( mdbschnuller ) ) ;
memcpy((void *)(* mdb )->w12 ,(void *) w ,sizeof(wort));
(* mdb )->l1 = l ;
memcpy((void *)(* mdb )->tr1 ,(void *) tr,sizeof(trennvektor)) ;
(* mdb )->neu1 = neu ;
(* mdb )->used1 = used ;
(* mdb )->del1 = false ;
(* mdb )->li = nil ;
(* mdb )->re = nil ;
if ( isidebug == 1 )
{
(void) putc('\n', stdout );
}
}
else {

test = vergl ( w , l , (*mdb )->w12 , (*mdb )->l1 ) ;
if ( test == -1 )
{
if ( isidebug == 1 )
{
(void) putc( '/' , stdout );
}
mdbeintragen ( w , l , tr , neu , used , (*mdb )->li ) ;
}
else if ( test == 1 )
{
if ( isidebug == 1 )
{
(void) putc( '\\' , stdout );
}
mdbeintragen ( w , l , tr , neu , used , (*mdb )->re ) ;
}
else {

(void) Fputs( stdout , " =iSi=> mdb_eintragen vom gleichen Wort nocheinmal !!!" ) ;
(void) putc('\n', stdout );
}
}
}
void zmdmeintragen ( w , l , tr , neu , mdm )
wort w ;
integer l ;
trennvektor tr ;
boolean neu ;
mdmknoten * mdm ;
{mdmeintragen_regmem
mdmknoten rechts ;
if ( (*mdm )== nil )
{
(* mdm )= (mdmknoten) malloc ( sizeof ( mdmschnuller ) ) ;
memcpy((void *)(* mdm )->w12 ,(void *) w,sizeof(wort)) ;
(* mdm )->l1 = l ;
memcpy((void *)(* mdm )->tr1 ,(void *) tr,sizeof(trennvektor)) ;
(* mdm )->neu1 = neu ;
(* mdm )->li = nil ;
(* mdm )->re = nil ;
}
else if ( (*mdm )->re == nil )
{
(* mdm )->re = (mdmknoten) malloc ( sizeof ( mdmschnuller ) ) ;
memcpy((void *)(* mdm )->re ->w12 ,(void *) w ,sizeof(wort));
(* mdm )->re ->l1 = l ;
memcpy((void *)(* mdm )->re ->tr1 ,(void *) tr,sizeof(trennvektor)) ;
(* mdm )->re ->neu1 = neu ;
(* mdm )->re ->li = nil ;
(* mdm )->re ->re = nil ;
(* mdm )->li = (*mdm )->re ;
}
else {
rechts = (*mdm )->re ;
(* mdm )->re = (mdmknoten) malloc ( sizeof (mdmschnuller ) ) ;
memcpy((void *)(* mdm )->re ->w12 ,(void *) w ,sizeof(wort));
(* mdm )->re ->l1 = l ;
memcpy((void *)(* mdm )->re ->tr1 ,(void *) tr ,sizeof(trennvektor));
(* mdm )->re ->neu1 = neu ;
(* mdm )->re ->li = nil ;
(* mdm )->re ->re = nil ;
rechts ->li = (*mdm )->re ;
}
}
void zmdleintragen ( w , l , mdl )
wort w ;
integer l ;
mdlknoten * mdl ;
{mdleintragen_regmem
mdlknoten rechts ;
if ( isidebug == 1 )
{
(void) Fputs( stdout , " =iSi=> mdl_eintragen von " ) ;
wwort ( w , l ) ;
(void) putc('\n', stdout );
}
if ( (*mdl )== nil )
{
(* mdl )= (mdlknoten) malloc ( sizeof ( mdlschnuller ) ) ;
memcpy((void *)(* mdl )->w12 ,(void *) w,sizeof(wort)) ;
(* mdl )->l1 = l ;
(* mdl )->li = nil ;
(* mdl )->re = nil ;
}
else if ( (*mdl )->re == nil )
{
(* mdl )->re = (mdlknoten) malloc ( sizeof ( mdlschnuller ) ) ;
memcpy((void *)(* mdl )->re ->w12 ,(void *) w,sizeof(wort)) ;
(* mdl )->re ->l1 = l ;
(* mdl )->re ->li = nil ;
(* mdl )->re ->re = nil ;
(* mdl )->li = (*mdl )->re ;
}
else {

rechts = (*mdl )->re ;
(* mdl )->re = (mdlknoten) malloc ( sizeof ( mdlschnuller ) ) ;
memcpy((void *)(* mdl )->re ->w12 ,(void *) w,sizeof(wort)) ;
(* mdl )->re ->l1 = l ;
(* mdl )->re ->li = nil ;
(* mdl )->re ->re = nil ;
rechts ->li = (*mdl )->re ;
}
}
void zmdeeintragen ( w , l , mde )
wort w ;
integer l ;
mdeknoten * mde ;
{mdeeintragen_regmem
mdeknoten rechts ;
if ( isidebug == 1 )
{
(void) Fputs( stdout , " =iSi=> mde_eintragen von " ) ;
wwort ( w , l ) ;
(void) putc('\n', stdout );
}
if ( (*mde )== nil )
{
(* mde )= (mdeknoten) malloc ( sizeof ( mdeschnuller ) ) ;
memcpy((void *)(* mde )->w12 ,(void *) w,sizeof(wort)) ;
(* mde )->l1 = l ;
(* mde )->li = nil ;
(* mde )->re = nil ;
}
else if ( (*mde )->re == nil )
{
(* mde )->re = (mdeknoten) malloc ( sizeof ( mdeschnuller ) ) ;
memcpy((void *)(* mde )->re ->w12 ,(void *) w,sizeof(wort)) ;
(* mde )->re ->l1 = l ;
(* mde )->re ->li = nil ;
(* mde )->re ->re = nil ;
(* mde )->li = (*mde )->re ;
}
else {

rechts = (*mde )->re ;
(* mde )->re = (mdeknoten) malloc ( sizeof ( mdeschnuller ) ) ;
memcpy((void *)(* mde )->re ->w12 ,(void *) w,sizeof(wort)) ;
(* mde )->re ->l1 = l ;
(* mde )->re ->li = nil ;
(* mde )->re ->re = nil ;
rechts ->li = (*mde )->re ;
}
}
boolean zmdsuchen ( w , l , mdb , tr )
wort w ;
integer l ;
mdbknoten * mdb ;
trennvektor tr ;
{register boolean Result; mdsuchen_regmem
integer test ;
if ( (*mdb )== nil )
{
Result = false ;
}
else {

test = vergl ( w , l , (*mdb )->w12 , (*mdb )->l1 ) ;
if ( test == -1 )
{
Result = mdsuchen ( w , l , (*mdb )->li , tr ) ;
}
else if ( test == 1 )
{
Result = mdsuchen ( w , l , (*mdb )->re , tr ) ;
}
else {

tr = (*mdb )->tr1 ;
(* mdb )->used1 = true ;
Result = true ;
}
}
return(Result) ;
}