int main()
{
Mras2an_struct * myStruct = NULL;
/*Add new element*/
myStruct = ajouterFin(myStruct, 11);
myStruct = ajouterDebut(myStruct, 10);
myStruct = ajouterDebut(myStruct, 9);
myStruct = ajouterDebut(myStruct, 8);
/*print nb elements*/
printf("nbElement: %d\n",nbElement(myStruct));
printf("nbElementRec: %d\n",nbElementRec(myStruct));
/*print elements*/
affichage(myStruct);
/*search nb 10*/
if (recherche(myStruct, 10))
{
printf("Nb found\n");
}
else
{
printf("Nb not found\n");
}
/*search nb 20*/
if (recherche(myStruct, 20))
{
printf("Nb found\n");
}
else
{
printf("Nb not found\n");
}
/*removing the first and last element*/
myStruct = suppDebut(myStruct);
myStruct = suppFin(myStruct);
/*print*/
printf("nbElement: %d\n",nbElement(myStruct));
printf("nbElementRec: %d\n",nbElementRec(myStruct));
affichage(myStruct);
/*removing the nb 9*/
myStruct = element(myStruct, 9);
printf("nbElement: %d\n",nbElement(myStruct));
affichage(myStruct);
return 0;
}
int deb_AccesLettre(char * nom_tab, char * nom_lettre)
{
//faire recherchet_spec dès le début
int addr1, addrop2, a, a_typeOp2,a_abs_rel2,a_typage_Op2;
reinitialiser_nivPointeur();
init_get_lettre_acces();
int addr;
if( (addr=recherche(nom_tab))==-1)
{
return -1;
}
else
{
//On vérifie que la valeur entre les crochets est inférieure à la dimension de cette
//zone du tableau, exemple soit tab[2][3] on ne peut pas écrire tab[5]
if(get_adresse_tab(addr)!=addr+1)
{
return -2;
}
else
{
initialiser_nom_tableau(nom_tab);
initialiser_deb_lettre();
initialiser_presence_lettre();
int abs_rel, typage_var;
int addr_lettre=recherchet_spec(nom_lettre, &abs_rel, &typage_var);
//On copie la valeur contener par l'adresse dans la pile
if(abs_rel==0)
{
printf("COP @%d @@%d\n", (addr1=empilert(addr_lettre,0,abs_rel, typage_var)), addr_lettre);
}
else
{
printf("COP @%d @%d\n", (addr1=empilert(addr_lettre,0,abs_rel, typage_var)), addr_lettre);
}
init_tabAcces(recherche(nom_tab));
incrementerPC();
//On empile la valeur par laquelle on va multiplier la valeur précédente pour
//savoir à quelle case accéder
printf("AFC @%d %d\n", (addrop2=empilert(get_val_tabAcces(get_nivPtr()), 0, 1, 1)),get_val_tabAcces(get_nivPtr())) ;
a = depilert(&a_typeOp2,&a_abs_rel2,&a_typage_Op2);
printf("MUL @%d @%d @%d\n", addr1, addr1, addrop2);
incrementerPC();
incrementerPC();
//Suite à cette addition on a à addr1 (dans la pile) l'adresse de la case tableau accédée
//printf("ADD %d %d %d\n", addr1, recherche($1)+1, addr1);
incrementer_niveau_pointeur();
return 0;
}
}
}
//Recherche d'une valeur
int recherche (arbre a, int val)
{
if(a == NULL)
return 1;
else
if(a->val == val)
return 0;
else
if (val > a->val)
return recherche (a->droit,val);
else
return recherche (a->gauche,val);
}
void Liste::retirerJoueur(int position) { //À TESTER!!!!!!!!!!!!!!!
if(researchPrefix.length() > 0){
for(int i = 0 ; i < joueurs_.size(); i ++)
if(joueurs_[i] == searchJoueurs_[position])
position = i;
}
delete joueurs_[position];
joueurs_[position] = joueurs_.back();
joueurs_.pop_back();
if(researchPrefix.length()>0){
string tmp = researchPrefix;
recherche("");
recherche(tmp);
}
}
int dereferencement(char * nomptr)
{
int abs_rel, typage_var, addr;
addr=recherchet_spec(nomptr, &abs_rel, &typage_var);
if(abs_rel==0)
{
addr=addr+getNombredevariableglobale()+1;
}
if(get_Pointeur(addr)==-1)
{
return -1;
}
else
{
int i=0, addr;
char str[50];
strcpy(str, nomptr);
while(i<get_nivPtr())
{
addr=recherche(str);
init_adresse_pointee_bis(get_adresse_pointee(addr));
strcpy(str, getNomVar(get_adresse_pointee_bis()));
i++;
}
return 0;
}
}
FenPrincipale::FenPrincipale(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::FenPrincipale)
{
ui->setupUi(this);
connect(ui->actionA_Propos,SIGNAL(triggered()),this,SLOT(showAPropos()));
connect(ui->actionQuitter,SIGNAL(triggered()),this,SLOT(close()));
connect(ui->actionD_connexion,SIGNAL(triggered()),this, SLOT(deconnexion()));
connect(ui->actionConnexion,SIGNAL(triggered()),this, SLOT(connexion()));
connect(ui->actionNouvel_utilisateur,SIGNAL(triggered()),this,SLOT(nouvelUtilisateur()));
connect(ui->leRecherche,SIGNAL(textChanged(QString)),this,SLOT(recherche(QString)));
db = new QSqlDatabase(QSqlDatabase::addDatabase("QMYSQL"));
db->setHostName("localhost");
db->setPort(3306);
db->setDatabaseName("test");
db->setUserName("root");
db->setPassword("root");
if (!db->open())
{
QMessageBox::critical(0, QObject::tr("Database Error"), db->lastError().text());
}
}
void shell_aux()
{
char * input=(char *)malloc(TAILLE_INPUT*sizeof(char));//Allocation de la chaine de caractère pour gérer la saisi au clavier
int pid_child=0,taille=0;
Liste l=listenouv();//Allocation de la liste
l_handler=l;
input_handler=input;//Mise en place des valeurs des variables globales pour la fin du programme (pour leur désallocation)
int hide=0;//Variable qui vaut 1 si on lance le programme avec '&', 0 sinon
int i=0;//indice du caractère '&'
int status;
char ** arg=NULL;//Pointeur pour un tableau de chaine de caractère
Commande c;
while(1)
{
do
{
printf("> : ");
//Si on envoie un EOF ou on tape "exit" dans le terminal, cela provoque l'appel de la fonction qui arrête le programme
if((fgets(input,TAILLE_INPUT,stdin) == NULL) || estExit(input)) handler(0);//Provoque la désallocation des autres ressources puis la fin du programme
wait_hidden_child(l);//On regarde si un/des processus de la liste de ps caché est mort, et si c'est le cas, on affiche sa notification de décès
}
while(input[0]=='\n');//Demande de saisi tant que l'utilisateur appuie sur Entrée sans indiqué de commande
taille=taille_tableau(input);
input[taille-1]='\0';//On remplace le '\n' en fin de chaine de caractères par un '\0'
i=recherche(input,'&');//On recherche le caractère "&" pour indiqué si oui ou non on doit cacher l'execution du processus
if(i==-1) hide=0;
else
{
hide=1;
input[i]=' ';//Transforme le '&' par un espace
input=elimine_espace_fin(input,taille);
c.commande=malloc((taille+1)*sizeof(char));
strcpy(c.commande,input);//Copie l'intitulé de la commande (tapé au clavier)
}
arg=separation_argument(input);//Sépare les arguments de la commande pour les envoyer à exec plus tard
pid_child=fork();
if(!pid_child)
{
execvp(arg[0],arg);//Lance l'exec de la commande saisi au clavier de la part du fils créer par un fork pour ça
}
else
{
c.pid=pid_child;
if(!hide) waitpid(pid_child,&status,0);//Si on ne doit pas cacher l'execution du processus fils, on fait un waitpid simple sur le pid de ce processus
else
{
adjq(l,c);//Sinon on ajoute la structure commande à la liste des processus cachés
printf("[%d] %d\n",l->taille,pid_child);//Affiche une notification de lancement de processus caché (avec l'ordre d'insertion dans la liste, ainsi que le pid du processus)
}
}
freeArg(arg);//Libère le tableau d'argument
}
return;
}
void eliminer1()
{
int i, numero ;
char nomrecherche[MAX_NOM] ;
struct etudiant eleve ;
if(nbeleves == 0)
{
printf("Aucun élève dans la base. Élimination impossible.\n") ;
}
else
{
printf("Saisissez le nom à éliminer de la base : ") ;
scanf("%s", nomrecherche) ;
numero = recherche(nomrecherche) ;
if(numero == NON_TROUVE)
{
printf("%s n'a pas été trouvé. Élimination impossible.\n", nomrecherche) ;
}
else
{
for(i = numero ; i < nbeleves ; i++)
{
tabeleve[i] = tabeleve[i+1] ;
}
printf("Élève %s %s %d éliminé de la base.", eleve.nom, eleve.prenom, eleve.age) ;
nbeleves-- ;
a_sauvegarder = 1 ;
}
}
}
void complete_word(t_line **line, t_le *le)
{
char **path_and_word;
char *buffer;
t_arbre *arbre;
t_arbre *tmp;
int i;
i = -1;
(void)le;
arbre = NULL;
path_and_word = get_actual_word(*line);
buffer = ft_memalloc(sizeof(char) * 1024);
creer_arbre(&arbre, path_and_word[0]);
tmp = arbre;
arbre = recherche(&arbre, path_and_word[1]);
completion_tree(arbre, &buffer, 0);
while (buffer[++i])
add_to_line(le, line, buffer[i]);
if (is_folder(path_and_word[0], path_and_word[1], buffer))
add_to_line(le, line, '/');
free_arbre(&tmp);
free(buffer);
free(path_and_word[0]);
free(path_and_word[1]);
}
int recherche(int elt, sabr *a)
{
if (a==NULL)
{return 0;}
if ((a->e)==elt)
{
return 1;
}
else if ((a->e)>elt)
{
recherche(elt,a->g);
}
else if ((a->e)<elt)
{
recherche(elt,a->d);
}
}
int fin_AccesLettre(char * nom_tab, int * abs_rel, int * typage_var)
{
int retour, abs_rel_1, typage_var_1, addrOp2;
char nom_premiere_case[50];
strcpy(nom_premiere_case, nom_tab);
strcat(nom_premiere_case, "0");
int addr=recherchet_spec(nom_premiere_case, &abs_rel_1, &typage_var_1);
/*if(abs_rel_1==0)
{
addr=addr+getNombredevariableglobale()+1;
}
*/
printf("AFC @%d %d\n", (addrOp2=empilert(addr, 0, 1, 1)),addr) ;
incrementerPC();
/*if(abs_rel_1==0)
{
printf("ADD @%d @%d @%d\n", getAdressePile()+2, addrOp2, getAdressePile()+2);
}
else
{*/
printf("ADD @%d @%d @%d\n", getAdressePile()+2, addrOp2, getAdressePile()+2);
//}
incrementerPC();
if(get_nivPtr()==get_nivPtr_var(recherche(nom_tab)))
{
init_champ_pointeur((getAdressePile()+1), 0);
}
else if (get_nivPtr()<get_nivPtr_var(recherche(nom_tab)))
{
init_champ_pointeur((getAdressePile()+1), get_nivPtr());
}
init_adresse_pointee_bis(recherche(nom_tab)+1);
retour=getAdressePile()+2;
reinit_tabAcces();
reinit_adresse_retour();
initialiser_niv_tab(recherche(nom_tab));
reinit_presence_lettre();
*abs_rel=1;
*typage_var=get_nivPtr()+1;
printf("COPA @%d @%d\n", retour, retour);
incrementerPC();
return retour;
}
int deb_acces_case(char * nom_tab, int num_case)
{
reinitialiser_nivPointeur();
int addr, addr_retour;
if( (addr=recherche(nom_tab))==-1)
{
return -1;
}
else
{
//On vérifie que la valeur entre les crochets est inférieure à la dimension de cette
//zone du tableau, exemple soit tab[2][3] on ne peut pas écrire tab[5]
if(get_adresse_tab(addr)!=addr+1)
{
return -2;
}
else
{
if(num_case<dimension(nom_tab,get_nivPtr()))
{
initialiser_nom_tableau(nom_tab);
initialiser_deb_nombre();
int a =recherche(nom_tab);
init_tabAcces(recherche(nom_tab));
//print_tab_Acces();
init_adresse_retour(recherche(nom_tab)+1);
incrementer_adresse_retour(num_case*get_val_tabAcces(get_nivPtr()));
incrementer_niveau_pointeur();
init_avt_nb();
return 0;
//empiler(get_adresse_retour(), 0);
}
else
{
return -3;
}
}
}
}
int main(void) {
Arbre *a = creerArbre(5);
printf("5 est présent : %d\n", recherche(a, 5));
printf("5 est présent : %d\n", recherche2(a, 5));
printf("%d", nbCles(a));
return EXIT_SUCCESS;
}
int main(){
TMatr matrix;
initMat(&matrix, 12, 4, 1.2);
printf("\nDans le main:\nmatrice initialisée :\n%d, %d, %f, %p.\n",matrix.nbMaxRows, matrix.nbMaxCols, matrix.valDef, matrix.headRows);
TPRow p1; TPRow p1prev; TPCol p2; TPCol p2prev;
recherche(matrix, 3, 5, &p1, &p1prev, &p2, &p2prev);
printf("\np1:%p\np1prev:%p\np2:%p\np2prev:%p\n", p1,p1prev,p2,p2prev);
return 0;
}
main(){
char chaine[] = "Il était une fois\n";
printf("%s", chaine);
//Question 1
char *pchar = chaine;
printf("%p %p\n", &chaine, pchar);
char *pOccurenceC = recherche(pchar, 'o');
printf("%p\n", pOccurenceC);
printf("Il y a %d occurrence(s) de t dans la chaine\n", compte(pchar, 't'));
}
void action(int act) {
nodeType *t1, *t2;
switch (act) {
case 1: //-----------nouvelle case tab
t1 = depiler();
t2 = depiler();
A[nameToIndexGPL(t2->name)] = t1;
tailleForet++;
break;
case 2: //-----------genAtom
empiler(genAtomGPL(recherche(dicos->dicoNT, NONTERMINAL, val_scan()),
action_scan(), NONTERMINAL));
break;
case 3: //-----------genUnion
t1 = depiler();
t2 = depiler();
empiler(genUnion(t2, t1));
break;
case 4: //-----------genConc
t1 = depiler();
t2 = depiler();
empiler(genConc(t2, t1));
break;
case 5: //-----------genAtome
empiler(genAtomGPL(recherche(dicos->dicoT, TERMINAL, val_scan()),
action_scan(), TERMINAL));
break;
case 6: //-----------genStar
t1 = depiler();
empiler(genStar(t1));
break;
case 7: //-----------genUn
t1 = depiler();
empiler(genUn(t1));
break;
default:
printf("erreur action numéro %d", act);
break;
}
}
void recherche(int* t, int taille_tab){
int tail;
while(
}
int main(void){
int i, n = 1000;
int t[n];
for(i = 0; i < n; i++){
t[i] = i;
}
recherche(t, n);
return 1;
}
int debut_accesCase_id(char * nom_var)
{
int addr;
if ((addr=recherche(nom_var))==-1)
{
return -1;
}
else
{
if(get_Pointeur(addr)!=1)
{
return -2;
}
return 0;
}
}
int init_pointeur_AccesCase()
{
//get_nivPtr() renvoi la valeur obtenue après déréférencement du tableau avec AccesCase et get_niv_tab()
//Contient la diemnsion du tableau. On vérifie que l'on n'accède pas à une valeur contenue dans le tab
if(get_nivPtr()<get_niv_tab())
{
//On vérifie que les niveaux des pointeurs de chaque côté du = sont équivalents
int abs_rel, typage_var;
int addr= recherchet_spec(get_nom_pointeur(), &abs_rel, &typage_var);
if((get_niv_tab()-get_nivPtr())!=get_nivPtr_var(addr+getNombredevariableglobale()+1))
{
return -1;
}
else
{
//On copie l'adresse empilée suite à AccesCase dans le pointeur à droite de =
if(abs_rel==0)
{
printf("COP @@%d @%d\n", addr,getAdressePile()+1);
}
else
{
printf("COP @%d @%d\n", addr,getAdressePile()+1);
}
incrementerPC();
init_adresse_pointee(recherche(get_nom_pointeur()),get_adresse_pointee_bis());
viderPile();
modifierChampInitialiserVariable(get_nom_pointeur());
reinitialiser_nivPointeur();
reinitialiser_nivTab();
return 0;
}
}
else if(get_nivPtr()==get_niv_tab())
{
return -2;
}
else
{
return -3;
}
}
int recherche(Mras2an_struct * l, int X)
{
if (estVide(l))
{
return 0;
}
else
{
if (X == l->compt)
{
return 1;
}
else
{
return(recherche(l->suivant,X));
}
}
}
bool recherche(Arbre *a, int cle) {
Arbre_list *courant;
if (a == NULL)
return false;
if (estPresentDansLesCles(a->cles, cle))
return true;
courant = a->fils;
while (courant != NULL && !recherche(&(courant->a), cle)) {
courant = courant->suivant;
}
return (courant != NULL);
}
int fin_accesCase_id(char * nom_var, int dim, int * abs_rel, int * typage_var)
{
int addr=recherche(nom_var);
int retour;
if (get_champ_tab(get_adresse_pointee(addr))!=1 && get_Pointeur(get_adresse_pointee(addr))!=0)
{
return -1;
}
else
{
init_adresse_retour(get_adresse_pointee(addr));
incrementer_adresse_retour(dim);
retour=get_adresse_retour();
init_adresse_pointee_bis(get_adresse_retour());
recherchet_spec(getNomVar(get_adresse_retour()), abs_rel, typage_var);
reinit_adresse_retour();
return retour;
}
}
int deb_suite_acces(int dim )
{
//On vérifie que le déréférencement du tableau ne va pas trop loin et que la valeur entre les crochets
//est toujours correcte
int a,a_typeOp2,a_abs_rel2,a_typage_Op2, addrop2, addr1;
if(get_nivPtr()<get_nivPtr_var(recherche(get_nomTableau())))
{
if(dim<dimension(get_nomTableau(),get_nivPtr()))
{
if(get_presence_lettre()==1)
{
//print_tab_Acces();
init_adresse_retour(0);
incrementer_adresse_retour(dim*get_val_tabAcces(get_nivPtr()));
int abs_rel3, typage_var_3;
int addr_emp=recherchet_spec(getNomVar(get_adresse_retour()), &abs_rel3, &typage_var_3);
printf("AFC @%d %d\n", (addrop2=empilert(addr_emp, 0,1, 1)), addr_emp);
a = depilert(&a_typeOp2,&a_abs_rel2,&a_typage_Op2);
addr1=getAdressePile()+1;
printf("ADD @%d @%d @%d\n", addr1, addrop2, addr1);
incrementerPC();
}
else
{
incrementer_adresse_retour(dim*get_val_tabAcces(get_nivPtr()));
}
incrementer_niveau_pointeur();
return 0;
}
else
{
return -1;
}
}
else
{
return -2;
}
}
void modification()
{
int numero ;
char nomrecherche[MAX_NOM] ;
struct etudiant eleve ;
if(nbeleves == 0)
{
printf("Aucun élève dans la base. Modification impossible.\n") ;
}
else
{
printf("Saisissez le nom à recherche : ") ;
scanf("%s", nomrecherche) ;
numero = recherche(nomrecherche) ;
if(numero == NON_TROUVE)
{
printf("%s n'a pas été trouvé. Modification impossible.\n", nomrecherche) ;
}
else
{
eleve = tabeleve[numero] ;
printf("Nom actuel : %s --", eleve.nom);
printf("Nouveau nom : ") ;
scanf("%s", eleve.nom) ;
conv_maj(eleve.nom) ;
printf("Prénom actuel : %s --", eleve.prenom);
printf("Nouveau prénom : ") ;
scanf("%s", eleve.prenom) ;
conv_maj(eleve.prenom) ;
printf("Âge actuel : %d --", eleve.age);
printf("Nouvel âge : ") ;
scanf("%d", &eleve.age) ;
tabeleve[numero] = eleve ;
a_sauvegarder = 1 ;
}
}
}
void Liste::ajouterJoueur(Joueur* joueur) {
//Si c'est un nouveau joueur, lui attribuer un Id et l'ajouter
if(joueur->getId() == 0 ){
highestId+=1;
joueur->setId(highestId);
joueurs_.push_back(joueur);
}
else{
if(joueur->getId()>highestId)
highestId = joueur->getId();
bool found = false;
//Chercher si un jouer avec le même id existe déjà
for(int i = 0 ; i < joueurs_.size();i++){
//Si c'est le cas
if(!found&&joueurs_[i]->getId() == joueur->getId()){
//Ajouter le nouveau joueur s'il est plus récent
if(joueurs_[i]->getLastModified() < joueur->getLastModified()){
retirerJoueur(i);
joueurs_.push_back(joueur);
}
//Ne rien faire sinon
found = true;
}
}
//S'il n'existe pas déjà, l'ajouter à la liste
if(!found){
joueurs_.push_back(joueur);
}
}
recherche(researchPrefix);
}
void Player::initTechnologies() {
Technologie recherche("Recherche", "Permet de débloquer la bibliothèque et la recherche de technologies.", 0, 0, 0, 0);
Technologie exploration("Exploration", "Description", 0, 0, 0, 0);
Technologie vivres("Vivres", "Description", 0, 0, 0, 0);
Technologie petrole("Pétrole", "Description", 0, 0, 0, 0);
Technologie caserne("Caserne", "Description", 0, 0, 0, 0);
Technologie avantPoste("Avant poste", "Description", 0, 0, 0, 0);
Technologie recrutement("Recrutement", "Description", 0, 0, 0, 0);
Technologie metal("Métal", "Description", 0, 0, 0, 0);
Technologie soldat("Soldat", "Description", 0, 0, 0, 0);
Technologie demolisseur("Démolisseur", "Description", 0, 0, 0, 0);
Technologie usine("Usine", "Description", 0, 0, 0, 0);
Technologie aeroport("Aéroport", "Description", 0, 0, 0, 0);
Technologie port("Port", "Description", 0, 0, 0, 0);
Technologie jeep("Jeep", "Description", 0, 0, 0, 0);
Technologie charAssault("Char", "Description", 0, 0, 0, 0);
Technologie artillerie("Artillerie", "Description", 0, 0, 0, 0);
Technologie dca("DCA", "Description", 0, 0, 0, 0);
Technologie chasseur("Chasseur", "Description", 0, 0, 0, 0);
Technologie bombardier("Bombardier", "Description", 0, 0, 0, 0);
Technologie helicoptere("Hélicoptère", "Description", 0, 0, 0, 0);
Technologie cuirasse("Cuirasse", "Description", 0, 0, 0, 0);
Technologie torpilleur("Torpilleur", "Description", 0, 0, 0, 0);
Technologie corvette("Corvette", "Description", 0, 0, 0, 0);
Technologie vivresStock("Stockage de vivres", "Description", 0, 0, 0, 0);
Technologie petroleStock("Stockage de pétrole", "Description", 0, 0, 0, 0);
Technologie metalStock("Stockage de métaux", "Description", 0, 0, 0, 0);
Technologie transportTerrestre("Transport Terrestre", "Description", 0, 0, 0, 0);
Technologie transportMarin("Transport Marin", "Description", 0, 0, 0, 0);
Technologie transportAerien("Transport Aérien", "Description", 0, 0, 0, 0);
recherche.setTechSuivante(exploration);
recherche.setTechSuivante(vivres);
exploration.setTechSuivante(avantPoste);
exploration.setTechSuivante(recrutement);
vivres.setTechSuivante(vivresStock);
vivres.setTechSuivante(caserne);
vivres.setTechSuivante(petrole);
vivres.setTechSuivante(metal);
caserne.setTechSuivante(soldat);
caserne.setTechSuivante(demolisseur);
petrole.setTechSuivante(petroleStock);
petrole.setTechSuivante(usine);
metal.setTechSuivante(petroleStock);
metal.setTechSuivante(metalStock);
usine.setTechSuivante(aeroport);
usine.setTechSuivante(port);
usine.setTechSuivante(jeep);
usine.setTechSuivante(charAssault);
usine.setTechSuivante(artillerie);
usine.setTechSuivante(dca);
usine.setTechSuivante(transportTerrestre);
aeroport.setTechSuivante(chasseur);
aeroport.setTechSuivante(bombardier);
aeroport.setTechSuivante(helicoptere);
aeroport.setTechSuivante(transportAerien);
port.setTechSuivante(cuirasse);
port.setTechSuivante(torpilleur);
port.setTechSuivante(corvette);
port.setTechSuivante(transportMarin);
demolisseur.setTechPrecedente(caserne);
soldat.setTechPrecedente(caserne);
caserne.setTechPrecedente(vivres);
vivresStock.setTechPrecedente(vivres);
petrole.setTechPrecedente(vivres);
metal.setTechPrecedente(vivres);
metalStock.setTechPrecedente(metal);
petroleStock.setTechPrecedente(petrole);
usine.setTechPrecedente(petrole);
usine.setTechPrecedente(metal);
aeroport.setTechPrecedente(usine);
port.setTechPrecedente(usine);
jeep.setTechPrecedente(usine);
charAssault.setTechPrecedente(usine);
artillerie.setTechPrecedente(usine);
dca.setTechPrecedente(usine);
transportTerrestre.setTechPrecedente(usine);
chasseur.setTechPrecedente(aeroport);
bombardier.setTechPrecedente(aeroport);
helicoptere.setTechPrecedente(aeroport);
transportAerien.setTechPrecedente(aeroport);
cuirasse.setTechPrecedente(port);
torpilleur.setTechPrecedente(port);
corvette.setTechPrecedente(port);
transportMarin.setTechPrecedente(port);
vivres.setTechPrecedente(recherche);
exploration.setTechPrecedente(recherche);
avantPoste.setTechPrecedente(exploration);
recrutement.setTechPrecedente(exploration);
}
int main()
{
printf("%lld", recherche());
}
int main()
{
int choix;
char motCle[30];
/* initialisation de la connexion */
mysqlconnect = mysql_init(NULL);
mysql_options(mysqlconnect,MYSQL_READ_DEFAULT_GROUP,"toto");
if (mysqlconnect == NULL)
{
printf("Echec de l'initialisation...\n");
exit (-1);
}
/* se connecter au serveur MySQL à l’aide des informations de connexion fournies */
if (mysql_real_connect(mysqlconnect, HOSTNAME, USERNAME, PASSWD, DATABASE, PORT, SOCKET, FLAGS) == NULL)
{
printf("Echec de la connexion. Message retournée (%s)\n", mysql_error(mysqlconnect));
}
/* Message d'accueil de l'utilisateur - affichage du menu */
printf("Bonjour et bienvenue sur notre outil de recherche.\n");
printf("Que désirez-vous faire ?\n");
printf("\t1- Recherche par nom d'ouvrage\n");
printf("\t2- Recherche par nom d'auteur\n");
printf("\t3- Recherche par nom d'éditeur\n");
printf("\t4- Recherche par genre\n");
/* Récupération du choix de l'utilisateur */
scanf("%d", &choix);
/* Traitement de la demande */
switch(choix)
{
case 1:
printf("\n--------------- RECHERCHE PAR NOM D'OUVRAGE ---------------\n");
printf("Entrez le nom de l'ouvrage recherché :\n");
scanf(" %[^\n]",motCle); // scanf "spécial" pour prendre en compte les espaces dans les noms d'ouvrages
recherche(choix, motCle);
break;
case 2:
printf("\n--------------- RECHERCHE PAR NOM D'AUTEUR ---------------\n");
printf("Entrez le nom de l'auteur recherché :\n");
scanf("%s",motCle);
recherche(choix, motCle);
break;
case 3:
printf("\n--------------- RECHERCHE PAR NOM D'EDITEUR ---------------\n");
printf("Entrez le nom de l'éditeur recherché :\n");
scanf("%s",motCle);
recherche(choix, motCle);
break;
case 4:
printf("\n--------------- RECHERCHE PAR GENRE ---------------\n");
printf("Entrez le genre recherché :\n");
scanf("%s",motCle);
recherche(choix, motCle);
break;
default:
printf("La valeur reçue est inconnue du système.\n");
exit(-1);
break;
}
/*fermer la connexion au serveur */
mysql_close(mysqlconnect);
return 0;
}
int main()
{
arbre a,tmp1,tmp2,tmp3,tmp4,tmp5,tmp6,tmp7,tmp8,tmp9;
tmp1 = (arbre)malloc(sizeof(struct noeud));
tmp1->val = 1;
tmp1->gauche = NULL;
tmp1->droit = NULL;
tmp2 = (arbre)malloc(sizeof(struct noeud));
tmp2->val = 3;
tmp2->gauche = NULL;
tmp2->droit = NULL;
tmp3 = (arbre)malloc(sizeof(struct noeud));
tmp3->val = 7;
tmp3->gauche = NULL;
tmp3->droit = NULL;
tmp4 = (arbre)malloc(sizeof(struct noeud));
tmp4->val = 9;
tmp4->gauche = NULL;
tmp4->droit = NULL;
tmp5 = (arbre)malloc(sizeof(struct noeud));
tmp5->val = 2;
tmp5->gauche = tmp1;
tmp5->droit = tmp2;
tmp6 = (arbre)malloc(sizeof(struct noeud));
tmp6->val = 6;
tmp6->gauche = NULL;
tmp6->droit = tmp3;
tmp7 = (arbre)malloc(sizeof(struct noeud));
tmp7->val = 10;
tmp7->gauche = tmp4;
tmp7->droit = NULL;
tmp8 = (arbre)malloc(sizeof(struct noeud));
tmp8->val = 4;
tmp8->gauche = tmp5;
tmp8->droit = NULL;
tmp9 = (arbre)malloc(sizeof(struct noeud));
tmp9->val = 8;
tmp9->gauche = tmp6;
tmp9->droit = tmp7;
a = (arbre)malloc(sizeof(struct noeud));
a->val = 5;
a->gauche = tmp8;
a->droit = tmp9;
printf("La hauteur de 10 est %d\n",hauteur(a,10));
printf("Taille de l'arbre a = %d\n",taille(a));
printf("Affiche prefixe : ");
affiche_prefixe (a);
inserer (&a,1);
printf("\n");
printf("Affiche infixe : ");
affiche_infixe (a);
inserer (&a,11);
printf("\n");
printf("Affiche suffixe : ");
affiche_suffixe (a);
printf("\n");
printf ("Recherche de 2 = %d\n",recherche(a,2));
printf ("Recherche de 12 = %d\n",recherche(a,12));
printf ("Recherche de 2 = %d\n",recherche(a,5));
printf ("Recherche de 12 = %d\n",recherche(a,0));
detruit(&a);
printf("Affiche suffixe : ");
affiche_suffixe (a);
printf("\n");
return 0;
}
int fin_accesCase(char * nom_tab, int * abs_rel, int * typage_var)
{
int addr_retour;
if(get_nivPtr()==get_nivPtr_var(recherche(nom_tab)))
{
//printf("=================== valeur de adresse retour : %d \n", get_adresse_retour());
if(get_presence_lettre()==1)
{
init_champ_pointeur((getAdressePile()+1), 0);
init_adresse_pointee_bis(recherche(nom_tab)+1);
addr_retour=getAdressePile()+1;
*abs_rel=1;
*typage_var=1;
printf("COPA @%d @%d\n", addr_retour, addr_retour);
incrementerPC();
}
else
{
//printf("Valeur de l'adresse de retour %d\n", get_adresse_retour());
//printf("valeur du nom de l'adresse retour %s\n", getNomVar(get_adresse_retour()));
recherchet_spec(getNomVar(get_adresse_retour()), abs_rel, typage_var);
//printf("valeur de abs_rel %d\n", *abs_rel);
if(*abs_rel==0)
{
//printf("valeur de l'adresse retour dans le if %d\n", get_adresse_retour());
addr_retour= get_adresse_retour()-(getNombredevariableglobale()+1);
}
else
{
addr_retour= get_adresse_retour();
}
empilert(addr_retour,1, *abs_rel, *typage_var );
init_adresse_pointee_bis(get_adresse_retour());
}
}
else if(get_nivPtr()<get_nivPtr_var(recherche(nom_tab)))
{
if(get_presence_lettre()==1)
{
init_champ_pointeur((getAdressePile()+1), get_nivPtr());
init_adresse_pointee_bis(recherche(nom_tab)+1);
addr_retour=getAdressePile()+1;
*abs_rel=1;
*typage_var= get_nivPtr()+1;
//Peut-être initialiser toutes les cases du tab avec
//init_champ_pointeur(get_adresse_retour(), get_nivPtr());
}
else
{
int absm,typ;
int ad = recherchet_spec( getNomVar( get_adresse_retour()),&absm,&typ) ;
printf("AFC @%d %d\n",empilert(ad,0, *abs_rel, *typage_var) ,ad);
init_adresse_pointee_bis(get_adresse_retour());
//printf("Niveau ptr pile : %d\n", get_nivPtr());
init_champ_pointeur((getAdressePile()+1), get_nivPtr());
incrementerPC();
init_champ_pointeur(get_adresse_retour(), get_nivPtr());
addr_retour=getAdressePile()+1;
*abs_rel=1;
*typage_var=get_nivPtr()+1;
}
}
reinit_tabAcces();
reinit_adresse_retour();
initialiser_niv_tab(recherche(nom_tab));
reinit_presence_lettre();
return addr_retour;
}
