Esempio n. 1
0
void NTerminal::first_NT(Simbolos *Ne){
    Simbolos velho, novo;
    novo.insert(this);
    bool adicionou = false;
    do{
        velho = novo;

        for(auto it_firstNT = velho.begin(); it_firstNT != velho.end(); it_firstNT++){
            NTerminal *a = *it_firstNT;
            set<FormaSentencial> prod_a = a->_producoes;
            for(auto it_prod = prod_a.begin(); it_prod != prod_a.end(); it_prod++){
                FormaSentencial fs = *it_prod;
                for(auto it_simb = fs.begin(); it_simb != fs.end(); it_simb++){
                    Simbolo *x = *it_simb;
                    if(!x->ehNTerminal())
                        break;
                    if(x == this)
                        adicionou = true;
                    novo.insert(x);
                    if(Ne->find(x)==Ne->end())
                        break;
                }
            }
        }

    }while(velho != novo);
    if(!adicionou){
        novo.erase(this);
    }
    _first_NT.insert(novo.begin(), novo.end());
}
void compilarDeclaracion(vector< Simbolo* > &vectorSimbolos, Tipo *tipo, bool global)
{
  for(int i=0; i < vectorSimbolos.size(); i++ ){
    //antes de insertar el nuevo simbolo, comprobar que no
    //hay otro ya con el mismo nombre presente
    if( existeSimbolo( tablaSimbolos, vectorSimbolos[i] ) ){
      string err;
      err = "Existe declaración previa del símbolo " +  (vectorSimbolos[i]->getNombre());
      yyerror(err.c_str());
    }

    if( vectorSimbolos[i]->getDimension() > 0 ){ //array
      size_t tamArray = vectorSimbolos[i]->getDimension();
      Simbolo* simboloArray = vectorSimbolos[i];
      
      TipoArray* nuevoArray = new TipoArray(tipo, tamArray);
      
      simboloArray->setTipo( nuevoArray );
      tablaTipos.insertar("array", nuevoArray); 
    }
    else
      vectorSimbolos[i]->setTipo(tipo);

    if( global )
      vectorSimbolos[i]->setGlobal();
    
    
    tablaSimbolos.insertar(vectorSimbolos[i]);
  }
}
Esempio n. 3
0
Simbolo::Simbolo(Simbolo const& otro):
    _ptr(otro._ptr->clone()),
    _identificador(otro.getIdentificador()),
    _tipo(otro.getTipo()),
    _constante(otro.esConstante()),
    _cantDimensiones(otro.getCantidadDimensiones()),
    _inicializado(otro.estaInicializado())
{
}
Esempio n. 4
0
void ManejadorClass::escribirMain(void)
{
    string metodo  = "main";
    string firma   = "9";

    escribirCabeceraMetodo(metodo, firma, T_INVALIDO);

    Simbolo* dummy = new Simbolo("Args");
    dummy->setTipo(T_CADENA)->setInicializado();
    registrarVariableLocal(dummy, 2);
}
Esempio n. 5
0
bool NTerminal::derivaEpsilonDiretamente(){

    for(auto A = _producoes.begin(); A != _producoes.end();A++){
        FormaSentencial fs = *A;

        if(fs.front()->nome().compare(string("&")) == 0)
            return true;

        if(NTerminal::somenteNTerminais(fs)){
            for (int i = 0; i < fs.size(); ++i) {
                Simbolo * s = fs.at(i);
                if(s->nome().compare(string("&")) == 0)
                    return true;
            }
        }
    }
    return false;
}
Tipo* buscaYapilaDireccion(string nombre)
{
  Simbolo *simbolo;
  simbolo = tablaSimbolos.buscar(nombre);
  if( !simbolo ){
    char error[64];
    sprintf(error, "Identificador %s no encontrado", nombre.c_str());
    yyerror(error);
  }
  if( simbolo->getGlobal() )
    printf("IPUSH %d\n", simbolo->getDireccion());
  else{
    printf("IPUSHBP %d\n", simbolo->getDireccion()); 
    if(simbolo->getParametroPorRef()){
      printf("ILOAD\n"); 
      //cargar el entero que representa la
      //direccion de memoria de la referencia
    }
  }


  return simbolo->getTipo();
}