GestorChk::~GestorChk()
{
liberar( chksObj );
liberar( chksAtr );
liberar( chksMth );
liberar( chksInstr );
}
int main(int argc, char** argv){
if(argc != 3){
printf("Uso: ./join <Archivo1> <Archivo2>\n");
exit(1);
}
FILE* archivo1 = fopen(argv[1], "r");
FILE* archivo2 = fopen(argv[2], "r");
if(!archivo1 || !archivo2) {
if(archivo1) fclose(archivo1);
if(archivo2) fclose(archivo2);
printf("Error al abrir un archivo o no existe\n");
exit(1);
}
hash_t* hash = hash_crear(free);
if(!hash){
liberar(hash, archivo1, archivo2);
exit(1);
}
ssize_t len1 = 0, len2=0;
size_t capacidad = 0;
char* linea1 = NULL;
char* linea2 = NULL;
while((len2 = getline(&linea2, &capacidad, archivo2 ) > 0)){
char* campo_1 = obtener_campo1(linea2);
if(!hash_guardar(hash, campo_1, linea2)){
liberar(hash, archivo1, archivo2);
exit(1);
}
free(campo_1);
linea2 = NULL;
}
while((len1 = getline(&linea1, &capacidad, archivo1 ) > 0)){
char cadena[MAX_LEN];
char* campo_1 = obtener_campo1(linea1);
if(hash_pertenece(hash, campo_1)){
char* aux = cadena;
acoplar(&aux, linea1, (char*)hash_obtener(hash, campo_1));
printf("%s", cadena);
}
free(campo_1);
}
liberar(hash, archivo1, archivo2);
free(linea1);
free(linea2);
return 0;
}
int main(int argc, char *argv[])
{
char *entrada=argv[1], *saida=argv[2]; //Obtendo o nome dos arquivos passados por parametro ao executar o programa
int instancias,aux;
FILE *input= fopen (entrada,"r"); //Abertura do arquivo de leitura de dados.
FILE *out= fopen (saida,"w+a"); //Abertura do arquivo para gravação dos dados de saida.
Matriz *MAT;
if(input == NULL ) //Verificar se o arquivo de entrada não pode ser aberto.
{
fprintf(out,"ERRO 01: Houve algum problema ao abrir o seu arquivo de texto, verifique se o arquivo existe ou se o nome digitado esta correto");
fclose(input);
fclose(out);
return 0;
}
fscanf(input,"%d ",&instancias);
if(instancias <= 0) //Verifica se o número de instãncias lido é permitido.
{
fprintf(out,"ERRO 02: Número de instâncias insuficiente");
fclose(out);
fclose(input);
return 0;
}
while(instancias > 0)//Loop para executar as leituras e operações das matrizes de acordo com o número de instâncias.
{
MAT = criar(MAT,input,out);
MAT = carregar(MAT,input);
MAT = verificar(MAT,input,out);
imprimir(MAT,out,instancias);
liberar(MAT);
instancias--;
}
fclose(out); //fechamento dos arquivos utilizados durante o programa
fclose(input);
return 0;
}
int main(void)
{
tNodoPolinomio *pol1,*pol2;
pol1 = NULL;
pol2 = NULL;
crearPolinomio(&pol1);
crearPolinomio(&pol2);
printf("\nPolinomio 1 : ");
recorrer(pol1);
printf("\nPolinomio 2 : ");
recorrer(pol2);
printf("\nSuma de ambos : ");
sumarPolinomios(&pol1,pol2);
recorrer(pol1);
liberar(pol1);
liberar(pol2);
return 0;
}
void eliminar_acciones (TABLA_SIMBOLOS tabla, int nivel)
/**********************************************************************/
{
int i, j;
for (i = 0; i < TAMANO_TABLA; ++i)
{
j = 1;
while (j <= longitud_lista (tabla[i]))
{
SIMBOLO *simbolo = (SIMBOLO*) observar (tabla[i], j);
if (ES_ACCION(*simbolo) && ((*simbolo).nivel == nivel))
{
liberar (&((*simbolo).parametros));
borrar (&tabla[i], j);
}
else
++j;
}
}
}
int main(){
printf("--INICIÓ PROCESO HIJO--\n");
init(); //inicializa operaciones
int i, j, n;
int shmid1,shmid2;
key_t llave1,llave2;
float *shm1;
float *shm2;
llave1 = 5677;
llave2 = 5678;
pid_t pid;
char *argv[2];
argv[0] = "Nieto";
argv[1] = NULL;
/*Creación de bloque de memoria compartida*/
if((shmid1 = shmget(llave1, sizeof(float)*100, IPC_CREAT | 0666)) < 0)
{
perror("Error al obtener memoria compartida: shmget\n");
exit(0);
}
if((shmid2 = shmget(llave2, sizeof(float)*100, IPC_CREAT | 0666)) < 0)
{
perror("Error al obtener memoria compartida: shmget\n");
exit(0);
}
if((shm1 = shmat(shmid1, NULL, 0)) == (float *) -1){
perror("Error al enlazar la memoria compartida: shmat\n");
exit(0);
}
if((shm2 = shmat(shmid2, NULL, 0)) == (float *) -1){
perror("Error al enlazar la memoria compartida: shmat\n");
exit(0);
}
/*Obtención de las matrices del proceso padre*/
Matriz m1 = crear(10, 10);
Matriz m2 = crear(10, 10);
for(i=0; i<10; i++){
for(j=0; j<10; j++){
n= (i*10) + j;
m1->filas[i][j] = *(shm1+n);
m2->filas[i][j] = *(shm2+n);
}
}
/*Valores de las matrices para el proceso nieto*/
srand(time(NULL));
for(i=0; i<100; i++){
*(shm1+i) = rand() % 11;
}
for(i=0; i<100; i++){
*(shm2+i) = rand() % 11;
}
/*Creación del proceso hijo del hijo*/
if((pid= fork())==-1)
printf("Error al crear el proceso hijo del proceso hijo\n");
if(pid == 0){
execv(argv[0], argv);
}
else{
Matriz m = mult(m1, m2);
printf("\nMatriz 1 recibida del padre:\n");
printMatriz(m1);
printf("\nMatriz 2 recibida del padre:\n");
printMatriz(m2);
printf("\nM1*M2:\n");
printMatriz(m);
esperar(0); //esperamos que termine suma
printf("Hijo: Enviando mult a padre...\n");
/*Guardando el producto en el bloque de memoria compartida*/
for(i=0; i<10; i++){
for(j=0; j<10; j++){
n= (i*10) + j;
*(shm1+n) = m->filas[i][j];
}
}
printf("--FINALIZÓ PROCESO HIJO--\n");
liberar(1); //termina multiplicación
exit(0);
}
}
/*
��� Destrutor �����������������������������������������������������������������
*/
IString::~IString()
{
IRASTROSTRING("IString::~IString()\n")
liberar();
}
int main() {
inicializar();
int lugar_juan= reservar("juan", 1);
printf("juan reservo el lugar %d\n", lugar_juan);
if (lugar_juan!=0) {
fprintf(stderr, "juan debio haber estacionado en 0, no en %d\n",
lugar_juan);
exit(1);
}
printE();
int lugar_eva= reservar("eva", 2);
printf("eva reservo el lugar %d\n", lugar_eva);
if (lugar_eva!=1) {
fprintf(stderr, "eva debio haber estacionado en 1, no en %d\n",
lugar_eva);
exit(2);
}
printE();
pthread_t hebra_pato;
Args args_pato= { "pato", 3, -1 };
pthread_create(&hebra_pato, NULL, carro, &args_pato);
printf("Verificando que pato espera por obtener su lugar\n");
sleep(1);
if (args_pato.lugar!=-1) {
fprintf(stderr, "pato debio haber esperado, pero recibio\n");
fprintf(stderr, "incorrectamente el lugar %d\n",
args_pato.lugar);
exit(3);
}
printE();
int lugar_ana= reservar("ana", 1);
printf("ana reservo el lugar %d\n", lugar_ana);
if (lugar_ana!=3) {
fprintf(stderr, "ana debio haber estacionado en 3, no en %d\n",
lugar_ana);
exit(4);
}
printE();
pthread_t hebra_pedro;
Args args_pedro= { "pedro", 5, -1 };
pthread_create(&hebra_pedro, NULL, carro, &args_pedro);
printf("Verificando que pedro espera por obtener su lugar\n");
sleep(1);
if (args_pedro.lugar!=-1) {
fprintf(stderr, "pedro debio haber esperado, pero recibio\n");
fprintf(stderr, "incorrectamente el lugar %d\n",
args_pedro.lugar);
exit(5);
}
printE();
liberar("eva");
printf("eva libera su lugar\n");
printE();
if (args_pato.lugar!=-1) {
fprintf(stderr, "pato debio haber esperado, pero recibio\n");
fprintf(stderr, "incorrectamente el lugar %d\n",
args_pato.lugar);
exit(6);
}
printE();
liberar("juan");
printf("juan libera su lugar\n");
printE();
pthread_join(hebra_pato, NULL);
printf("pato reservo el lugar %d\n", args_pato.lugar);
if (args_pato.lugar!=0) {
fprintf(stderr, "pato debio haber estacionado en 0, no en %d\n",
args_pato.lugar);
exit(7);
}
printE();
liberar("pato");
printf("pato libera su lugar\n");
if (args_pedro.lugar!=-1) {
fprintf(stderr, "pedro debio haber esperado, pero recibio\n");
fprintf(stderr, "incorrectamente el lugar %d\n",
args_pedro.lugar);
exit(8);
}
printE();
/* Al liberar ana usamos una copia del string "ana". En el enunciado
* se pide que se haga una copia del string y por lo tanto en la
* comparacion se debe usar strcmp y no la igualdad de punteros.
*/
char copia_ana[4];
strcpy(copia_ana, "ana");
liberar(copia_ana);
printf("ana libera su lugar\n");
pthread_join(hebra_pedro, NULL);
printf("pedro reservo el lugar %d\n", args_pedro.lugar);
if (args_pedro.lugar!=0) {
fprintf(stderr, "pedro debio haber estacionado en 0, no en %d\n",
args_pedro.lugar);
exit(9);
}
printE();
liberar("pedro");
printf("pedro libera su lugar\n");
printE();
printf("\nFelicitaciones: su solucion funciona de acuerdo al enunciado.\n");
return 0;
}
