<![CDATA[//datei-name: equal.C
#include "baum.h"
/*
Typ 1 : durch semikolon abgeschlossener ausdruck
Typ 2 : funktion oder Block
Typ 3 : struct
Typ 4 : klasse
Typ 5 : funktionskopf
Typ 6 : funktionsrumpf
Typ 7 : structkopf
Typ 8 : structrumpf
Typ 9 : structtail
Typ 10 : klassenkopf
Typ 11 : klassenrumpf
Typ 12 : klassentail
Typ 13 : parameter
Typ 14 : ifkopf
Typ 15 : elsekopf
Typ 16 : whilekopf
Typ 17 : dokopf
Typ 18 : forkopf
Typ 19 : switchkopf
Typ 20 : blockinhalt
*/
void Baum::lexan()
// kopiert text
{ int i, j;
ERR1 = 1; ERR2 = 2; ERR3 = 3; ERR4 = 4; err = 0;
if (*baumDat)
{ lex();
token(); *stck0 = 0;
if (err)
{ errMes(); return; }
if (*stack)
{ pars();
i = srIndex(0);
if (err)
{ errMes(); return; }
rTyp = 's'; root = sBau(0, Typ, 'i', 'i', 't');
if (i)
{ if (! cstack[i] && stack[i] == ';') ++i;
root = sBau(root, i, 's', 'i', '.');
loop:
i = srIndex(i);
if (err)
{ errMes(); return; }
if (i)
{ if (! cstack[i] && stack[i] == ';') ++i;
j = sBau(s[root].sr, Typ, 'i', 'i', 't');
umbau(root, 'r', j, 's');
root = sBau(root, i, 's', 'i', '.'); goto loop; }
j = sBau(s[root].sr, Typ, 'i', 'i', 't');
umbau(root, 'r', j, 's'); }
parsA(root);
ast = Ast = 0; parsA1(root);
if (Ast) root = sBau(Ast, ast, 's', 's', '.');
else root = ast;
iN = 0;
aufAb(root);
structBaum(root);
iiBaum(root);
hashRek(root);
castRek(root); varBaum(root);
copyTree(root);
k1Del(root); s[root].lc = STDLOC;
equalBaum(root); equalBaumClr(root);
switchBaum(root);
if (iN) structUmbau();
zeigerUmbau(root);
newUmbau(root);
retUmbau(root);
AltB(root, '.'); root = Ast; }
else mes = 2; } }
void Baum::lex()
{ char a1, a2, b, c, d;
char* p1; char* p2;
p1 = p2 = baumDat;
while (*p2 == ' ') p2++; //1
while ((c = *p2++))
{ if ((c == '\'') || (c == '"')) //2
{ d = c; *p1++ = c;
loop:
*p1++ = c = *p2++;
if (c == -62) --p1;
if (c == '\\')
{ *p1++ = c = *p2++; goto loop; }
if (c != d ) goto loop;
continue; }
if (c == -62) c = *p2++; //3
if (c == '/')
{ if (*p2 == '*') //4
{ p2++;
do
{ c = *p2++;
if (c) d = *p2;
else break; }
while (c != '*' || d != '/');
p2++; continue; }
if (*p2 == '/')
{ while (*(p1 - 1) == ' ') p1--;
while (*p2 != '\n') p2++;
continue; } }
if (c == 'e') //5
{ if (*p2 == 'x')
if (*(p2 + 1) == 't')
if (*(p2 + 2) == 'e')
if (*(p2 + 3) == 'r')
if (*(p2 + 4) == 'n')
if (*(p2 + 5) == ' ')
{ p2 += 6;
while (*p2 != '\n') p2++;
continue; } }
else
{ if (c == '#' && *p2 == 'i') //6
{ while (*p2 != '\n') p2++;
continue; }
if (c == '\t') continue; //7
if (c == '\n') //8
{ a1 = a2 = 0;
b = *(p2 - 2);
if (bScan(b)) a1 = 1;
while (*p2 == ' ') p2++; //9
b = *p2;
if (bScan(b)) a2 = 1;
if (a1 && a2) *p1++ = ' ';
continue; }
if (c == ' ')
{ while (*p2 == ' ') p2++;
a1 = a2 = 1;
b = *(p1 - 1); d = *p2;
if (bScan(b)) a1 = 0;
if (bScan(d)) a2 = 0;
if (a1 || a2) continue; } } //10
*p1++ = c; }
*p1 = 0; }
//1 ohne spaces am anfang
//2 '_' "___"
//3 editor-fehler
//4 ohne kommentare
//5 ohne extern_deklaration
//6 #include entfernen
//7 ohne tabulatorzeichen
//8wort \n wort ~> wort ' ' wort
//9 ohne führende spaces
//10 ' ' schlucken oder einbauen
char Baum::bScan(char c)
// stellt fest ob das zeichen zum bezeichner gehört
{ if (((c >= '0') && (c <= '9')) ||
((c >= 'A') && (c <= 'Z')) ||
((c >= 'a') && (c <= 'z')) ||
(c == '\'') || (c == '_'))
return 1;
return 0; }
void Baum::token()
// setzt baumDat, stck0, cstck0 voraus
{ char c1, c2, t1, t2;
loc = TOKLOC; txt0 = tex; txt1 = baumDat;
loop:
c1 = *txt1++;
if (c1)
{ if (c1 == ' ') goto loop;
if (c1 == '"')
{ parsString(); goto loop; }
if (c1 == '\'')
{ txt0 = tex; *txt0++ = c1;
if (*txt1 == '\\') *txt0++ = *txt1++;
*txt0++ = *txt1++; *txt0++ = *txt1++;
*txt0 = 0; txt0 = tex;
*stck0++ = wortI(txt0); *cstck0++ = 'w'; goto loop; }
t1 = bScan(c1);
loop1:
c2 = *txt1;
if (c2)
{ t2 = bScan(c2);
if (t1 && t2)
{ *txt0++ = c1; c1 = c2; ++txt1; goto loop1; }
if (t1 && ! t2)
{ *txt0++ = c1; *txt0 = 0; txt0 = tex;
*stck0++ = wortI(txt0); *cstck0++ = 'w'; goto loop; }
if (! t1 && t2)
{ *stck0++ = c1; *cstck0++ = 0; txt0 = tex; goto loop; }
if (! t1 && ! t2)
{ if (c1 == c2)
{ if (c1 == '=')
{ *stck0++ = '?'; *cstck0++ = 0; ++txt1; goto loop; }
if (c1 == '|')
{ *stck0++ = '|'; *cstck0++ = 0; ++txt1; goto loop; }
if (c1 == '&')
{ *stck0++ = '&'; *cstck0++ = 0; ++txt1; goto loop; }
if (c1 == '+')
{ *stck0++ = pp_; *cstck0++ = 'w'; ++txt1; goto loop; }
if (c1 == '-')
{ *stck0++ = mm_; *cstck0++ = 'w'; ++txt1; goto loop; }
if (c1 == ':')
{ *stck0++ = 176; *cstck0++ = 0; ++txt1; goto loop; }
if (c1 == '<')
{ *stck0++ = 'C'; *cstck0++ = 0; ++txt1; goto loop; }
if (c1 == '>')
{ *stck0++ = 'C'; *cstck0++ = 0; ++txt1; goto loop; }
if (c1 == '*')
{ txt0 = tex; *txt0++ = '^';
while (*txt1++ == '*') *txt0++ = '^';
*txt0 = 0; txt0 = tex; txt1--;
*stck0++ = wortI(txt0); *cstck0++ = 'w';
goto loop; } }
if (c1 == '!' && c2 == '=')
{ *stck0++ = 191; *cstck0++ = 0; ++txt1; goto loop; }
if (c1 == '<' && c2 == '=')
{ *stck0++ = 171; *cstck0++ = 0; ++txt1; goto loop; }
if (c1 == '>' && c2 == '=')
{ *stck0++ = 187; *cstck0++ = 0; ++txt1; goto loop; }
if (c1 == '-' && c2 == '>')
{ *stck0++ = '^'; *cstck0++ = 0; ++txt1; goto loop; }
if (c1 == '(' && c2 == ')')
{ *stck0++ = k1_; *cstck0++ = 'w'; ++txt1; goto loop; }
if (c1 == ']' && c2 == '[')
{ *stck0++ = ','; *cstck0++ = 0; ++txt1; goto loop; }
if (c1 == '[' && c2 == ']')
{ if (*(stck0 - 1) != delete_)
{ *stck0++ = k2_; *cstck0++ = 'w'; }
++txt1; goto loop; }
if (c1 == '+' && c2 == '=')
{ *stck0++ = '='; *cstck0++ = 0;
*stck0++ = ':'; *cstck0++ = 'w';
*stck0++ = '+'; *cstck0++ = 0;
++txt1; goto loop; }
if (c1 == '-' && c2 == '=')
{ *stck0++ = '='; *cstck0++ = 0;
*stck0++ = ':'; *cstck0++ = 'w';
*stck0++ = '-'; *cstck0++ = 0;
++txt1; goto loop; }
if (c1 == '*' && c2 == '=')
{ *stck0++ = '='; *cstck0++ = 0;
*stck0++ = ':'; *cstck0++ = 'w';
*stck0++ = '*'; *cstck0++ = 0;
++txt1; goto loop; }
if (c1 == '/' && c2 == '=')
{ *stck0++ = '='; *cstck0++ = 0;
*stck0++ = ':'; *cstck0++ = 'w';
*stck0++ = '/'; *cstck0++ = 0;
++txt1; goto loop; }
if (c1 == '%' && c2 == '=')
{ *stck0++ = '='; *cstck0++ = 0;
*stck0++ = ':'; *cstck0++ = 'w';
*stck0++ = '%'; *cstck0++ = 0;
++txt1; goto loop; }
if (c1 == -73)
{ err = ERR1; return; }
*stck0++ = c1; *cstck0++ = 0; txt0 = tex;
goto loop; } }
*stck0++ = c1; *cstck0++ = 0; } }
void Baum::parsString()
// weist jeder stringKonstante einen satzknoten zu
{ char c; char* tex1; tex1 = tex;
loop:
c = *txt1++;
if (c == '\\')
{ *tex1++ = c; *tex1++ = *txt1++; goto loop; }
if (c != '"')
{ *tex1++ = c; goto loop; }
*tex1 = 0;
*stck0++ = sBau(c, wortI(tex), 'w', 'w', ' ');
*cstck0++ = 's'; }
void Baum::pars()
{ stck0 = stck1 = stack; cstck0 = cstck1 = cstack; i = 0;
while(stack[i])
{ tok = stack[i];
if (tok == '!')
{ stack[i] = 191; cstack[i] = 'w'; } // '¿'
else if (tok == return_) stack[i] = 183;
else if (tok == break_) stack[i] = '|';
else if (tok == continue_) stack[i] = '_';
else if (tok == cin_) stack[i] = '?';
else if (tok == cout_) stack[i] = '!';
else if (tok == endl_) stack[i] = 183; // '·'
++i; }
if (*(stack + 1))
{ parsRef();
parsFloat(); *stck1 = 0;
stckrset(); stck1 = stck0; cstck1 = cstck0;
parsStack(); *stck1 = 0; } }
void Baum::parsRef()
{ int i, j, k, tok, vorTok, kNr; char t, vorT;
i = k = 0; iStruct = 0; vorTok = 0; vorT = 0;
while(stack[i])
{ tok = stack[i]; t = cstack[i];
if ((tok == struct_ || tok == class_ ) && t == 'w' && cstack[i + 1] == 'w') //1
{ mStruct[iStruct] = stack[i + 1]; ++iStruct; }
else if (t != 's')
{ if (i)
{ vorTok = stack[i - 1]; vorT = cstack[i - 1]; }
switch (tok)
{ case '*':
if (vorT)
{ if (datenTyp(vorTok))
{ kNr = sBau('^', vorTok, 'w', 'w', ' ');
--k; stack[k] = kNr; cstack[k] = 's';
++k; i++; continue; } //2
else if (vorTok == '}' || vorTok == else_ || vorTok == mm_ || vorTok == pp_ || vorTok == do_)
{ tok = 176; t = 'w'; }
else if ((vorTok == 191 || vorTok == '-') && vorT == 'w')
{ tok = 176; t = 'w'; } }
else if (vorTok == ')')
{ j = k - 2;
j = klammerAuf(j, '(', ')');
if (cstack[j] == 'w')
{ j = stack[j];
if (j == if_ || j == while_ || j == for_ || j == do_)
{ tok = 176; t = 'w'; } } } //3
else if (vorTok != ']' && ! vorT) // array-multiplikation
{ tok = 176; t = 'w'; } //3
break;
case '&':
if (vorT)
{ if (datenTyp(vorTok))
{ kNr = sBau( 176, vorTok, 'w', 'w', ' ');
--k; stack[k] = kNr; cstack[k] = 's';
++k; i++; continue; } //2
else if (vorTok == '}' || vorTok == else_)
{ tok = '^'; t = 'w'; } }
else if (vorTok == ')' )
{ if (datenTyp(stack[i - 2]))
{ tok = '^'; t = 'w'; } }
else if (! vorT && vorTok != ']' && vorTok != ')')
{ tok = '^'; t = 'w'; } //5
break;
case '-':
if (! vorT && vorTok != ')' && vorTok != ']') t = 'w';
else if (vorTok == 191 && vorT == 'w') t = 'w';
else if (vorTok == '}') t = 'w';
break; } }
stack[k] = tok; cstack[k] = t; ++i; ++k; }
stack[k] = 0; }
//1: structnamen sammeln
//2 zeiger-deklaration
//3: dereferenzierung
//4: referenz-deklaration
//5: adresse
char Baum::datenTyp(int t)
{ int i; i = 0;
if (t == char_ || t == int_ || t == long_ || t == float_ || t == double_ ||
t == atom_ || t == knot_ || t == back_ ||
t == uchar_ || t == uint_ || t == ulong_ || t == FILE_) return 1;
if (iStruct)
{ while (i < iStruct)
{ if (t == mStruct[i]) return 1;
++i; } }
return 0; }
int Baum::klammerAuf(int i, char auf, char zu)
{ int k; char c; k = 1;
loop:
while (cstack[i]) --i;
c = char(stack[i]); --i;
if (c == zu) ++k;
if (c == auf)
{ --k;
if (! k) return i; }
goto loop; }
void Baum::parsFloat()
// sucht alle worte deren nachfolger ein '.' ist und stellt fest ob das wort eine dezimalzahl ist
// gefolgt von einem dezimalstellen_teil gefolgt von (e|E(+|-)opt. und zahl)opt.
// bzw. sucht punkt gefolgt von einem dezimalstellen_teil gefolgt von (e|E(+|-)opt. und zahl)opt.
// und fasst dann diese teile zu einer floatKonstante zusammen
{ int a, b, c, d, e; char ta, tb, tc, td, te;
loop:
a = *stck0++;
if (! a) return;
ta = *cstck0++;
if (ta == 'w' && zScan(w[a].st))
{ b = *stck0++;
if (! b)
{ *stck1++ = a; *cstck1++ = 'w'; return; }
tb = *cstck0++;
if (! tb)
{ if (b == '.')
{ if (zScan(w[a].st))
{ c = *stck0++;
if (! c)
{ *stck1++ = a; *cstck1++ = 'w';
*stck1++ = b; *cstck1++ = 0; return; }
tc = *cstck0++;
if (tc == 'w')
{ d = *stck0++;
if (! d)
{ *stck1++ = a; *cstck1++ = 'w';
*stck1++ = b; *cstck1++ = 0;
*stck1++ = c; *cstck1++ = 'w'; return; }
td = *cstck0++;
if (! td)
{ if (d == '+' || d == '-')
{ e = *stck0++;
if (! e)
{ *stck1++ = a; *cstck1++ = 'w';
*stck1++ = b; *cstck1++ = 0;
*stck1++ = c; *cstck1++ = 'w';
*stck1++ = d; *cstck1++ = 'w'; return; }
te = *cstck0++;
if (te == 'w')
{ if (zScan(w[a].st))
{ txt0 = tex; txt1 = w[a].st;
while (*txt1) *txt0++ = *txt1++;
*txt0++ = '.'; txt1 = w[c].st;
while (*txt1) *txt0++ = *txt1++;
txt1 = w[d].st; *txt0++ = *txt1++;
txt1 = w[e].st;
while (*txt1) *txt0++ = *txt1++;
*txt0 = 0; txt0 = tex;
*stck1++ = wortI(txt0); *cstck1++ = 'w'; *cstck3++ = 3; goto loop; } }
stck0 -= 2; cstck0 -= 2;
txt0 = tex; txt1 = w[a].st;
while (*txt1) *txt0++ = *txt1++;
*txt0++ = '.'; txt1 = w[c].st;
while (*txt1) *txt0++ = *txt1++;
*txt0 = 0; txt0 = tex;
*stck1++ = wortI(txt0); *cstck1++ = 'w'; *cstck3++ = 3; goto loop; } }
stck0--; cstck0--;
txt0 = tex; txt1 = w[a].st;
while (*txt1) *txt0++ = *txt1++;
*txt0++ = '.'; txt1 = w[c].st;
while (*txt1) *txt0++ = *txt1++;
*txt0 = 0; txt0 = tex;
*stck1++ = wortI(txt0); *cstck1++ = 'w'; *cstck3++ = 3; goto loop; }
stck0--; cstck0--;
txt0 = tex; txt1 = w[a].st;
while (*txt1) *txt0++ = *txt1++;
*txt0++ = '.'; *txt0 = 0; txt0 = tex;
*stck1++ = wortI(txt0); *cstck1++ = 'w'; *cstck3++ = 3; goto loop; } } }
*stck1++ = a; *cstck1++ = ta;
*stck1++ = b; *cstck1++ = tb; goto loop; }
*stck1++ = a; *cstck1++ = ta;
goto loop; }
char Baum::zScan(char* txt)
// stellt fest ob die zeichenfolge eine dezimalzahl ist
{ char c;
loop:
c = *txt++;
if (! c) return 1;
if ((c >= '0') && (c <= '9')) goto loop;
return 0; }
void Baum::parsStack()
// stack verkürzen
{ int a; char t;
loop:
a = *stck0++;
if (! a)
{ *stck1 = 0; return; }
t = *cstck0++;
if (! t)
{ if (a != ' ')
{ if (a == 176)
{ if (*stck0 == '~')
{ a = sBau(*(stck0 - 2), delete_,'w', 'w', '°'); t = 's';
stck0 += 2; cstck0 += 2; --stck1; --cstck1; }
else if (*(stck0 - 2) == *stck0)
{ a = sBau(*(stck0 - 2), new_,'w', 'w', '°'); t = 's';
++stck0; ++cstck0; --stck1; --cstck1; }
else
{ a = sBau(*(stck0 - 2), *stck0,'w', 'w', '°'); t = 's';
++stck0; ++cstck0; --stck1; --cstck1; }
*stck1++ = a; *cstck1++ = t; goto loop; }
if (a == '(' && *stck0 == void_ && *(stck0 + 1) == ')')
{ *stck1++ = k1_; *cstck1++ = 'w'; stck0 += 2; cstck0 += 2; }
else
{ *stck1++ = a; *cstck1++ = 0; } }
goto loop; }
else
{ if (a == unsigned_)
{ a = *stck0++; t = *cstck0++;
if (a == char_) a = uchar_;
else if (a == int_) a = uint_;
else if (a == long_) a = ulong_; }
else if (a == const_ || a == inline_ || a == register_ || a == static_ || a == virtual_) goto loop; }
*stck1++ = a; *cstck1++ = t; goto loop; }
int Baum::srIndex(int i)
// gibt das nächste tok zurück
{ char c;
loop:
while (cstack[i]) ++i;
c = char(stack[i]); ++i;
if (c == ';')
{ Typ = 1; stack[i - 1] = 0;
if (! stack[i]) return 0;
return i; }
if (c == '{')
{ i = klammerZu(i, '{', '}');
Typ = 2;
if (err) return 0;
c = char(stack[i]);
if (! c) return 0;
else return i; }
if (c == '}')
{ err = ERR2; return 0; }
if (! c)
{ err = ERR1; return 0; }
goto loop; }
int Baum::klammerZu(int i, char auf, char zu)
{ int k; char c; k = 1;
loop:
while (cstack[i]) ++i;
c = char(stack[i]); ++i;
if (! c)
{ err = ERR2; return 0; }
if (c == zu)
{ --k;
if (! k) return i; }
if (c == auf) ++k;
goto loop; }
// i : erstes zeichen nach '{'
void Baum::errMes()
{ switch(err)
{ case 1:
cout << "kein parsbarer code!" << endl; break;
case 2:
cout << "block falsch geklammert!" << endl; break;
case 3:
cout << "array falsch deklariert!" << endl; break;
case 4:
cout << "deklarations-liste fehlerhaft!" << endl; } }
void Baum::parsA(int i)
{ if(s[i].v == 't')
{ if (s[i].sr == 2)
{ nr = s[i].sl; nr = stack[nr];
if (nr == struct_) s[i].sr = 3;
else if (nr == class_) s[i].sr = 4; }
return; }
parsA(s[i].sl); parsA(s[i].sr); }
void Baum::parsA1(int i)
{ if(s[i].v == 't')
{ if (s[i].sr == 2)
{ if (ast) ast = sBau(ast, i, 's', 's', '.');
else ast = i; }
else
{ if (Ast) Ast = sBau(Ast, i, 's', 's', '.');
else Ast = i; }
return; }
parsA1(s[i].sl); parsA1(s[i].sr); }
void Baum::aufAb(int i)
{ if (s[i].v == 't') typSwitch(i);
else
{ aufAb(s[i].sl); aufAb(s[i].sr); } }
void Baum::typSwitch(int i)
{ int t; t = s[i].sr;
switch(t)
{ case 1:
typ1Bau(i); break;
case 2:
typ2Bau(i); typ5Bau(i);
if (s[i].v == '°') i = s[i].sr;
i = s[i].sr;
typ6Bau(i); break;
case 3:
typ3Bau(i);
if (s[i].v == ';')
{ typ9Bau(i); i = s[i].sl; }
typ7Bau(i); typ8Bau(i); break;
case 4:
typ4Bau(i);
if (s[i].v == ';')
{ typ9Bau(i); i = s[i].sl; }
typ10Bau(i); typ11Bau(i); break; } }
void Baum::typ1Bau(int i)
{ int tok, tEnd;
tok = tEnd = s[i].sl;
while (stack[tEnd]) ++tEnd;
s[i].sr = tEnd; s[i].v = ','; }
void Baum::typ2Bau(int i)
{ int i1, i2;
i1 = s[i].sl;
i2 = typ2Scan(i1);
i1 = sBau(i1, 5, 'i', 'i', 't');
i2 = sBau(i2, 6, 'i', 'i', 't');
umbau(i, 'l', i1, 's'); umbau(i, 'r', i2, 's'); s[i].v = 'f'; }
int Baum::typ2Scan(int i)
{ char c; int j;
do
{ while (cstack[i]) ++i;
c = char(stack[i]); ++i; }
while (c != '{');
stack[i - 1] = 0;
j = klammerZu(i, '{', '}');
stack[j - 1] = 0;
return i; }
void Baum::typ3Bau(int i)
{ int i1, i2, tailStart, tail;
i1 = s[i].sl;
i2 = typ3Scan(i1); stack[i2] = 0;
++i2; tail = klammerZu(i2, '{', '}');
stack[tail - 1] = 0;
i1 = sBau(i1, 7, 'i', 'i', 't');
i2 = sBau(i2, 8, 'i', 'i', 't');
umbau(i, 'l', i1, 's'); umbau(i, 'r', i2, 's'); s[i].v = 's';
tailStart = tail;
while (!(! cstack[tail] && stack[tail] == ';')) ++tail;
stack[tail] = 0;
if (tailStart != tail)
{ tail = sBau(tail, 9, 'i', 'i', 't');
umbau(i, 'r', tail, 's'); s[i].v = ';'; s[i2].lc = STDLOC;
anbauLr(i, i2, 's', 's'); } }
int Baum::typ3Scan(int i)
{ char c;
do
{ while (cstack[i]) ++i;
c = char(stack[i]); ++i; }
while (c != '{');
return i - 1; }
void Baum::typ4Bau(int i)
{ int i1, i2, i2merker, tail;
i1 = s[i].sl;
i2 = typ3Scan(i1); tail = i2merker = i2;
i1 = sBau(i1, 10, 'i', 'i', 't');
i2 = sBau(i2, 11, 'i', 'i', 't');
umbau(i, 'l', i1, 's'); umbau(i, 'r', i2, 's'); s[i].v = 'c';
while (stack[tail]) ++tail;
--tail;
if (!cstack[tail] && stack[tail] == '}')
{ stack[tail] = 0; tail = 0; }
else
{ do --tail;
while (!cstack[tail] && stack[tail] != '}');
stack[tail] = 0; ++tail; }
stack[i2merker] = 0; s[i2].sl = i2merker + 1;
if (tail)
{ tail = sBau(tail, 12, 'i', 'i', 't');
umbau(i, 'r', tail, 's'); s[i].v = ';'; s[i2].lc = STDLOC;
anbauLr(i, i2, 's', 'c'); } }
void Baum::typ5Bau(int i)
{ int iL, tok, k, cName, fName, ret, param; char fTyp, rTyp;
iL = s[i].sl; tok = s[iL].sl;
while (stack[tok]) ++tok;
--tok;
if(stack[tok] == k1_) param = 0;
else
{ stack[tok] = 0; --tok;
while (stack[tok] != '(' || cstack[tok]) --tok;
stack[tok] = 0;
param = paramBau(tok + 1); }
--tok; fName = stack[tok]; fTyp = cstack[tok]; --tok;
if (tok < s[iL].sl)
{ ret = void_; rTyp = 'w'; }
else if(cstack[tok] == 's')
{ ret = stack[tok]; rTyp = 's'; } // char* char&
else
{ ret = stack[tok]; rTyp = 'w'; }
if ((ret == void_ || ret == slot_) && rTyp == 'w')
{ if (param) k = sBau(param, s[i].sr, 's', 's', 'f');
else k = sBau(183, s[i].sr, 'w', 's', 'f'); }
else
{ if (param)
{ k = sBau(param, ret, 's', rTyp, '}');
k = sBau(k, s[i].sr, 's', 's', 'f'); }
else
{ k = sBau(183, ret, 'w', rTyp, '}');
k = sBau(k, s[i].sr, 's', 's', 'f'); } }
if (fTyp == 's')
{ s[fName].lc = OUTLOC; cName = s[fName].sl; fName = s[fName].sr;
k = sBau(fName, k, 'w', 's', '"');
umbau(i, 'l', cName, 'w'); s[i].v = '°'; }
else
{ umbau(i, 'l', fName, 'w'); s[i].v = '"'; }
umbau(i, 'r', k, 's'); }
int Baum::paramBau(int tok)
{ int tok0, k, k1; char c;
k1 = 0; tok0 = tok;
loop:
while (cstack[tok]) ++tok;
c = char(stack[tok]);
if (c)
{ if (c != ',')
{ ++tok; goto loop; } }
k = sBau(tok0, tok, 'i', 'i', ',');
if (k1) k1 = sBau(k1, k , 's', 's', '.');
else k1 = k;
if (c)
{ stack[tok] = 0; ++tok; tok0 = tok; goto loop; }
return k1; }
void Baum::typ6Bau(int i)
{ int k, tEnd;
k = s[i].sr; tok = tEnd = s[k].sl;
stack[--tok] = '{';
while (stack[tEnd]) ++tEnd;
stack[tEnd]='}';
k = typ6Scan();
umbau(i, 'r', k, 's'); }
int Baum::typ6Scan()
// setzt tok voraus
{ int k, kNr, kLoop, tEnd;
if (stack[tok] == '{')
{ kNr = 0;
++tok;
tEnd = klammerZu(tok,'{','}');
while (tok < tEnd)
{ k = typ6Rek();
if (k)
{ if (s[k].v == 's')
{ mintN[iN] = k; ++iN; }
else
{ if (kNr) kNr = sBau(kNr, k, 's', 's', '.');
else kNr = k; }
if (stack[tok] == ';') ++tok;
if (stack[tok] == '}' && ! cstack[tok]) ++tok; }
else
{ k = stack[tok]; ++tok; stack[tok] = '{';
kLoop = typ6Scan();
k = sBau(k, kLoop, 'w', 's', '"');
if (kNr) kNr = sBau(kNr, k, 's', 's', '.');
else kNr = k; } } }
else kNr = typ6Rek();
return kNr; }
int Baum::typ6Rek()
// setzt tok voraus
{ int tPos, k, kNr;
if (stack[tok] == if_)
{ ++tok; k = ifBau();
if (stack[tok] == else_)
{ ++tok; kNr = elseBau();
k = sBau(k, kNr, 's', 's', '·'); } }
else if (stack[tok] == switch_)
{ ++tok; k = switchBau(); }
else if (stack[tok] == do_)
{ ++tok; k = doBau(); }
else if (stack[tok] == while_)
{ ++tok; k = whileBau(); }
else if (stack[tok] == for_)
{ ++tok; k = forBau(); }
else if (stack[tok] == struct_ && stack[tok + 2] == '{') k = structBau();
else if (stack[tok + 1] == ':' && ! cstack[tok + 1]) return 0;
else
{ tPos = tok;
while(stack[tok] != ';') ++tok;
k = sBau(tPos, tok, 'i', 'i', ','); // anweisung
++tok; }
return k; }
int Baum::structBau()
// setzt tok voraus
{ int k, i1, tail;
i1 = typ3Scan(tok);
tail = klammerZu(i1 + 1, '{', '}');
while (stack[tail] != ';') tail++;
k = sBau(tok, 3, 'i', 'i', 't');
typ3Bau(k);
if (s[k].v == ';')
{ typ9Bau(k); k = s[k].sl; }
typ7Bau(k); typ8Bau(k);
tok = tail + 1;
return k; }
int Baum::ifBau()
// setzt tok voraus
{ int tPos, kopf, rumpf, k;
tPos = tok;
tok = klammerZu(tPos + 1, '(', ')');
kopf = sBau(tPos, tok - 1, 'i', 'i', ',');
rumpf = typ6Scan();
k = sBau(kopf, rumpf, 's', 's', ',');
k = sBau(if_then, k, 'w', 's', '"');
return k; }
int Baum::elseBau()
{ int rumpf, k;
rumpf = typ6Scan();
k = sBau(else_, rumpf, 'w', 's', '"');
return k; }
int Baum::switchBau()
// setzt tok voraus
{ int tPos, tEnd, kopf, rumpf, k; char kopfTyp;
++tok;
exprScan(')', kopf, kopfTyp);
tEnd = klammerZu(tok, '{', '}');
tPos = tok;
while (tPos < tEnd)
{ if ((stack[tPos] == switch_) && cstack[tPos] == 'w')
{ while (stack[tPos] != '{') ++tPos;
++tPos; tPos = klammerZu(tPos, '{', '}'); }
if (stack[tPos] == ':' && !cstack[tPos]) stack[tPos] = '{';
else if ((stack[tPos] == case_ || stack[tPos] == default_) && cstack[tPos] == 'w')
{ stack[tPos] = '}'; cstack[tPos] = 0; }
++tPos; }
++ tok; rumpf = switchScan(tEnd);
k = sBau(kopf, rumpf, kopfTyp, 's', ',');
k = sBau(switch_, k, 'w', 's', '"');
return k; }
void Baum::exprScan(char c, int& kopf, char& kopfTyp)
{ int tEnd;
if (c == ')') tEnd = klammerZu(tok, '(', ')') - 1;
if (tEnd - tok == 1)
{ kopf = stack[tok]; kopfTyp = cstack[tok]; tok += 3; }
else
{ kopf = sBau(tok, tEnd, 'i', 'i', ','); kopfTyp = 's'; tok = tEnd + 2; } }
int Baum::switchScan(int tEnd)
{ int kNr, k, kopf, koepfe, rumpf; char kopfTyp, koepfeTyp;
kNr = 0;
caseBau:
kopf = stack[tok]; kopfTyp = cstack[tok];
while (stack[tok + 1] == '{' && stack[tok + 2] == '}')
{ tok += 3;
koepfe = stack[tok]; koepfeTyp = cstack[tok];
kopf = sBau(kopf, koepfe, kopfTyp, koepfeTyp, '.');
kopfTyp = 's'; }
++tok;
rumpf = typ6Scan();
while(stack[tok] == '}' || stack[tok] == ';') ++tok;
k = sBau(then_, rumpf, 'w', 's', '"');
k = sBau(kopf, k, kopfTyp, 's', ',');
if (! kNr) kNr = k;
else kNr = sBau(kNr, k, 's', 's', '.');
if (tok < tEnd)
{ if (cstack[tok]) goto caseBau;
kNr = sBau(case_, kNr, 'w', 's', '"');
if (stack[tok] == '{') // default
{ k = typ6Scan();
kNr = sBau(kNr, k, 's', 's', '.'); } }
else kNr = sBau(case_, kNr, 'w', 's', '"');
return (kNr); }
int Baum::doBau()
// setzt tok voraus
{ int tPos, kopf, rumpf, k;
tPos = tok;
rumpf = typ6Scan();
tPos = tok + 2; tok = klammerZu(tPos, '(', ')');
kopf = sBau(tPos, tok - 1, 'i', 'i', ',');
k = sBau(rumpf, kopf, 's', 's', ';');
k = sBau(do_while, k, 'w', 's', '"');
return k; }
int Baum::whileBau()
// setzt tok voraus
{ int tPos, kopf, rumpf, k;
tPos = tok;
tok = klammerZu(tPos + 1, '(', ')');
kopf = sBau(tPos, tok - 1, 'i', 'i', ',');
rumpf = typ6Scan();
k = sBau(kopf, rumpf, 's', 's', '_');
k = sBau(while_do, k, 'w', 's', '"');
return k; }
int Baum::forBau()
// setzt tok voraus
{ int tPos, kopf, rumpf, k;
tPos = tok;
tok = klammerZu(tPos + 1, '(', ')');
kopf = forKopf(tPos);
rumpf = typ6Scan();
k = sBau(kopf, rumpf, 's', 's', '~');
k = sBau(for_do, k, 'w', 's', '"');
return k; }
int Baum::forKopf(int tok)
{ int tPos, k, k1, k2, k3;
++tok; tPos = tok;
while (cstack[tPos] || stack[tPos] != ';') ++tPos;
k1 = sBau(tok, tPos, 'i', 'i', '.');
tok = ++tPos;
while (cstack[tPos] || stack[tPos] != ';') ++tPos;
k2 = sBau(tok, tPos, 'i', 'i', '.');
tok = ++tPos;
while (cstack[tPos] || stack[tPos] != ')') ++tPos;
k3 = sBau(tok, tPos, 'i', 'i', '.');
k = sBau(k1, k3, 's', 's', '|');
k = sBau(k, k2, 's', 's', '&');
return k; }
void Baum::typ7Bau(int i)
{ int j, j1;
j = s[i].sl; j1 = s[j].sl;
stack[j1] = 0; ++j1;
if (!stack[j1]) umbau(i, 'l', struct_, 'w');
else
{ umbau(i, 'l', stack[j1], 'w'); }
s[i].v = 's'; }
void Baum::typ8Bau(int i)
{ int tok, tPos, k, k1; char c;
tok = s[i].sr; tok = tPos = s[tok].sl; k = 0;
loop:
while (cstack[tPos]) ++tPos;
c = char(stack[tPos]); ++tPos;
if (c != ';') goto loop;
stack[tPos - 1] = 0;
k1 = sBau(tok, 1, 'i', 'i', 't');
typ1Bau(k1);
if (! k) k = k1;
else k = sBau(k, k1, 's', 's', '.');
tok = tPos;
if (stack[tPos]) goto loop;
umbau(i, 'r', k, 's'); }
void Baum::typ9Bau(int i)
{ int j, i1, i2; char t;
t = 'w';
j = s[i].sr; j = s[j].sl;
i1 = stack[j];
loop:
++j; i2 = stack[j];
if (i2)
{ ++j; i2 = stack[j];
i1 = sBau(i1, i2, t, 'w', '.');
t = 's'; goto loop; }
umbau(i, 'r', i1, t); s[i].v = ';'; }
void Baum::typ10Bau(int i)
{ int tok, tPos, k;
tok = s[s[i].sl].sl;
stack[tok] = 0; ++tok;
if (!stack[tok]) umbau(i, 'l', class_, 'w');
else if (!stack[tok + 1]) umbau(i, 'l', stack[tok], 'w');
else
{ tPos = tok + 2;
if (stack[tPos] == public_) ++tPos;
k = sBau(stack[tok], stack[tPos], 'w', 'w', ':');
loop:
++tPos;
if (stack[tPos])
{ ++tPos;
if (stack[tPos] == public_) ++tPos;
anbauRr(k, stack[tPos], 'w', '.');
goto loop; }
umbau(i, 'l', k, 's'); }
s[i].v = 'c'; }
void Baum::typ11Bau(int i) //klassenrumpf
{ int t, tok, iM, k, k1;
tok = s[i].sr; tok = s[tok].sl;
t = stack[tok];
if(cstack[tok] == 'w' && (t == public_ || t == protected_ || t == private_))
{ stack[tok] = 0; tok += 2; mintM[0] = sBau(t, tok, 'w', 'i', ':'); }
else
{ t = private_; mintM[0] = sBau(t, tok, 'w', 'i', ':'); }
iM = 1;
while(stack[tok])
{ t = stack[tok];
if(cstack[tok] == 'w' && (t == public_ || t == protected_ || t == private_))
{ stack[tok] = 0; tok +=2; mintM[iM++] = sBau(t, tok, 'w', 'i', ':'); --tok; }
++tok; }
mintM[iM] = 0;
while (iM)
{ k = mintM[--iM];
tok = s[k].sr;
k1 = scan11Bau(tok);
umbau(k, 'r', k1, 's'); }
while (mintM[++iM]) mintM[0] = sBau(mintM[0], mintM[iM], 's', 's', '.');
umbau(i, 'r', mintM[0], 's'); }
int Baum::scan11Bau(int tok)
{ int k, kNr, k1; iW = 0;
while (stack[tok])
{ mintW[iW++] = tok;
while (!(!cstack[tok] && stack[tok] == ';')) ++tok;
stack[tok] = 0; ++tok; }
protoScan(0, mintW[0]);
kNr = protoBau(0, mintW[0]);
if (! kNr) kNr = sBau(mintW[0], 1, 'i', 'i', 't');
for (k = 1; k < iW; ++k)
{ protoScan(k, mintW[k]);
k1 = protoBau(k, mintW[k]);
kNr = sBau(kNr, k1, 's', 's', '.'); }
return kNr; }
void Baum::protoScan(int k, int tok)
// deklaration
{ int tPos, tDif; tPos = tok;
while (stack[tPos])
{ if (stack[tPos] == k1_)
{ if (stack[tok] == '~') mintS[k] = 10; // destruktor
else
{ tDif = tPos - tok;
if (tDif == 1) mintS[k] = 1; // konstruktor
else if (tDif == 2) mintS[k] = 2; // standard-function
else mintS[k] = 3; } // funktion mit zeiger- oder referenz-rückgabe
return; }
if (stack[tPos] == '(')
{ if (stack[tok] == '~') mintS[k] = 11; // destruktor mit parametern
else
{ tDif = tPos - tok;
if (tDif == 1) mintS[k] = 4; // konstruktor mit parametern
else if (tDif == 2) mintS[k] = 5; // standard-function mit parametern
else mintS[k] = 6; } // funktion mit parametern und mit zeiger- oder referenz-rückgabe
return; }
++tPos; }
mintS[k] = 0; }
int Baum::protoBau(int kNr, int tok)
{ int k, k1;
switch (mintS[kNr])
{ case 0:
k = sBau(tok, 1, 'i', 'i', 't'); typ1Bau(k); return k;
case 1:
k = sBau(stack[tok], ')', 'w', 'w', 'F'); return k;
case 2:
k = sBau(stack[tok + 1], ')', 'w', 'w', '(');
k = sBau(stack[tok], k, 'w', 's', 'F'); return k;
case 3:
if (stack[tok + 1] == '*') k = sBau('^', stack[tok], 'w', 'w', ' ');
else if (stack[tok + 1] == 185) k = sBau('&', stack[tok], 'w', 'w', ' ');
k1 = sBau(stack[tok + 2], ')', 'w', 'w', '(');
k = sBau(k, k1, 's', 's', 'F'); return k;
case 4:
k = fProtoScan(tok + 2);
if (! k)
{ k = sBau(stack[tok], stack[tok + 2], 'w', 'w', 'F'); return k; }
else
{ k = sBau(stack[tok], k, 'w', 's', 'F'); return k; }
case 5:
k = fProtoScan(tok + 3);
if (! k)
{ k = sBau(stack[tok + 1], stack[tok + 3], 'w', 'w', '(');
k = sBau(stack[tok], k, 'w', 's', 'F'); return k; }
else
{ k = sBau(stack[tok + 1], k, 'w', 's', '(');
k = sBau(stack[tok], k, 'w', 's', 'F'); return k; }
case 6:
k = fProtoScan(tok + 4);
if (stack[tok + 1] == '*') k = sBau('^', stack[tok], 'w', 'w', ' ');
else if (stack[tok + 1] == 185) k = sBau('&', stack[tok], 'w', 'w', ' ');
if (! k)
{ k1 = sBau(stack[tok + 2], stack[tok + 4], 'w', 'w', '(');
k = sBau(k, k1, 's', 's', 'F'); return k; }
else
{ k1 = sBau(stack[tok + 2], k, 'w', 'w', '(');
k = sBau(k, k1, 's', 's', 'F'); return k; }
case 10:
k = sBau('~', stack[tok + 1], 'w', 'w', ' ');
k = sBau(k, ')', 's', 'w', 'F'); return k;
case 11:
k = fProtoScan(tok + 3);
if (! k)
{ k1 = sBau('~', stack[tok + 1], 'w', 'w', ' ');
k = sBau(k1, stack[tok + 3], 's', 'w', 'F'); return k; }
else
{ k1 = sBau('~', stack[tok + 1], 'w', 's', ' ');
k = sBau(k1, k, 's', 'w', 'F'); return k; } }
return 0; }
int Baum::fProtoScan(int tok)
{ int tPos; int iF;
int param[25]; char paramTyp[25];
tPos = tok; iF = 0;
while (stack[tPos] != ')') ++tPos;
stack[tPos] = 0;
if (! stack[tok + 1]) return 0;
loop:
tPos = tok + 1;
if (stack[tPos] == ',')
{ param[iF] = stack[tok]; paramTyp[iF++] = 'w';
tok = ++tPos; goto loop; }
else if (stack[tPos] == '*')
{ param[iF] = sBau('^', stack[tok], 'w', 'w', ' '); paramTyp[iF++] = 's';
if (stack[++tPos] == ',')
{ tok = ++tPos; goto loop; } }
else if (stack[tPos] == 185)
{ param[iF] = sBau('&', stack[tok], 'w', 'w', ' '); paramTyp[iF++] = 's';
if (stack[++tPos] == ',')
{ tok = ++tPos; goto loop; } }
else
{ param[iF] = stack[tok]; paramTyp[iF++] = 'w'; }
param[iF] = 0; iF = 1;
while (param[iF])
{ param[0] = sBau(param[0], param[iF], paramTyp[0], paramTyp[iF], '.');
++iF; paramTyp[0] = 's'; }
return param[0]; }
void Baum::structBaum(int k)
{ int i, worti;
if (iN) //1
{ for (i = 1; i < iN; ++i)
{ mintN[0] = sBau(mintN[0], mintN[i], 's' , 's', '.'); }
while (s[k].t1 == 's') k = s[k].sl;
if (s[k].v == '"') // 2
{ worti = wortI("main");
if (s[k].sl != worti) k = vLSatz(worti);
if (k)
{ k = s[k].sr;
if (s[k].v == 'f')
{ iN = mintN[0]; mintN[0] = k; anbauRl(k, iN, 's', '.'); return; } } }
cout << "kein structEinBau möglich, main fehlt !" << endl; } }
//1 iN : anzahl der strukte
//2 suche main hauptprogramm, strukte werden dort eingehängt
void Baum::iiBaum(int k)
{ int k1;
if (s[k].v == '"')
{ if (s[k].t2 == 's')
{ k1 = s[k].sr;
if (s[k1].v == 'f')
{ fNr = s[k].sl; iiBaum(k1);
stckrset(); stck1 = stack;
mountRek(s[k1].sr); *stck1 = 0;
if (*stack) mountTree();
return; } } }
if (iiFall(s[k].sl, s[k].t1, k, 'l')) iiBaum(s[k].sl);
if (iiFall(s[k].sr, s[k].t2, k, 'r')) iiBaum(s[k].sr); }
void Baum::mountRek(int k)
// arbeitet eine funktion ab
{ if (s[k].v == 'ß') *stck1++ = k;
else
{ if (s[k].t1 == 's') mountRek(s[k].sl);
if (s[k].t2 == 's') mountRek(s[k].sr); } }
void Baum::mountTree()
{ int k, fName;
stck2 = stck1 = stack;
while (*stck1)
{ k = *stck1++;
txt1 = tex; *txt1++ = ':'; txt2 = w[fNr].st;
while (*txt2) *txt1++ = *txt2++;
*txt1 = 0; fName = wortI(tex);
umbau(k, 'r', fName, 'w'); s[k].v = '}'; } }
char Baum::iiFall(int k, char t, int wrzl, char lr)
{ if (t == 's')
{ if (s[k].t1 == 'i' && s[k].t2 == 'i')
{ if (lr == 'l')
{ k = iiBau(k, t);
umbau(wrzl, 'l', k, t); return 0; }
else
{ k = iiBau(k, t);
umbau(wrzl, 'r', k, t); return 0; } }
return 1; }
return 0; }
int Baum::iiBau(int k, char& t)
{ int tEnd;
tok = s[k].sl; tEnd = s[k].sr;
k = iiRek(tEnd, t);
return k; }
int Baum::iiRek(int tEnd, char& t)
{ int tPos, tok0, kL, kR, k; char tL;
if (! cstack[tok] && stack[tok] == '(')
{ ++tok; tPos = klammerZu(tok, '(', ')');
if (tPos - tok == 2)
{ t = cstack[tok]; k = stack[tok]; }
else k = iiRek(tPos - 1, t);
if (tPos < tEnd)
{ if (castFall(k, t))
{ kL = k; tL = t;
tok = tPos; kR = iiRek(tEnd, t);
k = sBau(kL, kR, tL, t, '§');
t = 's'; return k; }
stack[tPos - 1] = k; cstack[tPos - 1] = t;
tok = tPos - 1; }
else return k; }
if (! cstack[tok] && stack[tok] == '[')
{ ++tok; tPos = klammerZu(tok, '[', ']');
k = iiRek(tPos - 1, t);
if (tPos < tEnd)
{ stack[tPos - 1] = k; cstack[tPos - 1] = t;
tok = tPos - 1; }
else return k; }
if (cstack[tok] == 's')
{ k = stack[tok];
if (s[k].sl == '^')
{ kL = k; tL = 's';
++tok; kR = iiRek(tEnd, t);
if (t == 'w')
{ k = sBau(kR, kL, 'w', 's', '"'); t = 's'; }
else
{ iS = 0; nachBauZ(kL , kR); nachBauZ1(kL);
k = mintS[0]; t = 's'; }
return k; } }
if (tEnd - tok == 2)
{ if (cstack[tok] && cstack[tok + 1])
{ k = sBau(stack[tok], stack[tok + 1], cstack[tok], cstack[tok + 1], ' ');
k = nachBau(k); t = 's'; return k; } }
tPos = tok;
if (tEnd - tok <= 1)
{ k = stack[tok]; t = cstack[tok]; return k; }
if (cstack[tPos] == 'w' && stack[tPos] == '}')
{ kL = '}';
++tok; kR = iiRek(tEnd, t);
k = sBau(kR, kL, t, 'w', ' ');
t = 's'; return k; }
if (cstack[tPos] && cstack[tPos + 1])
{ if (cstack[tok] == 'w' && datenTyp(stack[tok]))
{ kL = stack[tok]; tL = cstack[tok];
++tok;
kR = iiRek(tEnd, t);
k = sBau(kL, kR, tL, t, ' ');
k = nachBau(k); t = 's'; return k; } }
while (tPos < tEnd)
{ if (! cstack[tPos] && stack[tPos] == '(')
{ tPos = klammerZu(tPos + 1, '(',')'); continue; }
if (! cstack[tPos] && stack[tPos] == '[')
{ tPos = klammerZu(tPos + 1, '[',']'); continue; }
if (! cstack[tPos])
{ if (stack[tPos] == ',')
{ kL = iiRek(tPos, t); tL = t;
tok = tPos + 1;
kR = iiRek(tEnd, t);
k = sBau(kL, kR, tL, t, '.');
t = 's'; return k; } }
++tPos; }
tPos = tok;
while (tPos < tEnd)
{ if (! cstack[tPos] && stack[tPos] == '(')
{ tPos = klammerZu(tPos + 1, '(',')'); continue; }
if (! cstack[tPos] && stack[tPos] == '[')
{ tPos = klammerZu(tPos + 1, '[',']'); continue; }
if (! cstack[tPos])
{ if (stack[tPos] == '=')
{ kL = iiRek(tPos, t); tL = t;
if (! kL)
{ kL = mintM[iM - 1]; tL = s[kL].t2; kL = s[kL].sr; }
tok = tPos + 1;
kR = iiRek(tEnd, t);
k = sBau(kL, kR, tL, t, '=');
t = 's'; return k; } }
++tPos; }
tPos = tok;
while (tPos < tEnd)
{ if (! cstack[tPos] && stack[tPos] == '(')
{ tPos = klammerZu(tPos + 1, '(',')'); continue; }
if (! cstack[tPos] && stack[tPos] == '[')
{ tPos = klammerZu(tPos + 1, '[',']'); continue; }
if (! cstack[tPos])
{ if (stack[tPos] == 'C')
{ kL = iiRek(tPos, t); tL = t;
tok = tPos + 1;
kR = iiRek(tEnd, t);
k = sBau(kL, kR, tL, t, '.');
if (tL == 'w' && (kL == '!' || kL == '?')) s[k].v = ' ';
t = 's'; return k; } }
++tPos; }
tPos = tok;
while (tPos < tEnd)
{ if (! cstack[tPos] && stack[tPos] == '(')
{ tPos = klammerZu(tPos + 1, '(',')'); continue; }
if (! cstack[tPos] && stack[tPos] == '[')
{ tPos = klammerZu(tPos + 1, '[',']'); continue; }
if (! cstack[tPos])
{ if (stack[tPos] == '|')
{ kL = iiRek(tPos, t); tL = t;
tok = tPos + 1;
kR = iiRek(tEnd, t);
k = sBau(kL, kR, tL, t, '|');
t = 's'; return k; } }
++tPos; }
tPos = tok;
while (tPos < tEnd)
{ if (! cstack[tPos] && stack[tPos] == '(')
{ tPos = klammerZu(tPos + 1, '(',')'); continue; }
if (! cstack[tPos] && stack[tPos] == '[')
{ tPos = klammerZu(tPos + 1, '[',']'); continue; }
if (! cstack[tPos])
{ if (stack[tPos] == '&')
{ kL = iiRek(tPos, t); tL = t;
tok = tPos + 1;
kR = iiRek(tEnd, t);
k = sBau(kL, kR, tL, t, '&');
t = 's'; return k; } }
++tPos; }
tPos = tok;
while (tPos < tEnd)
{ if (! cstack[tPos] && stack[tPos] == '(')
{ tPos = klammerZu(tPos + 1, '(',')'); continue; }
if (! cstack[tPos] && stack[tPos] == '[')
{ tPos = klammerZu(tPos + 1, '[',']'); continue; }
if (! cstack[tPos])
{ if (stack[tPos] == '?')
{ kL = iiRek(tPos, t); tL = t;
tok = tPos + 1;
kR = iiRek(tEnd, t);
k = sBau(kL, kR, tL, t, '?');
t = 's'; return k; }
if (stack[tPos] == 191)
{ kL = iiRek(tPos, t); tL = t;
tok = tPos + 1;
kR = iiRek(tEnd, t);
k = sBau(kL, kR, tL, t, '¿' );
t = 's'; return k; } }
++tPos; }
tPos = tok;
while (tPos < tEnd)
{ if (! cstack[tPos] && stack[tPos] == '(')
{ tPos = klammerZu(tPos + 1, '(',')'); continue; }
if (! cstack[tPos] && stack[tPos] == '[')
{ tPos = klammerZu(tPos + 1, '[',']'); continue; }
if (! cstack[tPos])
{ if (stack[tPos] == '<')
{ kL = iiRek(tPos, t); tL = t;
tok = tPos + 1;
kR = iiRek(tEnd, t);
k = sBau(kL, kR, tL, t, '<');
t = 's'; return k; }
if (stack[tPos] == '>')
{ kL = iiRek(tPos, t); tL = t;
tok = tPos + 1;
kR = iiRek(tEnd, t);
k = sBau(kL, kR, tL, t, '>' );
t = 's'; return k; }
if (stack[tPos] == 171)
{ kL = iiRek(tPos, t); tL = t;
tok = tPos + 1;
kR = iiRek(tEnd, t);
k = sBau(kL, kR, tL, t, '«');
t = 's'; return k; }
if (stack[tPos] == 187)
{ kL = iiRek(tPos, t); tL = t;
tok = tPos + 1;
kR = iiRek(tEnd, t);
k = sBau(kL, kR, tL, t, '»' );
t = 's'; return k; } }
++tPos; }
tPos = tok;
while (tPos < tEnd)
{ if (! cstack[tPos] && stack[tPos] == '(')
{ tPos = klammerZu(tPos + 1, '(',')'); continue; }
if (! cstack[tPos] && stack[tPos] == '[')
{ tPos = klammerZu(tPos + 1, '[',']'); continue; }
if (! cstack[tPos])
{ if (stack[tPos] == '+')
{ kL = iiRek(tPos, t); tL = t;
tok = tPos + 1;
kR = iiRek(tEnd, t);
k = sBau(kL, kR, tL, t, '+');
t = 's'; return k; }
if (stack[tPos] == '-')
{ kL = iiRek(tPos, t); tL = t;
tok = tPos + 1;
kR = iiRek(tEnd, t);
k = sBau(kL, kR, tL, t, '-' );
t = 's'; return k; } }
++tPos; }
tPos = tok;
while (tPos < tEnd)
{ if (! cstack[tPos] && stack[tPos] == '(')
{ tPos = klammerZu(tPos + 1, '(',')'); continue; }
if (! cstack[tPos] && stack[tPos] == '[')
{ tPos = klammerZu(tPos + 1, '[',']'); continue; }
if (! cstack[tPos])
{ if (stack[tPos] == '*')
{ kL = iiRek(tPos, t); tL = t;
tok = tPos + 1;
kR = iiRek(tEnd, t);
k = sBau(kL, kR, tL, t, '*');
t = 's'; return k; }
if (stack[tPos] == '/')
{ kL = iiRek(tPos, t); tL = t;
tok = tPos + 1;
kR = iiRek(tEnd, t);
k = sBau(kL, kR, tL, t, '/' );
t = 's'; return k; }
if (stack[tPos] == '%')
{ kL = iiRek(tPos, t); tL = t;
tok = tPos + 1;
kR = iiRek(tEnd, t);
k = sBau(kL, kR, tL, t, '%');
t = 's'; return k; } }
++tPos; }
tPos = tok;
while (tPos < tEnd)
{ if (! cstack[tPos] && stack[tPos] == '(')
{ tPos = klammerZu(tPos + 1, '(',')'); continue; }
if (! cstack[tPos] && stack[tPos] == '[')
{ tPos = klammerZu(tPos + 1, '[',']'); continue; }
if (cstack[tPos] == 'w')
{ if (stack[tPos] == 176 || stack[tPos] == '-' || stack[tPos] == 191 || stack[tPos] == '^')
{ if (tok == tPos)
{ tok = tPos + 1;
kR = iiRek(tEnd, t);
k = sBau(stack[tPos], kR, 'w', t, ' '); }
else
{ kL = iiRek(tPos, t); tL = t;
tok = tPos;
kR = iiRek(tEnd, t);
k = sBau(kL, kR, tL, t, ' '); }
t = 's'; return k; } }
++tPos; }
tPos = tok; // foo(), *(..), --(..)
while (tPos < tEnd)
{ if (! cstack[tPos] && stack[tPos] == '[')
{ tPos = klammerZu(tPos + 1, '[',']'); continue; }
if (! cstack[tPos] && stack[tPos] == '(')
{ tok0 = tok; tok = tPos;
kR = iiRek(tEnd, t); --tPos;
if (stack[tPos] != fNr)
{ if (stack[tPos] == 176 || stack[tPos] == '-' || stack[tPos] == 191 || stack[tPos] == '^')
k = sBau(stack[tPos], kR, 'w' , t, ' ');
else if (stack[tPos] == pp_)
k = sBau(kR, '+', t, 'w', '(');
else if (stack[tPos] == mm_)
k = sBau(kR, '-', t, 'w', '(');
else k = sBau(kR, stack[tPos], t, cstack[tPos], '}'); }
else k = sBau(kR,stack[tPos], t, cstack[tPos], 'ß');
if (tPos - tok0)
{ stack[tPos] = k; cstack[tPos] = 's';
tok = tok0; k = iiRek(tPos + 1, t); }
t = 's'; return k; }
++tPos; }
tPos = tok; // ->
while (tPos < tEnd)
{ if (! cstack[tPos] && stack[tPos] == '(')
{ tPos = klammerZu(tPos + 1, '(',')'); continue; }
if (! cstack[tPos] && stack[tPos] == '[')
{ tPos = klammerZu(tPos + 1, '[',']'); continue; }
if (! cstack[tPos])
{ if (stack[tPos] == '^')
{ kL = iiRek(tPos, t); tL = t;
tok = tPos + 1;
kR = iiRek(tEnd, t);
k = sBau(kL, kR, tL, t, '^');
t = 's'; return k; } }
++tPos; }
tPos = tok; // .
while (tPos < tEnd)
{ if (! cstack[tPos] && stack[tPos] == '(')
{ tPos = klammerZu(tPos + 1, '(',')'); continue; }
if (! cstack[tPos] && stack[tPos] == '[')
{ tPos = klammerZu(tPos + 1, '[',']'); continue; }
if (! cstack[tPos])
{ if (stack[tPos] == '.')
{ kL = iiRek(tPos, t); tL = t;
tok = tPos + 1;
kR = iiRek(tEnd, t);
k = sBau(kL, kR, tL, t, 'o');
t = 's'; return k; } }
++tPos; }
tPos = tok; // #
while (tPos < tEnd)
{ if (! cstack[tPos] && stack[tPos] == '(')
{ tPos = klammerZu(tPos + 1, '(',')'); continue; }
if (! cstack[tPos] && stack[tPos] == '[')
{ tPos = klammerZu(tPos + 1, '[',']'); continue; }
if (! cstack[tPos])
{ if (stack[tPos] == '#')
{ kL = iiRek(tPos, t); tL = t;
tok = tPos + 1;
kR = iiRek(tEnd, t);
k = sBau(kL, kR, tL, t, '#');
t = 's'; return k; } }
++tPos; }
tPos = tok; // array[]
while (tPos < tEnd)
{ if (! cstack[tPos] && stack[tPos] == '(')
{ tPos = klammerZu(tPos + 1, '(',')'); continue; }
if (! cstack[tPos] && stack[tPos] == '[')
{ tok0 = tok; tok = tPos;
kR = iiRek(tEnd, t); --tPos;
k = sBau(stack[tPos], kR, cstack[tPos], t, '[');
if (tPos - tok0)
{ stack[tPos] = k; cstack[tPos] = 's';
tok = tok0; k = iiRek(tPos + 1, t); }
t = 's'; return k; }
++tPos; }
t = 'w'; return auto_; }
char Baum::castFall(int k, char t)
{ if (t == 'w') return datenTyp(k);
if (s[k].v == ' ' && s[k].sl == '^' && s[k].t2 == 'w') return datenTyp(s[k].sr);
return 0; }
int Baum::nachBau(int k)
{ int sl, sr, t1, t2; char v;
sl = s[k].sl; sr = s[k].sr; t1 = s[k].t1; t2 = s[k].t2;
if (t2 == 'w')
{ if (sr == pp_ )
{ s[k].lc = OUTLOC; k = sBau(sl, '+', t1, 'w', ')'); return k; }
if (sr == mm_)
{ s[k].lc = OUTLOC; k = sBau(sl, '-', t1, 'w', ')'); return k; } }
if (t1 == 'w')
{ if (sl == pp_)
{ s[k].lc = OUTLOC; k = sBau(sr, '+', t2, 'w', '('); return k; }
if (sl == mm_)
{ s[k].lc = OUTLOC; k = sBau(sr, '-', t2, 'w', '('); return k; }
if (sl == new_)
{ v = s[k].v = '"'; return k; }
if (sl == delete_ || sl == '}')
{ s[k].v = ' '; return k; } }
if (t2 == 'w' && s[k].sr == k1_)
{ CntrlU(k);
if (fNr == s[k].sr) s[k].v = 'ß';
else s[k].v = '}';
return k; }
if (s[k].v == ' ')
{ if (t2 == 'w')
{ if (t1 == 's')
{ if (s[sl].t1 == 'w')
{ if (s[sl].sl == '^')
{ s[k].v = '^'; abbauLl(k); }
else if (s[sl].sl == 176)
{ s[k].v = 'r'; abbauLl(k); } } } }
else if (t2 == 's' && s[sr].v == '[')
{ if (t1 == 'w' && (sl == 176 || sl == '^' || sl == 191 || sl == '-')) return k;
umbau(k, 'l', s[sr].sl, s[sr].t1); umbau(sr, 'l', sl, t1); s[k].v = '"'; } }
return k; }
void Baum::nachBauZ(int kL, int k)
{ if (s[k].v == '[')
{ mintS[iS] = sBau(kL, s[k].sr, 's', s[k].t2, '[');
mintS[iS] = sBau(s[k].sl, mintS[iS], 'w', 's', '"');
++iS; mintS[iS] = 's'; ++iS; return; }
if (s[k].t1 == 's')
{ if (s[s[k].sl].v == '.') nachBauZ(kL, s[k].sl);
else if (s[s[k].sl].v == ' ')
{ if (s[s[k].sl].t2 == 's') nachBauZ(kL, s[s[k].sl].sr);
else
{ mintS[iS] = s[s[k].sl].sr; ++iS;
mintS[iS] = 'w'; ++iS; } }
else if (s[s[k].sl].v == '[') nachBauZ(kL, s[k].sl); }
else
{ mintS[iS] = s[k].sl; ++iS;
mintS[iS] = 'w'; ++iS; }
if (s[k].t2 == 's')
{ if (s[s[k].sr].v == '.') nachBauZ(kL, s[k].sr);
else if (s[s[k].sr].v == ' ')
{ if (s[s[k].sr].t2 == 's') nachBauZ(kL, s[s[k].sr].sr);
else
{ mintS[iS] = s[s[k].sr].sr; ++iS;
mintS[iS] = 'w'; ++iS; } } }
else
{ mintS[iS] = s[k].sr; ++iS;
mintS[iS] = 'w'; ++iS; } }
void Baum::nachBauZ1(int k)
{ int i;
if (mintS[1] == 'w') mintS[0] = sBau(mintS[0], k, 'w', 's', '"');
for (i = 2; i < iS; i+= 2)
{ if (mintS[i+1] == 'w') mintS[i] = sBau(mintS[i], k, 'w', 's', '"');
mintS[0] = sBau(mintS[0], mintS[i], 's', 's', '.'); } }
void Baum::hashRek(int k)
{ int sl, sr;
if (s[k].v == '#')
{ hashBau(k); return; }
sl = s[k].sl; sr = s[k].sr;
if (s[k].t1 == 's') hashRek(sl);
if (s[k].t2 == 's') hashRek(sr);
}
void Baum::hashBau(int kNr)
{ int k;
while (s[kNr].t2 == 's' && s[s[kNr].sr].v == '#')
{ k = s[s[kNr].sr].sl; abbauRl(kNr); anbauLr(kNr, k, 'w', '#'); } }
void Baum::castRek(int k)
{ int sl, sr;
if (s[k].v == 'f') k = s[k].sr;
sl = s[k].sl; sr = s[k].sr;
if (s[k].v == '}')
{ if (s[k].t2 == 'w')
{ if (datenTyp(sr))
{ CntrlU(k); s[k].v = '§'; return;
} }
else if (s[sr].t1 == 'w' && s[sr].sl == '^')
{ CntrlU(k); s[k].v = '§'; return; } }
if (s[k].t1 == 's') castRek(sl);
if (s[k].t2 == 's') castRek(sr); }
void Baum::varBaum(int kNr)
{ int k;
if (s[kNr].v == '"')
{ if (s[kNr].t2 == 's')
{ k = s[kNr].sr;
if (s[k].v == 'f')
{ iM = 0; eqClr(s[k].sr); declClr(k);
varBau(k); return; } } }
if (s[kNr].t1 == 's') varBaum(s[kNr].sl);
if (s[kNr].t2 == 's') varBaum(s[kNr].sr); }
void Baum::eqClr(int k)
{ if (s[k].v == '=')
{ if (s[k].t1 == 's')
{ ast = s[k].sl;
if (s[ast].v == ' ')
{ if (s[ast].t1 == 'w')
{ if (datenTyp(s[ast].sl))
{ mintM[iM] = ast; ++iM;
umbau(k, 'l', s[ast].sr, s[ast].t2); } }
else
{ li = s[ast].sl;
if (s[li].sl == '^' || s[li].sl == 176)
{ mintM[iM] = ast; ++iM;
umbau(k, 'l', s[ast].sr, s[ast].t2); } } } }
return; }
if (s[k].t1 == 's') eqClr(s[k].sl);
if (s[k].t2 == 's') eqClr(s[k].sr); }
void Baum::declClr(int k)
{ int sL, sR;
sL = 0; sR = 0;
if (s[k].v == ' ')
{ ast = s[k].sl;
if (s[k].t1 == 'w')
{ if (datenTyp(ast))
{ mintM[iM] = k; ++iM;
s[k].lc = 1; } }
else if (s[ast].sl == '^' || s[ast].sl == 176)
{ mintM[iM] = k; ++iM;
s[k].lc = 1; }
return; }
if (s[k].v == '"')
{ ast = s[k].sr;
if (s[k].t2 == 's')
{ if (s[ast].v == ' ' || s[ast].v == '[')
{ mintM[iM] = k; ++iM;
s[k].lc = 1; } }
return; }
if (s[k].v != '.' && s[k].v != 'f') return;
if (s[k].v == '.')
{ if (s[k].t1 == 's')
{ sL = s[k].sl; declClr(sL);
if (s[sL].lc == 2)
{ umbau(k, 'l', s[sL].sr, s[sL].t2); }
else if (s[sL].lc == 3)
{ umbau(k, 'l', s[sL].sl, s[sL].t1); } } }
if (s[k].t2 == 's')
{ sR = s[k].sr; declClr(sR);
if (s[sR].lc == 2)
{ umbau(k, 'r', s[sR].sr, s[sR].t2); }
else if (s[sR].lc == 3)
{ umbau(k, 'r', s[sR].sl, s[sR].t1); } }
if (sL)
{ if (s[sL].lc == 1)
{ if (sR)
{ if (s[sR].lc == 1)
{ s[k].lc = 1; return; } }
s[k].lc = 2; return; } }
if (sR)
{ if (s[sR].lc == 1)
{ s[k].lc = 3; } } }
void Baum::varBau(int kNr)
{ int i, k, kk;
i = k = 0;
while (i < iM)
{ kk = mintM[i]; ++i;
if (! k) k = kk;
else k = sBau(k, kk, 's', 's', '.'); }
if (i)
{ if (s[kNr].t1 == 's')
{ kk = s[kNr].sl;
if (s[kk].v == '}')
{ k = sBau(s[kk].sl, k, s[kk].t1, 's', '·');
k = sBau(k, s[kk].sr, 's', s[kk].t2, '}'); }
else k = sBau(kk, k, 's', 's', '·');
umbau(kNr, 'l', k, 's'); }
else umbau(kNr, 'l', k, 's'); } }
void Baum::equalBaum(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 == 'f')
{ if (t1 == 's')
{ iM = 0; eqBaumRek(sl);
if (iM)
{ sl = mintM[0]; nr = 1;
while (nr < iM)
{ sr = mintM[nr];
sl = sBau(sl, sr, 's', 's', ' '); s[sl].v = '.';
++nr; }
anbauRl(k, sl, 's', '.');
k = s[k].sr; } }
equalBaum(s[k].sr); }
else
{ if (t1 == 's') equalBaum(sl);
if (t2 == 's') equalBaum(sr); } }
void Baum::eqBaumRek(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')
{ if (s[sl].v == '=')
{ mintM[iM] = sl; ++iM; }
else eqBaumRek(sl); }
if (t2 == 's')
{ if (s[sr].v == '=')
{ mintM[iM] = sr; ++iM; }
else eqBaumRek(sr); } }
void Baum::equalBaumClr(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 == 'f')
{ if (t1 == 's') eqBaumClrRek(sl); }
else
{ if (t1 == 's') equalBaumClr(sl);
if (t2 == 's') equalBaumClr(sr); } }
void Baum::eqBaumClrRek(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')
{ if (s[sl].v == '=') abbauLr(k);
else eqBaumClrRek(sl); }
if (t2 == 's')
{ if (s[sr].v == '=') abbauRr(k);
else eqBaumClrRek(sr); } }
void Baum::switchBaum(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 != '"')
{ if (t1 == 's') switchBaum(sl);
if (t2 == 's') switchBaum(sr); }
else
{ if (sl != case_)
{ if (t2 == 's') switchBaum(sr); }
else caseBaum(sr); } }
void Baum::caseBaum(int k)
{ if (s[k].v == ',') caseDel(k);
else
{ caseBaum(s[k].sl); caseBaum(s[k].sr); } }
void Baum::caseDel(int kNr)
{ int k[50]; int kI;
k[0] = kNr; kI = 1;
while (s[kNr].t2 == 's')
{ k[kI] = kNr = s[kNr].sr; ++kI; }
if (s[kNr].sr == break_)
{ kNr = k[kI - 2];
abbauRr(kNr); } }
void Baum::copyTree(int kNr)
{ int k, kk, kf, i;
iM = 0; mainList(root);
loc = STDLOC; k = 0;
for (i = 0; i < iM; ++i)
{ kk = mintM[i]; iF = 0;
kf = copyTreeRek(s[kk].sr);
if (kf != s[kk].sr) kk = sBau(s[kk].sl, kf, 'w', 's', '"');
if (! k) k = kk;
else k = sBau(k, kk, 's', 's', '.'); }
root = k;
baumLoc(kNr);
if (! s[root].b) s[kNr].lc = OUTLOC; }
void Baum::mainList(int k)
{ if (s[k].v == '"' && s[k].t2 == 's')
{ ast = s[k].sr;
if (s[ast].v == 'f')
{ fNr = s[k].sl;
if (! vSatz(fNr, 'w', '}'))
{ mintM[iM] = k; ++iM; }
return; } }
if (s[k].t1 == 's') mainList(s[k].sl);
if (s[k].t2 == 's') mainList(s[k].sr); }
int Baum::copyTreeRek(int k)
{ int sl, sr, sL, sR; char tL, tR;
sl = s[k].sl; sr = s[k].sr;
if (s[k].v == 'f')
{ sL = sl; tL = s[k].t1;
sR = copyTreeRek(sr); tR = 's';
if (sR == sr) return k;
else return sBau(sL, sR, tL, tR, 'f'); }
if (s[k].t1 == 'w')
{ sL = sl; tL = 'w'; }
else
{ sL = copyTreeRek(sl); tL = 's'; }
if (s[k].v == '}')
{ if (s[k].t2 == 'w')
{ if (inRekList(sr))
{ txt1 = w[sr].st;
txt2 = tex;
*txt2++ = ':';
while (*txt1) *txt2++ = *txt1++;
*txt2 = 0; sR = wortI(tex); tR = 'w'; }
else
{ if (vSatz(sr, 'w', '"'))
{ mintF[iF] = sr; ++iF;
sR = copyTreeRek(rSatz); tR = 's'; --iF; } //1
else
{ sR = sr; tR = 'w'; } } }
else
{ sR = sr; tR = 's'; }
if (sL == sl && sR == sr && tL == s[k].t1 && tR == s[k].t2) return k;
else return sBau(sL, sR, tL, tR, '}'); }
if (s[k].t2 == 'w')
{ if (sL == sl && tL == s[k].t1)
{ s[k].lc = STDLOC; return k; }
return sBau(sL, sr, tL, 'w', s[k].v); }
sR = copyTreeRek(sr); tR = 's';
if (sL == sl && sR == sr && tL == s[k].t1 && tR == s[k].t2)
{ s[k].lc = STDLOC; return k; }
return sBau(sL, sR, tL, tR, s[k].v); }
//1: rSatz : erstes glied der rückzeigerkette
char Baum::inRekList(int fName)
{ int i;
for (i = 0; i < iF; ++i)
{ if (fName == mintF[i]) return 1; }
return 0; }
void Baum::k1Del(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' && s[sl].v == '}')
{ if (s[sl].t1 == 'w' && s[sl].sl == k1_)
{ umbau(k, 'l', s[sl].sr, s[sl].t2);
sl = s[k].sl; t1 = s[k].t1; } }
if (t1 == 's') k1Del(sl);
if (s[k].v == '"' && t2 == 's') k = sr;
if (t2 == 's' && s[sr].v == '}')
{ if (s[sr].t1 == 'w' && s[sr].sl == k1_)
{ umbau(k, 'r', s[sr].sr, s[sr].t2);
sr = s[k].sr; t2 = s[k].t2; } }
if (t2 == 's') k1Del(sr); }
void Baum::structUmbau()
{ int k;
k = mintN[0];
abbauRl(k);
if (s[k].t1 == 's')
{ k = s[k].sl;
if (s[k].v == '}')
{ if (s[k].t1 == 's') k = s[k].sl;
else cout << "kein structEinBau möglich!" << endl; }
if (s[k].v == '·') anbauRl(k, iN, 's', '.');
return; }
cout << "kein structEinBau möglich!" << endl; }
//1 iN : structBaum
void Baum::zeigerUmbau(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].sl == '^')
{ s[k].v = '^'; CntrlU(k);
umbau(k, 'l', s[sr].sr, 'w');
return; }
if (s[k].v == 'r') //1
{ wrzl = s[k].h;
if (s[wrzl].v != '=')
{ umbau(k, 'l', ':', 'w'); s[k].v = ' '; return; }
umbau(wrzl, 'l', sr, 'w');
s[wrzl].v = ':'; CntrlU(wrzl);
Ast = wrzl; ast = s[wrzl].sl;
satzi = wrzl = s[Ast].h;
while (s[wrzl].v != 'f') wrzl = s[wrzl].h;
refUmbau(s[wrzl].sl);
wrzl = s[satzi].h;
if (Ast == s[satzi].sl)
{ if (satzi == s[wrzl].sl) umbau(wrzl, 'l', s[satzi].sr, s[satzi].t2);
else umbau(wrzl, 'l', s[satzi].sl, s[satzi].t1); }
else
{ if (satzi == s[wrzl].sl) umbau(wrzl, 'r', s[satzi].sr, s[satzi].t2);
else umbau(wrzl, 'r', s[satzi].sl, s[satzi].t1); }
return; }
if (t1 == 's')
{ s[sl].h = k; zeigerUmbau(sl); }
if (t2 == 's')
{ s[sr].h = k; zeigerUmbau(sr); } }
//1 referenz
void Baum::refUmbau(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') refUmbau(sl);
else if (s[k].sl == ast) umbau(k, 'l', Ast, 's');
if (t2 == 's') refUmbau(sr);
else if (s[k].sr == ast) umbau(k, 'r', Ast, 's'); }
void Baum::newUmbau(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].sl == new_)
{ if (s[sr].t2 == 's')
{ s[k].v = '"';
sr = sBau('[', s[s[sr].sr].sr, 'w', s[s[sr].sr].t2, ' ');
umbau(k, 'r', sr, 's'); }
else
{ s[k].v = ' '; umbau(k, 'l', '[', 'w'); umbau(k, 'r', sl, t1); }
return; }
else if (s[k].v == ' ' && t2 == 's')
{ if (sl == mm_)
{ umbau(k, 'l', '-', 'w'); s[k].v = '('; CntrlU(k); }
else if (sl == pp_)
{ umbau(k, 'l', '+', 'w'); s[k].v = '('; CntrlU(k); }
return; }
if (t1 == 's') newUmbau(sl);
if (t2 == 's') newUmbau(sr); }
void Baum::retUmbau(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 == '§')
{ if (t1 == 's')
// && s[sl].v == ' ' && s[sl].t1 == 'w' && s[sl].sl == '^' && s[sl].t2 == 'w')
{ umbau(k, 'l', s[sl].sr, 'w'); s[k].v = '^'; }
else s[k].v = ' '; }
if (t1 == 's') retUmbau(sl);
else if (s[k].sl == 183 && s[k].v == ' ')
{ CntrlU(k); s[k].v = '}'; }
if (t2 == 's') retUmbau(sr); }]]>
back to
baumC