Return to append.c CVS log

Up to [CSRG BSD Unix] / 43BSD / ucb / lisp / utils

Annotation of 43BSD/ucb/lisp/utils/append.c, revision 1.1.1.1

1.1       root        1: static char *rcsid =
                      2:   "$Header: append.c,v 1.2 84/01/22 04:07:25 sklower Exp $";
                      3:   
                      4: /*
                      5:  * append:  append a tail to a list of roots or prepend a head to a list
                      6:  *         of tails. 
                      7:  * use:
                      8:  *     append tail root1 root2 ... rootn
                      9:  * result:
                     10:  *     root1tail root2tail ... rootntail
                     11:  * or
                     12:  *     append -p root tail1 tail2 ... tailn
                     13:  *  result:
                     14:  *     roottail1 roottail2 ... roottailn
                     15:  *
                     16:  * or
                     17:  *     append -s xtail root1xoldt root2xoldt ...
                     18:  *  result:
                     19:  *     root1xtail  root2xtail ...
                     20:  *   that is, each root is tested for the presence of 'x', the first character
                     21:  *   in the tail.  If it is present, then all characters beyond it are thrown
                     22:  *   away before merging.  This is useful for things like
                     23:  *     append -s .c foo.o bar.o baz.o =>> foo.c bar.c baz.c
                     24:  *
                     25:  * Useful in Makefiles due to the lack of such facilities in make.
                     26:  * 
                     27: */
                     28: #include <stdio.h>
                     29: #include "lconf.h"
                     30: #include "config.h"
                     31: #if os_unix_ts || os_masscomp
                     32: #define rindex strrchr
                     33: #endif
                     34: 
                     35: char buffer[2000];     /* nice and big */
                     36: char *rindex();
                     37: 
                     38:  main(argc,argv)
                     39:  char **argv;
                     40:  {
                     41:      int i, base;
                     42:      int prepend = 0,
                     43:          append = 0,
                     44:         strip = 0;
                     45:      char stripchar;
                     46:      char *chp;
                     47:      
                     48:      if(argc <= 2)
                     49:      {
                     50:         fprintf(stderr,"use: append tail root1 root2 ... rootn\n");
                     51:         exit(1);
                     52:      }
                     53:      if(argv[1][0] == '-')
                     54:      {
                     55:         switch(argv[1][1])
                     56:         {
                     57:             case 'p' : prepend = 1;
                     58:                        break;
                     59:             case 's' : strip = 1;
                     60:                        append = 1;
                     61:                        stripchar = argv[2][0]; /* first char of tail */
                     62:                        break;
                     63:             default:  fprintf(stderr,"append: illegal switch %s\n",argv[1]);
                     64:                        exit(1);
                     65:         }
                     66:         base = 2;
                     67:      }
                     68:      else {
                     69:         append = 1;
                     70:         base = 1;
                     71:      }
                     72:      
                     73:      for(i = base +1; i < argc ; i++)
                     74:      {
                     75:         if(append)
                     76:         {
                     77:            strcpy(buffer,argv[i]);
                     78:            if(strip && (chp = rindex(buffer,stripchar)))
                     79:            {
                     80:                *chp = '\0';
                     81:            }
                     82:            strcat(buffer,argv[base]);
                     83:         }
                     84:         else {
                     85:             strcpy(buffer,argv[base]);
                     86:             strcat(buffer,argv[i]);
                     87:         }
                     88:         printf("%s ",buffer);
                     89:      }
                     90:      printf("\n");
                     91:      exit(0);
                     92:  }
                     93:  

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