iomenu.c

   1 #include <ctype.h>
   2 #include <fcntl.h>
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6 #include <sys/ioctl.h>
   7 #include <termios.h>
   8 #include <unistd.h>
   9
  10 #include "iomenu.h"
  11 #include "config.h"
  12
  13 /* add abstraction at no cost, but may add more complexity as well? */
  14 enum { FALSE = 0, TRUE = 1 };
  15
  16 /* preprocessor macros */
  17 #define LENGTH(x) (sizeof(x) / sizeof(*x))
  18 #define CONTROL(char) (char ^ 0x40)
  19 #define MIN(X, Y) (((X) < (Y)) ? (X) : (Y))
  20 #define MAX(X, Y) (((X) > (Y)) ? (X) : (Y))
  21
  22 /*
  23  * Fill the buffer apropriately with the lines and headers
  24  */
  25 Buffer *
  26 fill_buffer(char *separator)
  27 {
  28         /* fill buffer with string */
  29         char    string[LINE_SIZE];
  30         Line   *last   = NULL;
  31         Buffer *buffer = malloc(sizeof(Buffer));
  32         FILE   *fp     = fopen("/dev/stdin", "r");
  33
  34         if (!fp) {
  35                 die("Can not open file for reading.");
  36         }
  37
  38         /* read the file into a doubly linked list of lines */
  39         while (fgets(string, LINE_SIZE, fp)) {
  40                 buffer->total++;
  41                 last = add_line(buffer, buffer->total, string, separator, last);
  42         }
  43
  44         /* set the buffer stats */
  45         buffer->current = buffer->first;
  46
  47         /* empty line */
  48         buffer->empty = malloc(sizeof(Line));
  49         buffer->empty->content = "";
  50         buffer->empty->comment = "";
  51         buffer->empty->number  = 0;
  52         buffer->empty->matches = 0;
  53         buffer->empty->next    = buffer->first;
  54         buffer->empty->prev    = buffer->first;
  55
  56         return buffer;
  57 }
  58
  59 /*
  60  * Parse the line content to determine if it is a header and identify the
  61  * separator if any.
  62  */
  63 Line *
  64 parse_line(char *s, char *separator)
  65 {
  66         Line *line = malloc(sizeof(Line));
  67         char *sep  = strstr(s, separator);
  68         int   pos  = !sep ? (int) strlen(s) - 1 : (int) (sep - s);
  69
  70         /* strip trailing newline */
  71         s[strlen(s) - 1] = '\0';
  72
  73         /* fill line->content */
  74         line->content = malloc((pos + 1) * sizeof(char));
  75         strncpy(line->content, s, pos);
  76
  77         /* fill line->comment */
  78         if (sep) {
  79                 line->comment = malloc((strlen(s) - pos) * sizeof(char));
  80                 strcpy(line->comment, s + pos);
  81         } else {
  82                 line->comment = "";
  83         }
  84
  85         return line;
  86 }
  87
  88 /*
  89  * Add a line to the end of the current buffer.
  90  *
  91  * This requires to create a new line with a link to the previous line
  92  * and to NULL as the next line.
  93  *
  94  * The previous line's 'next' should be relinked to this new line.
  95  *
  96  * The header's last line have to point to this last line
  97  */
  98 Line *
  99 add_line(Buffer *buffer, int number, char *string, char *separator, Line *prev)
 100 {
 101         /* allocate new line */
 102         Line *line   = malloc(sizeof(Line));
 103         line         = parse_line(string, separator);
 104         line->next   = NULL;
 105         line->prev   = NULL;
 106         buffer->last = line;
 107         line->number = number;
 108
 109         /* interlink with previous line if exists */
 110         if (number == 1) {
 111                 buffer->first = line;
 112         } else {
 113                 prev->next = line;
 114                 line->prev = prev;
 115         }
 116
 117         return line;
 118 }
 119
 120 /*
 121  * Set buffer->candidates to an array of lines that match and update
 122  * buffer->matching to number of matching candidates.
 123  */
 124 void
 125 filter_lines(Buffer *buffer)
 126 {
 127         Line *  line  = buffer->first;
 128
 129         buffer->matching = 0;
 130
 131         while (line) {
 132                 if (line_match_input(line, buffer->input)) {
 133                         line->matches = TRUE;
 134                         buffer->matching++;
 135                 } else {
 136                         line->matches = FALSE;
 137                 }
 138
 139                 line = line->next;
 140         }
 141 }
 142
 143 /*
 144  * Check if line matches and return TRUE if so
 145  */
 146 int
 147 line_match_input(Line *line, char *input)
 148 {
 149         if (strncmp(input, line->content, strlen(input)) == 0) {
 150                 return TRUE;
 151         } else {
 152                 return FALSE;
 153         }
 154 }
 155
 156 /*
 157  * Replace tab as a multiple of 8 spaces in a line.
 158  */
 159 char *
 160 expand_tabs(char *line)
 161 {
 162         size_t i, n;
 163         char *converted = malloc(sizeof(char) * (strlen(line) * 8 + 1));
 164
 165         for (i = 0, n = 0; i < strlen(line); i++, n++) {
 166                 if (line[i] == '\t') {
 167                         converted[n] = ' ';
 168                         n++;
 169
 170                         for (; (n) % 8 != 0; n++) {
 171                                 converted[n] = ' ';
 172                         }
 173
 174                         n--;
 175                 } else {
 176                         converted[n] = line[i];
 177                 }
 178         }
 179
 180         converted[n] = '\0';
 181
 182         return converted;
 183 }
 184
 185 /*
 186  * Print a line to stderr.
 187  */
 188 void
 189 print_line(Line *line, int current, int cols)
 190 {
 191         size_t i;
 192         int n = 0;
 193         char *content = expand_tabs(line->content);
 194         char *comment = expand_tabs(line->comment);
 195
 196         /* clean the line in case it was not empty */
 197         fputs("\033[K", stderr);
 198
 199         /* line number if option set */
 200         if (TRUE) {
 201                 if (current) {
 202                         fputs("\033[1m", stderr);
 203                 } else {
 204                         fputs("\033[1;30m", stderr);
 205                 }
 206
 207                 fprintf(stderr, "%7d\033[0m ", line->number);
 208
 209
 210                 n += 8;
 211         }
 212
 213         /* highlight current line */
 214         if (current) {
 215                 fputs("\033[1;33m", stderr);
 216         }
 217
 218         /* print content without overflowing terminal width */
 219         for (i = 0; i < strlen(content) && n < cols; n++, i++) {
 220                 fputc(content[i], stderr);
 221         }
 222
 223         /* print spaces without overflowing terminal width */
 224         for (i = n; i <= 40             && n < cols; n++, i++) {
 225                 fputc(' ', stderr);
 226         }
 227
 228         /* comments in grey */
 229         fputs("\033[1;30m", stderr);
 230
 231         /* print comment without overflowing terminal width */
 232         for (i = 0; i < strlen(comment) && n < cols; n++, i++) {
 233                 fputc(comment[i], stderr);
 234         }
 235
 236         fputs("\033[0m\n", stderr);
 237
 238         free(content);
 239         free(comment);
 240 }
 241
 242 /*
 243  * Print a header title.
 244  */
 245 void
 246 print_header()
 247 {
 248 }
 249
 250 /*
 251  * Print all the lines from an array of pointer to lines.
 252  *
 253  * The total number oflines printed shall not excess 'count'.
 254  */
 255 void
 256 print_lines(Buffer *buffer, int count, int offset, int cols)
 257 {
 258         Line *line = buffer->current;
 259         int i = 0;
 260         int j = 0;
 261
 262         /* seek back from current line to the first line to print */
 263         while (line && i < count - offset) {
 264                 i    = line->matches ? i + 1 : i;
 265                 line = line->prev;
 266         }
 267         line = line ? line : buffer->first;
 268
 269         /* print up to count lines that match the input */
 270         while (line && j < count) {
 271                 if (line->matches) {
 272                         print_line(line, line == buffer->current, cols);
 273                         j++;
 274                 }
 275
 276                 line = line->next;
 277         }
 278
 279         /* continue up to the end of the screen clearing it */
 280         for (; j < count; j++) {
 281                 fputs("\r\033[K\n", stderr);
 282         }
 283 }
 284
 285 /*
 286  * Update the screen interface and print all candidates.
 287  *
 288  * This also has to clear the previous lines.
 289  */
 290 void
 291 update_screen(Buffer *buffer, int count, int offset, int tty)
 292 {
 293         struct winsize w;
 294         ioctl(tty, TIOCGWINSZ, &w);
 295
 296         fputs("\n", stderr);
 297         print_lines(buffer, count, offset, w.ws_col);
 298
 299         /* go up to the prompt position and update it */
 300         fprintf(stderr, "\033[%dA", count + 1);
 301         print_prompt(buffer, w.ws_col);
 302 }
 303
 304 void clear_screen(int count)
 305 {
 306         int i;
 307         for (i = 0; i < count + 1; i++) {
 308                 fputs("\r\033[K\n", stderr);
 309         }
 310
 311         fprintf(stderr, "\033[%dA", count + 1);
 312 }
 313
 314 /*
 315  * Set terminal to send one char at a time for interactive mode, and return the
 316  * last terminal state.
 317  */
 318 struct termios
 319 terminal_set(int tty)
 320 {
 321         struct termios termio_old;
 322         struct termios termio_new;
 323
 324         /* set the terminal to send one key at a time. */
 325
 326         /* get the terminal's state */
 327         if (tcgetattr(tty, &termio_old) < 0) {
 328                 die("Can not get terminal attributes with tcgetattr().");
 329         }
 330
 331         /* create a new modified state by switching the binary flags */
 332         termio_new          = termio_old;
 333         termio_new.c_lflag &= ~(ICANON | ECHO | IGNBRK);
 334
 335         /* apply this state to current terminal now (TCSANOW) */
 336         tcsetattr(tty, TCSANOW, &termio_new);
 337
 338         return termio_old;
 339 }
 340
 341 /*
 342  * Listen for the user input and call the appropriate functions.
 343  */
 344 void
 345 get_input(Buffer *buffer, int count, int offset, int tty)
 346 {
 347         FILE *tty_fd = fopen("/dev/tty", "r");
 348
 349         /* receive one character at a time from the terminal */
 350         struct termios termio_old = terminal_set(tty);
 351
 352         /* get input char by char from the keyboard. */
 353         while (do_key(fgetc(tty_fd), buffer)) {
 354                 update_screen(buffer, count, offset, tty);
 355         }
 356
 357         /* resets the terminal to the previous state. */
 358         tcsetattr(tty, TCSANOW, &termio_old);
 359
 360         fclose(tty_fd);
 361 }
 362
 363 /*
 364  * Perform action associated with key
 365  */
 366 int
 367 do_key(char key, Buffer *buffer)
 368 {
 369         size_t length;
 370         int i;
 371
 372         switch (key) {
 373
 374         case CONTROL('C'):
 375                 return FALSE;
 376
 377         case CONTROL('U'):
 378                 buffer->input[0] = '\0';
 379                 filter_lines(buffer);
 380                 break;
 381
 382         case CONTROL('W'):
 383                 length = strlen(buffer->input) - 1;
 384
 385                 for (i = length; i >= 0 && isspace(buffer->input[i]); i--) {
 386                         buffer->input[i] = '\0';
 387                 }
 388
 389                 length = strlen(buffer->input) - 1;
 390                 for (i = length; i >= 0 && !isspace(buffer->input[i]); i--) {
 391                         buffer->input[i] = '\0';
 392                 }
 393
 394                 filter_lines(buffer);
 395
 396                 break;
 397
 398         case CONTROL('H'):
 399         case 127:  /* backspace */
 400                 buffer->input[strlen(buffer->input) - 1] = '\0';
 401                 filter_lines(buffer);
 402                 break;
 403
 404         case CONTROL('N'):
 405                 do_next_line(buffer);
 406                 break;
 407
 408         case CONTROL('P'):
 409                 do_prev_line(buffer);
 410                 break;
 411
 412         case CONTROL('I'):
 413                 /* do_prev_line(buffer); */
 414                 /* strcpy(buffer->input, buffer->current->content); */
 415                 filter_lines(buffer);
 416                 break;
 417
 418         case CONTROL('M'):
 419         case CONTROL('J'):  /* enter */
 420                 fputs("\r\033[K", stderr);
 421                 puts(buffer->current->content);
 422                 return FALSE;
 423
 424         default:
 425                 if (isprint(key)) {
 426                         length = strlen(buffer->input);
 427                         buffer->input[length]     = key;
 428                         buffer->input[length + 1] = '\0';
 429                 }
 430
 431                 filter_lines(buffer);
 432
 433                 if (!buffer->current->matches) {
 434                         do_next_line(buffer);
 435                         do_prev_line(buffer);
 436                 }
 437
 438                 if (!buffer->current->matches) {
 439                         buffer->current = buffer->empty;
 440                 }
 441         }
 442
 443         return TRUE;
 444 }
 445
 446 /*
 447  * Set the current line to the next matching line, if any.
 448  */
 449 void
 450 do_prev_line(Buffer *buffer)
 451 {
 452         Line * line = buffer->current;
 453
 454         while (line->prev) {
 455                 line = line->prev;
 456
 457                 if (line->matches) {
 458                         buffer->current = line;
 459                         break;
 460                 }
 461         }
 462
 463 }
 464
 465 /*
 466  * Set the current line to the next matching line, if any.
 467  */
 468 void
 469 do_next_line(Buffer *buffer)
 470 {
 471         Line * line = buffer->current;
 472
 473         while (line->next) {
 474                 line = line->next;
 475
 476                 if (line->matches) {
 477                         buffer->current = line;
 478                         break;
 479                 }
 480         }
 481
 482 }
 483
 484 /*
 485  * Print the prompt, before the input, with the number of candidates that
 486  * match.
 487  */
 488 void
 489 print_prompt(Buffer *buffer, int cols)
 490 {
 491         size_t  i;
 492         int     digits   = 0;
 493         int     matching = buffer->matching;
 494         int     total    = buffer->total;
 495         char   *input    = expand_tabs(buffer->input);
 496         char   *suggest  = expand_tabs(buffer->current->content);
 497
 498         /* for the '/' separator between the numbers */
 499         cols--;
 500
 501         /* count the number of digits */
 502         for (i = matching; i; i /= 10, digits++);
 503         for (i = total;    i; i /= 10, digits++);
 504
 505         /* actual prompt */
 506         fputs("\r\033[K> ", stderr);
 507         cols -= 2;
 508
 509         /* input without overflowing terminal width */
 510         for (i = 0; i < strlen(input) && cols > digits; cols--, i++) {
 511                 fputc(input[i], stderr);
 512         }
 513
 514         /* save the cursor position at the end of the input */
 515         fputs("\033[s", stderr);
 516
 517         /* grey */
 518         fputs("\033[1;30m", stderr);
 519
 520         /* suggest without overflowing terminal width */
 521         for (; i < strlen(suggest) && cols > digits; cols--, i++) {
 522                 fputc(suggest[i], stderr);
 523         }
 524
 525         /* go to the end of the line */
 526         for (i = 0; cols > digits; cols--, i++) {
 527                 fputc(' ', stderr);
 528         }
 529
 530         /* total match and line count at the end of the line */
 531         fprintf(stderr, "%d/%d", matching, total);
 532
 533         /* restore cursor position at the end of the input */
 534         fputs("\033[u", stderr);
 535
 536         free(input);
 537         free(suggest);
 538 }
 539
 540 /*
 541  * Reset the terminal state and exit with error.
 542  */
 543 void die(const char *s)
 544 {
 545 /*      tcsetattr(STDIN_FILENO, TCSANOW, &termio_old); */
 546         fprintf(stderr, "%s\n", s);
 547         exit(EXIT_FAILURE);
 548
 549 }
 550
 551 int
 552 main(int argc, char *argv[])
 553 {
 554         int i;
 555         Buffer *buffer    = NULL;
 556         char   *separator = "* ";
 557         int count         = 30;
 558         int offset        = 3;
 559         int tty           = open("/dev/tty", O_RDWR);
 560
 561         /* command line arguments */
 562         for (i = 0; i <= argc; i++) {
 563                 if (argv[i][1] == '-') {
 564                         ;
 565                 }
 566         }
 567
 568         /* command line arguments */
 569         buffer = fill_buffer(separator);
 570
 571         /* set the interface */
 572         filter_lines(buffer);
 573         update_screen(buffer, count, offset, tty);
 574
 575         /* listen and interact to input */
 576         get_input(buffer, count, offset, tty);
 577
 578         clear_screen(count);
 579
 580         return 0;
 581 }