J'ai essayé sed et awk, mais ça ne marche pas car le personnage implique "/" qui est déjà là en commande comme délimiteur.

Veuillez me faire savoir comment y parvenir.

Voici un exemple. Nous souhaitons supprimer les sections commentées, c.-à-d. /*.....*/

/*This is to print the output
data*/
proc print data=sashelp.cars;
run;
/*Creating dataset*/
data abc;
set xyz;
run;

Je pense que j'ai trouvé une solution facile!

cpp -P yourcommentedfile.txt 

QUELQUES MISES À JOUR:

Citation de l'utilisateur ilkachu (texte original des commentaires des utilisateurs):

J'ai joué un peu avec les options de gcc: -fpreprocessed désactivera la plupart des directives et extensions de macro (sauf #define et #undef apparemment). L'ajout de -dD laissera également les définitions dans; et std = c89 peut être utilisé pour ignorer le nouveau style // commentaires. Même avec eux, cpp remplace les commentaires par des espaces (au lieu de les supprimer) et réduit les espaces et les lignes vides.

Mais je pense que c'est toujours raisonnable et une solution facile pour la plupart des cas, si vous désactivez l'expansion des macros et d'autres choses, je pense que vous obtiendrez de bons résultats ... - et oui, vous pouvez combiner cela avec un script shell pour aller mieux ... et beaucoup plus...

Une fois, je suis venu avec ce que nous pouvons affiner:

perl -0777 -pe '
  BEGIN{
    $bs=qr{(?:\\|\?\?/)};
    $lc=qr{(?:$bs\n|$bs\r\n?)}
  }
  s{
    /$lc*\*.*?\*$lc*/
    | /$lc*/(?:$lc|[^\r\n])*
    | (
         "(?:$bs$lc*.|.)*?"
       | '\''$lc*(?:$bs$lc*(?:\?\?.|.))?(?:\?\?.|.)*?'\''
       | \?\?'\''
       | .[^'\''"/?]*
      )
  }{$1 eq "" ? " " : "$1"}exsg'

pour gérer quelques autres cas d'angle.

Notez que si vous supprimez un commentaire, vous pouvez changer la signification du code ( 1-/* comment */-1est analysé comme 1 - -1while 1--1(que vous obtiendriez si vous supprimiez le commentaire) vous donnerait une erreur). Il est préférable de remplacer le commentaire par un caractère espace (comme nous le faisons ici) au lieu de le supprimer complètement.

Ce qui précède devrait fonctionner correctement sur ce code C ANSI valide par exemple qui essaie d'inclure quelques cas d'angle:

#include <stdio.h>
int main()
{
  printf ("% d% s% c% c% c% c% c% s% s% d \ n",
  1 - / * commentaire * / - 1,
  / \
* commentaire * /
  "/ * pas un commentaire * /",
  / * multiligne
  commentaire * /
  '"' / * commentaire * /, '"',
  '\' ',' "'/ * comment * /,
  '\
\
"', / * commentaire * /
  "\\
"/ * pas un commentaire * /",
  "?? /" / * pas un commentaire * / ",
  '??' '+' "'/ *" comment "* /);
  retourner 0;
}

Ce qui donne cette sortie:

#include <stdio.h>
int main()
{
  printf ("% d% s% c% c% c% c% c% s% s% d \ n",
  1- -1,

  "/ * pas un commentaire * /",

  '"', '"',
  '\' ',' "',
  '\
\
"',  
  "\\
"/ * pas un commentaire * /",
  "?? /" / * pas un commentaire * / ",
  '??' '+' "');
  retourner 0;
}

Les deux affichent la même sortie une fois compilés et exécutés.

Vous pouvez comparer avec la sortie de gcc -ansi -Epour voir ce que ferait le pré-processeur. Ce code est également un code C99 ou C11 valide, mais gccdésactive la prise en charge des trigraphes par défaut, de sorte qu'il ne fonctionnera pas gccsauf si vous spécifiez la norme comme gcc -std=c99ou gcc -std=c11ou ajoutez l' -trigraphsoption).

Il fonctionne également sur ce code C99 / C11 (non-ANSI / C90):

// commentaire
/ \
/ commentaire
// multiligne \
commentaire
"// pas un commentaire"

(comparer avec gcc -E/ gcc -std=c99 -E/ gcc -std=c11 -E)

ANSI C n'a pas soutenu le // formcommentaire. //n'est pas par ailleurs valide dans ANSI C, donc n'y apparaîtrait pas. Un cas artificiel où //peut véritablement apparaître dans ANSI C (comme indiqué ici , et vous pouvez trouver le reste de la discussion intéressant) est lorsque l' opérateur stringify est utilisé.

Il s'agit d'un code ANSI C valide:

#define s(x) #x
s(//not a comment)

Et au moment de la discussion en 2004, gcc -ansi -Eil a effectivement été étendu à "//not a comment". Cependant aujourd'hui, gcc-5.4renvoie une erreur dessus, donc je doute que nous trouvions beaucoup de code C en utilisant ce type de construction.

L' sedéquivalent GNU pourrait être quelque chose comme:

lc='([\\%]\n|[\\%]\r\n?)'
sed -zE "
  s/_/_u/g;s/!/_b/g;s/</_l/g;s/>/_r/g;s/:/_c/g;s/;/_s/g;s/@/_a/g;s/%/_p/g;
  s@\?\?/@%@g;s@/$lc*\*@:&@g;s@\*$lc*/@;&@g
  s:/$lc*/:@&:g;s/\?\?'/!/g
  s#:/$lc*\*[^;]*;\*$lc*/|@/$lc*/$lc*|(\"([\\\\%]$lc*.|[^\\\\%\"])*\"|'$lc*([\\\\%]$lc*.)?[^\\\\%']*'|[^'\"@;:]+)#<\5>#g
  s/<>/ /g;s/!/??'/g;s@%@??/@g;s/[<>@:;]//g
  s/_p/%/g;s/_a/@/g;s/_s/;/g;s/_c/:/g;s/_r/>/g;s/_l/</g;s/_b/!/g;s/_u/_/g"

Si votre GNU sedest trop ancien pour supporter -Eou -z, vous pouvez remplacer la première ligne par:

sed -r ":1;\$!{N;b1}

avec sed:

MISE À JOUR

/\/\*/ {
    /\*\// {
        s/\/\*.*\*\///g;
        b next
    };

    :loop;
    /\*\//! {
        N;
        b loop
    };
    /\*\// {
        s/\/\*.*\*\//\n/g
    }
    :next
}

prise en charge de tous les possibles (commentaire sur plusieurs lignes, données après [ou et] avant);

 e1/*comment*/
-------------------
e1/*comment*/e2
-------------------
/*comment*/e2
-------------------
e1/*com
ment*/
-------------------
e1/*com
ment*/e2
-------------------
/*com
ment*/e2
-------------------
e1/*com
1
2
ment*/
-------------------
e1/*com
1
2
ment*/e2
-------------------
/*com
1
2
ment*/e2
-------------------

$ sed -f command.sed FILENAME

e1
-------------------
e1e2
-------------------
e2
-------------------
e1

-------------------
e1
e2
-------------------

e2
-------------------
e1

-------------------
e1
e2
-------------------

e2
-------------------

 $ cat file | perl -pe 'BEGIN{$/=undef}s!/\*.+?\*/!!sg'

 proc print data=sashelp.cars;
 run;

 data abc;
 set xyz;
 run;

Supprimez les lignes vides, le cas échéant:

 $ cat file | perl -pe 'BEGIN{$/=undef}s!/\*.+?\*/\n?!!sg'

Edit - la version courte de Stéphane:

 $ cat file | perl -0777 -pe 's!/\*.*?\*/!!sg'

Solution en utilisant la commande SED et aucun script

Vous voilà:

sed 's/\*\//\n&/g' test | sed '/\/\*/,/\*\//d'

NB Cela ne fonctionne pas sur OS X, sauf si vous installez gnu-sed. Mais cela fonctionne sur Linux Distros.

sedfonctionne sur une seule ligne à la fois, mais certains des commentaires de l'entrée s'étendent sur plusieurs lignes. Selon /unix//a/152389/90751 , vous pouvez d'abord utiliser trpour transformer les sauts de ligne en un autre caractère. Vous sedpouvez ensuite traiter l'entrée comme une seule ligne, et vous utilisez à trnouveau pour restaurer les sauts de ligne.

tr '\n' '\0' | sed ... | tr '\0' \n'

J'ai utilisé des octets nuls, mais vous pouvez choisir n'importe quel caractère qui n'apparaît pas dans votre fichier d'entrée.

*a une signification particulière dans les expressions régulières, il devra donc s'échapper \*pour correspondre à un littéral *.

.*est gourmand - il correspondra au texte le plus long possible, y compris plus */et /*. Cela signifie le premier commentaire, le dernier commentaire et tout le reste. Pour restreindre cela, remplacez-le .*par un modèle plus strict: les commentaires peuvent contenir tout ce qui n'est pas un "*", et aussi "*" suivi de tout ce qui n'est pas un "/". Les séries de plusieurs *s doivent également être prises en compte:

tr '\n' '\0' | sed -e 's,/\*\([^*]\|\*\+[^*/]\)*\*\+/,,g' | tr '\0' '\n'

Cela supprimera tous les sauts de ligne dans les commentaires multilignes, c'est-à-dire.

data1 /* multiline
comment */ data2

va devenir

data1  data2

Si ce n'est pas ce que vous vouliez, sedon peut vous dire de conserver l'un des sauts de ligne. Cela signifie choisir un caractère de remplacement de saut de ligne qui peut être mis en correspondance.

tr '\n' '\f' | sed -e 's,/\*\(\(\f\)\|[^*]\|\*\+[^*/]\)*\*\+/,\2,g' | tr '\f' '\n'

Le caractère spécial \fet l'utilisation d'une référence arrière qui ne correspond peut-être à rien ne sont pas garantis pour fonctionner comme prévu dans toutes les sedimplémentations. (J'ai confirmé que cela fonctionne sur GNU sed 4.07 et 4.2.2.)

en utilisant une ligne sed pour supprimer les commentaires:

sed '/\/\*/d;/\*\//d' file

proc print data=sashelp.cars;
run;
data abc;
set xyz;
run;