git.sur5r.net Git - i3/i3/blob - src/cfgparse.y

   1 %{
   2 /*
   3  * vim:ts=4:sw=4:expandtab
   4  *
   5  */
   6 #include <sys/types.h>
   7 #include <sys/stat.h>
   8 #include <sys/wait.h>
   9 #include <unistd.h>
  10 #include <fcntl.h>
  11
  12 #include "all.h"
  13
  14 static pid_t configerror_pid = -1;
  15
  16 static Match current_match;
  17
  18 typedef struct yy_buffer_state *YY_BUFFER_STATE;
  19 extern int yylex(struct context *context);
  20 extern int yyparse(void);
  21 extern int yylex_destroy(void);
  22 extern FILE *yyin;
  23 YY_BUFFER_STATE yy_scan_string(const char *);
  24
  25 static struct bindings_head *current_bindings;
  26 static struct context *context;
  27
  28 /* We don’t need yydebug for now, as we got decent error messages using
  29  * yyerror(). Should you ever want to extend the parser, it might be handy
  30  * to just comment it in again, so it stays here. */
  31 //int yydebug = 1;
  32
  33 void yyerror(const char *error_message) {
  34     context->has_errors = true;
  35
  36     ELOG("\n");
  37     ELOG("CONFIG: %s\n", error_message);
  38     ELOG("CONFIG: in file \"%s\", line %d:\n",
  39         context->filename, context->line_number);
  40     ELOG("CONFIG:   %s\n", context->line_copy);
  41     char buffer[context->last_column+1];
  42     buffer[context->last_column] = '\0';
  43     for (int c = 1; c <= context->last_column; c++)
  44         buffer[c-1] = (c >= context->first_column ? '^' : ' ');
  45     ELOG("CONFIG:   %s\n", buffer);
  46     ELOG("\n");
  47 }
  48
  49 int yywrap() {
  50     return 1;
  51 }
  52
  53 /*
  54  * Goes through each line of buf (separated by \n) and checks for statements /
  55  * commands which only occur in i3 v4 configuration files. If it finds any, it
  56  * returns version 4, otherwise it returns version 3.
  57  *
  58  */
  59 static int detect_version(char *buf) {
  60     char *walk = buf;
  61     char *line = buf;
  62     while (*walk != '\0') {
  63         if (*walk != '\n') {
  64             walk++;
  65             continue;
  66         }
  67
  68         /* check for some v4-only statements */
  69         if (strncasecmp(line, "bindcode", strlen("bindcode")) == 0 ||
  70             strncasecmp(line, "force_focus_wrapping", strlen("force_focus_wrapping")) == 0 ||
  71             strncasecmp(line, "# i3 config file (v4)", strlen("# i3 config file (v4)")) == 0 ||
  72             strncasecmp(line, "workspace_layout", strlen("workspace_layout")) == 0) {
  73             printf("deciding for version 4 due to this line: %.*s\n", (int)(walk-line), line);
  74             return 4;
  75         }
  76
  77         /* if this is a bind statement, we can check the command */
  78         if (strncasecmp(line, "bind", strlen("bind")) == 0) {
  79             char *bind = strchr(line, ' ');
  80             if (bind == NULL)
  81                 goto next;
  82             while ((*bind == ' ' || *bind == '\t') && *bind != '\0')
  83                 bind++;
  84             if (*bind == '\0')
  85                 goto next;
  86             if ((bind = strchr(bind, ' ')) == NULL)
  87                 goto next;
  88             while ((*bind == ' ' || *bind == '\t') && *bind != '\0')
  89                 bind++;
  90             if (*bind == '\0')
  91                 goto next;
  92             if (strncasecmp(bind, "layout", strlen("layout")) == 0 ||
  93                 strncasecmp(bind, "floating", strlen("floating")) == 0 ||
  94                 strncasecmp(bind, "workspace", strlen("workspace")) == 0 ||
  95                 strncasecmp(bind, "focus left", strlen("focus left")) == 0 ||
  96                 strncasecmp(bind, "focus right", strlen("focus right")) == 0 ||
  97                 strncasecmp(bind, "focus up", strlen("focus up")) == 0 ||
  98                 strncasecmp(bind, "focus down", strlen("focus down")) == 0 ||
  99                 strncasecmp(bind, "border normal", strlen("border normal")) == 0 ||
 100                 strncasecmp(bind, "border 1pixel", strlen("border 1pixel")) == 0 ||
 101                 strncasecmp(bind, "border borderless", strlen("border borderless")) == 0) {
 102                 printf("deciding for version 4 due to this line: %.*s\n", (int)(walk-line), line);
 103                 return 4;
 104             }
 105         }
 106
 107 next:
 108         /* advance to the next line */
 109         walk++;
 110         line = walk;
 111     }
 112
 113     return 3;
 114 }
 115
 116 /*
 117  * Calls i3-migrate-config-to-v4 to migrate a configuration file (input
 118  * buffer).
 119  *
 120  * Returns the converted config file or NULL if there was an error (for
 121  * example the script could not be found in $PATH or the i3 executable’s
 122  * directory).
 123  *
 124  */
 125 static char *migrate_config(char *input, off_t size) {
 126     int writepipe[2];
 127     int readpipe[2];
 128
 129     if (pipe(writepipe) != 0 ||
 130         pipe(readpipe) != 0) {
 131         warn("migrate_config: Could not create pipes");
 132         return NULL;
 133     }
 134
 135     pid_t pid = fork();
 136     if (pid == -1) {
 137         warn("Could not fork()");
 138         return NULL;
 139     }
 140
 141     /* child */
 142     if (pid == 0) {
 143         /* close writing end of writepipe, connect reading side to stdin */
 144         close(writepipe[1]);
 145         dup2(writepipe[0], 0);
 146
 147         /* close reading end of readpipe, connect writing side to stdout */
 148         close(readpipe[0]);
 149         dup2(readpipe[1], 1);
 150
 151         static char *argv[] = {
 152             NULL, /* will be replaced by the executable path */
 153             NULL
 154         };
 155         exec_i3_utility("i3-migrate-config-to-v4", argv);
 156     }
 157
 158     /* parent */
 159
 160     /* close reading end of the writepipe (connected to the script’s stdin) */
 161     close(writepipe[0]);
 162
 163     /* write the whole config file to the pipe, the script will read everything
 164      * immediately */
 165     int written = 0;
 166     int ret;
 167     while (written < size) {
 168         if ((ret = write(writepipe[1], input + written, size - written)) < 0) {
 169             warn("Could not write to pipe");
 170             return NULL;
 171         }
 172         written += ret;
 173     }
 174     close(writepipe[1]);
 175
 176     /* close writing end of the readpipe (connected to the script’s stdout) */
 177     close(readpipe[1]);
 178
 179     /* read the script’s output */
 180     int conv_size = 65535;
 181     char *converted = malloc(conv_size);
 182     int read_bytes = 0;
 183     do {
 184         if (read_bytes == conv_size) {
 185             conv_size += 65535;
 186             converted = realloc(converted, conv_size);
 187         }
 188         ret = read(readpipe[0], converted + read_bytes, conv_size - read_bytes);
 189         if (ret == -1) {
 190             warn("Cannot read from pipe");
 191             return NULL;
 192         }
 193         read_bytes += ret;
 194     } while (ret > 0);
 195
 196     /* get the returncode */
 197     int status;
 198     wait(&status);
 199     if (!WIFEXITED(status)) {
 200         fprintf(stderr, "Child did not terminate normally, using old config file (will lead to broken behaviour)\n");
 201         return NULL;
 202     }
 203
 204     int returncode = WEXITSTATUS(status);
 205     if (returncode != 0) {
 206         fprintf(stderr, "Migration process exit code was != 0\n");
 207         if (returncode == 2) {
 208             fprintf(stderr, "could not start the migration script\n");
 209             /* TODO: script was not found. tell the user to fix his system or create a v4 config */
 210         } else if (returncode == 1) {
 211             fprintf(stderr, "This already was a v4 config. Please add the following line to your config file:\n");
 212             fprintf(stderr, "# i3 config file (v4)\n");
 213             /* TODO: nag the user with a message to include a hint for i3 in his config file */
 214         }
 215         return NULL;
 216     }
 217
 218     return converted;
 219 }
 220
 221 /*
 222  * Handler which will be called when we get a SIGCHLD for the nagbar, meaning
 223  * it exited (or could not be started, depending on the exit code).
 224  *
 225  */
 226 static void nagbar_exited(EV_P_ ev_child *watcher, int revents) {
 227     ev_child_stop(EV_A_ watcher);
 228     if (!WIFEXITED(watcher->rstatus)) {
 229         fprintf(stderr, "ERROR: i3-nagbar did not exit normally.\n");
 230         return;
 231     }
 232
 233     int exitcode = WEXITSTATUS(watcher->rstatus);
 234     printf("i3-nagbar process exited with status %d\n", exitcode);
 235     if (exitcode == 2) {
 236         fprintf(stderr, "ERROR: i3-nagbar could not be found. Is it correctly installed on your system?\n");
 237     }
 238
 239     configerror_pid = -1;
 240 }
 241
 242 /*
 243  * Starts an i3-nagbar process which alerts the user that his configuration
 244  * file contains one or more errors. Also offers two buttons: One to launch an
 245  * $EDITOR on the config file and another one to launch a $PAGER on the error
 246  * logfile.
 247  *
 248  */
 249 static void start_configerror_nagbar(const char *config_path) {
 250     fprintf(stderr, "Would start i3-nagscreen now\n");
 251     configerror_pid = fork();
 252     if (configerror_pid == -1) {
 253         warn("Could not fork()");
 254         return;
 255     }
 256
 257     /* child */
 258     if (configerror_pid == 0) {
 259         char *editaction,
 260              *pageraction;
 261         if (asprintf(&editaction, TERM_EMU " -e sh -c \"${EDITOR:-vi} \"%s\" && i3-msg reload\"", config_path) == -1)
 262             exit(1);
 263         if (asprintf(&pageraction, TERM_EMU " -e sh -c \"${PAGER:-less} \"%s\"\"", errorfilename) == -1)
 264             exit(1);
 265         char *argv[] = {
 266             NULL, /* will be replaced by the executable path */
 267             "-m",
 268             "You have an error in your i3 config file!",
 269             "-b",
 270             "edit config",
 271             editaction,
 272             (errorfilename ? "-b" : NULL),
 273             "show errors",
 274             pageraction,
 275             NULL
 276         };
 277         exec_i3_utility("i3-nagbar", argv);
 278     }
 279
 280     /* parent */
 281     /* install a child watcher */
 282     ev_child *child = smalloc(sizeof(ev_child));
 283     ev_child_init(child, &nagbar_exited, configerror_pid, 0);
 284     ev_child_start(main_loop, child);
 285 }
 286
 287 /*
 288  * Kills the configerror i3-nagbar process, if any.
 289  *
 290  * Called when reloading/restarting.
 291  *
 292  * If wait_for_it is set (restarting), this function will waitpid(), otherwise,
 293  * ev is assumed to handle it (reloading).
 294  *
 295  */
 296 void kill_configerror_nagbar(bool wait_for_it) {
 297     if (configerror_pid == -1)
 298         return;
 299
 300     if (kill(configerror_pid, SIGTERM) == -1)
 301         warn("kill(configerror_nagbar) failed");
 302
 303     if (!wait_for_it)
 304         return;
 305
 306     /* When restarting, we don’t enter the ev main loop anymore and after the
 307      * exec(), our old pid is no longer watched. So, ev won’t handle SIGCHLD
 308      * for us and we would end up with a <defunct> process. Therefore we
 309      * waitpid() here. */
 310     waitpid(configerror_pid, NULL, 0);
 311 }
 312
 313 /*
 314  * Checks for duplicate key bindings (the same keycode or keysym is configured
 315  * more than once). If a duplicate binding is found, a message is printed to
 316  * stderr and the has_errors variable is set to true, which will start
 317  * i3-nagbar.
 318  *
 319  */
 320 static void check_for_duplicate_bindings(struct context *context) {
 321     Binding *bind, *current;
 322     TAILQ_FOREACH(current, bindings, bindings) {
 323         TAILQ_FOREACH(bind, bindings, bindings) {
 324             /* Abort when we reach the current keybinding, only check the
 325              * bindings before */
 326             if (bind == current)
 327                 break;
 328
 329             /* Check if one is using keysym while the other is using bindsym.
 330              * If so, skip. */
 331             /* XXX: It should be checked at a later place (when translating the
 332              * keysym to keycodes) if there are any duplicates */
 333             if ((bind->symbol == NULL && current->symbol != NULL) ||
 334                 (bind->symbol != NULL && current->symbol == NULL))
 335                 continue;
 336
 337             /* If bind is NULL, current has to be NULL, too (see above).
 338              * If the keycodes differ, it can't be a duplicate. */
 339             if (bind->symbol != NULL &&
 340                 strcasecmp(bind->symbol, current->symbol) != 0)
 341                 continue;
 342
 343             /* Check if the keycodes or modifiers are different. If so, they
 344              * can't be duplicate */
 345             if (bind->keycode != current->keycode ||
 346                 bind->mods != current->mods)
 347                 continue;
 348             context->has_errors = true;
 349             if (current->keycode != 0) {
 350                 ELOG("Duplicate keybinding in config file:\n  modmask %d with keycode %d, command \"%s\"\n",
 351                      current->mods, current->keycode, current->command);
 352             } else {
 353                 ELOG("Duplicate keybinding in config file:\n  modmask %d with keysym %s, command \"%s\"\n",
 354                      current->mods, current->symbol, current->command);
 355             }
 356         }
 357     }
 358 }
 359
 360 void parse_file(const char *f) {
 361     SLIST_HEAD(variables_head, Variable) variables = SLIST_HEAD_INITIALIZER(&variables);
 362     int fd, ret, read_bytes = 0;
 363     struct stat stbuf;
 364     char *buf;
 365     FILE *fstr;
 366     char buffer[1026], key[512], value[512];
 367
 368     if ((fd = open(f, O_RDONLY)) == -1)
 369         die("Could not open configuration file: %s\n", strerror(errno));
 370
 371     if (fstat(fd, &stbuf) == -1)
 372         die("Could not fstat file: %s\n", strerror(errno));
 373
 374     buf = scalloc((stbuf.st_size + 1) * sizeof(char));
 375     while (read_bytes < stbuf.st_size) {
 376         if ((ret = read(fd, buf + read_bytes, (stbuf.st_size - read_bytes))) < 0)
 377             die("Could not read(): %s\n", strerror(errno));
 378         read_bytes += ret;
 379     }
 380
 381     if (lseek(fd, 0, SEEK_SET) == (off_t)-1)
 382         die("Could not lseek: %s\n", strerror(errno));
 383
 384     if ((fstr = fdopen(fd, "r")) == NULL)
 385         die("Could not fdopen: %s\n", strerror(errno));
 386
 387     while (!feof(fstr)) {
 388         if (fgets(buffer, 1024, fstr) == NULL) {
 389             if (feof(fstr))
 390                 break;
 391             die("Could not read configuration file\n");
 392         }
 393
 394         /* sscanf implicitly strips whitespace. Also, we skip comments and empty lines. */
 395         if (sscanf(buffer, "%s %[^\n]", key, value) < 1 ||
 396             key[0] == '#' || strlen(key) < 3)
 397             continue;
 398
 399         if (strcasecmp(key, "set") == 0) {
 400             if (value[0] != '$')
 401                 die("Malformed variable assignment, name has to start with $\n");
 402
 403             /* get key/value for this variable */
 404             char *v_key = value, *v_value;
 405             if ((v_value = strstr(value, " ")) == NULL)
 406                 die("Malformed variable assignment, need a value\n");
 407
 408             *(v_value++) = '\0';
 409
 410             struct Variable *new = scalloc(sizeof(struct Variable));
 411             new->key = sstrdup(v_key);
 412             new->value = sstrdup(v_value);
 413             SLIST_INSERT_HEAD(&variables, new, variables);
 414             DLOG("Got new variable %s = %s\n", v_key, v_value);
 415             continue;
 416         }
 417     }
 418     fclose(fstr);
 419
 420     /* For every custom variable, see how often it occurs in the file and
 421      * how much extra bytes it requires when replaced. */
 422     struct Variable *current, *nearest;
 423     int extra_bytes = 0;
 424     /* We need to copy the buffer because we need to invalidate the
 425      * variables (otherwise we will count them twice, which is bad when
 426      * 'extra' is negative) */
 427     char *bufcopy = sstrdup(buf);
 428     SLIST_FOREACH(current, &variables, variables) {
 429         int extra = (strlen(current->value) - strlen(current->key));
 430         char *next;
 431         for (next = bufcopy;
 432              (next = strcasestr(bufcopy + (next - bufcopy), current->key)) != NULL;
 433              next += strlen(current->key)) {
 434             *next = '_';
 435             extra_bytes += extra;
 436         }
 437     }
 438     FREE(bufcopy);
 439
 440     /* Then, allocate a new buffer and copy the file over to the new one,
 441      * but replace occurences of our variables */
 442     char *walk = buf, *destwalk;
 443     char *new = smalloc((stbuf.st_size + extra_bytes + 1) * sizeof(char));
 444     destwalk = new;
 445     while (walk < (buf + stbuf.st_size)) {
 446         /* Find the next variable */
 447         SLIST_FOREACH(current, &variables, variables)
 448             current->next_match = strcasestr(walk, current->key);
 449         nearest = NULL;
 450         int distance = stbuf.st_size;
 451         SLIST_FOREACH(current, &variables, variables) {
 452             if (current->next_match == NULL)
 453                 continue;
 454             if ((current->next_match - walk) < distance) {
 455                 distance = (current->next_match - walk);
 456                 nearest = current;
 457             }
 458         }
 459         if (nearest == NULL) {
 460             /* If there are no more variables, we just copy the rest */
 461             strncpy(destwalk, walk, (buf + stbuf.st_size) - walk);
 462             destwalk += (buf + stbuf.st_size) - walk;
 463             *destwalk = '\0';
 464             break;
 465         } else {
 466             /* Copy until the next variable, then copy its value */
 467             strncpy(destwalk, walk, distance);
 468             strncpy(destwalk + distance, nearest->value, strlen(nearest->value));
 469             walk += distance + strlen(nearest->key);
 470             destwalk += distance + strlen(nearest->value);
 471         }
 472     }
 473
 474     /* analyze the string to find out whether this is an old config file (3.x)
 475      * or a new config file (4.x). If it’s old, we run the converter script. */
 476     int version = detect_version(buf);
 477     if (version == 3) {
 478         /* We need to convert this v3 configuration */
 479         char *converted = migrate_config(new, stbuf.st_size);
 480         if (converted != NULL) {
 481             printf("\n");
 482             printf("****************************************************************\n");
 483             printf("NOTE: Automatically converted configuration file from v3 to v4.\n");
 484             printf("\n");
 485             printf("Please convert your config file to v4. You can use this command:\n");
 486             printf("    mv %s %s.O\n", f, f);
 487             printf("    i3-migrate-config-to-v4 %s.O > %s\n", f, f);
 488             printf("****************************************************************\n");
 489             printf("\n");
 490             free(new);
 491             new = converted;
 492         } else {
 493             printf("\n");
 494             printf("**********************************************************************\n");
 495             printf("ERROR: Could not convert config file. Maybe i3-migrate-config-to-v4\n");
 496             printf("was not correctly installed on your system?\n");
 497             printf("**********************************************************************\n");
 498             printf("\n");
 499         }
 500     }
 501
 502     /* now lex/parse it */
 503     yy_scan_string(new);
 504
 505     context = scalloc(sizeof(struct context));
 506     context->filename = f;
 507
 508     if (yyparse() != 0) {
 509         fprintf(stderr, "Could not parse configfile\n");
 510         exit(1);
 511     }
 512
 513     check_for_duplicate_bindings(context);
 514
 515     if (context->has_errors) {
 516         start_configerror_nagbar(f);
 517     }
 518
 519     yylex_destroy();
 520     FREE(context->line_copy);
 521     free(context);
 522     free(new);
 523     free(buf);
 524
 525     while (!SLIST_EMPTY(&variables)) {
 526         current = SLIST_FIRST(&variables);
 527         FREE(current->key);
 528         FREE(current->value);
 529         SLIST_REMOVE_HEAD(&variables, variables);
 530         FREE(current);
 531     }
 532 }
 533
 534 %}
 535
 536 %error-verbose
 537 %lex-param { struct context *context }
 538
 539 %union {
 540     int number;
 541     char *string;
 542     uint32_t *single_color;
 543     struct Colortriple *color;
 544     Match *match;
 545     struct Binding *binding;
 546 }
 547
 548 %token  <number>        NUMBER                      "<number>"
 549 %token  <string>        WORD                        "<word>"
 550 %token  <string>        STR                         "<string>"
 551 %token  <string>        STR_NG                      "<string (non-greedy)>"
 552 %token  <string>        HEX                         "<hex>"
 553 %token  <string>        OUTPUT                      "<RandR output>"
 554 %token                  TOKBINDCODE
 555 %token                  TOKTERMINAL
 556 %token                  TOKCOMMENT                  "<comment>"
 557 %token                  TOKFONT                     "font"
 558 %token                  TOKBINDSYM                  "bindsym"
 559 %token  <number>        MODIFIER                    "<modifier>"
 560 %token                  TOKCONTROL                  "control"
 561 %token                  TOKSHIFT                    "shift"
 562 %token                  TOKFLOATING_MODIFIER        "floating_modifier"
 563 %token  <string>        QUOTEDSTRING                "<quoted string>"
 564 %token                  TOKWORKSPACE                "workspace"
 565 %token                  TOKOUTPUT                   "output"
 566 %token                  TOKASSIGN                   "assign"
 567 %token                  TOKSET
 568 %token                  TOKIPCSOCKET                "ipc_socket"
 569 %token                  TOKRESTARTSTATE             "restart_state"
 570 %token                  TOKEXEC                     "exec"
 571 %token                  TOKEXEC_ALWAYS              "exec_always"
 572 %token  <single_color>  TOKSINGLECOLOR
 573 %token  <color>         TOKCOLOR
 574 %token                  TOKARROW                    "→"
 575 %token                  TOKMODE                     "mode"
 576 %token                  TOK_ORIENTATION             "default_orientation"
 577 %token                  TOK_HORIZ                   "horizontal"
 578 %token                  TOK_VERT                    "vertical"
 579 %token                  TOK_AUTO                    "auto"
 580 %token                  TOK_WORKSPACE_LAYOUT        "workspace_layout"
 581 %token                  TOKNEWWINDOW                "new_window"
 582 %token                  TOKNEWFLOAT                 "new_float"
 583 %token                  TOK_NORMAL                  "normal"
 584 %token                  TOK_NONE                    "none"
 585 %token                  TOK_1PIXEL                  "1pixel"
 586 %token                  TOKFOCUSFOLLOWSMOUSE        "focus_follows_mouse"
 587 %token                  TOK_FORCE_FOCUS_WRAPPING    "force_focus_wrapping"
 588 %token                  TOKWORKSPACEBAR             "workspace_bar"
 589 %token                  TOK_DEFAULT                 "default"
 590 %token                  TOK_STACKING                "stacking"
 591 %token                  TOK_TABBED                  "tabbed"
 592 %token  <number>        TOKSTACKLIMIT               "stack-limit"
 593 %token                  TOK_POPUP_DURING_FULLSCREEN "popup_during_fullscreen"
 594 %token                  TOK_IGNORE                  "ignore"
 595 %token                  TOK_LEAVE_FULLSCREEN        "leave_fullscreen"
 596 %token                  TOK_FOR_WINDOW              "for_window"
 597
 598 %token              TOK_MARK            "mark"
 599 %token              TOK_CLASS           "class"
 600 %token              TOK_INSTANCE        "instance"
 601 %token              TOK_ID              "id"
 602 %token              TOK_CON_ID          "con_id"
 603 %token              TOK_TITLE           "title"
 604
 605 %type   <binding>       binding
 606 %type   <binding>       bindcode
 607 %type   <binding>       bindsym
 608 %type   <number>        binding_modifiers
 609 %type   <number>        binding_modifier
 610 %type   <number>        direction
 611 %type   <number>        layout_mode
 612 %type   <number>        border_style
 613 %type   <number>        new_window
 614 %type   <number>        new_float
 615 %type   <number>        colorpixel
 616 %type   <number>        bool
 617 %type   <number>        popup_setting
 618 %type   <string>        command
 619 %type   <string>        word_or_number
 620 %type   <string>        optional_workspace_name
 621 %type   <string>        workspace_name
 622 %type   <string>        window_class
 623
 624 %%
 625
 626 lines: /* empty */
 627     | lines error
 628     | lines line
 629     ;
 630
 631 line:
 632     bindline
 633     | for_window
 634     | mode
 635     | floating_modifier
 636     | orientation
 637     | workspace_layout
 638     | new_window
 639     | new_float
 640     | focus_follows_mouse
 641     | force_focus_wrapping
 642     | workspace_bar
 643     | workspace
 644     | assign
 645     | ipcsocket
 646     | restart_state
 647     | exec
 648     | exec_always
 649     | single_color
 650     | color
 651     | terminal
 652     | font
 653     | comment
 654     | popup_during_fullscreen
 655     ;
 656
 657 comment:
 658     TOKCOMMENT
 659     ;
 660
 661 command:
 662     STR
 663     ;
 664
 665 bindline:
 666     binding
 667     {
 668         TAILQ_INSERT_TAIL(bindings, $1, bindings);
 669     }
 670     ;
 671
 672 binding:
 673     TOKBINDCODE bindcode         { $$ = $2; }
 674     | TOKBINDSYM bindsym         { $$ = $2; }
 675     ;
 676
 677 bindcode:
 678     binding_modifiers NUMBER command
 679     {
 680         printf("\tFound keycode binding mod%d with key %d and command %s\n", $1, $2, $3);
 681         Binding *new = scalloc(sizeof(Binding));
 682
 683         new->keycode = $2;
 684         new->mods = $1;
 685         new->command = $3;
 686
 687         $$ = new;
 688     }
 689     ;
 690
 691 bindsym:
 692     binding_modifiers word_or_number command
 693     {
 694         printf("\tFound keysym binding mod%d with key %s and command %s\n", $1, $2, $3);
 695         Binding *new = scalloc(sizeof(Binding));
 696
 697         new->symbol = $2;
 698         new->mods = $1;
 699         new->command = $3;
 700
 701         $$ = new;
 702     }
 703     ;
 704
 705 for_window:
 706     TOK_FOR_WINDOW match command
 707     {
 708         printf("\t should execute command %s for the criteria mentioned above\n", $3);
 709         Assignment *assignment = scalloc(sizeof(Assignment));
 710         assignment->type = A_COMMAND;
 711         assignment->match = current_match;
 712         assignment->dest.command = $3;
 713         TAILQ_INSERT_TAIL(&assignments, assignment, assignments);
 714     }
 715     ;
 716
 717 match:
 718     | matchstart criteria matchend
 719     {
 720         printf("match parsed\n");
 721     }
 722     ;
 723
 724 matchstart:
 725     '['
 726     {
 727         printf("start\n");
 728         match_init(&current_match);
 729     }
 730     ;
 731
 732 matchend:
 733     ']'
 734     {
 735         printf("match specification finished\n");
 736     }
 737     ;
 738
 739 criteria:
 740     criteria criterion
 741     | criterion
 742     ;
 743
 744 criterion:
 745     TOK_CLASS '=' STR
 746     {
 747         printf("criteria: class = %s\n", $3);
 748         current_match.class = $3;
 749     }
 750     | TOK_INSTANCE '=' STR
 751     {
 752         printf("criteria: instance = %s\n", $3);
 753         current_match.instance = $3;
 754     }
 755     | TOK_CON_ID '=' STR
 756     {
 757         printf("criteria: id = %s\n", $3);
 758         char *end;
 759         long parsed = strtol($3, &end, 10);
 760         if (parsed == LONG_MIN ||
 761             parsed == LONG_MAX ||
 762             parsed < 0 ||
 763             (end && *end != '\0')) {
 764             ELOG("Could not parse con id \"%s\"\n", $3);
 765         } else {
 766             current_match.con_id = (Con*)parsed;
 767             printf("id as int = %p\n", current_match.con_id);
 768         }
 769     }
 770     | TOK_ID '=' STR
 771     {
 772         printf("criteria: window id = %s\n", $3);
 773         char *end;
 774         long parsed = strtol($3, &end, 10);
 775         if (parsed == LONG_MIN ||
 776             parsed == LONG_MAX ||
 777             parsed < 0 ||
 778             (end && *end != '\0')) {
 779             ELOG("Could not parse window id \"%s\"\n", $3);
 780         } else {
 781             current_match.id = parsed;
 782             printf("window id as int = %d\n", current_match.id);
 783         }
 784     }
 785     | TOK_MARK '=' STR
 786     {
 787         printf("criteria: mark = %s\n", $3);
 788         current_match.mark = $3;
 789     }
 790     | TOK_TITLE '=' STR
 791     {
 792         printf("criteria: title = %s\n", $3);
 793         current_match.title = $3;
 794     }
 795     ;
 796
 797
 798
 799 word_or_number:
 800     WORD
 801     | NUMBER
 802     {
 803         asprintf(&$$, "%d", $1);
 804     }
 805     ;
 806
 807 mode:
 808     TOKMODE QUOTEDSTRING '{' modelines '}'
 809     {
 810         if (strcasecmp($2, "default") == 0) {
 811             printf("You cannot use the name \"default\" for your mode\n");
 812             exit(1);
 813         }
 814         printf("\t now in mode %s\n", $2);
 815         printf("\t current bindings = %p\n", current_bindings);
 816         Binding *binding;
 817         TAILQ_FOREACH(binding, current_bindings, bindings) {
 818             printf("got binding on mods %d, keycode %d, symbol %s, command %s\n",
 819                             binding->mods, binding->keycode, binding->symbol, binding->command);
 820         }
 821
 822         struct Mode *mode = scalloc(sizeof(struct Mode));
 823         mode->name = $2;
 824         mode->bindings = current_bindings;
 825         current_bindings = NULL;
 826         SLIST_INSERT_HEAD(&modes, mode, modes);
 827     }
 828     ;
 829
 830
 831 modelines:
 832     /* empty */
 833     | modelines modeline
 834     ;
 835
 836 modeline:
 837     comment
 838     | binding
 839     {
 840         if (current_bindings == NULL) {
 841             current_bindings = scalloc(sizeof(struct bindings_head));
 842             TAILQ_INIT(current_bindings);
 843         }
 844
 845         TAILQ_INSERT_TAIL(current_bindings, $1, bindings);
 846     }
 847     ;
 848
 849 floating_modifier:
 850     TOKFLOATING_MODIFIER binding_modifiers
 851     {
 852         DLOG("floating modifier = %d\n", $2);
 853         config.floating_modifier = $2;
 854     }
 855     ;
 856
 857 orientation:
 858     TOK_ORIENTATION direction
 859     {
 860         DLOG("New containers should start with split direction %d\n", $2);
 861         config.default_orientation = $2;
 862     }
 863     ;
 864
 865 direction:
 866     TOK_HORIZ       { $$ = HORIZ; }
 867     | TOK_VERT      { $$ = VERT; }
 868     | TOK_AUTO      { $$ = NO_ORIENTATION; }
 869     ;
 870
 871 workspace_layout:
 872     TOK_WORKSPACE_LAYOUT layout_mode
 873     {
 874         DLOG("new containers will be in mode %d\n", $2);
 875         config.default_layout = $2;
 876
 877 #if 0
 878         /* We also need to change the layout of the already existing
 879          * workspaces here. Workspaces may exist at this point because
 880          * of the other directives which are modifying workspaces
 881          * (setting the preferred screen or name). While the workspace
 882          * objects are already created, they have never been used.
 883          * Thus, the user very likely awaits the default container mode
 884          * to trigger in this case, regardless of where it is inside
 885          * his configuration file. */
 886         Workspace *ws;
 887         TAILQ_FOREACH(ws, workspaces, workspaces) {
 888                 if (ws->table == NULL)
 889                         continue;
 890                 switch_layout_mode(global_conn,
 891                                    ws->table[0][0],
 892                                    config.container_mode);
 893         }
 894 #endif
 895     }
 896     | TOK_WORKSPACE_LAYOUT TOKSTACKLIMIT TOKSTACKLIMIT NUMBER
 897     {
 898         DLOG("stack-limit %d with val %d\n", $3, $4);
 899         config.container_stack_limit = $3;
 900         config.container_stack_limit_value = $4;
 901
 902 #if 0
 903         /* See the comment above */
 904         Workspace *ws;
 905         TAILQ_FOREACH(ws, workspaces, workspaces) {
 906                 if (ws->table == NULL)
 907                         continue;
 908                 Container *con = ws->table[0][0];
 909                 con->stack_limit = config.container_stack_limit;
 910                 con->stack_limit_value = config.container_stack_limit_value;
 911         }
 912 #endif
 913     }
 914     ;
 915
 916 layout_mode:
 917     TOK_DEFAULT       { $$ = L_DEFAULT; }
 918     | TOK_STACKING    { $$ = L_STACKED; }
 919     | TOK_TABBED      { $$ = L_TABBED; }
 920     ;
 921
 922 new_window:
 923     TOKNEWWINDOW border_style
 924     {
 925         DLOG("new windows should start with border style %d\n", $2);
 926         config.default_border = $2;
 927     }
 928     ;
 929
 930 new_float:
 931     TOKNEWFLOAT border_style
 932     {
 933        DLOG("new floating windows should start with border style %d\n", $2);
 934        config.default_floating_border = $2;
 935     }
 936     ;
 937
 938 border_style:
 939     TOK_NORMAL      { $$ = BS_NORMAL; }
 940     | TOK_NONE      { $$ = BS_NONE; }
 941     | TOK_1PIXEL    { $$ = BS_1PIXEL; }
 942     ;
 943
 944 bool:
 945     NUMBER
 946     {
 947         $$ = ($1 == 1);
 948     }
 949     | WORD
 950     {
 951         DLOG("checking word \"%s\"\n", $1);
 952         $$ = (strcasecmp($1, "yes") == 0 ||
 953               strcasecmp($1, "true") == 0 ||
 954               strcasecmp($1, "on") == 0 ||
 955               strcasecmp($1, "enable") == 0 ||
 956               strcasecmp($1, "active") == 0);
 957     }
 958     ;
 959
 960 focus_follows_mouse:
 961     TOKFOCUSFOLLOWSMOUSE bool
 962     {
 963         DLOG("focus follows mouse = %d\n", $2);
 964         config.disable_focus_follows_mouse = !($2);
 965     }
 966     ;
 967
 968 force_focus_wrapping:
 969     TOK_FORCE_FOCUS_WRAPPING bool
 970     {
 971         DLOG("force focus wrapping = %d\n", $2);
 972         config.force_focus_wrapping = $2;
 973     }
 974     ;
 975
 976 workspace_bar:
 977     TOKWORKSPACEBAR bool
 978     {
 979         DLOG("workspace bar = %d\n", $2);
 980         config.disable_workspace_bar = !($2);
 981     }
 982     ;
 983
 984 workspace:
 985     TOKWORKSPACE NUMBER TOKOUTPUT OUTPUT optional_workspace_name
 986     {
 987         int ws_num = $2;
 988         if (ws_num < 1) {
 989             DLOG("Invalid workspace assignment, workspace number %d out of range\n", ws_num);
 990         } else {
 991             char *ws_name = NULL;
 992             if ($5 == NULL) {
 993                 asprintf(&ws_name, "%d", ws_num);
 994             } else {
 995                 ws_name = $5;
 996             }
 997
 998             DLOG("Should assign workspace %s to output %s\n", ws_name, $4);
 999             struct Workspace_Assignment *assignment = scalloc(sizeof(struct Workspace_Assignment));
1000             assignment->name = ws_name;
1001             assignment->output = $4;
1002             TAILQ_INSERT_TAIL(&ws_assignments, assignment, ws_assignments);
1003         }
1004     }
1005     | TOKWORKSPACE NUMBER workspace_name
1006     {
1007         int ws_num = $2;
1008         if (ws_num < 1) {
1009             DLOG("Invalid workspace assignment, workspace number %d out of range\n", ws_num);
1010         } else {
1011             DLOG("workspace name to: %s\n", $3);
1012 #if 0
1013             if ($<string>3 != NULL) {
1014                     workspace_set_name(workspace_get(ws_num - 1), $<string>3);
1015                     free($<string>3);
1016             }
1017 #endif
1018         }
1019     }
1020     ;
1021
1022 optional_workspace_name:
1023     /* empty */          { $$ = NULL; }
1024     | workspace_name     { $$ = $1; }
1025     ;
1026
1027 workspace_name:
1028     QUOTEDSTRING         { $$ = $1; }
1029     | STR                { $$ = $1; }
1030     | WORD               { $$ = $1; }
1031     ;
1032
1033 assign:
1034     TOKASSIGN window_class STR
1035     {
1036         printf("assignment of %s to *%s*\n", $2, $3);
1037         char *workspace = $3;
1038         char *criteria = $2;
1039
1040         Assignment *assignment = scalloc(sizeof(Assignment));
1041         Match *match = &(assignment->match);
1042         match_init(match);
1043
1044         char *separator = NULL;
1045         if ((separator = strchr(criteria, '/')) != NULL) {
1046             *(separator++) = '\0';
1047             match->title = sstrdup(separator);
1048         }
1049         if (*criteria != '\0')
1050             match->class = sstrdup(criteria);
1051         free(criteria);
1052
1053         printf("  class = %s\n", match->class);
1054         printf("  title = %s\n", match->title);
1055
1056         /* Compatibility with older versions: If the assignment target starts
1057          * with ~, we create the equivalent of:
1058          *
1059          * for_window [class="foo"] floating enable
1060          */
1061         if (*workspace == '~') {
1062             workspace++;
1063             if (*workspace == '\0') {
1064                 /* This assignment was *only* for floating */
1065                 assignment->type = A_COMMAND;
1066                 assignment->dest.command = sstrdup("floating enable");
1067                 TAILQ_INSERT_TAIL(&assignments, assignment, assignments);
1068                 break;
1069             } else {
1070                 /* Create a new assignment and continue afterwards */
1071                 Assignment *floating = scalloc(sizeof(Assignment));
1072                 match_copy(&(floating->match), match);
1073                 floating->type = A_COMMAND;
1074                 floating->dest.command = sstrdup("floating enable");
1075                 TAILQ_INSERT_TAIL(&assignments, floating, assignments);
1076             }
1077         }
1078
1079         assignment->type = A_TO_WORKSPACE;
1080         assignment->dest.workspace = workspace;
1081         TAILQ_INSERT_TAIL(&assignments, assignment, assignments);
1082     }
1083     ;
1084
1085 window_class:
1086     QUOTEDSTRING
1087     | STR_NG
1088     ;
1089
1090 ipcsocket:
1091     TOKIPCSOCKET STR
1092     {
1093         config.ipc_socket_path = $2;
1094     }
1095     ;
1096
1097 restart_state:
1098     TOKRESTARTSTATE STR
1099     {
1100         config.restart_state_path = $2;
1101     }
1102     ;
1103
1104 exec:
1105     TOKEXEC STR
1106     {
1107         struct Autostart *new = smalloc(sizeof(struct Autostart));
1108         new->command = $2;
1109         TAILQ_INSERT_TAIL(&autostarts, new, autostarts);
1110     }
1111     ;
1112
1113 exec_always:
1114     TOKEXEC_ALWAYS STR
1115     {
1116         struct Autostart *new = smalloc(sizeof(struct Autostart));
1117         new->command = $2;
1118         TAILQ_INSERT_TAIL(&autostarts_always, new, autostarts_always);
1119     }
1120     ;
1121
1122 terminal:
1123     TOKTERMINAL STR
1124     {
1125         ELOG("The terminal option is DEPRECATED and has no effect. "
1126             "Please remove it from your configuration file.\n");
1127     }
1128     ;
1129
1130 font:
1131     TOKFONT STR
1132     {
1133         config.font = load_font($2, true);
1134         printf("font %s\n", $2);
1135         free($2);
1136     }
1137     ;
1138
1139 single_color:
1140     TOKSINGLECOLOR colorpixel
1141     {
1142         uint32_t *dest = $1;
1143         *dest = $2;
1144     }
1145     ;
1146
1147 color:
1148     TOKCOLOR colorpixel colorpixel colorpixel
1149     {
1150         struct Colortriple *dest = $1;
1151
1152         dest->border = $2;
1153         dest->background = $3;
1154         dest->text = $4;
1155     }
1156     ;
1157
1158 colorpixel:
1159     '#' HEX
1160     {
1161         char *hex;
1162         if (asprintf(&hex, "#%s", $2) == -1)
1163             die("asprintf()");
1164         free($2);
1165         $$ = get_colorpixel(hex);
1166         free(hex);
1167     }
1168     ;
1169
1170
1171 binding_modifiers:
1172     /* NULL */                               { $$ = 0; }
1173     | binding_modifier
1174     | binding_modifiers '+' binding_modifier { $$ = $1 | $3; }
1175     | binding_modifiers '+'                  { $$ = $1; }
1176     ;
1177
1178 binding_modifier:
1179     MODIFIER        { $$ = $1; }
1180     | TOKCONTROL    { $$ = BIND_CONTROL; }
1181     | TOKSHIFT      { $$ = BIND_SHIFT; }
1182     ;
1183
1184 popup_during_fullscreen:
1185     TOK_POPUP_DURING_FULLSCREEN popup_setting
1186     {
1187         DLOG("popup_during_fullscreen setting: %d\n", $2);
1188         config.popup_during_fullscreen = $2;
1189     }
1190     ;
1191
1192 popup_setting:
1193     TOK_IGNORE              { $$ = PDF_IGNORE; }
1194     | TOK_LEAVE_FULLSCREEN  { $$ = PDF_LEAVE_FULLSCREEN; }
1195     ;