Beispiel #1
0
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;
}
Beispiel #2
0
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;
  }
}
Beispiel #5
0
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);
}
Beispiel #6
0
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;
    }
}
Beispiel #7
0
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;
  }
}
Beispiel #8
0
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;
  }
}
Beispiel #9
0
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;
}