NO* buscarElemento(int numero, NO *raiz) {
if ( raiz == NULL || raiz->matricula == numero) {
return raiz;
}
if (numero < raiz->matricula) {
return buscarElemento(numero, raiz->esquerda);
}
if(numero > raiz->matricula) {
return buscarElemento(numero,raiz->direita);
}
}
tipoNo* buscarElemento(int numero, tipoNo *raiz){
if(raiz == NULL){
return NULL;
}
if (numero < raiz->dado){
return buscarElemento(numero, raiz->noEsquerdo);
}
if(numero > raiz->dado){
return buscarElemento(numero,raiz->noDireito);
}
return raiz;
}
void declaracionboolean() { //boolean variable := [true,false,0,1]
int i;
if (token==ident) {
//ve a buscarlo a la tabla de símbolos
i=posicion();
if (i==0) {
error(11); //error 11: identificador no declarado
}
else if (buscarElemento(i) -> tipo != VARIABLE)
error(12); //error 12: no están permitidas las asignaciones a constantes o a procedimientos
obtoken();
if (token==asignacion) {
//mejora del tipo "adivinación" de la intención del programador
obtoken();
switch(token){
case truetok: break;
case falsetok: break;
default: error(40); break; //No coinciden tipos
}
obtoken();
if(token == puntoycoma){
obtoken();
}else{
error(5); //punto y coma
}
}
else
error (3) ; //error 3: el identificador debe ir seguido de ":="
}
else
error(4) ; //error 4: Boolean, Const, Var y Procedure deben ir seguidos de un identificador
}
void remover(tipoArvore arvore, FILE* arquivo, FILE* excluidos) { //arvore, entrada, saida
char delentrada [200], vet[600], *texto, delsaida[200], *token = NULL;
NO *aux;
int valor;
struct dirent *drt;
fgets(vet,600,arquivo); //passando tudo para o array
token = strtok(vet,";");//separando
while(token) {
valor = atoi(token);//transforma em numero
// printf("%d\n", valor);
aux = buscarElemento(valor, arvore.topo);
if (aux == NULL) {
//printf("Nao encontrado!");
fprintf(excluidos,"%d Nao encontrado\n", valor);
} else if (aux->matricula == valor) {
//printf ("Existe alguem com esse numero :D\n");
fprintf(excluidos,"%d Excluido\n",valor);
removerDaArvore(valor, &arvore);
}
token = strtok(NULL, ";");
}
fprintf(excluidos, "\n\n\n");//deixando espaço para o proximo desenho
fclose(excluidos);
}
tipoNo* removerElemento(int numero, tipoNo *raiz){
tipoNo *no;
tipoNo *aux;
tipoNo *M;
int auxCor;
no = buscarElemento(numero, raiz);
if(raiz == NULL || no == NULL){
return raiz;
}
auxCor = no->cor;
if(no->noEsquerdo == NULL){
aux = no->noDireito;
transplante(&raiz,no, no->noDireito);
}
else if(no->noDireito == NULL){
aux = no->noEsquerdo;
transplante(&raiz, no, no->noEsquerdo);
}
else{
M = menorDosMaiores(no);
auxCor = M->cor;
aux = M->noDireito;
if(M->noPai == no){
if(aux != NULL){
aux->noPai = M;
}
}
else{
transplante(&raiz, M, M->noDireito);
M->noDireito = no->noDireito;
M->noDireito->noPai = M;
}
transplante(&raiz, no, M);
M->noEsquerdo = no->noEsquerdo;
M->noEsquerdo->noPai = M;
M->cor = no->cor;
}
if(auxCor == NEG){
if(aux!= NULL){
conserta(&raiz, aux);
}
}
free(no);
return raiz;
}
NO* removerElemento(int numero, NO *raiz) {
NO *no;
NO *aux;
NO *M;
int auxCor;
no = buscarElemento(numero, raiz);
if(raiz == NULL || no == NULL) {
return raiz;
}
auxCor = no->cor;
if(no->esquerda == NULL) {
aux = no->direita;
transplante(&raiz,no, no->direita);
}
else if(no->direita == NULL) {
aux = no->esquerda;
transplante(&raiz, no, no->esquerda);
}
else {
M = menorDosMaiores(no);
auxCor = M->cor;
aux = M->direita;
if(M->pai == no) {
if(aux != NULL) {
aux->pai = M;
}
} else {
transplante(&raiz, M, M->direita);
M->direita = no->direita;
M->direita->pai = M;
}
transplante(&raiz, no, M);
M->esquerda = no->esquerda;
M->esquerda->pai = M;
M->cor = no->cor;
}
if(auxCor == NEG) {
if(aux!= NULL) {
conserta(&raiz, aux);
}
}
free(no);
return raiz;
}
/*----------------------------------------------------------------------------*/
void XmlParser::cargarMundo(Mundo* mundo,xmlpp::TextReader& reader)
{
do
{
buscarElemento(reader);
string path = reader.get_attribute(ATRIB_PATH);
if(path!="")
{
mundo->getNiveles()->push(path);
}
}while(reader.read());
}
/*----------------------------------------------------------------------------*/
void XmlParser::cargarGrafo(Mapa* mapa,xmlpp::TextReader& reader)
{
std::string name="";
do
{
buscarElemento(reader);
name = reader.get_name();
if(name==ARISTA)
agregarArista(mapa,reader);
}while(reader.read() && name!=ELEMENTOS);
}
//factor
void factor(int toksig[])
{
int i;
int setpaso[NOTOKENS]; //conjunto de paso por valor
test(tokinifact,toksig,24); //error(24): Una expresión no puede empezar con este símbolo
while (tokinifact[token]==1) {
//mientras el token sea un símbolo inicial de factor...
if (token==ident) {
i=posicion();
if (i==0) {
copia_set(setpaso,toksig);
setpaso[parenc]=1; //setpaso=parenc+toksig
funcion(setpaso);
//error(11); //error 11: Identificador no declarado
}else if (buscarElemento(i) -> tipo==PROCEDIMIENTO)
error(21); //error 21: Una expresión no debe contener un identificador de procedimiento
obtoken();
}
else if (token == entero || token == real)
obtoken();
else if (token==parena) {
obtoken();
copia_set(setpaso,toksig);
setpaso[parenc]=1; //setpaso=parenc+toksig
expresion(setpaso);
if (token==parenc)
obtoken();
else
error(22); //error 22: Falta un paréntesis de cierre
};
init_set(setpaso); //conjunto vacío
setpaso[parena]=1; //setpaso=parena
test(toksig,setpaso,23); //error(23): El factor anterior no puede ir seguido de este simbolo o falta un punto y coma
}
}
void funcion(int toksig[]) {
int i;
if (strcmp(lex, "READ") == 0 ||
strcmp(lex, "READLN") == 0) {
obtoken();
if (token == parena) {
obtoken();
if (token == ident) {
i = posicion();
if (i == 0) { // no se encontro el identificador
error(11); // identificador no declarado
}
else if (buscarElemento(i) -> tipo==PROCEDIMIENTO) {
error(21); //error 21: identificador de procedimiento
}
else { // era un identificador valido
obtoken();
if (token == parenc) {
// todo nice
obtoken();
}
else
error(27);// se esperaba un parentesis de cierre
}
}
else
error(28);
}
else
error(26); // se esperaba una lista de argumentos
}
else if (strcmp(lex, "WRITE") == 0 ||
strcmp(lex, "WRITELN") == 0 ){
obtoken();
if (token == parena) {
obtoken();
if (token == string) {
obtoken();
if (token == coma) {
obtoken();
}
else
error(5); // falta coma o punto y coma
}
if (token == ident) {
i = posicion();
if (i == 0) { // no se encontro el identificador
error(11); // identificador no declarado
}
else if (buscarElemento(i) -> tipo==PROCEDIMIENTO) {
error(21); //error 21: identificador de procedimiento
}
else { // era un identificador valido
obtoken();
if (token == parenc) {
// todo nice
obtoken();
}
else
error(27);
}
}
else
error(28);
}
else
error(26); // se esperaba una lista de argumentos
}
//random
else if (strcmp(lex, "RND") == 0 ||
strcmp(lex, "CLRSCR") == 0 ||
strcmp(lex, "HALT") == 0 ){
obtoken();
if (token == parena) {
obtoken();
if (token == parenc) {
obtoken();
}
else
error(27);//se esperaba parentesis de cierre
}
}
//pitagoras
else if (strcmp(lex, "PITAG") == 0 ){
obtoken();
if (token == parena) {
obtoken();
if (token == ident) {
obtoken();
if (token == coma) {
obtoken();
if (token == ident) {
obtoken();
if (token == coma) {
obtoken();
if (token == ident) {
obtoken();
if (token == parenc) {
obtoken();
}
else
error(27); // se esperaba parentesis de cierre
}
else
error(36); // se esperaba un identificador
}
else
error(5); // falta coma o punto y coma
}
else
error(36); // se esperaba un identificador
}
else
error(5); // falta coma o punto y coma
}
else
error(36); // se esperaba un identificador
}
else
error(37); // se esperaba parentesis de apertura
}
else
error(11); // identificador no declarado
}
//instruccion
void instruccion(int toksig[])
{
int i;
int setpaso[NOTOKENS]; //conjunto de paso por valor
int vacio[NOTOKENS]; //conjunto vacío
init_set(vacio);
if (token==ident) {
if (esFuncion()) {
copia_set(setpaso,toksig);
funcion(setpaso);
}
else {
//ve a buscarlo a la tabla de símbolos
i=posicion();
if (i==0) {
error(11); //error 11: identificador no declarado
}
else if (buscarElemento(i) -> tipo != VARIABLE)
error(12); //error 12: no están permitidas las asignaciones a constantes o a procedimientos
obtoken();
if (token==asignacion)
obtoken();
else
error(13); //error 13: se esperaba el operador de asignación
copia_set(setpaso,toksig);
expresion(setpaso);
}
}
else if (token==calltok) {
obtoken();
if (token!=ident)
error(14); //error 14: "CALL" debe ir seguido de un identificador
else {
//buscar el nombre del procedimiento en la tabla de símbolos
i=posicion();
if (i==0)
error(11); //error 11: Identificador no declarado
else if (buscarElemento(i) -> tipo!=PROCEDIMIENTO)
error(15); //error 15 : No tiene sentido llamar a una constante o a una variable
obtoken();
}
}
else if (token==iftok) {
obtoken();
copia_set(setpaso,toksig);
setpaso[thentok]=setpaso[dotok]=1; //setpaso=thentok+dotok+toksig
condicion(setpaso);
if (token==thentok)
obtoken();
else
error(16); //error 16: Se esperaba un "THEN"
copia_set(setpaso,toksig);
instruccion(toksig);
}
else if (token==begintok) {
obtoken();
copia_set(setpaso,toksig);
setpaso[puntoycoma]=setpaso[endtok]=1; //setpaso=puntoycoma+endtok+toksig
instruccion(setpaso);
while (token==puntoycoma || token==calltok || token==begintok || token==iftok || token==whiletok || token == fortok) {
//aquí el while 'inserta' el punto y coma para continuar compilando cuando no lo encuentre
//el compilador detecta la omisión clásica del punto y coma
if (token==puntoycoma)
obtoken();
else
error(10); //error 10: Falta un punto y coma entre instrucciones
copia_set(setpaso,toksig);
setpaso[puntoycoma]=setpaso[endtok]=1; //setpaso=puntoycoma+endtok+toksig
instruccion(setpaso);
}
if (token==endtok)
obtoken();
else
error(17); //error 17: Se esperaba un "END" o un punto y coma
}
else if (token==whiletok) {
obtoken();
copia_set(setpaso,toksig);
setpaso[dotok]=1;//setpaso=dotok+toksig
condicion(setpaso);
if (token==dotok)
obtoken();
else
error(18); //error 18: Se esperaba un "DO"
copia_set(setpaso,toksig);
instruccion(setpaso);
}
else if (token == fortok) {
obtoken();
copia_set(setpaso,toksig);
setpaso[dotok]=1;//setpaso=dotok+toksig
if (token == ident) {
i = posicion();
if (i == 0) { // no se encontro el identificador
error(11); // identificador no declarado
}
else if (buscarElemento(i) -> tipo==PROCEDIMIENTO) {
error(21); //error 21: identificador de procedimiento
}
else { // era un identificador valido
obtoken();
if (token == intok) {
obtoken();
if (token == entero) {
obtoken();
if (token == dospuntos) {
obtoken();
if (token == entero) {
obtoken();
if (token == dotok) {
obtoken();
copia_set(setpaso,toksig);
instruccion(setpaso);
}
else {
error(18);
}
}
else {
error(38); // se esperaba un numero entero
}
}
else {
error(39); // se esperaban dos puntos
}
}
else {
error(38); // se esperaba un numero entero
}
}
else {
error(29); // se esperaba un IN despues del FOR
}
}
}
else
error(28);
} else if (token == booleantok) {
obtoken();
declaracionboolean();
} else if (token == codigoptok) {
obtoken();
declaracioninline();
}
//comprobación explícita de que los tokens que viene son sucesores de instrucción
copia_set(setpaso,toksig);
test(setpaso,vacio,19); //error(19): Un simbolo incorrecto sigue a una instrucción
}
int DiVAFreeBuffer::getPositionToWrite()//A hacer: Primero buscar id minimo y luego comprobar si está leido
{
int pos = (last+1)%tamBuffer;
//En el caso de que no haya control de buffer
if (_consumecontrol==FALSE)
return pos;
//CON CONTROL DE CONSUMO: Buscaré el elmento de menor id y comprobaré que <= que el el más pequeño de lost lastReadenItemId
int minId=-1;
int i;
int nConsumers = 0;
for (i=0;i<BUFFERC_MAX_CONSUMIDORES;i++)
{
if (consumidores[i].activo)
{
nConsumers++;
int idAux = consumidores[i].lastReadenItemId;
if (minId==-1)
{
minId=idAux;
pos = consumidores[i].lastReadenPosition;
if (ocupados==0)//Caso especial. Primer elemento insertado (ocupados==0) con un cliente ya esperando
{
minId =-1;
pos=0;
}
}
else if (idAux<minId)
{
minId=idAux;
pos = consumidores[i].lastReadenPosition;
}
}
}
if ((nConsumers==0)&&(ocupados==tamBuffer))
return -1;
long id = -1;
if (minId>=0)
{
id = buscarElemento(minId,&pos);
if (id!=minId)
return -1;
}
int retpos = pos;
minId--;
while(minId>=0)
{
id = buscarElemento(minId,&pos);
if (id==minId)
{
retpos =pos;
minId--;
}
else
{
//#if _DEBUG
#if 0
printf("\n");
#endif
break;
}
//#if _DEBUG
#if 0
printf(".");
#endif
}
return retpos;
}
// Lee el primer elemento de la cola y lo saca del buffer
long DiVAFreeBuffer::get(void *elemento, long idElem, long idConsumidor)
{
// Control de acceso
int ret = WaitForSingleObject(hMutexBuffer, waitTimeout);
if (ret == WAIT_TIMEOUT)
return BUFFERC_TIMEOUT;
else if (ret == WAIT_FAILED)
return BUFFERC_ERROR;
else if(ret<0)
return BUFFERC_ERROR;
// Buscar el elemento solicitado, o el posterior más cercano en su defecto
int pos = -1;
long id = buscarElemento(idElem,&pos);
/* Si buscar elemento no encuentra el elemento porque...
... el buffer está vacio
... el elemento que quiero todavía no está
entonces el consumidor tendrá que esperar a ser liberado, cuando put introduzca un nuevo elemento.
*/
/*if ((pos == BUFFERC_EMPTY)||
((_consumecontrol)&&
(consumidores[idConsumidor].lastReadenPosition)))
*/
if (id<0)
{
consumidores[idConsumidor].esperandoLiberacion = TRUE;
ReleaseMutex(hMutexBuffer);
ret = WaitForSingleObject(consumidores[idConsumidor].hSemConsumidor, waitTimeout);
consumidores[idConsumidor].esperandoLiberacion = FALSE;
if (ret == WAIT_TIMEOUT){
// printf("DiVAFreeBuffer BUFFER EMPTY, WAIT_TIMEOUT\n");
return BUFFERC_EMPTY;
}
else if (ret == WAIT_FAILED){
// printf("DiVAFreeBuffer BUFFER ERROR, WAIT_FAILED\n");
return BUFFERC_ERROR;
}
else if(ret<0){
// printf("DiVAFreeBuffer BUFFER ERROR, WAIT_FAILED\n");
return BUFFERC_ERROR;
}
//printf("DiVAFreeBuffer BUFFER ERROR, WAIT_FAILED\n");
return get(elemento, idElem, idConsumidor); // If we get here, someone had NECESSARY introduce a new element in the buffer
}
// Copiar el dato en el puntero recibido
copiarLectura(elemento, pos);
consumidores[idConsumidor].lastReadenPosition = pos;
consumidores[idConsumidor].lastReadenItemId = id;
//Si tendo el lastReadenItemId más pequeño y el put espera liberación, le libero
int i;
int libero = 1;
if(_consumecontrol)
{
for (i=0;i<BUFFERC_MAX_CONSUMIDORES;i++)
{
if (consumidores[i].activo)
{
if (consumidores[i].lastReadenItemId<id)
{
//No libero
libero =0;
break;
}
}
}
if (libero)
{
if (_writerWaitingReleasing)
{
_writerWaitingReleasing = 0;
SetEvent(hMutexWriting);
}
}
}
ReleaseMutex(hMutexBuffer);
return BUFFERC_OK;
}
NO* buscarNaArvore(int numero, tipoArvore arvore) {
return buscarElemento(numero, arvore.topo);
}
