Eu tentei sed e awk, mas não está funcionando, pois o personagem envolve "/", que já está no comando como delimitador.

Por favor, deixe-me saber como posso conseguir isso.

Abaixo está um exemplo de exemplo. Queremos remover as seções comentadas, ou seja, /*.....*/

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

Eu acho que encontrei uma solução fácil!

cpp -P yourcommentedfile.txt 

ALGUMAS ATUALIZAÇÕES:

Citação do usuário ilkachu (texto original dos comentários do usuário):

Eu brinquei um pouco com as opções do gcc: -fpreprocessed desativará a maioria das diretivas e expansões de macro (exceto #define e #undef aparentemente). Adicionar -dD também deixará define em; e std = c89 pode ser usado para ignorar o novo estilo // comentários. Mesmo com eles, o cpp substitui os comentários por espaços (em vez de removê-los) e recolhe espaços e linhas vazias.

Mas acho que ainda é razoável e uma solução fácil para a maioria dos casos, se você desativar a expansão de macro e outras coisas, acho que obterá bons resultados ... - e sim, você pode combinar isso com o shell script para melhorar ... e muito mais...

Certa vez, inventei isso que podemos refinar:

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'

para lidar com mais alguns casos de canto.

Observe que se você remover um comentário, poderá alterar o significado do código ( 1-/* comment */-1é analisado como 1 - -1while 1--1(que você obteria se removesse o comentário) causaria um erro). É melhor substituir o comentário por um caractere de espaço (como fazemos aqui) em vez de removê-lo completamente.

O exemplo acima deve funcionar corretamente nesse código ANSI C válido, por exemplo, que tenta incluir alguns casos de canto:

#include <stdio.h>
int main ()
{
  printf ("% d% s% c% c% c% c% c% s% s% d \ n",
  1 - / * comentário * / - 1,
  / \
* Comente */
  "/ * não é um comentário * /",
  / * multiline
  Comente */
  '"' /* Comente */ , '"',
  '\'','"'/* Comente */,
  '\
\
"', /* Comente */
  "\\
"/ * não é um comentário * /",
  "?? /" / * não é um comentário * / ",
  '??' '+' "'/ *" comentário "* /);
  retornar 0;
}

O que fornece esta saída:

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

  "/ * não é um comentário * /",

  '"', '"'
  '\' ',' "',
  '\
\
"'  
  "\\
"/ * não é um comentário * /",
  "?? /" / * não é um comentário * / ",
  '??' '+' "');
  retornar 0;
}

Ambos imprimem a mesma saída quando compilados e executados.

Você pode comparar com a saída de gcc -ansi -Epara ver o que o pré-processador faria nele. Esse código também é um código C99 ou C11 válido, no entanto, gccdesabilita o suporte a trigrafs por padrão, para que não funcione, a gccmenos que você especifique o padrão como gcc -std=c99ou gcc -std=c11ou adicione a -trigraphsopção).

Também funciona neste código C99 / C11 (não-ANSI / C90):

// Comente
/ \
/ Comente
// multiline \
Comente
"// não é um comentário"

(compare com gcc -E/ gcc -std=c99 -E/ gcc -std=c11 -E)

O ANSI C não suporta o // formcomentário. //não é válido de outra maneira no ANSI C, portanto, não apareceria lá. Um caso artificial em que //pode realmente aparecer no ANSI C (como observado aqui , e você pode achar o restante da discussão interessante) é quando o operador stringify está em uso.

Este é um código ANSI C válido:

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

E na época da discussão em 2004, de gcc -ansi -Efato a expandiu para "//not a comment". No entanto, hoje, gcc-5.4retorna um erro, então duvido que encontraremos muito código C usando esse tipo de construção.

O sedequivalente GNU pode ser algo como:

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"

Se seu GNU sedé muito antigo para suportar -Eou -z, você pode substituir a primeira linha por:

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

com sed:

ATUALIZAR

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

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

suporta todo o possível (comentário em várias linhas, dados após [ou e] antes);

 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;

Remova linhas em branco, se houver:

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

Edit - a versão mais curta de Stephane:

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

Solução usando o comando SED e nenhum script

Olha Você aqui:

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

Nota: isso não funciona no OS X, a menos que você instale gnu-sed. Mas funciona em distribuições Linux.

sedopera em uma linha por vez, mas alguns dos comentários na entrada abrangem várias linhas. Conforme /unix//a/152389/90751 , você pode primeiro usar trpara transformar as quebras de linha em algum outro caractere. Em seguida, você sedpode processar a entrada como uma única linha e usar trnovamente para restaurar as quebras de linha.

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

Usei bytes nulos, mas você pode escolher qualquer caractere que não apareça no seu arquivo de entrada.

*tem um significado especial em expressões regulares, portanto, precisará ser escapado \*para corresponder a um literal *.

.*é ganancioso - ele corresponderá ao texto mais longo possível, incluindo mais */e /*. Isso significa o primeiro comentário, o último comentário e tudo mais. Para restringir isso, substitua .*por um padrão mais rígido: os comentários podem conter qualquer coisa que não seja um "*" e também "*" seguido por qualquer coisa que não seja um "/". Execuções de múltiplos *s também devem ser consideradas:

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

Isso removerá quaisquer quebras de linha nos comentários de várias linhas, ou seja.

data1 /* multiline
comment */ data2

se tornará

data1  data2

Se não era isso que se queria, sedpode ser dito para manter uma das quebras de linha. Isso significa escolher um caractere de substituição de quebra de linha que possa ser correspondido.

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

O caractere especial \fe o uso de uma referência anterior que pode não corresponder a nada não garantem que funcione conforme o esperado em todas as sedimplementações. (Confirmei que funciona no GNU sed 4.07 e 4.2.2.)

usando uma linha sed para remover comentários:

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

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