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;

  flag2Val = 0.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++;
          if( i>=argC ){
            fprintf( stderr,
                     "\n"
                     "not enough arguments for flag1\n");
            usage();
            exit(0);
          }       
          strcpy( flag1Arg1, argV[i] );

          i++;
          if( i>=argC ){
            fprintf( stderr,
                     "\n"
                     "not enough arguments for flag1\n");
            usage();
            exit(0);
          }       
          strcpy( flag1Arg2, argV[i] );
        }

        else if( !strcmp( argV[i], "--flag2" ) ){
          flag2 = 1; // set the flag2 to true;
          
          i++;
          if( i>=argC ){
            fprintf( stderr,
                     "\n"
                     "not enough arguments for flag2\n");
            usage();
            exit(0);
          }       

          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( (currentFlag != '\0') && (!done) ){
          
          switch(currentFlag){

          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++;
            if( i>=argC ){
              fprintf( stderr,
                       "\n"
                       "not enough arguments for -o\n");
              usage();
              exit(0);
          }       

            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++;
            if( i>=argC ){
              fprintf( stderr,
                       "\n"
                       "not enough arguments for -i\n");
              usage();
              exit(0);
            }     

            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", currentFlag);
            usage();
          }
          j++;
          currentFlag = 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 = argV[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 ){
    
    strcpy( inputArray[j].fileName, currentName->name );
    inputArray[j].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( inputArray[i].fileName, "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 and do stuff 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, 
                "\n"
                "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",
                programName);
  exit(0);
}
Revision:	522
Committed:	Wed May 7 17:13:03 2003 UTC (21 years, 2 months ago) by mmeineke
Content type:	text/plain
File size:	10674 byte(s)
Log Message:	we have succesfully debugged the program. it is ready for use in any application we want.
#	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	mmeineke	522	// char* inName;
62			// FILE* inFile;
63	mmeineke	521
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	mmeineke	522	// inName = NULL;
84			// inFile = NULL;
85	mmeineke	521
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	mmeineke	522	flag2Val = 0.0;
112	mmeineke	521	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	522	if( i>=argC ){
135			fprintf( stderr,
136			"\n"
137			"not enough arguments for flag1\n");
138			usage();
139			exit(0);
140			}
141	mmeineke	521	strcpy( flag1Arg1, argV[i] );
142	mmeineke	522
143	mmeineke	518	i++;
144	mmeineke	522	if( i>=argC ){
145			fprintf( stderr,
146			"\n"
147			"not enough arguments for flag1\n");
148			usage();
149			exit(0);
150			}
151	mmeineke	521	strcpy( flag1Arg2, argV[i] );
152	mmeineke	518	}
153
154	mmeineke	521	else if( !strcmp( argV[i], "--flag2" ) ){
155			flag2 = 1; // set the flag2 to true;
156
157	mmeineke	518	i++;
158	mmeineke	522	if( i>=argC ){
159			fprintf( stderr,
160			"\n"
161			"not enough arguments for flag2\n");
162			usage();
163			exit(0);
164			}
165
166	mmeineke	521	flag2Val = strtod( argV[i], &conversionCheck );
167			if( conversionCheck == argV[i] ) conversionError = 1;
168			if( *conversionCheck != '\0' ) conversionError = 1;
169
170			if( conversionError ){
171
172			fprintf( stderr,
173			"Error converting \"%s\" to a double\n", argV[i] );
174			usage();
175			exit(0);
176			}
177
178	mmeineke	518	}
179
180	mmeineke	521	else if( !strcmp( argV[i], "--flag3") ){
181			flag3 = 1; // set flag3 to be true
182
183	mmeineke	518	}
184
185	mmeineke	521	// anything else is an error
186	mmeineke	518
187			else{
188			fprintf( stderr,
189	mmeineke	521	"Invalid option \"%s\"\n", argV[i] );
190	mmeineke	518	usage();
191	mmeineke	521	exit(0);
192	mmeineke	518	}
193			}
194
195			else{
196
197			// parse single character options
198
199			done =0;
200			j = 1;
201	mmeineke	522	currentFlag = argV[i][j];
202			while( (currentFlag != '\0') && (!done) ){
203	mmeineke	518
204	mmeineke	522	switch(currentFlag){
205	mmeineke	518
206	mmeineke	521	case 'h':
207			// -h => give the usage help message
208
209			usage();
210			exit(0);
211			break;
212
213	mmeineke	518	case 'o':
214			// -o <prefix> => the output prefix.
215
216	mmeineke	521	j++;
217			currentFlag = argV[i][j];
218
219			if( currentFlag != '\0' ) optionError = 1;
220
221			if( optionError ){
222			fprintf( stderr,
223			"\n"
224			"The -o flag should end an option sequence.\n"
225			" example: -ro <outname> NOT -or <outname>\n" );
226			usage();
227			exit(0);
228			}
229
230	mmeineke	518	i++;
231	mmeineke	522	if( i>=argC ){
232			fprintf( stderr,
233			"\n"
234			"not enough arguments for -o\n");
235			usage();
236			exit(0);
237			}
238
239	mmeineke	521	outPrefix = argV[i];
240			if( outPrefix[0] == '-' ) optionError = 1;
241
242			if( optionError ){
243			fprintf( stderr,
244			"\n"
245			"\"%s\" is not a valid out prefix/name.\n"
246			"Out prefix/name should not begin with a dash.\n",
247			outPrefix );
248			usage();
249			exit(0);
250			}
251
252			havePrefix = 1;
253	mmeineke	518	done = 1;
254			break;
255
256	mmeineke	521
257	mmeineke	518
258			case 'r':
259	mmeineke	521	// the r flag
260	mmeineke	518
261	mmeineke	521	rFlag = 1; // set rflag to true
262	mmeineke	518	break;
263
264	mmeineke	521	case 'i':
265			// -i <int> set <int> to the iVal
266	mmeineke	518
267	mmeineke	521	iFlag = 1; // set iFlag to true
268			j++;
269			currentFlag = argV[i][j];
270
271			if( currentFlag != '\0' ) optionError = 1;
272
273			if( optionError ){
274			fprintf( stderr,
275			"\n"
276			"The -i flag should end an option sequence.\n"
277			" example: -ri <int> NOT -ir <int>\n" );
278			usage();
279			exit(0);
280			}
281
282			i++;
283	mmeineke	522	if( i>=argC ){
284			fprintf( stderr,
285			"\n"
286			"not enough arguments for -i\n");
287			usage();
288			exit(0);
289			}
290
291	mmeineke	521	iVal = (int)strtol( argV[i], &conversionCheck, 10 );
292			if( conversionCheck == argV[i] ) conversionError = 1;
293			if( *conversionCheck != '\0' ) conversionError = 1;
294
295			if( conversionError ){
296
297			fprintf( stderr,
298			"Error converting \"%s\" to a int\n", argV[i] );
299			usage();
300			exit(0);
301			}
302
303			done = 1;
304
305	mmeineke	518	break;
306
307			default:
308
309	mmeineke	521	(void)fprintf(stderr,
310			"\n"
311	mmeineke	522	"Bad option \"-%c\"\n", currentFlag);
312	mmeineke	518	usage();
313			}
314			j++;
315	mmeineke	522	currentFlag = argV[i][j];
316	mmeineke	518	}
317			}
318			}
319
320			else{
321
322	mmeineke	521
323			// ********************************************************
324			// for only a single input file, leave this as it is.
325			// ********************************************************
326
327	mmeineke	522	// if( inName != NULL ){
328			// fprintf( stderr,
329			// "\n"
330			// "Error at \"%s\", program does not currently support\n"
331			// "more than one input file.\n"
332			// "\n",
333			// argV[i]);
334			// usage();
335			// exit(0);
336			// }
337	mmeineke	521
338	mmeineke	522	// inName = argV[i];
339	mmeineke	521
340			// *************************************************************
341
342
343			// ************************************************************
344			// To support more than one input file, uncomment the following
345			// section.
346			// ************************************************************
347	mmeineke	518
348	mmeineke	521
349			nInputs++;
350			currentName = (linkedName *) malloc( sizeof( linkedName ) );
351			if( currentName == NULL ){
352			fprintf( stderr,
353			"\n"
354			"Ran out of memory\n" );
355			exit(0);
356			}
357
358			strcpy( currentName->name, argV[i] );
359
360			currentName->next = headName;
361			headName = currentName;
362
363			// **********************************************************
364			// end multiple input files
365			// **********************************************************
366	mmeineke	518	}
367			}
368
369	mmeineke	521
370
371
372			// initialize the input file(s)
373
374			// ***********************************************************
375			// single file:
376
377	mmeineke	522	// if(inName == NULL){
378	mmeineke	521
379	mmeineke	522	// fprintf( stderr,
380			// "\n"
381			// "Error, no input file was given\n");
382			// usage();
383			// exit(0);
384			// }
385	mmeineke	518
386	mmeineke	522	// inFile = fopen( inName, "r" );
387			// if( inFile == NULL ){
388	mmeineke	521
389	mmeineke	522	// fprintf( stderr,
390			// "\n"
391			// "Error trying to open \"%s\" for reading\n",
392			// inName );
393			// exit(0);
394			// }
395	mmeineke	518
396	mmeineke	521	// **************************************************************
397			// multiple files:
398
399			if( !nInputs ){
400
401			fprintf( stderr,
402			"\n"
403			"Error, no input files were given\n");
404			usage();
405			exit(0);
406			}
407
408			// create the input array
409
410			inputArray = (fileStruct *) calloc( nInputs, sizeof( fileStruct ) );
411			if( inputArray == NULL ){
412			fprintf(stderr,
413			"\n"
414			"Ran out of memory\n" );
415			exit(0);
416			}
417
418			j = nInputs - 1;
419			currentName = headName;
420			while( currentName != NULL ){
421
422	mmeineke	522	strcpy( inputArray[j].fileName, currentName->name );
423			inputArray[j].filePtr = NULL;
424	mmeineke	521	j--;
425			currentName = currentName->next;
426			}
427
428			// delete linked list
429
430			while( headName != NULL ){
431
432			currentName = headName;
433			headName = currentName->next;
434
435			free( currentName );
436			}
437
438
439			// open the files for reading
440
441			for(i=0; i<nInputs; i++){
442
443	mmeineke	522	inputArray[i].filePtr = fopen( inputArray[i].fileName, "r" );
444	mmeineke	521	if( inputArray[i].filePtr == NULL ){
445
446			fprintf( stderr,
447			"\n"
448			"Error trying to open \"%s\" for reading\n",
449			inputArray[i].fileName );
450			exit(0);
451			}
452
453			//read and do stuff here
454
455			}
456
457			// *************************************************************
458			// end file opening
459			// *************************************************************
460
461
462
463	mmeineke	522	// or read and do stuff here.
464	mmeineke	521
465
466
467
468	mmeineke	522
469	mmeineke	521	// close files when we are done.
470
471			// ***********************************************************
472			// single:
473
474	mmeineke	522	// fclose( inFile );
475	mmeineke	521
476			// *************************************************************
477			// multiple:
478
479			for( i=0; i<nInputs; i++){
480
481			fclose( inputArray[i].filePtr );
482			}
483
484			free( inputArray ); // free the input Array if we are done;
485			inputArray = NULL;
486
487			// ************************************************************
488			// end file closing
489			// ************************************************************
490
491	mmeineke	518	}
492
493
494			/***************************************************************************
495			* prints out the usage for the command line arguments, then exits.
496			***************************************************************************/
497
498			void usage(){
499			(void)fprintf(stdout,
500	mmeineke	522	"\n"
501	mmeineke	520	"The proper usage is: %s [options] <input_file>\n"
502	mmeineke	518	"\n"
503			"Options:\n"
504			"\n"
505			" short:\n"
506			" ------\n"
507			" -h Display this message\n"
508	mmeineke	520	" -o <name> The output name/prefix\n"
509			" -r the r flag\n"
510	mmeineke	521	" -i <int> set number to <#>\n"
511	mmeineke	518
512			"\n"
513			" long:\n"
514			" -----\n"
515	mmeineke	520	" --flag1 <arg1> <arg2> does flag 1 for arg1 and 2\n"
516	mmeineke	521	" --flag2 <double> does flag 2 for double\n"
517	mmeineke	520	" --flag3 does flag 3\n"
518	mmeineke	518
519			"\n"
520			"\n",
521	mmeineke	522	programName);
522	mmeineke	521	exit(0);
523	mmeineke	518	}