boucle if

boucle if - Shell/Batch - Programmation

Marsh Posté le 20-02-2006 à 21:12:00    

Bonjour,
je m'inicie au script shell, et je voudrait savoir si je peut imbriquer plusieur if ensemble, car j'ai une erreur a cette endroit!
voila en gro ma structure :
if
   if
   fi
 
   if
   fi
fi
merci

Message cité 1 fois
Reply

Marsh Posté le 20-02-2006 à 21:12:00   

Reply

Marsh Posté le 20-02-2006 à 21:26:24    

Apparemment c'est de l'Unix, mais c'est pour quel shell ?  
De toute manières, les if imbriqués sont poossibles.

Reply

Marsh Posté le 20-02-2006 à 21:27:03    

tu peux sans probleme imbriquer plusieurs if en meme temps ca marche, ton erreur doit se situer dans la syntaxe , montre ton script?

Reply

Marsh Posté le 20-02-2006 à 21:32:55    

/bin/sh
 
if [ $# -ne 1 ]; then
 { echo "Syntaxe : $0 nom de la classe (première lettre en MAJUSCULE) "
   echo ""
 } >&2
 exit 1
fi
 
extension=0
 
while [[extension != cpp]||[extension != java]]
do
{
 echo "Entrez le langage voulu (cpp ou java)."
 read
 extension=$EXTENSION
}done
 
nomClasse=$1
nomClasseMaj=$(echo $nomClasse | tr a-z A-Z)
nomClasseMin=$(echo $nomClasse | tr A-Z a-z)
nomClasseTesteur=${nomClasse}Testeur
repertoireFichierSource=./src/
 
if [extension == cpp]
 nomFichierEntete=${nomClasse}.h
 nomFichierImplementation=${nomClasse}.cpp
 nomFichierTesteur=${nomClasse}Testeur.cpp
 fichierEntete=${repertoireFichierSource}${nomFichierEntete}
 fichierImplementation=${repertoireFichierSource}${nomFichierImplementation}
 fichierTesteur=${repertoireFichierSource}${nomFichierTesteur}
 fichierMakefile=${repertoireFichierSource}Makefile
 
 #Saisie des informations de l'ent�e
 echo "Entrez une description sommaire de la classe"
 read
 description=$REPLY
 
 auteur=$LOGNAME
 dateCreation=$(date +%d" "%b" "%Y" "%X)
 
 reponse="O"
 
 if [ -e $fichierEntete ] ; then
  echo "Le fichier d'entete $fichierEntete existe. Voulez-vous l'écraser ? (O/N)"
  read reponse;
 fi
 
 if  [ $reponse = "O" ] || [ $reponse = "o" ]; then
 
  echo "Génération de $fichierEntete"
  touch $fichierEntete
 
  echo "//------------------------------------------------------------------------------
/** @file         $nomFichierEntete
 *  @brief        $description
 *  @author       $auteur
 *  @since        $dateCreation
 *  @version      0.1
 *  @date         $dateCreation
 *  @note         Voir la description detaillée�explicité dans le fichier
 *                $nomFichierImplementation
 */
//------------------------------------------------------------------------------
#ifndef _${nomClasseMaj}_H
#define _${nomClasseMaj}_H
 
// En-tetes standards necessaires dans ce fichier en-tete seulement ------------
 
// En-tetes propres �l'application necessaires dans ce fichier en-tete --------
 
class $nomClasse
{
 private :
 
 public :
  // CONSTRUCTEURs et DESTRUCTEURs
  ${nomClasse}() ;
  ~${nomClasse}() ;
 
 protected :
} ;
 
//------------------------------------------------------------------------------
#endif  //_${nomClasseMaj}_H
//------------------------------------------------------------------------------
 " > $fichierEntete;
 fi
 
 if [ -e $fichierImplementation ] ; then
  echo "Le fichier d'implementation $fichierImplementation existe. Voulez-vous l'ecraser ? (O/N)"
  read reponse;
 fi
 
 if  [ $reponse = "O" ] || [ $reponse = "o" ]; then
 
 echo "Generation de $fichierImplementation"
 touch $fichierImplementation
 
 echo "//------------------------------------------------------------------------------
/** @file         $nomFichierImplementation
 *  @brief        $description
 *  @author       $auteur
 *  @author       Licence pro logiciel libre et proprietaire
 *  @since        $dateCreation
 *  @version      0.1
 *  @date         $dateCreation
 *  Description detaille� du fichier $nomFichierImplementation
 */
//------------------------------------------------------------------------------
 
// En-t�e propre �l'application ----------------------------------------------
 
// En-t�e propre �l'objet ----------------------------------------------------
#include \"${nomFichierEntete}\"
 
 
/** CONSTRUCTEURs
 *
 */
${nomClasse}::${nomClasse}()
{
 
}
 
/** DESTRUCTEURs
 *
 */
${nomClasse}::~${nomClasse}()
{
 
}
 
//---------------------------------------------------------------------------
// METHODEs PUBLIQUEs
//---------------------------------------------------------------------------
 
 
//---------------------------------------------------------------------------
// METHODEs PRIVEEs
//---------------------------------------------------------------------------
 
 
//---------------------------------------------------------------------------
// METHODEs PROTEGEEs
//---------------------------------------------------------------------------
 
" > $fichierImplementation;
 fi
 
 
 if [ -e $fichierTesteur ] ; then
  echo "Le fichier de test $fichierTesteur existe. Voulez-vous l'ecraser ? (O/N)"
  read reponse;
 fi
 
 if  [ $reponse = "O" ] || [ $reponse = "o" ]; then
 
  echo "Generation de $fichierTesteur"
  touch $fichierTesteur
 
 
  echo "//*********************************************************************
// Fichier : $nomFichierTesteur
// Classe : $nomClasse
//*********************************************************************
// $dateCreation  : $auteur, Version initiale
//*********************************************************************
 
#include <iostream>
#include \"${nomFichierEntete}\"
 
using namespace std;
 
int main (int argc, char *argv[])
{
    // Construction de la classe �tester
    cout << \"Construction de la classe $nomClasse\" << endl;
    $nomClasse *${nomClasseMin} = new ${nomClasse}();
 
    return 0;
}
" > $fichierTesteur;
 fi
 
 if [ -e $fichierMakefile ] ; then
  echo "********************** ATTENTION ! **********************"
  echo "Le fichier Makefile existe. Voulez-vous l'ecraser ? (O/N)"
  read reponse;
 fi
 
 if  [ $reponse = "O" ] || [ $reponse = "o" ]; then
 
  echo "Génération de $fichierMakefile"
  touch $fichierMakefile
 
  echo "
#############################################################################
# Makefile pour g��er : nom du programme
# Projet : nom du projet
# Date : $dateCreation
# Commande : make
#############################################################################
 
# Options de compilation
CFLAGS = -Wall -pedantic -g
 
# Options de linkage si n�essaire (ex -lm)
LIBS =
 
# Options de compilation sp�ifiques �QT
#QTFLAGS = -I\${QTDIR}include
 
# Options de linkage sp�ifique �QT
#QTLIBS = -L\${QTDIR}lib -lqt-mt
 
# Commande de compilation
CC = g++ \${CFLAGS}
# Commande de linkage
CCLINK = \${CC} \${LIBS}
 
# on place ici les objects �linker dans l'application finale
OBJECTS = ${nomClasse}.o
 
# on place ici les objets testeurs
TESTOBJECTS = ${nomClasseTesteur}.o
 
# on place ici les objets QT
#MOCOBJECTS =
 
# on rajoute ici les ex�utables �g��er
all : \${OBJECTS} \${TESTOBJECTS} \${MOCOBJECTS} $nomClasseTesteur
 
clean :
 @rm -f *~ *.moc.cpp *.o
 
# r�le mod�is� pour la production des .o
%.o : %.cpp
 \${CC} -c \$<
 
# r�le mod�is� pour la production des .moc.cpp sp�ifique �QT
%.moc.cpp : %.h
 \${QTDIR}/bin/moc -o \$*.moc.cpp \$*.h
 
# r�le pour la production des ex�utables
$nomClasseTesteur : \${OBJECTS} ${nomClasseTesteur}.o
 \${CCLINK} \${OBJECTS} \$@.o -o \$@
 
" > $fichierMakefile;
 fi
fi #L'ERREUR EST ICI
if [extension == java]
 nomFichierImplementation=${nomClasse}.java
 fichierImplementation=${repertoireFichierSource}${nomFichierImplementation}
 fichierMakefile=${repertoireFichierSource}Makefile
 
 #Saisie des informations de l'ent�e
 echo "Entrez une description sommaire de la classe"
 read
 description=$REPLY
 direction=$HOME
 
 auteur=$LOGNAME
 dateCreation=$(date +%d" "%b" "%Y" "%X)
 
 reponse="O"
 
 if [ -e $fichierImplementation ] ; then
  echo "Le fichier d'entete $fichierImplementation existe. Voulez-vous l'écraser ? (O/N)"
  read reponse;
 fi
 
 if  [ $reponse = "O" ] || [ $reponse = "o" ]; then
 
 echo "Génération de $fichierImplementation"
 touch $fichierImplementation
 
 echo "//------------------------------------------------------------------------------
/** @file         $nomFichierImplementation
 *  @brief        $description
 *  @author       $auteur
 *  @since        $dateCreation
 *  @version      0.1
 *  @date         $dateCreation
 *  @note         Voir la description detaillée�explicité dans le fichier
 *                $nomFichierImplementation
 */
//------------------------------------------------------------------------------
//mettre le nom du pakage dans lequel il apartient!
package
 
 
// En-tetes standards necessaires dans ce fichier en-tete seulement ------------
 
// En-tetes propres �l'application necessaires dans ce fichier en-tete --------
 
public class $fichierImplementation
{
//---------------------------------------------------------------------------
// Attributs
//---------------------------------------------------------------------------
 
 
//---------------------------------------------------------------------------
// METHODEs PUBLIQUEs
//---------------------------------------------------------------------------
 public $fichierImplementation()
 {
 
 }
 
//---------------------------------------------------------------------------
// METHODEs PRIVEEs
//---------------------------------------------------------------------------
 
 
//---------------------------------------------------------------------------
// METHODEs PROTEGEEs
//---------------------------------------------------------------------------"
 
 
if [ -e $fichierMakefile ] ; then
 echo "********************** ATTENTION ! **********************"
 echo "Le fichier Makefile existe. Voulez-vous l'ecraser ? (O/N)"
 read reponse;
fi
 
if  [ $reponse = "O" ] || [ $reponse = "o" ]; then
 
echo "G��ation de $fichierMakefile"
touch $fichierMakefile
 
echo "
#############################################################################
# Makefile pour générer : $nomFichierImplementation
# Projet : $fichierImplementation
# Date : $dateCreation
# Commande : make
#############################################################################
JAVAC =$direction/jdk1.5.0_06/bin/javac
JAVA =$direction/jdk1.5.0_06/bin/java
 
all:
 $(JAVAC) $nomFichierImplementation
run:
 $(JAVA) $fichierImplementation
clean:
 find. -name "*.class" -exec rm {} \;"
 
fi

Reply

Marsh Posté le 20-02-2006 à 21:40:56    

deja la ligne

Code :
  1. if [extension == cpp]

ne marchera clairement pas sans le then.
Sinon pour chaque if respecte bien les espaces et nen met pas apres le 2eme crochet entre le ] et ;then
exemple :

Code :
  1. if [ "$var" = "true" ];then


ah oui tu peux mettre l'/les erreur(s) affichée(s) stp ?


Message édité par h4rold le 20-02-2006 à 21:41:33
Reply

Marsh Posté le 20-02-2006 à 21:48:21    

j'ai changer de faconde faire, je passe maintenant par des fonction, qui appelle celle ci, donc les if posant probleme ne sont plus la, mais j'ai une nouvelle erreur a la fin de mon script, faut il terminer les fonction par une chose spécial?

Reply

Marsh Posté le 20-02-2006 à 21:53:51    

en fait sa doit etre dans la fin du code , quand je genere le makefile que sa deconne

Reply

Marsh Posté le 20-02-2006 à 21:54:56    

sans l'erreur affiché et les lignes du script qui plantent on peux pas trop taider.

Reply

Marsh Posté le 20-02-2006 à 21:58:41    

revoila le nouveau script !!
 
 

Code :
  1. #! /bin/sh
  3. if [ $# -ne 1 ]; then
  4. { echo "Syntaxe : $0 nom de la classe (première lettre en MAJUSCULE) "
  5.    echo ""
  6. } >&2
  7. exit 1
  8. fi
  10. extension=0
  12. while [[extension != cpp]||[extension != java]]
  13. do
  14. {
  15. echo "Entrez le langage voulu (cpp ou java)."
  16. read
  17. extension=$EXTENSION
  18. }done
  20. nomClasse=$1
  21. nomClasseMaj=$(echo $nomClasse | tr a-z A-Z)
  22. nomClasseMin=$(echo $nomClasse | tr A-Z a-z)
  23. nomClasseTesteur=${nomClasse}Testeur
  24. repertoireFichierSource=./src/
  26. function cpp()
  27. {
  28. nomFichierEntete=${nomClasse}.h
  29. nomFichierImplementation=${nomClasse}.cpp
  30. nomFichierTesteur=${nomClasse}Testeur.cpp
  31. fichierEntete=${repertoireFichierSource}${nomFichierEntete}
  32. fichierImplementation=${repertoireFichierSource}${nomFichierImplementation}
  33. fichierTesteur=${repertoireFichierSource}${nomFichierTesteur}
  34. fichierMakefile=${repertoireFichierSource}Makefile
  36. #Saisie des informations de l'ent�e
  37. echo "Entrez une description sommaire de la classe"
  38. read
  39. description=$REPLY
  41. auteur=$LOGNAME
  42. dateCreation=$(date +%d" "%b" "%Y" "%X)
  44. reponse="O"
  46. if [ -e $fichierEntete ] ; then
  47.  echo "Le fichier d'entete $fichierEntete existe. Voulez-vous l'écraser ? (O/N)"
  48.  read reponse;
  49. fi
  51. if  [ $reponse = "O" ] || [ $reponse = "o" ]; then
  53.  echo "Génération de $fichierEntete"
  54.  touch $fichierEntete
  56.  echo "//------------------------------------------------------------------------------
  57. /** @file         $nomFichierEntete
  58. *  @brief        $description
  59. *  @author       $auteur
  60. *  @since        $dateCreation
  61. *  @version      0.1
  62. *  @date         $dateCreation
  63. *  @note         Voir la description detaillée�explicité dans le fichier
  64. *                $nomFichierImplementation
  65. */
  66. //------------------------------------------------------------------------------
  67. #ifndef _${nomClasseMaj}_H
  68. #define _${nomClasseMaj}_H
  70. // En-tetes standards necessaires dans ce fichier en-tete seulement ------------
  72. // En-tetes propres �l'application necessaires dans ce fichier en-tete --------
  74. class $nomClasse
  75. {
  76. private :
  78. public :
  79.  // CONSTRUCTEURs et DESTRUCTEURs
  80.  ${nomClasse}() ;
  81.  ~${nomClasse}() ;
  83. protected :
  84. } ;
  86. //------------------------------------------------------------------------------
  87. #endif  //_${nomClasseMaj}_H
  88. //------------------------------------------------------------------------------
  89. " > $fichierEntete;
  90. fi
  92. if [ -e $fichierImplementation ] ; then
  93.  echo "Le fichier d'implementation $fichierImplementation existe. Voulez-vous l'ecraser ? (O/N)"
  94.  read reponse;
  95. fi
  97. if  [ $reponse = "O" ] || [ $reponse = "o" ]; then
  99. echo "Generation de $fichierImplementation"
  100. touch $fichierImplementation
  102. echo "//------------------------------------------------------------------------------
  103. /** @file         $nomFichierImplementation
  104. *  @brief        $description
  105. *  @author       $auteur
  106. *  @author       Licence pro logiciel libre et proprietaire
  107. *  @since        $dateCreation
  108. *  @version      0.1
  109. *  @date         $dateCreation
  110. *  Description detaille� du fichier $nomFichierImplementation
  111. */
  112. //------------------------------------------------------------------------------
  114. // En-t�e propre �l'application ----------------------------------------------
  116. // En-t�e propre �l'objet ----------------------------------------------------
  117. #include \"${nomFichierEntete}\"
  120. /** CONSTRUCTEURs
  121. *
  122. */
  123. ${nomClasse}::${nomClasse}()
  124. {
  126. }
  128. /** DESTRUCTEURs
  129. *
  130. */
  131. ${nomClasse}::~${nomClasse}()
  132. {
  134. }
  136. //---------------------------------------------------------------------------
  137. // METHODEs PUBLIQUEs
  138. //---------------------------------------------------------------------------
  141. //---------------------------------------------------------------------------
  142. // METHODEs PRIVEEs
  143. //---------------------------------------------------------------------------
  146. //---------------------------------------------------------------------------
  147. // METHODEs PROTEGEEs
  148. //---------------------------------------------------------------------------
  150. " > $fichierImplementation;
  151. fi
  154. if [ -e $fichierTesteur ] ; then
  155.  echo "Le fichier de test $fichierTesteur existe. Voulez-vous l'ecraser ? (O/N)"
  156.  read reponse;
  157. fi
  159. if  [ $reponse = "O" ] || [ $reponse = "o" ]; then
  161.  echo "Generation de $fichierTesteur"
  162.  touch $fichierTesteur
  165.  echo "//*********************************************************************
  166. // Fichier : $nomFichierTesteur
  167. // Classe : $nomClasse
  168. //*********************************************************************
  169. // $dateCreation  : $auteur, Version initiale
  170. //*********************************************************************
  172. #include <iostream>
  173. #include \"${nomFichierEntete}\"
  175. using namespace std;
  177. int main (int argc, char *argv[])
  178. {
  179.     // Construction de la classe �tester
  180.     cout << \"Construction de la classe $nomClasse\" << endl;
  181.     $nomClasse *${nomClasseMin} = new ${nomClasse}();
  183.     return 0;
  184. }
  185. " > $fichierTesteur;
  186. fi
  188. if [ -e $fichierMakefile ] ; then
  189.  echo "********************** ATTENTION ! **********************"
  190.  echo "Le fichier Makefile existe. Voulez-vous l'ecraser ? (O/N)"
  191.  read reponse;
  192. fi
  194. if  [ $reponse = "O" ] || [ $reponse = "o" ]; then
  196.  echo "Génération de $fichierMakefile"
  197.  touch $fichierMakefile
  199.  echo "
  200. #############################################################################
  201. # Makefile pour g��er : nom du programme
  202. # Projet : nom du projet
  203. # Date : $dateCreation
  204. # Commande : make
  205. #############################################################################
  207. # Options de compilation
  208. CFLAGS = -Wall -pedantic -g
  210. # Options de linkage si n�essaire (ex -lm)
  211. LIBS =
  213. # Options de compilation sp�ifiques �QT
  214. #QTFLAGS = -I\${QTDIR}include
  216. # Options de linkage sp�ifique �QT
  217. #QTLIBS = -L\${QTDIR}lib -lqt-mt
  219. # Commande de compilation
  220. CC = g++ \${CFLAGS}
  221. # Commande de linkage
  222. CCLINK = \${CC} \${LIBS}
  224. # on place ici les objects �linker dans l'application finale
  225. OBJECTS = ${nomClasse}.o
  227. # on place ici les objets testeurs
  228. TESTOBJECTS = ${nomClasseTesteur}.o
  230. # on place ici les objets QT
  231. #MOCOBJECTS =
  233. # on rajoute ici les ex�utables �g��er
  234. all : \${OBJECTS} \${TESTOBJECTS} \${MOCOBJECTS} $nomClasseTesteur
  236. clean :
  237. @rm -f *~ *.moc.cpp *.o
  239. # r�le mod�is� pour la production des .o
  240. %.o : %.cpp
  241. \${CC} -c \$<
  243. # r�le mod�is� pour la production des .moc.cpp sp�ifique �QT
  244. %.moc.cpp : %.h
  245. \${QTDIR}/bin/moc -o \$*.moc.cpp \$*.h
  247. # r�le pour la production des ex�utables
  248. $nomClasseTesteur : \${OBJECTS} ${nomClasseTesteur}.o
  249. \${CCLINK} \${OBJECTS} \$@.o -o \$@
  251. " > $fichierMakefile;
  252. fi
  253. }
  254. function java()
  255. {
  256. nomFichierImplementation=${nomClasse}.java
  257. fichierImplementation=${repertoireFichierSource}${nomFichierImplementation}
  258. fichierMakefile=${repertoireFichierSource}Makefile
  260. #Saisie des informations de l'ent�e
  261. echo "Entrez une description sommaire de la classe"
  262. read
  263. description=$REPLY
  264. direction=$HOME
  266. auteur=$LOGNAME
  267. dateCreation=$(date +%d" "%b" "%Y" "%X)
  269. reponse="O"
  271. if [ -e $fichierImplementation ] ; then
  272.  echo "Le fichier d'entete $fichierImplementation existe. Voulez-vous l'écraser ? (O/N)"
  273.  read reponse;
  274. fi
  276. if  [ $reponse = "O" ] || [ $reponse = "o" ]; then
  278. echo "Génération de $fichierImplementation"
  279. touch $fichierImplementation
  281. echo "//------------------------------------------------------------------------------
  282. /** @file         $nomFichierImplementation
  283. *  @brief        $description
  284. *  @author       $auteur
  285. *  @since        $dateCreation
  286. *  @version      0.1
  287. *  @date         $dateCreation
  288. *  @note         Voir la description detaillée�explicité dans le fichier
  289. *                $nomFichierImplementation
  290. */
  291. //------------------------------------------------------------------------------
  292. //mettre le nom du pakage dans lequel il apartient!
  293. package
  296. // En-tetes standards necessaires dans ce fichier en-tete seulement ------------
  298. // En-tetes propres �l'application necessaires dans ce fichier en-tete --------
  300. public class $fichierImplementation
  301. {
  302. //---------------------------------------------------------------------------
  303. // Attributs
  304. //---------------------------------------------------------------------------
  307. //---------------------------------------------------------------------------
  308. // METHODEs PUBLIQUEs
  309. //---------------------------------------------------------------------------
  310. public $fichierImplementation()
  311. {
  313. }
  315. //---------------------------------------------------------------------------
  316. // METHODEs PRIVEEs
  317. //---------------------------------------------------------------------------
  320. //---------------------------------------------------------------------------
  321. // METHODEs PROTEGEEs
  322. //---------------------------------------------------------------------------"
  325. if [ -e $fichierMakefile ] ; then
  326. echo "********************** ATTENTION ! **********************"
  327. echo "Le fichier Makefile existe. Voulez-vous l'ecraser ? (O/N)"
  328. read reponse;
  329. fi
  331. if  [ $reponse = "O" ] || [ $reponse = "o" ]; then
  333. echo "Génération de $fichierMakefile"
  334. touch $fichierMakefile
  336. echo "
  337. #############################################################################
  338. # Makefile pour générer : $nomFichierImplementation
  339. # Projet : $fichierImplementation
  340. # Date : $dateCreation
  341. # Commande : make
  342. #############################################################################
  343. JAVAC =$direction/jdk1.5.0_06/bin/javac
  344. JAVA =$direction/jdk1.5.0_06/bin/java
  346. all:
  347. $(JAVAC) $nomFichierImplementation
  348. run:
  349. $(JAVA) $fichierImplementation
  350. clean:
  351. find. -name \"*.class\" -exec rm {} \;"
  353. fi
  355. } #ERREUR ICI
  357. if [ extension = cpp] ; then
  358. {
  359. cpp
  360. }
  361. else
  362. {
  363. java
  364. }
  365. fi


 
voila les erreurs données :
rgelle@linux:~/script new> sh generer_squelette test
generer_squelette: line 355: syntax error near unexpected token `}'
generer_squelette: line 355: `}'


Message édité par transistor49 le 20-02-2006 à 22:19:20
Reply

Marsh Posté le 20-02-2006 à 22:01:53    

tu pourrais mettre le script dans des balises [cpp] parceque chopper la ligne 355 c'est chaud  
mci  :sol:


Message édité par h4rold le 20-02-2006 à 22:02:12
Reply

Marsh Posté le 20-02-2006 à 22:01:53   

Reply

Marsh Posté le 20-02-2006 à 22:04:06    

et voila sorry!

Reply

Marsh Posté le 20-02-2006 à 22:09:24    


 

Code :
  1. nomFichierImplementation=${nomClasse}.java    fichierImplementation=${repertoireFichierSource}${nomFichierImplementation}    fichierMakefile=${repertoireFichierSource}Makefile


tu cherche a faire quoi la ?
on a un probleme de crochet, il peux etre a cause du echo mais je doute :|


Message édité par h4rold le 20-02-2006 à 22:10:27
Reply

Marsh Posté le 20-02-2006 à 22:12:13    

ben je c pas car avant que je fasse le java, j'avait le cpp et sa marchait comme sa! non c pas sa?

Reply

Marsh Posté le 20-02-2006 à 22:20:15    

je vien de modifier une petite erreur mais apparement sa ne venait pas de sa mon probleme
meme erreur meme endroit

Reply

Marsh Posté le 20-02-2006 à 23:05:38    

voila j'ai corriger l'erreur, mais y'en a encore une:

Code :
  1. #! /bin/sh
  3. if [ $# -ne 1 ]; then
  4. { echo "Syntaxe : $0 nom de la classe (première lettre en MAJUSCULE) "
  5.    echo ""
  6. } >&2
  7. exit 1
  8. fi
  10. extension=0
  12. while [[extension != cpp]||[extension != java]] ; do
  13. {
  14. echo "Entrez le langage voulu (cpp ou java)."
  15. read
  16. extension=$EXTENSION
  17. }done
  19. nomClasse=$1
  20. nomClasseMaj=$(echo $nomClasse | tr a-z A-Z)
  21. nomClasseMin=$(echo $nomClasse | tr A-Z a-z)
  22. nomClasseTesteur=${nomClasse}Testeur
  23. repertoireFichierSource=./src/
  25. function cpp()
  26. {
  27. nomFichierEntete=${nomClasse}.h
  28. nomFichierImplementation=${nomClasse}.cpp
  29. nomFichierTesteur=${nomClasse}Testeur.cpp
  30. fichierEntete=${repertoireFichierSource}${nomFichierEntete}
  31. fichierImplementation=${repertoireFichierSource}${nomFichierImplementation}
  32. fichierTesteur=${repertoireFichierSource}${nomFichierTesteur}
  33. fichierMakefile=${repertoireFichierSource}Makefile
  35. #Saisie des informations de l'ent�e
  36. echo "Entrez une description sommaire de la classe"
  37. read note
  38. description=$REPLY
  40. auteur=$LOGNAME
  41. dateCreation=$(date +%d" "%b" "%Y" "%X)
  43. reponse="O"
  45. if [ -e $fichierEntete ] ; then
  46.  echo "Le fichier d'entete $fichierEntete existe. Voulez-vous l'écraser ? (O/N)"
  47.  read reponse;
  48. fi
  50. if  [ $reponse = "O" ] || [ $reponse = "o" ]; then
  52.  echo "Génération de $fichierEntete"
  53.  touch $fichierEntete
  55.  echo "//------------------------------------------------------------------------------
  56. /** @file         $nomFichierEntete
  57. *  @brief        $description
  58. *  @author       $auteur
  59. *  @since        $dateCreation
  60. *  @version      0.1
  61. *  @date         $dateCreation
  62. *  @note         $note
  63. *                plus de détaille dans : $nomFichierImplementation
  64. */
  65. //------------------------------------------------------------------------------
  66. #ifndef _${nomClasseMaj}_H
  67. #define _${nomClasseMaj}_H
  69. // En-tetes standards necessaires dans ce fichier en-tete seulement ------------
  71. // En-tetes propres à l'application necessaires dans ce fichier en-tete --------
  73. class $nomClasse
  74. {
  75. private :
  77. public :
  78.  // CONSTRUCTEURs et DESTRUCTEURs
  79.  ${nomClasse}() ;
  80.  ~${nomClasse}() ;
  82. protected :
  83. } ;
  85. //------------------------------------------------------------------------------
  86. #endif  //_${nomClasseMaj}_H
  87. //------------------------------------------------------------------------------
  88. " > $fichierEntete;
  89. fi
  91. if [ -e $fichierImplementation ] ; then
  92.  echo "Le fichier d'implementation $fichierImplementation existe. Voulez-vous l'ecraser ? (O/N)"
  93.  read reponse;
  94. fi
  96. if  [ $reponse = "O" ] || [ $reponse = "o" ]; then
  98. echo "Generation de $fichierImplementation"
  99. touch $fichierImplementation
  101. echo "//------------------------------------------------------------------------------
  102. /** @file         $nomFichierImplementation
  103. *  @brief        $description
  104. *  @author       $auteur
  105. *  @author       Licence pro logiciel libre et proprietaire
  106. *  @since        $dateCreation
  107. *  @version      0.1
  108. *  @date         $dateCreation
  109. *  Description detaillee du fichier $nomFichierImplementation
  110. *                $note
  111. */
  112. //------------------------------------------------------------------------------
  114. // En-tete propre à l'application ----------------------------------------------
  116. // En-tete propre à l'objet ----------------------------------------------------
  117. #include \"${nomFichierEntete}\"
  120. /** CONSTRUCTEURs
  121. *
  122. */
  123. ${nomClasse}::${nomClasse}()
  124. {
  126. }
  128. /** DESTRUCTEURs
  129. *
  130. */
  131. ${nomClasse}::~${nomClasse}()
  132. {
  134. }
  136. //---------------------------------------------------------------------------
  137. // METHODEs PUBLIQUEs
  138. //---------------------------------------------------------------------------
  141. //---------------------------------------------------------------------------
  142. // METHODEs PRIVEEs
  143. //---------------------------------------------------------------------------
  146. //---------------------------------------------------------------------------
  147. // METHODEs PROTEGEEs
  148. //---------------------------------------------------------------------------
  150. " > $fichierImplementation;
  151. fi
  154. if [ -e $fichierTesteur ] ; then
  155.  echo "Le fichier de test $fichierTesteur existe. Voulez-vous l'ecraser ? (O/N)"
  156.  read reponse;
  157. fi
  159. if  [ $reponse = "O" ] || [ $reponse = "o" ]; then
  161.  echo "Generation de $fichierTesteur"
  162.  touch $fichierTesteur
  165.  echo "//*********************************************************************
  166. // Fichier : $nomFichierTesteur
  167. // Classe : $nomClasse
  168. //*********************************************************************
  169. // $dateCreation  : $auteur, Version initiale
  170. //*********************************************************************
  172. #include <iostream>
  173. #include \"${nomFichierEntete}\"
  175. using namespace std;
  177. int main (int argc, char *argv[])
  178. {
  179.     // Construction de la classe à tester
  180.     cout << \"Construction de la classe $nomClasse\" << endl;
  181.     $nomClasse *${nomClasseMin} = new ${nomClasse}();
  183.     return 0;
  184. }
  185. " > $fichierTesteur;
  186. fi
  188. if [ -e $fichierMakefile ] ; then
  189.  echo "********************** ATTENTION ! **********************
  190. Le fichier Makefile existe. Voulez-vous l'ecraser ? (O/N)"
  191.  read reponse;
  192. fi
  194. if  [ $reponse = "O" ] || [ $reponse = "o" ]; then
  196.  echo "Génération de $fichierMakefile"
  197.  touch $fichierMakefile
  199.  echo "#############################################################################
  200. # Makefile pour generer : $nomFichierImplementation
  201. # Projet : nom du projet
  202. # Date : $dateCreation
  203. # Commande : make
  204. #############################################################################
  206. # Options de compilation
  207. CFLAGS = -Wall -pedantic -g
  209. # Options de linkage si nécessaire (ex -lm)
  210. LIBS =
  212. # Options de compilation spécifiques à QT
  213. #QTFLAGS = -I\${QTDIR}include
  215. # Options de linkage spécifique à QT
  216. #QTLIBS = -L\${QTDIR}lib -lqt-mt
  218. # Commande de compilation
  219. CC = g++ \${CFLAGS}
  220. # Commande de linkage
  221. CCLINK = \${CC} \${LIBS}
  223. # on place ici les objects à linker dans l'application finale
  224. OBJECTS = ${nomClasse}.o
  226. # on place ici les objets testeurs
  227. TESTOBJECTS = ${nomClasseTesteur}.o
  229. # on place ici les objets QT
  230. #MOCOBJECTS =
  232. # on rajoute ici les executables à générer
  233. all : \${OBJECTS} \${TESTOBJECTS} \${MOCOBJECTS} $nomClasseTesteur
  235. clean :
  236. @rm -f *~ *.moc.cpp *.o
  238. # role modelisée pour la production des .o
  239. %.o : %.cpp
  240. \${CC} -c \$<
  242. # role modeise pour la production des .moc.cpp spéifique à QT
  243. %.moc.cpp : %.h
  244. \${QTDIR}/bin/moc -o \$*.moc.cpp \$*.h
  246. # role pour la production des exécutables
  247. $nomClasseTesteur : \${OBJECTS} ${nomClasseTesteur}.o
  248. \${CCLINK} \${OBJECTS} \$@.o -o \$@
  250. " > $fichierMakefile;
  251. fi
  252. }
  254. function java()
  255. {
  256. nomFichierImplementation=${nomClasse}.java
  257. fichierImplementation=${repertoireFichierSource}${nomFichierImplementation}
  258. fichierMakefile=${repertoireFichierSource}Makefile
  260. #Saisie des informations de l'entete
  262. echo "Entrez une description sommaire de la classe"
  263. read note
  264. description=$REPLY
  266. direction=$HOME
  267. auteur=$LOGNAME
  268. dateCreation=$(date +%d" "%b" "%Y" "%X)
  270. reponse="O"
  272. if [ -e $fichierImplementation ] ; then
  273.  echo "Le fichier d'entete $fichierImplementation existe. Voulez-vous l'écraser ? (O/N)"
  274.  read reponse;
  275. fi
  277. if  [ $reponse = "O" ] || [ $reponse = "o" ]; then
  279. echo "Génération de $fichierImplementation"
  280. touch $fichierImplementation
  282. echo "//------------------------------------------------------------------------------
  283. /** @file         $nomFichierImplementation
  284. *  @brief        $description
  285. *  @author       $auteur
  286. *  @since        $dateCreation
  287. *  @version      0.1
  288. *  @date         $dateCreation
  289. *  @note         $note
  290. *                plus de détaille dans : $nomFichierImplementation
  291. */
  292. //------------------------------------------------------------------------------
  293. //mettre le nom du pakage dans lequel il apartient!
  294. package
  297. // En-tetes standards necessaires dans ce fichier en-tete seulement ------------
  299. // En-tetes propres à l'application necessaires dans ce fichier en-tete --------
  301. public class $fichierImplementation
  302. {
  303. //---------------------------------------------------------------------------
  304. // Attributs
  305. //---------------------------------------------------------------------------
  308. //---------------------------------------------------------------------------
  309. // METHODEs PUBLIQUEs
  310. //---------------------------------------------------------------------------
  311. public $fichierImplementation()
  312. {
  314. }
  316. //---------------------------------------------------------------------------
  317. // METHODEs PRIVEEs
  318. //---------------------------------------------------------------------------
  321. //---------------------------------------------------------------------------
  322. // METHODEs PROTEGEEs
  323. //---------------------------------------------------------------------------
  324. }
  325. "> $fichierImplementation;
  326. fi
  328. if [ -e $fichierMakefile ] ; then
  329.  echo "********************** ATTENTION ! **********************
  330. Le fichier Makefile existe. Voulez-vous l'ecraser ? (O/N)"
  331.  read reponse;
  332. fi
  334. if  [ $reponse = "O" ] || [ $reponse = "o" ]; then
  335.  echo "Generation de $fichierMakefile "
  336.  touch $fichierMakefile
  337.  echo"#############################################################################
  338. # Makefile pour générer : $nomFichierImplementation
  339. # Projet : $fichierImplementation
  340. # Date : $dateCreation
  341. # Commande : make
  342. #############################################################################
  343. #ici, il faudra modifire le répertoire de votre jdk!!
  344. JAVAC = $direction/jdk1.5.0_06/bin/javac
  345. JAVA = $direction/jdk1.5.0_06/bin/java
  347. all:
  348. \$(JAVAC) $nomFichierImplementation
  349. run:
  350. \$(JAVA) $fichierImplementation
  351. clean:
  352. find. -name \"*.class\" -exec rm {} \;
  353. " > $fichierMakefile;
  355. fi
  356. }
  358. if [ extension = cpp ] ; then
  359. cpp
  360. else
  361. java
  362. fi


 
[sirius.info-ua]:~ > sh generer_squelette test
generer_squelette: line 363: syntax error: unexpected end of file
tjrs pas pigé


Message édité par transistor49 le 21-02-2006 à 09:53:00
Reply

Marsh Posté le 21-02-2006 à 04:01:43    

J'ai l'a flemme de lire ton code, mais tu sais qu'au lieu de faire des gros echo "..." qui t'obligent a backslasher plein de trucs, tu peux faire :

cat <<EOF > fichier
toto "titi" tata
tutu $var
EOF


Message édité par matafan le 21-02-2006 à 04:02:34
Reply

Marsh Posté le 21-02-2006 à 08:57:48    

dsl mais je trouve que cette facon de générer les fichier est plus simple. car tout est dedans. mon probleme est tjrs dans la fonction java, mais je c pas ou, la est le probleme

Reply

Marsh Posté le 21-02-2006 à 09:11:43    

line 364: syntax error: unexpected end of file cest que tu na pas fermé un crochet normalement.

Reply

Marsh Posté le 21-02-2006 à 09:13:36    

je suis d'accord avec toi mais le probleme c'est que je ne voit pas ou! en regardant bien il ne me semble pas qu'il en manque!

Reply

Marsh Posté le 21-02-2006 à 09:15:18    

essaie den rajouter un a la fin pour voir

Reply

Marsh Posté le 21-02-2006 à 09:22:39    

j'ai toujours la même erreur:
[sirius.info-ua]:~ > sh generer_squelette test
generer_squelette: line 364: syntax error: unexpected end of file

Reply

Marsh Posté le 21-02-2006 à 09:54:15    

je vien de remettre a jour le fichier ainsi qu l'erreur

Reply

Marsh Posté le 21-02-2006 à 11:16:35    

Je vien d'isoler le code posant probleme l'erreur est bien dans ma classe java!
voila le code :

Code :
  1. #!/bin/sh
  3. #vérification du parametre
  4. if [ $# -ne 1 ]; then
  5. {
  6. echo "Syntaxe : $0 nom de la classe (premiere lettre en MAJUSCULE) "
  7. echo ""
  8. } >&2
  9. exit 1
  10. fi
  12. #mise a zéro de l'extension
  13. extension="0"
  15. #vérification du paramètre entré
  16. while [ $extension != "cpp" ] || [ $extension != "java" ] ; do
  17. {
  18. echo "Entrez le langage voulu (cpp ou java)."
  19. read extension;
  20. extension = $EXTENSION
  21. }done
  23. #initialisation de toute les variables
  24. nomClasse=$1
  25. nomClasseMaj=$(echo $nomClasse | tr a-z A-Z)
  26. nomClasseMin=$(echo $nomClasse | tr A-Z a-z)
  27. nomClasseTesteur=${nomClasse}Testeur
  28. repertoireFichierSource=./src/
  30. #main du script
  32. jav
  34. #fonction java
  35. function jav()
  36. {
  37. nomFichierImplementation=${nomClasse}.java
  38. fichierImplementation=${repertoireFichierSource}${nomFichierImplementation}
  39. fichierMakefile=${repertoireFichierSource}Makefile
  41. #Saisie des informations de l'entete
  43. echo "Entrez une description sommaire de la classe"
  44. read note;
  45. description=$REPLY
  47. direction=$HOME
  48. auteur=$LOGNAME
  49. dateCreation=$(date +%d" "%b" "%Y" "%X)
  51. reponse="O"
  53. if [ -e $fichierImplementation ] ; then
  54.  echo "Le fichier d'entete $fichierImplementation existe. Voulez-vous l'écraser ? (O/N)"
  55.  read reponse;
  56. fi
  58. if  [ $reponse = "O" ] || [ $reponse = "o" ]; then
  60. echo "Génération de $fichierImplementation"
  61. touch $fichierImplementation
  63. echo "//------------------------------------------------------------------------------
  64. /** @file         $nomFichierImplementation
  65. *  @brief        $description
  66. *  @author       $auteur
  67. *  @since        $dateCreation
  68. *  @version      0.1
  69. *  @date         $dateCreation
  70. *  @note         $note
  71. *                plus de détaille dans : $nomFichierImplementation
  72. */
  73. //------------------------------------------------------------------------------
  74. //mettre le nom du pakage dans lequel il apartient!
  75. package
  78. // En-tetes standards necessaires dans ce fichier en-tete seulement ------------
  80. // En-tetes propres à l'application necessaires dans ce fichier en-tete --------
  82. public class $fichierImplementation
  83. {
  84. //---------------------------------------------------------------------------
  85. // Attributs
  86. //---------------------------------------------------------------------------
  89. //---------------------------------------------------------------------------
  90. // METHODEs PUBLIQUEs
  91. //---------------------------------------------------------------------------
  92. public $fichierImplementation()
  93. {
  95. }
  97. //---------------------------------------------------------------------------
  98. // METHODEs PRIVEEs
  99. //---------------------------------------------------------------------------
  102. //---------------------------------------------------------------------------
  103. // METHODEs PROTEGEEs
  104. //---------------------------------------------------------------------------
  105. }"> $fichierImplementation;
  106. fi
  108. if [ -e $fichierMakefile ] ; then
  109.  echo "********************** ATTENTION ! **********************
  110. Le fichier Makefile existe. Voulez-vous l'ecraser ? (O/N)"
  111.  read reponse;
  112. fi
  114. if  [ $reponse = "O" ] || [ $reponse = "o" ]; then
  115.  echo "Generation de $fichierMakefile "
  116.  touch $fichierMakefile
  117.  echo "#############################################################################
  118. # Makefile pour générer : $nomFichierImplementation
  119. # Projet : $fichierImplementation
  120. # Date : $dateCreation
  121. # Commande : make
  122. #############################################################################
  123. #ici, il faudra modifire le répertoire de votre jdk!!
  124. JAVAC = $direction/jdk1.5.0_06/bin/javac
  125. JAVA = $direction/jdk1.5.0_06/bin/java
  127. all:
  128. \$(JAVAC) $nomFichierImplementation
  129. run:
  130. \$(JAVA) $fichierImplementation
  131. clean:
  132. find. -name \"*.class\" -exec rm {} \;
  133. " > $fichierMakefile;
  134. fi
  135. }


 
et l'erreur :
[sirius.info-ua]:~ > sh jav test
jav: line 136: syntax error: unexpected end of file


Message édité par transistor49 le 21-02-2006 à 14:11:34
Reply

Marsh Posté le 21-02-2006 à 13:31:56    

:hello:  
Je me demande si par hasard, il ne faudrait pas remplacer
 

 if  [ $reponse = "O" ] || [ $reponse = "o" ]; then

par
 

 if  [[ $reponse = "O" ] || [ $reponse = "o" ]]; then

Reply

Marsh Posté le 21-02-2006 à 14:00:52    

j'ai deja essayer, et sa marche po mieux, deplus, il m'a été conseiller de ne pas faire comme ça!

Reply

Marsh Posté le 21-02-2006 à 14:03:25    

sinon quand tu compare une variable avec une chaine de carractere, il faut mettre des guillements sur la variables sinon tu as des problemes.
if  [ "$reponse" = "O" ] || [ "$reponse" = "o" ]; then
 
mais ce nest pas lerreur en cours, je la voit pas :|

Reply

Marsh Posté le 21-02-2006 à 14:13:40    

ben vi c pour sa que je demande, moi non plus je la voie pas!

Reply

Marsh Posté le 21-02-2006 à 14:22:28    

Je me demande si il y a pas un probleme avec sa!!

Code :
  1. echo "#############################################################################
  2. # Makefile pour generer : $nomFichierImplementation
  3. # Projet : $fichierImplementation
  4. # Date : $dateCreation
  5. # Commande : make
  6. #############################################################################
  7. #ici, il faudra modifire le repertoire de votre jdk!!
  8. JAVAC = $direction/jdk1.5.0_06/bin/javac
  9. JAVA = $direction/jdk1.5.0_06/bin/java
  11. all:
  12. \$(JAVAC) $nomFichierImplementation
  13. run:
  14. \$(JAVA) $fichierImplementation
  15. clean:
  16. find. -name \"*.class\" -exec rm {} \;
  17. " > $fichierMakefile;


Reply

Marsh Posté le 21-02-2006 à 14:40:16    

j'ai trouver, sa venait de ma boucle for, faut pas d'{}

Reply

Marsh Posté le 21-02-2006 à 14:50:36    

transistor49 a écrit :

Sujet : boucle if


 
Putain ça me fout les boules quand je vois quelqu'un parler de "boucle" pour un "if"...
 
Le "if" est une structure alternative non répétitive. Le "while", "until" et "for" sont des structures répétitives (donc des boucles).
 
La commande "break" sort de la boucle la plus proche. Si tu mets un "break" dans un "if" lui-même inclus dans un "while", ton "break" dépassera le "if" pour te faire quitter le "while" => le "if" n'est pas une boucle
 

transistor49 a écrit :

je m'inicie au script shell


Tu as un tutorial en français pour t'initier ici: http://fr.lang.free.fr/cours/Shell_v1.4.pdf


Message édité par Sve@r le 21-02-2006 à 14:51:36

---------------
Vous ne pouvez pas apporter la prospérité au pauvre en la retirant au riche.
Reply

Marsh Posté le    

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed