* vim:ts=4:sw=4:expandtab
*
* i3 - an improved dynamic tiling window manager
- * © 2009-2010 Michael Stapelberg and contributors (see also: LICENSE)
+ * © 2009-2011 Michael Stapelberg and contributors (see also: LICENSE)
*
* cmdparse.y: the parser for commands you send to i3 (or bind on keys)
*
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
+#include <limits.h>
#include "all.h"
+/** When the command did not include match criteria (!), we use the currently
+ * focused command. Do not confuse this case with a command which included
+ * criteria but which did not match any windows. This macro has to be called in
+ * every command.
+ */
+#define HANDLE_EMPTY_MATCH do { \
+ if (match_is_empty(¤t_match)) { \
+ owindow *ow = smalloc(sizeof(owindow)); \
+ ow->con = focused; \
+ TAILQ_INIT(&owindows); \
+ TAILQ_INSERT_TAIL(&owindows, ow, owindows); \
+ } \
+} while (0)
+
typedef struct yy_buffer_state *YY_BUFFER_STATE;
extern int cmdyylex(struct context *context);
extern int cmdyyparse(void);
extern FILE *cmdyyin;
YY_BUFFER_STATE cmdyy_scan_string(const char *);
-static struct bindings_head *current_bindings;
static struct context *context;
static Match current_match;
}
char *parse_cmd(const char *new) {
+ LOG("COMMAND: *%s*\n", new);
cmdyy_scan_string(new);
match_init(¤t_match);
int number;
}
-%token TOK_ATTACH "attach"
-%token TOK_EXEC "exec"
-%token TOK_EXIT "exit"
-%token TOK_RELOAD "reload"
-%token TOK_RESTART "restart"
-%token TOK_KILL "kill"
-%token TOK_FULLSCREEN "fullscreen"
-%token TOK_GLOBAL "global"
-%token TOK_LAYOUT "layout"
-%token TOK_DEFAULT "default"
-%token TOK_STACKED "stacked"
-%token TOK_TABBED "tabbed"
-%token TOK_BORDER "border"
-%token TOK_NORMAL "normal"
-%token TOK_NONE "none"
-%token TOK_1PIXEL "1pixel"
-%token TOK_MODE "mode"
-%token TOK_TILING "tiling"
-%token TOK_FLOATING "floating"
-%token TOK_WORKSPACE "workspace"
-%token TOK_TOGGLE "toggle"
-%token TOK_FOCUS "focus"
-%token TOK_MOVE "move"
-%token TOK_OPEN "open"
-%token TOK_NEXT "next"
-%token TOK_PREV "prev"
-%token TOK_SPLIT "split"
-%token TOK_HORIZONTAL "horizontal"
-%token TOK_VERTICAL "vertical"
-%token TOK_LEVEL "level"
-%token TOK_UP "up"
-%token TOK_DOWN "down"
-%token TOK_LEFT "left"
-%token TOK_RIGHT "right"
-%token TOK_AFTER "after"
-%token TOK_BEFORE "before"
-%token TOK_RESTORE "restore"
-%token TOK_MARK "mark"
-%token TOK_RESIZE "resize"
-%token TOK_GROW "grow"
-%token TOK_SHRINK "shrink"
-%token TOK_PX "px"
-%token TOK_OR "or"
-%token TOK_PPT "ppt"
-
-%token TOK_CLASS "class"
-%token TOK_ID "id"
-%token TOK_CON_ID "con_id"
-
-%token WHITESPACE "<whitespace>"
-%token STR "<string>"
-%token NUMBER "<number>"
+%token TOK_EXEC "exec"
+%token TOK_EXIT "exit"
+%token TOK_RELOAD "reload"
+%token TOK_RESTART "restart"
+%token TOK_KILL "kill"
+%token TOK_WINDOW "window"
+%token TOK_CLIENT "client"
+%token TOK_FULLSCREEN "fullscreen"
+%token TOK_GLOBAL "global"
+%token TOK_LAYOUT "layout"
+%token TOK_DEFAULT "default"
+%token TOK_STACKED "stacked"
+%token TOK_TABBED "tabbed"
+%token TOK_BORDER "border"
+%token TOK_NORMAL "normal"
+%token TOK_NONE "none"
+%token TOK_1PIXEL "1pixel"
+%token TOK_MODE "mode"
+%token TOK_TILING "tiling"
+%token TOK_FLOATING "floating"
+%token TOK_ENABLE "enable"
+%token TOK_DISABLE "disable"
+%token TOK_WORKSPACE "workspace"
+%token TOK_TOGGLE "toggle"
+%token TOK_FOCUS "focus"
+%token TOK_MOVE "move"
+%token TOK_OPEN "open"
+%token TOK_NEXT "next"
+%token TOK_PREV "prev"
+%token TOK_SPLIT "split"
+%token TOK_HORIZONTAL "horizontal"
+%token TOK_VERTICAL "vertical"
+%token TOK_UP "up"
+%token TOK_DOWN "down"
+%token TOK_LEFT "left"
+%token TOK_RIGHT "right"
+%token TOK_PARENT "parent"
+%token TOK_CHILD "child"
+%token TOK_APPEND_LAYOUT "append_layout"
+%token TOK_MARK "mark"
+%token TOK_RESIZE "resize"
+%token TOK_GROW "grow"
+%token TOK_SHRINK "shrink"
+%token TOK_PX "px"
+%token TOK_OR "or"
+%token TOK_PPT "ppt"
+%token TOK_NOP "nop"
+
+%token TOK_CLASS "class"
+%token TOK_ID "id"
+%token TOK_CON_ID "con_id"
+%token TOK_TITLE "title"
+
+%token <string> STR "<string>"
+%token <number> NUMBER "<number>"
+
+%type <number> direction
+%type <number> split_direction
+%type <number> fullscreen_mode
+%type <number> level
+%type <number> boolean
+%type <number> border_style
+%type <number> layout_mode
+%type <number> resize_px
+%type <number> resize_way
+%type <number> resize_tiling
+%type <number> optional_kill_mode
%%
-commands: /* empty */
- | commands optwhitespace ';' optwhitespace command
+commands:
+ commands ';' command
| command
{
owindow *current;
}
;
-optwhitespace:
- | WHITESPACE
- ;
-
command:
- match optwhitespace operations
+ match operations
;
match:
- | matchstart optwhitespace criteria optwhitespace matchend
+ | matchstart criteria matchend
{
printf("match parsed\n");
}
;
criteria:
+ criteria criterion
+ | criterion
+ ;
+
+criterion:
TOK_CLASS '=' STR
{
- printf("criteria: class = %s\n", $<string>3);
- current_match.class = $<string>3;
+ printf("criteria: class = %s\n", $3);
+ current_match.class = $3;
}
| TOK_CON_ID '=' STR
{
- printf("criteria: id = %s\n", $<string>3);
- /* TODO: correctly parse number */
- current_match.con_id = atoi($<string>3);
- printf("id as int = %d\n", current_match.con_id);
+ printf("criteria: id = %s\n", $3);
+ char *end;
+ long parsed = strtol($3, &end, 10);
+ if (parsed == LONG_MIN ||
+ parsed == LONG_MAX ||
+ parsed < 0 ||
+ (end && *end != '\0')) {
+ ELOG("Could not parse con id \"%s\"\n", $3);
+ } else {
+ current_match.con_id = (Con*)parsed;
+ printf("id as int = %p\n", current_match.con_id);
+ }
}
| TOK_ID '=' STR
{
- printf("criteria: window id = %s\n", $<string>3);
- /* TODO: correctly parse number */
- current_match.id = atoi($<string>3);
- printf("window id as int = %d\n", current_match.id);
+ printf("criteria: window id = %s\n", $3);
+ char *end;
+ long parsed = strtol($3, &end, 10);
+ if (parsed == LONG_MIN ||
+ parsed == LONG_MAX ||
+ parsed < 0 ||
+ (end && *end != '\0')) {
+ ELOG("Could not parse window id \"%s\"\n", $3);
+ } else {
+ current_match.id = parsed;
+ printf("window id as int = %d\n", current_match.id);
+ }
}
| TOK_MARK '=' STR
{
- printf("criteria: mark = %s\n", $<string>3);
- current_match.mark = $<string>3;
+ printf("criteria: mark = %s\n", $3);
+ current_match.mark = $3;
+ }
+ | TOK_TITLE '=' STR
+ {
+ printf("criteria: title = %s\n", $3);
+ current_match.title = $3;
}
;
operations:
operation
- | operation optwhitespace
- | operations ',' optwhitespace operation
+ | operations ',' operation
;
operation:
| reload
| border
| layout
- | restore
+ | append_layout
| move
| workspace
- | attach
| focus
| kill
| open
| fullscreen
- | next
- | prev
| split
- | mode
- | level
+ | floating
| mark
| resize
+ | nop
+ | mode
;
exec:
- TOK_EXEC WHITESPACE STR
+ TOK_EXEC STR
{
- printf("should execute %s\n", $<string>3);
- start_application($<string>3);
+ printf("should execute %s\n", $2);
+ start_application($2);
+ free($2);
}
;
{
printf("reloading\n");
load_configuration(conn, NULL, true);
+ x_set_i3_atoms();
/* Send an IPC event just in case the ws names have changed */
ipc_send_event("workspace", I3_IPC_EVENT_WORKSPACE, "{\"change\":\"reload\"}");
}
TOK_RESTART
{
printf("restarting i3\n");
- i3_restart();
- }
- ;
-
-attach:
- TOK_ATTACH
- {
- printf("should attach\n");
+ i3_restart(false);
}
;
{
owindow *current;
- printf("should focus\n");
if (match_is_empty(¤t_match)) {
- /* TODO: better error message */
- LOG("Error: The foucs command requires you to use some criteria.\n");
- return;
+ ELOG("You have to specify which window/container should be focused.\n");
+ ELOG("Example: [class=\"urxvt\" title=\"irssi\"] focus\n");
+
+ asprintf(&json_output, "{\"success\":false, \"error\":\"You have to "
+ "specify which window/container should be focused\"}");
+ break;
}
- /* TODO: warning if the match contains more than one entry. does not
- * make so much sense when focusing */
+ int count = 0;
TAILQ_FOREACH(current, &owindows, owindows) {
LOG("focusing %p / %s\n", current->con, current->con->name);
con_focus(current->con);
+ count++;
}
+
+ if (count > 1)
+ LOG("WARNING: Your criteria for the focus command matches %d containers, "
+ "while only exactly one container can be focused at a time.\n", count);
+
+ tree_render();
+ }
+ | TOK_FOCUS direction
+ {
+ int direction = $2;
+ switch (direction) {
+ case TOK_LEFT:
+ LOG("Focusing left\n");
+ tree_next('p', HORIZ);
+ break;
+ case TOK_RIGHT:
+ LOG("Focusing right\n");
+ tree_next('n', HORIZ);
+ break;
+ case TOK_UP:
+ LOG("Focusing up\n");
+ tree_next('p', VERT);
+ break;
+ case TOK_DOWN:
+ LOG("Focusing down\n");
+ tree_next('n', VERT);
+ break;
+ default:
+ ELOG("Invalid focus direction (%d)\n", direction);
+ break;
+ }
+
+ tree_render();
}
+ | TOK_FOCUS level
+ {
+ if ($2 == TOK_PARENT)
+ level_up();
+ else level_down();
+
+ tree_render();
+ }
+ ;
+
+level:
+ TOK_PARENT { $$ = TOK_PARENT; }
+ | TOK_CHILD { $$ = TOK_CHILD; }
;
kill:
- TOK_KILL
+ TOK_KILL optional_kill_mode
{
owindow *current;
printf("killing!\n");
/* check if the match is empty, not if the result is empty */
if (match_is_empty(¤t_match))
- tree_close_con();
+ tree_close_con($2);
else {
TAILQ_FOREACH(current, &owindows, owindows) {
printf("matching: %p / %s\n", current->con, current->con->name);
- tree_close(current->con, true, false);
+ tree_close(current->con, $2, false);
}
}
+ tree_render();
}
;
+optional_kill_mode:
+ /* empty */ { $$ = KILL_WINDOW; }
+ | TOK_WINDOW { $$ = KILL_WINDOW; }
+ | TOK_CLIENT { $$ = KILL_CLIENT; }
+ ;
+
workspace:
- TOK_WORKSPACE WHITESPACE STR
+ TOK_WORKSPACE TOK_NEXT
+ {
+ workspace_next();
+ tree_render();
+ }
+ | TOK_WORKSPACE TOK_PREV
{
- printf("should switch to workspace %s\n", $<string>3);
- workspace_show($<string>3);
- free($<string>3);
+ workspace_prev();
+ tree_render();
+ }
+ | TOK_WORKSPACE STR
+ {
+ printf("should switch to workspace %s\n", $2);
+ workspace_show($2);
+ free($2);
+
+ tree_render();
}
;
TOK_OPEN
{
printf("opening new container\n");
- Con *con = tree_open_con(NULL);
- asprintf(&json_output, "{\"success\":true, \"id\":%d}", (long int)con);
+ Con *con = tree_open_con(NULL, NULL);
+ con_focus(con);
+ asprintf(&json_output, "{\"success\":true, \"id\":%ld}", (long int)con);
+
+ tree_render();
}
;
fullscreen:
- TOK_FULLSCREEN
+ TOK_FULLSCREEN fullscreen_mode
{
- printf("toggling fullscreen\n");
+ printf("toggling fullscreen, mode = %s\n", ($2 == CF_OUTPUT ? "normal" : "global"));
owindow *current;
- /* check if the match is empty, not if the result is empty */
- if (match_is_empty(¤t_match))
- con_toggle_fullscreen(focused);
- else {
- TAILQ_FOREACH(current, &owindows, owindows) {
- printf("matching: %p / %s\n", current->con, current->con->name);
- con_toggle_fullscreen(current->con);
- }
- }
+ HANDLE_EMPTY_MATCH;
- }
- ;
+ TAILQ_FOREACH(current, &owindows, owindows) {
+ printf("matching: %p / %s\n", current->con, current->con->name);
+ con_toggle_fullscreen(current->con, $2);
+ }
-next:
- TOK_NEXT WHITESPACE direction
- {
- /* TODO: use matches */
- printf("should select next window in direction %c\n", $<chr>3);
- tree_next('n', ($<chr>3 == 'v' ? VERT : HORIZ));
+ tree_render();
}
;
-prev:
- TOK_PREV WHITESPACE direction
- {
- /* TODO: use matches */
- printf("should select prev window in direction %c\n", $<chr>3);
- tree_next('p', ($<chr>3 == 'v' ? VERT : HORIZ));
- }
+fullscreen_mode:
+ /* empty */ { $$ = CF_OUTPUT; }
+ | TOK_GLOBAL { $$ = CF_GLOBAL; }
;
split:
- TOK_SPLIT WHITESPACE direction
+ TOK_SPLIT split_direction
{
/* TODO: use matches */
- printf("splitting in direction %c\n", $<chr>3);
- tree_split(focused, ($<chr>3 == 'v' ? VERT : HORIZ));
+ printf("splitting in direction %c\n", $2);
+ tree_split(focused, ($2 == 'v' ? VERT : HORIZ));
+
+ tree_render();
}
;
-direction:
- TOK_HORIZONTAL { $<chr>$ = 'h'; }
- | 'h' { $<chr>$ = 'h'; }
- | TOK_VERTICAL { $<chr>$ = 'v'; }
- | 'v' { $<chr>$ = 'v'; }
+split_direction:
+ TOK_HORIZONTAL { $$ = 'h'; }
+ | 'h' { $$ = 'h'; }
+ | TOK_VERTICAL { $$ = 'v'; }
+ | 'v' { $$ = 'v'; }
;
-mode:
- TOK_MODE WHITESPACE window_mode
+floating:
+ TOK_FLOATING boolean
{
- if ($<number>3 == TOK_TOGGLE) {
- printf("should toggle mode\n");
- toggle_floating_mode(focused, false);
- } else {
- printf("should switch mode to %s\n", ($<number>3 == TOK_FLOATING ? "floating" : "tiling"));
- if ($<number>3 == TOK_FLOATING) {
- floating_enable(focused, false);
+ HANDLE_EMPTY_MATCH;
+
+ owindow *current;
+ TAILQ_FOREACH(current, &owindows, owindows) {
+ printf("matching: %p / %s\n", current->con, current->con->name);
+ if ($2 == TOK_TOGGLE) {
+ printf("should toggle mode\n");
+ toggle_floating_mode(current->con, false);
} else {
- floating_disable(focused, false);
+ printf("should switch mode to %s\n", ($2 == TOK_FLOATING ? "floating" : "tiling"));
+ if ($2 == TOK_ENABLE) {
+ floating_enable(current->con, false);
+ } else {
+ floating_disable(current->con, false);
+ }
}
}
+
+ tree_render();
}
;
-window_mode:
- TOK_FLOATING { $<number>$ = TOK_FLOATING; }
- | TOK_TILING { $<number>$ = TOK_TILING; }
- | TOK_TOGGLE { $<number>$ = TOK_TOGGLE; }
+boolean:
+ TOK_ENABLE { $$ = TOK_ENABLE; }
+ | TOK_DISABLE { $$ = TOK_DISABLE; }
+ | TOK_TOGGLE { $$ = TOK_TOGGLE; }
;
border:
- TOK_BORDER WHITESPACE border_style
+ TOK_BORDER border_style
{
- printf("border style should be changed to %d\n", $<number>3);
+ printf("border style should be changed to %d\n", $2);
owindow *current;
- /* check if the match is empty, not if the result is empty */
- if (match_is_empty(¤t_match))
- focused->border_style = $<number>3;
- else {
- TAILQ_FOREACH(current, &owindows, owindows) {
- printf("matching: %p / %s\n", current->con, current->con->name);
- current->con->border_style = $<number>3;
- }
- }
- }
- ;
-
-border_style:
- TOK_NORMAL { $<number>$ = BS_NORMAL; }
- | TOK_NONE { $<number>$ = BS_NONE; }
- | TOK_1PIXEL { $<number>$ = BS_1PIXEL; }
- ;
+ HANDLE_EMPTY_MATCH;
+ TAILQ_FOREACH(current, &owindows, owindows) {
+ printf("matching: %p / %s\n", current->con, current->con->name);
+ if ($2 == TOK_TOGGLE) {
+ current->con->border_style++;
+ current->con->border_style %= 3;
+ } else current->con->border_style = $2;
+ }
-level:
- TOK_LEVEL WHITESPACE level_direction
- {
- printf("level %c\n", $<chr>3);
- if ($<chr>3 == 'u')
- level_up();
- else level_down();
+ tree_render();
}
;
-level_direction:
- TOK_UP { $<chr>$ = 'u'; }
- | TOK_DOWN { $<chr>$ = 'd'; }
+border_style:
+ TOK_NORMAL { $$ = BS_NORMAL; }
+ | TOK_NONE { $$ = BS_NONE; }
+ | TOK_1PIXEL { $$ = BS_1PIXEL; }
+ | TOK_TOGGLE { $$ = TOK_TOGGLE; }
;
move:
- TOK_MOVE WHITESPACE before_after WHITESPACE direction
+ TOK_MOVE direction
{
- printf("moving: %s and %c\n", ($<number>3 == TOK_BEFORE ? "before" : "after"), $<chr>5);
- /* TODO: change API for the next call, we need to convert in both directions while ideally
- * we should not need any of both */
- tree_move(($<number>3 == TOK_BEFORE ? 'p' : 'n'), ($<chr>5 == 'v' ? VERT : HORIZ));
+ printf("moving in direction %d\n", $2);
+ tree_move($2);
+
+ tree_render();
}
- | TOK_MOVE WHITESPACE TOK_WORKSPACE WHITESPACE STR
+ | TOK_MOVE TOK_WORKSPACE STR
{
owindow *current;
- printf("should move window to workspace %s\n", $<string>5);
+ printf("should move window to workspace %s\n", $3);
/* get the workspace */
- Con *ws = workspace_get($<string>5);
+ Con *ws = workspace_get($3, NULL);
+ free($3);
- /* check if the match is empty, not if the result is empty */
- if (match_is_empty(¤t_match))
- con_move_to_workspace(focused, ws);
- else {
- TAILQ_FOREACH(current, &owindows, owindows) {
- printf("matching: %p / %s\n", current->con, current->con->name);
- con_move_to_workspace(current->con, ws);
- }
+ HANDLE_EMPTY_MATCH;
+
+ TAILQ_FOREACH(current, &owindows, owindows) {
+ printf("matching: %p / %s\n", current->con, current->con->name);
+ con_move_to_workspace(current->con, ws);
}
- }
- ;
-before_after:
- TOK_BEFORE { $<number>$ = TOK_BEFORE; }
- | TOK_AFTER { $<number>$ = TOK_AFTER; }
+ tree_render();
+ }
;
-restore:
- TOK_RESTORE WHITESPACE STR
+append_layout:
+ TOK_APPEND_LAYOUT STR
{
- printf("restoring \"%s\"\n", $<string>3);
- tree_append_json($<string>3);
+ printf("restoring \"%s\"\n", $2);
+ tree_append_json($2);
+ free($2);
+ tree_render();
}
;
layout:
- TOK_LAYOUT WHITESPACE layout_mode
+ TOK_LAYOUT layout_mode
{
- printf("changing layout to %d\n", $<number>3);
+ printf("changing layout to %d\n", $2);
owindow *current;
/* check if the match is empty, not if the result is empty */
if (match_is_empty(¤t_match))
- focused->parent->layout = $<number>3;
+ con_set_layout(focused->parent, $2);
else {
TAILQ_FOREACH(current, &owindows, owindows) {
printf("matching: %p / %s\n", current->con, current->con->name);
- current->con->layout = $<number>3;
+ con_set_layout(current->con, $2);
}
}
+ tree_render();
}
;
layout_mode:
- TOK_DEFAULT { $<number>$ = L_DEFAULT; }
- | TOK_STACKED { $<number>$ = L_STACKED; }
- | TOK_TABBED { $<number>$ = L_TABBED; }
+ TOK_DEFAULT { $$ = L_DEFAULT; }
+ | TOK_STACKED { $$ = L_STACKED; }
+ | TOK_TABBED { $$ = L_TABBED; }
;
mark:
- TOK_MARK WHITESPACE STR
+ TOK_MARK STR
{
- printf("marking window with str %s\n", $<string>3);
+ printf("marking window with str %s\n", $2);
owindow *current;
- /* check if the match is empty, not if the result is empty */
- if (match_is_empty(¤t_match))
- focused->mark = sstrdup($<string>3);
- else {
- TAILQ_FOREACH(current, &owindows, owindows) {
- printf("matching: %p / %s\n", current->con, current->con->name);
- current->con->mark = sstrdup($<string>3);
- }
+ HANDLE_EMPTY_MATCH;
+
+ TAILQ_FOREACH(current, &owindows, owindows) {
+ printf("matching: %p / %s\n", current->con, current->con->name);
+ current->con->mark = sstrdup($2);
}
- free($<string>3);
+ free($<string>2);
+
+ tree_render();
+ }
+ ;
+
+nop:
+ TOK_NOP STR
+ {
+ printf("-------------------------------------------------\n");
+ printf(" NOP: %s\n", $2);
+ printf("-------------------------------------------------\n");
+ free($2);
}
;
resize:
- TOK_RESIZE WHITESPACE resize_way WHITESPACE direction resize_px resize_tiling
+ TOK_RESIZE resize_way direction resize_px resize_tiling
{
/* resize <grow|shrink> <direction> [<px> px] [or <ppt> ppt] */
- printf("resizing in way %d, direction %d, px %d or ppt %d\n", $<number>3, $<number>5, $<number>6, $<number>7);
- int direction = $<number>5;
- int px = $<number>6;
- int ppt = $<number>7;
- if ($<number>3 == TOK_SHRINK) {
+ printf("resizing in way %d, direction %d, px %d or ppt %d\n", $2, $3, $4, $5);
+ int direction = $3;
+ int px = $4;
+ int ppt = $5;
+ if ($2 == TOK_SHRINK) {
px *= -1;
ppt *= -1;
}
} else {
LOG("tiling resize\n");
/* get the default percentage */
- int children = 0;
+ int children = con_num_children(focused->parent);
Con *other;
- TAILQ_FOREACH(other, &(focused->parent->nodes_head), nodes)
- children++;
LOG("ins. %d children\n", children);
double percentage = 1.0 / children;
LOG("default percentage = %f\n", percentage);
LOG("focused->percent after = %f\n", focused->percent);
LOG("other->percent after = %f\n", other->percent);
}
+
+ tree_render();
}
;
resize_px:
/* empty */
{
- $<number>$ = 10;
+ $$ = 10;
}
- | WHITESPACE NUMBER WHITESPACE TOK_PX
+ | NUMBER TOK_PX
{
- $<number>$ = $<number>2;
+ $$ = $1;
}
;
resize_tiling:
/* empty */
{
- $<number>$ = 10;
+ $$ = 10;
}
- | WHITESPACE TOK_OR WHITESPACE NUMBER WHITESPACE TOK_PPT
+ | TOK_OR NUMBER TOK_PPT
{
- $<number>$ = $<number>4;
+ $$ = $2;
}
;
resize_way:
- TOK_GROW { $<number>$ = TOK_GROW; }
- | TOK_SHRINK { $<number>$ = TOK_SHRINK; }
+ TOK_GROW { $$ = TOK_GROW; }
+ | TOK_SHRINK { $$ = TOK_SHRINK; }
;
direction:
- TOK_UP { $<number>$ = TOK_UP; }
- | TOK_DOWN { $<number>$ = TOK_DOWN; }
- | TOK_LEFT { $<number>$ = TOK_LEFT; }
- | TOK_RIGHT { $<number>$ = TOK_RIGHT; }
+ TOK_UP { $$ = TOK_UP; }
+ | TOK_DOWN { $$ = TOK_DOWN; }
+ | TOK_LEFT { $$ = TOK_LEFT; }
+ | TOK_RIGHT { $$ = TOK_RIGHT; }
+ ;
+
+mode:
+ TOK_MODE STR
+ {
+ switch_mode($2);
+ }
;
projects / i3 / i3 / blobdiff