<![CDATA[//datei-name: tool.C
#include "baum.h"
void Baum::muster(int Root, char Typ)
{ int rzi; char lc;
if (rTyp == 'w')
{ rzi = w[root].b;
if (! rzi)
{ mes = 2; return; }
loop:
rSatz = r[rzi].zS;
if (Root == rSatz) //0
{ mes = 2; return; }
if (s[rSatz].v == ':')
{ lc = loc; loc = CPYLOC;
re = copyB(s[rSatz].sr); //1
loc = lc; baumLoc(re); }
else
{ rzi = r[rzi].zz;
if (rzi) goto loop;
else
{ mes = 9; return; } } }
else re = root; //2
interface(re);
muster1(re); mNr++; nr = mNr; mNr *= sizeof(int);
root = Root; rTyp = Typ; }
//0 muster kann nicht auf sich selbst angewandt werden
//1 muster_name : muster(re) als l�ch-version
//2 re: muster
int Baum::copyB(int i)
{ int sl, sr;
if (s[i].t1 != 's') sl = s[i].sl;
else sl = copyB(s[i].sl);
if (s[i].t2 != 's') sr = s[i].sr;
else sr = copyB(s[i].sr);
return sBau(sl, sr, s[i].t1, s[i].t2, s[i].v); }
// erzeugt zu einem gegebenen baum einen loc_baum (rekursiv) u. gibt dessen wurzel zurck
void Baum::interface(int i)
{ if (s[i].t1 == 's') interface(s[i].sl);
else
{ txt0 = w[s[i].sl].st; interface1(); }
if (s[i].t2 == 's') interface(s[i].sr);
else
{ txt0 = w[s[i].sr].st; interface1(); } }
void Baum::interface1()
{ if (*txt0 == '?')
{ a = *(txt0 + 1);
if (! a) *txt0 = '';
else if (a == '?')
{ *txt0 = '';
if (*(txt0 + 2) == '?') *txt0 = ''; }
else if (a >= 'A' && a <= 'Z')
{ *txt0 = ''; a -= 0x10; *(txt0 + 1) = a; }
else if (a >= 'a' && a <= 'z')
{ *txt0 = ''; a -= 0x30; *(txt0 + 1) = a; }
else if (a >= '1' && a <= '9') *txt0 = ''; } }
void Baum::muster1(int i)
{ *stck0++ = 0; typ = 's'; mNr = 0;
loop:
if (typ == 's')
{ if (! musterL(i))
{ if (! musterR(i)) *stck0++ = i;
typ = s[i].t1; i = s[i].sl; goto loop; }
if (! musterR(i))
{ typ = s[i].t2; i = s[i].sr; goto loop; } }
i = *--stck0;
if (i)
{ typ = s[i].t2; i = s[i].sr; goto loop; } }
// schnelle iteration, packt zwischenwerte zwischenzeitlich auf stack
char Baum::musterL(int i)
{ int wert; char a;
if (s[i].t1 == 'w')
{ ast = s[i].sl;
txt0 = w[ast].st; a = *txt0++;
if (a == '' || a == '' || a == '')
{ if (*txt0)
{ wAb(i); s[i].t1 = a;
wert = atoi(txt0); s[i].sl = wert;
if (wert > mNr) mNr = wert; //1
return 1; }
else
{ if (a == '') s[i].t1 = '1';
else if (a == '') s[i].t1 = '2';
else s[i].t1 = '3';
s[i].sl = 0; } } }
return 0; }
// ersetztz n durch typ und n
//1 mNr : stacktiefe (zum saubermachen)
void Baum::wAb(int i)
{ rzp = &w[ast].b; modify0(i); rzi = *rzp;
*rzp = r[rzi].zz; r[rzi] = r[ENDRL];
if (rzl0 > rzi) rzl0 = rzi; }
// nimmt ast (wort) aus baum
char Baum::musterR(int i)
{ int wert; char a;
if (s[i].t2 == 'w')
{ ast = s[i].sr;
txt0 = w[ast].st; a = *txt0++;
if (a == '' || a == '' || a == '')
{ if (*txt0)
{ wAb(i); s[i].t2 = a;
wert = atoi(txt0); s[i].sr = wert;
if (wert > mNr) mNr = wert; //1
return 1; }
else
{ if (a == '') s[i].t2 = '1';
else if (a == '') s[i].t2 = '2';
else s[i].t2 = '3';
s[i].sr = 0; } } }
return 0; }
// ersetztz n durch typ und n
//1 mNr : stacktiefe (zum saubermachen)
void Baum::musterung()
{ stck0 = stack;
muster2(root);
baumLoc(root);
if (stck0 == stack)
{ mes = 2; return; }
*stck0 = 0; stck1 = stck0; stck0 = stack;
ZBaum(); rTyp = 's'; root = *stck0;
if (root) baumLoc(root);
}
void Baum::muster2(int i)
{ if (s[i].v == '"' && s[i].sl == '#') return;
memset(stck1, 0, 4*mNr); memset(stck2, 0, 4*mNr); memset(stck3, 0, 4*mNr);
if (match(i, re, 's', 's'))
{ if (! da(i)) *stck0++ = i; } //1
else
{ if (s[i].t1 == 's') muster2(s[i].sl);
if (s[i].t2 == 's') muster2(s[i].sr); } }
//1 *stck0++ = match (l�ung auf stack)
char Baum::da(int i)
{ int* stp; stp = stack;
while (stp < stck0)
{ if (i == *stp++) return 1; }
return 0; }
//wenn noch nicht da, l�ung auf stack
char Baum::match(int k, int kM, char t, char tM )
{ if (tM == '3') return 1;
if (tM == '')
{ if (! *(stck3 + kM))
{ *(stck3 + kM) = k;
*(cstck3 + kM) = t;
return 1; }
if (*(stck3 + kM) == k && *(cstck3 + kM) == t) return 1;
return 0; }
if (t == 's')
{ if (tM == '2') return 1;
if (tM == '')
{ if (! *(stck2 + kM))
{ *(stck2 + kM) = k;
return 1; }
if (*(stck2 + kM) == k) return 1;
return 0; }
if (tM == 's')
{ if (k == kM) return 1;
if (s[k].v == s[kM].v || s[kM].v == '')
{ if (match(s[k].sl, s[kM].sl, s[k].t1, s[kM].t1))
{ if (match(s[k].sr, s[kM].sr, s[k].t2, s[kM].t2)) return 1; } }
return 0; } }
if (t == 'w')
{ if (tM == '1') return 1;
if (tM == '')
{ if (! *(stck1 + kM))
{ *(stck1 + kM) = k;
return 1; }
if (*(stck1 + kM) == k) return 1; }
if (tM == 'w' && k == kM) return 1; }
return 0; }
// i : original a j : muster d matchen?/*
//************************************************************************
void Baum::transform(int k)
{ if (s[k].v != '')
{ stckload(k, re1, 's', 's'); fill(re);
tlz(k, s[re].s, 's', 's'); return; }
if (s[k].t1 == 's') transform(s[k].sl);
if (s[k].t2 == 's') transform(s[k].sr); }
void Baum::stckload(int k, int kM, char t, char tM )
{ if (tM == '')
{ *(stck3 + kM) = k; *(cstck3 + kM) = t; }
else if (tM == '')
{ if (tM == '') *(stck2 + kM) = k; }
else if (tM == '') *(stck1 + kM) = k;
else if (t == 's' && tM == 's')
{ stckload(s[k].sl, s[kM].sl, s[k].t1, s[kM].t1);
stckload(s[k].sr, s[kM].sr, s[k].t2, s[kM].t2); } }
void Baum::fill(int k)
{ if (s[k].t1 == 's') fill(s[k].sl);
if (s[k].t2 == 's') fill(s[k].sr);
tL = s[k].t1; sL = s[k].sl;
if (tL == '')
{ tL = *(cstck3 + sL); sL = *(stck3 + sL); }
else if (tL == '')
{ sL = *(stck2 + sL); tL = 's'; }
else if (tL == '')
{ sL = *(stck1 + sL); tL = 'w'; }
else if (tL == 's')
{ sL = s[sL].s; tL = 's'; }
sR = s[k].sr; tR = s[k].t2;
if (tR == '')
{ tR = *(cstck3 + sR); sR = *(stck3 + sR); }
else if (tR == '')
{ sR = *(stck2 + sR); tR = 's'; }
else if (tR == '')
{ sR = *(stck1 + sR); tR = 'w'; }
else if (tR == 's')
{ sR = s[sR].s; tR = 's'; }
s[k].s = sBau(sL, sR, tL, tR, s[k].v); }
// baut s[k].s (l�ungsbaum) auf
//-------------------------------------------------------------------
void Baum::o1baum()
{ int i;
*stck0++ = 0;
loop:
if (typ == 's')
{ if (s[ast].v == ' ')
{ if (t4ast(ast))
{ i = t4satz(ast); tlz(ast, i, 's', 's'); } }
else
{ *stck0++ = ast; typ = s[ast].t1; ast = s[ast].sl; goto loop; } }
ast = *--stck0;
if (ast)
{ typ = s[ast].t2; ast = s[ast].sr; goto loop; } }
char Baum::t4ast(int i)
{ if (s[i].t1 == 's' && s[i].t2 == 'w')
{ baumi = s[i].sl;
if (s[baumi].t1 == 'w' && s[baumi].t2 == 'w') return 1; }
return 0; }
int Baum::t4satz(int i)
{ int i1;
i1 = sBau(s[baumi].sr, s[i].sr, 'w', 'w', s[i].v);
return (sBau(s[baumi].sl, i1, 'w', 's', s0.v)); }]]>
back to
baumC