misc/parsarg.c

   1 /*
   2 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
   3 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
   4 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
   5 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
   6 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
   7 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
   8 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
   9 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  10 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
  11 COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  12 */
  13
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <string.h>
  17 #include <dos.h>
  18
  19 #include "parsarg.h"
  20
  21 #define ARGBUF_SIZE 500
  22 #define MAX_ARGS 100
  23
  24 char arg_buf[ARGBUF_SIZE];
  25 char *ab_ptr=arg_buf;
  26
  27 void perror_exit(int n,char *s)
  28 {
  29         perror(s);
  30         exit(n);
  31 }
  32
  33 void verror(char *s,void *first_arg_ptr)
  34 {
  35         fprintf(stderr,"Error: ");
  36         vfprintf(stderr,s,first_arg_ptr);
  37         fprintf(stderr,"\n");
  38 }
  39
  40 void error_exit(int ret_code,char *s,...)
  41 {
  42         verror(s,((char *) &s)+sizeof(s));      /* addr of next parm on stack */
  43         exit(ret_code);
  44 }
  45
  46 void parse_args(int argc,char **argv,void (*handler_func)(char *arg),int flags)
  47 {
  48
  49         for (;argc--;argv++) {
  50                 if (**argv=='@') {                      /* read args from file */
  51                         char *arg_ptrs[MAX_ARGS];
  52                         int arg_count;
  53                         FILE *argfile;
  54                         int len;
  55                         char *p=ab_ptr,c;
  56
  57                         if ((argfile=fopen(*argv+1,"rt"))==0) perror_exit(10,*argv+1);
  58                         if ((len=fread(ab_ptr,1,ARGBUF_SIZE-((int) (ab_ptr-arg_buf)),argfile))==ARGBUF_SIZE-(ab_ptr-arg_buf)) error_exit(20,"Argument buffer not big enough\n");
  59                         fclose(argfile);
  60                         ab_ptr[len++]=0;                /* write terminating null */
  61
  62                         /* remove comments */
  63
  64                         while ((p=strchr(ab_ptr,';'))!=NULL) {
  65                                 char *p2=strchr(p,'\n');
  66
  67                                 if (p2) {       /* found cr */
  68                                         strcpy(p,p2);   /* copy over comment */
  69                                         len = strlen(ab_ptr);
  70                                 }
  71                                 else {          /* no cr, end of string */
  72                                         *p=0;
  73                                         len = (int) (p-ab_ptr);
  74                                 }
  75                         }
  76                         ab_ptr[len]=0;          /* write terminating null */
  77
  78                         while (!ab_ptr[len-1]) len--;   /* back up over terminating nulls */
  79                         p=ab_ptr;
  80
  81
  82                         for (arg_count=0;p<ab_ptr+len;) {
  83                                 while (p<ab_ptr+len && ((c=*p)==' ' || c=='\t' || c=='\n')) p++;
  84                                 if (p<ab_ptr+len) {     /* found parm? */
  85                                         arg_ptrs[arg_count++]=p;
  86                                         if (arg_count>=MAX_ARGS) error_exit(10,"Too many args");
  87                                         while (p<ab_ptr+len && !((c=*p)==' ' || c=='\t' || c=='\n')) p++;
  88                                         *p++=0;
  89                                 }
  90                         }
  91                         ab_ptr+=len;
  92                         parse_args(arg_count,arg_ptrs,handler_func,flags);
  93                 }
  94                 else
  95                         if (flags&PA_EXPAND && (**argv != '-')) {
  96                                 struct find_t ffblk;
  97                                 char drive[_MAX_DRIVE],dir[_MAX_DIR];
  98                                 char filename[_MAX_DRIVE+_MAX_DIR+13],*nptr;
  99                                 int done;
 100
 101                                 _splitpath(*argv,drive,dir,NULL,NULL);          //get path
 102                                 strcpy(filename,drive);
 103                                 strcat(filename,dir);
 104                                 nptr = filename + strlen(filename);                     //point at name part
 105
 106                                 done = _dos_findfirst(*argv,0,&ffblk);
 107
 108                                 if (done) handler_func(*argv);
 109
 110                                 else while (!done) {
 111
 112                                         strcpy(nptr,ffblk.name);        //copy name after path
 113
 114                                         handler_func(filename);
 115
 116                                         done = _dos_findnext(&ffblk);
 117
 118                                 }
 119
 120                         }
 121                         else
 122                                 handler_func(*argv);
 123
 124         }
 125
 126 }
 127
 128