complete.c

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