src/parse.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <stdbool.h>
   5 #include <errno.h>
   6 #include "parse.h"
   7
   8 bool parse_bool(char *value, bool *b)
   9 {
  10         if (streq("true", value) || streq("on", value)) {
  11                 *b = true;
  12                 return true;
  13         } else if (streq("false", value) || streq("off", value)) {
  14                 *b = false;
  15                 return true;
  16         }
  17         return false;
  18 }
  19
  20 bool parse_split_type(char *s, split_type_t *t)
  21 {
  22         if (streq("horizontal", s)) {
  23                 *t = TYPE_HORIZONTAL;
  24                 return true;
  25         } else if (streq("vertical", s)) {
  26                 *t = TYPE_VERTICAL;
  27                 return true;
  28         }
  29         return false;
  30 }
  31
  32 bool parse_split_mode(char *s, split_mode_t *m)
  33 {
  34         if (streq("automatic", s)) {
  35                 *m = MODE_AUTOMATIC;
  36                 return true;
  37         } else if (streq("vertical", s)) {
  38                 *m = MODE_MANUAL;
  39                 return true;
  40         }
  41         return false;
  42 }
  43
  44 bool parse_layout(char *s, layout_t *l)
  45 {
  46         if (streq("monocle", s)) {
  47                 *l = LAYOUT_MONOCLE;
  48                 return true;
  49         } else if (streq("tiled", s)) {
  50                 *l = LAYOUT_TILED;
  51                 return true;
  52         }
  53         return false;
  54 }
  55
  56 bool parse_client_state(char *s, client_state_t *t)
  57 {
  58         if (streq("tiled", s)) {
  59                 *t = STATE_TILED;
  60                 return true;
  61         } else if (streq("pseudo_tiled", s)) {
  62                 *t = STATE_PSEUDO_TILED;
  63                 return true;
  64         } else if (streq("floating", s)) {
  65                 *t = STATE_FLOATING;
  66                 return true;
  67         } else if (streq("fullscreen", s)) {
  68                 *t = STATE_FULLSCREEN;
  69                 return true;
  70         }
  71         return false;
  72 }
  73
  74 bool parse_stack_layer(char *s, stack_layer_t *l)
  75 {
  76         if (streq("below", s)) {
  77                 *l = LAYER_BELOW;
  78                 return true;
  79         } else if (streq("normal", s)) {
  80                 *l = LAYER_NORMAL;
  81                 return true;
  82         } else if (streq("above", s)) {
  83                 *l = LAYER_ABOVE;
  84                 return true;
  85         }
  86         return false;
  87 }
  88
  89 bool parse_direction(char *s, direction_t *d)
  90 {
  91         if (streq("north", s)) {
  92                 *d = DIR_NORTH;
  93                 return true;
  94         } else if (streq("west", s)) {
  95                 *d = DIR_WEST;
  96                 return true;
  97         } else if (streq("south", s)) {
  98                 *d = DIR_SOUTH;
  99                 return true;
 100         } else if (streq("east", s)) {
 101                 *d = DIR_EAST;
 102                 return true;
 103         }
 104         return false;
 105 }
 106
 107 bool parse_cycle_direction(char *s, cycle_dir_t *d)
 108 {
 109         if (streq("next", s)) {
 110                 *d = CYCLE_NEXT;
 111                 return true;
 112         } else if (streq("prev", s)) {
 113                 *d = CYCLE_PREV;
 114                 return true;
 115         }
 116         return false;
 117 }
 118
 119 bool parse_circulate_direction(char *s, circulate_dir_t *d)
 120 {
 121         if (streq("forward", s)) {
 122                 *d = CIRCULATE_FORWARD;
 123                 return true;
 124         } else if (streq("backward", s)) {
 125                 *d = CIRCULATE_BACKWARD;
 126                 return true;
 127         }
 128         return false;
 129 }
 130
 131 bool parse_history_direction(char *s, history_dir_t *d)
 132 {
 133         if (streq("older", s)) {
 134                 *d = HISTORY_OLDER;
 135                 return true;
 136         } else if (streq("newer", s)) {
 137                 *d = HISTORY_NEWER;
 138                 return true;
 139         }
 140         return false;
 141 }
 142
 143
 144 bool parse_flip(char *s, flip_t *f)
 145 {
 146         if (streq("horizontal", s)) {
 147                 *f = FLIP_HORIZONTAL;
 148                 return true;
 149         } else if (streq("vertical", s)) {
 150                 *f = FLIP_VERTICAL;
 151                 return true;
 152         }
 153         return false;
 154 }
 155
 156 bool parse_resize_handle(char *s, resize_handle_t *h)
 157 {
 158         if (streq("left", s)) {
 159                 *h = HANDLE_LEFT;
 160                 return true;
 161         } else if (streq("top", s)) {
 162                 *h = HANDLE_TOP;
 163                 return true;
 164         } else if (streq("right", s)) {
 165                 *h = HANDLE_RIGHT;
 166                 return true;
 167         } else if (streq("bottom", s)) {
 168                 *h = HANDLE_BOTTOM;
 169                 return true;
 170         } else if (streq("top_left", s)) {
 171                 *h = HANDLE_TOP_LEFT;
 172                 return true;
 173         } else if (streq("top_right", s)) {
 174                 *h = HANDLE_TOP_RIGHT;
 175                 return true;
 176         } else if (streq("bottom_right", s)) {
 177                 *h = HANDLE_BOTTOM_RIGHT;
 178                 return true;
 179         } else if (streq("bottom_left", s)) {
 180                 *h = HANDLE_BOTTOM_LEFT;
 181                 return true;
 182         }
 183         return false;
 184 }
 185
 186 bool parse_modifier_mask(char *s, uint16_t *m)
 187 {
 188         if (strcmp(s, "shift") == 0) {
 189                 *m = XCB_MOD_MASK_SHIFT;
 190                 return true;
 191         } else if (strcmp(s, "control") == 0) {
 192                 *m = XCB_MOD_MASK_CONTROL;
 193                 return true;
 194         } else if (strcmp(s, "lock") == 0) {
 195                 *m = XCB_MOD_MASK_LOCK;
 196                 return true;
 197         } else if (strcmp(s, "mod1") == 0) {
 198                 *m = XCB_MOD_MASK_1;
 199                 return true;
 200         } else if (strcmp(s, "mod2") == 0) {
 201                 *m = XCB_MOD_MASK_2;
 202                 return true;
 203         } else if (strcmp(s, "mod3") == 0) {
 204                 *m = XCB_MOD_MASK_3;
 205                 return true;
 206         } else if (strcmp(s, "mod4") == 0) {
 207                 *m = XCB_MOD_MASK_4;
 208                 return true;
 209         } else if (strcmp(s, "mod5") == 0) {
 210                 *m = XCB_MOD_MASK_5;
 211                 return true;
 212         }
 213         return false;
 214 }
 215
 216 bool parse_button_index(char *s, int8_t *b)
 217 {
 218         if (strcmp(s, "any") == 0) {
 219                 *b = XCB_BUTTON_INDEX_ANY;
 220                 return true;
 221         } else if (strcmp(s, "button1") == 0) {
 222                 *b = XCB_BUTTON_INDEX_1;
 223                 return true;
 224         } else if (strcmp(s, "button2") == 0) {
 225                 *b = XCB_BUTTON_INDEX_2;
 226                 return true;
 227         } else if (strcmp(s, "button3") == 0) {
 228                 *b = XCB_BUTTON_INDEX_3;
 229                 return true;
 230         } else if (strcmp(s, "none") == 0) {
 231                 *b = -1;
 232                 return true;
 233         }
 234         return false;
 235 }
 236
 237 bool parse_pointer_action(char *s, pointer_action_t *a)
 238 {
 239         if (streq("move", s)) {
 240                 *a = ACTION_MOVE;
 241                 return true;
 242         } else if (streq("resize_corner", s)) {
 243                 *a = ACTION_RESIZE_CORNER;
 244                 return true;
 245         } else if (streq("resize_side", s)) {
 246                 *a = ACTION_RESIZE_SIDE;
 247                 return true;
 248         } else if (streq("focus", s)) {
 249                 *a = ACTION_FOCUS;
 250                 return true;
 251         } else if (streq("none", s)) {
 252                 *a = ACTION_NONE;
 253                 return true;
 254         }
 255         return false;
 256 }
 257
 258 bool parse_child_polarity(char *s, child_polarity_t *p)
 259 {
 260         if (streq("first_child", s)) {
 261                 *p = FIRST_CHILD;
 262                 return true;
 263         } else if (streq("second_child", s)) {
 264                 *p = SECOND_CHILD;
 265                 return true;
 266         }
 267         return false;
 268 }
 269
 270 bool parse_automatic_scheme(char *s, automatic_scheme_t *a)
 271 {
 272         if (streq("longest_side", s)) {
 273                 *a = SCHEME_LONGEST_SIDE;
 274                 return true;
 275         } else if (streq("alternate", s)) {
 276                 *a = SCHEME_ALTERNATE;
 277                 return true;
 278         } else if (streq("spiral", s)) {
 279                 *a = SCHEME_SPIRAL;
 280                 return true;
 281         }
 282         return false;
 283 }
 284
 285 bool parse_state_transition(char *s, state_transition_t *m)
 286 {
 287         if (streq("none", s)) {
 288                 *m = 0;
 289                 return true;
 290         } else if (streq("all", s)) {
 291                 *m = STATE_TRANSITION_ENTER | STATE_TRANSITION_EXIT;
 292                 return true;
 293         } else {
 294                 state_transition_t w = 0;
 295                 char *x = copy_string(s, strlen(s));
 296                 char *key = strtok(x, ",");
 297                 while (key != NULL) {
 298                         if (streq("enter", key)) {
 299                                 w |= STATE_TRANSITION_ENTER;
 300                         } else if (streq("exit", key)) {
 301                                 w |= STATE_TRANSITION_EXIT;
 302                         } else {
 303                                 free(x);
 304                                 return false;
 305                         }
 306                         key = strtok(NULL, ",");
 307                 }
 308                 free(x);
 309                 if (w != 0) {
 310                         *m = w;
 311                         return true;
 312                 } else {
 313                         return false;
 314                 }
 315         }
 316         return false;
 317 }
 318
 319 bool parse_tightness(char *s, tightness_t *t)
 320 {
 321         if (streq("high", s)) {
 322                 *t = TIGHTNESS_HIGH;
 323                 return true;
 324         } else if (streq("low", s)) {
 325                 *t = TIGHTNESS_LOW;
 326                 return true;
 327         }
 328         return false;
 329 }
 330
 331 bool parse_degree(char *s, int *d)
 332 {
 333         int i = atoi(s);
 334         while (i < 0)
 335                 i += 360;
 336         while (i > 359)
 337                 i -= 360;
 338         if ((i % 90) != 0) {
 339                 return false;
 340         } else {
 341                 *d = i;
 342                 return true;
 343         }
 344 }
 345
 346 bool parse_id(char *s, uint32_t *id)
 347 {
 348         char *end;
 349         errno = 0;
 350         uint32_t v = strtol(s, &end, 0);
 351         if (errno != 0 || *end != '\0') {
 352                 return false;
 353         }
 354         *id = v;
 355         return true;
 356 }
 357
 358 bool parse_bool_declaration(char *s, char **key, bool *value, alter_state_t *state)
 359 {
 360         *key = strtok(s, EQL_TOK);
 361         char *v = strtok(NULL, EQL_TOK);
 362         if (v == NULL) {
 363                 *state = ALTER_TOGGLE;
 364                 return true;
 365         } else {
 366                 if (parse_bool(v, value)) {
 367                         *state = ALTER_SET;
 368                         return true;
 369                 } else {
 370                         return false;
 371                 }
 372         }
 373         return false;
 374 }
 375
 376 bool parse_index(char *s, uint16_t *idx)
 377 {
 378         return (sscanf(s, "^%hu", idx) == 1);
 379 }
 380
 381 bool parse_rectangle(char *s, xcb_rectangle_t *r)
 382 {
 383         uint16_t w, h;
 384         int16_t x, y;
 385         if (sscanf(s, "%hux%hu+%hi+%hi", &w, &h, &x, &y) != 4) {
 386                 return false;
 387         }
 388         r->width = w;
 389         r->height = h;
 390         r->x = x;
 391         r->y = y;
 392         return true;
 393 }
 394
 395 bool parse_subscriber_mask(char *s, subscriber_mask_t *mask)
 396 {
 397         if (streq("all", s)) {
 398                 *mask = SBSC_MASK_ALL;
 399         } else if (streq("node", s)) {
 400                 *mask = SBSC_MASK_NODE;
 401         } else if (streq("desktop", s)) {
 402                 *mask = SBSC_MASK_DESKTOP;
 403         } else if (streq("monitor", s)) {
 404                 *mask = SBSC_MASK_MONITOR;
 405         } else if (streq("pointer_action", s)) {
 406                 *mask = SBSC_MASK_POINTER_ACTION;
 407         } else if (streq("node_add", s)) {
 408                 *mask = SBSC_MASK_NODE_ADD;
 409         } else if (streq("node_remove", s)) {
 410                 *mask = SBSC_MASK_NODE_REMOVE;
 411         } else if (streq("node_swap", s)) {
 412                 *mask = SBSC_MASK_NODE_SWAP;
 413         } else if (streq("node_transfer", s)) {
 414                 *mask = SBSC_MASK_NODE_TRANSFER;
 415         } else if (streq("node_focus", s)) {
 416                 *mask = SBSC_MASK_NODE_FOCUS;
 417         } else if (streq("node_presel", s)) {
 418                 *mask = SBSC_MASK_NODE_PRESEL;
 419         } else if (streq("node_stack", s)) {
 420                 *mask = SBSC_MASK_NODE_STACK;
 421         } else if (streq("node_activate", s)) {
 422                 *mask = SBSC_MASK_NODE_ACTIVATE;
 423         } else if (streq("node_geometry", s)) {
 424                 *mask = SBSC_MASK_NODE_GEOMETRY;
 425         } else if (streq("node_state", s)) {
 426                 *mask = SBSC_MASK_NODE_STATE;
 427         } else if (streq("node_flag", s)) {
 428                 *mask = SBSC_MASK_NODE_FLAG;
 429         } else if (streq("node_layer", s)) {
 430                 *mask = SBSC_MASK_NODE_LAYER;
 431         } else if (streq("desktop_add", s)) {
 432                 *mask = SBSC_MASK_DESKTOP_ADD;
 433         } else if (streq("desktop_rename", s)) {
 434                 *mask = SBSC_MASK_DESKTOP_RENAME;
 435         } else if (streq("desktop_remove", s)) {
 436                 *mask = SBSC_MASK_DESKTOP_REMOVE;
 437         } else if (streq("desktop_swap", s)) {
 438                 *mask = SBSC_MASK_DESKTOP_SWAP;
 439         } else if (streq("desktop_transfer", s)) {
 440                 *mask = SBSC_MASK_DESKTOP_TRANSFER;
 441         } else if (streq("desktop_focus", s)) {
 442                 *mask = SBSC_MASK_DESKTOP_FOCUS;
 443         } else if (streq("desktop_activate", s)) {
 444                 *mask = SBSC_MASK_DESKTOP_ACTIVATE;
 445         } else if (streq("desktop_layout", s)) {
 446                 *mask = SBSC_MASK_DESKTOP_LAYOUT;
 447         } else if (streq("monitor_add", s)) {
 448                 *mask = SBSC_MASK_MONITOR_ADD;
 449         } else if (streq("monitor_rename", s)) {
 450                 *mask = SBSC_MASK_MONITOR_RENAME;
 451         } else if (streq("monitor_remove", s)) {
 452                 *mask = SBSC_MASK_MONITOR_REMOVE;
 453         } else if (streq("monitor_swap", s)) {
 454                 *mask = SBSC_MASK_MONITOR_SWAP;
 455         } else if (streq("monitor_focus", s)) {
 456                 *mask = SBSC_MASK_MONITOR_FOCUS;
 457         } else if (streq("monitor_geometry", s)) {
 458                 *mask = SBSC_MASK_MONITOR_GEOMETRY;
 459         } else if (streq("report", s)) {
 460                 *mask = SBSC_MASK_REPORT;
 461         } else {
 462                 return false;
 463         }
 464         return true;
 465 }
 466
 467
 468 #define GET_MOD(k) \
 469         } else if (streq(#k, tok)) { \
 470                 sel->k = OPTION_TRUE; \
 471         } else if (streq("!" #k, tok)) { \
 472                 sel->k = OPTION_FALSE;
 473
 474 bool parse_monitor_modifiers(char *desc, monitor_select_t *sel)
 475 {
 476         char *tok;
 477         while ((tok = strrchr(desc, CAT_CHR)) != NULL) {
 478                 tok[0] = '\0';
 479                 tok++;
 480                 if (streq("occupied", tok)) {
 481                         sel->occupied = OPTION_TRUE;
 482                 } else if (streq("!occupied", tok)) {
 483                         sel->occupied = OPTION_FALSE;
 484                 GET_MOD(focused)
 485                 } else {
 486                         return false;
 487                 }
 488         }
 489         return true;
 490 }
 491
 492 bool parse_desktop_modifiers(char *desc, desktop_select_t *sel)
 493 {
 494         char *tok;
 495         while ((tok = strrchr(desc, CAT_CHR)) != NULL) {
 496                 tok[0] = '\0';
 497                 tok++;
 498                 if (streq("occupied", tok)) {
 499                         sel->occupied = OPTION_TRUE;
 500                 } else if (streq("!occupied", tok)) {
 501                         sel->occupied = OPTION_FALSE;
 502                 GET_MOD(focused)
 503                 GET_MOD(active)
 504                 GET_MOD(urgent)
 505                 GET_MOD(local)
 506                 GET_MOD(tiled)
 507                 GET_MOD(monocle)
 508                 GET_MOD(user_tiled)
 509                 GET_MOD(user_monocle)
 510                 } else {
 511                         return false;
 512                 }
 513         }
 514         return true;
 515
 516 }
 517
 518 bool parse_node_modifiers(char *desc, node_select_t *sel)
 519 {
 520         char *tok;
 521         while ((tok = strrchr(desc, CAT_CHR)) != NULL) {
 522                 tok[0] = '\0';
 523                 tok++;
 524                 if (streq("tiled", tok)) {
 525                         sel->tiled = OPTION_TRUE;
 526                 } else if (streq("!tiled", tok)) {
 527                         sel->tiled = OPTION_FALSE;
 528                 GET_MOD(automatic)
 529                 GET_MOD(focused)
 530                 GET_MOD(active)
 531                 GET_MOD(local)
 532                 GET_MOD(leaf)
 533                 GET_MOD(window)
 534                 GET_MOD(pseudo_tiled)
 535                 GET_MOD(floating)
 536                 GET_MOD(fullscreen)
 537                 GET_MOD(hidden)
 538                 GET_MOD(sticky)
 539                 GET_MOD(private)
 540                 GET_MOD(locked)
 541                 GET_MOD(marked)
 542                 GET_MOD(urgent)
 543                 GET_MOD(same_class)
 544                 GET_MOD(descendant_of)
 545                 GET_MOD(ancestor_of)
 546                 GET_MOD(below)
 547                 GET_MOD(normal)
 548                 GET_MOD(above)
 549                 GET_MOD(horizontal)
 550                 GET_MOD(vertical)
 551                 } else {
 552                         return false;
 553                 }
 554         }
 555         return true;
 556 }
 557
 558 #undef GET_MOD