Ejemplo n.º 1
0
void Recherche(Correspondance *c, Cascade_hte *index)
{
    // variables
    char recherche_brute[REQ_MAX];
    char *ca = NULL, char_vidage;
    int taille = 0;
    Correspondance *docs = c;

    while(docs != NULL){ // calcul du nombre de docs
        taille ++;
        docs = docs->next;
    }

    //execution
    if (fgets(recherche_brute, REQ_MAX-1, stdin) != NULL)
    {

        ca = strchr(recherche_brute, '\n');
        if (ca != NULL)
            *ca = '\0';
        else{
            while((char_vidage=getchar())!= '\n' && char_vidage!=EOF); // vidage buffer
            recherche_brute[REQ_MAX-1] = '\0';
        }
        Query* recherche_decoupe = decoupage(recherche_brute);
        int *tableau_resultats = NULL;
        tableau_resultats = classement(c, recherche_decoupe, index, &taille);
        Affichage_resultats(tableau_resultats, taille, c);
    }
    else
    {
        printf("Erreur saisie\n");
        return;
    }
}
Ejemplo n.º 2
0
static void decoupage(void * adr_zone_libre, uint8_t puiss_courante, uint8_t puiss_cherchee)
{
    if(puiss_courante != puiss_cherchee) 
    {
        //adresse du bloc de taille 2^(p-1)
        uint64_t adr_in_int = (uint64_t)adr_zone_libre + (1<<(puiss_courante-1));
        void * adr_prochain_bloc = (void *)adr_in_int;

        //ajout en tête de tzl[p-1]
        struct header h;
        h.taille = puiss_courante-1;
        h.suivant = tzl[puiss_courante-1];
        *((struct header*)adr_prochain_bloc) = h;
        tzl[puiss_courante-1] = adr_prochain_bloc;

        //récursion sur la partie "gauche"
        decoupage(adr_zone_libre, puiss_courante-1, puiss_cherchee);
    }
}
Ejemplo n.º 3
0
// Deuxième partie de la fonction d'envoi d'un SMS
void Reception_SMS_Continue(int handle)
{
    char buffer_SMS_recu[250];

    strcpy(buffer_SMS_recu, GSM_Line);

    Remplissage_SMS(buffer_SMS_recu);

    if (Verification(expediteur) == 1)// Le SMS provient bien de l'avion
    {
        printf("Nouveau message recu de l'avion\n");

        /* Stockage du message dans un fichier de log */
        Save_SMS_In_Log();

        /* Vérification de l'index (pour ne pas en laisser passer un)*/
        if (Check_index(index_msg) == 0) /*on a laissé passer qqch*/
        {
            printf("Attention perte d'un ou plusieurs messages...\n");
        }

        printf("Contenu du message :%s\n", data);



        // Découpage prévu du SMS recu
        decoupage(data);

        /* Envoi sur le bus Ivy */
        IvySendMsg("16 GPS 3 %s %s %s %s %s %s 0 335297960 31 0", extr_gps_utm_east, extr_gps_utm_north, extr_gps_course, extr_gps_alt, extr_gps_gspeed, extr_gps_climb);
        IvySendMsg("16 FBW_STATUS 0 1 %s 0",extr_vsupply);


        /* Suppression du message de la carte SIM */
        Suppr_SMS(handle, index_msg);
    }

    fflush(stdout);
}
Ejemplo n.º 4
0
    void *
mem_alloc(unsigned long size)
{
    if(zone_memoire == NULL)
    {
        perror("mémoire non initialisée!\n");
        return 0;
    }
    if(size == 0)
        return 0;

    //il nous faut la puissance de 2 de la taille souhaitée
    uint8_t k = prochaine_puissance(size);
    //il faut néanmoins avoir une taille minimale
    if(k < MIN_PUISS)
        k = MIN_PUISS;
    //on cherche la première liste de zones libres non-nulles
    uint8_t p = k;
    while((tzl[p] == NULL) && (p < 20))
    {
        p++; 
    }
    if(tzl[p] == NULL) 
    {
        return 0;      //il n'y a plus de zones libres
    }

    //récupération de la tête de liste
    void * adr_zone_libre = tzl[p];
    struct header h = *((struct header *)tzl[p]);
    //mise à jour du tableau de listes
    tzl[p] = h.suivant;
    //on découpe récursivement la zone libre jusqu'à ce qu'on tombe
    //sur la bonne taille
    decoupage(adr_zone_libre, p, k);
    return adr_zone_libre;
}
Ejemplo n.º 5
0
int main(int args,char* argv[]){
int i;
commande mot_decoupe;
FILE* pIN=fdopen(1,"r");	
char entree[256];
pid_t pid_fils;
int status;

	while(1){
		fgets(entree,256,pIN);	
		mot_decoupe=decoupage(entree);
		if(mot_decoupe->cmd_suivante==0){
			if((pid_fils=fork())==0){
				execvp(mot_decoupe->cmd[0],mot_decoupe->cmd);
				printf("erreur\n");
				break;
			}
			else
				wait(NULL);
			}
			else{
				if(fork()==0){
					execvp(mot_decoupe->cmd[0],mot_decoupe->cmd);
					printf("erreur\n");
					break;
				}
			else
				waitpid(pid_fils,&status,WNOHANG);									//On fait un wait non bloquant
			}
				for(i=0;i<N;i++)
					free(mot_decoupe->cmd[i]);
			
				free(mot_decoupe);
		}
	return 0;	
}