Come si scrive un programma di filtro in C?

Question

Poiché UNIX ha tutti quei meravigliosi programmi di filtro (come grep, sed, tr e così via), qual è il modo più semplice per scrivere uno di quelli in C standard?

da filtro, intendo un programma che legge l'input standard, esegue alcune manipolazione dei dati, e quindi lo scrive sullo standard output. Questo è utile nella costruzione di tubazioni di comandi, ad ogni esecuzione di qualche ulteriore manipolazione dei dati, ad esempio:

grep xyzzy input.file | tr '[A-Z]' '[a-z]' | sed 's/plugh/PLUGH/g' 

(ciascuno dei simboli di pipe | collega l'uscita standard del comando precedente nell'ingresso standard della avanti, da qui la metafora del gasdotto).

Diciamo che avevo bisogno di uno che ha convertito tutti i caratteri maiuscoli in caratteri minuscoli. E, sì, mi rendo conto che questo particolare problema può essere risolto con l'UNIX:

tr '[A-Z]' '[a-z]' 

ma questo è solo un esempio .

Quello che sto in realtà dopo è il più semplice codice sorgente C standard per fare un tale filtro.

Answer 1

Si potrebbe utilizzare getline come descritto da @hroptatyr, ma si può fare qualcosa di molto più semplice:

#include <stdio.h> 
#include <ctype.h> 
int main(void) { 
    int c; 
    while ((c = getchar()) != EOF) 
     putchar(tolower(c)); 
    return 0; 
} 

Answer 2

In pseudo-codice:

do 
    line = read(stdin); 
    filter(line); 
    print(line); 
until no_more_lines 

nel codice reale:

char *line = NULL; 
size_t len = 0U; 
ssize_t n; 

while ((n = getline(&line, &len, stdin)) >= 0) { 
     /* LINE is of length N, filter it */ 
     filter(line, n); 
     /* print it */ 
     fputs(line, stdout); 
} 
free(line); 

e filter() assomiglia:

static void filter(char *line, size_t length) 
{ 
     while ((*line++ = tolower(*line))); 
} 

Edit: Non dimenticare di definire _POSIX_C_SOURCE >= 200809L o _XOPEN_SOURCE >= 700 . E non dimenticate di includere stdio.h per getline() e ctype.h per tolower().

Answer 3

programma un "filtro" è semplicemente un programma che legge dal flusso di input standard (stdin) e scrive sul flusso di output standard (stdout). Prima di scrivere i dati letti, i dati vengono in genere trasformati in qualche modo (se non si preforma alcuna trasformazione o filtraggio, in pratica si scrive un programma cat che stampa solo ciò che gli viene dato). La potenza del programma di filtraggio deriva dal fatto che non dettano da dove proviene il loro input o dove sta andando l'output. Invece, è compito del chiamante del programma fornire i canali di input/output.

Il nucleo di un programma di filtro potrebbe essere simile a questo (è possibile utilizzare questo come modello per i propri programmi di filtro):

#include <stdio.h> 

int filter(FILE *input, FILE *output); 

int main(void) 
{ 
    const int retval = filter(stdin, stdout); 
    fflush(stdout); 
    return retval; 
} 

Questo è tutto. Il lavoro effettivo viene svolto da una funzione filter che esegue la trasformazione desiderata.Per esempio, ecco un semplice programma che legge i caratteri dal file di input, li trasforma in minuscolo, e poi li stampa per il file di output:

#include <stdio.h> 
#include <ctype.h> /* for tolower */ 

int filter(FILE *input, FILE *output) 
{ 
    while (!feof(input)) { 
     if (ferror(input)) { 
      return 1; 
     } 
     fputc(tolower(fgetc(input)), output); 
    } 
    return 0; 
} 

int main(void) 
{ 
    const int retval = filter(stdin, stdout); 
    fflush(stdout); 
    return retval; 
} 

Se si compila e si esegue questo programma, sarà semplicemente sedersi lì e attendere pazientemente i dati da leggere dal file di input standard stdin. Questo file è solitamente associato alla console, il che significa che devi inserire alcuni dati a mano. Tuttavia, le shell di comando implementano una funzione chiamata pipe che consente di inviare l'output di un comando all'input di un altro. Ciò consente di comporre più programmi in un pipeline per formare potenti comandi.

Ecco come potremmo usare il nostro programma di filtro (supponendo di aver chiamato il conseguente binario lower):

$ echo Hello | lower 
hello 
$ 

Poiché il nostro programma di filtro non definisce in cui i dati da leggere è venuta da, possiamo combinare con tutti i tipi di programmi che producono output su stdout. Per esempio, ecco come si può ottenere un intero file in minuscolo (è possibile utilizzare type su macchine Windows, invece):

$ cat myfile.txt 
Hello, World! 
This is a simple test. 

$ cat myfile.txt | lower 
hello, world! 
this is a simple test. 

$ 

Answer 4

L1: 
mov dx,081 
mov cx,1 
mov bx,0 
mov ax,03f00 
int 021 
cmp ax,0 
je L2 
cmp b[081],'a' 
jb L3 
cmp b[081],'z' 
ja L3 
sub b[081],020 
L3: 
mov dx,081 
mov cx,1 
mov bx,1 
mov ax,04000 
int 021 
jmp L1 
L2: 
mov ax,04c00 
int 021 

; Example in A86 Assembler see eji.com for A86/D86