¿Cómo escribo un programa de filtro en C?

Question

Dado que UNIX tiene todos esos maravillosos programas similares a filtros (como grep, sed, tr, etc.), ¿cuál es la forma más fácil de escribir uno de esos en C estándar?

Por filtro, me refiero a un programa que lee la entrada estándar, realiza una cierta manipulación de los datos, y luego lo escribe en la salida estándar. Esto es útil en la construcción de tuberías de comandos, con cada realización de alguna manipulación adicional de los datos, tales como:

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

(cada uno de los | símbolos de tubería conecta la salida estándar de la orden anterior a la entrada estándar de la a continuación, de ahí la metáfora de la tubería).

Digamos que necesitaba una que convirtiera todos los caracteres en mayúsculas a minúsculas. Y, sí, me di cuenta de esto en particular problema puede ser resuelto con el UNIX:

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

pero eso es sólo un ejemplo .

Lo que realmente busco es el código fuente C más simple para hacer un filtro de este tipo.

Answer 1

Usted podría utilizar getline como se describe por @hroptatyr, pero se puede hacer algo mucho más simple:

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

Answer 2

En pseudo-código:

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

En código real:

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); 

y filter() parece:

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

Editar: No se olvide de definir _POSIX_C_SOURCE >= 200809L o _XOPEN_SOURCE >= 700 . Y no se olvide de incluir stdio.h para getline() y ctype.h para tolower().

Answer 3

Un programa de "filtro" es simplemente un programa que lee del flujo de entrada estándar (stdin) y escribe en la corriente de salida estándar (stdout). Antes de escribir los datos leídos, los datos generalmente se transforman de alguna manera (si no realiza ninguna transformación o filtrado, básicamente escribió un programa cat que simplemente imprime lo que se le da). El poder del programa de filtro proviene del hecho de que no dictan de dónde proviene su entrada ni a dónde va la salida. En cambio, depende de quien llama el programa proporcionar los canales de entrada/salida.

El núcleo de un programa de filtro podría ser algo como esto (se puede utilizar esto como una plantilla para sus propios programas de filtro):

#include <stdio.h> 

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

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

Eso es todo. El trabajo real se realiza mediante una función filter que realiza la transformación que desea.Por ejemplo, aquí hay un sencillo programa que lee los caracteres del archivo de entrada, los convierte a minúsculas, y luego los imprime el archivo de salida:

#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; 
} 

Si se compila y ejecuta este programa, que va simplemente sentarse allí y espere pacientemente a que se lean los datos del archivo de entrada estándar stdin. Este archivo generalmente está vinculado a la consola, lo que significa que debe ingresar algunos datos a mano. Sin embargo, las shells de comando implementan una característica llamada pipes que le permite canalizar la salida de un comando a la entrada de otro. Esto permite componer múltiples programas en un pipeline para formar comandos potentes.

Así es como podríamos utilizar nuestro programa de filtro (suponiendo que llamó la resultante binario lower):

$ echo Hello | lower 
hello 
$ 

Dado que nuestro programa de filtro no define que los datos sean leídos está viniendo, podemos combinar con todo tipo de programas produciendo salida en stdout. Por ejemplo, aquí es cómo se puede obtener un archivo completo en minúscula (se puede utilizar type en máquinas Windows en su lugar):

$ 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