--- rpl/src/instructions_r4.c 2010/01/27 22:22:15 1.2 +++ rpl/src/instructions_r4.c 2010/03/09 10:18:48 1.10 @@ -1,6 +1,6 @@ /* ================================================================================ - RPL/2 (R) version 4.0.10 + RPL/2 (R) version 4.0.13 Copyright (C) 1989-2010 Dr. BERTRAND Joël This file is part of RPL/2. @@ -751,7 +751,7 @@ instruction_relax(struct_processus *s_et void instruction_rewind(struct_processus *s_etat_processus) { - file *descripteur; + struct_descripteur_fichier *descripteur; struct_objet *s_objet_argument; @@ -803,11 +803,19 @@ instruction_rewind(struct_processus *s_e return; } - if (fseek(descripteur, (long) 0, SEEK_SET) != 0) + if ((*descripteur).type == 'C') + { + if (fseek((*descripteur).descripteur_c, (long) 0, SEEK_SET) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + } + else { liberation(s_etat_processus, s_objet_argument); - (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + (*s_etat_processus).erreur_execution = d_ex_erreur_type_fichier; return; } } @@ -838,7 +846,13 @@ instruction_rewind(struct_processus *s_e void instruction_read(struct_processus *s_etat_processus) { - file *descripteur; + const char *queue; + + int ios; + + integer8 element; + integer8 id; + integer8 position_clef; logical1 indicateur_48; logical1 presence_chaine; @@ -854,6 +868,8 @@ instruction_read(struct_processus *s_eta socklen_t longueur_adresse; + sqlite3_stmt *ppStmt; + struct flock lock; struct sockaddr_un adresse_unix; @@ -862,14 +878,23 @@ instruction_read(struct_processus *s_eta struct timespec attente; + struct_descripteur_fichier *descripteur; + + struct_liste_chainee *l_element_courant; + struct_liste_chainee *l_element_inclus; + struct_objet *s_objet_adresse; - struct_objet *s_objet_argument; + struct_objet *s_objet_argument_1; + struct_objet *s_objet_argument_2; struct_objet *s_objet_resultat; struct_objet *s_objet_type; unsigned char caractere; + unsigned char *clef_utf8; + unsigned char *commande; unsigned char *tampon_lecture; unsigned char *tampon; + unsigned char *tampon2; unsigned long i; @@ -891,9 +916,10 @@ instruction_read(struct_processus *s_eta printf("(read a record of a file)\n\n"); } - printf(" 1: %s, %s\n", d_FCH, d_SCK); - printf(" To be fixed !\n"); + printf(" 1: %s, %s\n\n", d_FCH, d_SCK); + printf(" 2: %s, %s\n", d_INT, d_CHN); + printf(" 1: %s\n", d_FCH); return; } else if ((*s_etat_processus).test_instruction == 'Y') @@ -904,21 +930,54 @@ instruction_read(struct_processus *s_eta if (test_cfsf(s_etat_processus, 31) == d_vrai) { - if (empilement_pile_last(s_etat_processus, 1) == d_erreur) + if ((*s_etat_processus).l_base_pile == NULL) { + (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } + + if ((*(*(*s_etat_processus).l_base_pile).donnee).type == FCH) + { + if ((*((struct_fichier *) (*(*(*s_etat_processus).l_base_pile) + .donnee).objet)).acces == 'S') + { + if (empilement_pile_last(s_etat_processus, 1) == d_erreur) + { + return; + } + } + else + { + if (empilement_pile_last(s_etat_processus, 2) == d_erreur) + { + return; + } + } + } + else + { + if (empilement_pile_last(s_etat_processus, 1) == d_erreur) + { + return; + } + } } if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), - &s_objet_argument) == d_erreur) + &s_objet_argument_1) == d_erreur) { (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } - if ((*s_objet_argument).type == FCH) + if ((*s_objet_argument_1).type == FCH) { + if ((descripteur = descripteur_fichier(s_etat_processus, + (struct_fichier *) (*s_objet_argument_1).objet)) == NULL) + { + return; + } + /* * Vérification des verrous */ @@ -929,15 +988,10 @@ instruction_read(struct_processus *s_eta lock.l_len = 0; lock.l_pid = getpid(); - if ((descripteur = descripteur_fichier(s_etat_processus, - (struct_fichier *) (*s_objet_argument).objet)) == NULL) + if (fcntl(fileno((*descripteur).descripteur_c), F_GETLK, &lock) + == -1) { - return; - } - - if (fcntl(fileno(descripteur), F_GETLK, &lock) == -1) - { - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; @@ -945,7 +999,7 @@ instruction_read(struct_processus *s_eta if (lock.l_type != F_UNLCK) { - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); (*s_etat_processus).erreur_execution = d_ex_fichier_verrouille; @@ -956,30 +1010,35 @@ instruction_read(struct_processus *s_eta * Vérification de l'autorisation de lecture */ - if ((*((struct_fichier *) (*s_objet_argument).objet)).protection == 'W') + if ((*((struct_fichier *) (*s_objet_argument_1).objet)).protection + == 'W') { - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier; return; } - else if ((*((struct_fichier *) (*s_objet_argument).objet)).protection + else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).protection == 'N') { - if (fflush(descripteur) != 0) + if ((*descripteur).type == 'C') { - (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; - return; + if (fflush((*descripteur).descripteur_c) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } } } - if ((*((struct_fichier *) (*s_objet_argument).objet)).binaire == 'N') + if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire == 'N') { /* * Fichiers formatés */ - if ((*((struct_fichier *) (*s_objet_argument).objet)).acces == 'S') + if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces + == 'S') { /* * Fichiers séquentiels @@ -995,7 +1054,10 @@ instruction_read(struct_processus *s_eta return; } - if ((position_initiale = ftell(descripteur)) == -1) + BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n")); + + if ((position_initiale = ftell((*descripteur).descripteur_c)) + == -1) { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; @@ -1005,7 +1067,7 @@ instruction_read(struct_processus *s_eta { longueur_effective = fread(tampon_lecture, (size_t) sizeof(unsigned char), longueur_questure, - descripteur); + (*descripteur).descripteur_c); pointeur = 0; presence_indicateur = d_faux; @@ -1030,7 +1092,7 @@ instruction_read(struct_processus *s_eta if (presence_indicateur == d_faux) { - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); free(tampon_lecture); (*s_etat_processus).erreur_execution = @@ -1042,9 +1104,10 @@ instruction_read(struct_processus *s_eta presence_chaine = d_faux; niveau = 1; - if (fseek(descripteur, position_finale, SEEK_SET) != 0) + if (fseek((*descripteur).descripteur_c, position_finale, + SEEK_SET) != 0) { - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); free(tampon_lecture); (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; @@ -1055,7 +1118,7 @@ instruction_read(struct_processus *s_eta { longueur_effective = fread(tampon_lecture, (size_t) sizeof(unsigned char), longueur_questure, - descripteur); + (*descripteur).descripteur_c); pointeur = 0; presence_indicateur = d_faux; @@ -1064,8 +1127,19 @@ instruction_read(struct_processus *s_eta { if (tampon_lecture[pointeur] == '"') { - presence_chaine = (presence_chaine == d_vrai) - ? d_faux : d_vrai; + if (pointeur > 0) + { + if (tampon_lecture[pointeur - 1] != '\\') + { + presence_chaine = (presence_chaine == + d_vrai) ? d_faux : d_vrai; + } + } + else + { + presence_chaine = (presence_chaine == d_vrai) + ? d_faux : d_vrai; + } } else { @@ -1100,7 +1174,7 @@ instruction_read(struct_processus *s_eta if (presence_indicateur == d_faux) { - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); free(tampon_lecture); (*s_etat_processus).erreur_execution = @@ -1119,9 +1193,10 @@ instruction_read(struct_processus *s_eta return; } - if (fseek(descripteur, position_initiale, SEEK_SET) != 0) + if (fseek((*descripteur).descripteur_c, position_initiale, + SEEK_SET) != 0) { - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); free(tampon_lecture); (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; @@ -1131,7 +1206,7 @@ instruction_read(struct_processus *s_eta longueur_effective = fread(tampon_lecture, (size_t) sizeof(unsigned char), (size_t) longueur_enregistrement, - descripteur); + (*descripteur).descripteur_c); if (longueur_effective != longueur_enregistrement) { @@ -1141,20 +1216,38 @@ instruction_read(struct_processus *s_eta tampon_lecture[longueur_enregistrement] = d_code_fin_chaine; tampon = (*s_etat_processus).instruction_courante; - (*s_etat_processus).instruction_courante = tampon_lecture; + + if (((*s_etat_processus).instruction_courante = + transliteration(s_etat_processus, tampon_lecture, + "UTF-8", d_locale)) == NULL) + { + (*s_etat_processus).instruction_courante = tampon; + liberation(s_etat_processus, s_objet_argument_1); + free(tampon_lecture); + return; + } indicateur_48 = test_cfsf(s_etat_processus, 48); cf(s_etat_processus, 48); recherche_type(s_etat_processus); + free((*s_etat_processus).instruction_courante); if ((*s_etat_processus).erreur_execution != d_ex) { + if (indicateur_48 == d_vrai) + { + sf(s_etat_processus, 48); + } + else + { + cf(s_etat_processus, 48); + } + (*s_etat_processus).instruction_courante = tampon; free(tampon_lecture); - liberation(s_etat_processus, s_objet_argument); - + liberation(s_etat_processus, s_objet_argument_1); return; } @@ -1170,15 +1263,595 @@ instruction_read(struct_processus *s_eta (*s_etat_processus).instruction_courante = tampon; free(tampon_lecture); } - else if ((*((struct_fichier *) (*s_objet_argument).objet)).acces + else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces == 'D') { + BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n")); + + if (depilement(s_etat_processus, &((*s_etat_processus) + .l_base_pile), &s_objet_argument_2) == d_erreur) + { + (*s_etat_processus).erreur_execution = d_ex_manque_argument; + return; + } + + if ((*s_objet_argument_2).type != INT) + { + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_argument_2); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_type_argument; + return; + } + + if (alsprintf(&commande, "select data from data where " + "id = %lld", (*((integer8 *) (*s_objet_argument_2) + .objet))) < 0) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite, + commande, strlen(commande), &ppStmt, &queue) + != SQLITE_OK) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + switch(sqlite3_step(ppStmt)) + { + case SQLITE_ROW: + { + // Résultat attendu + break; + } + + case SQLITE_DONE: + { + // Aucun enregistrement + if (sqlite3_finalize(ppStmt) != SQLITE_OK) + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + + free(commande); + + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_argument_2); + + (*s_etat_processus).erreur_execution = + d_ex_enregistrement_inexistant; + return; + } + + default: + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + } + + if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + tampon = (*s_etat_processus).instruction_courante; + + if ((tampon_lecture = (unsigned char *) + sqlite3_column_text(ppStmt, 0)) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + if (((*s_etat_processus).instruction_courante = + transliteration(s_etat_processus, tampon_lecture, + "UTF-8", d_locale)) == NULL) + { + (*s_etat_processus).instruction_courante = tampon; + + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_argument_2); + free(commande); + return; + } + + indicateur_48 = test_cfsf(s_etat_processus, 48); + cf(s_etat_processus, 48); + + recherche_type(s_etat_processus); + + if ((*s_etat_processus).erreur_execution != d_ex) + { + if (indicateur_48 == d_vrai) + { + sf(s_etat_processus, 48); + } + else + { + cf(s_etat_processus, 48); + } + + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_argument_2); + + free((*s_etat_processus).instruction_courante); + free(commande); + + (*s_etat_processus).instruction_courante = tampon; + return; + } + + if (indicateur_48 == d_vrai) + { + sf(s_etat_processus, 48); + } + else + { + cf(s_etat_processus, 48); + } + + free((*s_etat_processus).instruction_courante); + liberation(s_etat_processus, s_objet_argument_2); + (*s_etat_processus).instruction_courante = tampon; + + if (sqlite3_step(ppStmt) != SQLITE_DONE) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + if (sqlite3_finalize(ppStmt) != SQLITE_OK) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + free(commande); } else { + BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n")); + + if (depilement(s_etat_processus, &((*s_etat_processus) + .l_base_pile), &s_objet_argument_2) == d_erreur) + { + (*s_etat_processus).erreur_execution = d_ex_manque_argument; + return; + } + + if ((*s_objet_argument_2).type != CHN) + { + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_argument_2); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_type_argument; + return; + } + + // Récupération de la position de la clef + + if (alsprintf(&commande, "select key from control " + "where id = 1") < 0) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite, + commande, strlen(commande), &ppStmt, &queue) + != SQLITE_OK) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + if (sqlite3_step(ppStmt) != SQLITE_ROW) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + position_clef = sqlite3_column_int64(ppStmt, 0); + + if (sqlite3_step(ppStmt) != SQLITE_DONE) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + if (sqlite3_finalize(ppStmt) != SQLITE_OK) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + free(commande); + + if ((clef_utf8 = transliteration(s_etat_processus, + (unsigned char *) (*s_objet_argument_2).objet, + d_locale, "UTF-8")) == NULL) + { + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_argument_2); + + return; + } + + // Récupération de l'identifiant de la clef + + if (alsprintf(&commande, "select id from key where key = " + "'{ \"%s\" }'", clef_utf8) < 0) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite, + commande, strlen(commande), &ppStmt, &queue) + != SQLITE_OK) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + switch(sqlite3_step(ppStmt)) + { + case SQLITE_ROW: + { + // Résultat attendu : une clef correspond. + break; + } + + case SQLITE_DONE: + { + // Aucun enregistrement + if (sqlite3_finalize(ppStmt) != SQLITE_OK) + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + + free(clef_utf8); + free(commande); + + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_argument_2); + + (*s_etat_processus).erreur_execution = + d_ex_enregistrement_inexistant; + return; + } + + default: + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + } + + if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER) + { + free(clef_utf8); + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + id = sqlite3_column_int64(ppStmt, 0); + + if (sqlite3_step(ppStmt) != SQLITE_DONE) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + if (sqlite3_finalize(ppStmt) != SQLITE_OK) + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + + free(commande); + + if (alsprintf(&commande, "select data from data where " + "key_id = %lld order by sequence asc", id) < 0) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite, + commande, strlen(commande), &ppStmt, &queue) + != SQLITE_OK) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + element = 1; + + do + { + switch(ios = sqlite3_step(ppStmt)) + { + case SQLITE_ROW: + { + // Donnée supplémentaire + + if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT) + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + + tampon = (*s_etat_processus).instruction_courante; + + if ((tampon_lecture = (unsigned char *) + sqlite3_column_text(ppStmt, 0)) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + + if (((*s_etat_processus).instruction_courante = + transliteration(s_etat_processus, + tampon_lecture, + "UTF-8", d_locale)) == NULL) + { + (*s_etat_processus).instruction_courante = + tampon; + + liberation(s_etat_processus, + s_objet_argument_1); + liberation(s_etat_processus, + s_objet_argument_2); + + free(commande); + free(clef_utf8); + return; + } + + indicateur_48 = test_cfsf(s_etat_processus, 48); + cf(s_etat_processus, 48); + + recherche_type(s_etat_processus); + + if ((*s_etat_processus).erreur_execution != d_ex) + { + if (indicateur_48 == d_vrai) + { + sf(s_etat_processus, 48); + } + else + { + cf(s_etat_processus, 48); + } + + liberation(s_etat_processus, + s_objet_argument_1); + liberation(s_etat_processus, + s_objet_argument_2); + + free((*s_etat_processus).instruction_courante); + free(commande); + free(clef_utf8); + + (*s_etat_processus).instruction_courante = + tampon; + return; + } + + if (indicateur_48 == d_vrai) + { + sf(s_etat_processus, 48); + } + else + { + cf(s_etat_processus, 48); + } + + free((*s_etat_processus).instruction_courante); + (*s_etat_processus).instruction_courante = tampon; + + element++; + + // Inscription de la clef + + if (element == position_clef) + { + if (((*s_etat_processus).instruction_courante = + transliteration(s_etat_processus, + clef_utf8, "UTF-8", d_locale)) == NULL) + { + (*s_etat_processus).instruction_courante = + tampon; + + liberation(s_etat_processus, + s_objet_argument_1); + liberation(s_etat_processus, + s_objet_argument_2); + + free(commande); + free(clef_utf8); + return; + } + + if (alsprintf(&tampon2, "{ \"%s\" }", + (*s_etat_processus) + .instruction_courante) < 0) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + free((*s_etat_processus).instruction_courante); + (*s_etat_processus).instruction_courante + = tampon2; + + indicateur_48 = test_cfsf(s_etat_processus, 48); + cf(s_etat_processus, 48); + + recherche_type(s_etat_processus); + + if ((*s_etat_processus).erreur_execution + != d_ex) + { + if (indicateur_48 == d_vrai) + { + sf(s_etat_processus, 48); + } + else + { + cf(s_etat_processus, 48); + } + + liberation(s_etat_processus, + s_objet_argument_1); + liberation(s_etat_processus, + s_objet_argument_2); + + free((*s_etat_processus) + .instruction_courante); + free(commande); + free(clef_utf8); + + (*s_etat_processus).instruction_courante = + tampon; + return; + } + + if (indicateur_48 == d_vrai) + { + sf(s_etat_processus, 48); + } + else + { + cf(s_etat_processus, 48); + } + + free((*s_etat_processus).instruction_courante); + (*s_etat_processus).instruction_courante = + tampon; + + element++; + } + + break; + } + + case SQLITE_DONE: + { + // Fin de la liste + break; + } + + default: + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + } + + } while(ios != SQLITE_DONE); + + if (sqlite3_finalize(ppStmt) != SQLITE_OK) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + free(commande); + free(clef_utf8); + + liberation(s_etat_processus, s_objet_argument_2); + + if ((s_objet_resultat = allocation(s_etat_processus, LST)) + == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + l_element_courant = NULL; + l_element_inclus = NULL; + + for(element--; element > 0; element--) + { + if (depilement(s_etat_processus, &((*s_etat_processus) + .l_base_pile), &s_objet_argument_2) == d_erreur) + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + + if ((*s_objet_argument_2).type != LST) + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + + l_element_inclus = (*s_objet_argument_2).objet; + + if (l_element_inclus != NULL) + { + while(l_element_inclus != NULL) + { + if ((*l_element_inclus).suivant == NULL) + { + (*l_element_inclus).suivant = l_element_courant; + break; + } + + l_element_inclus = (*l_element_inclus).suivant; + } + + l_element_courant = (*s_objet_argument_2).objet; + (*s_objet_argument_2).objet = NULL; + } + + liberation(s_etat_processus, s_objet_argument_2); + } + + (*s_objet_resultat).objet = l_element_inclus; + + if (empilement(s_etat_processus, + &((*s_etat_processus).l_base_pile), + s_objet_resultat) == d_erreur) + { + return; + } } } - else if ((*((struct_fichier *) (*s_objet_argument).objet)).binaire + else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire == 'Y') { /* @@ -1192,15 +1865,16 @@ instruction_read(struct_processus *s_eta */ } } - else if ((*s_objet_argument).type == SCK) + else if ((*s_objet_argument_1).type == SCK) { /* * Vérification de l'autorisation de lecture */ - if ((*((struct_socket *) (*s_objet_argument).objet)).protection == 'W') + if ((*((struct_socket *) (*s_objet_argument_1).objet)).protection + == 'W') { - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier; return; @@ -1210,21 +1884,22 @@ instruction_read(struct_processus *s_eta * Vérification de l'écoute de la socket si celle-ci est connectée */ - if ((strcmp((*((struct_socket *) (*s_objet_argument).objet)).type, + if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type, "STREAM") == 0) || (strcmp((*((struct_socket *) - (*s_objet_argument).objet)).type, "SEQUENTIAL DATAGRAM") == 0)) + (*s_objet_argument_1).objet)).type, "SEQUENTIAL DATAGRAM") + == 0)) { - if ((*((struct_socket *) (*s_objet_argument).objet)) + if ((*((struct_socket *) (*s_objet_argument_1).objet)) .socket_en_ecoute == 'Y') { - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); (*s_etat_processus).erreur_execution = d_ex_socket_en_ecoute; return; } } - if ((*((struct_socket *) (*s_objet_argument).objet)).binaire == 'N') + if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire == 'N') { // Socket formatée longueur_questure = 256; @@ -1246,32 +1921,32 @@ instruction_read(struct_processus *s_eta for(;;) { - if ((*((struct_socket *) (*s_objet_argument).objet)).domaine - == PF_UNIX) + if ((*((struct_socket *) (*s_objet_argument_1).objet)) + .domaine == PF_UNIX) { longueur_adresse = sizeof(adresse_unix); longueur_effective = recvfrom((*((struct_socket *) - (*s_objet_argument).objet)).socket, + (*s_objet_argument_1).objet)).socket, tampon_lecture, longueur_questure, MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) &adresse_unix, &longueur_adresse); } - else if ((*((struct_socket *) (*s_objet_argument).objet)) + else if ((*((struct_socket *) (*s_objet_argument_1).objet)) .domaine == PF_INET) { longueur_adresse = sizeof(adresse_ipv4); longueur_effective = recvfrom((*((struct_socket *) - (*s_objet_argument).objet)).socket, + (*s_objet_argument_1).objet)).socket, tampon_lecture, longueur_questure, MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) &adresse_ipv4, &longueur_adresse); } - else if ((*((struct_socket *) (*s_objet_argument).objet)) + else if ((*((struct_socket *) (*s_objet_argument_1).objet)) .domaine == PF_INET6) { longueur_adresse = sizeof(adresse_ipv6); longueur_effective = recvfrom((*((struct_socket *) - (*s_objet_argument).objet)).socket, + (*s_objet_argument_1).objet)).socket, tampon_lecture, longueur_questure, MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) &adresse_ipv6, &longueur_adresse); @@ -1279,7 +1954,7 @@ instruction_read(struct_processus *s_eta else { free(tampon_lecture); - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); while(sem_wait(&((*s_etat_processus) .semaphore_fork)) == -1) @@ -1331,14 +2006,14 @@ instruction_read(struct_processus *s_eta */ free(tampon_lecture); - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); return; } if (longueur_effective == -1) { free(tampon_lecture); - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier; @@ -1405,7 +2080,7 @@ instruction_read(struct_processus *s_eta { if (longueur_effective < longueur_questure) { - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); free(tampon_lecture); (*s_etat_processus).erreur_execution = @@ -1433,8 +2108,7 @@ instruction_read(struct_processus *s_eta (*s_etat_processus).instruction_courante = tampon; free(tampon_lecture); - liberation(s_etat_processus, s_objet_argument); - + liberation(s_etat_processus, s_objet_argument_1); return; } @@ -1503,26 +2177,26 @@ instruction_read(struct_processus *s_eta * Dans tous les autres cas, on renvoie une liste vide. */ - if (((*((struct_socket *) (*s_objet_argument).objet)).domaine + if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine == PF_UNIX) || (strcmp((*((struct_socket *) - (*s_objet_argument).objet)).type, "STREAM") == 0) || - (strcmp((*((struct_socket *) (*s_objet_argument).objet)) + (*s_objet_argument_1).objet)).type, "STREAM") == 0) || + (strcmp((*((struct_socket *) (*s_objet_argument_1).objet)) .type, "SEQUENTIAL DATAGRAM") == 0)) { longueur_adresse = 0; recvfrom((*((struct_socket *) - (*s_objet_argument).objet)).socket, tampon_lecture, + (*s_objet_argument_1).objet)).socket, tampon_lecture, position_finale, MSG_DONTWAIT, NULL, &longueur_adresse); (*s_objet_adresse).objet = NULL; } - else if ((*((struct_socket *) (*s_objet_argument).objet)) + else if ((*((struct_socket *) (*s_objet_argument_1).objet)) .domaine == PF_INET) { longueur_adresse = sizeof(adresse_ipv4); recvfrom((*((struct_socket *) - (*s_objet_argument).objet)).socket, tampon_lecture, + (*s_objet_argument_1).objet)).socket, tampon_lecture, position_finale, MSG_DONTWAIT, (struct sockaddr *) &adresse_ipv4, &longueur_adresse); @@ -1590,18 +2264,18 @@ instruction_read(struct_processus *s_eta } (*((integer8 *) (*(*(*((struct_liste_chainee *) - (*s_objet_adresse) .objet)).suivant).donnee).objet)) = + (*s_objet_adresse).objet)).suivant).donnee).objet)) = (integer8) ntohs(adresse_ipv4.sin_port); (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) .suivant).suivant = NULL; } - else if ((*((struct_socket *) (*s_objet_argument).objet)) + else if ((*((struct_socket *) (*s_objet_argument_1).objet)) .domaine == PF_INET6) { longueur_adresse = sizeof(adresse_ipv6); recvfrom((*((struct_socket *) - (*s_objet_argument).objet)).socket, tampon_lecture, + (*s_objet_argument_1).objet)).socket, tampon_lecture, position_finale, MSG_DONTWAIT, (struct sockaddr *) &adresse_ipv6, &longueur_adresse); @@ -1660,7 +2334,7 @@ instruction_read(struct_processus *s_eta } (*((integer8 *) (*(*(*((struct_liste_chainee *) - (*s_objet_adresse) .objet)).suivant).donnee).objet)) = + (*s_objet_adresse).objet)).suivant).donnee).objet)) = (integer8) ntohs(adresse_ipv6.sin6_port); (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) @@ -1670,7 +2344,7 @@ instruction_read(struct_processus *s_eta { longueur_adresse = 0; recvfrom((*((struct_socket *) - (*s_objet_argument).objet)).socket, tampon_lecture, + (*s_objet_argument_1).objet)).socket, tampon_lecture, position_finale, MSG_DONTWAIT, NULL, &longueur_adresse); } @@ -1694,7 +2368,7 @@ instruction_read(struct_processus *s_eta return; } - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); return; }