trunk/commandLine/commandLine.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define STR_BUFFER_SIZE 500

// ******************************************************* 
// Uncomment the following two tyedefs to support multiple 
// input files
// *******************************************************

typedef struct{
  char fileName[STR_BUFFER_SIZE];
  FILE* filePtr;
} fileStruct;

typedef struct linkedNameTag {
  char name[STR_BUFFER_SIZE];
  struct linkedNameTag* next;
} linkedName;

// *******************************************************
// end multiple file support
// *******************************************************


char *programName; /*the name of the program */
void usage(void);

int main(argC, argV)
     int argC;
     char *argV[];
{
  int i,j; // loop counters

  char* outPrefix; // the output prefix

  char* conversionCheck;
  int conversionError;
  int optionError;

  char currentFlag; // used in parsing the flags
  int done = 0; // multipurpose boolean
  int havePrefix; // boolean for the output prefix

  int flag1;
  char flag1Arg1[STR_BUFFER_SIZE];
  char flag1Arg2[STR_BUFFER_SIZE];
  int flag2;
  double flag2Val;
  int flag3;
  int rFlag;
  int iFlag, iVal;
  
  // **********************************************************
  // to support single or multiple input files, uncomment the 
  // appropriate declarations
  // **********************************************************
  // single:

  char* inName;
  FILE* inFile;

  // ***********************************************************
  // multiple: 
  
  fileStruct* inputArray;
  linkedName* headName;
  linkedName* currentName;
  int nInputs;
  
  // end input file declarations
  // ***********************************************************
  
  
  // intialize default values
  
  
  // ********************************************
  // single input:
  
  inName = NULL;
  inFile = NULL;
  
  // *********************************************
  // multiple input:
  
  nInputs = 0;
  inputArray = NULL;
  headName = NULL;
  currentName = NULL;

  // end file initialization
  // **********************************************


  outPrefix = NULL;

  conversionError = 0;
  optionError = 0;
 
  havePrefix = 0;
  flag1 = 0;
  flag2 = 0;
  flag3 = 0;
  rFlag = 0;
  iFlag = 0;

  
  iVal = 0;
  

  // here we set the name of the program need by the usage message
  programName = argV[0];
  

  for( i = 1; i < argC; i++){
    
    if(argV[i][0] =='-'){

      // parse the option
      
      if(argV[i][1] == '-' ){

        // parse long word options
        
        if( !strcmp( argV[i], "--flag1" ) ){
          flag1 = 1; // set flag1 to true
          
          i++;
          strcpy( flag1Arg1, argV[i] );
          i++;
          strcpy( flag1Arg2, argV[i] );
        }

        else if( !strcmp( argV[i], "--flag2" ) ){
          flag2 = 1; // set the flag2 to true;
          
          i++;
          flag2Val = strtod( argV[i], &conversionCheck );
          if( conversionCheck == argV[i] ) conversionError = 1;
          if( *conversionCheck != '\0' ) conversionError = 1;
          
          if( conversionError ){
            
            fprintf( stderr,
                     "Error converting \"%s\" to a double\n", argV[i] );
            usage();
            exit(0);
          }
          
        }

        else if( !strcmp( argV[i], "--flag3") ){
          flag3 = 1; // set flag3 to be true
          
        }
        
        // anything else is an error

        else{
          fprintf( stderr, 
                   "Invalid option \"%s\"\n", argV[i] );
          usage();
          exit(0);
        }
      }
      
      else{
        
        // parse single character options
        
        done =0;
        j = 1;
        currentFlag = argv[i][j];
        while( (current_flag != '\0') && (!done) ){
          
          switch(current_flag){

          case 'h':
            // -h => give the usage help message
            
            usage();
            exit(0);
            break;

          case 'o':
            // -o <prefix> => the output prefix.

            j++;
            currentFlag = argV[i][j];
              
            if( currentFlag != '\0' ) optionError = 1;
            
            if( optionError ){
              fprintf( stderr, 
                       "\n"
                       "The -o flag should end an option sequence.\n"
                       "   example: -ro <outname> *NOT* -or <outname>\n" );
              usage();
              exit(0);
            }
              
            i++;
            outPrefix = argV[i];
            if( outPrefix[0] == '-' ) optionError = 1;
                
            if( optionError ){
              fprintf( stderr, 
                       "\n"
                       "\"%s\" is not a valid out prefix/name.\n"
                       "Out prefix/name should not begin with a dash.\n",
                       outPrefix );
              usage();
              exit(0);
            }
            
            havePrefix = 1;
            done = 1;
            break;


          case 'r':
            // the r flag

            rFlag = 1; // set rflag to true
            break;

          case 'i':
            // -i <int>    set <int> to the iVal

            iFlag = 1; // set iFlag to true
            j++;
            currentFlag = argV[i][j];
              
            if( currentFlag != '\0' ) optionError = 1;
            
            if( optionError ){
              fprintf( stderr, 
                       "\n"
                       "The -i flag should end an option sequence.\n"
                       "   example: -ri <int> *NOT* -ir <int>\n" );
              usage();
              exit(0);
            }

            i++;
            iVal = (int)strtol( argV[i], &conversionCheck, 10 );
            if( conversionCheck == argV[i] ) conversionError = 1;
            if( *conversionCheck != '\0' ) conversionError = 1;
            
            if( conversionError ){
              
              fprintf( stderr,
                       "Error converting \"%s\" to a int\n", argV[i] );
              usage();
              exit(0);
            }
            
            done = 1;

            break;

          default:

            (void)fprintf(stderr, 
                          "\n"
                          "Bad option \"-%c\"\n", current_flag);
            usage();
          }
          j++;
          current_flag = argv[i][j];
        }
      }
    }

    else{
      
      
      // ********************************************************
      // for only a single input file, leave this as it is.
      // ********************************************************
      
      if( inName != NULL ){
        fprintf( stderr, 
                 "\n"
                 "Error at \"%s\", program does not currently support\n"
                 "more than one input file.\n"
                 "\n",
                 argV[i]);
        usage();
        exit(0);
      }
      
      inName = argvV[i];
      
      // *************************************************************
      
      
      // ************************************************************
      // To support more than one input file, uncomment the following
      // section.
      // ************************************************************

      
      nInputs++;
      currentName = (linkedName *) malloc( sizeof( linkedName ) );
      if( currentName == NULL ){
        fprintf( stderr, 
                 "\n"
                 "Ran out of memory\n" );
        exit(0);
      }
      
      strcpy( currentName->name, argV[i] );
      
      currentName->next = headName;
      headName = currentName;
      
      // **********************************************************
      // end multiple input files
      // **********************************************************
    }
  }


  // initialize the input file(s)

  // ***********************************************************
  // single file:
  
  if(inName == NULL){
    
    fprintf( stderr,
             "\n"
             "Error, no input file was given\n");
    usage();
    exit(0);
  }

  inFile = fopen( inName, "r" );
  if( inFile == NULL ){
    
    fprintf( stderr,
             "\n"
             "Error trying to open \"%s\" for reading\n",
             inName );
    exit(0);
  }

  // **************************************************************
  // multiple files:
  
  if( !nInputs ){
    
    fprintf( stderr,
             "\n"
             "Error, no input files were given\n");
    usage();
    exit(0);
  }

  // create the input array

  inputArray = (fileStruct *) calloc( nInputs, sizeof( fileStruct ) );
  if( inputArray == NULL ){
    fprintf(stderr,
            "\n"
            "Ran out of memory\n" );
    exit(0);
  }
  
  j = nInputs - 1;
  currentName = headName;
  while( currentName != NULL ){
    
    strcopy( inputArray[j].fileName, currentName->name );
    inputArray[i].filePtr = NULL;
    j--;
    currentName = currentName->next;
  }

  // delete linked list
  
  while( headName != NULL ){
    
    currentName = headName;
    headName = currentName->next;

    free( currentName );
  }
  

  // open the files for reading
  
  for(i=0; i<nInputs; i++){

    inputArray[i].filePtr = fopen( inName, "r" );
    if( inputArray[i].filePtr == NULL ){
      
      fprintf( stderr,
               "\n"
               "Error trying to open \"%s\" for reading\n",
               inputArray[i].fileName );
      exit(0);
    }

    //read and do stuff here

  }
  
  // *************************************************************
  // end file opening
  // *************************************************************
  

  //  or read files here
  

  // close files when we are done.

  // ***********************************************************
  // single:
  
  fclose( inFile );
  
  // *************************************************************
  // multiple:

  for( i=0; i<nInputs; i++){
    
    fclose( inputArray[i].filePtr );
  }

  free( inputArray ); // free the input Array if we are done;
  inputArray = NULL;

  // ************************************************************
  // end file closing
  // ************************************************************

}


/***************************************************************************
 * prints out the usage for the command line arguments, then exits.
 ***************************************************************************/

void usage(){
  (void)fprintf(stdout, 
                "The proper usage is: %s [options] <input_file>\n"
                "\n"
                "Options:\n"
                "\n"
                "   short:\n"
                "   ------\n"
                "   -h              Display this message\n"
                "   -o <name>       The output name/prefix\n"
                "   -r              the r flag\n"
                "   -i <int>        set number to <#>\n"
                
                "\n"
                "   long:\n"
                "   -----\n"
                "   --flag1 <arg1> <arg2>     does flag 1 for arg1 and 2\n"
                "   --flag2 <double>          does flag 2 for double\n"
                "   --flag3                   does flag 3\n"
                
                "\n"
                "\n",
                program_name)
  exit(0);
}
Revision:	521
Committed:	Tue May 6 19:42:41 2003 UTC (21 years, 2 months ago) by mmeineke
Content type:	text/plain
File size:	9859 byte(s)
Log Message:	fleshed out all of the ideas we wanted to see in this interface. it is still not yet debugged.
#	User	Rev	Content
1	mmeineke	518	#include <stdio.h>
2			#include <stdlib.h>
3			#include <string.h>
4
5	mmeineke	521	#define STR_BUFFER_SIZE 500
6	mmeineke	518
7	mmeineke	521	// *******************************************************
8			// Uncomment the following two tyedefs to support multiple
9			// input files
10			// *******************************************************
11
12			typedef struct{
13			char fileName[STR_BUFFER_SIZE];
14			FILE* filePtr;
15			} fileStruct;
16
17			typedef struct linkedNameTag {
18			char name[STR_BUFFER_SIZE];
19			struct linkedNameTag* next;
20			} linkedName;
21
22			// *******************************************************
23			// end multiple file support
24			// *******************************************************
25
26
27			char programName; /the name of the program */
28	mmeineke	518	void usage(void);
29
30	mmeineke	521	int main(argC, argV)
31			int argC;
32			char *argV[];
33	mmeineke	518	{
34			int i,j; // loop counters
35
36	mmeineke	521	char* outPrefix; // the output prefix
37
38			char* conversionCheck;
39			int conversionError;
40			int optionError;
41
42			char currentFlag; // used in parsing the flags
43	mmeineke	518	int done = 0; // multipurpose boolean
44	mmeineke	521	int havePrefix; // boolean for the output prefix
45	mmeineke	518
46	mmeineke	521	int flag1;
47			char flag1Arg1[STR_BUFFER_SIZE];
48			char flag1Arg2[STR_BUFFER_SIZE];
49			int flag2;
50			double flag2Val;
51			int flag3;
52			int rFlag;
53			int iFlag, iVal;
54	mmeineke	520
55	mmeineke	521	// **********************************************************
56			// to support single or multiple input files, uncomment the
57			// appropriate declarations
58			// **********************************************************
59			// single:
60
61			char* inName;
62			FILE* inFile;
63
64			// ***********************************************************
65			// multiple:
66
67			fileStruct* inputArray;
68			linkedName* headName;
69			linkedName* currentName;
70			int nInputs;
71
72			// end input file declarations
73			// ***********************************************************
74
75
76
77			// intialize default values
78
79
80			// ********************************************
81			// single input:
82
83			inName = NULL;
84			inFile = NULL;
85
86			// *********************************************
87			// multiple input:
88
89			nInputs = 0;
90			inputArray = NULL;
91			headName = NULL;
92			currentName = NULL;
93
94			// end file initialization
95			// **********************************************
96
97
98
99			outPrefix = NULL;
100
101			conversionError = 0;
102			optionError = 0;
103
104			havePrefix = 0;
105			flag1 = 0;
106			flag2 = 0;
107			flag3 = 0;
108			rFlag = 0;
109			iFlag = 0;
110
111
112			iVal = 0;
113
114
115
116	mmeineke	520	// here we set the name of the program need by the usage message
117	mmeineke	521	programName = argV[0];
118	mmeineke	520
119	mmeineke	518
120	mmeineke	521	for( i = 1; i < argC; i++){
121	mmeineke	518
122	mmeineke	521	if(argV[i][0] =='-'){
123	mmeineke	518
124			// parse the option
125
126	mmeineke	521	if(argV[i][1] == '-' ){
127	mmeineke	518
128			// parse long word options
129
130	mmeineke	521	if( !strcmp( argV[i], "--flag1" ) ){
131			flag1 = 1; // set flag1 to true
132
133	mmeineke	518	i++;
134	mmeineke	521	strcpy( flag1Arg1, argV[i] );
135	mmeineke	518	i++;
136	mmeineke	521	strcpy( flag1Arg2, argV[i] );
137	mmeineke	518	}
138
139	mmeineke	521	else if( !strcmp( argV[i], "--flag2" ) ){
140			flag2 = 1; // set the flag2 to true;
141
142	mmeineke	518	i++;
143	mmeineke	521	flag2Val = strtod( argV[i], &conversionCheck );
144			if( conversionCheck == argV[i] ) conversionError = 1;
145			if( *conversionCheck != '\0' ) conversionError = 1;
146
147			if( conversionError ){
148
149			fprintf( stderr,
150			"Error converting \"%s\" to a double\n", argV[i] );
151			usage();
152			exit(0);
153			}
154
155	mmeineke	518	}
156
157	mmeineke	521	else if( !strcmp( argV[i], "--flag3") ){
158			flag3 = 1; // set flag3 to be true
159
160	mmeineke	518	}
161
162	mmeineke	521	// anything else is an error
163	mmeineke	518
164			else{
165			fprintf( stderr,
166	mmeineke	521	"Invalid option \"%s\"\n", argV[i] );
167	mmeineke	518	usage();
168	mmeineke	521	exit(0);
169	mmeineke	518	}
170			}
171
172			else{
173
174			// parse single character options
175
176			done =0;
177			j = 1;
178	mmeineke	521	currentFlag = argv[i][j];
179	mmeineke	518	while( (current_flag != '\0') && (!done) ){
180
181			switch(current_flag){
182
183	mmeineke	521	case 'h':
184			// -h => give the usage help message
185
186			usage();
187			exit(0);
188			break;
189
190	mmeineke	518	case 'o':
191			// -o <prefix> => the output prefix.
192
193	mmeineke	521	j++;
194			currentFlag = argV[i][j];
195
196			if( currentFlag != '\0' ) optionError = 1;
197
198			if( optionError ){
199			fprintf( stderr,
200			"\n"
201			"The -o flag should end an option sequence.\n"
202			" example: -ro <outname> NOT -or <outname>\n" );
203			usage();
204			exit(0);
205			}
206
207	mmeineke	518	i++;
208	mmeineke	521	outPrefix = argV[i];
209			if( outPrefix[0] == '-' ) optionError = 1;
210
211			if( optionError ){
212			fprintf( stderr,
213			"\n"
214			"\"%s\" is not a valid out prefix/name.\n"
215			"Out prefix/name should not begin with a dash.\n",
216			outPrefix );
217			usage();
218			exit(0);
219			}
220
221			havePrefix = 1;
222	mmeineke	518	done = 1;
223			break;
224
225	mmeineke	521
226	mmeineke	518
227			case 'r':
228	mmeineke	521	// the r flag
229	mmeineke	518
230	mmeineke	521	rFlag = 1; // set rflag to true
231	mmeineke	518	break;
232
233	mmeineke	521	case 'i':
234			// -i <int> set <int> to the iVal
235	mmeineke	518
236	mmeineke	521	iFlag = 1; // set iFlag to true
237			j++;
238			currentFlag = argV[i][j];
239
240			if( currentFlag != '\0' ) optionError = 1;
241
242			if( optionError ){
243			fprintf( stderr,
244			"\n"
245			"The -i flag should end an option sequence.\n"
246			" example: -ri <int> NOT -ir <int>\n" );
247			usage();
248			exit(0);
249			}
250
251			i++;
252			iVal = (int)strtol( argV[i], &conversionCheck, 10 );
253			if( conversionCheck == argV[i] ) conversionError = 1;
254			if( *conversionCheck != '\0' ) conversionError = 1;
255
256			if( conversionError ){
257
258			fprintf( stderr,
259			"Error converting \"%s\" to a int\n", argV[i] );
260			usage();
261			exit(0);
262			}
263
264			done = 1;
265
266	mmeineke	518	break;
267
268			default:
269
270	mmeineke	521	(void)fprintf(stderr,
271			"\n"
272			"Bad option \"-%c\"\n", current_flag);
273	mmeineke	518	usage();
274			}
275			j++;
276			current_flag = argv[i][j];
277			}
278			}
279			}
280
281			else{
282
283	mmeineke	521
284			// ********************************************************
285			// for only a single input file, leave this as it is.
286			// ********************************************************
287
288			if( inName != NULL ){
289	mmeineke	518	fprintf( stderr,
290	mmeineke	521	"\n"
291	mmeineke	518	"Error at \"%s\", program does not currently support\n"
292			"more than one input file.\n"
293			"\n",
294	mmeineke	521	argV[i]);
295	mmeineke	518	usage();
296	mmeineke	521	exit(0);
297	mmeineke	518	}
298	mmeineke	521
299			inName = argvV[i];
300
301			// *************************************************************
302
303
304			// ************************************************************
305			// To support more than one input file, uncomment the following
306			// section.
307			// ************************************************************
308	mmeineke	518
309	mmeineke	521
310			nInputs++;
311			currentName = (linkedName *) malloc( sizeof( linkedName ) );
312			if( currentName == NULL ){
313			fprintf( stderr,
314			"\n"
315			"Ran out of memory\n" );
316			exit(0);
317			}
318
319			strcpy( currentName->name, argV[i] );
320
321			currentName->next = headName;
322			headName = currentName;
323
324			// **********************************************************
325			// end multiple input files
326			// **********************************************************
327	mmeineke	518	}
328			}
329
330	mmeineke	521
331
332
333			// initialize the input file(s)
334
335			// ***********************************************************
336			// single file:
337
338			if(inName == NULL){
339
340			fprintf( stderr,
341			"\n"
342			"Error, no input file was given\n");
343	mmeineke	518	usage();
344	mmeineke	521	exit(0);
345	mmeineke	518	}
346
347	mmeineke	521	inFile = fopen( inName, "r" );
348			if( inFile == NULL ){
349
350			fprintf( stderr,
351			"\n"
352			"Error trying to open \"%s\" for reading\n",
353			inName );
354			exit(0);
355			}
356	mmeineke	518
357	mmeineke	521	// **************************************************************
358			// multiple files:
359
360			if( !nInputs ){
361
362			fprintf( stderr,
363			"\n"
364			"Error, no input files were given\n");
365			usage();
366			exit(0);
367			}
368
369			// create the input array
370
371			inputArray = (fileStruct *) calloc( nInputs, sizeof( fileStruct ) );
372			if( inputArray == NULL ){
373			fprintf(stderr,
374			"\n"
375			"Ran out of memory\n" );
376			exit(0);
377			}
378
379			j = nInputs - 1;
380			currentName = headName;
381			while( currentName != NULL ){
382
383			strcopy( inputArray[j].fileName, currentName->name );
384			inputArray[i].filePtr = NULL;
385			j--;
386			currentName = currentName->next;
387			}
388
389			// delete linked list
390
391			while( headName != NULL ){
392
393			currentName = headName;
394			headName = currentName->next;
395
396			free( currentName );
397			}
398
399
400			// open the files for reading
401
402			for(i=0; i<nInputs; i++){
403
404			inputArray[i].filePtr = fopen( inName, "r" );
405			if( inputArray[i].filePtr == NULL ){
406
407			fprintf( stderr,
408			"\n"
409			"Error trying to open \"%s\" for reading\n",
410			inputArray[i].fileName );
411			exit(0);
412			}
413
414			//read and do stuff here
415
416			}
417
418			// *************************************************************
419			// end file opening
420			// *************************************************************
421
422
423
424			// or read files here
425
426
427
428
429
430			// close files when we are done.
431
432			// ***********************************************************
433			// single:
434
435			fclose( inFile );
436
437			// *************************************************************
438			// multiple:
439
440			for( i=0; i<nInputs; i++){
441
442			fclose( inputArray[i].filePtr );
443			}
444
445			free( inputArray ); // free the input Array if we are done;
446			inputArray = NULL;
447
448			// ************************************************************
449			// end file closing
450			// ************************************************************
451
452	mmeineke	518	}
453
454
455			/***************************************************************************
456			* prints out the usage for the command line arguments, then exits.
457			***************************************************************************/
458
459			void usage(){
460			(void)fprintf(stdout,
461	mmeineke	520	"The proper usage is: %s [options] <input_file>\n"
462	mmeineke	518	"\n"
463			"Options:\n"
464			"\n"
465			" short:\n"
466			" ------\n"
467			" -h Display this message\n"
468	mmeineke	520	" -o <name> The output name/prefix\n"
469			" -r the r flag\n"
470	mmeineke	521	" -i <int> set number to <#>\n"
471	mmeineke	518
472			"\n"
473			" long:\n"
474			" -----\n"
475	mmeineke	520	" --flag1 <arg1> <arg2> does flag 1 for arg1 and 2\n"
476	mmeineke	521	" --flag2 <double> does flag 2 for double\n"
477	mmeineke	520	" --flag3 does flag 3\n"
478	mmeineke	518
479			"\n"
480			"\n",
481	mmeineke	521	program_name)
482			exit(0);
483	mmeineke	518	}