<![CDATA[//datei-name: baumbild.C
#include "baum.h"
extern Dump* dump;
extern char pfad[512];
void Baum::cmdline()
{ int c = strlen(edbox);
if (edbox[c - 2] == '.' && edbox[c - 1] == 'a')
{ edbox[c - 2] = 0; F8(); } //1
else ifRb();
rpFlag = 1; bildneu(); }
//1 baum split laden
void Baum::ifRb()
{ if (! edbox[0])
{ strcpy(edbox, "z.k");
if (rTyp == 'w')
{ kett1 = w[root].st; strcpy(edbox, kett1); } }
baumDat = new char[BDAT]; stckrset();
if (! rb()) mes = 2;
else
{ memcpy(mint, baumDat, 4);
if (mint[0] == MAGIC) CntrlO();
else O0();
mes = 10; }
edbox[0] = 0; mesFlag = 0;
delete [] baumDat; }
int Baum::rb()
{ strcpy(tex, pfad);
if (*edbox != '/')
{ strcat(tex, edbox); }
else strcpy(tex, edbox);
stream = fopen(tex, "rb");
if (! stream) return 0;
fseek(stream, 0, SEEK_END); datLen = ftell(stream); fseek(stream, 0, SEEK_SET);
fread (baumDat, 1, datLen, stream); fclose(stream); return 1; }
void Baum::bildneu()
{ if (! root)
{ if (flag0) flag0 = 0;
else return; }
if (edFlag == 2)
{ edFlag = 0;
ast = clip[7]; baumi = clap[7];
if (ast == s[baumi].sl) umbau(baumi, 'l', root, rTyp);
else umbau(baumi, 'r', root, rTyp);
root = clap[6]; rTyp = 's'; }
edbox[0] = 0;
stckrset();
bBild();
lr = 0;
graphldruck(); graphrdruck();
vbox[0] = v; vbox[1] = 0; //1
if (t1flag)
sprintf(box, "*%u", root); //2 satznr.
else
{ strncpy(box, txt1, 15); box[15] = 0; } //3 satzlabel
if (t0flag)
{ if (t2flag) lr = rSatz;
else
{ rzi = s[rSatz].b;
rrSatz = r[rzi].zS; lr = rrSatz; } }
sprintf(lcbox, "%3d", loc);
sprintf(rzbox, "%5u", querz);
if (mes) mes0();
else
{ mespos[0] = 0;
statusbar->message(mespos); }
if (dump->isVisible())
{ dump->raise(); dump->repaint(); }
if (rpFlag) rpFlag = 0;
else repaint(0, 0, BILDBR, BILDH, FALSE); }
//1 satzverb.
//2 satznr.
//3 satzlabel
void Baum::bBild()
{ tabclr();
t0flag = t1flag = t2flag = 0;
bbild();
if (querz)
{ t0flag = 1; //1
if (rrSatz && labTest(rrSatz))
txt2 = w[s[rrSatz].sl].st; //2
else t2flag = 1; }
if (rTyp == 'w')
{ txt1 = w[root].st; v = 0;
if (! txt1) t1flag = 1; } //3
else
{ if (labTest(root))
{ txt1 = w[s[root].sl].st; //4
holz = s[root].sr; }
else
{ holz = root; t1flag = 1; } //5
v = s[holz].v; //6
krone(holz); } } //7
//1 wrzwrz
//2 wrzwrzlabel
//3 wurzelwort
//4 wurzellabel
//5 wurzelsatz
//6 verb.ausdruck
//7 wrzwrzsatz
void Baum::tabclr()
{ char i;
for (i = 0; i < LZAHL; i++)
{ tabl[i].l = 0; tabl[i].v = 0; tabl[i].t = 0; tabl[i].e = 0;
tabr[i].l = 0; tabr[i].v = 0; tabr[i].t = 0; tabr[i].e = 0; } }
void Baum::bbild()
{ rSatz = 0; rrSatz = 0; zweig = 0;
if (root)
{ if (rTyp == 's')
{ rzi = s[root].b;
if (rzi) rSatz = r[rzi].zS;
loc = s[root].lc;
Root = s[root].h; //1
if (! Root) Root = rSatz; }
else
{ rzi = w[root].b;
if (rzi)
{ rSatz = r[rzi].zS; loc = s[rSatz].lc;
if (labTest(rSatz) && ! r[rzi].zz)
{ root = rSatz; rTyp = 's';
rzi = s[root].b;
if (rzi) rSatz = r[rzi].zS;
loc = s[root].lc; }
if (histor)
{ if (s[histor].t1 == 'w' && s[histor].sl == root) v = 1;
else if (s[histor].t2 == 'w' && s[histor].sr == root) v = 1; }
if (v) v = 0;
else histor = rSatz;
Root = histor; } }
querz = 0;
if (! rzi) return;
querCount(root, rTyp);
if (root == s[Root].sl) zweig = '\\'; //1
else if (root == s[Root].sr) zweig = '/'; //1
else if (root == s[s[Root].sr].sl) zweig = '\\'; //1
else zweig = '/'; //1
if ((rzi = s[rSatz].b)) rrSatz = r[rzi].zS; }
else
{ rTyp = 's'; s0 = s[ENDS];
querz = 0; } }
//1 Root i history
//2 root i (Root h (links o. rechts))
void Baum::history()
{ if (rTyp == 'w')
{ if (! w[root].b) return;
if (histor)
{ rTyp = 's'; root = histor; histor = 0; }
else
{ rzi = w[root].b;
rTyp = 's'; root = r[rzi].zS;
getRSatz(); } }
else if (rTyp == 's')
{ if (! s[root].b ) return;
if (s[root].h)
{ rTyp = 's'; root = s[root].h; }
else
{ rzi = s[root].b;
root = r[rzi].zS; getRSatz(); } } }
void Baum::histLR(char histFlag)
{ if (rTyp == 's')
{ if (labTest(root))
{ Root = root; rTyp = s[root].t2; root = s[root].sr; }
else Root = 0;
if (histFlag == '<')
{ if (s[root].t1 == 'w')
{ rTyp = 'w';
if (Root && lflag) histor = Root;
else histor = root;
root = s[root].sl; Root = 0; }
else if (s[root].t1 == 's')
{ rTyp = 's';
if (Root && lflag) s[s[root].sl].h = Root;
else s[s[root].sl].h = root;
root = s[root].sl; Root = 0; } }
else
{ if (s[root].t2 == 'w')
{ rTyp = 'w';
if (Root && lflag) histor = Root;
else histor = root;
root = s[root].sr; Root = 0; }
else if (s[root].t2 == 's')
{ rTyp = 's';
if (Root && lflag) s[s[root].sr].h = Root;
else s[s[root].sr].h = root;
root = s[root].sr; Root = 0; } } } }
void Baum::getRSatz()
{ rSatz = getWrzl(root, rTyp);
if (rSatz)
{ if (labTest(rSatz))
{ root = rSatz; rTyp = 's'; } } } //1
int Baum::getWrzl(int i, char t)
{ int rzi;
if (t == 'w') rzi = w[i].b;
else rzi = s[i].b;
if (rzi) return r[rzi].zS;
return 0; }
void Baum::pfadH(int k)
{ if (s[k].t1 == rC1 && s[k].sl == rI1)
{ if (rC1 == 's') s[s[k].sl].h = k;
else histor = k;
ast = k; return; }
if (s[k].t1 == 's') pfadH(s[k].sl);
if (ast)
{ s[ast].h = k; ast = k; return; }
if (s[k].t2 == rC1 && s[k].sr == rI1)
{ if (rC1 == 's') s[s[k].sr].h = k;
else histor = k;
ast = k; return; }
if (s[k].t2 == 's') pfadH(s[k].sr);
if (ast)
{ s[ast].h = k; ast = k; } }
// setzt ast als bezugs.knoten
void Baum::querCount(int i, char t)
{ int rzi;
if (t == 'w') rzi = w[i].b;
else rzi = s[i].b;
while (rzi)
{ rSatz = r[rzi].zS;
if (s[rSatz].lc == loc) querz++; //1
rzi = r[rzi].zz; } }
//1 querz: anzahl der lokalen rückzeiger
void Baum::krone(int root1)
{ typ = s[root1].t1; // linker teil hat typ
holz = s[root1].sl; // und inhalt als neuer b-punkt.
if (s[root1].v != '"' && tabfall(holz, typ)) // wenn links tab-element
{ tabl[0].t = typ; tabl[0].e = holz; tabl[0].h = root1; } // in tabl eintragen
else
{ nr = 0; tab = tabl;
*stck0++ = 0; // anfang und ende.
astkrone(); }
typ = s[root1].t2; // rechter teil hat typ
holz = s[root1].sr;
if (s[root1].v != '"' && tabfall(holz, typ)) // wenn rechts tab-element
{ tabr[0].t = typ; tabr[0].e = holz; tabr[0].h = root1; } // in tabr eintragen
else
{ nr = 0; tab = tabr;
*stck0++ = 0; // anfang und ende.
astkrone(); } }
void Baum::astkrone()
{ char lrflag = 'l'; cstck0 = cstack;
loop:
if (! tabfall(holz, typ)) // wenn kein tab-element
{ if (lrflag == 'l') *cstck0++ = 127; // tiefen.zähler
*stck0++ = holz; // b-punkt merken
typ = s[holz].t1; // linker teil hat typ
ast = holz; holz = s[holz].sl; // und inhalt als neuer b-punkt.
lrflag = 'l'; goto loop; }
*cstck0++ = nr;
*cstck0++ = 0;
if (lrflag == 'r') abtrag();
tab[nr].t = typ; tab[nr].e = holz; tab[nr].h = ast; // sonst in tab eintragen
nr++; holz = *--stck0; // nächstes tab-element und vorgänger zurückholen.
if (holz)
{ if (nr != LZAHL)
{ tab[nr].v = s[holz].v; // verb.zeichen des b-punkts zuordnen.
typ = s[holz].t2; // rechter teil hat typ
ast = holz; holz = s[holz].sr; // und inhalt als neuer b-punkt.
lrflag = 'r';
goto loop; }
while (cstck0 > (cstack + 2)) abtrag(); }
tab[0].l = *--cstck0; }
// setzt holz & typ voraus
/*
void Baum::krone(int root1)
{ typ = s[root1].t1; //1
holz = s[root1].sl; //2
if (s[root1].v != '"' && tabfall(holz, typ)) //3
{ tabl[0].t = typ; tabl[0].e = holz; tabl[0].h = root1; } //4
else
{ nr = 0; tab = tabl;
*stck0++ = 0; //5
astkrone(); }
typ = s[root1].t2; //6
holz = s[root1].sr;
if (s[root1].v != '"' && tabfall(holz, typ)) //7
{ tabr[0].t = typ; tabr[0].e = holz; tabr[0].h = root1; } //8
else
{ nr = 0; tab = tabr;
*stck0++ = 0; //9
astkrone(); } }
//1 linker teil hat typ
//2 und inhalt als neuer b-punkt.
//3 wenn links tab-element
//4 in tabl eintragen
//5 anfang und ende.
//6 rechter teil hat typ
//7 wenn rechts tab-element
//8 in tabr eintragen
//9 anfang und ende.
void Baum::astkrone()
{ char lrflag = 'l'; cstck0 = cstack;
loop:
if (! tabfall(holz, typ)) //1
{ if (lrflag == 'l') *cstck0++ = 127; //2
*stck0++ = holz; //3
typ = s[holz].t1; //4
ast = holz; holz = s[holz].sl; } //5
*cstck0++ = nr;
*cstck0++ = 0;
if (lrflag == 'r') abtrag();
tab[nr].t = typ; tab[nr].e = holz; tab[nr].h = ast; //6
nr++; holz = *--stck0; //7
if (holz)
{ if (nr != LZAHL)
{ tab[nr].v = s[holz].v; //8
typ = s[holz].t2; //9
ast = holz; holz = s[holz].sr; //10
lrflag = 'r';
goto loop; }
while (cstck0 > (cstack + 2)) abtrag(); }
tab[0].l = *--cstck0; }
// setzt holz & typ voraus
//1 wenn kein tab-element
//2 tiefen.zähler
//3 b-punkt merken
//4 linker teil hat typ
//5 und inhalt als neuer b-punkt.
//6 sonst in tab eintragen
//7 nächstes tab-element und vorgänger zurückholen.
//8 verb.zeichen des b-punkts zuordnen.
//9 rechter teil hat typ
//10 und inhalt als neuer b-punkt.
*/
char Baum::tabfall(int kNr, char& t)
{ if (t != 's') return 1;
if (s[kNr].t1 != 's' && s[kNr].t2 != 's') return 1;
if (labTest(kNr))
{ t = 'l'; return 1; }
return 0; }
// wenn kein satz o. links u. rechts kein satz dann tab-element.
// wenn labelflagge gesetzt u. labelfall dann typ : 'l' u. tab-element.
void Baum::abtrag()
{ char a, b, c;
loop:
c = *--cstck0;
b = *--cstck0;
a = *--cstck0;
if (a != 127)
{ if (a < c) a = c;
a++; tab[b].l = a;
*cstck0++ = a;
goto loop; }
*cstck0++ = b; //1
*cstck0++ = c; } //2
//1 letztes \-element
//2 gesamt-tiefe
//*************************************************************
void Baum::graphldruck()
{ int line;
tab = tabl; line = 0;
while (tab[line].t && line < LZAHL )
{ typ = tab[line].t; bload(btextl[line], line); line++; }
if (line < LZAHL) btextl[line][0] = 0; }
void Baum::bload(char* txtb, int line)
{ int n; char* txta; char c; double *dd;
c = tab[line].v;
n = tab[line].e;
if (! c) c = ' ';
*txtb++ = c; *txtb++ = ' ';
if (typ == 's')
{ if (s[n].t1 == 'w' || s[n].t1 == '?' || s[n].t1 == 't')
{ txta = w[s[n].sl].st;
do
{ *txtb++ = *txta++; }
while (*txta); }
else if (s[n].t1 == 'ß')
{ txta = w[cmdStart_ + s[n].sl + 1].st;
do
{ *txtb++ = *txta++; }
while (*txta); }
else
{ sprintf(tex, "%d", s[n].sl); txta = tex;
*txtb++ = s[n].t1;
if (s[n].t1 != ':') *txtb++ = ':';
do
{ *txtb++ = *txta++; }
while (*txta); }
*txtb++ = ' '; *txtb++ = s[n].v; *txtb++ = ' ';
if (s[n].t2 == 'w' || s[n].t2 == '?' || s[n].t2 == 't')
{ txta = w[s[n].sr].st;
do
{ *txtb++ = *txta++; }
while (*txta); }
else if (s[n].t2 == 'ß')
{ txta = w[cmdStart_ + s[n].sr + 1].st;
do
{ *txtb++ = *txta++; }
while (*txta); }
else
{ sprintf(tex, "%d", s[n].sr); txta = tex;
*txtb++ = s[n].t2;
if (s[n].t2 != ':') *txtb++ = ':';
do
{ *txtb++ = *txta++; }
while (*txta); }
*txtb = 0; }
else if (typ == 'w' || typ == '?')
{ txta = w[n].st; strcpy(txtb, txta); }
else if (typ == '@')
{ rzi = s[n].b; n = r[rzi].zS;
strcpy(tex, ":"); strcat(tex, w[s[n].sl].st); strcpy(txtb, tex); }
else if (typ == 't')
{ strcpy(tex, "\""); strcat(tex, w[n].st); strcpy(txtb, tex); }
else if (typ == '\'' || typ == 'c')
{ if (n < 0) n += 256;
strcpy(tex, "\'"); strcat(tex, w[n].st); strcat(tex, "\'"); strcpy(txtb, tex); }
else if (typ == 'l')
{ txta = w[s[n].sl].st;
do
{ *txtb++ = *txta++; }
while (*txta);
*txtb = 0; }
else if (typ == 'd' || typ == 'f')
{ dd = (double*) n;
sprintf(txtb, "%f", *dd); }
else
{ if (typ == ':') sprintf(txtb, "%c%d", typ, n);
else if (typ == 'ß') strcpy(txtb, w[cmdStart_ + n + 1].st);
else sprintf(txtb, "%c:%d", typ, n); } }
void Baum::graphrdruck()
{ int line;
tab = tabr; line = 0;
while (tab[line].t && line < LZAHL )
{ typ = tab[line].t; bload(btextr[line], line); line++; }
if (line < LZAHL) btextr[line][0] = 0; }
void Baum::tiefe(char ty, int nr, int x, int gx)
{ int k; char t; //1
t = char((gx - x) / 7);
if (t) --t;
while (nr < LZAHL && t >= tab[nr].l) nr++; //2
if (labTest(root)) root = s[root].sr;
if (! ty)
{ typ = s[root].t1; holz = s[root].sl; }
else
{ typ = s[root].t2; holz = s[root].sr; }
rekFlag = 0; rekI = nr; k = holz;
tabNr(typ, holz); }
//1 t : spalten_nr
//2 nr : zeilen_nr
void Baum::tabNr(char t, int k)
{ if (! rekFlag)
{ if (tabfall(k, t))
{ if (rekI) --rekI;
return; }
tabNr(s[k].t1, s[k].sl);
if (! rekI)
{ rekI = 1; rekFlag = 1; holz = k; }
if (! rekFlag) tabNr(s[k].t2, s[k].sr); } }]]>
back to
baumC