<![CDATA[//datei-name: equal1.C
#include "baum.h"
// 0xdf: '� 176 : '' 183 : '' 191 : ''
void Baum::gBaum(int k)
{ int i, fAst;
iStruct = glob = iF = 0; stck0 = stack;
shadowRoot = k = shadow(k);
while (stck0 > stack)
{ ast = *--stck0; flag = 0; shadow1(k); } //0
vorScan(k); preCrement(k); postCrement(k); nachScan(k);
gp = int(gStack);
if (s[s[k].sr].v == 'f')
{ for (i = iF - 1; i > 0; i -= 2)
{ k = mintF[i]; fAst = iK = s[k].sr; //1
locals = 0; //2
if (s[fAst].t1 == 's')
{ locals = s[fAst].sl;
paramScan(locals);
locals = s[fAst].sl;
if (i == iF - 1)
{ glob = locals; locals = 0; } }
k = s[fAst].sr; //3
eeScan(k);
fooScan(k);
if (err) return;
m = 0; runVersion(k);
if (err) return;
umbau(fAst, 'r', mint[0], 's');
k = s[fAst].sr; //3
refScan(k);
sizeScan(k);
doLoopScan(k); gotoScan(k);
switchRek(k); brCoScan(k);
Ast = k; retCScan(k); }
slotScan(shadowRoot); }
else mes = 2; }
//0 wort @ kommentar bearbeiten
//1 funktion aus tabelle holen (s[fAst].v : 'f')
//2 locals : deklarationsAst fr lokale (im mainFall globale) variablen
//3 k : funktionsRumpf
int Baum::shadow(int k)
//erzeugt zu einem gegebenen baum einen shadow_baum (rekursiv) u. gibt dessen wurzel zurck
{ int sl, sr, k1; char t1, t2, v;
sl = s[k].sl; sr = s[k].sr; t1 = s[k].t1; t2 = s[k].t2; v = s[k].v;
if (v == '@') //1
{ if (t1 == 's') return shadow(sl);
*stck0++ = k; return k; }
if (t1 == 's') sl = shadow(sl);
else
{ t1 = '?';
if (v == '"')
{ if (t2 == 's' && s[sr].v == 'f')
{ k1 = fScan(sl); //2
if (k1) return k1;
sr = shadow(sr); k1 = sBau(sl, sr, t1, t2, v);
mintF[iF] = sl; ++iF; mintF[iF] = k1; ++iF; return k1; } } }
if (t2 == 's') sr = shadow(sr);
else t2 = '?';
return (sBau(sl, sr, t1, t2, v)); }
//1: fr kommentar nachBearbeitung
//2: verhindert mehrfaches anlegen von funktions_shadows
int Baum::fScan(int name)
{ int i;
for (i = 0; i < iF; i += 2)
{ if (name == mintF[i]) return mintF[i + 1]; }
return 0; }
void Baum::shadow1(int k)
// kommentare ausblenden
{ if (flag) return;
if (s[k].t1 == 's')
{ if (s[k].sl == ast)
{ Ast = s[s[k].sl].sl; umbau(k, 'l', Ast, '?'); flag = 1; }
else shadow1(s[k].sl); }
if (flag) return;
if (s[k].t2 == 's')
{ if (s[k].sr == ast)
{ Ast = s[s[k].sr].sl; umbau(k, 'r', Ast, '?'); flag = 1; }
else shadow1(s[k].sr); } }
void Baum::vorScan(int k)
// (cin, cout, endl, new, foo lab-aufruf) syntax
{ if (s[k].t1 == '?')
{ if (s[k].sl == '!' || s[k].sl == '?')
{ s[k].v = '!';
if (s[k].t2 == 's')
{ setEndl(s[k].sr); vorScan(s[k].sr); }
else if (s[k].sr == 183) s[k].t2 = '!';
return; } }
if (s[k].v == '"')
{ if (s[k].t2 == 's')
{ wrzl = k; k = s [k].sr;
if (s[k].v == 'f') vorScan(s[k].sr);
else if (s[k].v == ' ')
{ if (s[k].t1 == '?' && s[k].sl == '[')
{ s[k].sl = s[wrzl].sl; s[wrzl].sl = new_; s[k].v = '['; }
else if (s[k].t2 == '?' && s[k].sr == '}')
{ s[wrzl].v = '}'; CntrlU(wrzl); abbauLr(wrzl);
if (s[wrzl].t1 == 's') vorScan(s[wrzl].sl); }
else vorScan(k); }
else vorScan(k); }
return; }
//2
if (s[k].v == ' ')
{ worti = s[k].sl;
if (worti == '[')
{ s[k].sl = new_; s[k].v = '"'; anbauRr(k, '1', '?', '['); }
else if (worti == 191 && s[k].t2 == 's') vorScan(s[k].sr);
return; }
if (s[k].t1 == 's') vorScan(s[k].sl);
if (s[k].t2 == 's') vorScan(s[k].sr); }
//1 worti == long_ || worti == short_ kann nicht gecastet werden
/*//2
if (s[k].v == ' ')
{ if (s[k].t1 == 's')
{ if (s[s[k].sl].v == '^') s[k].v = ''; }
else
{ worti = s[k].sl;
if (worti == char_ || worti == int_ || worti == double_ || worti == float_ ||
worti == uchar_ || worti == uint_) s[k].v = ''; //1
else if (worti == '[')
{ s[k].sl = new_; s[k].v = '"'; anbauRr(k, '1', '?', '['); } }
return; } */
//vorScan ->
void Baum::setEndl(int k)
// endline-syntax
{ if (s[k].v == '.')
{ if (s[k].t1 == 's') setEndl(s[k].sl);
else if (s[k].sl == 183) s[k].t1 = '!';
if (s[k].t2 == 's') setEndl(s[k].sr);
else if (s[k].sr == 183) s[k].t2 = '!'; } }
//gBaum ->
void Baum::preCrement(int k)
{ int k1;
if (s[k].v == 'f') k = s[k].sr;
if (s[k].v == '(')
{ li = s[k].sl; typ = s[k].t1; re = s[k].sr;
k1 = sBau(li, 1, typ, ':', *w[re].st);
umbau(k, 'r', k1, 's'); s[k].v = '=';
return; }
if (s[k].t1 == 's') preCrement(s[k].sl);
if (s[k].t2 == 's') preCrement(s[k].sr); }
//gBaum ->
void Baum::postCrement(int k)
// siehe rcs h (postCrement i syntax)
{ int k1, wrzl; char t1;
if (s[k].v == ')')
{ wrzl = s[k].h;
if (s[wrzl].v == '.')
{ if (s[wrzl].sl == k) return;
if (s[k].t2 == 's') postCrement(s[k].sr);
return; }
li = s[k].sl; t1 = s[k].t1; re = s[k].sr;
k1 = sBau(li, 1, t1, ':', *w[re].st);
k1 = sBau(li, k1, t1, 's', '=');
if (s[wrzl].sl == k) umbau(wrzl, 'l', k1, 's');
else umbau(wrzl, 'r', k1, 's');
loop:
holz = s[wrzl].h;
if (! holz) anbauRr(wrzl, k1, 's', '.');
else if (s[holz].v == '.')
{ if (wrzl == s[holz].sl)
{ anbauLr(holz, k1, 's', '.');
s[wrzl].h = s[holz].sl; s[s[holz].sl].h = holz; } //1
else
{ anbauRr(holz, k1, 's', '.');
s[wrzl].h = s[holz].sr; s[s[holz].sr].h = holz; } } //1
else
{ wrzl = holz; goto loop; }
return; }
if (s[k].v == '"' && s[s[k].sr].v == 'f') k = s[s[k].sr].sr;
if (s[k].t1 == 's')
{ li = s[k].sl; s[li].h = k; postCrement(li); }
if (s[k].t2 == 's')
{ re = s[k].sr; s[re].h = k; postCrement(re); } }
//1 wurde durch anbau(umbau) gel�cht
//gBaum ->
void Baum::nachScan(int k)
{ if (s[k].t1 == 's')
{ if (s[k].v == '=')
{ Ast = 0; nachScan1(s[k].sl);
if (Ast)
{ m = 0; nachScan2(s[k].sl);
holz = sBau(mint[0], s[k].sr, 's', s[k].t2, '=');
holz = sBau(Ast, holz, 's', 's', '.');
if (k == s[wrzl].sl) umbau(wrzl, 'l', holz, 's');
else umbau(wrzl, 'r', holz, 's'); }
return; }
wrzl = k; nachScan(s[k].sl); }
if (s[k].t2 == 's')
{ wrzl = k; nachScan(s[k].sr); } }
//nachScan ->
void Baum::nachScan1(int k)
// setzt Ast
{ if (Ast) return;
if (s[k].v == '=')
{ Ast = k; return; }
if (s[k].t1 == 's') nachScan1(s[k].sl);
if (s[k].t2 == 's') nachScan1(s[k].sr); }
//nachScan ->
void Baum::nachScan2(int k)
// legt gleichung neu an (ohne r-wert von Ast)
// benutzt mint u. mchar (index: m)
{ if (s[k].v == '=')
{ mint[m] = s[k].sl; mchar[m] = s[k].t1; ++m; return; }
if (s[k].t1 == 's') nachScan2(s[k].sl);
else
{ mint[m] = s[k].sl; mchar[m] = s[k].t1; ++m; }
if (s[k].t2 == 's') nachScan2(s[k].sr);
else
{ mint[m] = s[k].sr; mchar[m] = s[k].t2; ++m; }
--m; sR = mint[m]; tR = mchar[m];
--m; sL = mint[m]; tL = mchar[m];
mint[m] = sBau(sL, sR, tL, tR, s[k].v); ++m; }
//gBaum ->
void Baum::paramScan(int k)
{ if (s[k].v == '.' || s[k].v == '')
{ paramScan(s[k].sl);
paramScan(s[k].sr); }
else
{ if (s[k].v == ' ' && s[k].t2 == 's' && s[s[k].sr].v == ':') //1
{ wort0 = s[s[k].sr].sl; worti = s[s[k].sr].sr;
refAbbau(s[iK].sr); abbauRr(k); } //2
varSBau(k); } }
//1 referenz
//2 iK = fAst (aufl�ung der demo-version)
//paramScan ->
void Baum::refAbbau(int k)
// aufl�ung der demo-version
{ if (s[k].v == '"' && s[k].t2 == 's' && s[s[k].sr].v == 'f') return;
if (s[k].t1 == 's') refAbbau(s[k].sl);
else if (s[k].sl == worti) umbau(k, 'l', wort0, '?');
if (s[k].t2 == 's') refAbbau(s[k].sr);
else if (s[k].sr == worti) umbau(k, 'r', wort0, '?'); }
//paramScan ->
void Baum::varSBau(int k)
// erzeugt aus einer variablen_deklaration eine initialisierung
{ int k1, dim1, dim2;
if (s[k].v == ' ') //1
{ if (s[k].t1 == '?')
{ if (s[k].sl == ':') return;
typScan(s[k].sl);
if (gTyp)
{ s[k].v = ':';
if (s[k].t2 == '?')
{ s[k].sl = s[k].sr; s[k].t2 = gTyp;
if (gTyp == 'd' || gTyp == 'f')
{ s[k].sr = gp; *((double*)gp) = 0.0; gp += 8; }
else s[k].sr = 0; }
else
{ iS = 0; varSBauRek(s[k].sr); varSSBau();
tlz(k, mintS[0], 's', 's'); } }
else //1A
{ CntrlU(k); s[k].v = 's';
anbauLr(k, gp, '^', ':');
worti = s[k].sr; getAst();
umbau(k, 'r', Ast, 's');
dim1 = s[s[Ast].sr].sr; gp += dim1; } } }
else if (s[k].v == '^') //2
{ if (s[k].t1 == '?')
{ typScan(s[k].sl);
if (s[k].t2 == '?')
{ CntrlU(k); anbauLr(k, 0, '^', ':');
if (gTyp)
{ s[k].v = ':'; umbau(k, 'r', gTyp, '?'); }
else
{ s[k].v = 's';
worti = s[k].sr; getAst();
umbau(k, 'r', Ast, 's'); } }
else
{ iS = 0; varZBauRek(s[k].sr); varSSBau();
tlz(k, mintS[0], 's', 's'); } } }
else if (s[k].v == '"') //3
{ s[k].v = ':';
k1 = s[k].sr;
if (s[k1].v == '[') //4
{ if (s[k1].t1 == '?')
{ typScan(s[k1].sl);
if (gTyp) umbau(k1, 'l', gTyp, '?'); }
else
{ typScan(s[s[k1].sl].sr);
if (gTyp) umbau(s[k1].sl, 'r', gTyp, '?');
else gTyp = '^'; }
if (gTyp)
{ anbauLr(k, gp, '^', ':');
umbau(k, 'r', s[k1].sl, s[k1].t1);
getSize(gTyp);
if (s[k1].t2 == '?')
{ dim1 = atoi(w[s[k1].sr].st);
gp += (datLen * dim1); }
else
{ k1 = s[k1].sr;
dim1 = atoi(w[s[k1].sl].st); dim2 = atoi(w[s[k1].sr].st);
*(int*)gp = dim2; gp += 4; gp += (datLen * dim1 * dim2); } } } }
//5 structfeld
else if (s[k].v == 'S')
{ sum = 0; compScan(s[k].sr);
anbauRr(k, sum, ':', ':'); } }
//1: z.b. S s //2: zeiger //3: label //4: array
// mStruct[iStruct] = k; ++iStruct;
/*//1A if (iStruct)
{ for (i = 0; i < iStruct; ++i)
{ if (s[k].sl == s[mStruct[i]].sl)
{ CntrlU(k); s[k].v = 's';
umbau(k, 'r', mStruct[i], 's');
anbauLr(k, gp, '^', ':');
k1 = s[mStruct[i]].sr;
dim1 = s[k1].sr; gp += dim1; } } } */
/*//5 else
{ if (iStruct)
{ for (i = 0; i < iStruct; ++i)
{ if (s[k1].sl == s[mStruct[i]].sl)
{ s[k].v = 's';
dim1 = atoi(w[s[k1].sr].st);
anbauLr(k, gp, '^', ':');
umbau(k, 'r', s[k1].sl, s[k1].t1);
k1 = s[mStruct[i]].sr; dim2 = s[k1].sr;
gp += (dim1 * dim2); return; } } } } */
void Baum::typScan(int i)
// setzt gTyp
{ gTyp = 0;
if (i == char_) gTyp = 'c';
else if (i == int_) gTyp = 'i';
else if (i == atom_) gTyp = 'A';
else if (i == knot_) gTyp = 'K';
else if (i == back_) gTyp = 'B';
else if (i == uchar_) gTyp = 'C';
else if (i == uint_) gTyp = 'I';
else if (i == long_) gTyp = 'l';
else if (i == ulong_) gTyp = 'L';
else if (i == float_) gTyp = 'f';
else if (i == double_) gTyp = 'd';
else if (i == '^') gTyp = '^'; }
void Baum::getSize(int i)
// setzt datLen
{ if (i == 'c' || i =='C') datLen = 1;
else if (i == 'i' || i =='I' || i == 'l' || i =='L' || i == '^' || i == 'A' || i =='K' || i =='B')
datLen = 4;
else if (i == 'd' || i == 'f') datLen = 8;
else datLen = 0; }
void Baum::varSBauRek(int k)
{ if (s[k].t1 == 's') varSBauRek(s[k].sl);
else
{ mintS[iS] = sBau(s[k].sl, 0, '?', gTyp, ':');
++iS; }
if (s[k].t2 == 's') varSBauRek(s[k].sr);
else
{ mintS[iS] = sBau(s[k].sr, 0, '?', gTyp, ':');
++iS; } }
void Baum::varZBauRek(int k)
{ if (s[k].t1 == 's') varZBauRek(s[k].sl);
else
{ ast = sBau(s[k].sl, 0, '?', '^', ':');
mintS[iS] = sBau(ast, gTyp, 's', '?', ':');
++iS; }
if (s[k].t2 == 's') varZBauRek(s[k].sr);
else
{ ast = sBau(s[k].sr, 0, '?', '^', ':');
mintS[iS] = sBau(ast, gTyp, 's', '?', ':');
++iS; } }
void Baum::varSSBau()
{ int i;
mintS[0] = sBau(mintS[0], mintS[1], 's', 's', '.');
for (i = 2; i < iS; ++i)
{ mintS[0] = sBau(mintS[0], mintS[i], 's', 's', '.'); } }
void Baum::compScan(int k)
// tr�t name, typ und komponenten(name, typ, offset) ein
{ int k1;
if (s[k].v == '.')
{ compScan(s[k].sl); compScan(s[k].sr); return; }
if (s[k].v == ' ')
{ s[k].v = ':'; typScan(s[k].sl);
s[k].t2 = gTyp;
s[k].sl = s[k].sr; s[k].sr = sum;
getSize(gTyp); sum += datLen; }
else //1
{ s[k].v = ':';
k1 = s[k].sr; umbau(k, 'r', sum, ':');
if (s[k1].v == ' ')
{ sum += 4;
if (s[k1].sr == char_ || s[k].sr == uchar_) s[k].t1 = 'p';
else if (s[k1].sr == float_) s[k].t1 = 'f';
else if (s[k1].sr == double_) s[k].t1 = 'D';
else s[k].t1 = 'P'; }
else //2
{ typScan(s[k1].sl); s[k].t1 = gTyp; getSize(gTyp);
if (s[k1].t2 == '?') sum += (datLen * atoi(w[s[k1].sr].st));
else
{ k1 = s[k1].sr; sum += (datLen * atoi(w[s[k1].sl].st) * atoi(w[s[k1].sr].st)); } } } }
//1: label_variable //2: array
void Baum::eeScan(int k)
// l�t += -= *= /= ... auf indem es ':' durch den l-wert ersetzt
{ int sl, sr; unsigned char t1, t2;
sl = s[k].sl; sr = s[k].sr; t1 = s[k].t1; t2 = s[k].t2;
if (s[k].v == '"' && t2 == 's' && s[sr].v == 'f') return;
if (s[k].v == '=' && t2 == 's' && s[sr].t1 == '?' && s[sr].sl == ':')
{ umbau(sr, 'l', sl, t1); return; }
if (t1 == 's') eeScan(sl);
if (t2 == 's') eeScan(sr); }
void Baum::fooScan(int k)
// k = funktionsrumpf (-f->) // worti = name der structInstanz
// locals zeigt an ob ein deklarationsAst vorhanden ist
{ int sl, sr, k1; char t1, t2, v; Ast = 0;
sl = s[k].sl; sr = s[k].sr; t1 = s[k].t1; t2 = s[k].t2; v = s[k].v;
if (v == '.' || v == ',' || v == '=' || v == '[' || v == '+' || v == '-' || v == '' || v == '')
{ if (t1 == 's') fooScan(sl);
else if (t1 == '?') varScanL(k);
if (t2 == 's') fooScan(sr);
else if (t2 == '?') varScanR(k); }
else if (v == '"')
{ if (sl == new_) newF(k);
else
{ if (s[sr].v != 'f') fooScan(sr); } }
else if (v == 'o')
{ if (t1 == '?')
{ worti = sl; getAst();
umbau(k, 'l', Ast, 's'); }
else
{ if (s[sl].t2 == '?') varScanR(sl);
worti = s[sl].sl; getAst();
if (!Ast)
{ err = k; cout << "fooScan-error" << endl; return; }
umbau(sl, 'l', Ast, 's'); } }
else if (v == ' ')
{ if (sl == '"') tlz(k, sr, 's', 't'); //1
else if (sl == '^' && t2 == '?') varScanR(k); //2
else if (sl == 176 || sl == '-' || sl == 191)
{ if( t2 == '?') varScanR(k); //3
else fooScan(sr); }
else
{ castFall(k); //6
if (s[k].v == '')
{ if (t2 == 's') fooScan(sr);
else
{ worti = sr;
getAst(); umbau(k, 'r', Ast, 's'); } } } }
else if (v == '#') //4
{ if (t1 == 's')
{ k1 = k;
while(s[k1].t1 == 's') k1 = s[k1].sl;
worti = s[k1].sl; }
else worti = sl;
getAst();
if (t1 == '?') varScanL(k);
else fooScan(sl); }
else if (v == '^') //6
{ castFall(k);
if (t2 == 's') fooScan(sr);
else
{ worti = sr;
getAst(); umbau(k, 'r', Ast, 's'); } }
else if (v == '!') //7
{ if (t2 == 's') fooScan(sr);
else if (t2 == '?') varScanR(k); }
else
{ if (t1 == 's') fooScan(sl);
else if (t1 == '?' && v != ':') varScanL(k);
if (t2 == 's') fooScan(sr);
else if (t2 == '?') varScanR(k); } }
//1 stringkonstante
//2 reine adresse
//3 dereferenzierung * p
//4 baumoperator #
//5 referenz
//6 cast
//7 cout
void Baum::newF(int k)
// z.b. (S s) oder ([ sP) oder (sZ " ([ 400))
{ k = s[k].sr;
worti = s[k].sl; getAst();
umbau(k, 'l', s[Ast].sl, 's');
if (s[Ast].v == 's')
{ datLen = s[s[s[Ast].sr].sr].sr; }
else getSize(s[Ast].sr);
if (s[k].sr == '1')
{ s[k].sr = datLen; s[k].t2 = ':'; }
else
{ sum = atoi(w[s[k].sr].st);
i = sBau(datLen, sum, ':', ':', '*');
umbau(k, 'r', i, 's'); } }
void Baum::varScanR(int k)
// i : satz mit konstante oder variable
{ unsigned char t;
worti = s[k].sr;
txt0 = w[worti].st;
t = isVal();
if (t)
{ if (strstr(txt0,".") && t == ':')
{ dd = atof(txt0);
dop = (double*) gp;
*dop = dd;
s[k].sr = gp; s[k].t2 = 'd'; //1
gp += 8; }
else
{ s[k].sr = strToVal(txt0); s[k].t2 = t; } }
else
{ getAst();
if (Ast) umbau(k, 'r', Ast, 's');
else if (! noFct(worti))
{ if (! isRek(k, 'r'))
{ if (s[k].v != '')
{ if (worti > cmdStart_ && worti < cmdEnd_)
{ s[k].t2 = 0xdf; s[k].sr = worti - cmdStart_ - 1; } } } } } }
//1: gibt gTyp und gOff zurck
void Baum::getAst()
// setzt worti voraus. prft ob worti eine gltige variable ist (Ast)
{ Ast = 0;
if (locals) varTest(locals);//w
if (! Ast)
{ if (glob) varTest(glob); } }//w
void Baum::varTest(int k)
{ if (! Ast)
{ v = s[k].v;
if (v == ' ' && s[k].t1 == '?' && s[k].sl == ':') return;
if (v == '.' || v == '')
{ varTest(s[k].sl);
if (! Ast) varTest(s[k].sr); }
else if (v == ':')
{ if (s[k].t1 == 's')
{ if (worti == s[s[k].sl].sl) Ast = k; }
else if (worti == s[k].sl) Ast = k; }
else if (v == 's')
{ if (worti == s[s[k].sl].sl) Ast = k; }
else if (v == 'S')
{ if (worti == s[k].sl) Ast = k; } } }
void Baum::varScanL(int k)
// k : satz mit konstante oder variable
{ char t;
worti = s[k].sl;
txt0 = w[worti].st;
t = isVal();
if (t)
{ if (strstr(txt0,".") && t == ':')
{ dd = atof(txt0);
dop = (double*) gp;
*dop = dd;
s[k].sl = gp; s[k].t1 = 'd'; //1
gp += 8; }
else
{ s[k].sl = strToVal(txt0); s[k].t1 = t; } }
else
{ getAst();
{ if (Ast) umbau(k, 'l', Ast, 's');
else if (! noFct(worti))
{ if (! isRek(k, 'l'))
{ if (s[k].t1 == '?')
{ if (s[k].v != '')
{ if (worti > cmdStart_ && worti < cmdEnd_)
{ s[k].t1 = '�; s[k].sl = worti - cmdStart_ - 1; } } } } } } } }
//1: gleitkommakonstante
//2: gibt gTyp und gOff zurck
char Baum::isVal()
// test auf konstante
{ char c, d;
c = *txt0;
if (c == '\'') return '\''; //1
if (c >= '0' && c <= '9') return ':'; //2
d = *(txt0 + 1);
if (c == '0' && d == 'x') return ':'; //3
return 0; }
//1 '_' (zeichen)
//2 dezimalzahl
//3 hexadezimalzahl
char Baum::noFct(int name)
// prft, ob keine interne funktion
{ if (name == '_') return 1;
if (name == '|') return 1;
if (name == 183) return 1; //1
if (name == ':') return 1;
if (name == '+') return 1;
if (name == '-') return 1;
if (name == '?') return 1; //2
if (name == '!') return 1; //2
if (name == 176) return 1;
if (name == '^') return 1;
typScan(name);
if (gTyp) return 1;
return 0; }
//1 ''
//2 ''
char Baum::isRek(int k, char lr)
// k ruft rekursion auf (als linker oder rechter ast)
{ int i, k1;
txt0 = w[worti].st;
if (*txt0 == ':')
{ worti = wortI(txt0 + 1);
for (i = 0; i < iF; i += 2)
{ if (worti == mintF[i])
{ k1 = mintF[i + 1];
if (lr == 'l')
{ s[k].sl = s[k1].sr; s[k].t1 = '@'; } //1
else
{ s[k].sr = s[k1].sr; s[k].t2 = '@'; } //1
return 1; } } }
return 0; }
//1 wird auf f_knoten der rekursion umgebogen
void Baum::castFall(int k)
{ int k1;
k1 = s[k].sl;
if (s[k].v == '^')
{ if (k1 == char_) gTyp = 'p';
else if (k1 == int_) gTyp = 'P';
else gTyp = 'p'; }
else typScan(k1);
if (gTyp)
{ umbau(k, 'l', gTyp, '?'); s[k].v = ''; } }
void Baum::runVersion(int k)
// benutzt mint u. mchar (index: m) li re tLi tRe v . k = s[fAst].sr
{ char v; v = s[k].v;
if (v == '.' || v == ',' || v == ';' || v == '_' || v == '~' || v == '' || v == '}' ||
v == '+' || v == '-' || v == '*' || v == '\\' ||
v == '<' || v == '>' || v == '' || v == '' || v == '?' || v == '' ||
v == '&' || v == '|')
{ if (s[k].t1 == 's') runVersion(s[k].sl);
else
{ mint[m] = s[k].sl; mchar[m] = s[k].t1; ++m; }
if (s[k].t2 == 's') runVersion(s[k].sr);
else
{ mint[m] = s[k].sr; mchar[m] = s[k].t2; ++m; } }
else if (v == '=')
{ adrScan(s[k].sl);
if (err) return;
if (s[k].t2 == 's') runVersion(s[k].sr);
else
{ if (s[k].t2 == 't' && s[s[k].sl].t2 == 'A') s[k].t2 = 'A';
mint[m] = s[k].sr; mchar[m] = s[k].t2; ++m; } }
else if (v == ':')
{ if (s[k].t1 == 's' && s[s[k].sl].v == ':') k = s[k].sl;
mint[m] = k; mchar[m] = 's'; ++m; return; }
else if (v == '[')
{ scanAr(k); return; }
else if (v == 'o')
{ scanS(k); return; }
else if (v == '"')
{ if (s[k].sl == new_)
{ mint[m] = k; mchar[m] = 's'; ++m; }
else
{ mint[m] = s[k].sl; mchar[m] = '?'; ++m;
if (s[k].t2 == 's') runVersion(s[k].sr);
else
{ mint[m] = s[k].sr; mchar[m] = s[k].t2; ++m; }
stackBau(s[k].v); }
return; }
else if (v == 'f' || v == '#')
{ mint[m] = k; mchar[m] = 's'; ++m;
return; }
else if (v == '')
{ adrScan(s[k].sl);
if (err) return;
scanB(k);
if (err) return; }
else if (v == '!' || v == '')
{ mint[m] = s[k].sl; mchar[m] = s[k].t1; ++m;
if (s[k].t2 == 's') runVersion(s[k].sr);
else
{ mint[m] = s[k].sr; mchar[m] = s[k].t2; ++m; } }
else if (s[k].t1 == '?' && s[k].t2 == 's')
{ if (s[k].sl == 176)
{ scanP(s[k].sr); return; }
else if (s[k].sl == '^')
{ k = sBauB(s[k].sr, '^', 's', '?', ':');
mint[m] = k; mchar[m] = 's'; ++m;
return; }
else
{ mint[m] = s[k].sl; mchar[m] = s[k].t1; ++m; runVersion(s[k].sr); } }
else if (v == ' ')
{ mint[m] = s[k].sl; mchar[m] = s[k].t1; ++m;
if (s[k].t2 == 's') runVersion(s[k].sr);
else
{ mint[m] = s[k].sr; mchar[m] = s[k].t2; ++m; } }
if (!(v == '.' || v == ',' || v == ';' || v == '_' || v == '~' || v == '' || v == '}'
|| v == '=' || v == '+' || v == '-' || v == '*' || v == '\\'
|| v == '<' || v == '>' || v == '' || v == '' || v == '?' || v == '' || v == '&' || v == '|'
|| v == '' || v == ' ' || v == '!' || v == ''))
// v == '"' || v == 'f' || v == '#' || v == ':' || v == '[' || v == 'o'
{ err = k; cout << "runVersion: " << v << endl; return; }
stackBau(v); }
/*//0
runVersion(s[k].sl);
if (s[k].t2 == 's') runVersion(s[k].sr);
else
{ if (s[k].t2 == 't' && s[s[k].sl].t2 == 'A') s[k].t2 = 'A';
mint[m] = s[k].sr; mchar[m] = s[k].t2; ++m; }
stackBau(s[k].v); }
*/
//runVersion ->
void Baum::adrScan(int k)
{ while (s[k].t1 == 's')
{ sL = s[k].sl; s[sL].h = k; k = sL; }
if (s[k].sl == 176)
{ scanP(s[k].sr); return; }
sL = k; k = s[k].h;
if (! k)
{ mint[m] = sL; mchar[m] = 's'; ++m; }
else if (s[k].v == ':')
{ Ast = s[k].sr;
k = s[k].h;
if (k)
{ if (s[k].v == '[')
{ sR = s[k].sr;
if (s[k].t2 == 's' && s[sR].v == '.')
{ sR = sBauB(s[sR].sl, s[sR].sr, s[sR].t1, s[sR].t2, '+');
n = *(int*)s[sL].sr; anbauLr(sR, n, ':', '*'); s[sR].v = '+'; }
sL = sBauB(sL, sR, 's', s[k].t2, '+');
sL = sBau(sL, Ast, 's', '?', ':'); }
else if (s[k].v == '+' || s[k].v == '-')
{ sR = s[k].sr;
if (s[k].t2 == 's')
{ runVersion(sR);
--m; sR = mint[m]; }
else sR = s[k].sr;
sL = sBauB(sL, sR, 's', s[k].t2, '+'); } }
mint[m] = sL; mchar[m] = 's'; ++m; }
else if (s[k].v == 's')
{ Ast = s[k].sr;
loop:
k = s[k].h;
if (s[k].v == 'o')
{ worti = s[k].sr; compOff(s[s[Ast].sr].sl);
sL = sBauB(sL, gOff, 's', ':', '+');
mint[m] = sL; mchar[m] = 's'; ++m; }
else if (s[k].v == '[')
{ if (s[k].t2 == ':' && s[k].sr == 0) goto loop;
datLen = s[s[Ast].sr].sr;
sR = sBauB(datLen, s[k].sr, ':', s[k].t2, '*');
k = s[k].h;
if (s[k].v == 'o')
{ worti = s[k].sr; compOff(s[s[Ast].sr].sl);
sR = sBau(sR, gOff, 's', ':', '+'); }
mint[m] = sBau(sL, sR, 's', 's', '+'); mchar[m] = 's'; ++m; }
else
{ mint[m] = sL; mchar[m] = 's'; ++m; } }
else
{ err = k; cout << "adrScan-error" << endl; } }
//rumpelKammer ( runVersion -> scanC
//runVersion|adrScan ->
void Baum::scanP(int k)
{ int kS, kT;
if (s[k].t1 == 's')
{ if (s[k].v == ':')
{ kT = k; k = s[kT].sl;
if (s[k].t1 == '?' && (s[k].t2 == '^' || s[k].t2 == 'A'))
{ mint[m] = kT; mchar[m] = 's'; ++m; } }
else if (s[k].v == '#')
{ k = sBauB(k, 'c', 's', '?', ':');
mint[m] = k; mchar[m] = 's'; ++m; }
else
{ kS = k; kT = s[kS].sl;
if (s[kT].t1 == 's')
{ k = s[kT].sl;
if (s[k].t1 == '?' && s[k].t2 == '^')
{ kS = sBauB(k, s[kS].sr, 's', s[kS].t2, s[kS].v);
runVersion(kS); --m; kS = mint[m];
k = sBauB(kS, s[kT].sr, 's', s[kT].t2, ':');
mint[m] = k; mchar[m] = 's'; ++m; } } } } }
//runVersion ->
void Baum::scanAr(int k)
{ int kL, kR, kLL, kLR; char tR;
if (s[k].t1 == 's')
{ kL = s[k].sl; kR = s[k].sr; tR = s[k].t2;
if (s[kL].t1 == 's' && s[kL].t2 == '?')
{ kLL = s[kL].sl; kLR = s[kL].sr;
if (tR == 's')
{ if (s[kR].v == '.')
{ s[kR].v = '+';
n = *(int *)s[kLL].sr;
anbauLr(kR, n, ':', '*'); }
runVersion(kR); kR = mint[--m]; }
getSize(kLR);
if (datLen)
{ if (datLen > 1)
{ kR = sBau(kR, datLen, tR, ':', '*'); tR = 's'; } }
kL = sBauB(kLL, kR, 's', tR, '[' );
k = sBauB(kL, kLR, 's', '?', ':'); }
mint[m] = k; mchar[m] = 's'; ++m; } }
//runVersion ->
void Baum::scanS(int k)
{ while (s[k].t1 == 's')
{ sL = s[k].sl; s[sL].h = k; k = sL; }
sL = k; k = s[k].h; Ast = s[k].sr;
loop:
k = s[k].h;
if (s[k].v == 'o')
{ worti = s[k].sr; compOff(s[s[Ast].sr].sl);
sL = sBauB(sL, gOff, 's', ':', '+'); }
else
{ if (s[k].t2 == ':' && s[k].sr == 0) goto loop;
datLen = s[s[Ast].sr].sr;
sR = sBauB(datLen, s[k].sr, ':', s[k].t2, '*');
k = s[k].h;
worti = s[k].sr; compOff(s[s[Ast].sr].sl);
sR = sBauB(sR, gOff, 's', ':', '+');
sL = sBauB(sL, sR, 's', 's', '+'); }
mint[m] = sBauB(sL, worti, 's', '?', ':'); mchar[m] = 's'; ++m; }
//scanS ->
void Baum::compOff(int k)
// setzt gTyp und gOff
{ if (s[k].v == ':')
{ if (worti == s[k].sl)
{ gTyp = s[k].t2; gOff = s[k].sr; } }
else
{ compOff(s[k].sl);
compOff(s[k].sr); } }
//runVersion ->
void Baum::scanB(int k)
{ if (s[s[k].sr].v != '')
{ lenScan(s[k].sr);
anbauRr(k, datLen, ':', ''); }
adrScan(s[k].sr);
sR = s[k].sr;
mint[m] = s[sR].sr; mchar[m] = s[sR].t2; ++m;
stackBau(''); }
//scanB ->
void Baum::lenScan(int k)
{ while (s[k].t1 == 's')
{ sL = s[k].sl; s[sL].h = k; k = sL; }
k = s[k].h;
if (s[k].v == 's')
{ Ast = s[k].sr;
datLen = s[s[Ast].sr].sr; }
else
{ datLen = 0; } }
//runVersion ->
void Baum::stackBau(char v)
{ --m; re = mint[m]; tRe = mchar[m]; --m; li = mint[m]; tLi = mchar[m];
mint[m] = sBauB(li, re, tLi, tRe, v); mchar[m] = 's'; ++m; }
int Baum::sBauB(int sl, int sr, char t1, char t2, char v)
{ SBau(sl, sr, t1, t2, v);
if (t1 == 's')
{ rzp = &(s[sl].b); neuRz(satz0); }
if (t2 == 's')
{ rzp = &(s[sr].b); neuRz(satz0); }
return satz0; }
void Baum::refScan(int k)
{ if (s[k].v == '"' && s[k].t2 == 's' && s[s[k].sr].v == 'f') return;
if (s[k].v == '}')
{ if (s[k].t2 == 's')
{ sL = s[k].sl; s[sL].h = 0;
while (s[sL].v == '.')
{ wrzl = sL; sL = s[sL].sl; s[sL].h = wrzl; }
iK = s[s[k].sr].sr; sR = s[iK].sl; s[sR].s = iK; //1
if (s[sR].v == '')
{ wrzl = sR; sR = s[sR].sl; s[sR].s = wrzl;
if (s[sR].v == '')
{ wrzl = sR; sR = s[sR].sl; s[sR].s = wrzl; } }
while (s[sR].v == '.')
{ wrzl = sR; sR = s[sR].sl; s[sR].s = wrzl; }
loop:
if (s[sR].sl == ':')
{ wort0 = s[sL].sl; worti = s[sR].sr;
refAbbau(s[iK].sr);
wrzl = s[sR].s; K = s[sL].h;
if (sR == s[wrzl].sl) umbau(wrzl, 'l', sL, 's');
else umbau(wrzl, 'r', sL, 's');
s[sL].h = K; sR = sL; s[sR].s = wrzl; }
loop1:
wrzl = s[sL].h;
if (wrzl)
{ sR = s[sR].s;
if (sL == s[wrzl].sr)
{ sL = wrzl; goto loop1; }
sL = s[wrzl].sr; s[sL].h = wrzl;
wrzl = sR; sR = s[sR].sr; s[sR].s = wrzl;
goto loop; } }
return; }
if (s[k].t1 == 's') refScan(s[k].sl);
if (s[k].t2 == 's') refScan(s[k].sr); }
//1 iK = fAst
void Baum::sizeScan(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 (s[k].v == '"' && t2 == 's' && s[sr].v == 'f') return;
if (s[k].v == '[')
{ s[k].v = '+'; return; }
if (t1 == 's')
{ if (s[k].v == '+' || s[k].v == '-') //1
{ if (s[sl].v == ':' && s[sl].t1 == '?' && s[sl].t2 == '^')
{ if (s[k].s == 1) return;
worti = s[sl].sl;
getAst(); getSize(s[Ast].sr);
if (datLen > 1)
{ if (s[k].t2 == ':' && s[k].sr == 1) umbau(k, 'r', datLen, ':');
else anbauRr(k, datLen, ':', '*'); }
s[k].h = 1; return; } }
sizeScan(sl); }
if (t2 == 's') sizeScan(sr); }
void Baum::doLoopScan(int k)
{ loop:
stck0 = stack;
doScan(k);
if (stck0 > stack) goto loop; }
void Baum::doScan(int k)
{ int sl, sr; char t1, t2;
loop:
sl = s[k].sl; sr = s[k].sr; t1 = s[k].t1; t2 = s[k].t2;
if (t1 == '?' && t2 == '?')
{ if (s[k].v == ' ' && sl == do_)
{ ast = k;
loop1:
if (stck0 == stack) return;
k = *--stck0;
if (s[k].v == '"' && s[k].sl == sr)
{ s[ast].t2 = ':'; s[ast].sr = k; s[ast].v = '{'; return; }
else goto loop1; }
loop2:
if (stck0 == stack) return;
Ast = *--stck0;
if (k == s[Ast].sl && k != s[Ast].sr)
{ if (s[Ast].t2 == 's')
{ *stck0++ = Ast; k = s[Ast].sr; goto loop; } }
k = Ast; goto loop2; }
if (t1 == 's')
{ *stck0++ = k; k = sl; goto loop; }
if (t2 == 's' && s[sr].v != 'f')
{ *stck0++ = k; k = sr; goto loop; }
goto loop2; }
// setzt stck0 voraus;
void Baum::gotoScan(int k)
{ loop:
flag = 0; worti = 0;
goRek(k);
if (flag)
{ flag = 0;
toRek(k);
goto loop; } }
void Baum::goRek(int k)
{ if (flag) return;
if (s[k].v == ' ' && s[k].t1 == '?' && s[k].t2 == '?')
{ if(s[k].sl == do_ || s[k].sl == goto_)
{ worti = s[k].sr; ast = k; flag = 1; }
return; }
if (s[k].v == '"' && s[k].t2 == 's' && s[s[k].sr].v == 'f') return;
if (s[k].t1 == 's') goRek(s[k].sl);
if (s[k].t2 == 's') goRek(s[k].sr); }
void Baum::toRek(int k)
{ if (flag) return;
if (s[k].v == '"' && s[k].t2 == 's')
{ if (s[k].sl == worti)
{ s[ast].t2 = ':'; s[ast].sr = k; s[ast].v = '{'; flag = 1; return; }
if (s[s[k].sr].v == 'f') return; }
if (s[k].t1 == 's') toRek(s[k].sl);
if (s[k].t2 == 's') toRek(s[k].sr); }
void Baum::switchRek(int k)
{ if (s[k].v == '"')
{ if (s[k].t2 != 's') return;
if (s[s[k].sr].v == 'f') return;
if (s[k].sl == switch_) switch1(s[k].sr); }
if (s[k].t1 == 's') switchRek(s[k].sl);
if (s[k].t2 == 's') switchRek(s[k].sr); }
void Baum::switch1(int k)
{ re = s[k].sr; typ = s[k].t2;
if (typ == 's' && s[re].t1 == '?' && s[re].sl == then_) umbau(k, 'r', s[re].sr, s[re].t2);
if (s[k].t1 == 's') switch1(s[k].sl);
if (s[k].t2 == 's') switch1(s[k].sr); }
void Baum::brCoScan(int k)
{ if (s[k].v == '{') return;
if (s[k].v == '"')
{ if (s[k].t2 != 's') return;
if (s[s[k].sr].v == 'f') return;
if (s[k].sl == while_do || s[k].sl == do_while || s[k].sl == for_do)
{ Ast = k; brCo1(s[k].sr); } }
if (s[k].t1 == 's') brCoScan(s[k].sl);
if (s[k].t2 == 's') brCoScan(s[k].sr); }
void Baum::brCo1(int k)
{ if (s[k].v == '"' && s[k].t2 == 's' && s[s[k].sr].v == 'f' || s[k].v == '{') return;
if (s[k].t1 == 's') brCo1(s[k].sl);
if (s[k].t2 == 's') brCo1(s[k].sr);
else if (s[k].t2 == '?' && (s[k].sr == '|' || s[k].sr == '_')) anbauRr(k, Ast, ':','{'); }
void Baum::retCScan(int k)
{ if (s[k].v == '"' && s[k].t2 == 's' && s[s[k].sr].v == 'f' || s[k].v == '{') return;
if (s[k].t1 == 's') retCScan(s[k].sl);
if (s[k].t2 == 's') retCScan(s[k].sr);
else if (s[k].t2 == '?' && s[k].sr == 183) anbauRr(k, Ast, ':','{'); }
void Baum::slotScan(int k)
// baut addSlot bzw. delSlot um (eingebundenen funktionsknoten in konstante)
{ int sl, sr; unsigned char t1, t2;
sl = s[k].sl; sr = s[k].sr; t1 = s[k].t1; t2 = s[k].t2;
if (s[k].v == '}' && t2 == 0xdf) //1
{ if (s[k].sr == (addSlot_ - cmdStart_ - 1) || s[k].sr == (delSlot_ - cmdStart_ - 1)) umbau(k, 'l', sr, ':'); }
else
{ if (t1 == 's') slotScan(sl);
if (t2 == 's') slotScan(sr); } }]]>
back to
baumC