typie

main.c

---

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

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

#define TRUE 1
#define FALSE 0
#define MAX_PROMPT_LENGTH 1024
#define MAX_LINES 100

char prompt_buffer[MAX_PROMPT_LENGTH];
int jumps_buffer[MAX_PROMPT_LENGTH];
int line_lengths_buffer[MAX_LINES];
char chars_printed_buffer[MAX_PROMPT_LENGTH];

const char * usage =\
"Usage: typie [-l] [-o OUTFILE] [-t TIME] PROMPT" "\n"\
"\n"\
"        -l          no backspacing, incorrect keys not accepted" "\n"\
"        -o OUTFILE  file to write output to (defaults to stdout)" "\n"\
"        -t TIME     exit after TIME seconds" "\n"\
/* "        -m       output mistakes after completion" "\n" */\
"\n"\
"See the man page for more details." "\n"\
"\n";

long int
get_time_millis()
{
	struct timespec now;
	timespec_get(&now, TIME_UTC);
	return now.tv_sec * 1000 + now.tv_nsec / 1000000;
}

int
type(State * state)
{
	int keypress_kind;
	int started = FALSE;

	for (;;) {
		char c = getchar();

		long int keypress_millis = get_time_millis();
		long int elapsed_millis = keypress_millis - state->start_millis;
		if (
			started &&
			state->duration_millis != 0 &&
			elapsed_millis > state->duration_millis
		) {
			state->timed_out = TRUE;
			return 0;
		}

		state->end_millis = keypress_millis;

		keypress_kind = handle_keypress(state, c);
		fflush(stdout);

		switch (keypress_kind) {
		case KEYPRESS_EXIT:
			return 1;
		
		case KEYPRESS_CORRECT: /* FALLTHROUGH */
			state->chars_correct++;
			if (state->prompt[state->index] == '\0')
				return 0;
		case KEYPRESS_INCORRECT:
			state->chars_total++;
			if (!started) {
				started = TRUE;
				state->start_millis = get_time_millis();
				fflush(stdout);
			}
			break;
		
		case KEYPRESS_ENTER:
			return 0;
			break;

		case KEYPRESS_BACKSPACE:
			break;

		case KEYPRESS_NONE:
			break;
		}
	}
}

void
write_output(State state)
{
	FILE * out;
	int correct = state.chars_correct,
		total = state.chars_total;

	double time_millis = state.timed_out ?
		state.duration_millis :
		state.end_millis - state.start_millis;
	double time_seconds = time_millis / 1000;
	double time_minutes = time_seconds / 60;

	int wpm = (correct / 5.0) / time_minutes;

	int accuracy = ((double) correct / total) * 100;

	out = stdout;
	if (state.flags & FLAG_FILE)
		out = fopen(state.outfile, "w");

	fprintf(
		out,
		"millis    %d" "\n"\
		"wpm       %d" "\n"\
		"accuracy  %d%%",
		(int) time_millis,
		wpm,
		accuracy
	);
	
	if (state.flags & FLAG_FILE) {
		fclose(out);
	} else {
		fprintf(out, "\n");
	}
}

int
get_length(const char * string)
{
	int index = 0;
	for (;;) {
		if (string[index] == '\0')
			break;
		index++;
	}
	return index;
}


void
init_state(State * state)
{
	state->flags = 0;
	state->index = 0;
	state->jumps.buffer = jumps_buffer;
	state->jumps.length = 0;
	state->line_lengths = line_lengths_buffer;
	state->chars_printed = chars_printed_buffer;
	state->chars_printed_index = 0;
	state->index = 0;
	state->row = 0;
	state->max_row = 0;
	state->column = 0;
	state->line_lengths[0] = 0;
}

int
main(int argc, const char * argv[])
{
	struct termios termios_original;
	State state;
	int result;
	
	init_state(&state);

	result = set_flags(&state, argc, argv);
	if (result > 0) {
		printf("%s", usage);
		exit(1);
	}
	state.prompt = argv[argc-1];
	state.prompt_length = get_length(state.prompt);
	
	if (state.prompt_length >= MAX_PROMPT_LENGTH) {
		fprintf(stderr, COLOR_RED "Max prompt length exceeded." "\n");
		return 1;
	}

	tcgetattr(0, &termios_original);
	setup_termios(termios_original);

	start_typing(&state);
	fflush(stdout);

	result = type(&state);
	if (result > 0) {
		restore_termios(termios_original);
		exit(1);
	}

	printf("\033[%dB", state.max_row - state.row - 1);
	restore_termios(termios_original);
	printf(COLOR_RESET "\n");

	write_output(state);

	return 0;
}