bool E34::transition(Automate& automate, Symbole* symbole) throw(std::pair<int, string>) {
switch (symbole->getType())
{
case(VG) :
automate.decalageTerminal(symbole, new E35);
return true;
case(PVG) :
automate.decalageTerminal(symbole, new E39);
return true;
case(ID) :
Symbole* symboleAnticipe = new Symbole();
symboleAnticipe->setType(VG);
automate.decalageAnticipe(symboleAnticipe, new E35);
std::pair<int, string> p = std::make_pair(0, "Erreur syntaxique symbole \",\" attendu");
throw(p);
return true;
}
Symbole* symboleAnticipe = new Symbole();
symboleAnticipe->setType(PVG);
automate.decalageAnticipe(symboleAnticipe, new E39);
std::pair<int, string> p = std::make_pair(0, "Erreur syntaxique symbole \";\" attendu");
throw(p);
return true;
}
void Etat28::transition(Automate* a, Symbole* s)
{
#ifdef MAP
std::cout << "Etat28" << std::endl;
#endif
switch(*s){
case Symbole::OPERATEUR_MUL:
a->pushSymbole(s);
//~ a->pushEtat(new Etat29());
a->pushEtat(Etat29::getInstance());
a->decaler();
break;
case Symbole::POINT_VIR:
case Symbole::PARENTHESE_FER:
case Symbole::OPERATEUR_ADD:
{
Symbole* symbole = a->topSymbole();
symbole->setType(Symbole::EXPRESSION);
a->popEtat();
a->etatCourant()->transition(a, symbole);
}
break;
default:
throw ExceptionSymbole(s, ExceptionSymbole::symbole_non_attendu);
break;
}
}
//----------------------------------------------------- Méthodes publiques
void Etat33::transition(Automate* const automate, Symbole* symbole)
{
for (int i = 0; i < 3; i++)
automate->popEtat();
//pour ne pas avoir a créer une classe par opérateur, nous n'avons pas
//dépilé le MUL ou DIV de l'état 29/30
Exp* f = (Exp*)automate->popSymbole();
delete automate->popSymbole();//Symbole OPM
Symbole* op = automate->popSymbole(); //Symbole MUL ou DIV
Exp* t = (Exp*)automate->popSymbole();
if(op->getId() == MUL)
{
automate->pushSymbole(new ExpMult(t, f));
automate->transitionReduction();
}
else
{
automate->pushSymbole(new ExpDiv(t, f));
automate->transitionReduction();
}
delete op;
}
SymboleValue::SymboleValue(const Symbole & s) :
Symbole(s.getChaine()) {
if (s == "<ENTIER>") {
m_valeur = atoi(s.getChaine().c_str()); // c_str convertit une string en char*
m_defini = true;
} else {
m_defini = false;
}
}
void Etat24::transition(Automate* a, Symbole* ) //réduction règle 17
{
#ifdef MAP
std::cout << "Etat24" << std::endl;
#endif
Symbole* terme = a->topSymbole();
terme->setType(Symbole::TERME);
a->popEtat();
a->etatCourant()->transition(a, terme);
}
SymboleValue::SymboleValue(Symbole s) : Symbole(s.getChaine())
{
defini = true;
if (s == "<ENTIER>")
setValeur(new ValeurEntiere(atoi(s.getChaine().c_str())));
else if (s == "<CHAINE>")
setValeur(new ValeurChaine(s.getChaine().c_str()));
else {
val = NULL;
defini = false;
}
}
void Syntaxe::lignesdonnees() {
Symbole s;
Arbre *a;
while (lex.GetId() == FIN_LIGNE) {
lex.Read();
}
switch (lex.GetId()) {
case ID :
// initialisation de la valeur de l'ID
s = lex.GetSymb();
if (s.GetInit()) {
// Erreur : symbole déjà rencontré
std::wcerr << L"Erreur ligne " << lex.GetLine() << L" colonne " << lex.GetColumn() << L"\u00a0: " << L"le label " << s.GetText() << " est déjà déclaré." << std::endl;
err = true;
} else s.SetValue(cData);
lex.Read();
if (lex.GetId() != DEUX_POINTS) {
// ERREUR : il faut :
std::wcerr << L"Erreur ligne " << lex.GetLine() << L" colonne " << lex.GetColumn() << L"\u00a0: " << L"':' attendu." << std::endl;
err = true;
} else lex.Read();
lignesdonnees();
break;
case NOMBRE :
case MOINS:
case NON:
case PGAUCHE :
a = nivn(7);
a->Evaluate();
if (a->GetType() != UNDEFINED)
cData += a->GetValue(); // met à jour le compteur de données.
delete a;
if (lex.GetId() != FIN_LIGNE) {
// ERREUR : il faut un saut de ligne
std::wcerr << L"Erreur ligne " << lex.GetLine() << L" colonne " << lex.GetColumn() << L"\u00a0: " << L"la déclaration d'une zone de données doit être suivie d'un saut de ligne." << std::endl;
err = true;
while (lex.GetId() != FIN_LIGNE) lex.Read();
}
lex.Read();
lignesdonnees();
break;
default :
// cas epsilon
break;
}
}
void Syntaxe::lignescode() {
Liste *l;
Symbole s;
int i;
unsigned int t;
while (lex.GetId() == FIN_LIGNE) {
lex.Read();
}
switch (lex.GetId()) {
case ID :
// initialisation de la valeur de l'ID
s = lex.GetSymb();
if (s.GetInit()) {
// Erreur : symbole déjà rencontré
std::wcerr << L"Erreur ligne " << lex.GetLine() << L" colonne " << lex.GetColumn() << L"\u00a0: " << L"le label " << s.GetText() << " est déjà déclaré." << std::endl;
err = true;
} else s.SetValue(cCode);
lex.Read();
if (lex.GetId() != DEUX_POINTS) {
// ERREUR : il faut :
std::wcerr << L"Erreur ligne " << lex.GetLine() << L" colonne " << lex.GetColumn() << L"\u00a0: " << L"':' attendu." << std::endl;
err = true;
} else lex.Read();
lignescode();
break;
case INSTR :
// MAJ de la pile d'instructions.
*lCurrent = Liste(lex.GetIdbis(), lex.GetLine());
lex.Read();
// lecture des opérandes et de finligne
for (i = 0; i < 3; i++) {
if ((lex.GetId() == VIRGULE) && (i == 0)) {
// ERREUR
std::wcerr << L"Erreur ligne " << lex.GetLine() << L" colonne " << lex.GetColumn() << L"\u00a0: " << L"',' en trop." << std::endl;
err = true;
lex.Read();
}
if (lex.GetId() == VIRGULE) lex.Read();
t = lex.GetId();
if (t == REGISTRE) {
lCurrent->SetReg(i, lex.GetIdbis());
lex.Read();
} else if (t == PGAUCHE || t == ID || t == NOMBRE || t == MOINS || t == NON) {
lCurrent->SetImm(i, nivn(7));
} else if (t == FIN_LIGNE) break;
}
l = new Liste(0,0);
lCurrent->SetSuiv(l);
lCurrent = l;
cCode++;
if (lex.GetId() != FIN_LIGNE) {
// ERREUR
std::wcerr << L"Erreur ligne " << lex.GetLine() << L" colonne " << lex.GetColumn() << L"\u00a0: " << L"une instruction doit être suivi d'un saut de ligne." << std::endl;
err = true;
while(lex.GetId() != FIN_LIGNE) lex.Read();
}
lex.Read();
lignescode();
break;
default:
// cas epsilon
break;
}
}
Symbole* Lexer::getSymbole()
{
if(getSymbole(next).compare("const")==0)
{
//cout << "CONST" << endl;
Symbole* toReturn = new Symbole();
toReturn->setType(CONST);
return toReturn;
}
else if(getSymbole(next).compare("var")==0)
{
//cout << "VAR" << endl;
Symbole* toReturn = new Symbole();
toReturn->setType(VAR);
return toReturn;
}
else if(getSymbole(next).compare("ecrire") == 0)
{
//cout << "ECRIRE" << endl;
Symbole* toReturn = new Symbole();
toReturn->setType(ECRIRE);
return toReturn;
}
else if (getSymbole(next).compare("lire") == 0)
{
//cout << "LIRE" << endl;
Symbole* toReturn = new Symbole();
toReturn->setType(LIRE);
return toReturn;
}
else if (getSymbole(next).compare(";") == 0)
{
//cout << "PVG" << endl;
Symbole* toReturn = new Symbole();
toReturn->setType(PVG);
return toReturn;
}
else if (getSymbole(next).compare(",") == 0)
{
//cout << "VG" << endl;
Symbole* toReturn = new Symbole();
toReturn->setType(VG);
return toReturn;
}
else if (getSymbole(next).compare("=") == 0)
{
//cout << "EG" << endl;
Symbole* toReturn = new Symbole();
toReturn->setType(EG);
return toReturn;
}
else if (getSymbole(next).compare("(") == 0)
{
//cout << "PARG" << endl;
Symbole* toReturn = new Symbole();
toReturn->setType(PARG);
return toReturn;
}
else if (getSymbole(next).compare(")") == 0)
{
//cout << "PARD" << endl;
Symbole* toReturn = new Symbole();
toReturn->setType(PARD);
return toReturn;
}
else if (getSymbole(next).compare(":=") == 0)
{
//cout << "AF" << endl;
Symbole* toReturn = new Symbole();
toReturn->setType(AF);
return toReturn;
}
else if (getSymbole(next).compare("+") == 0)
{
//cout << "PLUS" << endl;
Symbole* toReturn = new Symbole();
toReturn->setType(PLUS);
return toReturn;
}
else if (getSymbole(next).compare("-") == 0)
{
//cout << "MOINS" << endl;
Symbole* toReturn = new Symbole();
toReturn->setType(MOINS);
return toReturn;
}
else if (getSymbole(next).compare("*") == 0)
{
//cout << "MULT" << endl;
Symbole* toReturn = new Symbole();
toReturn->setType(MULT);
return toReturn;
}
else if (getSymbole(next).compare("/") == 0)
{
//cout << "DIV" << endl;
Symbole* toReturn = new Symbole();
toReturn->setType(DIV);
return toReturn;
}
else if (testRegex(getSymbole(next), NB))
{
//cout << "NB" << endl;
Nombre* toReturn = new Nombre(stoi(getSymbole(next)));
toReturn->setType(NB);
return toReturn;
}
else if(testRegex(getSymbole(next), ID))
{
//cout << "ID" << endl;
Variable* toReturn = new Variable();
toReturn->setID(getSymbole(next));
toReturn->setType(ID);
return toReturn;
}
else if (getSymbole(next).compare("$") == 0)
{
//cout << "DOL" << endl;
Symbole* toReturn = new Symbole();
toReturn->setType(DOL);
return toReturn;
}
else
{
cerr << "Erreur lexicale caractere "<< getSymbole(next) << endl;
Symbole* toReturn = new Symbole();
toReturn->setType(ERR);
return toReturn;
}
//next++;
return NULL;
}