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

   1 %{
   2 /*
   3  * vim:ts=8:expandtab
   4  *
   5  */
   6 #include <sys/types.h>
   7 #include <sys/stat.h>
   8 #include <unistd.h>
   9 #include <fcntl.h>
  10
  11 #include "all.h"
  12
  13 typedef struct yy_buffer_state *YY_BUFFER_STATE;
  14 extern int yylex(struct context *context);
  15 extern int yyparse(void);
  16 extern FILE *yyin;
  17 YY_BUFFER_STATE yy_scan_string(const char *);
  18
  19 static struct bindings_head *current_bindings;
  20 static struct context *context;
  21
  22 /* We don’t need yydebug for now, as we got decent error messages using
  23  * yyerror(). Should you ever want to extend the parser, it might be handy
  24  * to just comment it in again, so it stays here. */
  25 //int yydebug = 1;
  26
  27 void yyerror(const char *error_message) {
  28         ELOG("\n");
  29         ELOG("CONFIG: %s\n", error_message);
  30         ELOG("CONFIG: in file \"%s\", line %d:\n",
  31                 context->filename, context->line_number);
  32         ELOG("CONFIG:   %s\n", context->line_copy);
  33         ELOG("CONFIG:   ");
  34         for (int c = 1; c <= context->last_column; c++)
  35                 if (c >= context->first_column)
  36                         printf("^");
  37                 else printf(" ");
  38         printf("\n");
  39         ELOG("\n");
  40 }
  41
  42 int yywrap() {
  43         return 1;
  44 }
  45
  46 void parse_file(const char *f) {
  47         SLIST_HEAD(variables_head, Variable) variables = SLIST_HEAD_INITIALIZER(&variables);
  48         int fd, ret, read_bytes = 0;
  49         struct stat stbuf;
  50         char *buf;
  51         FILE *fstr;
  52         char buffer[1026], key[512], value[512];
  53
  54         if ((fd = open(f, O_RDONLY)) == -1)
  55                 die("Could not open configuration file: %s\n", strerror(errno));
  56
  57         if (fstat(fd, &stbuf) == -1)
  58                 die("Could not fstat file: %s\n", strerror(errno));
  59
  60         buf = scalloc((stbuf.st_size + 1) * sizeof(char));
  61         while (read_bytes < stbuf.st_size) {
  62                 if ((ret = read(fd, buf + read_bytes, (stbuf.st_size - read_bytes))) < 0)
  63                         die("Could not read(): %s\n", strerror(errno));
  64                 read_bytes += ret;
  65         }
  66
  67         if (lseek(fd, 0, SEEK_SET) == (off_t)-1)
  68                 die("Could not lseek: %s\n", strerror(errno));
  69
  70         if ((fstr = fdopen(fd, "r")) == NULL)
  71                 die("Could not fdopen: %s\n", strerror(errno));
  72
  73         while (!feof(fstr)) {
  74                 if (fgets(buffer, 1024, fstr) == NULL) {
  75                         if (feof(fstr))
  76                                 break;
  77                         die("Could not read configuration file\n");
  78                 }
  79
  80                 /* sscanf implicitly strips whitespace. Also, we skip comments and empty lines. */
  81                 if (sscanf(buffer, "%s %[^\n]", key, value) < 1 ||
  82                     key[0] == '#' || strlen(key) < 3)
  83                         continue;
  84
  85                 if (strcasecmp(key, "set") == 0) {
  86                         if (value[0] != '$')
  87                                 die("Malformed variable assignment, name has to start with $\n");
  88
  89                         /* get key/value for this variable */
  90                         char *v_key = value, *v_value;
  91                         if ((v_value = strstr(value, " ")) == NULL)
  92                                 die("Malformed variable assignment, need a value\n");
  93
  94                         *(v_value++) = '\0';
  95
  96                         struct Variable *new = scalloc(sizeof(struct Variable));
  97                         new->key = sstrdup(v_key);
  98                         new->value = sstrdup(v_value);
  99                         SLIST_INSERT_HEAD(&variables, new, variables);
 100                         DLOG("Got new variable %s = %s\n", v_key, v_value);
 101                         continue;
 102                 }
 103         }
 104         fclose(fstr);
 105
 106         /* For every custom variable, see how often it occurs in the file and
 107          * how much extra bytes it requires when replaced. */
 108         struct Variable *current, *nearest;
 109         int extra_bytes = 0;
 110         /* We need to copy the buffer because we need to invalidate the
 111          * variables (otherwise we will count them twice, which is bad when
 112          * 'extra' is negative) */
 113         char *bufcopy = sstrdup(buf);
 114         SLIST_FOREACH(current, &variables, variables) {
 115                 int extra = (strlen(current->value) - strlen(current->key));
 116                 char *next;
 117                 for (next = bufcopy;
 118                      (next = strcasestr(bufcopy + (next - bufcopy), current->key)) != NULL;
 119                      next += strlen(current->key)) {
 120                         *next = '_';
 121                         extra_bytes += extra;
 122                 }
 123         }
 124         FREE(bufcopy);
 125
 126         /* Then, allocate a new buffer and copy the file over to the new one,
 127          * but replace occurences of our variables */
 128         char *walk = buf, *destwalk;
 129         char *new = smalloc((stbuf.st_size + extra_bytes + 1) * sizeof(char));
 130         destwalk = new;
 131         while (walk < (buf + stbuf.st_size)) {
 132                 /* Find the next variable */
 133                 SLIST_FOREACH(current, &variables, variables)
 134                         current->next_match = strcasestr(walk, current->key);
 135                 nearest = NULL;
 136                 int distance = stbuf.st_size;
 137                 SLIST_FOREACH(current, &variables, variables) {
 138                         if (current->next_match == NULL)
 139                                 continue;
 140                         if ((current->next_match - walk) < distance) {
 141                                 distance = (current->next_match - walk);
 142                                 nearest = current;
 143                         }
 144                 }
 145                 if (nearest == NULL) {
 146                         /* If there are no more variables, we just copy the rest */
 147                         strncpy(destwalk, walk, (buf + stbuf.st_size) - walk);
 148                         destwalk += (buf + stbuf.st_size) - walk;
 149                         *destwalk = '\0';
 150                         break;
 151                 } else {
 152                         /* Copy until the next variable, then copy its value */
 153                         strncpy(destwalk, walk, distance);
 154                         strncpy(destwalk + distance, nearest->value, strlen(nearest->value));
 155                         walk += distance + strlen(nearest->key);
 156                         destwalk += distance + strlen(nearest->value);
 157                 }
 158         }
 159
 160         yy_scan_string(new);
 161
 162         context = scalloc(sizeof(struct context));
 163         context->filename = f;
 164
 165         if (yyparse() != 0) {
 166                 fprintf(stderr, "Could not parse configfile\n");
 167                 exit(1);
 168         }
 169
 170         FREE(context->line_copy);
 171         free(context);
 172         free(new);
 173         free(buf);
 174
 175         while (!SLIST_EMPTY(&variables)) {
 176                 current = SLIST_FIRST(&variables);
 177                 FREE(current->key);
 178                 FREE(current->value);
 179                 SLIST_REMOVE_HEAD(&variables, variables);
 180                 FREE(current);
 181         }
 182 }
 183
 184 %}
 185
 186 %expect 1
 187 %error-verbose
 188 %lex-param { struct context *context }
 189
 190 %union {
 191         int number;
 192         char *string;
 193         uint32_t *single_color;
 194         struct Colortriple *color;
 195         Match *match;
 196         struct Binding *binding;
 197 }
 198
 199 %token <number>NUMBER "<number>"
 200 %token <string>WORD "<word>"
 201 %token <string>STR "<string>"
 202 %token <string>STR_NG "<string (non-greedy)>"
 203 %token <string>HEX "<hex>"
 204 %token <string>OUTPUT "<RandR output>"
 205 %token TOKBINDCODE
 206 %token TOKTERMINAL
 207 %token TOKCOMMENT "<comment>"
 208 %token TOKFONT "font"
 209 %token TOKBINDSYM "bindsym"
 210 %token MODIFIER "<modifier>"
 211 %token TOKCONTROL "control"
 212 %token TOKSHIFT "shift"
 213 %token WHITESPACE "<whitespace>"
 214 %token TOKFLOATING_MODIFIER "floating_modifier"
 215 %token QUOTEDSTRING "<quoted string>"
 216 %token TOKWORKSPACE "workspace"
 217 %token TOKOUTPUT "output"
 218 %token TOKASSIGN "assign"
 219 %token TOKSET
 220 %token TOKIPCSOCKET "ipc_socket"
 221 %token TOKRESTARTSTATE "restart_state"
 222 %token TOKEXEC "exec"
 223 %token TOKSINGLECOLOR
 224 %token TOKCOLOR
 225 %token TOKARROW "→"
 226 %token TOKMODE "mode"
 227 %token TOK_ORIENTATION "default_orientation"
 228 %token TOK_HORIZ "horizontal"
 229 %token TOK_VERT "vertical"
 230 %token TOK_AUTO "auto"
 231 %token TOK_WORKSPACE_LAYOUT "workspace_layout"
 232 %token TOKNEWWINDOW "new_window"
 233 %token TOK_NORMAL "normal"
 234 %token TOK_NONE "none"
 235 %token TOK_1PIXEL "1pixel"
 236 %token TOKFOCUSFOLLOWSMOUSE "focus_follows_mouse"
 237 %token TOKWORKSPACEBAR "workspace_bar"
 238 %token TOK_DEFAULT "default"
 239 %token TOK_STACKING "stacking"
 240 %token TOK_TABBED "tabbed"
 241 %token TOKSTACKLIMIT "stack-limit"
 242 %token TOK_POPUP_DURING_FULLSCREEN "popup_during_fullscreen"
 243 %token TOK_IGNORE "ignore"
 244 %token TOK_LEAVE_FULLSCREEN "leave_fullscreen"
 245
 246 %%
 247
 248 lines: /* empty */
 249         | lines WHITESPACE line
 250         | lines error
 251         | lines line
 252         ;
 253
 254 line:
 255         bindline
 256         | mode
 257         | floating_modifier
 258         | orientation
 259         | workspace_layout
 260         | new_window
 261         | focus_follows_mouse
 262         | workspace_bar
 263         | workspace
 264         | assign
 265         | ipcsocket
 266         | restart_state
 267         | exec
 268         | single_color
 269         | color
 270         | terminal
 271         | font
 272         | comment
 273         | popup_during_fullscreen
 274         ;
 275
 276 comment:
 277         TOKCOMMENT
 278         ;
 279
 280 command:
 281         STR
 282         ;
 283
 284 bindline:
 285         binding
 286         {
 287                 TAILQ_INSERT_TAIL(bindings, $<binding>1, bindings);
 288         }
 289         ;
 290
 291 binding:
 292         TOKBINDCODE WHITESPACE bindcode         { $<binding>$ = $<binding>3; }
 293         | TOKBINDSYM WHITESPACE bindsym         { $<binding>$ = $<binding>3; }
 294         ;
 295
 296 bindcode:
 297         binding_modifiers NUMBER WHITESPACE command
 298         {
 299                 printf("\tFound keycode binding mod%d with key %d and command %s\n", $<number>1, $2, $<string>4);
 300                 Binding *new = scalloc(sizeof(Binding));
 301
 302                 new->keycode = $<number>2;
 303                 new->mods = $<number>1;
 304                 new->command = $<string>4;
 305
 306                 $<binding>$ = new;
 307         }
 308         ;
 309
 310 bindsym:
 311         binding_modifiers word_or_number WHITESPACE command
 312         {
 313                 printf("\tFound keysym binding mod%d with key %s and command %s\n", $<number>1, $<string>2, $<string>4);
 314                 Binding *new = scalloc(sizeof(Binding));
 315
 316                 new->symbol = $<string>2;
 317                 new->mods = $<number>1;
 318                 new->command = $<string>4;
 319
 320                 $<binding>$ = new;
 321         }
 322         ;
 323
 324 word_or_number:
 325         WORD
 326         | NUMBER
 327         {
 328                 asprintf(&$<string>$, "%d", $1);
 329         }
 330         ;
 331
 332 mode:
 333         TOKMODE WHITESPACE QUOTEDSTRING WHITESPACE '{' modelines '}'
 334         {
 335                 if (strcasecmp($<string>3, "default") == 0) {
 336                         printf("You cannot use the name \"default\" for your mode\n");
 337                         exit(1);
 338                 }
 339                 printf("\t now in mode %s\n", $<string>3);
 340                 printf("\t current bindings = %p\n", current_bindings);
 341                 Binding *binding;
 342                 TAILQ_FOREACH(binding, current_bindings, bindings) {
 343                         printf("got binding on mods %d, keycode %d, symbol %s, command %s\n",
 344                                         binding->mods, binding->keycode, binding->symbol, binding->command);
 345                 }
 346
 347                 struct Mode *mode = scalloc(sizeof(struct Mode));
 348                 mode->name = $<string>3;
 349                 mode->bindings = current_bindings;
 350                 current_bindings = NULL;
 351                 SLIST_INSERT_HEAD(&modes, mode, modes);
 352         }
 353         ;
 354
 355
 356 modelines:
 357         /* empty */
 358         | modelines modeline
 359         ;
 360
 361 modeline:
 362         WHITESPACE
 363         | comment
 364         | binding
 365         {
 366                 if (current_bindings == NULL) {
 367                         current_bindings = scalloc(sizeof(struct bindings_head));
 368                         TAILQ_INIT(current_bindings);
 369                 }
 370
 371                 TAILQ_INSERT_TAIL(current_bindings, $<binding>1, bindings);
 372         }
 373         ;
 374
 375 floating_modifier:
 376         TOKFLOATING_MODIFIER WHITESPACE binding_modifiers
 377         {
 378                 DLOG("floating modifier = %d\n", $<number>3);
 379                 config.floating_modifier = $<number>3;
 380         }
 381         ;
 382
 383 orientation:
 384         TOK_ORIENTATION WHITESPACE direction
 385         {
 386                 DLOG("New containers should start with split direction %d\n", $<number>3);
 387                 config.default_orientation = $<number>3;
 388         }
 389         ;
 390
 391 direction:
 392         TOK_HORIZ       { $<number>$ = HORIZ; }
 393         | TOK_VERT      { $<number>$ = VERT; }
 394         | TOK_AUTO      { $<number>$ = NO_ORIENTATION; }
 395         ;
 396
 397 workspace_layout:
 398         TOK_WORKSPACE_LAYOUT WHITESPACE layout_mode
 399         {
 400                 DLOG("new containers will be in mode %d\n", $<number>3);
 401                 config.default_layout = $<number>3;
 402
 403 #if 0
 404                 /* We also need to change the layout of the already existing
 405                  * workspaces here. Workspaces may exist at this point because
 406                  * of the other directives which are modifying workspaces
 407                  * (setting the preferred screen or name). While the workspace
 408                  * objects are already created, they have never been used.
 409                  * Thus, the user very likely awaits the default container mode
 410                  * to trigger in this case, regardless of where it is inside
 411                  * his configuration file. */
 412                 Workspace *ws;
 413                 TAILQ_FOREACH(ws, workspaces, workspaces) {
 414                         if (ws->table == NULL)
 415                                 continue;
 416                         switch_layout_mode(global_conn,
 417                                            ws->table[0][0],
 418                                            config.container_mode);
 419                 }
 420 #endif
 421         }
 422         | TOK_WORKSPACE_LAYOUT WHITESPACE TOKSTACKLIMIT WHITESPACE TOKSTACKLIMIT WHITESPACE NUMBER
 423         {
 424                 DLOG("stack-limit %d with val %d\n", $<number>5, $<number>7);
 425                 config.container_stack_limit = $<number>5;
 426                 config.container_stack_limit_value = $<number>7;
 427
 428 #if 0
 429                 /* See the comment above */
 430                 Workspace *ws;
 431                 TAILQ_FOREACH(ws, workspaces, workspaces) {
 432                         if (ws->table == NULL)
 433                                 continue;
 434                         Container *con = ws->table[0][0];
 435                         con->stack_limit = config.container_stack_limit;
 436                         con->stack_limit_value = config.container_stack_limit_value;
 437                 }
 438 #endif
 439         }
 440         ;
 441
 442 layout_mode:
 443       TOK_DEFAULT       { $<number>$ = L_DEFAULT; }
 444       | TOK_STACKING    { $<number>$ = L_STACKED; }
 445       | TOK_TABBED      { $<number>$ = L_TABBED; }
 446       ;
 447
 448 new_window:
 449         TOKNEWWINDOW WHITESPACE border_style
 450         {
 451                 DLOG("new windows should start with border style %d\n", $<number>3);
 452                 config.default_border = $<number>3;
 453         }
 454         ;
 455
 456 border_style:
 457         TOK_NORMAL      { $<number>$ = BS_NORMAL; }
 458         | TOK_NONE      { $<number>$ = BS_NONE; }
 459         | TOK_1PIXEL    { $<number>$ = BS_1PIXEL; }
 460         ;
 461
 462 bool:
 463         NUMBER
 464         {
 465                 $<number>$ = ($<number>1 == 1);
 466         }
 467         | WORD
 468         {
 469                 DLOG("checking word \"%s\"\n", $<string>1);
 470                 $<number>$ = (strcasecmp($<string>1, "yes") == 0 ||
 471                               strcasecmp($<string>1, "true") == 0 ||
 472                               strcasecmp($<string>1, "on") == 0 ||
 473                               strcasecmp($<string>1, "enable") == 0 ||
 474                               strcasecmp($<string>1, "active") == 0);
 475         }
 476         ;
 477
 478 focus_follows_mouse:
 479         TOKFOCUSFOLLOWSMOUSE WHITESPACE bool
 480         {
 481                 DLOG("focus follows mouse = %d\n", $<number>3);
 482                 config.disable_focus_follows_mouse = !($<number>3);
 483         }
 484         ;
 485
 486 workspace_bar:
 487         TOKWORKSPACEBAR WHITESPACE bool
 488         {
 489                 DLOG("workspace bar = %d\n", $<number>3);
 490                 config.disable_workspace_bar = !($<number>3);
 491         }
 492         ;
 493
 494 workspace:
 495         TOKWORKSPACE WHITESPACE NUMBER WHITESPACE TOKOUTPUT WHITESPACE OUTPUT optional_workspace_name
 496         {
 497                 int ws_num = $<number>3;
 498                 if (ws_num < 1) {
 499                         DLOG("Invalid workspace assignment, workspace number %d out of range\n", ws_num);
 500                 } else {
 501 #if 0
 502                         Workspace *ws = workspace_get(ws_num - 1);
 503                         ws->preferred_output = $<string>7;
 504                         if ($<string>8 != NULL) {
 505                                 workspace_set_name(ws, $<string>8);
 506                                 free($<string>8);
 507                         }
 508 #endif
 509                 }
 510         }
 511         | TOKWORKSPACE WHITESPACE NUMBER WHITESPACE workspace_name
 512         {
 513                 int ws_num = $<number>3;
 514                 if (ws_num < 1) {
 515                         DLOG("Invalid workspace assignment, workspace number %d out of range\n", ws_num);
 516                 } else {
 517                         DLOG("workspace name to: %s\n", $<string>5);
 518 #if 0
 519                         if ($<string>5 != NULL) {
 520                                 workspace_set_name(workspace_get(ws_num - 1), $<string>5);
 521                                 free($<string>5);
 522                         }
 523 #endif
 524                 }
 525         }
 526         ;
 527
 528 optional_workspace_name:
 529         /* empty */                     { $<string>$ = NULL; }
 530         | WHITESPACE workspace_name     { $<string>$ = $<string>2; }
 531         ;
 532
 533 workspace_name:
 534         QUOTEDSTRING         { $<string>$ = $<string>1; }
 535         | STR                { $<string>$ = $<string>1; }
 536         | WORD               { $<string>$ = $<string>1; }
 537         ;
 538
 539 assign:
 540         TOKASSIGN WHITESPACE window_class WHITESPACE optional_arrow assign_target
 541         {
 542                 printf("assignment of %s\n", $<string>3);
 543
 544                 struct Match *match = $<match>6;
 545
 546                 char *separator = NULL;
 547                 if ((separator = strchr($<string>3, '/')) != NULL) {
 548                         *(separator++) = '\0';
 549                         match->title = sstrdup(separator);
 550                 }
 551                 if (*$<string>3 != '\0')
 552                         match->class = sstrdup($<string>3);
 553                 free($<string>3);
 554
 555                 printf("  class = %s\n", match->class);
 556                 printf("  title = %s\n", match->title);
 557                 if (match->insert_where == M_ASSIGN_WS)
 558                         printf("  to ws %s\n", match->target_ws);
 559                 TAILQ_INSERT_TAIL(&assignments, match, assignments);
 560         }
 561         ;
 562
 563 assign_target:
 564         NUMBER
 565         {
 566                 /* TODO: named workspaces */
 567                 Match *match = smalloc(sizeof(Match));
 568                 match_init(match);
 569                 match->insert_where = M_ASSIGN_WS;
 570                 asprintf(&(match->target_ws), "%d", $<number>1);
 571                 $<match>$ = match;
 572         }
 573         | '~'
 574         {
 575                 /* TODO: compatiblity */
 576 #if 0
 577                 struct Assignment *new = scalloc(sizeof(struct Assignment));
 578                 new->floating = ASSIGN_FLOATING_ONLY;
 579                 $<assignment>$ = new;
 580 #endif
 581         }
 582         | '~' NUMBER
 583         {
 584                 /* TODO: compatiblity */
 585 #if 0
 586                 struct Assignment *new = scalloc(sizeof(struct Assignment));
 587                 new->workspace = $<number>2;
 588                 new->floating = ASSIGN_FLOATING;
 589                 $<assignment>$ = new;
 590 #endif
 591         }
 592         ;
 593
 594 window_class:
 595         QUOTEDSTRING
 596         | STR_NG
 597         ;
 598
 599 optional_arrow:
 600         /* NULL */
 601         | TOKARROW WHITESPACE
 602         ;
 603
 604 ipcsocket:
 605         TOKIPCSOCKET WHITESPACE STR
 606         {
 607                 config.ipc_socket_path = $<string>3;
 608         }
 609         ;
 610
 611 restart_state:
 612         TOKRESTARTSTATE WHITESPACE STR
 613         {
 614                 config.restart_state_path = $<string>3;
 615         }
 616         ;
 617
 618 exec:
 619         TOKEXEC WHITESPACE STR
 620         {
 621                 struct Autostart *new = smalloc(sizeof(struct Autostart));
 622                 new->command = $<string>3;
 623                 TAILQ_INSERT_TAIL(&autostarts, new, autostarts);
 624         }
 625         ;
 626
 627 terminal:
 628         TOKTERMINAL WHITESPACE STR
 629         {
 630                 ELOG("The terminal option is DEPRECATED and has no effect. "
 631                     "Please remove it from your configuration file.\n");
 632         }
 633         ;
 634
 635 font:
 636         TOKFONT WHITESPACE STR
 637         {
 638                 config.font = load_font($<string>3, true);
 639                 printf("font %s\n", $<string>3);
 640         }
 641         ;
 642
 643 single_color:
 644         TOKSINGLECOLOR WHITESPACE colorpixel
 645         {
 646                 uint32_t *dest = $<single_color>1;
 647                 *dest = $<number>3;
 648         }
 649         ;
 650
 651 color:
 652         TOKCOLOR WHITESPACE colorpixel WHITESPACE colorpixel WHITESPACE colorpixel
 653         {
 654                 struct Colortriple *dest = $<color>1;
 655
 656                 dest->border = $<number>3;
 657                 dest->background = $<number>5;
 658                 dest->text = $<number>7;
 659         }
 660         ;
 661
 662 colorpixel:
 663         '#' HEX
 664         {
 665                 char *hex;
 666                 if (asprintf(&hex, "#%s", $<string>2) == -1)
 667                         die("asprintf()");
 668                 $<number>$ = get_colorpixel(hex);
 669                 free(hex);
 670         }
 671         ;
 672
 673
 674 binding_modifiers:
 675         /* NULL */                               { $<number>$ = 0; }
 676         | binding_modifier
 677         | binding_modifiers '+' binding_modifier { $<number>$ = $<number>1 | $<number>3; }
 678         | binding_modifiers '+'                  { $<number>$ = $<number>1; }
 679         ;
 680
 681 binding_modifier:
 682         MODIFIER        { $<number>$ = $<number>1; }
 683         | TOKCONTROL    { $<number>$ = BIND_CONTROL; }
 684         | TOKSHIFT      { $<number>$ = BIND_SHIFT; }
 685         ;
 686
 687 popup_during_fullscreen:
 688         TOK_POPUP_DURING_FULLSCREEN WHITESPACE popup_setting
 689         {
 690                 DLOG("popup_during_fullscreen setting: %d\n", $<number>3);
 691                 config.popup_during_fullscreen = $<number>3;
 692         }
 693         ;
 694
 695 popup_setting:
 696         TOK_IGNORE              { $<number>$ = PDF_IGNORE; }
 697         | TOK_LEAVE_FULLSCREEN  { $<number>$ = PDF_LEAVE_FULLSCREEN; }
 698         ;