Ho provato sed e awk, ma non funziona perché il personaggio coinvolge "/" che è già lì al comando come delimitatore.

Per favore fatemi sapere come posso raggiungere questo obiettivo.

Di seguito è riportato un esempio.Vogliamo rimuovere le sezioni commentate, ad es /*.....*/

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

Penso di aver trovato una soluzione semplice!

cpp -P yourcommentedfile.txt 

ALCUNI AGGIORNAMENTI:

Citazione dell'utente ilkachu (testo originale dei commenti dell'utente):

Ho giocato un po 'con le opzioni per gcc: -fpreprocessed disabiliterà la maggior parte delle direttive e delle espansioni di macro (apparentemente tranne #define e #undef). L'aggiunta di -dD lascerà anche le definizioni; e std = c89 può essere usato per ignorare il nuovo stile // commenti. Anche con loro, cpp sostituisce i commenti con spazi (invece di rimuoverli) e comprime spazi e righe vuote.

Ma penso che sia ancora ragionevole e una soluzione facile per la maggior parte dei casi, se disabiliti l'espansione macro e altre cose penso che otterrai risultati buoni ... - e sì puoi combinarlo con lo script della shell per migliorare ... e altro ancora...

Una volta ho pensato a questo che possiamo affinare a:

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'

per gestire alcuni altri casi angolari.

Si noti che se si rimuove un commento, è possibile modificare il significato del codice ( 1-/* comment */-1analizzato come 1 - -1while 1--1(che si otterrebbe se si rimuovesse il commento) si darebbe un errore). È meglio sostituire il commento con un carattere spaziale (come facciamo qui) invece di rimuoverlo completamente.

Quanto sopra dovrebbe funzionare correttamente su questo codice ANSI C valido, ad esempio, che tenta di includere alcuni casi angolari:

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

Che dà questo risultato:

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

  "/ * non un commento * /",

  '"', '"',
  '\' ',' "',
  '\
\
"',  
  "\\
"/ * non un commento * /",
  "?? /" / * non un commento * / ",
  '??' '+' "');
  ritorna 0;
}

Entrambi stampano lo stesso output quando vengono compilati ed eseguiti.

Puoi confrontare con l'output di gcc -ansi -Eper vedere cosa farebbe il pre-processore su di esso. Tale codice è anche un codice C99 o C11 valido, tuttavia gccdisabilita il supporto trigraph per impostazione predefinita, quindi non funzionerà a gccmeno che non si specifichi lo standard gcc -std=c99o gcc -std=c11o si aggiunga l' -trigraphsopzione).

Funziona anche con questo codice C99 / C11 (non ANSI / C90):

// commento
/ \
/ commento
// multilinea \
commento
"// non un commento"

(confronta con gcc -E/ gcc -std=c99 -E/ gcc -std=c11 -E)

ANSI C non supportava il // formcommento. //non è altrimenti valido in ANSI C quindi non apparirebbe lì. Un caso forzato in cui //potrebbe effettivamente apparire in ANSI C (come notato qui , e potresti trovare interessante il resto della discussione) è quando l' operatore stringify è in uso.

Questo è un codice ANSI C valido:

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

E al momento della discussione del 2004, l' gcc -ansi -Eaveva davvero ampliata "//not a comment". Tuttavia oggi gcc-5.4restituisce un errore, quindi dubito che troveremo molto codice C usando questo tipo di costrutto.

L' sedequivalente GNU potrebbe essere qualcosa del tipo:

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 la tua GNU sedè troppo vecchia per supportare -Eo -z, puoi sostituire la prima riga con:

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

con sed:

AGGIORNARE

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

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

supportare tutto il possibile (commento su più righe, dati dopo [o e] prima);

 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;

Rimuovi eventuali righe vuote:

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

Modifica: la versione più breve di Stephane:

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

Soluzione utilizzando il comando SED e nessuno script

Ecco qui:

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

NB Questo non funziona su OS X, a meno che non venga installato gnu-sed. Ma funziona su Linux Distros.

sedopera su una riga alla volta, ma alcuni dei commenti nell'input si estendono su più righe. Come da /unix//a/152389/90751 , puoi prima usare trper trasformare le interruzioni di riga in qualche altro personaggio. Quindi è sedpossibile elaborare l'input come una riga singola e trriutilizzarlo per ripristinare le interruzioni di riga.

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

Ho usato byte nulli, ma puoi scegliere qualsiasi carattere che non appare nel tuo file di input.

*ha un significato speciale nelle espressioni regolari, quindi dovrà sfuggire \*per corrispondere a un letterale *.

.*è avido - corrisponderà al testo più lungo possibile, incluso più */e /*. Ciò significa che il primo commento, l'ultimo commento e tutto il resto. Per limitarlo, sostituiscilo .*con uno schema più rigoroso: i commenti possono contenere tutto ciò che non è un "*" e anche "*" seguito da tutto ciò che non è un "/". Le esecuzioni di più messaggi *devono anche essere contabilizzate:

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

Ciò rimuoverà qualsiasi interruzione di riga nei commenti su più righe, ad es.

data1 /* multiline
comment */ data2

diventerà

data1  data2

Se questo non è ciò che si voleva, si sedpuò dire di mantenere una delle interruzioni di riga. Questo significa scegliere un carattere sostitutivo per l'interruzione di riga che può essere abbinato.

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

Il carattere speciale \fe l'uso di un riferimento indietro che potrebbe non corrispondere a nulla, non sono garantiti per funzionare come previsto in tutte le sedimplementazioni. (Ho confermato che funziona su GNU sed 4.07 e 4.2.2.)

usando una riga sed per rimuovere i commenti:

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

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