<![CDATA[//datei-name: run.C
#include "baum.h"
void Baum::run(int k)
{ varI = 0; forFlag = 0;
iG = 0; rekI = 0;
if (s[k].t2 == 's' && s[k].v == '"')
{ k = s[k].sr;
if (s[k].v == 'f')
{ iR = k; typ = s[iR].t2; iK = s[iR].sr;
fWert(); } } } //1
//1 hier fängt der blinde affe an nach der banane zu suchen
//run ->
void Baum::fWert()
// zentraler befehlsverteiler
{ loop:
if (iR)
{ if (typ == 's')
{ s[iK].h = iR;
iR = iK;
kontiniu:
switch (s[iR].v)
{ case '=':
*stck4++ = iR; zuweis(iR); iK = *--stck4;
if (err) return;
break;
case '"':
labFall(iR); goto loop;
case '}':
fctFall(iR); goto loop;
case '{':
iK = s[iR].sr; //1
if (s[iR].sl == do_ || s[iR].sl == goto_) //2
{ typ = s[iK].t2; iR = s[iK].sr;
goto kontiniu; }
else if (s[iR].sl == 183 || s[iR].sl == '|') break;
else
{ iR = iK; s[iR].s = 1; goto kontiniu; }
case '!':
if (s[iR].sl == '?') cinFall(s[iR].sr);
else if (s[iR].t2 == '!') cout << endl;
else
{ *stck4++ = iR; coutFall(s[iR].sr, s[iR].t2); iK = *--stck4; }
break;
case '¢':
*stck4++ = iR; byteCopy(iR); iK = *--stck4; break;
default:
typ = s[iR].t1; iK = s[iR].sl;
goto loop; }
if (err) return; }
else
{ if (typ == '@')
{ ++s[iK].s; rekStack[rekI] = iR; ++rekI; //3
fAst(iK); } //4
else if (typ == 'ß')
{ (this->*func[iK])(); iK = iR; }
else if (iK == 183)
{ cout << endl; iK = iR; }
else
{ err = iR; cout << "fWert: unerwartete syntax" << endl; return; } } }
down:
iR = s[iK].h;
if (! iR) return;
if (iK == s[iR].sl)
{ if (s[iR].v == '·')
{ iK = iR; goto down; } //5
if (s[iR].v == '_' || s[iR].v == '~')
{ if (varWert[varI])
{ typ = s[iR].t2; iK = s[iR].sr; goto loop; }
iK = iR; goto down; }
if (s[iK].v == '|')
{ iK = iR; goto down; }
if (s[iR].v == ';')
{ if (s[iR].t2 == 's') sWert(s[iR].sr);
else eWert(s[iR].sr, s[iR].t2);
if (err) return;
--varI; convTyp(varI, 'i');
if (varWert[varI])
{ typ = s[iR].t1; iK = s[iR].sl; goto loop; }
iK = iR; goto down; }
typ = s[iR].t2; iK = s[iR].sr; goto loop; }
iK = iR;
if (s[iR].v == '_')
{ iR = s[iK].h; whileFall(iK); goto loop; }
if (s[iR].v == '~')
{ iR = s[iK].h; forDo(iK); goto loop; }
if (s[iR].v == 'f')
{ if (s[iR].s)
{ --s[iR].s;
iK = s[iR].sl;
if (s[iK].v == '·') iK = s[iK].sl;
popRek(iK); return; } }
goto down; }
//1 baumZauber: springt nach knoten iK
//2 baumZauber: gotoAusführung
//3 iK wird von switch (s[iR].v gesetzt bei typ != 's'
//4 rekursionsAufruf (iK : fAst von funktion)
//5 else-fall überspringen
//6 automatischer break-fall
//fWert|sWert ->
void Baum::zuweis(int k)
// von rechts nach links
{ if ( s[k].t2 == 's') sWert(s[k].sr); //1
else eWert(s[k].sr, s[k].t2); //1
if (err) return;
lWert(s[k].sl); //2
if (err) return;
setWert(); } //3
//1: setzt varWert und varTyp
//2: setzt gTyp u. gStack_adresse(offset)
//3: weist einer gStack_adresse (letzter varWert) den vorletzten varWert zu
//fWert|sWert ->
void Baum::byteCopy(int k)
// weist ziel-adresse i bytes von quell-adresse zu (von rechts nach links)
{ char* q, * p; int i;
sR = s[k].sr;
sWert(s[sR].sl); //1
if (err) return;
sWert(s[k].sl); //2
if (err) return;
if (s[sR].t2 == 's') sWert(s[sR].sr); //3
else eWert(s[sR].sr, s[sR].t2); //3
if (err) return;
--varI; i = varWert[varI];
--varI; p = (char*)varWert[varI];
--varI; q = (char*)varWert[varI];
memcpy(p, q, i); }
//1: setzt quell-adresse
//2: setzt ziel-adresse
//3: setzt byte.anzahl
//zuweis|sWert ->
void Baum::lWert(int k)
// berechnet adresse (adr)
{ if (s[k].v == ':')
{ if (s[k].t1 == '?')
{ varWert[varI] = int(& s[k].sr);
varTyp[varI] = '^'; gTyp = s[k].t2;
++varI; }
else
{ sWert(s[k].sl); varTyp[varI - 1] = '^'; gTyp = s[k].sr; } }
else if (s[k].v == '#') baumAdr(k);
else sWert(k); }
//lWert ->
void Baum::baumAdr(int k)
// die adresse, an der eine strukturKomponente steht
{ int i, sl, sr; char t;
sl = s[k].sl; sr = s[k].sr; t = s[k].t1;
if (t == 's')
{ if (s[sl].v == ':')
{ t = s[sl].t2; i = s[sl].sr; }
else if (s[sl].v == '#')
{ baumFall(sl); --varI; t = varTyp[varI]; i = varWert[varI]; } }
else { err = k; cout << "baumAdr-err" << endl; return; }
gTyp = 'i';
switch(t)
{ case 'A':
varTyp[varI] = 'P';
if (sr == st_)
{ varWert[varI] = int(& w[i].st); gTyp = 'p'; }
else if (sr == wl_) varWert[varI] = int(& w[i].wl);
else if (sr == wr_) varWert[varI] = int(& w[i].wr);
else if (sr == b_) varWert[varI] = int(& w[i].b);
else
{ err = k; cout << "baumAdr: falsche atomKomponente" << endl; return; }
break;
case 'K':
if (sr == sl_)
{ if (s[i].t1 == 's' || s[i].t1 == '?') varTyp[varI] = 'P';
else varTyp[varI] = '^';
varWert[varI] = int(& s[i].sl); }
else if (sr == sr_)
{ if (s[i].t2 == 's' || s[i].t2 == '?') varTyp[varI] = 'P';
else varTyp[varI] = '^';
varWert[varI] = int(& s[i].sr); }
else
{ varTyp[varI] = 'p'; gTyp = 'c';
if (sr == t1_) varWert[varI] = int(& s[i].t1);
else if (sr == t2_) varWert[varI] = int(& s[i].t2);
else if (sr == 'v') varWert[varI] = int(& s[i].v);
else if (sr == lc_) varWert[varI] = int(& s[i].lc);
else
{ varTyp[varI] = 'P'; gTyp = 'i';
if (sr == b_) varWert[varI] = int(& s[i].b);
else if (sr == h_) varWert[varI] = int(& s[i].h);
else if (sr == s_) varWert[varI] = int(& s[i].s);
else cout << "baumAdr: falsche knotKomponente in zuweisung" << endl; } }
break;
case 'B':
varTyp[varI] = 'P';
if (sr == zS_) varWert[varI] = int(& r[i].zS);
else if (sr == zz_) varWert[varI] = int(& r[i].zz);
else cout << "baumAdr: falsche backKomponente in zuweisung " << endl;
break;
default: cout << "baumAdr: falscher baumvariablentyp: " << varTyp[varI] << " ~ " << t << endl;
return; }
++varI; }
//zuweis ->
void Baum::setWert()
// weist einer gStack_adresse (letzter varWert) den vorletzten varWert zu . setzt gTyp voraus .
{ char t; int locGp;
--varI; locGp = varWert[varI];
--varI; convTyp(varI, gTyp); t = varTyp[varI];
if (t == 'c' || t == C) *(char*)locGp = varWert[varI];
else *(int*)locGp = varWert[varI]; }
//fWert|fctFall ->
void Baum::labFall(int k)
{ int sl, sr; char t2;
sl = s[k].sl; sr = s[k].sr; t2 = s[k].t2;
if (t2 == 's' && s[sr].v == 'f')
{ s[sr].h = 0; *stck4++ = k; fAst(sr); fWert(); iK = *--stck4; }
else if (sl == if_then)
{ s[sr].h = k; ifFall(sr); }
else if (sl == while_do)
{ s[sr].h = k; whileFall(sr); }
else if (sl == for_do)
{ s[sr].h = k;
if (s[k].s) s[k].s = 0;
else s[s[s[sr].sl].sl].v = '¬';
forDo(sr); }
else if (sl == switch_)
{ s[sr].h = k; switchFall(sr); }
else if (sl == do_while)
{ iR = k; typ = s[iR].t2; iK = s[iR].sr; }
else if (sl == new_)
{ newFall(sr); iR = 0; }
else
{ typ = s[iR].t2; iK = s[iR].sr; } }
//labFall ->
void Baum::ifFall(int k)
{ if (s[k].t1 == 's') sWert(s[k].sl);
else eWert(s[k].sl, s[k].t1);
if (err) return;
--varI; convTyp(varI, 'i');
if (varWert[varI])
{ iR = k; typ = s[iR].t2; iK = s[iR].sr; }
else
{ iK = s[k].h; k = s[iK].h;
if (s[k].v == '·')
{ iR = k; typ = s[iR].t2; iK = s[iR].sr; }
else iR = 0; } }
//ifFall ->
void Baum::switchFall(int k)
{ int k1;
sWert(s[k].sl);
if (err) return;
k1 = s[k].sr;
if (s[k1].v == '"')
{ doCase(s[k1].sr);
iR = 0; iK = 0; }
else if (doCase(s[s[k1].sl].sr))
{ iR = 0; iK = k; }
else //1
{ s[k1].h = k;
iR = k1; typ = s[iR].t2; iK = s[iR].sr; }
--varI; }
//1 default-fall
//switchFall ->
char Baum::doCase(int k)
{ if (s[k].v == '.')
{ if (doCase(s[k].sl)) return 1;
if (doCase(s[k].sr)) return 1; }
else if (doCaseK(k))
{ iR = k; typ = s[iR].t2; iK = s[iR].sr;
s[iR].h = 0; fWert(); return 1; }
return 0; }
//doCase ->
char Baum::doCaseK(int k)
{ if (s[k].t1 == ':')
{ eWert(s[k].sl, ':');
--varI;
if (varWert[varI] == varWert[varI - 1]) return 1; }
else if (doCaseRek(s[k].sl)) return 1;
return 0; }
//doCaseK ->
char Baum::doCaseRek(int k)
{ if (s[k].v == '.')
{ if (s[k].t1 == ':')
{ eWert(s[k].sl, ':');
--varI;
if (varWert[varI] == varWert[varI - 1]) return 1; }
else if (doCaseRek(s[k].sl)) return 1;
if (s[k].t2 == ':')
{ eWert(s[k].sr, ':');
--varI;
if (varWert[varI] == varWert[varI - 1]) return 1; }
else if (doCaseRek(s[k].sr)) return 1; }
else
{ sWert(k); --varI;
if (varWert[varI] == varWert[varI - 1]) return 1; }
return 0; }
//labFall ->
void Baum::newFall(int k)
{ s[s[k].sl].sr = gp;
if (s[k].t2 == 's') sWert(s[k].sr);
else eWert(s[k].sr, ':');
--varI; gp += varWert[varI]; }
//fWert ->
void Baum::coutFall(int k, char t)
{ if (t == 's')
{ if (s[k].v == '.')
{ coutFall(s[k].sl, s[k].t1);
coutFall(s[k].sr, s[k].t2); }
else if (s[k].sr == '"') cout << (char*)(s[s[k].sl].sr);
else if (s[k].t2 == 'c') cout << char(s[k].sr);
else
{ sWert(k);
if (err) return;
if (err) return;
--varI; wertAusgabe(varI); } }
else
{ if (k == 183) cout << endl; //1
else if (t == 't' || t == '\'') cout << w[k].st; } }
//1 183 : '·'
//coutFall ->
void Baum::wertAusgabe(int i)
// gibt den letzten varWert aus
{ switch(varTyp[i])
{ case 'p':
cout << (char*)varWert[i]; break;
case 'c':
cout << char(varWert[i]); break;
case 'C':
cout << (unsigned char)varWert[i]; break;
case 'i': case 'l': case '^': case 'P': case 'A': case 'K': case 'B':
cout << varWert[i]; break;
case 'I': case 'L':
cout << (unsigned int)varWert[i]; break;
case 'D':
cout << (double*)varWert[i]; break;
case 'd': case 'f':
dop = (double*)varWert[i]; cout << *dop; break;
default:
cout << "wertAusgabe: falscher typ " << varTyp[i] << endl; } }
//labFall ->
void Baum::cinFall(int adr)
{ char t; char* p;
char c; unsigned char uc; int i; unsigned int ui;
t = s[adr].t2;
if (t == 'c')
{ cin >> c; s[adr].sr = c; }
else if (t == 'C')
{ cin >> uc; s[adr].sr = uc; }
else if (t == 'i' || t == 'l')
{ cin >> i; s[adr].sr = i; }
else if (t == 'I' || t == 'L' || t == 'A' || t == 'K' || t == 'B')
{ cin >> ui; s[adr].sr = ui; }
else if (t == 'd' || t == 'f')
{ dop = (double*)s[adr].sr; cin >> *dop; }
else if (t == '^')
{ dp = (char*)s[adr].sr; fgets(dp, 255, stdin);
p = strchr(dp,'\n'); *p = 0; }
else if (t == '?')
{ sWert(s[adr].sl); --varI;
if (s[adr].sr == 'c')
{ dp = (char*)varWert[varI]; cin >> c; *dp = c; }
else if (s[adr].sr == 'i')
{ dP = (int*)varWert[varI]; cin >> i; *dP = i; } } }
//fWert ->
void Baum::fctFall(int k)
// setzt }_knoten voraus. führt zu fWertDbg_rekursion
{ 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') argRek(sl, t1);
else eWert(sl, t1);
if (t2 == 's')
{ if (s[sr].v == '"')
{ *stck4++ = k; fAst1(s[sr].sr);
if (err) return;
fWert(); iK = *--stck4; }
else iK = s[iR].sr; }
else if (t2 == 'ß')
{ (this->*func[s[k].sr])(); iK = k; iR = 0; }
else if (t2 == '@')
{ ++s[sr].s; //1
*stck4++ = k; fAst1(sr); fWert(); iK = *--stck4; iR = 0; } } //2
//1 rekursions-aufruf: s[sr].s is rekursions-zähler
//2 k is aufruf u. rückkehr-knoten
//fctFall ->
void Baum::argRek(int k, char t)
{ if (t == 's')
{ if (s[k].v == '.')
{ argRek(s[k].sl, s[k].t1);
argRek(s[k].sr, s[k].t2); }
else sWert(k); }
else eWert(k, t); }
//fWert|zuweis|doCase|sWert|whileFall|lWert|byteCopy ->
void Baum::sWert(int k)
// schiebt ausdruckswert auf rechenstack
{ int sl, sr; char t1, t2, v;
if (err) return;
sl = s[k].sl; sr = s[k].sr; t1 = s[k].t1; t2 = s[k].t2; v = s[k].v;
if (v == ':')
{ if (t1 == '?') eWert(sr, t2);
else
{ if (sr == '^') lWert(sl);
else
{ sWert(sl); --varI;
if (err) return;
if (sr == 'c') eWert(varWert[varI], 'p');
else if (sr == 'i') eWert(varWert[varI], 'P');
else if (sr == 'd' || sr == 'f') eWert(varWert[varI], 'D');
else if (sr != '"')
{ err = k; cout << "sWert: typR" << endl; } } } }
else if (v == ' ')
{ if (sl == '-')
{ if (t2 == 's') sWert(sr);
else eWert(sr, t2);
if (err) return;
neg(); }
else if (sl == 191) // '¿'
{ if (t2 == 's') sWert(sr);
else eWert(sr, t2);
if (err) return;
not1(); } }
else if (v == '=')
{ zuweis(k); ++varI; }
else if (v == '}') fctWert(k);
else if (v == '"')
{ fAst(sr); s[iR].h = 0; fWert(); }
else if (v == '#') baumFall(k);
else if (v == '§')
{ if (t2 == 's') sWert(sr);
else eWert(sr, t2);
convTyp(varI - 1, sl); }
else if (v == '¢')
{ byteCopy(k); ++varI; }
else
{ if (t1 == 's') sWert(sl);
else eWert(sl, t1);
if (err) return;
if (t2 == 's') sWert(sr);
else eWert(sr, t2);
if (err) return;
binOp(s[k].v); ++varI; } }
//sWert ->
void Baum::fctWert(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') argRek(sl, t1);
else eWert(sl, t1);
if (t2 == 's')
{ iR = sr;
if (s[iR].v == '"')
{ fAst1(s[iR].sr); s[iR].h = 0; fWert(); }
else s[iR].h = k; }
else if (t2 == 'ß')
{ (this->*func[s[k].sr])(); iR = 0; }
else if (t2 == '@')
{ ++s[sr].s; rekStack[rekI] = k; ++rekI; //1
fAst1(sr); s[iR].s = 0; fWert(); } }
//sWert|baumAdr ->
void Baum::baumFall(int k)
// liest baumvariablen-komponente aus
{ int sl, sr; char t;
sl = s[k].sl; sr = s[k].sr; t = s[k].t1;
if (t == 's')
{ if (s[sl].v == ':')
{ t = s[sl].t2; sl = s[sl].sr; }
else if (s[sl].v == '#')
{ baumFall(sl); --varI; t = varTyp[varI]; sl = varWert[varI]; } }
else { err = k; cout << "baumFall" << endl; return; }
switch(t)
{ case 'A':
if (sr == st_)
{ varTyp[varI] = 'p'; varWert[varI] = int(w[sl].st); }
else if (sr == wl_)
{ varTyp[varI] = 'A'; varWert[varI] = w[sl].wl; }
else if (sr == wr_)
{ varTyp[varI] = 'A'; varWert[varI] = w[sl].wr; }
else if (sr == b_)
{ varTyp[varI] = 'R'; varWert[varI] = w[sl].b; }
else
{ err = k; cout << "baumFall: falsche atomKomponente" << endl; return; }
break;
case 'K':
if (sr == sl_)
{ if (s[sl].t1 == 'w' || s[sl].t1 == '?') varTyp[varI] = 'A';
else if (s[sl].t1 == 's') varTyp[varI] = 'K';
else varTyp[varI] = '^';
varWert[varI] = s[sl].sl; }
else if (sr == sr_)
{ if (s[sl].t2 == 'w' || s[sl].t2 == '?') varTyp[varI] = 'A';
else if (s[sl].t2 == 's') varTyp[varI] = 'K';
else varTyp[varI] = 'i';
varWert[varI] = s[sl].sr; }
else if (sr == t1_)
{ varTyp[varI] = 'c'; varWert[varI] = s[sl].t1; }
else if (sr == t2_)
{ varTyp[varI] = 'c'; varWert[varI] = s[sl].t2; }
else if (sr == 'v')
{ varTyp[varI] = 'c'; varWert[varI] = s[sl].v; }
else if (sr == lc_)
{ varTyp[varI] = 'c'; varWert[varI] = s[sl].lc; }
else if (sr == b_)
{ varTyp[varI] = 'B'; varWert[varI] = s[sl].b; }
else if (sr == h_)
{ varTyp[varI] = 'i'; varWert[varI] = s[sl].h; }
else if (sr == s_)
{ varTyp[varI] = 'i'; varWert[varI] = s[sl].s; }
else
{ err = k; cout << "baumFall: falsche knotKomponente" << endl; return; }
break;
case 'B':
if (sr == zS_)
{ varTyp[varI] = 'K'; varWert[varI] = r[sl].zS; }
else if (sr == zz_)
{ varTyp[varI] = 'B'; varWert[varI] = r[sl].zz; }
else
{ err = k; cout << "baumFall: falsche backKomponente" << endl; return; }
break;
default: err = k; cout << "baumFall: falscher baumvariablentyp " << t << endl; return; }
++varI; }
//fWert|labFall ->
void Baum::fAst(int k)
{ if (s[k].t1 == 's')
{ if (s[k].s) pushRek(k); }
iR = k; typ = s[iR].t2; iK = s[iR].sr; }
//fWert|fctFall ->
void Baum::fAst1(int k)
{ int sl;
if (s[k].t1 == 's')
{ if (s[k].s) pushRek(k);
sl = s[k].sl;
if (s[sl].v == '·') sl = s[sl].sl;
param(sl); }
iR = k; typ = s[iR].t2; iK = s[iR].sr; }
//fAst ->
void Baum::pushRek(int k)
{ k = s[k].sl;
if (s[k].v == '·') k = s[k].sl;
pushRek1(k); }
//pushRek ->
void Baum::pushRek1(int k)
{ if (s[k].v == '.' || s[k].v == '·')
{ pushRek1(s[k].sl);
pushRek1(s[k].sr); }
else
{ while (s[k].t1 == 's') k = s[k].sl;
rekStack[rekI] = s[k].sr; ++rekI; } }
//fAst ->
void Baum::param(int k)
{ iF = 0;
parCount(k);
while (varI)
{ k = mintF[--iF];
parWert(k);
if (err) return;
setWert(); } }
void Baum::parCount(int k)
{ if (s[k].v == '.' || s[k].v == '·')
{ parCount(s[k].sl); parCount(s[k].sr); }
else if (iF < varI) mintF[iF++] = k; }
//param ->
void Baum::parWert(int k)
// legt adresse auf rechenStack
{ if (s[k].v == ':')
{ if (s[k].t1 == '?')
{ if (s[k].t2 == 'd' || s[k].t2 == 'f' || s[k].t2 == '^')
{ varWert[varI] = s[k].sr; }
else varWert[varI] = int(& s[k].sr);
varTyp[varI] = gTyp = s[k].t2;
++varI; }
else lWert(s[k].sl); }
else if (s[k].v == '#') baumAdr(k); }
//fWert|zuweis|fctFall|doCase|sWert|whileFall ->
void Baum::eWert(int i, char t)
// schiebt variablen_wert i auf rechen_stack
{ switch(t)
{ case ':': case 'i': case 'l': case 'R':
varTyp[varI] = 'i'; varWert[varI] = i; break;
case 'c':
varTyp[varI] = 'c'; varWert[varI] = i; break;
case '^':
if (! i)
{ worti = i; iScan(iK); cout << "eWert: adr(0)" << endl; return; }
varTyp[varI] = t; varWert[varI] = i; break;
case 'A': case 'K': case 'B': case 'd': case 'f':
varTyp[varI] = t; varWert[varI] = i; break;
case 'p':
varTyp[varI] = 'c'; varWert[varI] = 0; varWert[varI] = *(char*)i; break;
case 'P':
varTyp[varI] = 'i'; varWert[varI] = *(int*)i; break;
case 'ß':
(this->*func[i])(); return;
case '\'':
varTyp[varI] = 'c'; varWert[varI] = 0; varWert[varI] = i; break;
case 'D': varTyp[varI] = 'd'; varWert[varI] = *(int*)i; break;
case 'I': case 'L':
varTyp[varI] = 'I'; varWert[varI] = i; break;
case 'C':
varTyp[varI] = 'C'; varWert[varI] = 0; varWert[varI] = i; break;
case 't':
varTyp[varI] = 'p'; varWert[varI] = int(w[i].st); break;
default:
{ worti = i; iScan(iK); cout << "eWert: typFehler '" << t << "'" << endl; return; } }
++varI; }
void Baum::iScan(int k)
{ if (s[k].t1 == 's') iScan(s[k].sl);
else if (s[k].sl == worti) err = k;
if (s[k].t2 == 's') iScan(s[k].sr);
else if (s[k].sr == worti) err = k; }
//fWert|setWert|ifFall|sWert|whileFall ->
void Baum::convTyp(int i, char t)
// konvertiert varWert[i] in gewünschten neuen varTyp t
{ char iT; iT = varTyp[i];
if (iT == 'f') iT = 'd';
else if (t == 'f') t = 'd';
else if (iT == 'l') iT = 'i';
else if (iT == 'L') iT = 'I';
else if (t == 'l') t = 'i';
else if (t == 'L') t = 'I';
if (iT == t) return;
if (t == 'd')
{ dop = (double*)gp; *dop = varWert[i]; varWert[i] = gp; gp += 8; }
else if (iT == 'd')
{ dop = (double*)varWert[i]; dd = *dop; varWert[i] = int(dd);
if (g == gp) gp -= 8; }
varTyp[i] = t; }
//fWert|labFall ->
void Baum::whileFall(int k)
{ if (s[k].t1 == 's') sWert(s[k].sl);
else eWert(s[k].sl, s[k].t1);
--varI; convTyp(varI, 'i');
if (varWert[varI])
// if (varWert[varI])
{ iR = k; typ = s[iR].t2; iK = s[iR].sr; }
else
{ iK = s[k].h; iR = 0; } }
//fWert|labFall ->
void Baum::forDo(int k)
{ int i; i = varI;
iK = s[s[k].sl].sl;
if (s[iK].v == '¬')
{ s[iK].v = '|';
if (s[iK].t1 == 's') sWertB(s[iK].sl);
else eWert(s[iK].sl, s[iK].t1 ); }
else
{ if (s[iK].t2 == 's') sWertB(s[iK].sr);
else eWert(s[iK].sr, s[iK].t2); }
if (err) return;
varI = i;
iK = s[k].sl;
if (s[iK].t2 == 's') sWert(s[iK].sr);
else eWert(s[iK].sr, s[iK].t1);
if (err) return;
--varI;
iK = k;
if (varWert[varI])
{ iR = iK; typ = s[iR].t2; iK = s[iR].sr; }
else iR = 0; }
void Baum::sWertB(int k)
{ if (s[k].v == '.')
{ sWertB(s[k].sl); sWertB(s[k].sr); }
else sWert(k); }
//fWert ->
void Baum::popRek(int k)
{ if (s[k].v == '.' || s[k].v == '·')
{ popRek(s[k].sr);
popRek(s[k].sl); }
else
{ while (s[k].t1 == 's') k = s[k].sl;
--rekI; s[k].sr = rekStack[rekI]; } }]]>
back to
baumC