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

   1 %{
   2 /*
   3  * vim:ts=8:expandtab
   4  *
   5  */
   6 #include <stdio.h>
   7 #include <string.h>
   8 #include <xcb/xcb.h>
   9 #include <sys/types.h>
  10 #include <sys/stat.h>
  11 #include <unistd.h>
  12 #include <fcntl.h>
  13 #include <stdlib.h>
  14 #include <errno.h>
  15
  16 #include "data.h"
  17 #include "config.h"
  18 #include "i3.h"
  19 #include "util.h"
  20 #include "queue.h"
  21 #include "table.h"
  22 #include "workspace.h"
  23 #include "xcb.h"
  24 #include "log.h"
  25
  26 typedef struct yy_buffer_state *YY_BUFFER_STATE;
  27 extern int yylex(void);
  28 extern int yyparse(void);
  29 extern FILE *yyin;
  30 YY_BUFFER_STATE yy_scan_string(const char *);
  31
  32 static struct bindings_head *current_bindings;
  33
  34 int yydebug = 1;
  35
  36 void yyerror(const char *str) {
  37         fprintf(stderr,"error: %s\n",str);
  38 }
  39
  40 int yywrap() {
  41         return 1;
  42 }
  43
  44 void parse_file(const char *f) {
  45         SLIST_HEAD(variables_head, Variable) variables = SLIST_HEAD_INITIALIZER(&variables);
  46         int fd, ret, read_bytes = 0;
  47         struct stat stbuf;
  48         char *buf;
  49         FILE *fstr;
  50         char buffer[1026], key[512], value[512];
  51
  52         if ((fd = open(f, O_RDONLY)) == -1)
  53                 die("Could not open configuration file: %s\n", strerror(errno));
  54
  55         if (fstat(fd, &stbuf) == -1)
  56                 die("Could not fstat file: %s\n", strerror(errno));
  57
  58         buf = smalloc(stbuf.st_size * sizeof(char));
  59         while (read_bytes < stbuf.st_size) {
  60                 if ((ret = read(fd, buf + read_bytes, (stbuf.st_size - read_bytes))) < 0)
  61                         die("Could not read(): %s\n", strerror(errno));
  62                 read_bytes += ret;
  63         }
  64
  65         if (lseek(fd, 0, SEEK_SET) == (off_t)-1)
  66                 die("Could not lseek: %s\n", strerror(errno));
  67
  68         if ((fstr = fdopen(fd, "r")) == NULL)
  69                 die("Could not fdopen: %s\n", strerror(errno));
  70
  71         while (!feof(fstr)) {
  72                 if (fgets(buffer, 1024, fstr) == NULL) {
  73                         if (feof(fstr))
  74                                 break;
  75                         die("Could not read configuration file\n");
  76                 }
  77
  78                 /* sscanf implicitly strips whitespace. Also, we skip comments and empty lines. */
  79                 if (sscanf(buffer, "%s %[^\n]", key, value) < 1 ||
  80                     key[0] == '#' || strlen(key) < 3)
  81                         continue;
  82
  83                 if (strcasecmp(key, "set") == 0) {
  84                         if (value[0] != '$')
  85                                 die("Malformed variable assignment, name has to start with $\n");
  86
  87                         /* get key/value for this variable */
  88                         char *v_key = value, *v_value;
  89                         if ((v_value = strstr(value, " ")) == NULL)
  90                                 die("Malformed variable assignment, need a value\n");
  91
  92                         *(v_value++) = '\0';
  93
  94                         struct Variable *new = scalloc(sizeof(struct Variable));
  95                         new->key = sstrdup(v_key);
  96                         new->value = sstrdup(v_value);
  97                         SLIST_INSERT_HEAD(&variables, new, variables);
  98                         DLOG("Got new variable %s = %s\n", v_key, v_value);
  99                         continue;
 100                 }
 101         }
 102
 103         /* For every custom variable, see how often it occurs in the file and
 104          * how much extra bytes it requires when replaced. */
 105         struct Variable *current, *nearest;
 106         int extra_bytes = 0;
 107         SLIST_FOREACH(current, &variables, variables) {
 108                 int extra = (strlen(current->value) - strlen(current->key));
 109                 char *next;
 110                 for (next = buf;
 111                      (next = strcasestr(buf + (next - buf), current->key)) != NULL;
 112                      next += strlen(current->key))
 113                         extra_bytes += extra;
 114         }
 115
 116         /* Then, allocate a new buffer and copy the file over to the new one,
 117          * but replace occurences of our variables */
 118         char *walk = buf, *destwalk;
 119         char *new = smalloc((stbuf.st_size + extra_bytes + 1) * sizeof(char));
 120         destwalk = new;
 121         while (walk < (buf + stbuf.st_size)) {
 122                 /* Find the next variable */
 123                 SLIST_FOREACH(current, &variables, variables)
 124                         current->next_match = strcasestr(walk, current->key);
 125                 nearest = NULL;
 126                 int distance = stbuf.st_size;
 127                 SLIST_FOREACH(current, &variables, variables) {
 128                         if (current->next_match == NULL)
 129                                 continue;
 130                         if ((current->next_match - walk) < distance) {
 131                                 distance = (current->next_match - walk);
 132                                 nearest = current;
 133                         }
 134                 }
 135                 if (nearest == NULL) {
 136                         /* If there are no more variables, we just copy the rest */
 137                         strncpy(destwalk, walk, (buf + stbuf.st_size) - walk);
 138                         destwalk += (buf + stbuf.st_size) - walk;
 139                         *destwalk = '\0';
 140                         break;
 141                 } else {
 142                         /* Copy until the next variable, then copy its value */
 143                         strncpy(destwalk, walk, distance);
 144                         strncpy(destwalk + distance, nearest->value, strlen(nearest->value));
 145                         walk += distance + strlen(nearest->key);
 146                         destwalk += distance + strlen(nearest->value);
 147                 }
 148         }
 149
 150         yy_scan_string(new);
 151
 152         if (yyparse() != 0) {
 153                 fprintf(stderr, "Could not parse configfile\n");
 154                 exit(1);
 155         }
 156
 157         free(new);
 158         free(buf);
 159 }
 160
 161 %}
 162
 163 %expect 1
 164
 165 %union {
 166         int number;
 167         char *string;
 168         struct Colortriple *color;
 169         struct Assignment *assignment;
 170         struct Binding *binding;
 171 }
 172
 173 %token <number>NUMBER
 174 %token <string>WORD
 175 %token <string>STR
 176 %token <string>STR_NG
 177 %token <string>HEX
 178 %token TOKBIND
 179 %token TOKTERMINAL
 180 %token TOKCOMMENT
 181 %token TOKFONT
 182 %token TOKBINDSYM
 183 %token MODIFIER
 184 %token TOKCONTROL
 185 %token TOKSHIFT
 186 %token WHITESPACE
 187 %token TOKFLOATING_MODIFIER
 188 %token QUOTEDSTRING
 189 %token TOKWORKSPACE
 190 %token TOKSCREEN
 191 %token TOKASSIGN
 192 %token TOKSET
 193 %token TOKIPCSOCKET
 194 %token TOKEXEC
 195 %token TOKCOLOR
 196 %token TOKARROW
 197 %token TOKMODE
 198 %token TOKNEWCONTAINER
 199 %token TOKNEWWINDOW
 200 %token TOKFOCUSFOLLOWSMOUSE
 201 %token TOKCONTAINERMODE
 202 %token TOKSTACKLIMIT
 203
 204 %%
 205
 206 lines: /* empty */
 207         | lines WHITESPACE line
 208         | lines line
 209         ;
 210
 211 line:
 212         bindline
 213         | mode
 214         | floating_modifier
 215         | new_container
 216         | new_window
 217         | focus_follows_mouse
 218         | workspace
 219         | assign
 220         | ipcsocket
 221         | exec
 222         | color
 223         | terminal
 224         | font
 225         | comment
 226         ;
 227
 228 comment:
 229         TOKCOMMENT
 230         ;
 231
 232 command:
 233         STR
 234         ;
 235
 236 bindline:
 237         binding
 238         {
 239                 TAILQ_INSERT_TAIL(bindings, $<binding>1, bindings);
 240         }
 241         ;
 242
 243 binding:
 244         TOKBIND WHITESPACE bind                 { $<binding>$ = $<binding>3; }
 245         | TOKBINDSYM WHITESPACE bindsym         { $<binding>$ = $<binding>3; }
 246         ;
 247
 248 bind:
 249         binding_modifiers NUMBER WHITESPACE command
 250         {
 251                 printf("\tFound binding mod%d with key %d and command %s\n", $<number>1, $2, $<string>4);
 252                 Binding *new = scalloc(sizeof(Binding));
 253
 254                 new->keycode = $<number>2;
 255                 new->mods = $<number>1;
 256                 new->command = sstrdup($<string>4);
 257
 258                 $<binding>$ = new;
 259         }
 260         ;
 261
 262 bindsym:
 263         binding_modifiers word_or_number WHITESPACE command
 264         {
 265                 printf("\tFound symbolic mod%d with key %s and command %s\n", $<number>1, $<string>2, $<string>4);
 266                 Binding *new = scalloc(sizeof(Binding));
 267
 268                 new->symbol = sstrdup($<string>2);
 269                 new->mods = $<number>1;
 270                 new->command = sstrdup($<string>4);
 271
 272                 $<binding>$ = new;
 273         }
 274         ;
 275
 276 word_or_number:
 277         WORD
 278         | NUMBER
 279         {
 280                 asprintf(&$<string>$, "%d", $1);
 281         }
 282         ;
 283
 284 mode:
 285         TOKMODE WHITESPACE QUOTEDSTRING WHITESPACE '{' modelines '}'
 286         {
 287                 if (strcasecmp($<string>3, "default") == 0) {
 288                         printf("You cannot use the name \"default\" for your mode\n");
 289                         exit(1);
 290                 }
 291                 printf("\t now in mode %s\n", $<string>3);
 292                 printf("\t current bindings = %p\n", current_bindings);
 293                 Binding *binding;
 294                 TAILQ_FOREACH(binding, current_bindings, bindings) {
 295                         printf("got binding on mods %d, keycode %d, symbol %s, command %s\n",
 296                                         binding->mods, binding->keycode, binding->symbol, binding->command);
 297                 }
 298
 299                 struct Mode *mode = scalloc(sizeof(struct Mode));
 300                 mode->name = strdup($<string>3);
 301                 mode->bindings = current_bindings;
 302                 current_bindings = NULL;
 303                 SLIST_INSERT_HEAD(&modes, mode, modes);
 304         }
 305         ;
 306
 307
 308 modelines:
 309         /* empty */
 310         | modelines modeline
 311         ;
 312
 313 modeline:
 314         WHITESPACE
 315         | comment
 316         | binding
 317         {
 318                 if (current_bindings == NULL) {
 319                         current_bindings = scalloc(sizeof(struct bindings_head));
 320                         TAILQ_INIT(current_bindings);
 321                 }
 322
 323                 TAILQ_INSERT_TAIL(current_bindings, $<binding>1, bindings);
 324         }
 325         ;
 326
 327 floating_modifier:
 328         TOKFLOATING_MODIFIER WHITESPACE binding_modifiers
 329         {
 330                 DLOG("floating modifier = %d\n", $<number>3);
 331                 config.floating_modifier = $<number>3;
 332         }
 333         ;
 334
 335 new_container:
 336         TOKNEWCONTAINER WHITESPACE TOKCONTAINERMODE
 337         {
 338                 DLOG("new containers will be in mode %d\n", $<number>3);
 339                 config.container_mode = $<number>3;
 340
 341                 /* We also need to change the layout of the already existing
 342                  * workspaces here. Workspaces may exist at this point because
 343                  * of the other directives which are modifying workspaces
 344                  * (setting the preferred screen or name). While the workspace
 345                  * objects are already created, they have never been used.
 346                  * Thus, the user very likely awaits the default container mode
 347                  * to trigger in this case, regardless of where it is inside
 348                  * his configuration file. */
 349                 Workspace *ws;
 350                 TAILQ_FOREACH(ws, workspaces, workspaces) {
 351                         if (ws->table == NULL)
 352                                 continue;
 353                         switch_layout_mode(global_conn,
 354                                            ws->table[0][0],
 355                                            config.container_mode);
 356                 }
 357         }
 358         | TOKNEWCONTAINER WHITESPACE TOKSTACKLIMIT WHITESPACE TOKSTACKLIMIT WHITESPACE NUMBER
 359         {
 360                 DLOG("stack-limit %d with val %d\n", $<number>5, $<number>7);
 361                 config.container_stack_limit = $<number>5;
 362                 config.container_stack_limit_value = $<number>7;
 363
 364                 /* See the comment above */
 365                 Workspace *ws;
 366                 TAILQ_FOREACH(ws, workspaces, workspaces) {
 367                         if (ws->table == NULL)
 368                                 continue;
 369                         Container *con = ws->table[0][0];
 370                         con->stack_limit = config.container_stack_limit;
 371                         con->stack_limit_value = config.container_stack_limit_value;
 372                 }
 373         }
 374         ;
 375
 376 new_window:
 377         TOKNEWWINDOW WHITESPACE WORD
 378         {
 379                 DLOG("new windows should start in mode %s\n", $<string>3);
 380                 config.default_border = strdup($<string>3);
 381         }
 382         ;
 383
 384 bool:
 385         NUMBER
 386         {
 387                 $<number>$ = ($<number>1 == 1);
 388         }
 389         | WORD
 390         {
 391                 DLOG("checking word \"%s\"\n", $<string>1);
 392                 $<number>$ = (strcasecmp($<string>1, "yes") == 0 ||
 393                               strcasecmp($<string>1, "true") == 0 ||
 394                               strcasecmp($<string>1, "on") == 0 ||
 395                               strcasecmp($<string>1, "enable") == 0 ||
 396                               strcasecmp($<string>1, "active") == 0);
 397         }
 398         ;
 399
 400 focus_follows_mouse:
 401         TOKFOCUSFOLLOWSMOUSE WHITESPACE bool
 402         {
 403                 DLOG("focus follows mouse = %d\n", $<number>3);
 404                 config.disable_focus_follows_mouse = !($<number>3);
 405         }
 406         ;
 407
 408 workspace:
 409         TOKWORKSPACE WHITESPACE NUMBER WHITESPACE TOKSCREEN WHITESPACE screen optional_workspace_name
 410         {
 411                 int ws_num = $<number>3;
 412                 if (ws_num < 1) {
 413                         DLOG("Invalid workspace assignment, workspace number %d out of range\n", ws_num);
 414                 } else {
 415                         Workspace *ws = workspace_get(ws_num - 1);
 416                         ws->preferred_screen = sstrdup($<string>7);
 417                         if ($<string>8 != NULL)
 418                                 workspace_set_name(ws, $<string>8);
 419                 }
 420         }
 421         | TOKWORKSPACE WHITESPACE NUMBER WHITESPACE workspace_name
 422         {
 423                 int ws_num = $<number>3;
 424                 if (ws_num < 1) {
 425                         DLOG("Invalid workspace assignment, workspace number %d out of range\n", ws_num);
 426                 } else {
 427                         if ($<string>5 != NULL)
 428                                 workspace_set_name(workspace_get(ws_num - 1), $<string>5);
 429                 }
 430         }
 431         ;
 432
 433 optional_workspace_name:
 434         /* empty */                     { $<string>$ = NULL; }
 435         | WHITESPACE workspace_name     { $<string>$ = $<string>2; }
 436         ;
 437
 438 workspace_name:
 439         QUOTEDSTRING         { $<string>$ = $<string>1; }
 440         | STR                { $<string>$ = $<string>1; }
 441         | WORD               { $<string>$ = $<string>1; }
 442         ;
 443
 444 screen:
 445         NUMBER              { asprintf(&$<string>$, "%d", $<number>1); }
 446         | NUMBER 'x'        { asprintf(&$<string>$, "%d", $<number>1); }
 447         | NUMBER 'x' NUMBER { asprintf(&$<string>$, "%dx%d", $<number>1, $<number>3); }
 448         | 'x' NUMBER        { asprintf(&$<string>$, "x%d", $<number>2); }
 449         ;
 450
 451 assign:
 452         TOKASSIGN WHITESPACE window_class WHITESPACE optional_arrow assign_target
 453         {
 454                 printf("assignment of %s\n", $<string>3);
 455
 456                 struct Assignment *new = $<assignment>6;
 457                 printf("  to %d\n", new->workspace);
 458                 printf("  floating = %d\n", new->floating);
 459                 new->windowclass_title = strdup($<string>3);
 460                 TAILQ_INSERT_TAIL(&assignments, new, assignments);
 461         }
 462         ;
 463
 464 assign_target:
 465         NUMBER
 466         {
 467                 struct Assignment *new = scalloc(sizeof(struct Assignment));
 468                 new->workspace = $<number>1;
 469                 new->floating = ASSIGN_FLOATING_NO;
 470                 $<assignment>$ = new;
 471         }
 472         | '~'
 473         {
 474                 struct Assignment *new = scalloc(sizeof(struct Assignment));
 475                 new->floating = ASSIGN_FLOATING_ONLY;
 476                 $<assignment>$ = new;
 477         }
 478         | '~' NUMBER
 479         {
 480                 struct Assignment *new = scalloc(sizeof(struct Assignment));
 481                 new->workspace = $<number>2;
 482                 new->floating = ASSIGN_FLOATING;
 483                 $<assignment>$ = new;
 484         }
 485         ;
 486
 487 window_class:
 488         QUOTEDSTRING
 489         | STR_NG
 490         ;
 491
 492 optional_arrow:
 493         /* NULL */
 494         | TOKARROW WHITESPACE
 495         ;
 496
 497 ipcsocket:
 498         TOKIPCSOCKET WHITESPACE STR
 499         {
 500                 config.ipc_socket_path = sstrdup($<string>3);
 501         }
 502         ;
 503
 504 exec:
 505         TOKEXEC WHITESPACE STR
 506         {
 507                 struct Autostart *new = smalloc(sizeof(struct Autostart));
 508                 new->command = sstrdup($<string>3);
 509                 TAILQ_INSERT_TAIL(&autostarts, new, autostarts);
 510         }
 511         ;
 512
 513 terminal:
 514         TOKTERMINAL WHITESPACE STR
 515         {
 516                 DLOG("The terminal option is DEPRECATED and has no effect. "
 517                     "Please remove it from your configuration file.");
 518         }
 519         ;
 520
 521 font:
 522         TOKFONT WHITESPACE STR
 523         {
 524                 config.font = sstrdup($<string>3);
 525                 printf("font %s\n", config.font);
 526         }
 527         ;
 528
 529
 530 color:
 531         TOKCOLOR WHITESPACE colorpixel WHITESPACE colorpixel WHITESPACE colorpixel
 532         {
 533                 struct Colortriple *dest = $<color>1;
 534
 535                 dest->border = $<number>3;
 536                 dest->background = $<number>5;
 537                 dest->text = $<number>7;
 538         }
 539         ;
 540
 541 colorpixel:
 542         '#' HEX
 543         {
 544                 char *hex;
 545                 if (asprintf(&hex, "#%s", $<string>2) == -1)
 546                         die("asprintf()");
 547                 $<number>$ = get_colorpixel(global_conn, hex);
 548                 free(hex);
 549         }
 550         ;
 551
 552
 553 binding_modifiers:
 554         /* NULL */                               { $<number>$ = 0; }
 555         | binding_modifier
 556         | binding_modifiers '+' binding_modifier { $<number>$ = $<number>1 | $<number>3; }
 557         | binding_modifiers '+'                  { $<number>$ = $<number>1; }
 558         ;
 559
 560 binding_modifier:
 561         MODIFIER        { $<number>$ = $<number>1; }
 562         | TOKCONTROL    { $<number>$ = BIND_CONTROL; }
 563         | TOKSHIFT      { $<number>$ = BIND_SHIFT; }
 564         ;