salut ,
 
Voila je fait un petit script pour compter le nombre de ligne dans un fichier .c mais sans prendre en compte les commentaire qui commence par  
/*    */ ou par
//    //
 
j'ai des soucis avec mon expression reg
 
$1 !~ /\/*/ && /\/\//
 
un petit coup de mains svp.    
 

voila mon code  
 
BEGIN {
   cpt = 0
   titre = "Le nombre de lignes"
$1 !~ /^\/*/ && $1 !~ /^\/\/ { cpt++ }
END { print titre cpt }

 
J'aurais plutôt un truc du style :
 
BEGIN {
   cpt = 0
   titre = "Le nombre de lignes"
$1 !~ /^\/\*/ && $1 !~ /^\/\// && $1 !~ /\*\/$/ { cpt++ }
END { print titre cpt }
 
J'espère que cela ira ...  
 
 
A+

Merci pour ton aide je vais essayer ça

sauf que ça marche pas pour un truc du genre :

ça comptera 1 ligne au lieu de 0
 
EDIT : tiens, pour joce non plus, ça marche pas

$1 !~ /^\/\*/ && $1 !~ /^\/\// && $1 !~ /\*\/$/ { cpt++ }
 
Awk c'est tellement beau que parfois on dirait du perl

 
Bon .. OK ... mea culpa ...    
 
Alors :
 
#!/usr/bin/ksh
 
awk '
BEGIN {
 flag = 1
 cpt = 0
 titre = "Le nombre de lignes : "
}
$1 ~ /^\/\*/ {
 flag = 0
}
$1 ~ /\*\/$/ {
 flag = 1
}
$1 !~ /^\/\*/ && $1 !~ /^\/\// && $1 !~ /\*\/$/ && flag != 0 {
 cpt++
}
END {
print titre cpt
}' $1

En effet ça marchait pas très bien mais bon ct un bon début , j'ai pas eu le tps de tester le reste mais promis demain c'est fait et je vous tiens au courant.
Merci à vous.

Hello
 
Dis-moi Stafy, je comprends pas prkoi tu testes */$ ; en C les commentaire sont formatés soit avec //commentaire soit avec /*commentaire*/ non ?
Peux-tu t'expliquer stp.

 
Comme le dit très justement bobuse, les commentaires sont une portion de texte commençant par /* et finissant par le premier */ rencontrés, y compris sur plusieurs lignes.
 
Est-ce que cela fonctionne maintenant ?
 

Je n'arrive pas à voir la bonne fonctionnalité du script pour des cas comme celui-ci
 
/*blabla
blablablabla
blablablabla
blablablabla*/
 
Sur la deuxième ligne, on teste si
le début de ligne ne commence pas par /*
le début de ligne ne commence pas par //
la fin de ligne ne se termine pas par */
et si le flag est différent de 0 donc =1 cad si  la fin de ligne ne se termine pas par */
 
Donc pour moi les 2 lignes en rouge sont comptées ce qui ne devrait pas et ce qui n'est pas (j'ai testé) mais je ne comprend pas le prkoi.
Can you explain to me please  

C'est bon j'ai compris dsl mais c que lundi matin et ce WE à été très fatiguant
Merci bien pour ton aide

 
En fait, le compteur s'incrémente si :
  - la ligne ne commence pas par //
  - la ligne ne comporte ni /* et ni */
  - le flag est à 1 .. donc non dans une série de lignes commentaires
 
Si les deux premières conditions sont remplies ... mais que le flag est à 0 .. cela signifie qu'avant on a eu le /* mais qu'il n'y a toujours pas eu de fin de commentaire (*/).

Et oui ton script fonctionne bien pas de soucis  
Merci encore

j'ai une modif en fait par rapport au départ je doit varier aussi les lignes qui commence par ;// et @" ma ligne de code est  
$1 !~ /^\/\*/ && $1 !~ /^\/\// && $1 !~ /\*\/$/ && flag != 0 && $1 !~ /^\;\/\// && $1 !~ /\@\"/ {  
 cpt++  
 print $0 >> "houtil/result.txt"
 
mais ça fonctionne pas  
j'ai essayé plusieurs syntaxe mais pas de prise en compte de ces lignes.
J'en appelle à toi Stafy, si tu peux m'aider encore un peu

Nan c bon, le prob ct ma redirection >> qui bien sur rajoute à la fin du fichier et mo j'ai regardé que le début
Donc pas de soucis ça fonctionne bien

 
Effectivement ...    
 
Cependant je viens de m'apercevoir d'un bug dans mon awk ...
Je t'explique ... comme j'utilisais $1 pour tester les champs il fallait obligatoirement que la chaine */ soit en début de ligne .. or ce n'est pas toujours le cas    
 
De ce fait j'ai modifié le code comme indiqué ci-dessous :
 
#!/usr/bin/ksh  
 
awk '  
BEGIN {  
 flag = 1  
 cpt = 0  
 titre = "Le nombre de lignes : "  
}  
$0 ~ /^\/\*/ {  
 flag = 0  
}  
$0 ~ /\*\/$/ {
 flag = 1  
}  
$0 !~ /^\/\*/ && $0 !~ /^\/\// && $0 !~ /\*\/$/ && $0 !~ /^;\/\// && $0 !~ /^\@\"/ && flag != 0 {  
 print $0
 cpt++
}  
END {  
print titre cpt  
}' $1 > FicRes.txt
 
 
N'hésites pas à me dire si ça fonctionne convenablement .. et si tu as des questions n'hésites pas.
 

En effet, pour une ligne comme celle-ci ça ne fonctionnait pas  
static T_UWORD ruw_IST_Result;  /* IST result : calculated by IST_Algo_X(), used by IST_Management() */
 
car il trouve */ en fin de ligne  
J'ai testé ton script mais il ne fonctionne pas, prkoi, je sais pas encore , il m'affiche même pas le titre avec le nombre de ligne mais bon ça doit pas être bien grave je venair demain et je te tiens au courant
Merci pour ton aide

 
De rien .. ça me fait progresser ...
   
 
   

Salut Stafy,
 
Ton script n'est pas bon pour 2 raisons :
Il ne prend pas en compte les lignes de code qui sont suivies par un commentaire, du genre
 
#include <bdframwo.h>   /*opening of an aligned RAM word class*/
 
et d'autre part les lignes vides sont comptées  
 

 
Tu peux essayer ça maintenant :
 
#!/usr/bin/ksh  
awk '  
BEGIN {  
 flag = 1  
 cpt = 0  
 titre = "Le nombre de lignes : "  
}  
$0 ~ /\/\*/ {  
 flag = 0  
}  
$0 ~ /\*\// {
 flag = 1  
}  
$0 !~ /^\/\*.*\*\/$/ && $0 !~ /.*\*\/$/ && $0 !~ /^.*\/\// && $0 !~ /^;\/\// && $0 !~ /^\@\"/ && $0 !~ /^$/ && flag != 0 {  
 print $0
 cpt++
}
END {  
print titre cpt  
}' $1
 
Tiens moi au courant ..

Ci dessous le fichier en entrée :
 
#include <bdframwo.h>   /*opening of an aligned RAM word class*/
 
1 qzegqjsbd
// TOTO
2 qzegqjsbd
 
/* TOTO
TOTO
TOTO
TOTO */
3 qzegqjsbd
 
/* TOTO */
4 qzegqjsbd
/* TOTO
TOTO
*/
 
5 qzegqjsbd
;// TOTO
6 qzegqjsbd
 
7 qzegqjsbd
@"TOTO
8 qzegqjsbd
 
 
Et le résultat :
 
1 qzegqjsbd
2 qzegqjsbd
3 qzegqjsbd
4 qzegqjsbd
5 qzegqjsbd
6 qzegqjsbd
7 qzegqjsbd
8 qzegqjsbd
Le nombre de lignes : 8

On a du mal se comprendre au niveau du résultat à obtenir car la 1ere ligne il faut qu'elle soit pris en compte peut importe le commentaire qui suit c'est quand même une ligne de code.

En fait voila ce qui marche (enfin pour le momment   )
 
#!/usr/bin/ksh  
awk '  
BEGIN {  
 flag = 1  
 cpt = 0  
 titre = "Le nombre de lignes : "  
}  
$0 ~ /\/\*/ {  
 flag = 0  
}  
$0 ~ /\*\// {  
 flag = 1  
}  
$0 !~ /^\/\*.*\*\/$/ &&  $0 !~ /^.*\/\// && $0 !~ /^;\/\// && $0 !~ /^\@\"/ && $0 !~ /^$/ && flag != 0 {  
 print $0 > "./fich_resul.txt"
 cpt++  
}  
END {  
print titre cpt  
}' $1  
 
J'ai juste supprimé le teste de fin de ligne    

en fait ça prend bien en compte les lignes suivies d'un commentaire mais je me retrouve avec des lignes du style  
 
*********************************************************/
 
normal.Je me demande s'il ne faudrait pas inclure un tant que cad si trouve /* tant que pas */ passe ligne suivante nan ?

 
Ca ne fonctionne pas encore correctement .. car ça donne ça dans mon jeu test :
 
#include <bdframwo.h>   /*opening of an aligned RAM word class*/
1 qzegqjsbd
2 qzegqjsbd
TOTO */
3 qzegqjsbd
4 qzegqjsbd
*/
5 qzegqjsbd
6 qzegqjsbd
7 qzegqjsbd
8 qzegqjsbd
Le nombre de lignes : 11
 
A suivre donc ...  

Bon voilà ma contribution.
Je me contente de supprimer les lignes qu'il faut,il reste plus qu'à compter le résultat (wc -l)

 
Il reste au moins un bug, c'est les lignes du genre

Salut bobuse,
 
Intéréssant ton script, mais je vais essayé d'en finir avec celui que l'on commencé avec stafy.
En fait je n'aiplus qu'un problème à régler; celui ci :
 
 
/*   $Workfile:                       |     PROCESSOR:
 ****************************************************************************
 *   $Author:
 *   $Date:  
 ****************************************************************************
 *   $Revision:   1.2  $    |  PROJECT:       |  COMPILER:                            
 ****************************************************************************/
 
sur cet exemple il me compte la ligne en rouge et c'est pas bon  
 
ça c'est le script
 
 
#!/usr/bin/ksh  
awk '  
BEGIN {  
 flag = 1  
 cpt = 0  
 titre = "Le nombre de lignes : "  
}  
$1 ~ /\/\*/ {  
 flag = 0  
}  
$1 ~ /\*\// {  
 flag = 1  
}  
$1 !~ /^\/\*.*\*\/$/ &&  $1 !~ /^.*\/\// && $1 !~ /^;\/\// && $1 !~ /^\@\"/ && $1 !~ /^$/ && flag != 0 {  
 print $0 > "./fich_resul.txt"
 cpt++  
}  
END {  
print titre cpt  
}' $1  
 
En fait c'est simple : Si trouve /*  ; tant que pas trouve */ passage ligne suivante , mais pas si simple à coder enfin pour un débutant comme moi    

Bon voilà, ça a l'air de marcher comme ça :

Et dans notre version .. je pense avoir également trouvé :
 
#!/usr/bin/ksh
awk '  
BEGIN {flag=1;cpt=0;titre="Le nombre de lignes : "}
$0 ~ /\/\*/ && $0 !~ /\*\// {
 flag = 0
}
$0 ~ /\*\// && $0 !~ /\/\*/ {
 flag = 1
 next
}
$0 !~ /^\/\*.*\*\/$/ && $0 !~ /^.*\/\// && $0 !~ /^;\/\// && $0 !~ /^\@\"/ && $0 !~ /^$/ && flag != 0 {  
 print $0
 cpt++
}
END {print titre cpt}' $1
exit 0
 
 

C'est quel chose dans ce style que je voudrais faire  
Est-ce une mauvaise idée
 
 
#!/usr/bin/ksh  
awk '  
BEGIN {  
 flag = 1  
 cpt = 0  
 titre = "Le nombre de lignes : "  
}  
$1 ~ /\/\*/ {  
 flag = 0  
 while '$0 !~ /\*\//$' do next
}  
$1 ~ /\*\// {  
 flag = 1  
}  
$1 !~ /^\/\*.*\*\/$/ &&  $1 !~ /^.*\/\// && $1 !~ /^;\/\// && $1 !~ /^\@\"/ && $1 !~ /^$/ && flag != 0 {  
 print $0 > "./fich_resul.txt"
 cpt++  
}  
END {  
print titre cpt  
}' $1  
 
 
J'ai testé ton script stafy mais ça ma pas l'air de marcher, je ne me suis pas vraiment penché dessus non plus

Stafy ou bobuse ,
 
je comprends pas très bien ceci $1 !~ /^\/\*.*\*\/$/  
Tu cherches en début de ligne /* une multitude de fois jusqu'en fin de ligne ?

C'est juste pour dire que la chaîne doit matcher :
  - /* en début de ligne
  - */ en fin de ligne
  - n'importe quels caractères entre les deux (.*)

 
Bah    
Ca fonctionne pourtant ici ...
Tu pourrais me faire un copier coller de ton script test (ou un extrait) qui doit être parcouru par le awk stp ?
 
Voici mon jeu test :
 
/*   $Workfile:                       |     PROCESSOR:
 ****************************************************************************
 *   $Author:
 *   $Date:
 ****************************************************************************
 *   $Revision:   1.2  $    |  PROJECT:       |  COMPILER:
 ****************************************************************************/
1 #include <bdframwo.h>   /*opening of an aligned RAM word class*/
2 Ligne test
// TOTO
3 Ligne test
 
/* TOTO
TOTO
TOTO */
3 Ligne test
/* TOTO */
4 Ligne test
/* TOTO
TOTO
*/
5 Ligne test
;// TOTO
6 Ligne test
@"TOTO
 
Et voici le résultat :
 
1 #include <bdframwo.h>   /*opening of an aligned RAM word class*/
2 Ligne test
3 Ligne test
3 Ligne test
4 Ligne test
5 Ligne test
6 Ligne test
Le nombre de lignes : 7
 
Donc ça a l'air de fonctionner .. non ?
 

et s'il y a des espaces/tabulations avant un /* ?

 
Ah ouais .. mais là c'est plus marrant ...
   
 
Ok j'y retourne ..
 

Je fais court :
 
$0 !~ /^[ \t]*\/\*.*\*\/$/ && $0 !~ /^\/\*.*\*\/$/ && $0 !~ /^.*\/\// && $0 !~ /^;\/\// && $0 !~ /^\@\"/ && $0 !~ /^$/ && flag != 0 {  
 print $0
 cpt++
}

/*~+:***********************************************************************************************/
/*~+:   EXTERNAL FUNCTIONS                                                                           */
/*~+:*/
/*~+:***********************************************************************************************/
/*~+:*/
/*~F*/
void NEAR_FCT IST_Algo_0(void)
/*~-*/
{
   /*~T*/
 
   /*~T*/
#pragma asm
 
   ;// Register usage
 
    @"  *****************************************************************************  "
    @"  Register Usage:    "
    @"  REG1  : register for indirect address mode (const.area, rul_IST_Calc_Temp_Dat1 = XRAM)  "
    @"  REG2  : register for indirect address mode (rul_IST_Calc_Temp_Dat2 = external RAM)   "
    @"  REG3  : working register for calculation tests  "
    @"  REG4  : return parameter result value  "
    @"  REG5  : temporary register for flag tests  "
 
 
 
resultat apres passage
 
void NEAR_FCT IST_Algo_0(void)
{
  /*~T*/
   /*~T*/#pragma asm
    @"  *****************************************************************************  "
    @"  Register Usage:    "
    @"  REG1  : register for indirect address mode (const.area, rul_IST_Calc_Temp_Dat1 = XRAM)  "
    @"  REG2  : register for indirect address mode (rul_IST_Calc_Temp_Dat2 = external RAM)   "
    @"  REG3  : working register for calculation tests  "
    @"  REG4  : return parameter result value  "    @"  REG5  : temporary register for flag tests  "
     
 
 

Bon ben je vais me coucher ... je reviendrais la semaine prochaine ...

 
A+

Ca y est c'est le bon je crois , j'ai juste changé le $0 en $1 pour varer les @"
 
Merci à vous les gars
 
 
#!/usr/bin/ksh  
awk '  
BEGIN {flag=1;cpt=0;titre="Le nombre de lignes : "}  
$0 ~ /\/\*/ && $0 !~ /\*\// {  
 flag = 0  
}  
$0 ~ /\*\// && $0 !~ /\/\*/ {  
 flag = 1  
 next  
}  
$0 !~ /^[ \t]*\/\*.*\*\/$/ && $0 !~ /^\/\*.*\*\/$/ && $0 !~ /^.*\/\// && $0 !~ /^;\/\// && $1 !~ /^\@\"/ && $0 !~ /^$/ && flag != 0 {  
 print $0 > "./resultat.txt"
 cpt++  
}  
END {print titre cpt}' $1