/*********************************************************
 *
 *                    args.c
 *
 *     The implementation of the UNIX command line argument
 *  processing package.  See args.h for a description of
 *  the assumptions that this package makes.
 *
 ********************************************************/

#include "args.h"
#include <ctype.h>	/* for isalpha and isdigit */
#include <string.h>	/* for strlen, strncpy and strcmp */
#include <stdlib.h>

/*
 *  The get_flag procedure extracts a legal flag from the
 *  character string that is passed to it.  The flag is returned
 *  as get_flag's value.
 *
 *  Pre-conditions:
 *    The input string s contains a valid flag and is NULL terminated
 *
 *  Post-conditions:
 *    Returns the flag that is the prefix of s, the flag ends at
 *    the first non-alphabetic character.
 *
 *  Note: the return value is malloc'ed and must be freed by the
 *        calling procedure.
 */

static char* get_flag(char s[]) {
	int i;
	int len;
	char* result;

	len = strlen(s);
	for(i=1; i<len; i++)
		if(!isalpha(s[i]))
			break;

	result = malloc(i+1);
	return (strncpy(result, s, i));
}

/*
 *  The find_entry procedure finds the argument table entry
 *  for a given flag.  This procedure returns the index of
 *  the entry, if it is successful, otherwise it returns -1.
 *
 *  Pre-conditions:
 *    args is a valid zero terminated argument table, flag is
 *    a NULL terminated string.
 *
 *  Post-conditions:
 *    returns the index where flag is found, or -1 if flag
 *    isn't in args.
 */

static int find_entry(Arg* args, char*  flag) {
	int i;

	i = 0;
	while(args[i].flag != 0) {
		if(strcmp(args[i].flag, flag) == 0)
			return(i);
		i++;
	}

	return(-1);
}

/*
 *  The get_string procedure stores a string value in the
 *  variable pointed to by the argument table entry arg.
 *
 *  Pre-conditions:
 *    arg is a valid argument table entry
 *    value points to a NULL terminated character string
 *
 *  Post-Conditions:
 *    the string variable pointed to by the value field
 *    of arg is updated to point to value.
 */

static void get_string(Arg arg, char* value) {
	char** val;

	if(arg.value == 0) {
		printf("zero address for %s flag\n", arg.flag);
	} else {
		val = (char**) arg.value;
		*val = value;
	}
}

/*
 *  The get_int procedure extracts an integer from the value
 *  parameter and stores it in the variable pointed to by
 *  the value field of the arg parameter.
 *
 *  Pre-conditions:
 *    The NULL terminated string value contains an integer
 *    arg is a valid argument table entry
 *
 *  Post-conditions:
 *    The integer value in value is stored in the variable
 *    pointed to be arg.value.
 */

static void get_int(Arg arg, char value[]) {
	int i;
	int len;
	int start;
	int* val;

	len = strlen(value);

	/*
	 *  first check that value contains a properly
	 *  formatted integer
	 */

	start = 0;
	if(value[0] == '+' || value[0] == '-')
		start = 1;

	for(i=start; i<len; i++)
		if(!isdigit(value[i])) {
			printf("%s is an integer parameter\n", arg.flag);
			return;
		}

	if(arg.value == 0) {
		printf("zero address for %s flag\n", arg.flag);
	} else {
		val = (int* ) arg.value;
		*val = atoi(value);
	}

}

/*
 *  The get_float procedure extracts a float from the value
 *  parameter and stores it in the variable pointed to by
 *  the value field of the arg parameter.
 *
 *  Pre-conditions:
 *    The NULL terminated string value contains an float
 *    arg is a valid argument table entry
 *
 *  Post-conditions:
 *    The float value in value is stored in the variable
 *    pointed to be arg.value.
 */


static void get_float(Arg arg, char value[]) {
	int i;
	int len;
	int start;
	float* val;

	len = strlen(value);

	/*
	 *  first check that value contains a valid
	 *  floating point number
	 */

	start = 0;
	if(value[0] == '+' || value[0] == '-')
		start = 1;

	for(i=start; i<len; i++)
		if(!isdigit(value[i]) && value[i] != '.') {
			printf("%s is a float parameter\n", arg.flag);
			return;
		}

	if(arg.value == 0) {
		printf("zero address for %s flag\n", arg.flag);
	} else {
		val = (float* ) arg.value;
		*val = atof(value);
	}

}


/*
 *  The get_value procedure finds the value for an argument
 *  in the argv array.  This value could either be in the same
 *  entry as the flag, or in the next entry.  It then calls the
 *  appropriate procedure to decode the value and assign it
 *  to the appropriate program variable.  If the argument value
 *  is found in the same argv entry as the flag this procedure
 *  returns zero, otherwise it returns one.
 *
 *  Pre-conditions:
 *    arg is the argument table entry for the argument.
 *    index is the subscript of the argv array entry that
 *    contains the argument flag.
 *
 *  Post-conditions:
 *    The argument value is stored in the appropriate
 *    program variable.
 *    Return 1 if the value is in the next argv entry,
 *    return 0 if it is in the current entry
 */

static int get_value(Arg arg, int index, char* argv[]) {
	int len;

	len = strlen(argv[index]);
	/*
	 * If the length of the current argv entry is the
	 * same as the flag's length, then the value must
	 * be in the next argv entry
	 */
	if(len == strlen(arg.flag)) {
		switch(arg.type) {
			case ARG_STRING:
				get_string(arg, argv[index+1]);
				break;
			case ARG_INT:
				get_int(arg, argv[index+1]);
				break;
			case ARG_FLOAT:
				get_float(arg, argv[index+1]);
				break;
			default:
				printf("bad argument type in table: %d\n",
					arg.type);
				break;
		}
		return(1);
	/*
	 *  Otherwise, the value must be part of the current
	 *  argv entry.  Skip over the flag, and use the rest
	 *  of the entry as the value.
	 */
	} else {
		len = strlen(arg.flag);
		switch(arg.type) {
			case ARG_INT:
				get_int(arg, argv[index]+len);
				break;
			case ARG_FLOAT:
				get_float(arg, argv[index]+len);
				break;
			default:
				printf("bad argument type in table: %d\n",
					arg.type);
				break;
		}
		return(0);
	}
}

/*
 *  The process_arguments procedure processes the command
 *  line arguments for a program.  The first paramter, args,
 *  is the argument table that describes the paramters, the
 *  next two parameters are argc and argv from the main procedure.
 *  This procedure returns a list of the arguments that appear
 *  without a flag.  It is assumed that these are the files
 *  that are processed by the calling program, and process_arguments
 *  does nothing with them.  This list is terminated by a
 *  zero entry.
 *
 *  Pre-conditions:
 *    args is a valid, zero terminated, argument table.
 *    argc and argv are the corresponding parameters from
 *    the main procedure.
 *
 *  Post-conditions:
 *    Argument values are stored in the appropriate program
 *    variables.
 *    The arguments without flags are returned as a zero
 *    terminated array of character pointers
 *
 *  General Outline:
 *    while(not end of argv) {
 *	if(current argument is a flag)
 *		get the flag value
 *		find it in the argument table
 *		find and process the argument value
 *	else
 *		add the current argument to the array
 *		that is returned by process_arguments
 *    }
 */

char** process_arguments(Arg* args, int argc, char* argv[]) {
	char** result;
	int i;
	int nfiles;
	char* flag;
	int entry;

	/*
	 *  result is the array of arguments with flags, in
	 *  the worst case this could be all the arguments, so
	 *  allocate an array large enough to hold them, plus
	 *  the terminating zero.
	 */
	printf ("Want space for: %d*%d bytes\n", argc, sizeof *result);
	result = (char**) malloc(argc * (sizeof *result));
	if(result == NULL) {
		printf("can't allocate memory in process_arguments\n");
		abort();
	}
	nfiles = 0;

	i = 1;
	while(i < argc) {
		if(*argv[i] == '-' || *argv[i] == '+') {
			flag = get_flag(argv[i]);
			entry = find_entry(args, flag);
			if(entry < 0) {
				printf("unrecognized flag: %s\n", flag);
			} else {
				i += get_value(args[entry], i, argv);
			}
			free(flag);
		} else {
			result[nfiles++] = argv[i];
		}
		i++;
	}

	result[nfiles] = 0;
	return(result);
}