summaryrefslogtreecommitdiff
path: root/app/baisy/2.2.1-schulis/src/systembaum
blob: 24973983ecbf8fe2aa4a287027acea7721d36af5 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
PACKET systembaumDEFINES sohnvon,reorganisieren,gibbaumtabelle,KNOTEN ,=,
neuerknoten,nilknoten,markierungsknoten,erster,naechster,gueltig,suche,
existiert,read,write,inknotenmenge,ausknotenmenge,knotenloeschen,move,
KNOTENMENGE ,:=,zahlderelemente,leereknotenmenge,knotenmengeloeschen,exporte,
importe,system,listederteilbaeume,startesystembaum,kopieresystembaum,
ueberschreibesystembaum,setzesystembaumzurueck:BOOL PROC sohnvon(KNOTEN 
CONST vater,sohn):pos(kmknoten,CONCR (sohn))>0.kmknoten:IF CONCR (vater)<=
maxknTHEN systembaum.tabzeile(CONCR (vater)).knotenELSE verwaltung.tabzeile(
CONCR (vater)-maxkn).knotenFI .ENDPROC sohnvon;LET maxkn=2190,niltext="",null
=0,knindex=1;LET kn1=2191,kn2=2192,kn3=2193;LET systembaumname="BAISY-0",
systembaumkopie="SBKOP",verwaltungsname="BAISY-1",verwaltungskopie="VWKOP";
LET maxhoehe=100,bottom=1,refkz="1",erreichtkz="2";LET reorgincr=7000;TYPE 
TUPEL =STRUCT (KNOTEN kn,INT index,BOOL markiert);TYPE STACK =STRUCT (ROW 
maxhoeheTUPEL st,INT top);TYPE KNOTENMENGE =INT ;TYPE KNOTEN =INT ;TYPE 
EINTRAG =STRUCT (TEXT attribute,KNOTEN vater,LONGROW knotenmengenLONGROW 
knoten);TYPE SYSTAB =STRUCT (INT maxeintrag,ersterfreier,ROW maxknEINTRAG 
tabzeile);KNOTEN CONST nilknoten:=KNOTEN :(null);KNOTEN CONST 
markierungsknoten:=KNOTEN :(4711);BOUND SYSTAB VAR systembaum;BOUND SYSTAB 
VAR verwaltung;BOUND SYSTAB VAR reorg;KNOTENMENGE VAR exp,imp,sys;PROC 
gibbaumtabelle(TEXT CONST startknotenname,DATASPACE VAR ds):CONCR (systembaum
.tabzeile(systembaum.ersterfreier).vater):=zeilennr(startknotenname);ds:=old(
systembaumname)END PROC gibbaumtabelle;INT PROC zeilennr(TEXT CONST 
startknotenname):KNOTEN VAR k;IF existiert(exporte,k,startknotenname)THEN 
KNOTENMENGE VAR soehne;read(k,soehne);CONCR (erster(soehne))ELSE nullFI END 
PROC zeilennr;OP :=(KNOTEN VAR k,KNOTEN CONST l):CONCR (k):=CONCR (l)END OP 
:=;BOOL OP =(KNOTEN CONST k,KNOTEN CONST l):CONCR (k)=CONCR (l)END OP =;
KNOTEN PROC neuerknoten(KNOTENMENGE CONST m):KNOTEN VAR k;CONCR (k):=
neuereintrag(CONCR (m)<>CONCR (sys),true);inknotenmenge(m,k);kEND PROC 
neuerknoten;KNOTEN PROC neuerknoten(KNOTENMENGE CONST m,TEXT CONST schluessel
):KNOTEN VAR k;IF existiert(m,k,schluessel)THEN LEAVE neuerknotenWITH kFI ;
KNOTEN VAR l;CONCR (l):=neuereintrag(CONCR (m)<>CONCR (sys),true);write(l,
schluessel);inknotenmenge(m,l,k);lEND PROC neuerknoten;BOOL PROC existiert(
KNOTENMENGE CONST a,KNOTEN VAR r,TEXT CONST muster):BOOL VAR gefunden;suche(a
,muster,r,gefunden);gefundenEND PROC existiert;PROC read(KNOTEN CONST k,
KNOTEN VAR vater):vater:=kvater.kvater:IF CONCR (k)<=maxknTHEN systembaum.
tabzeile(CONCR (k)).vaterELSE verwaltung.tabzeile(CONCR (k)-maxkn).vaterFI .
END PROC read;PROC read(KNOTEN CONST k,KNOTENMENGE VAR soehne):CONCR (soehne)
:=CONCR (k)END PROC read;PROC read(KNOTEN CONST k,TEXT VAR attribute):
attribute:=kattribute.kattribute:IF CONCR (k)<=maxknTHEN systembaum.tabzeile(
CONCR (k)).attributeELSE verwaltung.tabzeile(CONCR (k)-maxkn).attributeFI .
END PROC read;PROC read(KNOTEN CONST k,EINTRAG VAR attribute):attribute:=
keintrag.keintrag:IF CONCR (k)<=maxknTHEN systembaum.tabzeile(CONCR (k))ELSE 
verwaltung.tabzeile(CONCR (k)-maxkn)FI .END PROC read;PROC write(KNOTEN 
CONST k,KNOTEN CONST vater):kvater:=vater.kvater:IF CONCR (k)<=maxknTHEN 
systembaum.tabzeile(CONCR (k)).vaterELSE verwaltung.tabzeile(CONCR (k)-maxkn)
.vaterFI .END PROC write;PROC write(KNOTEN CONST k,KNOTENMENGE CONST soehne):
kknoten:=sohnknoten.kknoten:IF CONCR (k)<=maxknTHEN systembaum.tabzeile(
CONCR (k)).knotenELSE verwaltung.tabzeile(CONCR (k)-maxkn).knotenFI .
sohnknoten:IF CONCR (soehne)<=maxknTHEN systembaum.tabzeile(CONCR (soehne)).
knotenELSE verwaltung.tabzeile(CONCR (soehne)-maxkn).knotenFI .END PROC write
;PROC write(KNOTEN CONST k,TEXT CONST attribute):kattribute:=attribute.
kattribute:IF CONCR (k)<=maxknTHEN systembaum.tabzeile(CONCR (k)).attribute
ELSE verwaltung.tabzeile(CONCR (k)-maxkn).attributeFI .END PROC write;PROC 
write(KNOTEN CONST k,EINTRAG CONST attribute):keintrag:=attribute.keintrag:
IF CONCR (k)<=maxknTHEN systembaum.tabzeile(CONCR (k))ELSE verwaltung.
tabzeile(CONCR (k)-maxkn)FI .END PROC write;PROC inknotenmenge(KNOTENMENGE 
CONST km,KNOTEN CONST k):kmknotenCAT kindex;kknotenmengenCAT kmindex.kmknoten
:IF CONCR (km)<=maxknTHEN systembaum.tabzeile(CONCR (km)).knotenELSE 
verwaltung.tabzeile(CONCR (km)-maxkn).knotenFI .kknotenmengen:IF CONCR (k)<=
maxknTHEN systembaum.tabzeile(CONCR (k)).knotenmengenELSE verwaltung.tabzeile
(CONCR (k)-maxkn).knotenmengenFI .kindex:CONCR (k).kmindex:CONCR (km).END 
PROC inknotenmenge;PROC inknotenmenge(KNOTENMENGE CONST km,KNOTEN CONST k,l):
IF l=nilknotenTHEN inknotenmenge(km,k)ELSE insert(kmknoten,posl,kindex);
kknotenmengenCAT kmindexFI .posl:pos(kmknoten,lindex).kmknoten:IF CONCR (km)
<=maxknTHEN systembaum.tabzeile(CONCR (km)).knotenELSE verwaltung.tabzeile(
CONCR (km)-maxkn).knotenFI .kknotenmengen:IF CONCR (k)<=maxknTHEN systembaum.
tabzeile(CONCR (k)).knotenmengenELSE verwaltung.tabzeile(CONCR (k)-maxkn).
knotenmengenFI .kindex:CONCR (k).lindex:CONCR (l).kmindex:CONCR (km).END 
PROC inknotenmenge;PROC ausknotenmenge(KNOTENMENGE CONST km,KNOTEN VAR k):
KNOTEN VAR l:=k;naechster(l,km);delete(kmknoten,kindex);delete(kknotenmengen,
kmindex);k:=l.kmknoten:IF CONCR (km)<=maxknTHEN systembaum.tabzeile(CONCR (km
)).knotenELSE verwaltung.tabzeile(CONCR (km)-maxkn).knotenFI .kknotenmengen:
IF CONCR (k)<=maxknTHEN systembaum.tabzeile(CONCR (k)).knotenmengenELSE 
verwaltung.tabzeile(CONCR (k)-maxkn).knotenmengenFI .kindex:pos(kmknoten,
CONCR (k)).kmindex:pos(kknotenmengen,CONCR (km)).END PROC ausknotenmenge;
PROC knotenloeschen(KNOTENMENGE CONST km,KNOTEN VAR k):IF 
knotenundknotenmengeexistierenTHEN ausallenmengen;sohnknotenmengeloeschen;
ungueltigmachen(CONCR (l))FI .knotenundknotenmengeexistieren:(CONCR (km)<>0)
CAND (CONCR (k)<>0).ausallenmengen:KNOTEN VAR nachf:=k;KNOTEN CONST l:=k;
LONGROW VAR mengen:=kknotenmengen;INT VAR i,mindex;KNOTENMENGE VAR m;FOR i
FROM 1UPTO length(mengen)REP mindex:=mengen_i;CONCR (m):=mindex;
ausknotenmenge(m,k);IF mindex=CONCR (km)THEN nachf:=kFI ;k:=lPER ;k:=nachf.
sohnknotenmengeloeschen:KNOTENMENGE VAR soehne;CONCR (soehne):=CONCR (l);
knotenmengeloeschen(soehne).kknotenmengen:IF CONCR (k)<=maxknTHEN systembaum.
tabzeile(CONCR (k)).knotenmengenELSE verwaltung.tabzeile(CONCR (k)-maxkn).
knotenmengenFI .END PROC knotenloeschen;PROC move(KNOTEN CONST k,KNOTEN 
CONST l):eigenschaftenuebertragen;pointerpflegen.eigenschaftenuebertragen:
systembaum.tabzeile(CONCR (l)).knoten:=systembaum.tabzeile(CONCR (k)).knoten;
systembaum.tabzeile(CONCR (l)).attribute:=systembaum.tabzeile(CONCR (k)).
attribute.pointerpflegen:soehnevonkumsetzen;vaetervonkumsetzen.
soehnevonkumsetzen:soehneumsetzen(systembaum.tabzeile(CONCR (k)).knoten,k,l).
vaetervonkumsetzen:vaeterumsetzen(systembaum.tabzeile(CONCR (k)).knotenmengen
,k,l).END PROC move;PROC soehneumsetzen(LONGROW CONST soehne,KNOTEN CONST von
,nach):INT VAR i;FOR iFROM 1UPTO length(soehne)REP INT VAR sohni:=soehne_i;
replace(beisohni,posvon,CONCR (nach))PER .beisohni:systembaum.tabzeile(sohni)
.knotenmengen.posvon:pos(beisohni,CONCR (von)).END PROC soehneumsetzen;PROC 
vaeterumsetzen(LONGROW CONST vaeter,KNOTEN CONST von,nach):INT VAR i,refindex
;refindex:=CONCR (systembaum.tabzeile(CONCR (von)).vater);FOR iFROM 1UPTO 
length(vaeter)REP INT VAR vateri:=vaeter_i;vaterumsetzen(vateri,refindex,nach
)PER END PROC vaeterumsetzen;PROC vaterumsetzen(INT CONST vaterindex,refindex
,KNOTEN CONST nach):IF (vaterindex<>CONCR (system))CAND (vaterindex<>refindex
)THEN KNOTENMENGE VAR vater;CONCR (vater):=vaterindex;inknotenmenge(vater,
nach)FI END PROC vaterumsetzen;KNOTEN PROC erster(KNOTENMENGE CONST m):
LONGROW CONST ordnung:=mknoten;ersternach(null,ordnung).mknoten:IF CONCR (m)
<=maxknTHEN systembaum.tabzeile(CONCR (m)).knotenELSE verwaltung.tabzeile(
CONCR (m)-maxkn).knotenFI .END PROC erster;PROC naechster(KNOTEN VAR k,
KNOTENMENGE CONST m):LONGROW CONST ordnung:=mknoten;k:=ersternach(indexvonk,
ordnung).indexvonk:pos(ordnung,CONCR (k)).mknoten:IF CONCR (m)<=maxknTHEN 
systembaum.tabzeile(CONCR (m)).knotenELSE verwaltung.tabzeile(CONCR (m)-maxkn
).knotenFI .END PROC naechster;BOOL PROC gueltig(KNOTEN CONST k):CONCR (k)<>
nullEND PROC gueltig;PROC suche(KNOTENMENGE CONST m,TEXT CONST muster,KNOTEN 
VAR k,BOOL VAR gefunden):LONGROW CONST ordnung:=mknoten;INT CONST l:=length(
ordnung);IF l=nullTHEN gefunden:=false;k:=nilknotenELSE INT VAR ordnungsindex
;binsearch(ordnung,muster,BOOL PROC (TEXT CONST ,INT CONST )kleiner,
ordnungsindex);IF ordnungsindex>lTHEN gefunden:=false;k:=nilknotenELSE CONCR 
(k):=ordnung_ordnungsindex;TEXT VAR gefundenesmuster;read(k,gefundenesmuster)
;gefunden:=(muster=gefundenesmuster)FI FI .mknoten:IF CONCR (m)<=maxknTHEN 
systembaum.tabzeile(CONCR (m)).knotenELSE verwaltung.tabzeile(CONCR (m)-maxkn
).knotenFI .END PROC suche;OP :=(KNOTENMENGE VAR k,KNOTENMENGE CONST l):
CONCR (k):=CONCR (l)END OP :=;INT PROC zahlderelemente(KNOTENMENGE CONST km):
length(kmknoten).kmknoten:IF CONCR (km)<=maxknTHEN systembaum.tabzeile(CONCR 
(km)).knotenELSE verwaltung.tabzeile(CONCR (km)-maxkn).knotenFI .END PROC 
zahlderelemente;KNOTENMENGE PROC leereknotenmenge:KNOTENMENGE VAR k;CONCR (k)
:=neuereintrag(true,false);kEND PROC leereknotenmenge;PROC 
knotenmengeloeschen(KNOTENMENGE VAR km):IF knotenmengeexistiertTHEN 
allezeigerloeschen;alsungueltigkennzeichnenFI .knotenmengeexistiert:CONCR (km
)<>0.allezeigerloeschen:INT CONST kmind:=CONCR (km);LONGROW VAR knoten:=
kmindknoten;INT VAR i,kindex;LONGROW VAR row;FOR iFROM 1UPTO length(knoten)
REP kindex:=knoten_i;row:=kindexknotenmengen;delete(kindexknotenmengen,pos(
row,kmind))PER ;.kmindknoten:IF kmind<=maxknTHEN systembaum.tabzeile(kmind).
knotenELSE verwaltung.tabzeile(kmind-maxkn).knotenFI .kindexknotenmengen:IF 
kindex<=maxknTHEN systembaum.tabzeile(kindex).knotenmengenELSE verwaltung.
tabzeile(kindex-maxkn).knotenmengenFI .alsungueltigkennzeichnen:IF 
nichtinknotenTHEN ungueltigmachen(kmind);ELSE kmindknoten:=newrowFI ;CONCR (
km):=null.nichtinknoten:KNOTEN VAR vglknoten,kmknoten;CONCR (kmknoten):=kmind
;read(kmknoten,vglknoten);CONCR (vglknoten)=knindex.END PROC 
knotenmengeloeschen;KNOTENMENGE PROC exporte:expEND PROC exporte;KNOTENMENGE 
PROC importe:impEND PROC importe;KNOTENMENGE PROC system:sysEND PROC system;
PROC startesystembaum:IF verwaltungdaTHEN nurankoppelnELSE 
ankoppelnundpermanenteknotenmengenerzeugenFI ;systembaumbehandeln.
verwaltungda:exists(verwaltungsname).nurankoppeln:verwaltung:=old(
verwaltungsname);CONCR (exp):=kn1;CONCR (imp):=kn2;CONCR (sys):=kn3.
ankoppelnundpermanenteknotenmengenerzeugen:verwaltung:=new(verwaltungsname);
verwaltung.maxeintrag:=0;verwaltung.ersterfreier:=1;exp:=leereknotenmenge;imp
:=leereknotenmenge;sys:=leereknotenmenge.systembaumbehandeln:IF exists(
systembaumname)THEN systembaum:=old(systembaumname)ELSE systembaum:=new(
systembaumname);systembaum.maxeintrag:=0;systembaum.ersterfreier:=1;FI .END 
PROC startesystembaum;PROC listederteilbaeume(TEXT CONST dateiname):LONGROW 
VAR refinements;FILE VAR f:=sequentialfile(output,dateiname);refinements:=
verwaltung.tabzeile(CONCR (exporte)-maxkn).knoten;INT VAR i;FOR iFROM 1UPTO 
length(refinements)REP put(f,verwaltung.tabzeile((refinements_i)-maxkn).
attribute);line(f)PER ;close(f)END PROC listederteilbaeume;PROC 
kopieresystembaum:copy(systembaumname,systembaumkopie);systembaum:=old(
systembaumkopie);copy(verwaltungsname,verwaltungskopie);verwaltung:=old(
verwaltungskopie)END PROC kopieresystembaum;PROC ueberschreibesystembaum:
forget(systembaumname,quiet);rename(systembaumkopie,systembaumname);forget(
verwaltungsname,quiet);rename(verwaltungskopie,verwaltungsname)END PROC 
ueberschreibesystembaum;PROC setzesystembaumzurueck:systembaum:=old(
systembaumname);forget(systembaumkopie,quiet);verwaltung:=old(verwaltungsname
);forget(verwaltungskopie,quiet)END PROC setzesystembaumzurueck;INT PROC 
neuereintrag(BOOL CONST istverwaltung,istknoten):EINTRAG VAR e;e.attribute:=
niltext;IF istknotenTHEN CONCR (e.vater):=null;ELSE CONCR (e.vater):=knindex
FI ;e.knotenmengen:=newrow;e.knoten:=newrow;INT VAR eintragsnr;
naechstenfreiensuchen(istverwaltung,eintragsnr);KNOTEN VAR k;CONCR (k):=
eintragsnr;write(k,e);eintragsnrEND PROC neuereintrag;OP :=(EINTRAG VAR e,
EINTRAG CONST f):CONCR (e):=CONCR (f)END OP :=;PROC naechstenfreiensuchen(
BOOL CONST istverwaltung,INT VAR eintragsnr):IF istverwaltungTHEN 
naechstenfreieninverwaltungsuchen(eintragsnr)ELSE 
naechstenfreieninsystembaumsuchen(eintragsnr)FI END PROC 
naechstenfreiensuchen;PROC naechstenfreieninsystembaumsuchen(INT VAR 
eintragsnr):eintragsnr:=systembaum.ersterfreier;IF systembaum.ersterfreier>
systembaum.maxeintragTHEN systembaum.maxeintrag:=systembaum.ersterfreier;
systembaum.ersterfreierINCR 1ELSE INT VAR i;FOR iFROM systembaum.ersterfreier
+1UPTO systembaum.maxeintragREP IF NOT istgueltigTHEN systembaum.ersterfreier
:=i;LEAVE naechstenfreieninsystembaumsuchenFI PER ;systembaum.ersterfreier:=
systembaum.maxeintrag+1FI .istgueltig:CONCR (systembaum.tabzeile(i).vater)>=
null.END PROC naechstenfreieninsystembaumsuchen;PROC 
naechstenfreieninverwaltungsuchen(INT VAR eintragsnr):eintragsnr:=verwaltung.
ersterfreier+maxkn;IF verwaltung.ersterfreier>verwaltung.maxeintragTHEN 
verwaltung.maxeintrag:=verwaltung.ersterfreier;verwaltung.ersterfreierINCR 1
ELSE INT VAR i;FOR iFROM verwaltung.ersterfreier+1UPTO verwaltung.maxeintrag
REP IF NOT istgueltigTHEN verwaltung.ersterfreier:=i;LEAVE 
naechstenfreieninverwaltungsuchenFI PER ;verwaltung.ersterfreier:=verwaltung.
maxeintrag+1FI .istgueltig:CONCR (verwaltung.tabzeile(i).vater)>=null.END 
PROC naechstenfreieninverwaltungsuchen;KNOTEN PROC ersternach(INT CONST 
knindex,LONGROW CONST ordnung):KNOTEN VAR k:=nilknoten;INT CONST l:=length(
ordnung);IF (l>0)CAND (knindex<l)THEN CONCR (k):=ordnung_(knindex+1)FI ;kEND 
PROC ersternach;BOOL PROC kleiner(TEXT CONST muster,INT CONST i):KNOTEN VAR k
;TEXT VAR vglmuster;CONCR (k):=i;read(k,vglmuster);muster<=vglmusterEND PROC 
kleiner;PROC ungueltigmachen(INT CONST nr):EINTRAG VAR e;e.attribute:=niltext
;CONCR (e.vater):=-1;e.knotenmengen:=newrow;e.knoten:=newrow;KNOTEN VAR k;
CONCR (k):=nr;write(k,e);ersterfreier(nr)END PROC ungueltigmachen;PROC 
ersterfreier(INT CONST nr):IF nr<=maxknTHEN ersterfreier(systembaum.
ersterfreier,nr)ELSE ersterfreier(verwaltung.ersterfreier,nr-maxkn)FI END 
PROC ersterfreier;PROC ersterfreier(INT VAR ef,INT CONST nr):IF nr<efTHEN ef
:=nrFI END PROC ersterfreier;PROC reorganisieren:meldestartderreorganisation;
reorganisieresystem;reorganisiereverwaltung.meldestartderreorganisation:out(
"��");put("Der Systembaum wird reorganisiert").END PROC reorganisieren;PROC 
reorganisieresystem:vorbereitung;ausfuehrung;abschluss.ausfuehrung:
sammlealleunbenutztenrefinements;reorganisierediese.
sammlealleunbenutztenrefinements:LONGROW VAR refinements;refinements:=
verwaltung.tabzeile(CONCR (exporte)-maxkn).knoten;LONGROW VAR unbenutzte:=
newrow,startknoten:=newrow;INT VAR i;EINTRAG VAR e;FOR iFROM 1UPTO length(
refinements)REP INT VAR knnummer:=refinements_i;INT VAR relnummer:=knnummer-
maxkn;e:=verwaltung.tabzeile(relnummer);IF NOT ((e.vater)=markierungsknoten)
THEN unbenutzteCAT knnummer;startknotenCAT (e.knoten_1)FI PER .
reorganisierediese:reorganisiere(unbenutzte,startknoten).vorbereitung:
DATASPACE VAR ds:=nilspace;reorg:=ds;reorg.maxeintrag:=0;reorg.ersterfreier:=
1.abschluss:forget(systembaumname,quiet);copy(ds,systembaumname);forget(ds).
END PROC reorganisieresystem;PROC reorganisiereverwaltung:vorbereitung;
ausfuehrung;abschluss.ausfuehrung:line;put(
"Die Verwaltungsstruktur wird reorganisiert");INT VAR i;FOR iFROM 1UPTO reorg
.maxeintragREP IF gueltigTHEN uebertrageELSE markiereFI PER .gueltig:cout(i);
CONCR (verwaltung.tabzeile(i).vater)>=0.uebertrage:EINTRAG VAR e;e.attribute
:=verwaltung.tabzeile(i).attribute;e.knotenmengen:=verwaltung.tabzeile(i).
knotenmengen;e.vater:=verwaltung.tabzeile(i).vater;e.knoten:=decr(verwaltung.
tabzeile(i).knoten);reorg.tabzeile(i):=e.markiere:CONCR (reorg.tabzeile(i).
vater):=-1.vorbereitung:DATASPACE VAR ds:=nilspace;reorg:=ds;reorg.maxeintrag
:=verwaltung.maxeintrag;reorg.ersterfreier:=verwaltung.ersterfreier.abschluss
:forget(verwaltungsname,quiet);copy(ds,verwaltungsname);forget(ds);
startesystembaum.END PROC reorganisiereverwaltung;PROC reorganisiere(LONGROW 
CONST unbenutzte,startknoten):INT VAR i;FOR iFROM 1UPTO length(unbenutzte)
REP reorganisiere(knoten,name)PER .knoten:KNOTEN :(startknoten_i).name:TEXT 
VAR na;read(KNOTEN :(unbenutzte_i),na);na.END PROC reorganisiere;PROC 
reorganisiere(KNOTEN CONST k,TEXT CONST teilbaumname):line;put("Teilbaum "+
teilbaumname+"  wird reorganisiert");reorganisiere(k)END PROC reorganisiere;
PROC reorganisiere(KNOTEN CONST k):vorbereitung;erstenaufstack;REP 
stackbearbeitungUNTIL stackleerPER .stackbearbeitung:nimmoberstenvomstack;IF 
(NOT oberstermarkiert)CAND hatsoehneTHEN markiertzurueck;
allesoehneaufdenstackELSE oberstenuebertragenFI .vorbereitung:STACK VAR s:=
leererstack.erstenaufstack:TUPEL VAR tup;IF schonmalerreicht(k)THEN LEAVE 
reorganisiereELSE tup.kn:=k;tup.index:=naechsterindex;tup.markiert:=false;
alserreichtkennzeichnen(k);vater.kn:=systembaum.tabzeile(CONCR (k)).vater;
vater.index:=CONCR (vater.kn);hauptindexaendern(tup,vater);push(s,tup)FI .
stackleer:leer(s).nimmoberstenvomstack:TUPEL VAR vater;pop(s,vater).
oberstermarkiert:vater.markiert.markiertzurueck:vater.markiert:=true;push(s,
vater).hatsoehne:KNOTENMENGE VAR soehne;read(vater.kn,soehne);INT VAR 
sohnzahl:=zahlderelemente(soehne);sohnzahl>0.oberstenuebertragen:uebertrage(
vater).allesoehneaufdenstack:INT VAR i;LONGROW VAR sohnverzeichnis:=
systembaum.tabzeile(CONCR (soehne)).knoten;tup.markiert:=false;FOR iFROM 1
UPTO sohnzahlREP holesohn;IF NOT (schonmalerreicht(sohn))THEN 
itersohnaufstackELSE indexaendern(s,vater,sohn)FI PER .holesohn:KNOTEN VAR 
sohn;CONCR (sohn):=sohnverzeichnis_i.itersohnaufstack:tup.kn:=sohn;tup.index
:=naechsterindex;IF isrefinement(sohn)THEN alserreichtkennzeichnen(sohn)FI ;
hauptindexaendern(tup,vater);push(s,tup).END PROC reorganisiere;BOOL PROC 
schonmalerreicht(KNOTEN CONST k):is(k,erreichtkz)END PROC schonmalerreicht;
BOOL PROC isrefinement(KNOTEN CONST k):is(k,refkz)END PROC isrefinement;BOOL 
PROC is(KNOTEN CONST k,TEXT CONST muster):is(attribute(k),muster)END PROC is;
BOOL PROC is(TEXT CONST k,TEXT CONST muster):(subtext(k,1,1)=muster)END PROC 
is;PROC alserreichtkennzeichnen(KNOTEN CONST k):replace(systembaum.tabzeile(
CONCR (k)).attribute,1,erreichtkz)END PROC alserreichtkennzeichnen;TEXT PROC 
attribute(KNOTEN CONST k):systembaum.tabzeile(CONCR (k)).attributeEND PROC 
attribute;INT PROC naechsterindex:reorg.maxeintragINCR 1;reorg.ersterfreier
INCR 1;cout(reorg.maxeintrag);reorg.maxeintragEND PROC naechsterindex;PROC 
uebertrage(TUPEL CONST tup):EINTRAG VAR e;INT VAR knummer:=CONCR (tup.kn);e.
attribute:=systembaum.tabzeile(knummer).attribute;e.vater:=systembaum.
tabzeile(knummer).vater;e.knotenmengen:=decr(systembaum.tabzeile(knummer).
knotenmengen);e.knoten:=decr(systembaum.tabzeile(knummer).knoten);IF 
schonmalerreichtTHEN replace(e.attribute,1,refkz)FI ;reorg.tabzeile(tup.index
):=e;CONCR (systembaum.tabzeile(knummer).vater):=tup.index.schonmalerreicht:
is(e.attribute,erreichtkz).END PROC uebertrage;PROC hauptindexaendern(TUPEL 
CONST tup,TUPEL CONST vater):INT VAR knummer:=CONCR (tup.kn);LONGROW VAR 
knotenmengen:=systembaum.tabzeile(knummer).knotenmengen;INT VAR i;FOR iFROM 1
UPTO length(knotenmengen)REP IF verwaltungodervaterTHEN indexaendern(knummer,
tup.index,iteknotenmenge,vater.index)FI PER .verwaltungodervater:INT VAR 
iteknotenmenge:=knotenmengen_i;(iteknotenmenge>maxkn)COR (iteknotenmenge=
CONCR (vater.kn)).END PROC hauptindexaendern;PROC indexaendern(STACK CONST s,
TUPEL CONST vater,KNOTEN CONST sohn):INT VAR neuersohnindex:=CONCR (
systembaum.tabzeile(CONCR (sohn)).vater);IF nochaufstackTHEN 
sucheneuensohnindexFI ;indexaendern(CONCR (sohn),neuersohnindex,CONCR (vater.
kn),vater.index);reorg.tabzeile(neuersohnindex).knotenmengen:=decr(systembaum
.tabzeile(CONCR (sohn)).knotenmengen).nochaufstack:(neuersohnindex>maxkn).
sucheneuensohnindex:search(s,CONCR (sohn),neuersohnindex);.END PROC 
indexaendern;PROC indexaendern(INT CONST alterindex,nind,knalt,kneu):INT VAR 
neuerindex:=nind+reorgincr,knneu:=kneu+reorgincr;IF knalt<=maxknTHEN 
possystemELSE errechneposition;posverwaltung;FI .possystem:INT VAR ps:=pos(
systemknoten,alterindex);replace(systemknoten,ps,neuerindex);replace(
systemknotenmengen,knpos,knneu).systemknoten:systembaum.tabzeile(knalt).
knoten.systemknotenmengen:systembaum.tabzeile(alterindex).knotenmengen.knpos:
pos(systemknotenmengen,knalt).errechneposition:INT CONST position:=knalt-
maxkn.posverwaltung:INT VAR pv:=pos(verwaltungsknoten,alterindex);replace(
verwaltungsknoten,pv,neuerindex).verwaltungsknoten:verwaltung.tabzeile(
position).knoten.END PROC indexaendern;LONGROW PROC decr(LONGROW CONST l):
LONGROW VAR row:=newrow;INT VAR i;FOR iFROM 1UPTO length(l)REP rowCAT ((l_i)
MOD reorgincr)PER ;rowEND PROC decr;STACK PROC leererstack:STACK VAR s;s.top
:=bottom;sEND PROC leererstack;OP :=(TUPEL VAR ziel,TUPEL CONST quelle):
CONCR (ziel):=CONCR (quelle)END OP :=;OP :=(STACK VAR ziel,STACK CONST quelle
):CONCR (ziel):=CONCR (quelle)END OP :=;PROC push(STACK VAR s,TUPEL CONST k):
IF NOT (s.top=maxhoehe)THEN s.st(s.top):=k;s.topINCR 1ELSE errorstop(
"Stacküberlauf")FI END PROC push;PROC pop(STACK VAR s,TUPEL VAR k):IF NOT (s.
top=bottom)THEN s.topDECR 1;k:=s.st(s.top)ELSE errorstop("Stackunterlauf")FI 
END PROC pop;PROC search(STACK CONST s,INT CONST index,INT VAR neuersohnindex
):INT VAR i:=0;REP iINCR 1;IF i>s.topTHEN errorstop("Rekursionsauflösung: "+
text(index)+" nicht auf stack")FI UNTIL CONCR (s.st(i).kn)=indexPER ;
neuersohnindex:=s.st(i).indexEND PROC search;INT PROC hoehe(STACK CONST s):s.
top-1END PROC hoehe;BOOL PROC voll(STACK CONST s):s.top=maxhoeheEND PROC voll
;BOOL PROC leer(STACK CONST s):s.top=bottomEND PROC leer;END PACKET 
systembaum;