Return to xargs.c CVS log

Up to [MW Coherent from dump] / coherent / e / bin

Annotation of coherent/e/bin/xargs.c, revision 1.1.1.1

1.1       root        1: /* xargs -- quickie version of System V xargs(1): read a list of
                      2:  *     arguments from stdin, apply to the command which is
                      3:  *     the argument(s) of xargs
                      4:  */
                      5: 
                      6: #include <stdio.h>
                      7: 
                      8: char *cmdname;         /* should point to argv[0] */
                      9: 
                     10: char command[BUFSIZ];  /* command given to xargs */
                     11: char line[BUFSIZ];     /* current input line */        
                     12: char cmdbuf[BUFSIZ];   /* command + input lines */
                     13: 
                     14: main(argc, argv)
                     15:        int argc;
                     16:        char *argv[];
                     17: {
                     18:        char *gets();
                     19:        char *strcat(), *strcpy();
                     20: 
                     21:        cmdname = argv[0];
                     22: 
                     23:        /* skip (xargs) command name */
                     24: 
                     25:        argv++, argc--;
                     26: 
                     27:        /* construct command from arguments */
                     28: 
                     29:        strcpy(command, "exec");
                     30:        while (argc--) {
                     31:                (void) strcat(command, " ");
                     32:                (void) strcat(command, *argv++);
                     33:        }
                     34: 
                     35:        /* initialize for command execution loop */
                     36: 
                     37:        (void) strcpy(cmdbuf, command);
                     38: 
                     39:        /* here's where all the action is: read in arguments
                     40:         * from stdin, appending to the current command buffer
                     41:         * if next line would overflow command buffer, execute
                     42:         * command buffer and reinitialize
                     43:         */
                     44: 
                     45:        while (gets(line) != NULL) {
                     46: 
                     47:                /* the "+2" is for the blank and trailing null char */
                     48: 
                     49:                if (strlen(cmdbuf)+strlen(line)+2 > BUFSIZ) {
                     50:                        docmd(cmdbuf);
                     51:                        (void) strcpy(cmdbuf, command);
                     52:                }
                     53:                (void) strcat(cmdbuf, " ");
                     54:                (void) strcat(cmdbuf, line);
                     55:        }
                     56: 
                     57:        /* see if there is any left to do */
                     58: 
                     59:        if (strlen(cmdbuf) != strlen(command)) {
                     60:                docmd(cmdbuf);
                     61:        }
                     62: }
                     63: 
                     64: docmd(cmdbuf)
                     65: char *cmdbuf;
                     66: {
                     67:        return system(cmdbuf);
                     68: }
                     69: 
                     70: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.