PDA

Afficher la version complète : impossible de compiler avec kdevelop 3.0



cybermarcel
13/01/2005, 14h10
bonjours,
je n'arrive pas a compiler avec kdevelop 3.0 pourtant je n'est rien toucher apres l'installation de suse !!!
mes projet on commencer sous mandrake 10.0 et je voudrais les continuer sous suse 9.1 et bientot suse 9.2

j'ai changer les version d'automake et d'autconf mais rien a changer !!!
lorsque je veus compiler j'ai une erreur de se type :

cd "/home/matthieu/documents/informatique/prog/C++/citations" && WANT_AUTOCONF_2_5="1" WANT_AUTOMAKE_1_6="1" gmake -k
**** Sortie avec l'état : 2 ***

arrivez vous a utiliser kdevelop 3.0 ?
d'ou l'erreur peut elle venir ?

d'avance merci

Sirius
15/01/2005, 00h48
Tu programmes en quel langage ? C++ ? Si c'est le cas il est de notoriété publique que Kdevelop à de base un problème de compilation avec le C++... En tout cas Google reste ton ami !! http://www.alionet.org/style_emoticons/<#EMO_DIR#>/laugh.gif

cybermarcel
18/01/2005, 18h22
oui je programme en c++
bon ben je vais chercher sur le net alors :-(
merci

molodoi
18/01/2005, 18h25
N'est-ce pas plus simple d'avoir une bonne répartition de fichiers, une bonne arborescence de répertoire et un bon gros Makefile?

cybermarcel
18/01/2005, 18h39
ouf !!! bah la je dois dire que tu m'en demande trop c'est pas de mon niveau !!!
j'ai tout fait avec kdevelop tout simplement donc apres je sais pas !!!
mais si ca te dit tu peux m'expliquer !!!
@++

molodoi
18/01/2005, 21h01
on regarde ça dès que possible http://www.alionet.org/style_emoticons/<#EMO_DIR#>/smile.gif

lucienmathieu
18/01/2005, 21h31
Je dois dire que je n'ai pas su faire fonctionner kdevelop, ni kdesigner d'ailleur.

Par contre le petit Makefile, la commande gcc, rien de tel ;-P

Ne pas oublier de dire que le Makefile est un fichier ;-P

molodoi
19/01/2005, 09h55
Chose promise, chose due... Tout savoir sur le Makefile http://www.alionet.org/style_emoticons/<#EMO_DIR#>/smile.gif

Introduction
Un Makefile est une collection d'instructions permettant de compiler un programme. Dès qu'on modifie un des fichiers source et qu'on tape la commande


make

le programme sera recompilé automatiquement, en évitant un maximum de refaire le travail déjà fait. En fait, seul le fichier modifié et ceux qui en dépendent seront recompilés.

Structure d'un Makefile

Typiquement, un Makefile contient trois types de lignes: La définition des variables. Il s'agit de définir les valeurs pour les différentes variables à utiliser. Exemple:


CFLAGS = -g -Wall
SRCS = main.c file1.c file2.c
CC = gcc

Pour expliquer, CC sera simplement une variable qui va contenir le compilateur (gcc, dans notre cas), SRCS est une variable qui va contenir tous les fichiers sources et CFLAGS permet de gérer les flags nécessaires à la compilation
Les règles. Ces lignes définissent sous quelles conditions un fichier donné a besoin d'être recompilé et comment il doit être compilé. Exemple


main.o: main.c
$(CC) $(CFLAGS) -c main.c

Important: la deuxième ligne ($(CC)...) doit nécessairement commencé par une tabulation. Makefile est très pointilleux sur les aspects syntaxiques.

La première ligne donne la règle. La deuxième, l'action à effectuer.

Cela signifie simplement que le fichier 'main.o' doit être recompiler (en suivant les indications de la 2ème ligne) si le fichier 'main.c' a été modifié.
Les commentaires. Comme tout script ou programme, un Makefile peut contenir des commentaires. Une ligne sera commentée si elle commence par le caractère:


#
Ordre de compilation
Qd un Makefile est exécuté, on appelle la commande make pour exécuter une cible ('target') particulière. La cible, c'est tout simplement un nom qui apparaît au début d'une règle. Dans l'exemple de règle plus haut, c'est 'main.o'.

Une cible peut être le nom du fichier à créer ou tout simplement un nom qcq utilisé comme point de départ.

Qd make est invoqué, il évalue d'abord toutes les variables, du haut vers le bas. Ensuite, qd il rencontre une règle "A" dont la cible correspond au target donné, il essaie d'évaluer cette règle.

Je passe sur les détails de gestion de dépendance. C'est donné au lecteur à titre d'exercice http://www.alionet.org/style_emoticons/<#EMO_DIR#>/ohmy.gif

Un seul fichier source
Considérons un exemple simple de Makefile qui sera utilisé dans le cadre d'un pogramme ne nécessitant qu'un seul fichier source


# Règle de haut niveau pour créer le programme.
all: main

# Compilation du fichier source.
main.o: main.c
gcc -g -Wall -c main.c

# "Linkage" du programme.
main: main.o
gcc -g main.o -o main

# Nettoyage.
clean:
/bin/rm -f main main.o

Qq indications: Toutes les règles ne seront pas invoquées lors de l'utilisation de make. Par exemple, la règle clean ne sera jamais utilisée lors de la compilation. Elle a simplement pour but de nettoyer le répertoire en enlevant les fichiers créés et ce, afin de gagner de l'espacer disque et de la visibilité dans le dossier. Pour invoquer la règle clean, il suffit de faire:


make clean
Une règle ne doit pas avoir nécessairement de dépendances. Si il n'y a pas de dépendances, les actions seront simplement exécutées, comme dans le cas de clean
Une règle ne doit pas nécessairement avoir de commandes. Par exemple, la règle all n'a pas de commandes propres. Elle sert seulement à appeler les autres règles. En fait, ça permet de s'assurer que si qqn invoque make sans nom de cible (comme c'est svt le cas), cette règle sera exécutée.
Utiliser le chemin complet pour 'rm' permet d'éviter les problèmes d'alias (si jamais l'utilisateur a défini des alias pour rm).
Plusieurs fichiers sources
La plupart du tps, tout projet de programmation comportera plus d'un fichier source. C'est vraiment dans ce genre de cas que l'utilisation du Makefile devient pertinente. Changer un fichier implique de recompiler le dit fichier et toutes ces dépendances. Le Makefile bien pensé fait ça tout seul.


# Règle de haut niveau pour créer le programme.
all: prog

# Le programme est fait de plusieurs fichiers sources.
prog: main.o file1.o file2.o
gcc main.o file1.o file2.o -o prog

# Règle pour main.o
main.o: main.c file1.h file2.h
gcc -g -Wall -c main.c

# Règle pour file1.o
file1.o: file1.c file1.h
gcc -g -Wall -c file1.c

# Règle pour file2.o
file2.o: file2.c file2.h
gcc -g -Wall -c file2.c

# Nettoyage.
clean:
/bin/rm -f prog main.o file1.o file2.o

Qq explications: Il y a une seule règle par fichier. C'est qq peu redondant. On verra par la suite comment on peut faire pour agréger tout cela.
On ajoute des dépendances pour les headers (fichiers *.h). Si un de ces fichiers changent, le fichier qui les inclut doit aussi être recompilé. Ce n'est certes pas trjs vrai mais il est préférable de compiler un peu trop afin d'être sûr qu'il n'y a pas de problèmes de synchro entre le pgm et les sources.
Compilateurs & Flags
Comme on peut le voir dans les segments de code supra, il y a pas mal de pattern redondant dans les règles de notre Makefile.

Ca risque de poser problème qd on voudra faire des changements car il faudra les répercuter partout (ou presque). Et qd le Makefile fait qq centaines de ligne, ça fout la merde.

Une solution relativement simple à ce problème est d'utiliser des variables pour stocker les valeurs des différents paramètres (ou flags) et même les noms des différentes commandes.

Ca nous donnerait un Makefile de la forme suivante:


# Utilisation de gcc pour compiler les sources.
CC = gcc
# Le linker est aussi gcc. Mais il pourrait être différent du compilateur, dans le cas d'un autre lgge.
LD = gcc
# Les flags du compilateurs.
CFLAGS = -g -Wall
# Les flags du linker. Pour le moment, nous n'en avons pas mais tout dépend des différents besoins.
LDFLAGS =
# rm. C'est bien d'en faire une variable car son emplacement peut varier d'une machine (ou distribution) à l'autre.
RM = /bin/rm -f
# La liste des fichiers objet à générer.
OBJS = main.o file1.o file2.o
# Le nom de l'exécutable.
PROG = prog

# Règle de haut niveau pour créer le programme
all: $(PROG)

# Règle pour linker le programme
$(PROG): $(OBJS)
$(LD) $(LDFLAGS) $(OBJS) -o $(PROG)

# Règle pour main.o
main.o: main.c file1.h file2.h
$(CC) $(CFLAGS) -c main.c

# Règle pour file1.o .
file1.o: file1.c file1.h
$(CC) $(CFLAGS) -c file1.c

# Règle pour file2.o.
file2.o: file2.c file2.h
$(CC) $(CFLAGS) -c file2.c

# Nettoyage.
clean:
$(RM) $(PROG) $(OBJS)

Qq explications: Typiquement le nom des variables est tjrs en majuscule. Pour accéder à la valeur d'une variable, il suffit de la mettre entre parenthèses précédées d'un $
On définit énormément de variables. Ca rend les modifications plus facile car il y a un seul endroit à changer.
On a encore un problème. On définit une règle pour chaque fichier source. C'est redondant. Ca ne pose pas trop de problèmes si il y a 3-4 fichiers sources. C'est un gros problème qd il y en a une bonne dizaine (ce qui est le cas dans les projets de moyenne envergure).
Une règle pour tout
La phase suivante est d'éliminer les règles redondantes. Dans la mesure où toutes ces règles correspondent au même type d'action, on peut essayer de les regrouper dans une seule règle.


# Je passe toutes les définitions de variables. Il suffit de les reprendre dans le segment de code précédent

# La règle de linkage, identique à ce qui a été proposé supra.
$(PROG): $(OBJS)
$(LD) $(LDFLAGS) $(OBJS) -o $(PROG)

# Une 'meta-rgèle' permettant de compiler tout fichier source "C".
%.o: %.c
$(CC) $(CFLAGS) -c $<

Qq explications: Le caractère '%' est un wildcard (sorry, je ne trouve pas de mot pertinent en français) permettant de matcher toute partie d'un nom de fichier. Le passage:

%.o: %.c
signifie que "un fichier avec un suffixe '.o' est dépendant d'un fichier avec le même nom mais ayant un suffixe '.c'". le "$<" fait référence à la liste de dépendance qui a été matchée par la règle (dans notre cas, le nom de fichier complet).Création automatique des dépendances
Un des problèmes avec l'utilisation de règles implicites, c'est qu'on risque de perdre la liste des dépendances. Liste qui est unique pour chaque fichier.

On peut s'attaquer à cela en ajoutant des règles supplémentaires contenant les dépendances mais aucune commandes. Ca peut se faire soit manuellement, soit automatiquement.

Je propose de jeter un coup d'oeil à makedepend et son utilisation dans un Makefile.


# La liste des fichiers source.
SRCS = main.c file1.c file2.c
.
.
# Le reste du Makefile est identique
# A la fin, on ajoute "simplement" les lignes suivantes:

# Règle pour construire la liste des dépendances et l'écrire ensuite dans un fichier appelé ".depend".
depend:
$(RM) .depend
makedepend -f- -- $(CFLAGS) -- $(SRCS) > .depend

# Il suffit ensuite d'inclure cette liste de dépendance.
include .depend

Qq explications: L'exécution de

make depend
va permettre d'éxécuter le programme makedepend. Celui-ci va scanner les fichiers sources donnés et créer la liste de dépendance pour chacun d'eux. LE résultat est redirigé vers un fichier (.depend)
On inclut ensuite les dépendances dans le Makefile via

include .depend
Ces dépendances seront vérifiées automatiquement à chaque compilation. Il faut donc faire le "make depend" une et une seule fois (sauf si on ajoute/supprime des fichiers sources).Note finale
Voilà, tu dois maintenant savoir faire un Makefile http://www.alionet.org/style_emoticons/<#EMO_DIR#>/smile.gif

A noter que ces qq points concernent seulement un programme C (ou C++).

Pour ceux qui sont intéressés, je peux toucher un mot pour un Makefile LaTeX et Java.

Je vais p'têt faire un petit tuto, un de ces 4, sur le sujet http://www.alionet.org/style_emoticons/<#EMO_DIR#>/tongue.gif

siko
19/01/2005, 12h30
Super ton explication j'ai vraiment compris comment fonctionne le makefile, c'est clair et précis, je vais le garder dans un coin. http://www.alionet.org/style_emoticons/<#EMO_DIR#>/clap_1.gif

molodoi
19/01/2005, 12h46
Merci http://www.alionet.org/style_emoticons/<#EMO_DIR#>/smile.gif

Qd j'aurai fini, j'en ferai un tuto et j'étendrai cela à l'utilisation pour LaTeX et les programmes Java http://www.alionet.org/style_emoticons/<#EMO_DIR#>/rolleyes.gif

siko
19/01/2005, 12h55
Connais tu aussi les commandes les plus courantes et de base pour optimiser le code avec gccj, et si oui peux tu faire un tuto à l'occase.
j'ai trouvé de la doc mais c'est toujours trop gros et en anglais.

molodoi
19/01/2005, 13h06
chaque chose en son temps http://www.alionet.org/style_emoticons/<#EMO_DIR#>/smile.gif

Je verrai ce que je peux faire http://www.alionet.org/style_emoticons/<#EMO_DIR#>/rolleyes.gif

siko
19/01/2005, 13h09
C'était juste une idée http://www.alionet.org/style_emoticons/<#EMO_DIR#>/rolleyes.gif

molodoi
19/01/2005, 13h54
le Makefile est fini.

Je le transfère dans les tutos un de ces 4 http://www.alionet.org/style_emoticons/<#EMO_DIR#>/smile.gif

Allez zou, on fête ça: http://www.alionet.org/style_emoticons/<#EMO_DIR#>/beer.gif

lucienmathieu
19/01/2005, 14h23
Beau topic, j'ai appris plein de trucs que je ne connaissais pas ;-P

okparanoid
19/01/2005, 19h16
Pour ceux que ca interesse je vous refile mon Makefile qui normalement est cense compiler, archiver, nettoyer, tout seul sans qu'on est besoin de specifier les fichiers sources, il prend automatiquement tous les fichier .cc .hh .c et .h du repertoire courant, et les compile en c++, avec la commande make, au prealable il faut avoir fait un petit make depend. Il peut aussi construire les tags pour xemacs, creer un fichier ps des sources et contient d'autres petits gadgets : faire make help pour avoir la liste des commandes... La prochaine etape serait de refaire appel a make depend automatiquement quand un nouveau fichier source a ete ajoute.

Vous avez juste a changer le nom de l'executable :


################################################## ########
# Makefile
################################################## ########

#Dans cette version necessite :
#make
#doc++
#makedepend
#etags

#Shell
SHELL= /bin/bash

#Nom de l'executable
EXECFIL := Exec

#Extension des fichiers d'entete c++
SUFFIXE_HEADER := hh
#Extension des fichiers d'implementation c++
SUFFIXE_FILE := cc

#Extension des fichiers d'entete c
SUFFIXE_HEADER2 := h
#Extension des fichiers d'implementation c
SUFFIXE_FILE2:= c

#Extension des fichiers d'inline
SUFFIXE_INLINE := inl
#Extension des objets compiles
SUFFIXE_OBJECT := o

#Script autres que les fichiers
SCRIPTS := Makefile

################################################## #######
#Nom du repertoire ou est cree la documentation doc++
DIR_DOC := Documentation/

#Nom du repertoire ou sont faites les sauvegardes
DIR_BACKUP := Archive_$(EXECFIL)/

#Nom du repertoire ou est cree le fichier PS
DIR_OUTPS := Printable/

################################################## #######
#Pour la creation d'archive
FORMAT_TAR :=j
EXTENSION_FORMAT_TAR := tar.bz2

#Recuperation de la date courante sous forme de string
#En triant par nom, on classe par date sous ce format
DATE := $(shell date +%Y-%m-%d_%H.%M.%S)

ARCHIVE_CODE := $(EXECFIL)_Source_$(DATE)

################################################## ######
#Compilateur pour le c++
CC = g++

#Commande de build pour le compilateur
OPT_BUILD := -o

# Options supplementaires de compilation pour le c++
# A modifier selon les besoins
CXXFLAGS := -Wall -o3

#Fichier ou sont stockés les tags
TAGS_FILE := TAGS

#la commande pour créer les tags
TAGS_COMMAND := etags

#les options des tags
TAGS_OPTION :=-o $(TAGS_FILE) --language=c++ --declarations --typedefs-and-c++ --globals -d --members --

################################################## ######
#Bibliotéques à inclure pour l'édition des liens
LIBS := -lm

################################################## ##############################
############
################################################## ##############################
############
# Attention aux modications dans la partie qui suit #
################################################## ##############################
############
################################################## ##############################
############

#Recuperation des noms de tous les fichiers d'entete
HEADERS := $(wildcard *.$(SUFFIXE_HEADER2)) $(wildcard *.$(SUFFIXE_HEADER))

#Recuperation des noms de tous les fichiers d'implementation
FILES := $(wildcard *.$(SUFFIXE_FILE2)) $(wildcard *.$(SUFFIXE_FILE))

#Recuperation des noms de tous les fichiers d'inline
INLINE_FILES := $(wildcard *.$(SUFFIXE_INLINE))

#Recuperation des noms de tous les fichiers objet à partir des fichiers sources
OBJECTS := $(patsubst %.$(SUFFIXE_FILE2),%.$(SUFFIXE_OBJECT),$(wildcard *.$(SUFFIXE_FILE2))) $(patsubst %.$(SUFFIXE_FILE),%.$(SUFFIXE_OBJECT),$(wildcard *.$(SUFFIXE_FILE)))

#les fichiers backup que l'on veut pouvoir supprimer
BACKUP_FILES := *~

#Definition des suffixes pour réecrir les regles implicites .cc.o
SUFFIXES = $(SUFFIXE_FILE)

all: tags $(EXECFIL)

#Construction de l'executable
$(EXECFIL): $(OBJECTS)
@echo $(FILES)
$(CC) $(CXXFLAGS) $(OPT_BUILD) $(EXECFIL) $(OBJECTS) $(LIBS)

#fabrique les dependances
.PHONY : depend
depend:
makedepend $(FILES) 2>/dev/null

#Efface les objets compiles et l'executable
.PHONY : clean
clean:
rm -f $(OBJECTS) $(EXECFIL)

#Efface tous les fichiers et repertoires sauf les sources et les archives
.PHONY : delete
delete:
make clean
rm -f $(BACKUP_FILES)
rm -rf $(DIR_DOC) $(DIR_OUTPS)
rm -f $(TAGS_FILE)

#Efface les fichiers backup ~
.PHONY : cleanback
cleanback:
rm $(BACKUP_FILES)

#Cree la documentation doc++ du programme
.PHONY : doc
doc :
-@doc++ -p -d $(DIR_DOC) -bApukf $(HEADERS)


#Cree une archive des fichiers source et du Makefile en évitant les warnings si le dossier existe déjÃ
.PHONY : archive
archive :
@make -s hidearchive

#Cree une archive des fichiers source et du Makefile
# '-' devant mkdir permet d'ignorer l'erreur si le dossier existe deja
.PHONY : hidearchive
hidearchive :
-@mkdir $(DIR_BACKUP) 2>/dev/null
-@mkdir $(ARCHIVE_CODE) 2>/dev/null
-@cp -rf $(HEADERS) $(FILES) $(SCRIPTS) $(INLINE_FILES) $(ARCHIVE_CODE)
-@tar -c$(FORMAT_TAR)f $(ARCHIVE_CODE).$(EXTENSION_FORMAT_TAR) $(ARCHIVE_CODE)
-@mv $(ARCHIVE_CODE).$(EXTENSION_FORMAT_TAR) $(DIR_BACKUP)
-@rm -rf $(ARCHIVE_CODE)
@echo Archive creee

#Cree un fichier ps contenant les sources en évitant les warnings si le dossier existe déjÃ
.PHONY : printable
printable :
@make -s hideprintable

#Cree un fichier ps contenant les sources
.PHONY : hideprintable
hideprintable :
-@mkdir $(DIR_OUTPS) 2>/dev/null
a2ps -q -f 7 -o $(DIR_OUTPS)Code_$(DATE).ps $(HEADERS) $(FILES) $(INLINE_FILES)


#Calcul le nombre de ligne des fichiers en ne comptabilisant qu'une seule ligne vide pour une bloc de lignes vides consécutives
.PHONY : nblignes
nblignes :
@echo -e $(foreach i,$(HEADERS) $(FILES) $(INLINE_FILES),$(shell (cat -s $(i)|wc -l)) $(i)'\n')|less
@echo Nombre total de lignes : $(shell cat -s $(HEADERS) $(FILES) $(INLINE_FILES)|wc -l)

#Calcul le nombre de sources
.PHONY : nbsources
nbsources :
@echo `ls -dl $(FILES) $(HEADERS) $(INLINE_FILES)|wc -l`

#Creation des tags
.PHONY : tags
tags :
@make -s hidetags

.PHONY : hidetags
hidetags :
@-rm $(TAGS_FILE) 2>/dev/null
@-$(TAGS_COMMAND) $(TAGS_OPTIONS) $(FILES) $(HEADERS) $(INLINE_FILES)
@-echo Tags crees

#Informations sur la facon de compiler
.PHONY : showopt
showopt :
@echo -e Compilateur:"\n\t"`$(CC) --version|grep $(CC)`"\n"Options:"\n\t" $(CXXFLAGS)

#Liste des sources
.PHONY : liste
liste :
@echo $(HEADERS) $(FILES)

#Recapitulatif des options
.PHONY : help
help :
@echo -e "Aide du Makefile"'\n\t'\
Recapitulatif des options :'\n\n'\
make all :"\n\t"Objectif par defaut fait les tags, compile et cree l executable'\n'\
make depend :"\n\t"Fabrique les dependances automatiquement'\n'\
make clean :'\n''\t'Efface les objets compiles et l executable'\n'\
make delete :'\n''\t'Efface tous les fichiers et repertoires'\n'\
'\t'crees sauf les sources et les archives'\n'\
make cleanback :'\n''\t'Efface les fichiers backup ~ des sources, des objets compiles et des scripts'\n'\
make doc :'\n''\t'Cree la documentation doc++ du programme dans'\n'\
'\t'un dossier $(DIR_DOC)'\n'\
make archive :'\n''\t'Cree une archive des fichiers source et du'\n'\
'\t'Makefile dans le dossier $(DIR_BACKUP)'\n'\
make printable :'\n''\t'Cree un fichier PS des fichiers de'\n'\
'\t'programmation dans le dossier $(DIR_OUTPS)'\n'\
make liste :'\n''\t'Affiche la liste des sources'\n'\
make nblignes :'\n''\t'Compte le nombre de lignes des fichiers en ne comptabilisant qu une'\n'\
'\t'seule ligne vide pour une bloc de lignes vides consecutives'\n'\
make nbsources :'\n''\t'Compte le nombre de fichiers '*.'$(SUFFIXE_HEADER), '*.'$(SUFFIXE_FILE), '*.'$(SUFFIXE_HEADER2) et '*.'$(SUFFIXE_FILE2)'\n'\
make tags :'\n''\t'Cree des tags stockes dans le fichier $(TAGS_FILE)'\n'\
make showopt :'\n''\t'Affiche la version du compilateur et les options de compilation'\n'\


# ******************** Makedepend performs here *******************
#
# Be sure to let a blank line after this one

# DO NOT DELETE

edit : petite maj du makefile sans grande incidence

siko
19/01/2005, 19h17
Il fait pas le café par hasard http://www.alionet.org/style_emoticons/<#EMO_DIR#>/tongue.gif http://www.alionet.org/style_emoticons/<#EMO_DIR#>/tongue.gif

Merci je vais le garder et le tester.

okparanoid
19/01/2005, 19h22
lol, ben en faite a l'origine je l'ai recupere quelque part sur le net, rearrange un poil a ma sauce, mais effectivement il y avait une commande make cafe que j'ai viree qui envoyait peter l'utilisateur mais qui effectuait un eject du lecteur cd-rom pour s'en servir en guise de porte gobelet, c'est deja ca http://www.alionet.org/style_emoticons/<#EMO_DIR#>/tongue.gif

Si il y a un specialiste peut etre pourra-t-il m'expliquer a quoi sert la methode hide* effectuee en deux temps comme pour les tags par exemple, elle y etait pour toutes les commandes mais vu que je comprenais pas je les ai pratiquement toutes virees en en faisant des methodes plus directes, mais je me doute bien qu'il devait y avoir une utiliite...

Si vous avez des conseils pour ameilorer ce Makefile n'hesitez pas je suis preneur http://www.alionet.org/style_emoticons/<#EMO_DIR#>/tongue.gif

lucienmathieu
19/01/2005, 19h55
Pas mal le Makefile, mais je vais plutot me tenir aux explications de Molodoi, car ca a l'air vraiment trop complique... ;-P

okparanoid
19/01/2005, 20h54
Originally posted by lucienmathieu@mercredi 19 janvier 2005 à 18:55
Pas mal le Makefile, mais je vais plutot me tenir aux explications de Molodoi, car ca a l'air vraiment trop complique... ;-P
<div align='right'><{POST_SNAPBACK}> (index.php?act=findpost&pid=16646)[/quote]

C'est la que tu te trompes, il a plus de fonctions et donc ca peut rendre le makefile un peu austere, quoique, mais en faite il est vraiment tres simple a utiliser, tu mets tes sources .cc et .hh et il se debrouille tout seul a compiler avec la commande make, tu fais un make depend a chaque fois que necessaire... make archive et ca t'archive toutes tes sources en mettant la date heure sec dans le nom de l'archive, c'est vraiment un outil super pratique, proche du Makefile ultime !

teste le tu verras, toute facon je t'assure qu'il est moins complique que tes moulinettes du shell pour recompiler le systeme !

lucienmathieu
19/01/2005, 21h44
Euh la moulinette!

cybermarcel
19/01/2005, 22h16
ca ma l'air bien tout ca
j'essairais quand je vais avoir le temps je vous tiens au courant !!

encore merci

yehundidai
20/01/2005, 10h46
Le tuto de molodoi est bien fait, car il a le mérite d'être simple et expliqué de manière progressive.

Des tutos de makefile sur le net, il n'en manque pas, bien que je suis loin d'être débutant en la matière je les trouve trop "indigeste", peu clair, ils ne vont pas à l'essentiel pour des utilisations courantes.

Même si les outils tel que KDevelop sont nécessaires pour des gros projets, rien de tel que de comprendre le fonctionnement d'un makefile au cas où KDevelop "t'insulte" concernant une erreur de dépendance ou autre.

jacqueline
20/01/2005, 11h34
En effet, très clair ce tuto! ( ce qui est assez rare dans le monde linuxien pour le souligner ). De la démystification !

Je n'ai pas eue le temps de retoucher à kdevelop ( trop de choses à faire ), sauf qu'il ne "plante" plus au lancement de projet en installant la totale, mais cette approche "manuelle" me paraît nécessaire avant de commencer avec "l'usine à gaz" !

Par contre elle me paraît utile pour les projets mixtes ( même petits : C++ et interfaces graphiques de Qt designer tout de même assez sympas ) mais il ne faut pas brûler les étapes.

J'ai mille choses persos à faire en dehors de linux, dommage !

julinux
31/01/2005, 08h28
Pour en revenir au sujet initial *** Sortie avec l'état : 2 ***

J'ai eu exactement la même erreur en reprenant mon projet d'une ancienne version de kdevelop vers la version 3.1.2

Premiere chose, j'ai verifié les paquetages automake et autoconf
Il faut absolument verifier que automake existe en version 1.6 et autoconf en version 2.5

pour cela, verifier en fesant :
rpm -qa | grep automake
rpm -qa | grep autoconf

Mais, ça ne marchait tjs pas.
Puis, j'ai configuré KDevelop pour qu'il soit plus précis dans ses messages d'erreurs :

Configuration / Configurer KDevelop /
dans "General", tu trouves à droite un "Sorties du compilateur" qui est fixé à "tres courtes", parametre le en "Toutes". Fais "Ok".

Relance la compilation et là tu auras + d'explication à l'erreur

De mon coté, il manquait une dépendance sur SDL_image

/usr/bin/ld: cannot find -lSDL_image
collect2: ld returned 1 exit status
gmake: *** [test] Erreur 1
gmake: La cible « all » n'a pas pu être refabriquée à cause d'erreurs.
*** Sortie avec l'état : 2 ***

J'espere que ça pourra aider http://www.alionet.org/style_emoticons/<#EMO_DIR#>/wink.gif

cybermarcel
02/02/2005, 23h28
merci je suis peut etre sur une piste
voila se que ca donne quand kdevelop cause plus :

cd "/home/matthieu/documents/informatique/prog/C++/citations" && WANT_AUTOCONF_2_5="1" WANT_AUTOMAKE_1_6="1" gmake -k
*cd . && aclocal-1.4
*/bin/sh: line 1: aclocal-1.4: command not found
*gmake: *** [aclocal.m4] Erreur 127
*gmake: Échec de refabrication du makefile « Makefile ».
*gmake: La cible « all » n'a pas pu être refabriquée à cause d'erreurs.
**** Sortie avec l'état : 2 ***

en faite y'a un probleme avec aclocal-1.4 mais apres une recherche moi j'ai la version 1.6

qu'est ce que je dois faire ?
d'avance merci

molodoi
03/02/2005, 00h04
on dirait qu'il essaie de construire un Makefile ou un script pour la compilation.

Il doit sans doute y avoir des variables à changer, pour la construction de ce script/Makefile