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_pointer_action(char *s, pointer_action_t *a)
 157 {
 158         if (streq("move", s)) {
 159                 *a = ACTION_MOVE;
 160                 return true;
 161         } else if (streq("resize_corner", s)) {
 162                 *a = ACTION_RESIZE_CORNER;
 163                 return true;
 164         } else if (streq("resize_side", s)) {
 165                 *a = ACTION_RESIZE_SIDE;
 166                 return true;
 167         } else if (streq("focus", s)) {
 168                 *a = ACTION_FOCUS;
 169                 return true;
 170         }
 171         return false;
 172 }
 173
 174 bool parse_child_polarity(char *s, child_polarity_t *p)
 175 {
 176         if (streq("first_child", s)) {
 177                 *p = FIRST_CHILD;
 178                 return true;
 179         } else if (streq("second_child", s)) {
 180                 *p = SECOND_CHILD;
 181                 return true;
 182         }
 183         return false;
 184 }
 185
 186 bool parse_degree(char *s, int *d)
 187 {
 188         int i = atoi(s);
 189         while (i < 0)
 190                 i += 360;
 191         while (i > 359)
 192                 i -= 360;
 193         if ((i % 90) != 0) {
 194                 return false;
 195         } else {
 196                 *d = i;
 197                 return true;
 198         }
 199 }
 200
 201 bool parse_id(char *s, uint32_t *id)
 202 {
 203         char *end;
 204         errno = 0;
 205         uint32_t v = strtol(s, &end, 0);
 206         if (errno != 0 || *end != '\0') {
 207                 return false;
 208         }
 209         *id = v;
 210         return true;
 211 }
 212
 213 bool parse_bool_declaration(char *s, char **key, bool *value, alter_state_t *state)
 214 {
 215         *key = strtok(s, EQL_TOK);
 216         char *v = strtok(NULL, EQL_TOK);
 217         if (v == NULL) {
 218                 *state = ALTER_TOGGLE;
 219                 return true;
 220         } else {
 221                 if (parse_bool(v, value)) {
 222                         *state = ALTER_SET;
 223                         return true;
 224                 } else {
 225                         return false;
 226                 }
 227         }
 228         return false;
 229 }
 230
 231 bool parse_index(char *s, uint16_t *idx)
 232 {
 233         return (sscanf(s, "^%hu", idx) == 1);
 234 }
 235
 236 bool parse_rectangle(char *s, xcb_rectangle_t *r)
 237 {
 238         uint16_t w, h;
 239         int16_t x, y;
 240         if (sscanf(s, "%hux%hu+%hi+%hi", &w, &h, &x, &y) != 4) {
 241                 return false;
 242         }
 243         r->width = w;
 244         r->height = h;
 245         r->x = x;
 246         r->y = y;
 247         return true;
 248 }
 249
 250 bool parse_subscriber_mask(char *s, subscriber_mask_t *mask)
 251 {
 252         if (streq("all", s)) {
 253                 *mask = SBSC_MASK_ALL;
 254         } else if (streq("node", s)) {
 255                 *mask = SBSC_MASK_NODE;
 256         } else if (streq("desktop", s)) {
 257                 *mask = SBSC_MASK_DESKTOP;
 258         } else if (streq("monitor", s)) {
 259                 *mask = SBSC_MASK_MONITOR;
 260         } else if (streq("node_manage", s)) {
 261                 *mask = SBSC_MASK_NODE_MANAGE;
 262         } else if (streq("node_unmanage", s)) {
 263                 *mask = SBSC_MASK_NODE_UNMANAGE;
 264         } else if (streq("node_swap", s)) {
 265                 *mask = SBSC_MASK_NODE_SWAP;
 266         } else if (streq("node_transfer", s)) {
 267                 *mask = SBSC_MASK_NODE_TRANSFER;
 268         } else if (streq("node_focus", s)) {
 269                 *mask = SBSC_MASK_NODE_FOCUS;
 270         } else if (streq("node_presel", s)) {
 271                 *mask = SBSC_MASK_NODE_PRESEL;
 272         } else if (streq("node_stack", s)) {
 273                 *mask = SBSC_MASK_NODE_STACK;
 274         } else if (streq("node_activate", s)) {
 275                 *mask = SBSC_MASK_NODE_ACTIVATE;
 276         } else if (streq("node_geometry", s)) {
 277                 *mask = SBSC_MASK_NODE_GEOMETRY;
 278         } else if (streq("node_state", s)) {
 279                 *mask = SBSC_MASK_NODE_STATE;
 280         } else if (streq("node_flag", s)) {
 281                 *mask = SBSC_MASK_NODE_FLAG;
 282         } else if (streq("node_layer", s)) {
 283                 *mask = SBSC_MASK_NODE_LAYER;
 284         } else if (streq("desktop_add", s)) {
 285                 *mask = SBSC_MASK_DESKTOP_ADD;
 286         } else if (streq("desktop_rename", s)) {
 287                 *mask = SBSC_MASK_DESKTOP_RENAME;
 288         } else if (streq("desktop_remove", s)) {
 289                 *mask = SBSC_MASK_DESKTOP_REMOVE;
 290         } else if (streq("desktop_swap", s)) {
 291                 *mask = SBSC_MASK_DESKTOP_SWAP;
 292         } else if (streq("desktop_transfer", s)) {
 293                 *mask = SBSC_MASK_DESKTOP_TRANSFER;
 294         } else if (streq("desktop_focus", s)) {
 295                 *mask = SBSC_MASK_DESKTOP_FOCUS;
 296         } else if (streq("desktop_activate", s)) {
 297                 *mask = SBSC_MASK_DESKTOP_ACTIVATE;
 298         } else if (streq("desktop_layout", s)) {
 299                 *mask = SBSC_MASK_DESKTOP_LAYOUT;
 300         } else if (streq("monitor_add", s)) {
 301                 *mask = SBSC_MASK_MONITOR_ADD;
 302         } else if (streq("monitor_rename", s)) {
 303                 *mask = SBSC_MASK_MONITOR_RENAME;
 304         } else if (streq("monitor_remove", s)) {
 305                 *mask = SBSC_MASK_MONITOR_REMOVE;
 306         } else if (streq("monitor_swap", s)) {
 307                 *mask = SBSC_MASK_MONITOR_SWAP;
 308         } else if (streq("monitor_focus", s)) {
 309                 *mask = SBSC_MASK_MONITOR_FOCUS;
 310         } else if (streq("monitor_geometry", s)) {
 311                 *mask = SBSC_MASK_MONITOR_GEOMETRY;
 312         } else if (streq("report", s)) {
 313                 *mask = SBSC_MASK_REPORT;
 314         } else {
 315                 return false;
 316         }
 317         return true;
 318 }
 319
 320
 321 #define GET_MOD(k) \
 322         } else if (streq(#k, tok)) { \
 323                 sel->k = OPTION_TRUE; \
 324         } else if (streq("!" #k, tok)) { \
 325                 sel->k = OPTION_FALSE;
 326
 327 bool parse_monitor_modifiers(char *desc, monitor_select_t *sel)
 328 {
 329         char *tok;
 330         while ((tok = strrchr(desc, CAT_CHR)) != NULL) {
 331                 tok[0] = '\0';
 332                 tok++;
 333                 if (streq("occupied", tok)) {
 334                         sel->occupied = OPTION_TRUE;
 335                 } else if (streq("!occupied", tok)) {
 336                         sel->occupied = OPTION_FALSE;
 337                 GET_MOD(focused)
 338                 } else {
 339                         return false;
 340                 }
 341         }
 342         return true;
 343 }
 344
 345 bool parse_desktop_modifiers(char *desc, desktop_select_t *sel)
 346 {
 347         char *tok;
 348         while ((tok = strrchr(desc, CAT_CHR)) != NULL) {
 349                 tok[0] = '\0';
 350                 tok++;
 351                 if (streq("occupied", tok)) {
 352                         sel->occupied = OPTION_TRUE;
 353                 } else if (streq("!occupied", tok)) {
 354                         sel->occupied = OPTION_FALSE;
 355                 GET_MOD(focused)
 356                 GET_MOD(urgent)
 357                 GET_MOD(local)
 358                 } else {
 359                         return false;
 360                 }
 361         }
 362         return true;
 363
 364 }
 365
 366 bool parse_node_modifiers(char *desc, node_select_t *sel)
 367 {
 368         char *tok;
 369         while ((tok = strrchr(desc, CAT_CHR)) != NULL) {
 370                 tok[0] = '\0';
 371                 tok++;
 372                 if (streq("tiled", tok)) {
 373                         sel->tiled = OPTION_TRUE;
 374                 } else if (streq("!tiled", tok)) {
 375                         sel->tiled = OPTION_FALSE;
 376                 GET_MOD(automatic)
 377                 GET_MOD(focused)
 378                 GET_MOD(local)
 379                 GET_MOD(leaf)
 380                 GET_MOD(window)
 381                 GET_MOD(pseudo_tiled)
 382                 GET_MOD(floating)
 383                 GET_MOD(fullscreen)
 384                 GET_MOD(locked)
 385                 GET_MOD(sticky)
 386                 GET_MOD(private)
 387                 GET_MOD(urgent)
 388                 GET_MOD(same_class)
 389                 GET_MOD(below)
 390                 GET_MOD(normal)
 391                 GET_MOD(above)
 392                 } else {
 393                         return false;
 394                 }
 395         }
 396         return true;
 397 }
 398
 399 #undef GET_MOD