bool parent_izq(){
estado estado_anterior, estado_actual = 0;
while(estado_actual !=UDEF){
estado_anterior = estado_actual;
char c = siguiente();
switch (estado_actual){
case 0:
if(c=='(') estado_actual =1;
else estado_actual = UDEF;
break;
case 1:
if (c=='(');
else estado_anterior=estado_actual;
break;
}
}
if (estado_anterior==1){
retroceso();
acepta();
return true;
}
else{
falla();
return false;
}
}
//********************
PtrNodoListaDeposito anterior(ListaArtDeposito &listaArtDep,PtrNodoListaDeposito ptrNodoListaDep){
PtrNodoListaDeposito ptrPrevio = finAD();
PtrNodoListaDeposito ptrCursor = primero(listaArtDep);
while (( ptrCursor != finAD()) && (ptrCursor != ptrNodoListaDep)) {
ptrPrevio = ptrCursor;
ptrCursor = siguiente(listaArtDep,ptrCursor);
}
return ptrPrevio;
}
PtrNodoPiso anterior(ListaPiso &listaP, PtrNodoPiso ptrNodoP){
PtrNodoPiso ptrPrevio = finP();
PtrNodoPiso ptrCursor = primero(listaP);
while (( ptrCursor != finP()) && (ptrCursor != ptrNodoP)) {
ptrPrevio = ptrCursor;
ptrCursor = siguiente(listaP,ptrCursor);
}
return ptrPrevio;
}
bool esp_blanco(){
if(isspace(siguiente())){
acepta();
return true;
}
else{
falla();
return false;
}
}
bool eof(){
if(siguiente()==EOF){
acepta();
return true;
}
else{
falla();
return false;
}
}
void guardarEnArchivos(Lista &Candidatos, Lista &Partidos, Lista &Mesa)
{
FILE *fileCandi, *filePart, *fileMesa;
PtrNodoLista nodo;
//Guardo Mesas
if((fileMesa=fopen("mesas.txt", "w"))!=NULL)
{
nodo = primero(Mesa);
while (nodo != fin())
{
fprintf(fileMesa,"%d;%d\n", getIdMesa(*(Mesas*)nodo->ptrDato),getProvinciaMesa(*(Mesas*)nodo->ptrDato) );
nodo = siguiente(Mesa, nodo);
}
} else{puts("El archivo mesas.txt no pudo ser creado");}
//Guardo Candidatos
if((fileCandi=fopen("candidatos.txt", "w"))!=NULL)
{
nodo = primero(Candidatos);
while (nodo != fin())
{
fprintf(fileCandi,"%d;%s;%d\n", getIdCandidato(*(Candidato*)nodo->ptrDato),getNombreCandidato(*(Candidato*)nodo->ptrDato),getPartidoPolitico(*(Candidato*)nodo->ptrDato) );
nodo = siguiente(Candidatos, nodo);
}
} else{puts("El archivo candidatos.txt no pudo ser creado");}
//Guardo Partidos
if((filePart=fopen("partidos.txt", "w"))!=NULL)
{
nodo = primero(Partidos);
while (nodo != fin())
{
fprintf(filePart,"%d;%s\n", getIdPartido(*(Partido*)nodo->ptrDato),getNombrePartido(*(Partido*)nodo->ptrDato) );
nodo = siguiente(Partidos, nodo);
}
} else{puts("El archivo partidos.txt no pudo ser creado");}
}
int MiembroHash (char *cad,TablaHash t)
{
tPosicion p;
int enc;
int pos=Hash(cad);
p=primero(t[pos]);
enc=0;
while (p!=fin(t[pos]) && !enc) {
if (strcmp(cad,elemento(p,t[pos]))==O)
enc=1;
else
p=siguiente(p,t[pos]);
}
return enc;
}
void eliminarNodo(ListaPiso &listaP, PtrNodoPiso ptrNodoP){
PtrNodoPiso ptrPrevio;
/* verifica que la lista no esté vacia y que nodo no sea fin*/
if ((! listaVacia(listaP)) && (ptrNodoP != finP())) {
if (ptrNodoP == primero(listaP))
listaP.primeroPiso = siguiente(listaP,primero(listaP));
else {
ptrPrevio = anterior( listaP , ptrNodoP );
ptrPrevio->sgteP = ptrNodoP->sgteP;
}
// Si el dato es un TDA, acá habría que llamar al destructor.
destruir(ptrNodoP->pilUb);
delete ptrNodoP;
}
}
//*******************
void eliminarNodo(ListaArtDeposito &listaArtDep,PtrNodoListaDeposito ptrNodoListaDep){
PtrNodoListaDeposito ptrPrevio;
/* verifica que la lista no esté vacia y que nodo no sea fin*/
if ((! listaVacia(listaArtDep)) && (ptrNodoListaDep != finAD())) {
if (ptrNodoListaDep == primero(listaArtDep))
listaArtDep.primerArtDeposito = siguiente(listaArtDep,primero(listaArtDep));
else {
ptrPrevio = anterior( listaArtDep , ptrNodoListaDep );
ptrPrevio->sgteAD= ptrNodoListaDep->sgteAD;
}
// Si el dato es un TDA, acá habría que llamar al destructor.
delete ptrNodoListaDep;
}
}
bool identificador(){ //hex, oct,nat, y flot
estado estado_anterior, estado_actual = 0;
while(estado_actual !=UDEF){
estado_anterior = estado_actual;
char c = siguiente();
switch (estado_actual){
case 0:
if(c=='_') estado_actual =1;
else if(isalpha(c)) estado_actual = 2;
else estado_actual = UDEF;
break;
case 1:
if(isdigit(c) || c == '_');
else if(isalpha(c)) estado_actual = 2;
else estado_actual = UDEF;
break;
case 2:
// if (isdigit(c)|| isalpha(c) || c == '_');
if (isalnum (c) || c == '_');
else estado_actual = UDEF;
}
}
if (estado_anterior == 2){
retroceso();
acepta();
return true;
}
else{
falla();
return false;
}
}
bool hexadecimal(){
estado estado_anterior, estado_actual = 0;
while(estado_actual !=UDEF){
estado_anterior = estado_actual;
char c = siguiente();
switch (estado_actual){
case 0:
if(c=='0') estado_actual = 1;
else estado_actual = UDEF;
break;
case 1:
if((c=='X')||(c=='x')) estado_actual = 2;
else estado_actual = UDEF;
break;
case 2:
if ((isdigit(c))||(isCarHex(c))) estado_actual = 3;
else estado_actual = UDEF;
break;
case 3:
if ((isdigit(c))||(isCarHex(c)));
else estado_actual = UDEF;
break;
}
}
if (estado_anterior == 1){
retroceso();
acepta();
return true;
}
else{
falla();
return false;
}
}
bool octal(){ //debe comenzar con 0
estado estado_anterior, estado_actual = 0;
while(estado_actual !=UDEF){
estado_anterior = estado_actual;
char c = siguiente();
switch (estado_actual){
case 0:
if (c=='0') estado_actual=1;
else estado_actual=UDEF;
break;
case 1:
if (isCarOctal(c))estado_actual=2;
else estado_actual=UDEF;
break;
case 2: if (isCarOctal(c) || c=='0' );
else estado_actual=UDEF;
}
}
if (estado_actual== 2){
retroceso();
acepta();
return true;
}
else {
falla();
return false;
}
}
bool naturales(){ //no debe tener 0
estado estado_anterior, estado_actual = 0;
while(estado_actual !=UDEF){
estado_anterior = estado_actual;
char c = siguiente();
switch (estado_actual){
case 0:
if(isdigit(c)&& c!='0') estado_actual = 1;
else estado_actual = UDEF;
break;
case 1:
if(isdigit(c));
else estado_actual = UDEF;
}
}
if (estado_anterior == 1){
retroceso();
acepta();
return true;
}
else{
falla();
return false;
}
}
void Recuerdo::updateParticulas(double tiempoSeg, double tiempoMil){
// a que recuerdo llamo con tiempo en segundo.
bool* pixelBool = new bool[(int)this->pixels->size()];
std::fill_n( pixelBool, (int)this->pixels->size(), 0 );
vector<Particula*>::iterator it = this->particulas->begin();
vector<Pixel*>::iterator itpixels;
Pixel *pixel;
Particula* particula;
Punto *ptoAnt = NULL;
Punto *ptoSig = NULL;
Punto *ptoAct = NULL;
long a;// = ofGetElapsedTimeMillis() % 1000;
bool recTienePar=false;
while (it!=this->particulas->end())
{
particula = *it;
// a = fmod(tiempoMil,particula->frecuencia);
a = fmod(tiempoMil - (particula->tiempoini),particula->frecuencia );//+ particula->tiempoini*1000;
itpixels = pixels->begin();
//if (particula->tiempoini <= tiempoSeg && particula->tiempofin >= tiempoSeg){
if (particula->tiempoini <= tiempoMil && particula->tiempofin >= tiempoMil){
ptoAnt = anterior(particula, a);
ptoSig = siguiente(particula,a);
if (ptoAnt != NULL && ptoSig != NULL){
ptoAct = ptoActual(ptoAnt,ptoSig,a);
//Gonzalo
//ptoAct->draw(ptoAct);
//ofPushMatrix();
//particula->draw(ptoAct);
//ofPopMatrix();
cout << particula->id;
while (itpixels != pixels->end()){
pixel = *itpixels;
ofVec3f pos = pixel->getPosition();
int dis = sqrt((pos.x - ptoAct->x)*(pos.x - ptoAct->x) + (pos.z - ptoAct->z)* (pos.z - ptoAct->z));
if (dis <= ptoAct->intensidad){
//Aca va el decaimiento del color
ofVec3f colores(ptoAct->r, ptoAct->g,ptoAct->b);
ofVec3f retColores = decaimiento (colores,dis,ptoAct->intensidad);
pixel->blendRGBA(retColores.x, retColores.y, retColores.z,0,0.4f);
//pixel->blendRGBA(ptoAct->r,ptoAct->g,ptoAct->b,0,0.4f);
pixelBool[(int)pixel->getId()] = true;
}
itpixels++;
}
}
}
it++;
}// Busco
itpixels = pixels->begin();
if (recTienePar) {
while (itpixels != pixels->end()){
Pixel* px = *itpixels;
if (!pixelBool[(int)px->getId()]){
px->blendRGBA(0, 0, 0, 255, 0.4f);
}
itpixels++;
}
}
delete[] pixelBool;
this->draw();
};
int main() {
lista lst = crear_lista();
nat cont_comandos = 0;
bool salir = false;
while (!salir) {
mostrar_prompt(cont_comandos);
enum_cmd_t enum_com = identificador_comando();
// procesar el comando
switch (enum_com) {
case cmd_fin:
salir = true;
imprimir_con_nl(msg_fin);
break;
case cmd_comentario:
escribir_nueva_linea();
break;
case cmd_ins_lista: {
info_t info = leer_info(MAX_LARGO_PALABRA);
while (es_valida_info(info)) {
insertar_despues(info, final_lista(lst), lst);
info = leer_info(MAX_LARGO_PALABRA);
}
liberar_info(info);
texto_t txt = cadena_a_texto("primero");
info = crear_info(0, txt);
insertar_antes(info, inicio_lista(lst), lst);
imprimir_lista(lst);
break;
}
case cmd_recorrido_lista: {
if (!es_vacia_lista(lst)) {
localizador loc = inicio_lista(lst);
while (es_localizador_lista(loc)) {
texto_t txt = info_a_texto(info_lista(loc, lst));
escribir_texto(txt);
liberar_texto(txt);
loc = siguiente(loc, lst);
}
loc = final_lista(lst);
while (es_localizador_lista(loc)) {
texto_t txt = info_a_texto(info_lista(loc, lst));
escribir_texto(txt);
liberar_texto(txt);
loc = anterior(loc, lst);
}
escribir_nueva_linea();
}
break;
}
case cmd_segmentos_lista: {
int clave1 = leer_int();
int clave2 = leer_int();
localizador desde = siguiente_clave(clave1, inicio_lista(lst), lst);
localizador hasta = anterior_clave(clave2, final_lista(lst), lst);
if (es_localizador_lista(desde) && es_localizador_lista(hasta) &&
precede_en_lista(desde, hasta, lst)) {
lista sgm = separar_segmento(desde, hasta, lst);
lista copia = segmento_lista(inicio_lista(sgm), final_lista(sgm), sgm);
imprimir_lista(sgm);
liberar_lista(sgm);
insertar_segmento_despues(copia, final_lista(lst), lst);
liberar_lista(copia);
imprimir_lista(lst);
}
break;
}
case cmd_modificar_lista: {
int clave1 = leer_int();
int clave2 = leer_int();
localizador loc1 = siguiente_clave(clave1, inicio_lista(lst), lst);
localizador loc2 = anterior_clave(clave2, final_lista(lst), lst);
if (es_localizador_lista(loc1) && es_localizador_lista(loc2)) {
intercambiar(loc1, loc2, lst);
imprimir_lista(lst);
retroceder(loc2, lst);
imprimir_lista(lst);
}
break;
}
case cmd_ordenar_lista: {
nat len_lst = longitud(lst);
imprimir_int(len_lst);
localizador loc = inicio_lista(lst);
for (nat i = 0; i < len_lst / 2 - 1; i++)
loc = siguiente(loc, lst);
lista primera = segmento_lista(inicio_lista(lst), loc, lst);
lista segunda =
segmento_lista(siguiente(loc, lst), final_lista(lst), lst);
lista concat = concatenar(primera, segunda);
imprimir_lista(concat);
liberar_lista(concat);
if (son_numeros_iguales(primera, segunda)) {
imprimir_lista(primera);
}
if (!esta_ordenada(primera))
ordenar(primera);
if (!esta_ordenada(segunda))
ordenar(segunda);
lista mzc = mezcla(primera, segunda);
imprimir_lista(mzc);
unificar(mzc);
imprimir_lista(mzc);
liberar_lista(mzc);
liberar_lista(primera);
liberar_lista(segunda);
break;
}
case cmd_filtrado_lista: {
int clave = leer_int();
texto_t palabra = leer_palabra(MAX_LARGO_PALABRA);
comp_t criterio = texto_a_comp(palabra);
liberar_texto(palabra);
if (pertenece(clave, lst)) {
imprimir_int(cantidad(clave, lst));
}
lista flt = filtrado(clave, criterio, lst);
imprimir_lista(flt);
liberar_lista(flt);
break;
}
case cmd_reversa_lista: {
int dato1 = leer_int();
int dato2 = leer_int();
if (esta_ordenada(lst) && pertenece(dato1, lst) &&
pertenece(dato2, lst) && dato1 < dato2) {
lista sub = sublista(dato1, dato2, lst);
imprimir_lista(sub);
lista rev = reversa(sub);
imprimir_lista(rev);
cambiar_todos(dato1, dato2, rev);
imprimir_lista(rev);
liberar_lista(sub);
liberar_lista(rev);
}
break;
}
case cmd_liberar_lista: {
liberar_lista(lst);
lst = crear_lista();
break;
}
default:
imprimir_con_nl(msg_cmd_no_reconocido);
break;
} // switch
texto_t resto_linea = leer_resto_linea(MAX_RESTO_LINEA);
liberar_texto(resto_linea);
} // while
liberar_lista(lst);
return 0;
}
