Come usare più argomenti per awk con uno shebang (cioè #!)?

Vorrei eseguire uno script gawk--re-interval usando uno shebang. L'approccio "ingenuo" di

#!/usr/bin/gawk --re-interval -f
... awk script goes here

non funziona, poiché gawk viene chiamato con il primo argomento "--re-interval -f"(non diviso attorno agli spazi), che non comprende. C'è una soluzione alternativa per questo?

Ovviamente non puoi chiamare gawk direttamente ma racchiuderlo in uno script di shell che divide il primo argomento, o creare uno script di shell che poi chiami gawk e metta lo script in un altro file, ma mi chiedevo se ci fosse un modo per farlo questo all'interno di un file.

Il comportamento delle linee shebang differisce da sistema a sistema - almeno in Cygwin non divide gli argomenti con spazi bianchi. Mi interessa solo come farlo su un sistema che si comporta in questo modo; lo script non è pensato per essere portabile.

Questo sembra funzionare per me con (g) awk.

#!/bin/sh
arbitrary_long_name==0 "exec" "/usr/bin/gawk" "--re-interval" "-f" "$0" "$@"


# The real awk program starts here
{ print $0 }

Notare la #! esecuzioni /bin/sh, quindi questo script viene prima interpretato come uno script di shell.

All'inizio, ho semplicemente provato "exec" "/usr/bin/gawk" "--re-interval" "-f" "$0" "$@" , ma awk lo ha trattato come un comando e ha stampato incondizionatamente ogni riga di input. Questo è il motivo per cui ho inserito il arbitrary_long_name==0- dovrebbe fallire tutto il tempo. Potresti sostituirlo con una stringa senza senso. Fondamentalmente, stavo cercando una condizione falsa in awk che non avrebbe influenzato negativamente lo script della shell.

Nello script della shell, arbitrary_long_name==0definisce una variabile chiamata arbitrary_long_namee la imposta uguale a =0.

La linea Shebang non è mai stata specificata come parte di POSIX, SUS, LSB o qualsiasi altra specifica. AFAIK, non è stato nemmeno adeguatamente documentato.

C'è un consenso approssimativo su ciò che fa: prendere tutto tra il !e il \ne exec. Il presupposto è che tutto ciò che si trova tra il !e il \nè un percorso completo e assoluto per l'interprete. Non c'è consenso su cosa succede se contiene spazi bianchi.

1. Alcuni sistemi operativi trattano semplicemente l'intera cosa come il percorso. Dopo tutto, nella maggior parte dei sistemi operativi, spazi bianchi o trattini sono legali in un percorso.
2. Alcuni sistemi operativi si dividono in spazi bianchi e trattano la prima parte come il percorso dell'interprete e il resto come argomenti individuali.
3. Alcuni sistemi operativi si dividono al primo spazio bianco e trattano la parte anteriore come il percorso dell'interpeter e il resto come un singolo argomento (che è ciò che stai vedendo).
4. Alcuni addirittura non supportano linee shebang a tutti .

Per fortuna, 1. e 4. sembrano essersi estinti, ma 3. è abbastanza diffuso, quindi semplicemente non puoi fare affidamento sulla possibilità di superare più di un argomento.

E dal momento che la posizione dei comandi è, inoltre, non specificato in POSIX o SUS, in genere si usa up che singolo argomento passando dell'eseguibile nome di envmodo che esso possa determinare la posizione del file eseguibile; per esempio:

#!/usr/bin/env gawk

[Ovviamente, questo presuppone ancora un percorso particolare env, ma ci sono solo pochissimi sistemi in cui vive /bin, quindi questo è generalmente sicuro. La posizione di envè molto più standardizzata rispetto alla posizione di gawko, peggio ancora, qualcosa come pythono rubyo spidermonkey.]

Il che significa che non si può effettivamente utilizzare eventuali argomenti affatto .

Sebbene non sia esattamente portabile, a partire da coreutils 8.30 e secondo la sua documentazione sarai in grado di utilizzare:

#!/usr/bin/env -S command arg1 arg2 ...

Così dato:

$ cat test.sh
#!/usr/bin/env -S showargs here 'is another' long arg -e "this and that " too

otterrete:

% ./test.sh 
$0 is '/usr/local/bin/showargs'
$1 is 'here'
$2 is 'is another'
$3 is 'long'
$4 is 'arg'
$5 is '-e'
$6 is 'this and that '
$7 is 'too'
$8 is './test.sh'

e nel caso foste curiosi showargsè:

#!/usr/bin/env sh
echo "\$0 is '$0'"

i=1
for arg in "$@"; do
    echo "\$$i is '$arg'"
    i=$((i+1))
done

Risposta originale qui .

Mi sono imbattuto nello stesso problema, senza una soluzione apparente a causa del modo in cui gli spazi bianchi vengono trattati in un lampo (almeno su Linux).

Tuttavia, puoi passare diverse opzioni in uno shebang, purché siano opzioni brevi e possano essere concatenate (nel modo GNU).

Ad esempio, non puoi avere

#!/usr/bin/foo -i -f

ma puoi avere

#!/usr/bin/foo -if

Ovviamente, funziona solo quando le opzioni hanno brevi equivalenti e non accettano argomenti.

Sotto Cygwin e Linux tutto ciò che segue il percorso dello shebang viene analizzato nel programma come un argomento.

È possibile aggirare questo problema usando un altro awkscript all'interno dello shebang:

#!/usr/bin/gawk {system("/usr/bin/gawk --re-interval -f " FILENAME); exit}

Questo verrà eseguito {system("/usr/bin/gawk --re-interval -f " FILENAME); exit}in awk.
E questo verrà eseguito /usr/bin/gawk --re-interval -f path/to/your/script.awknella shell del tuo sistema.

#!/bin/sh
''':'
exec YourProg -some_options "$0" "$@"
'''

Il trucco di shell shebang sopra è più portatile di /usr/bin/env.

Nel manuale di gawk (http://www.gnu.org/manual/gawk/gawk.html), alla fine della sezione 1.14 si nota che si dovrebbe usare un solo argomento quando si esegue gawk da una riga di shebang. Dice che il sistema operativo tratterà tutto dopo il percorso di gawk come un singolo argomento. Forse c'è un altro modo per specificare l' --re-intervalopzione? Forse il tuo script può fare riferimento alla tua shell nella riga shebang, essere eseguito gawkcome un comando e includere il testo del tuo script come "here document".

Perché non usare bashe gawkse stesso, per saltare oltre Shebang, leggere lo script e passarlo come file a una seconda istanza di gawk [--with-whatever-number-of-params-you-need]?

#!/bin/bash
gawk --re-interval -f <(gawk 'NR>3' $0 )
exit
{
  print "Program body goes here"
  print $1
}

(-Lo stesso potrebbe naturalmente essere ottenuto anche con ad esempio sedo tail, ma penso che ci sia un qualche tipo di bellezza che dipende solo da bashe da gawkse stesso;)

Solo per divertimento: c'è la seguente soluzione piuttosto strana che reindirizza stdin e il programma attraverso i descrittori di file 3 e 4. Puoi anche creare un file temporaneo per lo script.

#!/bin/bash
exec 3>&0
exec <<-EOF 4>&0
BEGIN {print "HALLO"}
{print \$1}
EOF
gawk --re-interval -f <(cat 0>&4) 0>&3

Una cosa è fastidiosa in questo: la shell esegue l'espansione delle variabili sullo script, quindi devi citare ogni $ (come fatto nella seconda riga dello script) e probabilmente di più.

Per una soluzione portatile, usa awkinvece di gawk, invoca la shell BOURNE standard ( /bin/sh) con il tuo shebang e invoca awkdirettamente, passando il programma sulla riga di comando come un here document piuttosto che tramite stdin:

#!/bin/sh
gawk --re-interval <<<EOF
PROGRAM HERE
EOF

Nota: nessun -fargomento per awk. Ciò lascia a stdindisposizione per awkleggere l'input da. Supponendo che tu abbia gawkinstallato e sul tuo PATH, questo ottiene tutto ciò che penso stavi cercando di fare con il tuo esempio originale (supponendo che volessi che il contenuto del file fosse lo script awk e non l'input, che penso che il tuo approccio shebang lo avrebbe trattato come ).