typie

opt.c

---

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

#include "opt.h"
#include "typer.h"

#define ERROR(message)  fprintf(stderr, COLOR_RED message COLOR_RESET);
#define ERRORARG(message, arg)\
	fprintf(stderr, COLOR_RED message COLOR_RESET, arg);

#define PROCESS_GROUP_SUCCESS  0
#define PROCESS_GROUP_FAILURE  1
#define PROCESS_GROUP_SKIP  2
#define PARSE_INT_FAILURE  -1

int
parse_int(const char * arg)
{
        char * endptr;
        int ret;
        ret = strtol(arg, &endptr, 10);
        if (* endptr != '\0' || ret > INT_MAX || ret < INT_MIN)
                return PARSE_INT_FAILURE;
        return ret;
}

int
get_flag(char c)
{
	switch (c) {
	case 'l': return FLAG_LEARN_MODE;
	case 'o': return FLAG_FILE;
	case 't': return FLAG_TIME;
	}

	return 0;
}

int
process_flag_group(State * state, const char * group, const char * next)
{
	int index;
	char c;
	int flag;

	if (group[0] != '-') {
		ERROR("Invalid flag format." "\n\n");
		return 1;
	}
	
	index = 1;
	for (;;) {
		c = group[index];

		if (c == '\0')
			break;

		flag = get_flag(c);

		if (flag == 0) {
			ERRORARG("Unrecognized flag: -%c." "\n\n", c);
			return PROCESS_GROUP_FAILURE;
		}

		if ((state->flags & flag) != 0) {
			ERRORARG("Repeated flag: -%c." "\n\n", c);
			return PROCESS_GROUP_FAILURE;
		}

		state->flags |= flag;

		if (flag == FLAG_FILE) {
			if (next == NULL || group[index+1] != '\0') {
				ERROR("Filename must follow -f." "\n\n");
				return PROCESS_GROUP_FAILURE;
			}

			state->outfile = next;

			return PROCESS_GROUP_SKIP;
		}

		if (flag == FLAG_TIME) {
			long int duration_seconds;
			if (next == NULL || group[index+1] != '\0') {
				ERROR("Integer must follow -t." "\n\n");
				return PROCESS_GROUP_FAILURE;
			}

			duration_seconds = parse_int(next);
			if (duration_seconds == PARSE_INT_FAILURE) {
				ERROR("Integer must follow -t." "\n\n");
				return PROCESS_GROUP_FAILURE;
			}
			state->duration_millis = duration_seconds * 1000;

			return PROCESS_GROUP_SKIP;
		}

		index++;
	}

	return 0;
}

int
set_flags(State * state, int argc, const char * argv[])
{
	int index = 1;
	const char * group;
	const char * next;
	int result;

	if (argc == 2)
		return 0;

	if (argc == 1) {
		ERROR("Not enough arguments." "\n\n");
		return 1;
	}

	for (;;) {
		group = argv[index];
		next = (index+1 < argc-1) ? argv[index+1] : NULL;

		result = process_flag_group(state, group, next);
		if (result == PROCESS_GROUP_SKIP)
			index++;
		if (result == PROCESS_GROUP_FAILURE)
			return 1;
	
		index++;
		if(index >= argc-1) /* last arg is PROMPT */
			break;
	}

	return 0;
}