It seems to work now

[iomenu.git] / iomenu.c

#include <ctype.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <termios.h>
#include <unistd.h>

#include "iomenu.h"
#include "config.h"

/* add abstraction at no cost, but may add more complexity as well? */
enum { FALSE = 0, TRUE = 1 };

/* debug switches */
#define COMPLETE_MODE 0

/* preprocessor macros */
#define LENGTH(x) (sizeof(x) / sizeof(*x))
#define CONTROL(char) (char ^ 0x40)
#define MIN(X, Y) (((X) < (Y)) ? (X) : (Y))
#define MAX(X, Y) (((X) > (Y)) ? (X) : (Y))

/*
 * Fill the buffer apropriately with the lines and headers
 */
Buffer *
fill_buffer(char *separator)
{
        /* fill buffer with string */
        char    string[LINE_SIZE];
        Line   *last   = NULL;
        Buffer *buffer = malloc(sizeof(Buffer));
        FILE   *fp     = fopen("/dev/stdin", "r");

        if (!fp) {
                die("Can not open file for reading.");
        }

        /* read the file into a doubly linked list of lines */
        while (fgets(string, LINE_SIZE, fp)) {
                buffer->total++;
                last = add_line(buffer, buffer->total, string, separator, last);
        }

        /* set the buffer stats */
        buffer->current = buffer->first;

        /* empty line */
        buffer->empty = malloc(sizeof(Line));
        buffer->empty->content = "";
        buffer->empty->comment = "";
        buffer->empty->number  = 0;
        buffer->empty->matches = 0;
        buffer->empty->next    = buffer->first;
        buffer->empty->prev    = buffer->first;

        return buffer;
}

/*
 * Parse the line content to determine if it is a header and identify the
 * separator if any.
 */
Line *
parse_line(char *s, char *separator)
{
        Line *line = malloc(sizeof(Line));
        char *sep  = strstr(s, separator);
        int   pos  = !sep ? (int) strlen(s) - 1 : (int) (sep - s);

        /* strip trailing newline */
        s[strlen(s) - 1] = '\0';

        /* fill line->content */
        line->content = malloc((pos + 1) * sizeof(char));
        strncpy(line->content, s, pos);

        /* fill line->comment */
        if (sep) {
                line->comment = malloc((strlen(s) - pos) * sizeof(char));
                strcpy(line->comment, s + pos);
        } else {
                line->comment = "";
        }

        return line;
}

/*
 * Add a line to the end of the current buffer.
 *
 * This requires to create a new line with a link to the previous line
 * and to NULL as the next line.
 *
 * The previous line's 'next' should be relinked to this new line.
 *
 * The header's last line have to point to this last line
 */
Line *
add_line(Buffer *buffer, int number, char *string, char *separator, Line *prev)
{
        /* allocate new line */
        Line *line   = malloc(sizeof(Line));
        line         = parse_line(string, separator);
        line->next   = NULL;
        line->prev   = NULL;
        buffer->last = line;
        line->number = number;

        /* interlink with previous line if exists */
        if (number == 1) {
                buffer->first = line;
        } else {
                prev->next = line;
                line->prev = prev;
        }

        return line;
}

/*
 * Set buffer->candidates to an array of lines that match and update
 * buffer->matching to number of matching candidates.
 */
void
filter_lines(Buffer *buffer)
{
        Line *  line     = buffer->first;
        buffer->matching = 0;

        while (line) {
                line->matches = line_match_input(line, buffer->input);
                buffer->matching += line->matches;

                line = line->next;
        }
}

/*
 * Check if line matches and return TRUE if so
 */
int
line_match_input(Line *line, char *input)
{
        if (COMPLETE_MODE) {
                if (!strncmp(input, line->content, strlen(input)))
                        return TRUE;
        } else {
                if (strstr(line->content, input))
                        return TRUE;
        }

        return FALSE;
}

/*
 * Replace tab as a multiple of 8 spaces in a line.
 */
char *
expand_tabs(char *line)
{
        size_t i, n;
        char *converted = malloc(sizeof(char) * (strlen(line) * 8 + 1));

        for (i = 0, n = 0; i < strlen(line); i++, n++) {
                if (line[i] == '\t') {
                        converted[n] = ' ';
                        n++;

                        for (; (n) % 8 != 0; n++) {
                                converted[n] = ' ';
                        }

                        n--;
                } else {
                        converted[n] = line[i];
                }
        }

        converted[n] = '\0';

        return converted;
}

/*
 * Print a line to stderr.
 */
void
print_line(Line *line, int current, int cols)
{
        size_t i;
        int n = 0;
        char *content = expand_tabs(line->content);
        char *comment = expand_tabs(line->comment);

        /* clean the line in case it was not empty */
        fputs("\033[K", stderr);

        /* line number if option set */
        if (TRUE) {
                if (current) {
                        fputs("\033[1m", stderr);
                } else {
                        fputs("\033[1;30m", stderr);
                }

                fprintf(stderr, "%7d\033[0m ", line->number);


                n += 8;
        }

        /* highlight current line */
        if (current) {
                fputs("\033[1;33m", stderr);
        }

        /* print content without overflowing terminal width */
        for (i = 0; i < strlen(content) && n < cols; n++, i++) {
                fputc(content[i], stderr);
        }

        /* print spaces without overflowing terminal width */
        for (i = n; i <= 40             && n < cols; n++, i++) {
                fputc(' ', stderr);
        }

        /* comments in grey */
        fputs("\033[1;30m", stderr);

        /* print comment without overflowing terminal width */
        for (i = 0; i < strlen(comment) && n < cols; n++, i++) {
                fputc(comment[i], stderr);
        }

        fputs("\033[0m\n", stderr);

        free(content);
        free(comment);
}

/*
 * Print a header title.
 */
void
print_header()
{
}

/*
 * Print all the lines from an array of pointer to lines.
 *
 * The total number oflines printed shall not excess 'count'.
 */
void
print_lines(Buffer *buffer, int count, int offset, int cols)
{
        Line *line = buffer->current;
        int i = 0;
        int j = 0;

        /* seek back from current line to the first line to print */
        while (line && i < count - offset) {
                i    = line->matches ? i + 1 : i;
                line = line->prev;
        }
        line = line ? line : buffer->first;

        /* print up to count lines that match the input */
        while (line && j < count) {
                if (line->matches) {
                        print_line(line, line == buffer->current, cols);
                        j++;
                }

                line = line->next;
        }

        /* continue up to the end of the screen clearing it */
        for (; j < count; j++) {
                fputs("\r\033[K\n", stderr);
        }
}

/*
 * Update the screen interface and print all candidates.
 *
 * This also has to clear the previous lines.
 */
void
update_screen(Buffer *buffer, int count, int offset, int tty)
{
        struct winsize w;
        ioctl(tty, TIOCGWINSZ, &w);

        fputs("\n", stderr);
        print_lines(buffer, count, offset, w.ws_col);

        /* go up to the prompt position and update it */
        fprintf(stderr, "\033[%dA", count + 1);
        print_prompt(buffer, w.ws_col);
}

void clear_screen(int count)
{
        int i;
        for (i = 0; i < count + 1; i++) {
                fputs("\r\033[K\n", stderr);
        }

        fprintf(stderr, "\033[%dA", count + 1);
}

/*
 * Set terminal to send one char at a time for interactive mode, and return the
 * last terminal state.
 */
struct termios
terminal_set(int tty)
{
        struct termios termio_old;
        struct termios termio_new;

        /* set the terminal to send one key at a time. */

        /* get the terminal's state */
        if (tcgetattr(tty, &termio_old) < 0) {
                die("Can not get terminal attributes with tcgetattr().");
        }

        /* create a new modified state by switching the binary flags */
        termio_new          = termio_old;
        termio_new.c_lflag &= ~(ICANON | ECHO | IGNBRK);

        /* apply this state to current terminal now (TCSANOW) */
        tcsetattr(tty, TCSANOW, &termio_new);

        return termio_old;
}

/*
 * Listen for the user input and call the appropriate functions.
 */
void
get_input(Buffer *buffer, int count, int offset, int tty)
{
        FILE *tty_fd = fopen("/dev/tty", "r");

        /* receive one character at a time from the terminal */
        struct termios termio_old = terminal_set(tty);

        /* get input char by char from the keyboard. */
        while (do_key(fgetc(tty_fd), buffer)) {
                update_screen(buffer, count, offset, tty);
        }

        /* resets the terminal to the previous state. */
        tcsetattr(tty, TCSANOW, &termio_old);

        fclose(tty_fd);
}

/*
 * Perform action associated with key
 */
int
do_key(char key, Buffer *buffer)
{
        size_t length;
        int i;

        switch (key) {

        case CONTROL('C'):
                return FALSE;

        case CONTROL('U'):
                buffer->input[0] = '\0';
                buffer->current  = buffer->first;
                filter_lines(buffer);
                break;

        case CONTROL('W'):
                length = strlen(buffer->input) - 1;

                for (i = length; i >= 0 && isspace(buffer->input[i]); i--) {
                        buffer->input[i] = '\0';
                }

                length = strlen(buffer->input) - 1;
                for (i = length; i >= 0 && !isspace(buffer->input[i]); i--) {
                        buffer->input[i] = '\0';
                }

                filter_lines(buffer);

                break;

        case 127:
        case CONTROL('H'):  /* backspace */
                buffer->input[strlen(buffer->input) - 1] = '\0';
                filter_lines(buffer);

                if (!buffer->current->matches) {
                        do_next_line(buffer);
                        do_prev_line(buffer);
                }
                break;

        case CONTROL('N'):
                do_next_line(buffer);
                break;

        case CONTROL('P'):
                do_prev_line(buffer);
                break;

        case CONTROL('I'):  /* tab */
                if (COMPLETE_MODE) {
                        strcpy(buffer->input, buffer->current->content);
                        filter_lines(buffer);
                } else {
                        do_next_line(buffer);
                }
                break;

        case CONTROL('M'):
        case CONTROL('J'):  /* enter */
                fputs("\r\033[K", stderr);

                if (COMPLETE_MODE) {
                        puts(buffer->input);
                } else {
                        puts(buffer->current->content);
                }
                return FALSE;

        default:
                if (isprint(key)) {
                        length = strlen(buffer->input);
                        buffer->input[length]     = key;
                        buffer->input[length + 1] = '\0';
                }

                filter_lines(buffer);

                if (!buffer->current->matches) {
                        do_next_line(buffer);
                        do_prev_line(buffer);
                }

                if (!buffer->current->matches) {
                        buffer->current = buffer->empty;
                }
        }

        return TRUE;
}

/*
 * Set the current line to the next matching line, if any.
 */
void
do_prev_line(Buffer *buffer)
{
        Line * line = buffer->current;

        while (line->prev) {
                line = line->prev;

                if (line->matches) {
                        buffer->current = line;
                        break;
                }
        }

}

/*
 * Set the current line to the next matching line, if any.
 */
void
do_next_line(Buffer *buffer)
{
        Line * line = buffer->current;

        while (line->next) {
                line = line->next;

                if (line->matches) {
                        buffer->current = line;
                        break;
                }
        }

}

/*
 * Print the prompt, before the input, with the number of candidates that
 * match.
 */
void
print_prompt(Buffer *buffer, int cols)
{
        size_t  i;
        int     digits   = 0;
        int     matching = buffer->matching;
        int     total    = buffer->total;
        char   *input    = expand_tabs(buffer->input);
        char   *suggest  = expand_tabs(buffer->current->content);

        /* for the '/' separator between the numbers */
        cols--;

        /* count the number of digits */
        for (i = matching; i; i /= 10, digits++);
        for (i = total;    i; i /= 10, digits++);

        /* actual prompt */
        fputs("\r\033[K> ", stderr);
        cols -= 2;

        /* input without overflowing terminal width */
        for (i = 0; i < strlen(input) && cols > digits; cols--, i++) {
                fputc(input[i], stderr);
        }

        /* save the cursor position at the end of the input */
        fputs("\033[s", stderr);

        /* grey */
        fputs("\033[1;30m", stderr);

        /* suggest without overflowing terminal width */
        if (COMPLETE_MODE) {
                for (; i < strlen(suggest) && cols > digits; cols--, i++) {
                        fputc(suggest[i], stderr);
                }
        }

        /* go to the end of the line */
        for (i = 0; cols > digits; cols--, i++) {
                fputc(' ', stderr);
        }

        /* total match and line count at the end of the line */
        fprintf(stderr, "%d/%d", matching, total);

        /* restore cursor position at the end of the input */
        fputs("\033[u", stderr);

        free(input);
        free(suggest);
}

/*
 * Reset the terminal state and exit with error.
 */
void die(const char *s)
{
/*      tcsetattr(STDIN_FILENO, TCSANOW, &termio_old); */
        fprintf(stderr, "%s\n", s);
        exit(EXIT_FAILURE);

}

int
main(int argc, char *argv[])
{
        int i;
        Buffer *buffer    = NULL;
        char   *separator = "separator";
        int count         = 30;
        int offset        = 3;
        int tty           = open("/dev/tty", O_RDWR);

        /* command line arguments */
        for (i = 0; i <= argc; i++) {
                if (argv[i][1] == '-') {
                        ;
                }
        }

        /* command line arguments */
        buffer = fill_buffer(separator);

        /* set the interface */
        filter_lines(buffer);
        update_screen(buffer, count, offset, tty);

        /* listen and interact to input */
        get_input(buffer, count, offset, tty);

        clear_screen(count);

        return 0;
}