/*
* <sentencia> →
* <identificador> := <expresión> #asignar ; |
* leer ( <listaIdentificadores> ) ; |
* escribir ( <listaExpresiones> ) ;
*/
void sentencia(void) {
token tok = prox_token();
struct reg_expr id_reg, result_reg;
switch(tok) {
case ID:
identificador(&id_reg);
match(ASIGNACION);
expresion(&result_reg);
asignar(&id_reg, &result_reg);
match(PUNTOYCOMA);
break;
case LEER:
match(LEER);
match(PARENIZQUIERDO);
lista_identificadores();
match(PARENDERECHO);
match(PUNTOYCOMA);
break;
case ESCRIBIR:
match(ESCRIBIR);
match(PARENIZQUIERDO);
lista_expresiones();
match(PARENDERECHO);
match(PUNTOYCOMA);
break;
default:
error_sintactico(tok);
return;
}
}
int main(int argc, char **argv){
float *x,*y,*t,*ks,*alpha_walk, *beta_walk, *gamma_walk, *epsilon_walk, *datost, *datosx, *datosy;
float h,alpha,beta,gamma,epsilon;
int n_points,i,n_puntos,n_burn;
//96 lineas tienen los datos
n_points = 96;
//parametros entrados por consola
n_puntos = atoi(argv[1]);
n_burn = atoi(argv[2]);
//arreglos para guardar los datos del tiempo, presas y depredadores
datost = crearArregloCero(96);
datosx = crearArregloCero(96);
datosy = crearArregloCero(96);
//asignar los datos del archivo a los arreglos datost, datosx, datosy
asignar(datost,datosx,datosy);
//arreglos para guardar los mejores parametros estimados
alpha_walk = crearArregloCero(n_puntos);
beta_walk = crearArregloCero(n_puntos);
gamma_walk = crearArregloCero(n_puntos);
epsilon_walk = crearArregloCero(n_puntos);
//valores aleatorios para el modelo
srand48(time(NULL));
alpha_walk[0] = drand48()*0.2-0.1;
beta_walk[0] = drand48()*0.2-0.1;
gamma_walk[0] = drand48()*0.2-0.1;
epsilon_walk[0] = drand48()*0.2-0.1;
//inicializar los arreglos
alpha = alpha_walk[0];
beta = beta_walk[0];
gamma = gamma_walk[0];
epsilon = epsilon_walk[0];
//Arreglos para el RungeKutta
ks = crearArregloCero(2);
x = crearArregloCero(n_points);
x[0] = 15.0;
y = crearArregloCero(n_points);
y[0] = 13.0;
t = crearArregloCero(n_points);
t[0] = 0.006;
t[95] = 0.799;
h = (t[95]-t[0])/n_points ;
//RungeKutta
loopRungeKutta4(ks,x,y,t,h,alpha,beta,gamma,epsilon,n_points);
//Rungekutta y markov deben ir en un loop
for(i=0;i<n_points;i++){
printf("%f %f %f\n", t[i],x[i],y[i]);
}
return 0;
}
void retornar(t_valor_variable retorno) {
if(status_check() != EXECUTING)
return;
//1) Obtengo el stack index
t_stack * actual_stack_index = actual_pcb->stack_index;
//2) Obtengo la entrada actual
t_stack_entry *last_entry = get_last_entry(actual_stack_index);
//3) Actualizo el PC a la posicion de retorno de la entrada actual
actual_pcb->program_counter = last_entry->ret_pos;
//4) Asigno el valor de retorno de la entrada actual a la variable de retorno
asignar(obtener_t_posicion(last_entry->ret_vars), retorno);
//5) Libero la ultima entrada del indice de stack
free(pop_stack(actual_stack_index));
}
void sentencia(void) {
/*
* <sentencia> -> <identificador> ASIGNACION <expresión> PUNTOYCOMA
* | LEER PARENIZQUIERDO <listaIdentificadores> PARENDERECHO PUNTOYCOMA
* | ESCRIBIR PARENIZQUIERDO <listaExpresiones> PARENDERECHO PUNTOYCOMA
*/
token tok = next_token();
reg_expr right_operand, left_operand;
switch (tok) {
case ID:
identificador(&left_operand);
match(ASIGNACION);
expresion(&right_operand);
asignar(&left_operand, &right_operand); // #asignar
match(PUNTOYCOMA);
break;
case LEER:
match(LEER);
match(PARENIZQUIERDO);
lista_identificadores();
match(PARENDERECHO);
match(PUNTOYCOMA);
break;
case ESCRIBIR:
match(ESCRIBIR);
match(PARENIZQUIERDO);
lista_expresiones();
match(PARENDERECHO);
match(PUNTOYCOMA);
break;
default:
syntax_error(tok, "SENTENCIA");
}
}
void menu(matriz A, matriz B)
{int op; limpiar();double x;
gotoxy(10,5); cout<<"[1] OBTENER UN ELEMENTO DE A..";
gotoxy(10,6); cout<<"[2] OBTENER UN ELEMENTO DE B..";
gotoxy(10,7); cout<<"[3] ASIGNAR UN ELEMENTO DE A..";
gotoxy(10,8); cout<<"[4] ASIGNAR UN ELEMENTO DE B..";
gotoxy(10,9); cout<<"[5] IGUALAR A<-B..............";
gotoxy(10,10); cout<<"[6] IGUALAR B<-A..............";
gotoxy(10,11); cout<<"[7] SUMAR A + B...............";
gotoxy(10,12); cout<<"[8] NEGATIVA DE A.............";
gotoxy(10,13); cout<<"[9] NEGATIVA DE B.............";
gotoxy(10,14); cout<<"[10] RESTAR A - B.............";
gotoxy(10,15); cout<<"[11] RESTAR B - A.............";
gotoxy(10,16); cout<<"[12] ESCALAR PARA A...........";
gotoxy(10,17); cout<<"[13] ESCALAR PARA B...........";
gotoxy(10,18); cout<<"[14] PRODUCTO A * B...........";
gotoxy(10,19); cout<<"[15] PRODUCTO B * A...........";
gotoxy(10,20); cout<<"[16] TRANSPUESTA DE A.........";
gotoxy(10,21); cout<<"[17] TRANSPUESTA DE B.........";
gotoxy(10,22); cout<<"[18] DETERMINANTE DE A........";
gotoxy(10,23); cout<<"[19] DETERMINANTE DE B........";
gotoxy(10,24); cout<<"[20] INVERSA DE A.............";
gotoxy(10,25); cout<<"[21] INVERSA DE B.............";
gotoxy(10,26); cout<<"[22] SALIR....................";
do{gotoxy(22,28); cout<<"Seleccione una opcion (1-22): ";cin>>op;
if(op<1 || op>22)
{gotoxy(20,28);cout<<"Opci¢n incorrecta vuelva a intentar";}
}while(op<1 || op>22);
switch(op)
{case 1: {limpiar();gotoxy(28,4); cout<<"[1] OBTENER UN ELEMENTO DE A..";
obtener(A);menu(A,B);break;}
case 2: {limpiar(); gotoxy(28,4); cout<<"[2] OBTENER UN ELEMENTO DE B..";
obtener(B);menu(A,B);break;}
case 3: {limpiar(); gotoxy(28,4); cout<<"[3] ASIGNAR UN ELEMENTO DE A..";
imprimir(asignar(A));getchar();menu(A,B);break;}
case 4: {limpiar(); gotoxy(28,4); cout<<"[4] ASIGNAR UN ELEMENTO DE B..";
imprimir(asignar(B));getchar();menu(A,B);break;}
case 5: {limpiar(); gotoxy(28,4); cout<<"[5] IGUALAR A<-B..............";
imprimir(igual(A,B));menu(A,B);break;}
case 6: {limpiar(); gotoxy(28,4); cout<<"[6] IGUALAR B<-A..............";
imprimir(igual(B,A));menu(A,B);break;}
case 7: {limpiar(); gotoxy(28,4); cout<<"[7] SUMAR A + B...............";
imprimir(sumar(A,B));menu(A,B);break;}
case 8: {limpiar(); gotoxy(28,4); cout<<"[8] NEGATIVA DE A.............";
imprimir(negativa(A));menu(A,B);break;}
case 9: {limpiar(); gotoxy(28,4); cout<<"[9] NEGATIVA DE B.............";
imprimir(negativa(B));menu(A,B);break;}
case 10: {limpiar(); gotoxy(28,4); cout<<"[10] RESTAR A - B.............";
imprimir(restar(A,B));menu(A,B);break;}
case 11: {limpiar(); gotoxy(28,4); cout<<"[11] RESTAR B - A.............";
imprimir(restar(B,A));menu(A,B);break;}
case 12: {limpiar(); gotoxy(28,4); cout<<"[12] ESCALAR PARA A...........";
imprimir(escalar(A));menu(A,B);break;}
case 13: {limpiar(); gotoxy(28,4); cout<<"[13] ESCALAR PARA B...........";
imprimir(escalar(B));menu(A,B);break;}
case 14: {limpiar(); gotoxy(28,4); cout<<"[14] PRODUCTO A * B...........";
imprimir(producto(A,B));menu(A,B);break;}
case 15: {limpiar(); gotoxy(28,4); cout<<"[15] PRODUCTO B * A...........";
imprimir(producto(B,A));menu(A,B);break;}
case 16: {limpiar(); gotoxy(28,4); cout<<"[16] TRANSPUESTA DE A.........";
imprimir(transpuesta(A));menu(A,B);break;}
case 17: {limpiar(); gotoxy(28,4); cout<<"[17] TRANSPUESTA DE B.........";
imprimir(transpuesta(B));menu(A,B);break;}
case 18: {limpiar(); gotoxy(28,4); cout<<"[18] DETERMINANTE DE A........";
x=det(A);gotoxy(5,5);cout<<"Determinante = "<<x;getchar();menu(A,B);break;}
case 19: {limpiar(); gotoxy(28,4); cout<<"[19] DETERMINANTE DE B........";
x=det(B);gotoxy(5,5);cout<<"Determinante = "<<x;getchar();menu(A,B);break;}
case 20: {limpiar(); gotoxy(28,4); cout<<"[20] INVERSA DE A.............";
inversa(A);menu(A,B);break;}
case 21: {limpiar(); gotoxy(28,4); cout<<"[21] INVERSA DE B.............";
inversa(B);menu(A,B);break;}
case 22: {limpiar(); gotoxy(28,4); cout<<"[22] SALIR....................";
gotoxy(10,10); cout<<"Saliendo...";
gotoxy(25,23); cout<<"Presione Enter Para Salir...";break;
}
}
}
String::String(const char *s, int largo) : buffer(NULL),
tamanoReservado(0), tamano(0) {
asignar(s, largo);
}
String::String(const char * s) : buffer(NULL), tamanoReservado(0), tamano(0) {
asignar(s);
}
void retornar(t_valor_variable retorno) {
if (SEG_flag == 1)
return;
printf("retornar\n");
uint32_t prog_counter_ant; //vamos a pedir los 12 bytes que guardamos en el stack para volver al cntxt anterior.
uint32_t cursor_contexto_ant;
uint32_t direccion_retornar;
uint32_t cant_vars_ant;
t_struct_sol_bytes * punts_contx_ant = malloc(sizeof(t_struct_sol_bytes));
punts_contx_ant->base = var_seg_stack;
punts_contx_ant->offset = (temp_cursor_stack - (3 * sizeof(uint32_t))); //-var_seg_stack;estoy casi seguro que no se le resta la base, porq el cursor de contexto ya es el offset de la base //restamos el cursor actual - 12(xq es el tamaño de los punteros q guarde en la umv) - el inicio del stack.
punts_contx_ant->tamanio = 3 * sizeof(uint32_t);
socket_enviar(sockUMV, D_STRUCT_SOL_BYTES, punts_contx_ant);
void * structRecibido;
t_tipoEstructura tipoStruct;
socket_recibir(sockUMV, &tipoStruct, &structRecibido);
if (tipoStruct != D_STRUCT_RESPUESTA_UMV) {
printf("%d\n", tipoStruct);
}
int tamanio_instruccion;
tamanio_instruccion = ((t_struct_respuesta_umv*) structRecibido)->tamano_buffer;
if (tamanio_instruccion == sizeof(int)) {
int*respuesta = malloc(sizeof(int));
memcpy(respuesta, ((t_struct_respuesta_umv*) structRecibido)->buffer, tamanio_instruccion);
int valor1 = *respuesta;
if (valor1 < 0) {
excepcion_UMV(0);
return;
}
}
int tmanio_respuesta, offset;
tmanio_respuesta = ((t_struct_respuesta_umv*) structRecibido)->tamano_buffer; //esto esta al pedo
memcpy(&cursor_contexto_ant, ((t_struct_respuesta_umv*) structRecibido)->buffer, offset = sizeof(uint32_t));
memcpy(&prog_counter_ant, ((t_struct_respuesta_umv*) structRecibido)->buffer + offset, sizeof(uint32_t));
offset += sizeof(uint32_t);
memcpy(&direccion_retornar, ((t_struct_respuesta_umv*) structRecibido)->buffer + offset, sizeof(uint32_t));
free(((t_struct_respuesta_umv*) structRecibido)->buffer);
free(structRecibido);
dictionary_clean_and_destroy_elements(dicc_variables, free); // debemos limpiar el diccionario y rellenarlo con las variables del contexto anterior
cant_vars_ant = ((punts_contx_ant->offset) - cursor_contexto_ant) / 5;
int i = 0;
int incremento = 0;
int posicion = 1;
while (i < cant_vars_ant) { // con esto volvemos a llenar el dicc_variables con las variables del contexto anterior
int valor_var;
char nombre_var;
t_struct_sol_bytes * sol_var_ant = malloc(sizeof(t_struct_sol_bytes));
sol_var_ant->base = var_seg_stack;
sol_var_ant->offset = cursor_contexto_ant + incremento;
sol_var_ant->tamanio = sizeof(char) + sizeof(int);
socket_enviar(sockUMV, D_STRUCT_SOL_BYTES, sol_var_ant);
void * structRecibido2;
t_tipoEstructura tipoStruct2;
socket_recibir(sockUMV, &tipoStruct2, &structRecibido2);
if (tipoStruct2 != D_STRUCT_RESPUESTA_UMV) {
printf("%d\n", tipoStruct2);
}
memcpy(&nombre_var, ((t_struct_respuesta_umv*) structRecibido2)->buffer, offset = sizeof(char));
memcpy(&valor_var, ((t_struct_respuesta_umv*) structRecibido2)->buffer + offset, sizeof(int)); // no es necesario este valor
char key = nombre_var;
char keyABuscar[2] = { key, '\0' };
int* posicion_variable = malloc(sizeof(int));
*posicion_variable = posicion;
dictionary_put(dicc_variables, keyABuscar, posicion_variable);
incremento = incremento + (sol_var_ant->tamanio);
i++;
posicion++;
free(sol_var_ant);
free(((t_struct_respuesta_umv*) structRecibido2)->buffer);
free(structRecibido2);
//free(posicion_variable);
}
temp_counter = prog_counter_ant; //aca cargamos PCounter del cntxt que guradamos en la UMV.
temp_cursor_stack = cursor_contexto_ant; //aca cargo elcursor del cntxt anterior q se guardo en la UMV.
//direccion_retornar=retorno; // esto no creo q sea asi, me parece que deberia hacerse una asignacion del valor de "reotorno" en la "direccion_retornar". lO hice mas arriba
var_tamanio_contexto = cant_vars_ant; // recuperamos nuestro tamanio de contexto anterior cortesia de la variable cant_vars_ant creada para el recupero del diccionario de variables ;)
if (retorno != -1) {
asignar(direccion_retornar, retorno); // el if es para reutilizar el reotornar en el finalizar omitiendo la asignacion
}
log_escribir(archLog,"Se termina de ejecutar una instruccion",INFO,"Se ejecuto retornar");
free(punts_contx_ant);
printf("retornar\n");
}
