<![CDATA[//datei-name: baum1.C
#include "baum.h"
extern Baum* baum;
extern Output* outputWindow;
extern Fund* fundList;
extern BMes* bMes;
extern EditDialog* editDialog;
void Baum::Cntrl0()
{ mes = 1;
baumDat = new char[BDAT];
if (rTyp == 'w')
{ iStruct = 0;
strcpy(edbox, w[root].st);
if (rb())
{ lexan();
locLoesch(OUTLOC); } }
else mes = 2;
delete [] baumDat; }
void Baum::Alt0()
{ mes = 1;
baumDat = new char[BDAT];
transMulti(10, baumDat);
datLen = strlen(baumDat);
edbox[0] = 0;
lexan();
delete [] baumDat; locLoesch(OUTLOC); }
void Baum::CntrlA(int k, unsigned char t, char lc)
{ if (neu[0])
{ if (t == 'w') fallW(k);
else fallS(k, lc);
if (k != root)
{ tlz(k, root, t, rTyp); } } }
// ersetzt kNr durch neu erstellte root
void Baum::fallW(int kNr)
{ if (alt[0])
{ ttrafo(w[kNr].st);
root = wortI(tex); rTyp = 'w'; }
else
{ strcpy(tex, neu);
tScan(tex); } }
void Baum::fallS(int kNr, char lc)
{ if (alt[0])
{ loc = CPYLOC;
kNr = copyShadow(kNr);
ARek(kNr);
loc = lc;
KRoot(kNr); } //1
else
{ strcpy(tex, neu);
tScan(tex); } }
//1 shadowWurzel erhält lokalität OUTLOC
void Baum::ARek(int kNr)
{ if (s[kNr].t1 == 's') ARek(s[kNr].sl);
else
{ ttrafo(w[s[kNr].sl].st);
s[kNr].sl = wortI(tex); }
if (s[kNr].t2 == 's') ARek(s[kNr].sr);
else
{ ttrafo(w[s[kNr].sr].st);
s[kNr].sr = wortI(tex); } }
// teilstring in shadowbaum ersetzen
void Baum::ttrafo(char* txtAlt)
{ int a; char* txtNeu, * strAlt, * strNeu;
txtNeu = tex; strAlt = alt; strNeu = neu;
a = strlen(strAlt);
loop:
if (ttrafo1(txtAlt, strAlt)) *txtNeu++ = *txtAlt++; //1
else
{ while (*strNeu) *txtNeu++ = *strNeu++;
txtAlt += a; strNeu = neu; }
if (*txtAlt) goto loop; *txtNeu = 0; }
// text mit eventuellen ersetzungen nach tex kopieren
//1 wenn nicht suchtext, ein weiter
//2 durch neu ersetzen
char Baum::ttrafo1(char* txtAlt, char* strNeu)
{ char c;
loop:
c = *strNeu++;
if (c && c == *txtAlt)
{ txtAlt++; goto loop; }
return c; }
// text und suchtext // !c: suchtext vollständig gefunden
void Baum::CntrlAe()
{ typ = 's'; ast = root; o1baum(); }
void Baum::AltA()
{ int kNr;
if (rTyp == 's')
{ txt1 = alt; txt2 = neu;
if (! *txt2) return;
loc = CPYLOC;
kNr = copyShadow(root);
ARek(kNr); //1
root = CntrlW(kNr); } } //2
// kopieren und ersetzen
//1 teilstring in shadowbaum ersetzen
//2 shadowWurzel erhält lokalität OUTLOC
int Baum::CntrlB(int alt)
{ int neu;
if (s[alt].v == '"' && s[alt].t2 == 's') alt = s[alt].sr;
v = s[alt].v; //1
tmpS = new tmp_t[10000]; iM = 0;
BRek(alt, 's'); neu = BAusgleich();
delete [] tmpS;
if (neu != alt)
{ Root = s[alt].h; tlz(alt, neu, 's', 's'); s[neu].h = Root; }
return neu; }
// setzt satz voraus
//1 baumausgleich nur für dieses verb.zeichen
void Baum::BRek(int alt, char t)
{ if (t == 's')
{ if (v == s[alt].v)
{ BRek(s[alt].sl, s[alt].t1); BRek(s[alt].sr, s[alt].t2); return; } }
tmpS[iM].c = t; tmpS[iM].i = alt; ++iM; } //1
//1 endelement für baumausgleich
int Baum::BAusgleich()
{ int i, j;
while (iM > 1)
{ i = 2; j = 0;
while (i <= iM)
{ tmpS[j].i = sBau(tmpS[i - 2].i, tmpS[i - 1].i, tmpS[i - 2].c, tmpS[i - 1].c, v); tmpS[j].c = 's';
i += 2; ++j; }
if (i == iM + 1)
{ tmpS[j].i = tmpS[i - 2].i; tmpS[j].c = tmpS[i - 2].c; ++j; }
iM = j; }
return tmpS[0].i; }
void Baum::AltB(int alt, char v)
{ Ast = alt; v0 = v;
tmpS = new tmp_t[1000]; iM = 0;
AltBRek();
if (iM > 1) AltBAusgleich(0);
Ast = tmpS[0].i;
if (alt != Ast) tlz(alt, Ast, 's', 's');
mes = 1;
delete [] tmpS; }
// setzt satz voraus.
void Baum::AltBRek()
{ int sl, sr, n; unsigned char t1, t2, v;
sl = s[Ast].sl; sr = s[Ast].sr;
t1 = s[Ast].t1; t2 = s[Ast].t2; v = s[Ast].v;
if (v == v0)
{ if (t1 == 's')
{ Ast = sl; AltBRek(); }
else
{ tmpS[iM].c = t1; tmpS[iM].i = sl; ++iM; }
if (t2 == 's')
{ Ast = sr; AltBRek(); }
else
{ tmpS[iM].c = t2; tmpS[iM].i = sr; ++iM; } }
else
{ n = iM;
if (t1 == 's')
{ Ast = sl; AltBRek();
if (iM - 1 > 1) AltBAusgleich(n); }
else
{ tmpS[iM].c = t1; tmpS[iM].i = sl; ++iM; }
++n;
if (t2 == 's')
{ Ast = sr; AltBRek();
if (iM - 1 > 1) AltBAusgleich(n); }
else
{ tmpS[iM].c = t2; tmpS[iM].i = sr; ++iM; }
iM -= 2;
tmpS[iM].i = sBau(tmpS[iM].i, tmpS[iM + 1].i, tmpS[iM].c, tmpS[iM + 1].c, v);
tmpS[iM].c = 's';
++iM; } }
// setzt satz Ast, v0, tmpS u. iM voraus
void Baum::AltBAusgleich(int iL)
{ int iJ, iK; iJ = iK = iL; iK += 2;
while (iM > (iL + 1))
{ while (iK <= iM)
{ tmpS[iJ].i = sBau(tmpS[iK - 2].i, tmpS[iK - 1].i, tmpS[iK - 2].c, tmpS[iK - 1].c, v0); tmpS[iJ].c = 's';
iK += 2; ++iJ; }
if (iK == iM + 1)
{ tmpS[iJ].i = tmpS[iK - 2].i; tmpS[iJ].c = tmpS[iK - 2].c; ++iJ; }
iM = iJ; iJ = iK = iL; iK += 2; } }
void Baum::CntrlD()
{ time(&zeit); strcpy(edbox,ctime(&zeit));
tex[0] = edbox[22]; tex[1] = edbox[23];
if (strstr(edbox, "Jan")) { tex[2] = '0'; tex[3] = '1'; }
else if (strstr(edbox, "Feb")) { tex[2] = '0'; tex[3] = '2'; }
else if (strstr(edbox, "Mar")) { tex[2] = '0'; tex[3] = '3'; }
else if (strstr(edbox, "Apr")) { tex[2] = '0'; tex[3] = '4'; }
else if (strstr(edbox, "May")) { tex[2] = '0'; tex[3] = '5'; }
else if (strstr(edbox, "Jun")) { tex[2] = '0'; tex[3] = '6'; }
else if (strstr(edbox, "Jul")) { tex[2] = '0'; tex[3] = '7'; }
else if (strstr(edbox, "Aug")) { tex[2] = '0'; tex[3] = '8'; }
else if (strstr(edbox, "Sep")) { tex[2] = '0'; tex[3] = '9'; }
else if (strstr(edbox, "Oct")) { tex[2] = '1'; tex[3] = '0'; }
else if (strstr(edbox, "Nov")) { tex[2] = '1'; tex[3] = '1'; }
else if (strstr(edbox, "Dec")) { tex[2] = '1'; tex[3] = '2'; }
tex[4] = edbox[8]; tex[5] = edbox[9];
if (tex[4] == ' ') tex[4] = '0';
if (strstr(edbox, "Mon")) tex[6] = '1';
else if (strstr(edbox, "Tue")) tex[6] = '2';
else if (strstr(edbox, "Wed")) tex[6] = '3';
else if (strstr(edbox, "Thu")) tex[6] = '4';
else if (strstr(edbox, "Fri")) tex[6] = '5';
else if (strstr(edbox, "Sat")) tex[6] = '6';
else if (strstr(edbox, "Sun")) tex[6] = '7';
tex[7] = 0; tScan(tex); }
void Baum::AltD()
{ int Root;
if (rTyp == 'w' && ! w[root].b)
{ txt1 = w[root].st;
if (isDay(txt1))
{ worti = wortI("journal");
if (vLSatz(worti)) //1
{ ast = s[rSatz].sr;
Root = root; AltD1();
if (mes == 2)
{ rTyp = 's'; root = ast; return; }
rTyp = 'w'; root = Root; F7(); return; } } }
mes = 2; }
// ordnet datum in baum ein
//1 vLSatz setzt rSatz als journal-baum
void Baum::AltD1()
// langsame baum_iteration von rechts nach links mit abbruch, setzt txt1, ast u. root voraus
{ *stck0++ = 0;
loop:
if (s[ast].v == '"') //1
{ holz = s[ast].sl; txt2 = w[holz].st;
if (isDay(txt2))
{ if (strlen(txt1) != strlen(txt2))
{ mes = 2; return; }
if (strcmp(txt1, txt2) > 0)
{ Ast = *--stck0;
if (ast == s[Ast].sr) anbauRr(Ast, root, 'w', '.');
else anbauLr(Ast, root, 'w', '.');
DAusgleich (); return; }
loop1:
Ast = *--stck0;
if (s[Ast].t1 == 's')
{ if (ast == s[Ast].sl)
{ ast = Ast; goto loop1; }
*stck0++ = Ast; ast = s[Ast].sl; goto loop; }
else
{ ast = Ast; mes = 2; } }
else
{ if (s[ast].t2 != 's')
{ mes = 2; return; }
*stck0++ = 0;
ast = s[ast].sr; goto loop; } }
else
{ if (s[ast].t2 != 's')
{ mes = 2; return; }
*stck0++ = ast; ast = s[ast].sr; goto loop; } } //2
//1 look_for_todo
//2 stack_up_right
void Baum::DAusgleich()
{ int p, l, r, lSum, rSum;
loop:
p = *--stck0;
if (p)
{ l = s[p].sl; r = s[p].sr;
sum = 0; getLSum(l); lSum = sum;
sum = 0; getLSum(r); rSum = sum;
if (lSum <= rSum) goto loop;
CntrlB(p); }
else
{ ++stck0; p = *stck0;
if (p) CntrlB(p); } }
void Baum::getLSum(int l)
{ if (s[l].v == '.')
{ getLSum(s[l].sl); getLSum(s[l].sr); }
++sum; }
void Baum::CntrlE()
{ if (rTyp == 's')
{ CntrlE1(root);
strcpy(tex, editDialog->comboEBox->text(0));
nr = 0; //1
editDialog->line->setText(tex); }
else mes = 2; }
// baum editieren, legt alle Worte auf comboEBox
//1 erstes wort in editierzeile
void Baum::CntrlE1(int kNr)
{ if (s[kNr].t1 == 's') CntrlE1(s[kNr].sl);
else editDialog->comboEBox->insertItem((QString) w[s[kNr].sl].st, -1);
if (s[kNr].t2 == 's') CntrlE1(s[kNr].sr);
else editDialog->comboEBox->insertItem((QString) w[s[kNr].sr].st, -1); }
// kopiert worte in comboEBox
void Baum::ERek1(int kNr)
{ if (s[kNr].t1 == 's') ERek1(s[kNr].sl);
else
{ strcpy(tex, editDialog->comboEBox->text(nr));
s[kNr].sl = wortI(tex);
++nr; } //1
if (s[kNr].t2 == 's') ERek1(s[kNr].sr);
else
{ strcpy(tex, editDialog->comboEBox->text(nr));
s[kNr].sr = wortI(tex);
++nr; } } //1
// worte aus comboEbox in shadowBaum einsetzen
//1 eingabezeile in shadow einbauen
void Baum::CntrlE2()
{ stck3 = stack + 3 * STCK1; cstck4 = cstack + CSTACK - CSTCK; stck4 = stack + STACK - STCK;
typ = 's'; ast = Root; CntrlE2a(); root = *--stck3; rTyp = 's'; }
// langsame rekursion, setzt root voraus, kopiert struktur mit stack als inhalt
void Baum::CntrlE2a()
{ if (typ == 'w')
{ txt1 = w[ast].st;
if (*txt1 == '¹') *stck3++ = *stck4++; // look for todo
else *stck3++ = ast;
*cstck3++ = 'w'; return; }
*stck0++ = ast; typ = s[ast].t1; ast = s[ast].sl; CntrlE2a(); // links hoch
ast = *--stck0;
if (s[ast].v == '¹')
{ *cstck2++ = *cstck4++; stck4++; }
else *cstck2++ = s[ast].v;
*stck0++ = ast; typ = s[ast].t2; ast = s[ast].sr; CntrlE2a(); // rechts hoch
ast = *--stck0;
s0.t2 = *--cstck3; s0.t1 = *--cstck3;
s0.sr = *--stck3; s0.sl = *--stck3;
s0.v = *--cstck2; *cstck3++ = 's'; *stck3++ = makesatz(); }
void Baum::AltE()
{ if (rTyp == 's')
{ iM = 0; AltE1(root); }
else mes = 2; }
void Baum::AltE1(int kNr)
{ if (s[kNr].t1 == 's') AltE1(s[kNr].sl);
else
{ txt1 = w[s[kNr].sl].st;
if (*txt1 == '¹')
{ mintM[iM] = s[kNr].sl; ++iM; } }
if (s[kNr].t2 == 's') AltE1(s[kNr].sr);
else
{ txt1 = w[s[kNr].sr].st;
if (*txt1 == '¹')
{ mintM[iM] = s[kNr].sr; ++iM; } } }
// eingabemaske für baumerzeugung verwenden
void Baum::ERek(int kNr)
{ if (s[kNr].t1 == 's') ERek(s[kNr].sl);
else
{ txt1 = w[s[kNr].sl].st;
if (*txt1 == '¹')
{ s[kNr].sl = mintS[nr]; ++nr; } } //1
if (s[kNr].t2 == 's') ERek(s[kNr].sr);
else
{ txt1 = w[s[kNr].sr].st;
if (*txt1 == '¹')
{ s[kNr].sr = mintS[nr]; ++nr; } } }
//1 eingabezeile in shadow einbauen
void Baum::CntrlF(int kNr)
{ fundList->iFF = 0;
FRek(kNr);
if (fundList->iFF)
{ fundList->setCaption("fundListe lokal");
fundList->repaint(); }
else AltF(); }
void Baum::FRek(int kNr)
{ int sl, sr; unsigned char t1, t2;
sl = s[kNr].sl; sr = s[kNr].sr;
t1 = s[kNr].t1; t2 = s[kNr].t2;
if (t1 == 's') FRek(sl);
else
{ if (t1 == 'w')
{ if (strstr(w[sl].st, kette)) Cntrl1F(sl); } }
if (t2 == 's') FRek(sr);
else
{ if (t2 == 'w')
{ if (strstr(w[sr].st, kette)) Cntrl1F(sr); } } }
void Baum::Cntrl1F(int in)
{ int i; char da; da = 0;
for (i = 0; i < fundList->iFF; ++i)
{ if (tmpF[i].i == in)
{ da = 1; break; } }
if (! da)
{ if (fundList->iFF < 1000)
{ tmpF[fundList->iFF].i = in; ++fundList->iFF; } } }
void Baum::AltF()
{ worti = 255;
while (worti < wort0)
{ worti++;
if (w[worti].b)
{ kett1 = w[worti].st;
if (strstr(kett1, kette)) Cntrl1F(worti); } }
fundList->setCaption("fundListe global");
fundList->repaint(); }
void Baum::CntrlG()
{ int sl, sr, rrSatz, rzSatz; unsigned char t1, t2; rzi = 0;
if (! root || rTyp != 's') return;
sl = s[root].sl; sr = s[root].sr; t1 = s[root].t1; t2 = s[root].t2;
if (t1 == 'w' && sl == gW) rzi = w[sl].b;
else if (t2 == 'w' && sr == gW) rzi = w[sr].b;
if (! rzi) return;
rSatz = r[rzi].zS;
loop:
rzi = r[rzi].zz;
if (! rzi) return;
rzSatz = r[rzi].zS;
if (rSatz == root)
{ rrSatz = s[rSatz].h;
if (rrSatz)
{ if (rSatz == s[rrSatz].sl) umbau(rrSatz, 'l', rzSatz, 's');
else umbau(rrSatz, 'r', rzSatz, 's');
s[rSatz].h = 0; s[rzSatz].h = rrSatz; }
root = rzSatz; }
else
{ rSatz = rzSatz; goto loop; } }
//1 gW wird von vSatzN gesetzt
void Baum::AltG(int kNr)
{ int sl, sr; unsigned char t1, t2;
sl = s[kNr].sl; sr = s[kNr].sr; t1 = s[kNr].t1; t2 = s[kNr].t2;
if (s[kNr].v == '"')
{ if (sl == worti)
{ if (! ast)
{ ast = sr; typ = t2; }
else
{ ast = sBau(ast, sr, typ, t2, '.'); typ = 's'; } }
else if (t2 == 's') AltG(sr);
return; }
else if (t1 == 's') AltG(sl);
if (t2 == 's') AltG(sr); }
void Baum::CntrlH()
{ int* rzp; int rzi, rzr, rzv, rSatz, rzSatz;
if (rTyp == 's')
{ if (root == knot)
{ if (typJ == 's') rzp = & s[rootJ].b;
else rzp = & w[rootJ].b;
rzi = *rzp; rSatz = r[rzi].zS;
if (root == rSatz)
{ rzr = r[rzi].zz;
while (rzr)
{ rzv = rzr; rzr = r[rzr].zz; }
root = r[rzv].zS; s[rSatz].s = rzv; }
else
{ root = s[root].s;
loop:
rzSatz = r[rzi].zS;
if (rzSatz != root)
{ rzi = r[rzi].zz; goto loop; }
s[rSatz].s = rzi; } }
else CntrlJ(); }
else CntrlJ();
knot = root; }
void Baum::CntrlI(int alt)
{ int neu, i;
if (s[alt].v == '"' && s[alt].t2 == 's') alt = s[alt].sr;
v = s[alt].v; //1
sortS = new sort_t[50000];
memset(sortS, 0, sizeof(sort_t) * 50000);
iM = 0; sortVorList(alt, 's');
i = 1;
while (i < iM)
{ txt1 = w[sortS[i].w].st; nr = i;
if (sortZ) sortZBaum(0);
else sortBaum(0);
++i; }
tmpS = new tmp_t[50000];
nr = 0; sortList(0); delete [] sortS;
neu = BAusgleich(); delete [] tmpS;
if (neu != alt) tlz(alt, neu, 's', 's'); }
// setzt satz voraus
//1 baumsort nur für dieses verb.zeichen
void Baum::sortVorList(int k, unsigned char t)
{ if (t == 's')
{ if (v == s[k].v)
{ sortVorList(s[k].sl, s[k].t1); sortVorList(s[k].sr, s[k].t2); }
else
{ sortS[iM].s = k;
while (s[k].t1 == 's') k = s[k].sl;
sortS[iM].w = s[k].sl; ++iM; } }
else
{ sortS[iM].w = k; ++iM; } }
void Baum::sortBaum(int i)
{ txt2 = w[sortS[i].w].st;
if (strcmp(txt1, txt2) < 0)
{ if (sortS[i].vor) sortBaum(sortS[i].vor);
else sortS[i].vor = nr; }
else
{ if (sortS[i].nach) sortBaum(sortS[i].nach);
else sortS[i].nach = nr; } }
// setzt nr und txt1 voraus
void Baum::sortZBaum(int i)
{ txt2 = w[sortS[i].w].st;
if (strlen(txt1) == strlen(txt2))
{ if (strcmp(txt1, txt2) < 0)
{ if (sortS[i].vor) sortZBaum(sortS[i].vor);
else sortS[i].vor = nr; }
else
{ if (sortS[i].nach) sortZBaum(sortS[i].nach);
else sortS[i].nach = nr; } }
else if (strlen(txt1) < strlen(txt2))
{ if (sortS[i].vor) sortZBaum(sortS[i].vor);
else sortS[i].vor = nr; }
else
{ if (sortS[i].nach) sortZBaum(sortS[i].nach);
else sortS[i].nach = nr; } }
void Baum::sortList(int k)
{ if (sortS[k].vor) sortList(sortS[k].vor);
if (sortS[k].s)
{ tmpS[nr].i = sortS[k].s; tmpS[nr].c = 's'; }
else
{ tmpS[nr].i = sortS[k].w; tmpS[nr].c = 'w'; }
++nr;
if (sortS[k].nach) sortList(sortS[k].nach); }
// arbeitet sortS_baum rekursiv ab u. überträgt alle knoten in tmpS_liste
void Baum::CntrlJ()
{ int* rzp; int rzi, rzr, rzv, rSatz, rzSatz;
if (rTyp == 's' && root == knot)
{ if (typJ == 's') rzp = & s[rootJ].b;
else rzp = & w[rootJ].b;
rzi = *rzp; rSatz = r[rzi].zS;
rzr = r[rzi].zz; rzSatz = r[rzr].zS;
rzv = s[rSatz].s; rzv = r[rzv].zz;
if (rzv)
{ root = r[rzv].zS; s[rSatz].s = rzv; }
else
{ root = rSatz; s[rSatz].s = rzi; } }
else
{ rootJ = root; typJ = rTyp;
if (rTyp == 's') rzp = & s[root].b;
else rzp = & w[root].b;
vSatzR(rzp);
root = r[*rzp].zS; rTyp = 's'; }
knot = root; }
// setzt root und rTyp voraus
// setzt beim 1. mal rootJ, typJ und knot und diese in der folge als gegeben voraus
/*
{ int* rzp; int rzi, rzr, rzv, rSatz, rzSatz;
if (rTyp == 's')
{ if (root == knot)
{ if (typJ == 's') rzp = & s[rootJ].b;
else rzp = & w[rootJ].b;
rzi = *rzp; rSatz = r[rzi].zS;
rzr = r[rzi].zz; rzSatz = r[rzr].zS;
rzv = s[rSatz].s; rzv = r[rzv].zz;
if (rzv)
{ root = r[rzv].zS; s[rSatz].s = rzv; }
else
{ root = rSatz; s[rSatz].s = rzi; } }
else
{ rzp = & s[root].b;
rootJ = root; typJ = rTyp;
vSatzR(rzp); root = r[*rzp].zS; } }
else
{ rzp = & w[root].b;
rootJ = root; typJ = rTyp;
vSatzR(rzp);
root = r[*rzp].zS; rTyp = 's'; }
knot = root; }
*/
void Baum::vSatzR(int* rzp)
{ int i, rzi, rzr, pre, per, prep, rSatz, rzSatz;
i = rzi = *rzp;
if (r[rzi].zz)
{ while (rzi)
{ querz = 0; rSatz = r[rzi].zS; rzr = s[rSatz].b;
while (rzr)
{ ++querz; rzr = r[rzr].zz; }
s[rSatz].s = querz;
rzi = r[rzi].zz; }
rzi = pre = prep = i;
rzr = r[rzi].zz;
while (rzr)
{ per = rzi; rzSatz = r[rzr].zS; sum = s[rzSatz].s;
while (per != rzr)
{ rSatz = r[per].zS; querz = s[rSatz].s;
if (querz < sum)
{ r[pre].zz = r[rzr].zz; r[rzr].zz = per;
if (per == rzi) *rzp = rzi = rzr;
else r[prep].zz = rzr;
break; }
else if (prep != per) prep = per; per = r[per].zz; }
pre = per; rzr = r[pre].zz; }
rSatz = r[rzi].zS; rzr = r[rzi].zz; rzSatz = r[rzr].zS; s[rSatz].s = rzi;
loop:
s[rzSatz].s = rSatz;
rzi = rzr; rSatz = r[rzi].zS;
rzr = r[rzr].zz;
if (rzr)
{ rzSatz = r[rzr].zS; goto loop; } } }
void Baum::CntrlOe()
{ knot = 0; mes = 11; }
// (CntrlJ a CntrlH h knot) zurückgesetzt!
void Baum::CntrlK(int k)
{ if (loc == STDLOC)
{ loc = EDLOC;
histWrzl = s[k].h;
if (!histWrzl)
{ rzi = s[k].b; wrzl = r[rzi].zS;
if (k == s[wrzl].sl) kFall = 1;
else kFall = 2; }
else
{ if (s[histWrzl].v == '"' && lflag) histWrzl = s[histWrzl].sr;
if (k == s[histWrzl].sl) kFall = 3;
else if (k == s[histWrzl].sr) kFall = 4; } }
else loc = STDLOC;
KRoot(k);
if (loc == EDLOC) return;
switch(kFall)
{ case 1:
umbau(wrzl, 'l', root, 's'); break;
case 2:
umbau(wrzl, 'r', root, 's'); break;
case 3:
umbau(histWrzl, 'l', root, 's'); break;
case 4:
umbau(histWrzl, 'r', root, 's'); } }
// setzt satz voraus und toggelt loc
void Baum::KRoot(int k)
{ if (! s[k].b) s[k].lc = OUTLOC;
root = KRek(k); }
// setzt neue root und bereitet gegebenenfalls alte zum löschen vor
int Baum::KRek(int k)
{ int sl, sr; char t1, t2;
sl = s[k].sl; sr = s[k].sr;
t1 = s[k].t1; t2 = s[k].t2;
if (t1 == 's') sl = KRek(sl);
if (t2 == 's') sr = KRek(sr);
return sBau(sl, sr, t1, t2, s[k].v); }
// kopiert bäume (in neue lokalität)
int Baum::CntrlL(int wrzl, char *txt)
{ char zweig;
zweig = zzweig(wrzl);
if (! zweig)
{ if (s[wrzl].v == '"') wrzl = rootAbbau(wrzl, 'l');
if (! *txt) return wrzl;
wrzl = sBau(wortI(txt), wrzl, 'w', 's', '"'); }
else
{ if (lflag && s[wrzl].v == '"')
{ lflag = 0; wrzl = rootAbbau(wrzl, 'l'); lflag = 1; }
else wrzl = rSatz;
if (! *txt) return wrzl;
if (zweig == '\\')
{ anbauLl(wrzl, wortI(txt), 'w', '"'); wrzl = s[wrzl].sl; }
else
{ anbauRl(wrzl, wortI(txt), 'w', '"'); wrzl = s[wrzl].sr; } }
lflag = 1; return wrzl; }
// setzt label (neu)
char Baum::zzweig(int wrzl)
{ int rzi; char zweig; zweig = 0;
rzi = s[wrzl].b; //1
if (rzi)
{ rSatz = r[rzi].zS; //2
if (wrzl == s[rSatz].sl) zweig = '\\';
else zweig = '/'; }
return zweig; }
// wrzl bezüglich rSatz in zweig als links oder rechts merken.
//1 liste der rückzeiger
//2 wenn rzi, dann rückzeigersatz
void Baum::CntrlM()
{ int k;
if (rTyp == 's')
{ k = root;
tScan(edbox);
muster(k, 's');
musterung();
F6(re, 's'); } }
void Baum::AltM()
{ int k;
if (rTyp == 's')
{ k = root;
tScan(edbox);
muster(k, 's');
musterung();
bildneu();
if (Muster())
{ stckrset(); re1 = re; //1
if (rTyp == 's')
{ k = root;
tScan(edbox);
muster(k, 's');
transform(root);
F6(re1, 's'); } }
F6(re, 's'); } }
//1 re bleibt erhalten
void Baum::CntrlN()
{ unsigned char v1; int k;
if (rTyp == 's')
{ v = s[root].v;
if (v == '"')
{ root = s[root].sr; v = s[root].v; }
if (s[root].t2 == 's')
{ k = s[root].sr; v1 = s[k].v;
s0.sl = s[root].sl; s0.t1 = s[root].t1;
s0.sr = s[k].sl; s0.t2 = s[k].t1;
s0.v = v;
s0.sl = makesatz(); s0.t1 = 's'; s0.v = v1;
s0.sr = s[k].sr; s0.t2 = s[k].t2;
k = makesatz(); tlz(root, k, 's', 's');
F7(); } } }
void Baum::AltN()
{ unsigned char v1; int k;
if (rTyp == 's')
{ v = s[root].v;
if (v == '"')
{ root = s[root].sr; v = s[root].v; }
if (s[root].t1 == 's')
{ k = s[root].sl; v1 = s[k].v;
s0.sr = s[root].sr; s0.t2 = s[root].t2;
s0.sl = s[k].sr; s0.t1 = s[k].t2;
s0.v = v;
s0.sr = makesatz(); s0.t2 = 's'; s0.v = v1;
s0.sl = s[k].sl; s0.t1 = s[k].t1;
k = makesatz(); tlz(root, k, 's', 's');
F7(); } } }
void Baum::CntrlO()
{ int header, ascisp, wortsp, satzsp, i;
delete [] ascii; delete [] w; delete [] s; delete [] r; //1
ascii = new char[ENDC+1]; w = new wort[ENDW+1]; //1
s = new satz[ENDS+1]; r = new kett[ENDRL+1]; //1
header = 16;
memcpy(mint, baumDat, header);
ascisp = mint[1] - header;
wortsp = mint[2] - mint[1];
satzsp = mint[3] - mint[2];
memcpy(ascii, baumDat + header, ascisp);
memcpy(w, baumDat + mint[1], wortsp);
memcpy(s, baumDat + mint[2], satzsp);
memcpy(r, baumDat + mint[3], satzsp);
asci0 = ascii + ascisp;
while (! *asci0) asci0--;
asci0++; asci0++;
wort0 = wortsp / sizeof(wort) - 1;
for (i = 0; i <= wort0; i++) w[i].st += int(ascii); // relocieren der einzelnen textzeiger
sMax = satzsp / sizeof(satz);
rMax = 2 * sMax;
satz0 = 1; while (s[satz0].v) satz0++;
rzl0 = 1; while (r[rzl0].zS) rzl0++;
keyList();
rTyp = 's'; root = sMax;
stck1 = stack + STCK1;
for(i = 1; i < 256; i++)
{ worti = w[i].wl; // suchbaum_anker
if (worti)
{ wBSort(worti);
*stck1 = 0; stck1 = stack + STCK1;
wBAusgleich();
w[i].wl = *stck1; } }
bLinks(); }
// umkehr_funktion von CntrlS
//1 alte puffer durch neue ersetzen
void Baum::O0()
{ baumdat = baumDat + 3;
loc = *baumdat++; //1
stck0 = stack; ORek();
typ = 's'; rTyp = typ; root = s0.sl; }
// liest klammer_ausdrücke als baum_struktur ein
// lokalität einlesen
void Baum::ORek()
{ if (*++baumdat == 1)
{ ORek(); // rekursion
loop:
s0.v = *baumdat++;
if (*baumdat == 1)
{ *cstck0++ = s0.v;
*stck0++ = s0.sl;
*cstck0++ = s0.t1;
ORek(); // rekursion
s0.t2 = s0.t1;
s0.sr = s0.sl;
s0.t1 = *--cstck0;
s0.sl = *--stck0;
s0.v = *--cstck0;
s0.sl = makesatz();
s0.t1 = 's';
baumdat++;
return; }
if (*baumdat == 20)
{ ++baumdat; s0.t2 = *baumdat++; }
else s0.t2 = 'w';
if (s0.t2 == 'w' || s0.t2 == '?')
{ s0.sr = wortI(baumdat);
loop2: if (*baumdat++) goto loop2; }
else
{ s0.sr = *(int*)baumdat; baumdat += 4; }
s0.sl = makesatz();
s0.t1 = 's';
baumdat++;
return; }
if (*baumdat == 20)
{ ++baumdat; s0.t1 = *baumdat++; }
else s0.t1 = 'w';
if (s0.t1 == 'w' || s0.t1 == '?')
{ s0.sl = wortI(baumdat);
loop1: if (*baumdat++) goto loop1; }
else
{ s0.sl = *(int*)baumdat; baumdat += 4; }
goto loop; }
void Baum::CntrlP()
{ mes = 2; Ast = root; Typ = rTyp;
if (Typ == 's' && s[Ast].v == '"' && s[Ast].t2 == 's' && s[s[Ast].sr].v == 'f')
{ loc = EDLOC; PRek();
root = Ast; rTyp = Typ;
loc = STDLOC; mes = 1; } }
void Baum::PRek()
{ int sl, sr; unsigned char t1, t2, v;
sl = s[Ast].sl; sr = s[Ast].sr;
t1 = s[Ast].t1; t2 = s[Ast].t2; v = s[Ast].v;
if (v == '"')
{ if (t2 == 's')
{ if (s[sr].v == 'f')
{ Ast = s[sr].sr; PRek();
if (Ast)
{ if (Typ == 's') AltB(Ast, '.');
Ast = sBau(sl, Ast, 'w', Typ, '"'); Typ = 's'; }
else
{ Ast = sl; Typ = 'w'; }
return; }
Ast = sr; PRek(); return; }
Ast = 0; return; }
if (v == '}')
{ if (t2 == 's')
{ Ast = sr; PRek(); return; }
if (sr == '}') Ast = 0;
else
{ Ast = sr; Typ = 'w'; }
return; }
if(t1 == 's')
{ Ast = sl; PRek(); sl = Ast; t1 = Typ; }
else if (v == '.')
{ if (sl == '}' || sl == break_ || sl == continue_) sl = 0; }
else sl = 0;
if(t2 == 's')
{ Ast = sr; Typ = 's'; PRek(); sr = Ast; t2 = Typ; }
else if (v == '.')
{ if (sr == '}' || sr == break_ || sr == continue_) sr = 0; }
else sr = 0;
if (sl && sr)
{ Ast = sBau(sl, sr, t1, t2, '.'); Typ = 's'; }
else if (sl)
{ Ast = sl; Typ = t1; }
else if (sr)
{ Ast = sr; Typ = t2; }
else Ast = 0; }
void Baum::AltP()
{ int k, kNr;
if (clip[0] && clipTyp[0] == 's' && rTyp == 's')
{ k = clip[0]; //1
kNr = root;
iM = 0; AltE1(k); //2
if (!iM)
{ mes = 2; return; }
iG = 0;
rekFlag = 0;
AltP1(k, kNr); //3
if (rekFlag)
{ mes = 2; return; } }
else
{ mes = 2; return; } } //4
// übernehme werte aus baum in eingabemaske
//1 k = eingabemaske
//2 ¹worte der eingabemaske merken in mintM
//3 baumvergleich + datensatzübernahme in mintG
//4 baum nicht strukturgleich
void Baum::AltP1(int k, int kNr)
{ if (s[k].t1 != s[kNr].t1 || s[k].v != s[kNr].v) rekFlag = 1;
if (rekFlag) return;
if (s[k].t1 == 's') AltP1(s[k].sl, s[kNr].sl);
else
{ txt1 = w[s[k].sl].st;
if (*txt1 == '¹')
{ mintG[iG] = s[kNr].sl; ++iG; } }
if (s[k].t2 != s[kNr].t2 || s[k].t2 != s[kNr].t2) rekFlag = 1;
if (rekFlag) return;
if (s[kNr].t2 == 's') AltP1(s[k].sr, s[kNr].sr);
else
{ txt1 = w[s[k].sr].st;
if (*txt1 == '¹')
{ mintG[iG] = s[kNr].sr; ++iG; } } }
void Baum::AltP2(int k, int kNr)
{ if (s[k].t1 == 's') AltP2(s[k].sl, s[kNr].sl);
else
{ txt1 = w[s[k].sl].st;
if (*txt1 == '¹')
{ s[kNr].sl = mintS[iG]; ++iG; } }
if (s[kNr].t2 == 's') AltP2(s[k].sr, s[kNr].sr);
else
{ txt1 = w[s[k].sr].st;
if (*txt1 == '¹')
{ s[kNr].sr = mintS[iG]; ++iG; } } }
void Baum::CntrlR()
{ if (rTyp == 's')
{ if (s[root].v == '"' && s[s[root].sr].v == 'f') //1
{ if (s[s[root].sr].t2 == 'w') return;
err = 0;
makeShadow(root);
if (err)
{ root = err; cout << endl; return; }
Run(); }
else AltRun(); }
else AltRun();
if (err)
{ root = err; cout << endl; return; } }
//1 übersetzbare funktion
void Baum::Run()
{ runStack = new int[RUN];
tStack = new char[RUN];
rekStack = new int[REK];
varWert = new int[CALC];
varTyp = new char[CALC];
if (shadowRoot) delete outputWindow; //1
outputWindow = new Output(baum);
loc = STDLOC;
run(shadowRoot);
delete [] varWert; delete [] varTyp;
delete [] runStack; delete [] tStack; delete [] rekStack; }
//1 wird (außer beim start) immer ausgeführt
void Baum::makeShadow(int fctRoot)
{ err = 0; gBaum0(fctRoot);
if (err) root = err;
if (gStack != NULL) delete [] gStack;
gStack = new char[GSTACK];
mes = 1;
clrRunLoc(); loc = RUNLOC;
if (! err)
{ gBaum(fctRoot);
if (err) root = err; }
F7(); loc = STDLOC; }
void Baum::AltR()
{ if (rTyp == 's')
{ if (s[root].v == '"' && s[s[root].sr].v == 'f')
{ err = 0; makeShadow(root); //1
if (err) cout << endl; }
else mes = 2; }
else mes = 2; }
//1 übersetzbare funktion
void Baum::clrRunLoc()
{ holz = sMax;
while (holz)
{ if (! s[holz].b)
{ if(s[holz].lc == RUNLOC) runLocRek(holz, 's'); }
holz--; } }
void Baum::runLocRek(int i, char t)
{ if (t != 's') return;
if (! s[i].v) return;
*stck0++ = s[i].sr; *cstck0++ = s[i].t2;
*stck0++ = s[i].sl; *cstck0++ = s[i].t1;
s[i] = s[ENDS]; //1
i = *--stck0; t = *--cstck0; runLocRek(i, t);
i = *--stck0; t = *--cstck0; runLocRek(i, t); }
//1 leeren satzblock kopieren
void Baum::AltRun()
{ int k; bool ok; QString z;
ok = false;
z = QInputDialog::getText("Programmstart:", "Programmname:", QLineEdit::Normal, "",
&ok, this);
if (ok)
{ strcpy(neu, z);
if (*neu)
{ worti = wortI(neu);
k = vLSatz(worti);
if (k)
{ if (s[s[k].sr].v == 'f')
{ Run(); return; } } } }
mes = 2; }
void Baum::CntrlS()
{ int i, header, ascisp, wortsp, satzsp;
if (shadowRoot)
{ clrRunLoc(); shadowRoot = 0; }
header = 16;
ascisp = asci0 - ascii;
wortsp = (wort0 + 1) * sizeof(wort);
satzsp = (sMax + 1) * sizeof(satz);
for (i = 0; i <= wort0; i++) w[i].st -= int(ascii); //1
mint[0] = MAGIC;
mint[1] = header + ascisp - ascisp % 16 + 16; //2
mint[2] = mint[1] + wortsp;
mint[3] = mint[2] + satzsp;
datLen = mint[3] + satzsp;
memcpy(baumDat, mint, header);
memcpy(baumDat + header, ascii, ascisp);
memcpy(baumDat + mint[1], w, wortsp);
memcpy(baumDat + mint[2], s, satzsp);
memcpy(baumDat + mint[3], r, satzsp); }
// umkehr_funktion von CntrlO
//1 delocieren der einzelnen textzeiger
//2 bounding auf 16 (auch bei !(% 16))
void Baum::S0()
{ if (rTyp != 's') return;
txt0 = baumDat;
*txt0++ = 0; *txt0++ = 0; *txt0++ = 0; *txt0++ = loc; //1
SRek(root);
datLen = int(txt0 - baumDat); }
// baum als klammer_ausdruck speichern
//1 header mit lokalität
void Baum::SRek(int k)
{ *txt0++ = 1; //1
if (s[k].t1 == 's') SRek(s[k].sl);
else
{ if (s[k].t1 == 'w') copytext(s[k].sl);
else
{ *txt0++ = 20; *txt0++ = s[k].t1; //3
if (s[k].t1 == '?') copytext(s[k].sl);
else
{ txt1 = (char*)&s[k].sl;
*txt0++ = *txt1++; *txt0++ = *txt1++;
*txt0++ = *txt1++; *txt0++ = *txt1++; } } }
*txt0++ = s[k].v;
if (s[k].t2 == 's')
{ SRek(s[k].sr);
*txt0++ = 2; } //2
else
{ if (s[k].t2 == 'w') copytext(s[k].sr);
else
{ *txt0++ = 20; *txt0++ = s[k].t2; //3
if (s[k].t2 == '?') copytext(s[k].sr);
else
{ txt1 = (char*)(& s[k].sr);
*txt0++ = *txt1++; *txt0++ = *txt1++;
*txt0++ = *txt1++; *txt0++ = *txt1++; } }
*txt0++ = 2; } } //2
//1 klammer auf
//2 klammer zu
//3 20: achtung typ folgt
void Baum::copytext(int k)
{ int i = 0;
txt1 = w[k].st;
while (txt1[i])
*txt0++ = txt1[i++];
*txt0++ = 0; }
void Baum::CntrlT() // zeit holen
{ time(&zeit);
strcpy(edbox,ctime(&zeit));
tex[0] = edbox[11];
tex[1] = edbox[12];
tex[2] = edbox[13];
tex[3] = edbox[14];
tex[4] = edbox[15];
tex[5] = 0; tScan(tex); }
void Baum::CntrlU(int k)
{ int kTausch; unsigned char t;
if (labTest(k)) k = s[k].sr;
kTausch = s[k].sl; t = s[k].t1;
s[k].sl = s[k].sr; s[k].t1 = s[k].t2;
s[k].sr = kTausch; s[k].t2 = t; }
void Baum::AltU(int k)
{ mes = 2; }
void Baum::CntrlV(int k)
{ bool ok; QString z; ok = false;
z = QInputDialog::getText("steuerZeichen:", "neu:", QLineEdit::Normal, "abbruch", &ok, this);
if (ok)
{ strcpy (neu, z);
if (strcmp (neu, "abbruch") == 0) return;
if (labTest(k)) k = s[k].sr;
s[k].v = *neu; } }
void Baum::AltV(int kNr)
{ int k; bool ok; QString z; char lc;
k = kNr; ok = false;
z = QInputDialog::getText("steuerZeichen:", "alt neu:", QLineEdit::Normal, "abbruch", &ok, this);
if (ok)
{ strcpy (neu, z);
if (strcmp (neu, "abbruch") == 0) return;
lc = loc;
if (! s[kNr].b) s[kNr].lc = OUTLOC;
loc = CPYLOC;
kNr = copyShadow(kNr);
v0 = *neu; v = *(neu + 2); VRek(kNr); //1
loc = lc;
if (! s[kNr].b) s[kNr].lc = OUTLOC; //2
kNr = KRek(kNr);
if (kNr != k)
{ tlz(k, kNr, 's', 's'); } } }
// steuerzeichen pro ast ersetzen. setzt satz voraus
//1 alt: *neu neu: *(neu + 2)
//2 shadowWurzel erhält lokalität OUTLOC
void Baum::VRek(int k)
{ if (s[k].v == v0) s[k].v = v;
if (s[k].t1 == 's') VRek(s[k].sl);
if (s[k].t2 == 's') VRek(s[k].sr); }
int Baum::CntrlW(int k)
{ if (! loc) loc = EDLOC;
else loc = STDLOC;
if (! s[k].b) s[k].lc = OUTLOC;
return KRek(k); }
// loc_toggle. setzt root : satz voraus
void Baum::CntrlX()
{ if (! dbgFlag)
{ dbgFlag = 1;
if (rTyp == 's')
{ if (s[root].v == '"' && s[s[root].sr].v == 'f') //1
{ err = 0; makeShadow(root); cout << endl;
if (err) return;
CntrlX1(); }
else CntrlX2(); }
else CntrlX2(); }
else
{ if (dbgFlag == 1)
{ loc = RUNLOC; fWertDbg(); loc = STDLOC;
delete outputWindow; outputWindow = new Output(baum); } //1
if (! dbgFlag) deleteX(); } }
//1 wird (außer beim start) immer ausgeführt
void Baum:: CntrlX1()
{ runStack = new int[RUN];
tStack = new char[RUN];
rekStack = new int[REK];
varWert = new int[CALC];
varTyp = new char[CALC];
if (! err) runDbg(shadowRoot); }
void Baum::CntrlX2()
{ int k; bool ok; QString z;
ok = false;
z = QInputDialog::getText("Programmstart:", "Programmname:", QLineEdit::Normal, "",
&ok, this);
if (ok)
{ strcpy(neu, z);
if (*neu)
{ worti = wortI(neu);
k = vLSatz(worti);
if (k)
{ if (s[s[k].sr].v == 'f')
{ makeShadow(k); CntrlX1(); return; } } } }
mes = 2; }
void Baum::deleteX()
{ if (gStack != NULL)
{ delete [] gStack; gStack = 0; }
delete [] varWert; delete [] varTyp;
delete [] runStack; delete [] tStack; delete [] rekStack;
cout << "programmEnde" << endl;
clrRunLoc(); F7(); loc = STDLOC; bLinks(); }
void Baum::CntrlY()
{ stck3 = stck2;
worti = wortI("journal");
if (vLSatz(worti)) //1
{ baumi = root; typ = rTyp;
CntrlY1(s[rSatz].sr);
stck1 = stck2; YNeu();
rTyp = 's'; root = *stck1; }
else mes = 2; }
//1 vLSatz setzt rSatz als journal-baum
void Baum::CntrlY1(int i)
{ if (s[i].v == '"')
{ ast = s[i].sl; txt1 = w[ast].st;
if (isDay(txt1))
{ if (hatMember(s[i].sr, s[i].t2))
*stck2++ = i; return; } }
if (s[i].t2 == 's') CntrlY1(s[i].sr);
if (s[i].t1 == 's') CntrlY1(s[i].sl); }
// schnelle rekursion, setzt typ und baumi voraus
// sucht im d·baum nach baumi . legt ausgewählte knoten nach stck2
char Baum::isDay(char* date)
{ char c;
if (strlen(date) == 7)
{ c = *date++; if (c < '0' || c > '9') return 0;
c = *date++; if (c < '0' || c > '9') return 0;
c = *date++; if (c < '0' || c > '1') return 0;
c = *date++; if (c < '0' || c > '9') return 0;
c = *date++; if (c < '0' || c > '3') return 0;
c = *date++; if (c < '0' || c > '9') return 0;
c = *date++; if (c < '1' || c > '7') return 0;
return 1; }
if (strlen(date) == 8)
{ c = *date++; if (c < '0' || c > '2') return 0;
c = *date++; if (c < '0' || c > '9') return 0;
c = *date++; if (c < '0' || c > '9') return 0;
c = *date++; if (c < '0' || c > '9') return 0;
c = *date++; if (c < '0' || c > '1') return 0;
c = *date++; if (c < '0' || c > '9') return 0;
c = *date++; if (c < '0' || c > '3') return 0;
c = *date++; if (c < '0' || c > '9') return 0;
return 1; }
return 0; }
char Baum::hatMember(int k, char t)
{ if (t == typ && k == baumi) return 1;
if (t == 's')
{ if (hatMember(s[k].sl, s[k].t1)) return 1;
if (hatMember(s[k].sr, s[k].t2)) return 1; }
return 0; }
// setzt baumi und typ voraus. setzt flag
void Baum::YNeu()
{ loc = OUTLOC; lcmod = 0; s0.v = '.';
s0.t1 = 's'; s0.t2 = 's';
loop:
*stck1 = 0; stck1 = stck2 = stck3; //1
if (! *(stck2 + 1)) return;
loop1:
if (*stck2)
{ s0.sl = *stck2++;
if (*stck2)
{ s0.sr = *stck2++;
*stck1++ = makesatz();
goto loop1; }
else *stck1++ = s0.sl; }
goto loop; }
//1 stck1 abschließen und zurücksetzen
void Baum::CntrlZ()
{ int k, rzb;
baumi = sMax;
while (baumi)
{ if (! s[baumi].b && s[baumi].lc == OUTLOC) loeschRek(baumi, 's');
baumi--; }
baumi = root; typ = rTyp;
*stck0 = 0; stck1 = stck0; stck3 = stck2;
if (rTyp == 's') rzi = s[root].b;
else rzi = w[root].b;
if (! rzi) return;
rzb = rzi;
pick:
k = r[rzb].zS;
if (s[k].v == '"')
{ if (isDay(w[s[k].sl].st)) rTyp = 'd';
else if (s[s[k].sr].v == 'f') rTyp = 'f';
else
{ if ((rzb = s[k].b)) goto pick;
mes = 2; return; } }
else
{ if ((rzb = s[k].b)) goto pick;
mes = 2; return; }
loop:
*stck3++ = rzi;
k = r[rzi].zS;
if (s[k].v == '"')
{ if (rTyp == 'd')
{ if (isDay(w[s[k].sl].st))
{ k = ZRahmen(k); *stck1++ = k;
loop1:
rzi = *--stck3;
rzi = r[rzi].zz;
if (rzi) goto loop;
if (stck3 > stck2) goto loop1; }
else
{ rzi = s[k].b;
if (rzi) goto loop; } }
else if (s[k].t2 == 's' && s[s[k].sr].v == 'f')
{ k = ZRahmen(k); *stck1++ = k; goto loop1; }
else
{ rzi = s[k].b;
if (rzi) goto loop; } }
else
{ rzi = s[k].b;
if (rzi) goto loop; }
if (*stck0) ZBaum();
root = *stck0; rTyp = 's'; }
void Baum::AltZ()
{ int k, rzb;
typ = rTyp; baumi = root;
if (typ == 's') rzi = s[baumi].b;
else rzi = w[baumi].b;
if (! rzi) return;
rzb = rzi; k = baumi;
while (rzb)
{ k = r[rzb].zS; rzb = s[k].b; }
root = ZRahmen(k); rTyp = 's'; }
int Baum::ZRahmen(int k)
{ int sl, sr; char t1, t2;
sl = s[k].sl; sr = s[k].sr; t1 = s[k].t1; t2 = s[k].t2;
if (t1 == 's')
{ if (hatMember(sl, t1))
{ sl = ZRahmen(sl); t1 = 's'; }
else
{ sl = '.'; t1 = 'w'; } }
else
{ sl = '.'; t1 = 'w'; }
if (t2 == 's')
{ if (hatMember(sr, t2))
{ sr = ZRahmen(sr); t2 = 's'; }
else
{ sr = '.'; t2 = 'w'; } }
else
{ sr = '.'; t2 = 'w'; }
return sBau(sl, sr, t1, t2, s[k].v); }
// setzt baumi und typ voraus. gibt rahmenBaum zurück
void Baum::ZBaum()
{ loc = STDLOC; lcmod = 0; s0.v = '·';
s0.t1 = 's'; s0.t2 = 's';
loop:
*stck1 = 0; stck2 = stck1 = stck0;
if (! *(stck2 + 1)) return;
loop1:
if (*stck2)
{ s0.sl = *stck2++;
if (*stck2)
{ s0.sr = *stck2++;
*stck1++ = makesatz();
goto loop1; }
else *stck1++ = s0.sl; }
goto loop; }
// stck0 = anfang. stck1 = ende.
void Baum::lcLinks()
{ if (rTyp == 'w' || ! root)
{ if (s[sMax].v) sMax++;
rTyp = 's'; root = sMax; }
do root--;
while(root && ((! s[root].v || s[root].b) || (loc != s[root].lc)));
if (! root) flag0 = 1; }
void Baum::bLinks()
{ if (lcmod) { lcLinks(); return; } // ?
if (rTyp == 'w' || ! root)
{ if (s[sMax].v) sMax++;
rTyp = 's'; root = sMax; }
do root--;
while(root && (! s[root].v || s[root].b));
if (! root) flag0 = 1; }
void Baum::lcRechts()
{ if (rTyp == 'w' || root >= sMax)
{ if (s[sMax].v) sMax++;
rTyp = 's'; root = 0; }
do root++;
while(root < sMax && ((! s[root].v || s[root].b) || (loc != s[root].lc)));
if (! root) flag0 = 1; }
void Baum::bRechts()
{ if (lcmod) { lcRechts(); return; }
if (rTyp == 'w' || root >= sMax)
{ if (s[sMax].v) sMax++;
rTyp = 's'; root = 0; }
do root++;
while(root < sMax && (! s[root].v || s[root].b));
if (! root) flag0 = 1; }
void Baum::rzLinks(int i, unsigned char t)
{ int eins, vor, end;
if (t == 'w') rzp = &w[i].b;
else rzp = &s[i].b;
if (!(*rzp)) return;
eins = vor = *rzp; end = r[eins].zz;
if (! end) return;
rzi = end;
while ((rzi = r[rzi].zz))
{ vor = end; end = rzi; }
*rzp = end; r[vor].zz = 0; r[end].zz = eins;
loc = s[r[end].zS].lc;
if (t == 'w') histor = r[end].zS;
else s[i].h = r[end].zS; }
void Baum::rzRechts(int i, unsigned char t)
{ int eins, zwei, end;
if (t == 'w') rzp = &w[i].b;
else rzp = &s[i].b;
if (!(*rzp)) return;
eins = *rzp; zwei = r[eins].zz;
if (! zwei) return;
rzi = zwei;
do { end = rzi; rzi = r[rzi].zz; } while (rzi);
*rzp = zwei; r[eins].zz = 0; r[end].zz = eins;
loc = s[r[zwei].zS].lc;
if (t == 'w') histor = r[zwei].zS;
else s[i].h = r[zwei].zS; }
void Baum::fallvRek()
{ if (typ != 's') return;
if (s[holz].v == v) *stck1++ = holz;
*stck0++ = holz;
typ = s[holz].t1; holz = s[holz].sl;
fallvRek();
holz = *--stck0;
typ = s[holz].t2; holz = s[holz].sr;
fallvRek(); }
void Baum::fallV()
{ if (clipTyp[0] != 's') return;
holz = clip[0]; typ = 's';
if (s[holz].v == '"') holz = s[holz].sr;
fallvRek();
YNeu(); rTyp = 's'; root = *stck1; }
void Baum::lastEntry()
{ lastEntry1(); s0.v = '.';
root = BAusgleich(); }
void Baum::lastEntry1()
{ int i; char typ1 = clipTyp[0];
i = 0; baumi = clip[0];
*stck0++ = 0; typ = rTyp = 's'; ast = s[root].sr;
loop:
if (typ == 's') // if (satz)
{ if (s[ast].v == '.')
{ *stck0++ = ast; *cstck0++ = 'r';
typ = s[ast].t2; ast = s[ast].sr; goto loop; } // stack_up_right
if (s[ast].v == '"') // look_for_todo
{ holz = s[ast].sl; txt1 = w[holz].st; }
if (isDay(txt1))
{ if (isInAst(baumi, typ1))
{ tmpS[i].i = ast; tmpS[i].c = 's'; ++i;
stck2 = stack + 2 * STCK1; }
goto stack_down; }
ast = s[ast].sr; goto loop;
root = *--stck0; return; }
stack_down:
ast = *--stck0; lrflag = *--cstck0;
if (! ast) return;
if (lrflag == 'r')
{ *stck0++ = ast; *cstck0++ = 'l';
typ = s[ast].t1; ast = s[ast].sl; goto loop; }
goto stack_down; }
// langsame baum_iteration von rechts nach links mit abbruch
char Baum::isInAst(int i, char t)
{ *stck2++ = 0; typ = 's'; Ast = s[ast].sr;
loop:
if (typ == 'w')
{ if (t == 'w') if (Ast == i) return 1; }
else
{ if (typ == 's')
{ if (t == 's') if (Ast == i) return 1;
typ = s[Ast].t1; *stck2++ = Ast; Ast = s[Ast].sl; goto loop; } }
Ast = *--stck2;
if (Ast)
{ typ = s[Ast].t2; Ast = s[Ast].sr; goto loop; }
return 0; }
// schnelle iteration, setzt s[ast] voraus, prüft ob i in baum (ast)
void Baum::dbfBau()
{ int i, j, k, k1, k2, iRec, dataStart, iFeld, offset;
unsigned char t1, t2; char* txt1;
unsigned char uc, uc1; unsigned char feldBreite[100];
dP = (int*) (baumDat + 4); iRec = *dP;
uc = *(baumDat + 8); uc1 = *(baumDat + 9); dataStart = int(uc1)*256 + int(uc);
iFeld = 0; k = 0; offset = 32;
while (offset < dataStart - 32) //1
{ *(baumDat + offset + 10) = 0;
worti = wortI(baumDat + offset);
if (!k)
{ k = worti; rTyp = 'w'; }
else
{ k = sBau(k, worti, rTyp, 'w', ' '); rTyp = 's'; }
feldBreite[iFeld] = *(baumDat + offset + 16); iFeld++; offset += 32; }
offset = dataStart; i = 1; k2 = 0;
while (i <= iRec) //2
{ j = 0; ++offset; k1 = 0;
while (j < iFeld) //3
{ strncpy(tex, baumDat + offset, feldBreite[j] );
tex[feldBreite[j]] = 0;
dp = tex; txt1 = &tex[feldBreite[j]]; --txt1;
while (*dp == ' ') dp++;
while (txt1 > dp && *txt1 == ' ') *txt1 = 0;
if (*dp) worti = wortI(dp);
else worti = 183; //4
if (! k1)
{ t1 = 'w'; k1 = worti; }
else
{ k1 = sBau(k1, worti, t1, 'w', ' '); t1 = 's'; }
offset += feldBreite[j];
++j; }
if (! k2)
{ k2 = k1; t2 = t1; }
else
{ k2 = sBau(k2, k1, t1, t2, '.'); t2 = 's'; }
++i; }
if (k2) root = sBau(k, k2, rTyp, t2, ':');
else root = sBau(k, 183, rTyp, 'w', ':');
rTyp = 's'; }
//1 feldnamen zusammenbauen
//2 datensätze zusammenbauen
//3 feldinhalte extrahieren und blanks entfernen
//4 dicker punkt = datenfeld ist leer
void Baum::csvBau()
{ FILE* cvsHandle; char string[1000];
char ende; int kNr, k; char * txt1, * txt2;
kNr = 0;
cvsHandle = fopen(edbox, "rt");
if (cvsHandle)
{ do
{ fgets(string, 1000, cvsHandle);
if (*string == 26) break;
txt1 = txt2 = string; k = 0;
ende = -1;
while (ende != LF && ende != CR && ende)
{ if (*txt1 == '"')
{ ++txt1; txt2 = txt1;
while (*txt2 != '"') ++txt2;
*txt2 = 0; ++txt2; }
else
{ txt2 = txt1;
while (*txt2 != CR && *txt2 != LF && *txt2 != ',' && *txt2) ++txt2; }
ende = *txt2;
*txt2 = 0;
if (ende == CR && *(txt2 + 1) == LF) ++txt2;
++txt2;
worti = wortI(txt1);
if (! k)
{ k = worti; typ = 'w'; }
else
{ k = sBau(k, worti, typ, 'w', ' '); typ = 's'; }
txt1 = txt2; }
if (! kNr) kNr = k;
else kNr = sBau(kNr, k, 's', 's', '.'); }
while (! feof(cvsHandle)); }
else mes = 2;
fclose(cvsHandle);
root = kNr; rTyp = 's'; }]]>
back to
baumC