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