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