complete.c

   1 #include <ctype.h>
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5 #include <sys/ioctl.h>
   6 #include <termios.h>
   7 #include <unistd.h>
   8
   9 #include "complete.h"
  10 #include "config.h"
  11
  12 enum { FALSE = 0, TRUE = 1 };
  13
  14 #define LENGTH(x) (sizeof(x) / sizeof(*x))
  15 #define CONTROL(char) (char ^ 0x40)
  16 #define MIN(X, Y) (((X) < (Y)) ? (X) : (Y))
  17 #define MAX(X, Y) (((X) > (Y)) ? (X) : (Y))
  18
  19 /*
  20  * Fill the buffer apropriately with the lines and headers
  21  */
  22 Buffer *
  23 fill_buffer(char *separator)
  24 {
  25         /* fill buffer with string */
  26         char    string[LINE_SIZE];
  27         Line   *last   = NULL;
  28         Buffer *buffer = malloc(sizeof(Buffer));
  29         FILE   *fp     = fopen("complete.c", "r");
  30
  31         if (!fp) {
  32                 die("Can not open file for reading.");
  33         }
  34
  35         /* read the file into a doubly linked list of lines. */
  36         while (fgets(string, LINE_SIZE, fp)) {
  37                 buffer->total++;
  38 ;
  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, "test")) {
 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 (line && input /* match */) {
 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)
 281 {
 282         struct winsize w;
 283         ioctl(STDOUT_FILENO, 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()
 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(0, &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(STDIN_FILENO, 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)
 335 {
 336         /* receive one character at a time from the terminal */
 337         struct termios termio_old = terminal_set();
 338
 339         /* get input char by char from the keyboard. */
 340         while (do_key(getchar(), buffer)) {
 341                 filter_lines(buffer);
 342                 update_screen(buffer, count, offset);
 343         }
 344
 345         /* resets the terminal to the previous state. */
 346         tcsetattr(STDIN_FILENO, TCSANOW, &termio_old);
 347 }
 348
 349 /*
 350  * Perform action associated with key
 351  */
 352 int
 353 do_key(char key, Buffer *buffer)
 354 {
 355         size_t length;
 356         int i;
 357
 358         switch (key) {
 359
 360         case CONTROL('C'):
 361                 return FALSE;
 362
 363         case CONTROL('U'):
 364                 buffer->input[0] = '\0';
 365                 break;
 366
 367         case CONTROL('W'):
 368                 length = strlen(buffer->input) - 1;
 369
 370                 for (i = length; i >= 0 && isspace(buffer->input[i]); i--) {
 371                         buffer->input[i] = '\0';
 372                 }
 373
 374                 length = strlen(buffer->input) - 1;
 375                 for (i = length; i >= 0 && !isspace(buffer->input[i]); i--) {
 376                         buffer->input[i] = '\0';
 377                 }
 378
 379                 break;
 380
 381         case CONTROL('H'):
 382         case 127:  /* backspace */
 383                 buffer->input[strlen(buffer->input) - 1] = '\0';
 384                 break;
 385
 386         case CONTROL('N'):
 387                 if (buffer->current->next) {
 388                         buffer->current = buffer->current->next;
 389                 }
 390
 391                 break;
 392
 393         case CONTROL('P'):
 394                 if (buffer->current->prev) {
 395                         buffer->current = buffer->current->prev;
 396                 }
 397                 break;
 398
 399         case CONTROL('M'):
 400         case CONTROL('J'):  /* enter */
 401                 fputs("\r\033[K", stderr);
 402                 puts(buffer->current->content);
 403                 return FALSE;
 404
 405         default:
 406                 if (isprint(key)) {
 407                         length = strlen(buffer->input);
 408                         buffer->input[length]     = key;
 409                         buffer->input[length + 1] = '\0';
 410                 }
 411         }
 412
 413         return TRUE;
 414 }
 415
 416 /*
 417  * Print the prompt, before the input, with the number of candidates that
 418  * match.
 419  */
 420 void
 421 print_prompt(Buffer *buffer, int cols)
 422 {
 423         size_t  i;
 424         int     digits   = 0;
 425         int     matching = buffer->matching;
 426         int     total    = buffer->total;
 427         char   *input    = expand_tabs(buffer->input);
 428         char   *suggest  = expand_tabs(buffer->current->content);
 429
 430         /* for the '/' separator between the numbers */
 431         cols--;
 432
 433         /* count the number of digits */
 434         for (i = matching; i; i /= 10, digits++);
 435         for (i = total;    i; i /= 10, digits++);
 436
 437         /* actual prompt */
 438         fputs("\r\033[K> ", stderr);
 439         cols -= 2;
 440
 441         /* input without overflowing terminal width */
 442         for (i = 0; i < strlen(input) && cols > digits; cols--, i++) {
 443                 fputc(input[i], stderr);
 444         }
 445
 446         /* save the cursor position at the end of the input */
 447         fputs("\033[s", stderr);
 448
 449         /* grey */
 450         fputs("\033[1;30m", stderr);
 451
 452         /* suggest without overflowing terminal width */
 453         for (i = 0; i < strlen(suggest) && cols > digits; cols--, i++) {
 454                 fputc(suggest[i], stderr);
 455         }
 456
 457         /* go to the end of the line */
 458         for (i = 0; cols > digits; cols--, i++) {
 459                 fputc(' ', stderr);
 460         }
 461
 462         /* total match and line count at the end of the line */
 463         fprintf(stderr, "%d/%d", matching, total);
 464
 465         /* restore cursor position at the end of the input */
 466         fputs("\033[u", stderr);
 467
 468         free(input);
 469         free(suggest);
 470 }
 471
 472 /*
 473  * Reset the terminal state and exit with error.
 474  */
 475 void die(const char *s)
 476 {
 477 /*      tcsetattr(STDIN_FILENO, TCSANOW, &termio_old); */
 478         fprintf(stderr, "%s\n", s);
 479         exit(EXIT_FAILURE);
 480
 481 }
 482
 483 int
 484 main(int argc, char *argv[])
 485 {
 486         int i;
 487         Buffer *buffer    = NULL;
 488         char   *separator = "* ";
 489         int count         = 30;
 490         int offset        = 3;
 491
 492
 493         /* command line arguments */
 494         for (i = 0; i <= argc; i++) {
 495                 if (argv[i][1] == '-') {
 496                         ;
 497                 }
 498         }
 499
 500         /* command line arguments */
 501         buffer = fill_buffer(separator);
 502
 503         /* set the interface */
 504         filter_lines(buffer);
 505         update_screen(buffer, count, offset);
 506
 507         /* listen and interact to input */
 508         get_input(buffer, count, offset);
 509
 510         clear_screen(count);
 511
 512         return 0;
 513 }