<![CDATA[//datei-name: aToBaum
#include "baum.h"
extern BMes* bMes;
void Baum::tScan(char* txt)
{ char c; int k, i; i = 0;
if (! *txt)
{ mes = 2; return; }
while (*txt == ' ') txt++; //1
umlScan(txt); //2
txt1 = txt;
do
{ c = *txt1++;
if (c == ' ' || c == '(' || c == ')') i++; } //2
while (c);
if (!i) wscan(txt);
else
{ txt1 = txt;
if (i == 1) s1scan();
else
{ if (i == 2)
{ txt2 = txt1;
do c = *txt2++;
while (c != ' ');
if (*(txt2 + 1) == ' ')
{ s2scan();
abschluss:
stck0 = stack; cstck0 = cstack; uKnot(root);
if (stack < stck0)
{ stck1 = stck0;
stck0 = stack + STCK1; cstck0 = cstack + CSTCK1; loeschRek(root, 's');
uBaum(root);
rTyp = 's'; root = clip[0]; }
return; } }
txt1 = txt; klammernZu();
loc = OUTLOC;
txt1 = txt2 = txt;
while (*txt2) ++txt2;
while (*(txt2 - 1) == ' ') *--txt2 = 0;
if ((txt2 - txt1) > 3)
{ ++txt2; spacer(); *txt2 = 0; }
k = SBau((int)txt1, (int)(txt2), 'i', 'i', '_');
llRek(k); rootMount(k);
lbRek(k); loc = STDLOC; s3scan(k); rTyp = 's'; root = Ast;
goto abschluss; } } }
//1 führende blanks überspringen
//2 i: blanks u. klammern zählen
void Baum::umlScan(char* txt)
// wandelt in eingabezeile hexzahlen vom typ /0xff in byte um
{ char * txt1;
txt1 = txt;
while (*txt1)
{ if (*txt1 == '/')
{ ++txt1;
if (*txt1 == '0')
{ ++txt1;
if (*txt1 == 'x')
{ ++txt1;
*txt++ = hexToByte(txt1);
txt1 += 2; }
else
{ *txt++ = '/'; *txt++ = '0'; continue; } }
else
{ *txt++ = '/'; continue; } }
else
{ if (*txt1 == '(')
{ if (*(txt1 + 1) == ' ') *txt1 = 'ß'; }
else if (*txt1 == ')')
{ if (*(txt1 - 1) == ' ') *txt1 = 'ð'; }
*txt++ = *txt1++; } }
*txt = 0; }
unsigned char Baum::hexToByte(char* txt)
// wandelt hexzahl in byte um
{ unsigned char n1, n2;
n1 = *txt; n2 = *(txt + 1);
n1 -= 48; n2 -= 48;
if (n1 > 9)
{ n1 -= 7;
if (n1 > 15) n1 -= 32; }
n1 *= 16;
if (n2 > 9)
{ n2 -= 7;
if (n2 > 15) n2 -= 32; }
n1 += n2;
return n1; }
void Baum::wscan(char* txt)
{ int ast;
ast = holzI(txt);
if (typ == '!')
{ root = ast; rTyp = 'w'; }
else if (ast == '<')
{ if (rTyp == 's')
{ if (labTest(root)) root = s[root].sr;
root = rootAbbau(root, 'r'); } }
else if (ast == '>')
{ if (rTyp == 's')
{ if (labTest(root)) root = s[root].sr;
root = rootAbbau(root, 'l'); } }
else
{ root = ast; rTyp = typ; } }
char Baum::labTest(int i)
// setzt i : satz voraus
{ if (lflag)
{ if (s[i].v == '"')
{ if ((s[i].t1 == 'w' || s[i].t1 == '?') && s[i].t2 == 's') return 1; }
if (s[i].v == 'S') return 1; }
return 0; }
void Baum::s1scan()
//setzt txt1 voraus
{ char c; char* txt2;
txt2 = txt1;
do c = *txt2++; while (c != ' ');
*(txt2 - 1) = 0;
v = ' ';
soscan(txt1, txt2); }
void Baum::soscan(char* txt1, char* txt2)
{ ast = holzI(txt1);
s0.sl = ast; s0.t1 = typ;
ast = holzI(txt2);
s0.sr = ast; s0.t2 = typ;
s0.v = v;
root = makeSatz(); rTyp = 's'; }
int Baum::makeSatz()
// setzt root und rTyp = 's' und bereits gestzte s0-komponenten voraus
// t1:! t2:! | t1:! t2:w | t1:w t2:! | t1:w t2:w
{ char t; t = 0;
if (s0.v == 'ß') s0.v = '(';
else if (s0.v == 'ð') s0.v = ')';
if (s0.t2 == '!')
{ s0.t2 = 'w'; t = 1; }
if (s0.t1 == 'w')
{ switch (s0.sl)
{ case '.': s0.t1 = rTyp; s0.sl = root; return makesatz();
case ':': if (labTest(root)) root = s[root].sr;
umbau(root, 'r', s0.sr, s0.t2); s[root].v = s0.v; return root;
case '<': anbauLr(anbauT(root), s0.sr, s0.t2, s0.v); return root;
case '>': anbauRr(anbauT(root), s0.sr, s0.t2, s0.v); return root; } }
else if (s0.t1 == '!') s0.t1 = 'w';
if (s0.t2 == 'w' && ! t)
{ switch (s0.sr)
{ case '.': s0.t2 = rTyp; s0.sr = root; return makesatz();
case ':': if (labTest(root)) root = s[root].sr;
umbau(root, 'l', s0.sl, s0.t1); s[root].v = s0.v; return root;
case '<': anbauLl(anbauT(root), s0.sl, s0.t1, s0.v); return root;
case '>': anbauRl(anbauT(root), s0.sl, s0.t1, s0.v); return root; } }
return makesatz(); }
int Baum::anbauT(int i)
{ if (labTest(i)) return s[i].sr;
else return i; }
void Baum::klammernZu()
// setzt txt1 voraus, ergänzt fehlende klammern
{ int i, j; char* txt;
i = j = 0; txt = txt1;
while (*txt1)
{ if (*txt1 == '(') i = 1;
else if (*txt1 == ')')
{ if (! i) ++j; }
++txt1; }
if(j)
{ txt2 = txt1; txt2 += j; *txt2 = 0;
while (txt1 > txt) *--txt2 = *--txt1;
while (j)
{ *txt1++ = '('; --j; } }
txt1 = txt; i = 0;
while (*txt1)
{ if (*txt1 == '(') ++i;
else if (*txt1 == ')') --i;
txt1++; }
if (i > 0)
{ while(i)
{ *txt1++ = ')'; --i; }
*txt1 = 0; }
else if(i < 0)
{ txt2 = txt1;
i *= -1; txt2 += i; *txt2 = 0;
while (txt1 > txt) *--txt2 = *--txt1;
while (i)
{ *txt1++ = '('; --i; } } }
void Baum::spacer()
// space korrektur . txt1 u. txt2 werden um die länge des neuen textes verschoben
{ char c, d;
c = *txt1++; d = *txt1++;
*txt2++ = c;
if (d == '(')
{ *txt2++ = ' '; *txt2++ = d; }
else if (! (c == '(' && d == ' ')) *txt2++ = d;
while (d)
{ c = d; d = *txt1++;
if (! d) break;
if (c == '(' && d == ' ') *txt2++ = c;
else if (c == ')' && d != ' ' && d != ')')
{ *txt2++ = ' '; *txt2++ = d; }
else if (c == ' ' && d == ')') *(txt2 - 1) = d;
else if (c != ' ' && c != '(' && d == '(')
{ *txt2++ = ' '; *txt2++ = d; }
else *txt2++ = d; } }
void Baum::s2scan()
{ *(txt2 - 1) = 0;
if (*txt2 == ' ') v = ' ';
else v = *txt2++;
txt2++;
if (v == '`') v = ' ';
soscan(txt1, txt2); }
//---------------------------------------
void Baum::llRek(int k)
// zeile als baum
{ int ast;
txt1 = (char*)s[k].sl; txt2 = (char*)s[k].sr;
adr = 0; tok = (int)txt1; lMid(k);
if (!adr) return;
ast = SBau(tok, (int)txt2, 'i', 'i', '_');
s[k].sl = ast; s[k].t1 = 's';
ast = SBau(adr, s[k].sr, 'i', 'i', '_');
s[k].sr = ast; s[k].t2 = 's';
s[k].v = v;
llRek(s[k].sl);
llRek(s[k].sr); }
void Baum::lMid(int k)
// setzt txt1 & txt2 voraus. mitte: hinter dem größten abstand vor einem verb bzw. wort
{ char c, vc; int i, iM; char* txt, * txtE;
vc = 0; i = iM = 0;
while (txt1 < txt2)
{ c = *txt1++;
if (c == '(')
{ txt = txt1;
klammerAusdruck();
if (txt1 >= txt2)
{ if (! adr)
{ txt2 = txt1 - 1; s[k].sr = (int)txt2; s[k].t2 = 'i';
txt1 = txt; tok = (int)txt1; continue; }
else break; } }
while (c && c != ' ') c = *txt1++; //1
if (txt1 >= txt2) break;
txt = txt1 - 1; i = 1;
while (*txt1 == ' ') //1
{ ++i; ++txt1; }
vc = c = *txt1;
if (c == '(')
{ vc = ' ';
if (iM <= i)
{ iM = i; v = vc; txtE = txt; adr = (int)txt1; }
++txt1; klammerAusdruck();
if (txt1 >= txt2) break; }
else
{ ++txt1; c = *txt1++;
if (c == ' ')
{ while (c == ' ') c = *txt1++;
--txt1; }
else
{ vc = ' '; txt1 -= 2; }
if (iM <= i)
{ iM = i; v = vc; txtE = txt; adr = (int)txt1; } } }
if (adr)
{ txt2 = txtE;
while (*(txt2 - 1) == ')') --txt2; } } //2
//1 zwei texte oder klammern müssen durch (mindestens ein) leer zeichen getrennt sein
//2 ende entweder schon vorhanden oder vor dem größten abstand
void Baum::klammerAusdruck()
{ int k; char c; k = 1;
loop:
c = *txt1++;
if (c == ')')
{ --k;
if (! k) return; }
if (c == '(') ++k;
goto loop; }
int Baum::SBau(int sl, int sr, char t1, char t2, char v)
// neuer satz: satz0: neuer s_block: leer
{ while(s[satz0].v) satz0++;
if (satz0 > sMax) sMax = satz0;
s[satz0].sl = sl; s[satz0].sr = sr; s[satz0].t1 = t1; s[satz0].t2 = t2; s[satz0].v = v;
s[satz0].lc = loc;
return satz0; }
void Baum::rootMount(int k)
{ int A, B, C, D; char l, r;
l = r = 0; li = s[k].sl;
if (s[li].t1 == 'i')
{ txt1 = (char*)s[li].sl; txt2 = (char*)s[li].sr;
if (txt1 + 1 == txt2 && (*txt1 == '<' || *txt1 == '>')) rootMR(s[k].sr);
else
{ re = s[k].sr;
rechts:
Root = k;
while (s[re].t1 != 'i')
{ s[re].h = k; k = re; re = s[re].sr; }
s[re].h = k; k = Root;
txt1 = (char*)s[re].sl; txt2 = (char*)s[re].sr;
if (txt1 + 1 == txt2 && (*txt1 == '<' || *txt1 == '>'))
{ r = 1;
A = re; B = s[re].h; C = s[B].sl; D = s[B].h;
li = s[k].sl; re = s[k].sr; v = s[k].v;
s[k].sr = A; s[k].sl = B; s[k].v = s[B].v;
s[B].sl = li; s[B].v = v;
if (B == re) s[B].sr = C;
else
{ s[D].sr = C; s[B].sl = re; } }
if (r) rootMR(s[k].sl);
else rootMR(k); } }
else
{ Root = k;
while (s[li].t1 != 'i')
{ s[li].h = k; k = li; li = s[li].sl; }
s[li].h = k; k = Root;
txt1 = (char*)s[li].sl; txt2 = (char*)s[li].sr;
if (txt1 + 1 == txt2 && (*txt1 == '<' || *txt1 == '>'))
{ l = 1;
A = li; B = s[li].h; C = s[B].sr; D = s[B].h;
li = s[k].sl; re = s[k].sr; v = s[k].v;
s[k].sl = A; s[k].sr = B; s[k].v = s[B].v;
s[B].sr = re; s[B].v = v;
if (B == li) s[B].sl = C;
else
{ s[D].sl = C; s[B].sl = li; } }
if (l) rootMR(s[k].sr);
else
{ re = s[k].sr;
if (s[re].t1 == 'i') rootMR(s[k].sl);
else goto rechts; } } }
void Baum::rootMR(int k)
{ if (s[k].t1 == 'i') return;
li = s[k].sl;
if (s[li].t1 == 'i')
{ txt1 = (char*)s[li].sl; txt2 = (char*)s[li].sr;
if (txt1 + 1 == txt2 && (*txt1 == '<' || *txt1 == '>')) *txt1 = '?'; }
else rootMR(li);
re = s[k].sr;
if (s[re].t1 == 'i')
{ txt1 = (char*)s[re].sl; txt2 = (char*)s[re].sr;
if (txt1 + 1 == txt2 && (*txt1 == '<' || *txt1 == '>')) *txt1 = '?'; }
else rootMR(re); }
void Baum::lbRek(int k)
{ if (s[k].t1 == 's')
{ Ast = k; lbRek(s[k].sl); }
else
{ if (s[k].t1 == 'i')
{ txt1 = (char*)s[k].sl; txt2 = (char*)s[k].sr;
*txt2 = 0; worti = holzI(txt1);
if (k == s[Ast].sl)
{ s[Ast].sl = worti; s[Ast].t1 = typ; }
else
{ s[Ast].sr = worti; s[Ast].t2 = typ; }
return; } }
Ast = k; lbRek(s[k].sr); }
void Baum::s3scan(int k)
// setzt satz-knoten ein
{ if (s[k].t1 == 's')
{ li = s[k].sl;
if (s[li].lc == OUTLOC)
{ s[li].h = k; s[li].s = 'L'; s3scan(li); } }
if (s[k].t2 == 's')
{ re = s[k].sr;
if (s[re].lc == OUTLOC)
{ s[re].h = k; s[re].s = 'R'; s3scan(re); } }
s0 = s[k]; Ast = makeSatz(); //1
if (s[k].s == 'L')
{ li = s[k].h; s[li].sl = Ast; }
else if (s[k].s == 'R')
{ re = s[k].h; s[re].sr = Ast; } }
//1 wertet sonder-zeichen aus
//-------------------------------------------------------
void Baum::uKnot(int k)
// legt u-werte auf stack
{ if (s[k].v == 'u')
{ li = s[k].sl;
if (s[k].t1 == 's')
{ if (s[li].v == 'u') uKnot(li);
else
{ *stck0++ = li; *cstck0++ = 's'; } }
else
{ *stck0++ = li; *cstck0++ = 'w'; }
re = s[k].sr;
if (s[k].t2 == 's')
{ if (s[re].v == 'u') uKnot(re);
else
{ *stck0++ = re; *cstck0++ = 's'; } }
else
{ *stck0++ = re; *cstck0++ = 'w'; } } }
void Baum::uBaum(int k)
// ordnet gefundene lösungen nach tiefe (clip clap)
{ char c, d; int i, j;
stck0 = stack; cstck0 = cstack;
stck2 = stck1; cstck2 = cstck1 = cstack + CSTCK1;
knot = *stck0; typ = *cstck0;
if (typ == 's') rzi = s[knot].b;
else rzi = w[knot].b;
iR = 0; flag = 0;
uBaumSet(rzi);
if (stck1 < stck2)
{ do //1
{ flag = 0;
stck0 = stck1; cstck0 = cstck1;
while (stck0 < (stck2 - 1))
{ c = *cstck0; d = *(cstck0 + 1);
if (c > d)
{ flag = 1;
*cstck0 = d; *(cstck0 + 1) = c;
i = *stck0; j = *(stck0 + 1);
*stck0 = j; *(stck0 + 1) = i; }
++cstck0; ++stck0; } }
while (flag);
for (i = 0; i < 8; ++i)
{ clip[i] = 0; clipTyp[i] = 0; }
stck0 = stck1; i = 0;
while (stck0 < stck2)
{ clip[i] = *stck0++; clipTyp[i] = 's'; ++i;
if (i >= 8) break; } } }
//1 bubble-sort
void Baum::uBaumSet(int rz)
// tiefen-rekursion . sucht lösungen
{ if (iR < 10)
{ ++iR; rSatz = r[rz].zS;
stck0 = stack + 1; cstck0 = cstack + 1; uKnotVal(rSatz); //1
if (! flag)
{ if (s[rSatz].b)
{ rzi = s[rSatz].b; uBaumSet(rzi); } }
--iR; rzi = r[rz].zz;
if (rzi) uBaumSet(rzi); } }
//1 setzt flag bei gefundener lösung
void Baum::uKnotVal(int k)
// trägt gefundene lösung u. tiefe in stack ein
{ flag = 1;
while (stck0 < stck1)
{ knot = *stck0++; typ = *cstck0++;
if (! uBaumScan(k))
{ flag = 0; break; } }
if (flag)
{ *stck2++ = k; *cstck2++ = (char) iR; } }
char Baum::uBaumScan(int k)
// setzt knot u. typ voraus . prüft k-baum auf komponente
{ if (s[k].sl == knot && s[k].t1 == typ) return 1;
if (s[k].t1 == 's')
{ if (uBaumScan(s[k].sl)) return 1; }
if (s[k].sr == knot && s[k].t2 == typ) return 1;
if (s[k].t2 == 's')
{ if (uBaumScan(s[k].sr)) return 1; }
return 0; }
//*******************************************************
void Baum::asciiToBaum()
{ int i, num, k; x = 0;
num = bMes->numLines();
if (! num) return;
baumdat = baumDat = new char[0x10000]; *baumdat++ = ' ';
for (i = 0; i < num; ++i)
{ strcpy(tex, bMes->textLine(i));
preview();
if (tex[0] == '*') *baumdat++ = 1; //1
else if (tex[0] == 0) *baumdat++ = 2; //2
else if (tex[0] == '#') *baumdat++ = 4; //4
else
{ txt1 = tex;
while (*txt1)
{ if (*txt1 == ':')
{ if (txt1 != tex && *(txt1 - 1) != ' ') *baumdat++ = ' '; }
else if (*txt1 == '(' || *txt1 == '"')
{ if (txt1 != tex && *(txt1 - 1) != ' ') *baumdat++ = ' ';
if (*(txt1 + 1) == ' ')
{ *baumdat++ = *txt1; ++txt1; }
else
{ *baumdat++ = *txt1; *baumdat++ = ' '; ++txt1; continue; } }
else if ((*txt1 == ',' || *txt1 == ';' || *txt1 == '?' || *txt1 == '!' || *txt1 == ')')
&& *(txt1 - 1) != ' ') *baumdat++ = ' ';
else if (*txt1 == '.')
{ if (*(txt1 + 1) == '.')
{ while (*txt1 == '.') *baumdat++ = *txt1++; continue; }
if (*(txt1 + 2) == '.')
{ *baumdat++ = *txt1++; *baumdat++ = *txt1++; *baumdat++ = *txt1++;
if (*(txt1 + 1) == '.')
{ *baumdat++ = *txt1++; *baumdat++ = *txt1++; }
continue; }
if (!(*(txt1 + 1)) || *(txt1 + 1) == ' ' || *(txt1 + 1) == '(')
{ if ((txt1 - 1) != tex && *(baumdat - 2) != ' ')
{ if (*(txt1 - 1) != ' ') *baumdat++ = ' ';
*baumdat++ = *txt1++; continue; } }
if (*(txt1 - 1) == ')')
{ *baumdat++ = ' '; *baumdat++ = *txt1++; continue; } }
*baumdat++ = *txt1++; }
txt1 = baumdat - 1;
while (*txt1 == ' ')
{ --baumdat; --txt1; } }
*baumdat++ = ' '; *baumdat++ = 3; *baumdat++ = ' '; }
txt1 = baumdat - 1;
while (*txt1 == ' ' || (*txt1 < 4 && *txt1 != 1))
{ --baumdat; --txt1; *baumdat = 0; }
stck0 = stack; rTyp = 's'; aTok();
if (rTyp == 's')
{ k = sBau((int)stack, (int)stck1, 'i', 'i', '_');
mesFlag = 0; sekRek1(k, 0x10); stack = stck0; //2
if (mesFlag == 1)
{ cout << "kein lab-end" << endl; return; }
if (mesFlag == 2)
{ cout << "kein klamm-end" << endl; return; }
if (mesFlag == 3)
{ cout << "kein text-end" << endl; return; }
sekRekD(k); //3
sekRekE(k); //4
if (s[root].b) tlz(root, k, 's', 's');
else root = k; }
delete [] baumDat; }
//1 label //2 neuer absatz(leerzeile) //3 zeilenumbruch //4 label ende
//2 stack-restore
//3 überarbeitung -(klammern & text)-
//4 test u. eventueller zusammenbau von bindestrich-wörtern
void Baum::preview()
// tolower . (satz-umbruch (\\ oder <br>))
{ txt1 = tex;
while (*txt1)
{ *txt1 = tolower(*txt1); ++txt1; }
/* --txt1;
if (*txt1 == '\\')
{ --txt1;
if (*txt1 == '\\')
{ if (*(txt1 - 1) != '\\')
{ *txt1++ = '·'; *txt1 = 0; } } }
else if (*txt1 == '>')
{ --txt1;
if (*txt1 == 'r')
{ --txt1;
if (*txt1 == 'b')
{ --txt1;
if (*txt1 == '<')
{ *txt1++ = '·'; *txt1++ = 0; *txt1++ = 0; *txt1++ = 0; } } } } */
txt1 = tex; }
void Baum::aTok()
// baut tokenstack auf (stack -> stck1)
{ int* tmp1, * tmp2; unsigned char c;
txt1 = baumDat;
while (txt1 < baumdat)
{ if (*txt1 == ' ') *txt1 = 0;
++txt1; }
txt1 = baumDat; *stack++ = 0; tmp1 = stack;
while (txt1 < baumdat)
{ if (! *txt1) ++txt1;
else
{ worti = wortI(txt1);
while (*txt1) ++txt1;
*tmp1++ = worti; } }
stck1 = tmp1; tmp1 = stack;
while (tmp1 < stck1)
{ worti = *tmp1++;
if (*(tmp1 - 1) == 3 && *(tmp1 + 1) == 3)
{ worti = *tmp1++;
if (worti > 0x20)
{ if (worti < 256)
{ *(tmp1 - 2) = 0x10; ++tmp1; }
else
{ c = *(w[worti].st);
if ((nr = verbNr(c)))
{ *(tmp1 - 2) = nr; *(tmp1 - 1) = c; ++tmp1; } } } } }
tmp1 = tmp2 = stack;
if (tmp1 == stck1 - 1)
{ root = worti; rTyp = 'w'; return; }
while (tmp1 < stck1)
{ worti = *tmp1++;
if (worti == 3)
{ if (*(tmp2 - 1) == '.') --tmp2;
else if (*(tmp2 - 1) < 0x10 ) worti = 0;
else if (*(tmp2 - 2) > 0xf && *(tmp2 - 2) < 0x20) worti = 0;
else worti = 0; }
else if (worti < 0x10)
{ if (*(tmp2 - 1) == 3) --tmp2;
if (worti == 2)
{ if (*(tmp2 - 1) == 2) --tmp2;
else if (*(tmp2 - 1) < 0x10) worti = 0;
else if (*(tmp2 - 2) > 0xf && *(tmp2 - 2) < 0x20) worti = 0; }
else if (worti == 1)
{ if (*(tmp2 - 1) == 2) --tmp2; } }
if (worti) *tmp2++ = worti; }
worti = *(tmp2 - 1);
while (worti == ' ' || worti == '.' || worti < 4)
{ --tmp2; worti = *(tmp2 - 1) ; }
*tmp2 = 0; tmp1 = stack; stck1 = tmp2; ++tmp2;
while (tmp1 < stck1)
{ worti = *tmp1;
if (worti == '(')
{ A = *(tmp1 - 1); B = *(tmp1 - 2);
if (A > 0xff || (A > '0' && B > 0x20)) *tmp2++ = '-'; }
else if (worti == ')')
{ A = *(tmp1 + 1);
if (A > '0')
{ *tmp2++ = ')'; *tmp1 = '-'; } }
else if (worti == '"' && ! nr)
{ nr = 1;
A = *(tmp1 - 1); B = *(tmp1 - 2);
if (A > 0xff ||(A > '0' && B > 0x20)) *tmp2++ = '-'; }
else if (worti == '"' && nr == 1)
{ nr = 0;
A = *(tmp1 + 1);
if (A > '0')
{ *tmp2++ = '"'; *tmp1 = '-'; } }
*tmp2++ = *tmp1++; }
stack = stck1 + 1; stck1 = tmp2; }
int Baum::verbNr(unsigned char c)
{ unsigned char d; char* p; int i = 0x10;
p = w[worti].st; ++p; d = *p++;
while (c == d)
{ ++i; d = *p++; }
if (d) return 0;
return i; }
void Baum::sekRek1(int k, int nr)
{ int* tmp, * tmp0, * tmp1;
tmp = tmp0 = (int*)s[k].sl; tmp1 = (int*)s[k].sr;
while (tmp0 < tmp1)
{ if (*tmp0 == 1)
{ tmpStack = labEnd(tmp0, tmp1);
if (! tmpStack)
{ mesFlag = 1; return; }
if (tmp0 == (tmp + 1))
{ if ((tmpStack + 1) == tmp1)
{ s[k].v = '"'; umbau(k, 'l', *tmp, 'w');
++tmp0; x = sBau((int)tmp0, (int)tmpStack, 'i', 'i', '_'); umbau(k, 'r', x, 's');
sekRek1(x, 0x10); return; }
tmp0 = tmpStack + 1; } //1
else
{ ++tmpStack;
tmp0 = tmpStack; } }
else if (*tmp0 == nr)
{ x = sBau((int)tmp, (int)tmp0, 'i', 'i', '_');
umbau(k, 'l', x, 's'); ++nr; ++tmp0; s[k].v = *tmp0; ++tmp0;
sekRek1(x, nr);
x = sBau((int)tmp0, (int)tmp1, 'i', 'i', '_');
umbau(k, 'r', x, 's');
sekRek1(x, nr); return; } //2
else ++tmp0; }
sekRek2(k); }
//1 verlässt sich darauf, dass noch ein verb kommt, falls tmpStack < tmp1
//2 nr ist bereits erhöht
int* Baum::labEnd(int* tmp0, int* tmp1)
{ int k; k = 0;
while (tmp0 < tmp1)
{ if (*tmp0 == 1) ++k;
else if (*tmp0 == 4)
{ --k;
if (! k) return tmp0; }
++tmp0; }
return 0; }
void Baum::sekRek2(int k)
{ int* tmp, * tmp0, * tmp1;
tmp = tmp0 = (int*)s[k].sl; tmp1 = (int*)s[k].sr;
while (tmp0 < tmp1)
{ if (*tmp0 == 2)
{ x = sBau((int)tmp, (int)tmp0, 'i', 'i', '_');
umbau(k, 'l', x, 's'); s[k].v = '*'; ++tmp0;
sekRek3(x);
x = sBau((int)tmp0, (int)tmp1, 'i', 'i', '_');
umbau(k, 'r', x, 's');
sekRek2(x); return; }
else ++tmp0; }
sekRek3(k); }
void Baum::sekRek3(int k)
{ int* tmp, * tmp0, * tmp1;
tmp = tmp0 = (int*)s[k].sl; tmp1 = (int*)s[k].sr;
while (tmp0 < tmp1)
{ if (*tmp0 == 3)
{ x = sBau((int)tmp, (int)tmp0, 'i', 'i', '_');
umbau(k, 'l', x, 's'); s[k].v = '·'; ++tmp0;
sekRek4(x);
x = sBau((int)tmp0, (int)tmp1, 'i', 'i', '_');
umbau(k, 'r', x, 's');
sekRek3(x); return; }
else ++tmp0; }
sekRek4(k); }
void Baum::sekRek4(int k)
{ int* tmp, * tmp0, * tmp1;
tmp = tmp0 = (int*)s[k].sl; tmp1 = (int*)s[k].sr;
while (tmp0 < tmp1)
{ if (*tmp0 == ':')
{ x = sBau((int)tmp, (int)tmp0, 'i', 'i', '_');
umbau(k, 'l', x, 's'); s[k].v = ':'; ++tmp0;
sekRek5(x);
x = sBau((int)tmp0, (int)tmp1, 'i', 'i', '_');
umbau(k, 'r', x, 's');
sekRek5(x); return; }
else ++tmp0; }
sekRek5(k); }
void Baum::sekRek5(int k)
{ int* tmp, * tmp0, * tmp1;
tmp = tmp0 = (int*)s[k].sl; tmp1 = (int*)s[k].sr;
while (tmp0 < tmp1)
{ if (*tmp0 == '(')
{ tmp0 = klammEnd(tmp0, tmp1);
if (! tmp0)
{ mesFlag = 2; return; } }
else if (*tmp0 == '"')
{ tmp0 = textEnd(tmp0, tmp1);
if (! tmp0)
{ mesFlag = 3; return; } }
else if (*tmp0 == '.')
{ x = sBau((int)tmp, (int)tmp0, 'i', 'i', '_');
umbau(k, 'l', x, 's'); s[k].v = '.'; ++tmp0;
sekRek5(x);
x = sBau((int)tmp0, (int)tmp1, 'i', 'i', '_');
umbau(k, 'r', x, 's');
sekRek5(x); return; }
++tmp0; }
sekRek6(k); }
int* Baum::klammEnd(int* tmp0, int* tmp1)
{ int k; k = 0;
while (tmp0 < tmp1)
{ if (*tmp0 == '(') ++k;
else if (*tmp0 == ')')
{ --k;
if (! k) return tmp0; }
++tmp0; }
return 0; }
int* Baum::textEnd(int* tmp0, int* tmp1)
{ while (tmp0 < tmp1)
{ ++tmp0;
if (*tmp0 == '"') return tmp0; }
return 0; }
void Baum::sekRek6(int k)
{ int* tmp, * tmp0, * tmp1;
tmp = tmp0 = (int*)s[k].sl; tmp1 = (int*)s[k].sr;
while (tmp0 < tmp1)
{ if (*tmp0 == '(')
{ tmp0 = klammEnd(tmp0, tmp1);
if (! tmp0)
{ mesFlag = 2; return; } }
else if (*tmp0 == '"')
{ tmp0 = textEnd(tmp0, tmp1);
if (! tmp0)
{ mesFlag = 3; return; } }
else if (*tmp0 == '?' || *tmp0 == '!')
{ x = sBau((int)tmp, (int)tmp0, 'i', 'i', '_');
umbau(k, 'l', x, 's'); s[k].v = ' ';
sekRek7(x);
if (tmp0 == (tmp1 - 1))
{ umbau(k, 'r', *tmp0, 'w'); return; }
anbauLr(k, *tmp0, 'w', ' '); ++tmp0;
x = sBau((int)tmp0, (int)tmp1, 'i', 'i', '_');
umbau(k, 'r', x, 's');
sekRek6(x); return; }
++tmp0; }
sekRek7(k); }
void Baum::sekRek7(int k)
{ int* tmp, * tmp0, * tmp1;
tmp = tmp0 = (int*)s[k].sl; tmp1 = (int*)s[k].sr;
while (tmp0 < tmp1)
{ if (*tmp0 == '-' || *tmp0 == ';')
{ x = sBau((int)tmp, (int)tmp0, 'i', 'i', '_');
umbau(k, 'l', x, 's'); s[k].v = *tmp0; ++tmp0;
sekRekC(x);
x = sBau((int)tmp0, (int)tmp1, 'i', 'i', '_');
umbau(k, 'r', x, 's');
sekRek7(x); return; }
else ++tmp0; }
sekRekC(k); }
void Baum::sekRekC(int k)
{ int* tmp, * tmp0, * tmp1;
tmp = tmp0 = (int*)s[k].sl; tmp1 = (int*)s[k].sr;
while (tmp0 < tmp1)
{ if (*tmp0 == '(')
{ tmp0 = sekRekA(k, tmp, tmp0, tmp1);
if (! tmp0)
{ mes = 2; return; }
if ((int)tmp0 == 1) return; }
else if (*tmp0 == '"')
{ tmp0 = sekRekB(k, tmp, tmp0, tmp1);
if (! tmp0)
{ mes = 3; return; }
if ((int)tmp0 == 1) return; }
else if (*tmp0 == ',')
{ x = sBau((int)tmp, (int)tmp0, 'i', 'i', '_');
umbau(k, 'l', x, 's'); sekRek8(x);
s[k].v = ','; ++tmp0;
x = sBau((int)tmp0, (int)tmp1, 'i', 'i', '_');
umbau(k, 'r', x, 's'); sekRekC(x); return; }
else ++tmp0; }
sekRek8(k); }
int* Baum::sekRekA(int k, int* tmp, int* tmp0, int* tmp1)
{ tmpStack = klammEnd(tmp0, tmp1);
if (! tmpStack) return 0;
if (tmp0 == tmp)
{ if ((tmpStack + 1) == tmp1)
{ ++tmp0; umbau(k, 'l', (int)tmp0, 'i'); umbau(k, 'r', (int)tmpStack, 'i');
rzi = s[k].b;
if (rzi)
{ wrzl = r[rzi].zS;
if (k == s[wrzl].sl) s[wrzl].v = ')';
else s[wrzl].v = '('; }
sekRek5(k); return (int*)1; }
tmp0 = tmpStack + 1; } //1
else
{ ++tmpStack;
tmp0 = tmpStack; }
return tmp0; }
//1 verlässt sich darauf, dass noch ein verb kommt, falls tmpStack < tmp1
int* Baum::sekRekB(int k, int* tmp, int* tmp0, int* tmp1)
{ tmpStack = textEnd(tmp0, tmp1);
if (! tmpStack) return 0;
if (tmp0 == tmp)
{ if ((tmpStack + 1) == tmp1)
{ ++tmp0; x = sBau((int)tmp0, (int)tmpStack, 'i', 'i', '_');
umbau(k, 'l', '"', 'w'); s[k].v = '"';
umbau(k, 'r', x, 's');
sekRek5(x);
return (int*)1; }
tmp0 = tmpStack + 1; } //1
else
{ ++tmpStack;
tmp0 = tmpStack; }
return tmp0; }
//1 verlässt sich darauf, dass noch ein verb kommt, falls tmpStack < tmp1
void Baum::sekRek8(int k)
{ int* tmp, * tmp0, * tmp1;
tmp = tmp0 = (int*)s[k].sl; tmp1 = (int*)s[k].sr;
if (tmp0 < tmp1)
{ if (tmp0 == (tmp1 - 1))
{ rzi = s[k].b;
wrzl = r[rzi].zS;
if (k == s[wrzl].sl)
{ umbau(wrzl, 'l', *tmp0, 'w'); }
else
{ umbau(wrzl, 'r', *tmp0, 'w'); }
return; }
if (tmp0 == (tmp1 - 2))
{ umbau(k, 'l', *tmp0, 'w');
++tmp0; s[k].v = ' ';
umbau(k, 'r', *tmp0, 'w'); return; }
umbau(k, 'l', *tmp0, 'w');
++tmp0; s[k].v = ' ';
x = sBau((int)tmp0, (int)tmp1, 'i', 'i', ' ');
umbau(k, 'r', x, 's'); sekRek8(x); } }
void Baum::sekRekD(int k)
// überarbeitung -(klammern & text)-
{ if (s[k].t1 == 's') sekRekD(s[k].sl);
if (s[k].t2 == 's')
{ if (s[k].v == '-')
{ ast = s[k].sr;
if (s[ast].v == '(' || s[ast].v == ')' || s[ast].v == '-')
{ s[k].v = ' '; s[ast].v = ' '; } }
sekRekD(s[k].sr); } }
void Baum::sekRekE(int k)
// überarbeitung bindestrich-wörter
{ if (s[k].v == '"')
{ sekRekE(s[k].sr); return; }
if (s[k].t1 == 's') sekRekE(s[k].sl);
else
{ worti = s[k].sl;
if ((satzi = bindeStrich())) umbau(k, 'l', satzi, 's'); }
if (s[k].t2 == 's') sekRekE(s[k].sr);
else
{ worti = s[k].sr;
if ((satzi = bindeStrich())) umbau(k, 'r', satzi, 's'); } }
int Baum::bindeStrich()
// test u. eventueller zusammenbau von bindestrich-wörtern
{ txt0 = w[worti].st; txt1 = txt0;
while (*txt0 && *txt0 != '-') ++txt0;
if (*txt0 == '-')
{ *txt0++ = 0; txt2 = txt0;
li = wortI(txt1); re = wortI(txt2);
return sBau(li, re, 'w', 'w', '-'); }
return 0; }
//-------------------------------------------------------
void Baum::baumToAscii()
{ baumDat = new char[100000]; baumdat = baumDat;
verbN(root);
baumAsciiRek(root);
*baumdat = 0; bMes->setText(baumDat);
delete [] baumDat;
editor1show(); bmod = 1;
bildneu(); }
void Baum::verbN(int k)
{ int n; n = 0; s[k].h = 0;
loopL:
if (s[k].v == '"')
{ if (s[k].t2 == 's') verbN(s[k].sr);
goto loopT; }
if (s[k].v >= '0' && s[k].v != '·') s[k].s = ++n;
if (s[k].t1 == 's')
{ wrzl = k; k = s[k].sl; s[k].h = wrzl;
goto loopL; }
loopR:
if (s[k].t2 == 's')
{ wrzl = k; k = s[k].sr; s[k].h = wrzl;
goto loopL; }
loopT:
wrzl = s[k].h;
if (wrzl)
{ if (k == s[wrzl].sl && k != s[wrzl].sr)
{ k = wrzl; goto loopR; }
k = wrzl; goto loopT; } }
void Baum::baumAsciiRek(int k)
{ int li, re;
li = s[k].sl; re = s[k].sr;
if (s[k].v == ')')
{ *baumdat++ = '(';
if (s[k].t1 == 's') baumAsciiRek(li);
else baumAsciiCpy(li);
*baumdat++ = ')'; *baumdat++ = ' ';
if (s[k].t2 == 's') baumAsciiRek(re);
else baumAsciiCpy(re);
return; }
if (s[k].v == '(')
{ if (s[k].t1 == 's') baumAsciiRek(li);
else baumAsciiCpy(li);
*baumdat++ = ' '; *baumdat++ = '(';
if (s[k].t2 == 's') baumAsciiRek(re);
else baumAsciiCpy(re);
*baumdat++ = ')'; *baumdat++ = ' ';
return; }
if (s[k].v == '"')
{ baumAsciiCpy(li);
if (li == '"')
{ if (s[k].t2 == 's') baumAsciiRek(re);
else baumAsciiCpy(re);
*baumdat++ = '"'; return; }
*baumdat++ = LF;
datLen = strlen(w[li].st);
while (datLen--) *baumdat++ = '*';
*baumdat++ = LF;
if (s[k].t2 == 's') baumAsciiRek(re);
else baumAsciiCpy(re);
*baumdat++ = LF; *baumdat++ = '#'; return; }
if (s[k].t1 == 's') baumAsciiRek(li);
else baumAsciiCpy(li);
if (s[k].v == ' ') *baumdat++ = ' ';
else if (s[k].v == ',' || s[k].v == ';' || s[k].v == ':')
{ *baumdat++ = s[k].v; *baumdat++ = ' '; }
else if (s[k].v == '-' || s[k].v == '.')
{ *baumdat++ = ' '; *baumdat++ = s[k].v; *baumdat++ = ' '; }
else if (s[k].v == '·')
{ *baumdat++ = ' '; *baumdat++ = '.'; *baumdat++ = LF; }
else if (s[k].v == '*')
{ *baumdat++ = LF; *baumdat++ = LF; }
else if (s[k].v == '·')
{ *baumdat++ = ' '; *baumdat++ = '·'; *baumdat++ = LF; }
else if (s[k].v == '*')
{ *baumdat++ = LF; *baumdat++ = LF; }
else
{ *baumdat++ = LF;
nr = s[k].s;
while (nr)
{ *baumdat++ = s[k].v; --nr; }
*baumdat++ = LF; }
if (s[k].t2 == 's') baumAsciiRek(re);
else baumAsciiCpy(re); }
void Baum::baumAsciiCpy(int ast)
{ txt0 = w[ast].st;
do
{ *baumdat = *txt0++;
baumdat++; }
while (*txt0); }]]>
back to
baumC