summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorRichard Grenville <pyxlcy@gmail.com>2013-01-28 21:39:38 +0800
committerRichard Grenville <pyxlcy@gmail.com>2013-01-28 21:39:38 +0800
commit679bfe3cab740f06b38f606d599304f515b9de4d (patch)
treef5112867914ecf0e32101f4659e0f9db78395fd5
parent56a35506b1f65bd36e4f5b30054b348eea79f515 (diff)
downloadtdebase-679bfe3cab740f06b38f606d599304f515b9de4d.tar.gz
tdebase-679bfe3cab740f06b38f606d599304f515b9de4d.zip
Feature #16: Advanced window matching
- Add advanced window matching system, capable of matching against arbitrary window properties as well as a series of internal properties, with 4 additional operators (>, <, >=, <=) useful for integer targets, and support of logical operators. The old matching system is removed, but compatibility with the format is retained. - As the new matching system is pretty complicated, and I have no past experience in writing a parser, it's pretty possible that bugs are present. It also has inferior performance, but I hope it doesn't matter on modern CPUs. - It's possible to disable matching system at compile time with NO_C2=1 now. - Add ps->o.config_file to track which config file we have actually read. Queryable via D-Bus. - Parse -d in first pass in get_cfg() as c2 needs to query X to get atoms during condition parsing. - Fix a bug in wid_get_prop_adv() that 0 == rformat is not handled correctly. - Fix incompatibility with FreeBSD sed in dbus-examples/cdbus-driver.sh . - Add recipe to generate .clang_complete in Makefile, used by Vim clang_complete plugin. - Add DEBUG_C2 for debugging condition string parsing. DEBUG_WINMATCH is still used for match debugging. - Rename win_on_wdata_change() to win_on_factor_change(). - Extra malloc() failure checks. Add const to matching cache members in session_t. Code clean-up. Documentation update.
-rw-r--r--c2.c1296
-rw-r--r--c2.h326
-rw-r--r--common.h58
-rw-r--r--compton.c396
-rw-r--r--compton.h62
-rw-r--r--dbus.c1
6 files changed, 1756 insertions, 383 deletions
diff --git a/c2.c b/c2.c
new file mode 100644
index 000000000..5bbb4e3a8
--- /dev/null
+++ b/c2.c
@@ -0,0 +1,1296 @@
+/*
+ * Compton - a compositor for X11
+ *
+ * Based on `xcompmgr` - Copyright (c) 2003, Keith Packard
+ *
+ * Copyright (c) 2011-2013, Christopher Jeffrey
+ * See LICENSE for more information.
+ *
+ */
+
+#include "c2.h"
+
+/**
+ * Parse a condition string.
+ */
+c2_lptr_t *
+c2_parse(session_t *ps, c2_lptr_t **pcondlst, const char *pattern) {
+ if (!pattern)
+ return NULL;
+
+ // Parse the pattern
+ c2_ptr_t result = C2_PTR_INIT;
+ int offset = -1;
+
+ if (strlen(pattern) >= 2 && ':' == pattern[1])
+ offset = c2_parse_legacy(ps, pattern, 0, &result);
+ else
+ offset = c2_parse_grp(ps, pattern, 0, &result, 0);
+
+ if (offset < 0) {
+ c2_freep(&result);
+ return NULL;
+ }
+
+ // Insert to pcondlst
+ {
+ const static c2_lptr_t lptr_def = C2_LPTR_INIT;
+ c2_lptr_t *plptr = malloc(sizeof(c2_lptr_t));
+ if (!plptr)
+ printf_errfq(1, "(): Failed to allocate memory for new condition linked"
+ " list element.");
+ memcpy(plptr, &lptr_def, sizeof(c2_lptr_t));
+ plptr->ptr = result;
+ if (pcondlst) {
+ plptr->next = *pcondlst;
+ *pcondlst = plptr;
+ }
+
+#ifdef DEBUG_C2
+ printf_dbgf("(\"%s\"): ", pattern);
+ c2_dump(plptr->ptr);
+#endif
+
+ return plptr;
+ }
+}
+
+#undef c2_error
+#define c2_error(format, ...) do { \
+ printf_err("Pattern \"%s\" pos %d: " format, pattern, offset, \
+ ## __VA_ARGS__); \
+ return -1; \
+} while(0)
+
+#define C2H_SKIP_SPACES() { while (isspace(pattern[offset])) ++offset; }
+
+/**
+ * Parse a group in condition string.
+ *
+ * @return offset of next character in string
+ */
+static int
+c2_parse_grp(session_t *ps, const char *pattern, int offset, c2_ptr_t *presult, int level) {
+ // Check for recursion levels
+ if (level > C2_MAX_LEVELS)
+ c2_error("Exceeded maximum recursion levels.");
+
+ if (!pattern)
+ return -1;
+
+ // Expected end character
+ const char endchar = (offset ? ')': '\0');
+
+#undef c2_error
+#define c2_error(format, ...) do { \
+ printf_err("Pattern \"%s\" pos %d: " format, pattern, offset, \
+ ## __VA_ARGS__); \
+ goto c2_parse_grp_fail; \
+} while(0)
+
+ // We use a system that a maximum of 2 elements are kept. When we find
+ // the third element, we combine the elements according to operator
+ // precedence. This design limits operators to have at most two-levels
+ // of precedence and fixed left-to-right associativity.
+
+ // For storing branch operators. ops[0] is actually unused
+ c2_b_op_t ops[3] = { };
+ // For storing elements
+ c2_ptr_t eles[2] = { C2_PTR_INIT, C2_PTR_INIT };
+ // Index of next free element slot in eles
+ int elei = 0;
+ // Pointer to the position of next element
+ c2_ptr_t *pele = eles;
+ // Negation flag of next operator
+ bool neg = false;
+ // Whether we are expecting an element immediately, is true at first, or
+ // after encountering a logical operator
+ bool next_expected = true;
+
+ // Parse the pattern character-by-character
+ for (; pattern[offset]; ++offset) {
+ assert(elei <= 2);
+
+ // Jump over spaces
+ if (isspace(pattern[offset]))
+ continue;
+
+ // Handle end of group
+ if (')' == pattern[offset])
+ break;
+
+ // Handle "!"
+ if ('!' == pattern[offset]) {
+ if (!next_expected)
+ c2_error("Unexpected \"!\".");
+
+ neg = !neg;
+ continue;
+ }
+
+ // Handle AND and OR
+ if ('&' == pattern[offset] || '|' == pattern[offset]) {
+ if (next_expected)
+ c2_error("Unexpected logical operator.");
+
+ next_expected = true;
+ if (!mstrncmp("&&", pattern + offset)) {
+ ops[elei] = C2_B_OAND;
+ ++offset;
+ }
+ else if (!mstrncmp("||", pattern + offset)) {
+ ops[elei] = C2_B_OOR;
+ ++offset;
+ }
+ else
+ c2_error("Illegal logical operator.");
+
+ continue;
+ }
+
+ // Parsing an element
+ if (!next_expected)
+ c2_error("Unexpected expression.");
+
+ assert(!elei || ops[elei]);
+
+ // If we are out of space
+ if (2 == elei) {
+ --elei;
+ // If the first operator has higher or equal precedence, combine
+ // the first two elements
+ if (c2h_b_opcmp(ops[1], ops[2]) >= 0) {
+ eles[0] = c2h_comb_tree(ops[1], eles[0], eles[1]);
+ c2_ptr_reset(&eles[1]);
+ pele = &eles[elei];
+ ops[1] = ops[2];
+ }
+ // Otherwise, combine the second and the incoming one
+ else {
+ eles[1] = c2h_comb_tree(ops[2], eles[1], C2_PTR_NULL);
+ assert(eles[1].isbranch);
+ pele = &eles[1].b->opr2;
+ }
+ // The last operator always needs to be reset
+ ops[2] = C2_B_OUNDEFINED;
+ }
+
+ // It's a subgroup if it starts with '('
+ if ('(' == pattern[offset]) {
+ if ((offset = c2_parse_grp(ps, pattern, offset + 1, pele, level + 1)) < 0)
+ goto c2_parse_grp_fail;
+ }
+ // Otherwise it's a leaf
+ else {
+ if ((offset = c2_parse_target(ps, pattern, offset, pele)) < 0)
+ goto c2_parse_grp_fail;
+
+ assert(!pele->isbranch && !c2_ptr_isempty(*pele));
+
+ if ((offset = c2_parse_op(pattern, offset, pele)) < 0)
+ goto c2_parse_grp_fail;
+
+ if ((offset = c2_parse_pattern(ps, pattern, offset, pele)) < 0)
+ goto c2_parse_grp_fail;
+
+ if (!c2_l_postprocess(ps, pele->l))
+ goto c2_parse_grp_fail;
+ }
+ // Decrement offset -- we will increment it in loop update
+ --offset;
+
+ // Apply negation
+ if (neg) {
+ neg = false;
+ if (pele->isbranch)
+ pele->b->neg = !pele->b->neg;
+ else
+ pele->l->neg = !pele->l->neg;
+ }
+
+ next_expected = false;
+ ++elei;
+ pele = &eles[elei];
+ }
+
+ // Wrong end character?
+ if (pattern[offset] && !endchar)
+ c2_error("Expected end of string but found '%c'.", pattern[offset]);
+ if (!pattern[offset] && endchar)
+ c2_error("Expected '%c' but found end of string.", endchar);
+
+ // Handle end of group
+ if (!elei) {
+ c2_error("Empty group.");
+ }
+ else if (next_expected) {
+ c2_error("Missing rule before end of group.");
+ }
+ else if (elei > 1) {
+ assert(2 == elei);
+ assert(ops[1]);
+ eles[0] = c2h_comb_tree(ops[1], eles[0], eles[1]);
+ c2_ptr_reset(&eles[1]);
+ }
+
+ *presult = eles[0];
+
+ if (')' == pattern[offset])
+ ++offset;
+
+ return offset;
+
+c2_parse_grp_fail:
+ c2_freep(&eles[0]);
+ c2_freep(&eles[1]);
+
+ return -1;
+}
+
+#undef c2_error
+#define c2_error(format, ...) do { \
+ printf_err("Pattern \"%s\" pos %d: " format, pattern, offset, \
+ ## __VA_ARGS__); \
+ return -1; \
+} while(0)
+
+/**
+ * Parse the target part of a rule.
+ */
+static int
+c2_parse_target(session_t *ps, const char *pattern, int offset, c2_ptr_t *presult) {
+ // Initialize leaf
+ presult->isbranch = false;
+ presult->l = malloc(sizeof(c2_l_t));
+ if (!presult->l)
+ c2_error("Failed to allocate memory for new leaf.");
+
+ c2_l_t * const pleaf = presult->l;
+ memcpy(pleaf, &leaf_def, sizeof(c2_l_t));
+
+ // Parse negation marks
+ while ('!' == pattern[offset]) {
+ pleaf->neg = !pleaf->neg;
+ ++offset;
+ C2H_SKIP_SPACES();
+ }
+
+ // Copy target name out
+ unsigned tgtlen = 0;
+ for (; pattern[offset]
+ && (isalnum(pattern[offset]) || '_' == pattern[offset]); ++offset) {
+ ++tgtlen;
+ }
+ if (!tgtlen)
+ c2_error("Empty target.");
+ pleaf->tgt = mstrncpy(&pattern[offset - tgtlen], tgtlen);
+
+ // Check for predefined targets
+ for (unsigned i = 1; i < sizeof(C2_PREDEFS) / sizeof(C2_PREDEFS[0]); ++i) {
+ if (!strcmp(C2_PREDEFS[i].name, pleaf->tgt)) {
+ pleaf->predef = i;
+ pleaf->type = C2_PREDEFS[i].type;
+ pleaf->format = C2_PREDEFS[i].format;
+ break;
+ }
+ }
+
+ // Alias for predefined targets
+ if (!pleaf->predef) {
+#define TGTFILL(pdefid) \
+ (pleaf->predef = pdefid, \
+ pleaf->type = C2_PREDEFS[pdefid].type, \
+ pleaf->format = C2_PREDEFS[pdefid].format)
+
+ // if (!strcmp("WM_NAME", tgt) || !strcmp("_NET_WM_NAME", tgt))
+ // TGTFILL(C2_L_PNAME);
+#undef TGTFILL
+
+ // Alias for custom properties
+#define TGTFILL(target, type, format) \
+ (pleaf->target = mstrcpy(target), \
+ pleaf->type = type, \
+ pleaf->format = format)
+
+ // if (!strcmp("SOME_ALIAS"))
+ // TGTFILL("ALIAS_TEXT", C2_L_TSTRING, 32);
+#undef TGTFILL
+ }
+
+ C2H_SKIP_SPACES();
+
+ // Parse target-on-frame flag
+ if ('@' == pattern[offset]) {
+ pleaf->tgt_onframe = true;
+ ++offset;
+ C2H_SKIP_SPACES();
+ }
+
+ // Parse index
+ if ('[' == pattern[offset]) {
+ offset++;
+
+ C2H_SKIP_SPACES();
+
+ int index = -1;
+ char *endptr = NULL;
+
+ index = strtol(pattern + offset, &endptr, 0);
+
+ if (!endptr || pattern + offset == endptr)
+ c2_error("No index number found after bracket.");
+
+ if (index < 0)
+ c2_error("Index number invalid.");
+
+ if (pleaf->predef)
+ c2_error("Predefined targets can't have index.");
+
+ pleaf->index = index;
+ offset = endptr - pattern;
+
+ C2H_SKIP_SPACES();
+
+ if (']' != pattern[offset])
+ c2_error("Index end marker not found.");
+
+ ++offset;
+
+ C2H_SKIP_SPACES();
+ }
+
+ // Parse target type and format
+ if (':' == pattern[offset]) {
+ ++offset;
+ C2H_SKIP_SPACES();
+
+ // Look for format
+ bool hasformat = false;
+ int format = 0;
+ {
+ char *endptr = NULL;
+ format = strtol(pattern + offset, &endptr, 0);
+ assert(endptr);
+ if ((hasformat = (endptr && endptr != pattern + offset)))
+ offset = endptr - pattern;
+ C2H_SKIP_SPACES();
+ }
+
+ // Look for type
+ enum c2_l_type type = C2_L_TUNDEFINED;
+ {
+ switch (pattern[offset]) {
+ case 'w': type = C2_L_TWINDOW; break;
+ case 'd': type = C2_L_TDRAWABLE; break;
+ case 'c': type = C2_L_TCARDINAL; break;
+ case 's': type = C2_L_TSTRING; break;
+ case 'a': type = C2_L_TATOM; break;
+ default: c2_error("Invalid type character.");
+ }
+
+ if (type) {
+ if (pleaf->predef) {
+ printf_errf("(): Warning: Type specified for a default target will be ignored.");
+ }
+ else {
+ if (pleaf->type && type != pleaf->type)
+ printf_errf("(): Warning: Default type overridden on target.");
+ pleaf->type = type;
+ }
+ }
+
+ offset++;
+ C2H_SKIP_SPACES();
+ }
+
+ // Default format
+ if (!pleaf->format) {
+ switch (pleaf->type) {
+ case C2_L_TWINDOW:
+ case C2_L_TDRAWABLE:
+ case C2_L_TATOM:
+ pleaf->format = 32; break;
+ case C2_L_TSTRING:
+ pleaf->format = 8; break;
+ default:
+ break;
+ }
+ }
+
+ // Write format
+ if (hasformat) {
+ if (pleaf->predef)
+ printf_errf("(): Warning: Format \"%d\" specified on a default target will be ignored.", format);
+ else if (C2_L_TSTRING == pleaf->type)
+ printf_errf("(): Warning: Format \"%d\" specified on a string target will be ignored.", format);
+ else {
+ if (pleaf->format && pleaf->format != format)
+ printf_err("Warning: Default format %d overridden on target.",
+ pleaf->format);
+ pleaf->format = format;
+ }
+ }
+ }
+
+ if (!pleaf->type)
+ c2_error("Target type cannot be determined.");
+
+ // if (!pleaf->predef && !pleaf->format && C2_L_TSTRING != pleaf->type)
+ // c2_error("Target format cannot be determined.");
+
+ if (pleaf->format && 8 != pleaf->format
+ && 16 != pleaf->format && 32 != pleaf->format)
+ c2_error("Invalid format.");
+
+ return offset;
+}
+
+/**
+ * Parse the operator part of a leaf.
+ */
+static int
+c2_parse_op(const char *pattern, int offset, c2_ptr_t *presult) {
+ c2_l_t * const pleaf = presult->l;
+
+ // Parse negation marks
+ C2H_SKIP_SPACES();
+ while ('!' == pattern[offset]) {
+ pleaf->neg = !pleaf->neg;
+ ++offset;
+ C2H_SKIP_SPACES();
+ }
+
+ // Parse qualifiers
+ if ('*' == pattern[offset] || '^' == pattern[offset]
+ || '%' == pattern[offset] || '~' == pattern[offset]) {
+ switch (pattern[offset]) {
+ case '*': pleaf->match = C2_L_MCONTAINS; break;
+ case '^': pleaf->match = C2_L_MSTART; break;
+ case '%': pleaf->match = C2_L_MWILDCARD; break;
+ case '~': pleaf->match = C2_L_MPCRE; break;
+ default: assert(0);
+ }
+ ++offset;
+ C2H_SKIP_SPACES();
+ }
+
+ // Parse flags
+ while ('?' == pattern[offset]) {
+ pleaf->match_ignorecase = true;
+ ++offset;
+ C2H_SKIP_SPACES();
+ }
+
+ // Parse operator
+ while ('=' == pattern[offset] || '>' == pattern[offset]
+ || '<' == pattern[offset]) {
+ if ('=' == pattern[offset] && C2_L_OGT == pleaf->op)
+ pleaf->op = C2_L_OGTEQ;
+ else if ('=' == pattern[offset] && C2_L_OLT == pleaf->op)
+ pleaf->op = C2_L_OLTEQ;
+ else if (pleaf->op) {
+ c2_error("Duplicate operator.");
+ }
+ else {
+ switch (pattern[offset]) {
+ case '=': pleaf->op = C2_L_OEQ; break;
+ case '>': pleaf->op = C2_L_OGT; break;
+ case '<': pleaf->op = C2_L_OLT; break;
+ default: assert(0);
+ }
+ }
+ ++offset;
+ C2H_SKIP_SPACES();
+ }
+
+ // Check for problems
+ if (C2_L_OEQ != pleaf->op && (pleaf->match || pleaf->match_ignorecase))
+ c2_error("Exists/greater-than/less-than operators cannot have a qualifier.");
+
+ return offset;
+}
+
+/**
+ * Parse the pattern part of a leaf.
+ */
+static int
+c2_parse_pattern(session_t *ps, const char *pattern, int offset, c2_ptr_t *presult) {
+ c2_l_t * const pleaf = presult->l;
+
+ // Exists operator cannot have pattern
+ if (!pleaf->op)
+ return offset;
+
+ C2H_SKIP_SPACES();
+
+ char *endptr = NULL;
+ // Check for boolean patterns
+ if (!strcmp_wd("true", &pattern[offset])) {
+ pleaf->ptntype = C2_L_PTINT;
+ pleaf->ptnint = true;
+ offset += strlen("true");
+ }
+ else if (!strcmp_wd("false", &pattern[offset])) {
+ pleaf->ptntype = C2_L_PTINT;
+ pleaf->ptnint = false;
+ offset += strlen("false");
+ }
+ // Check for integer patterns
+ else if (pleaf->ptnint = strtol(pattern + offset, &endptr, 0),
+ pattern + offset != endptr) {
+ pleaf->ptntype = C2_L_PTINT;
+ offset = endptr - pattern;
+ // Make sure we are stopping at the end of a word
+ if (isalnum(pattern[offset]))
+ c2_error("Trailing characters after a numeric pattern.");
+ }
+ // Check for string patterns
+ else {
+ bool raw = false;
+ char delim = '\0';
+
+ // String flags
+ if ('r' == tolower(pattern[offset])) {
+ raw = true;
+ ++offset;
+ C2H_SKIP_SPACES();
+ }
+
+ // Check for delimiters
+ if ('\"' == pattern[offset] || '\'' == pattern[offset]) {
+ pleaf->ptntype = C2_L_PTSTRING;
+ delim = pattern[offset];
+ ++offset;
+ }
+
+ if (C2_L_PTSTRING != pleaf->ptntype)
+ c2_error("Invalid pattern type.");
+
+ // Parse the string now
+ // We can't determine the length of the pattern, so we use the length
+ // to the end of the pattern string -- currently escape sequences
+ // cannot be converted to a string longer than itself.
+ char *tptnstr = malloc((strlen(pattern + offset) + 1) * sizeof(char));
+ char *ptptnstr = tptnstr;
+ pleaf->ptnstr = tptnstr;
+ for (; pattern[offset] && delim != pattern[offset]; ++offset) {
+ // Handle escape sequences if it's not a raw string
+ if ('\\' == pattern[offset] && !raw) {
+ switch(pattern[++offset]) {
+ case '\\': *(ptptnstr++) = '\\'; break;
+ case '\'': *(ptptnstr++) = '\''; break;
+ case '\"': *(ptptnstr++) = '\"'; break;
+ case 'a': *(ptptnstr++) = '\a'; break;
+ case 'b': *(ptptnstr++) = '\b'; break;
+ case 'f': *(ptptnstr++) = '\f'; break;
+ case 'n': *(ptptnstr++) = '\n'; break;
+ case 'r': *(ptptnstr++) = '\r'; break;
+ case 't': *(ptptnstr++) = '\t'; break;
+ case 'v': *(ptptnstr++) = '\v'; break;
+ case 'o':
+ case 'x':
+ {
+ char *tstr = mstrncpy(pattern + offset + 1, 2);
+ char *pstr = NULL;
+ long val = strtol(tstr, &pstr,
+ ('o' == pattern[offset] ? 8: 16));
+ free(tstr);
+ if (pstr != &tstr[2] || val <= 0)
+ c2_error("Invalid octal/hex escape sequence.");
+ assert(val < 256 && val >= 0);
+ *(ptptnstr++) = val;
+ offset += 2;
+ break;
+ }
+ default: c2_error("Invalid escape sequence.");
+ }
+ }
+ else {
+ *(ptptnstr++) = pattern[offset];
+ }
+ }
+ if (!pattern[offset])
+ c2_error("Premature end of pattern string.");
+ ++offset;
+ *ptptnstr = '\0';
+ pleaf->ptnstr = mstrcpy(tptnstr);
+ free(tptnstr);
+ }
+
+ C2H_SKIP_SPACES();
+
+ if (!pleaf->ptntype)
+ c2_error("Invalid pattern type.");
+
+ // Check if the type is correct
+ if (!(((C2_L_TSTRING == pleaf->type
+ || C2_L_TATOM == pleaf->type)
+ && C2_L_PTSTRING == pleaf->ptntype)
+ || ((C2_L_TCARDINAL == pleaf->type
+ || C2_L_TWINDOW == pleaf->type
+ || C2_L_TDRAWABLE == pleaf->type)
+ && C2_L_PTINT == pleaf->ptntype)))
+ c2_error("Pattern type incompatible with target type.");
+
+ if (C2_L_PTINT == pleaf->ptntype && pleaf->match)
+ c2_error("Integer/boolean pattern cannot have operator qualifiers.");
+
+ if (C2_L_PTINT == pleaf->ptntype && pleaf->match_ignorecase)
+ c2_error("Integer/boolean pattern cannot have flags.");
+
+ if (C2_L_PTSTRING == pleaf->ptntype
+ && (C2_L_OGT == pleaf->op || C2_L_OGTEQ == pleaf->op
+ || C2_L_OLT == pleaf->op || C2_L_OLTEQ == pleaf->op))
+ c2_error("String pattern cannot have an arithmetic operator.");
+
+ return offset;
+}
+
+/**
+ * Parse a condition with legacy syntax.
+ */
+static int
+c2_parse_legacy(session_t *ps, const char *pattern, int offset, c2_ptr_t *presult) {
+ unsigned plen = strlen(pattern + offset);
+
+ if (plen < 4 || ':' != pattern[offset + 1]
+ || !strchr(pattern + offset + 2, ':'))
+ c2_error("Legacy parser: Invalid format.");
+
+ // Allocate memory for new leaf
+ c2_l_t *pleaf = malloc(sizeof(c2_l_t));
+ if (!pleaf)
+ printf_errfq(1, "(): Failed to allocate memory for new leaf.");
+ presult->isbranch = false;
+ presult->l = pleaf;
+ memcpy(pleaf, &leaf_def, sizeof(c2_l_t));
+ pleaf->type = C2_L_TSTRING;
+ pleaf->op = C2_L_OEQ;
+ pleaf->ptntype = C2_L_PTSTRING;
+
+ // Determine the pattern target
+#define TGTFILL(pdefid) \
+ (pleaf->predef = pdefid, \
+ pleaf->type = C2_PREDEFS[pdefid].type, \
+ pleaf->format = C2_PREDEFS[pdefid].format)
+ switch (pattern[offset]) {
+ case 'n': TGTFILL(C2_L_PNAME); break;
+ case 'i': TGTFILL(C2_L_PCLASSI); break;
+ case 'g': TGTFILL(C2_L_PCLASSG); break;
+ case 'r': TGTFILL(C2_L_PROLE); break;
+ default: c2_error("Target \"%c\" invalid.\n", pattern[offset]);
+ }
+#undef TGTFILL
+
+ offset += 2;
+
+ // Determine the match type
+ switch (pattern[offset]) {
+ case 'e': pleaf->match = C2_L_MEXACT; break;
+ case 'a': pleaf->match = C2_L_MCONTAINS; break;
+ case 's': pleaf->match = C2_L_MSTART; break;
+ case 'w': pleaf->match = C2_L_MWILDCARD; break;
+ case 'p': pleaf->match = C2_L_MPCRE; break;
+ default: c2_error("Type \"%c\" invalid.\n", pattern[offset]);
+ }
+ ++offset;
+
+ // Determine the pattern flags
+ while (':' != pattern[offset]) {
+ switch (pattern[offset]) {
+ case 'i': pleaf->match_ignorecase = true; break;
+ default: c2_error("Flag \"%c\" invalid.", pattern[offset]);
+ }
+ ++offset;
+ }
+ ++offset;
+
+ // Copy the pattern
+ pleaf->ptnstr = mstrcpy(pattern + offset);
+
+ if (!c2_l_postprocess(ps, pleaf))
+ return -1;
+
+ return offset;
+}
+
+#undef c2_error
+#define c2_error(format, ...) { \
+ printf_err(format, ## __VA_ARGS__); \
+ return false; }
+
+/**
+ * Do postprocessing on a condition leaf.
+ */
+static bool
+c2_l_postprocess(session_t *ps, c2_l_t *pleaf) {
+ // Give a pattern type to a leaf with exists operator, if needed
+ if (C2_L_OEXISTS == pleaf->op && !pleaf->ptntype) {
+ pleaf->ptntype =
+ (C2_L_TSTRING == pleaf->type ? C2_L_PTSTRING: C2_L_PTINT);
+ }
+
+ // Get target atom if it's not a predefined one
+ if (!pleaf->predef) {
+ pleaf->tgtatom = get_atom(ps, pleaf->tgt);
+ if (!pleaf->tgtatom)
+ c2_error("Failed to get atom for target \"%s\".", pleaf->tgt);
+ }
+
+ // Insert target Atom into atom track list
+ if (pleaf->tgtatom) {
+ bool found = false;
+ for (latom_t *platom = ps->track_atom_lst; platom;
+ platom = platom->next) {
+ if (pleaf->tgtatom == platom->atom) {
+ found = true;
+ break;
+ }
+ }
+ if (!found) {
+ latom_t *pnew = malloc(sizeof(latom_t));
+ if (!pnew)
+ printf_errfq(1, "(): Failed to allocate memory for new track atom.");
+ pnew->next = ps->track_atom_lst;
+ pnew->atom = pleaf->tgtatom;
+ ps->track_atom_lst = pnew;
+ }
+ }
+
+ // Enable specific tracking options in compton if needed by the condition
+ // TODO: Add track_leader
+ if (pleaf->predef) {
+ switch (pleaf->predef) {
+ case C2_L_PFOCUSED: ps->o.track_focus = true; break;
+ case C2_L_PNAME:
+ case C2_L_PCLASSG:
+ case C2_L_PCLASSI:
+ case C2_L_PROLE: ps->o.track_wdata = true; break;
+ default: break;
+ }
+ }
+
+ // Warn about lower case characters in target name
+ if (!pleaf->predef) {
+ for (const char *pc = pleaf->tgt; *pc; ++pc) {
+ if (islower(*pc)) {
+ printf_errf("(): Warning: Lowercase character in target name \"%s\".", pleaf->tgt);
+ break;
+ }
+ }
+ }
+
+ // PCRE patterns
+ if (C2_L_PTSTRING == pleaf->ptntype && C2_L_MPCRE == pleaf->match) {
+#ifdef CONFIG_REGEX_PCRE
+ const char *error = NULL;
+ int erroffset = 0;
+ int options = 0;
+
+ // Ignore case flag
+ if (pleaf->match_ignorecase)
+ options |= PCRE_CASELESS;
+
+ // Compile PCRE expression
+ pleaf->regex_pcre = pcre_compile(pleaf->ptnstr, options,
+ &error, &erroffset, NULL);
+ if (!pleaf->regex_pcre)
+ c2_error("Pattern \"%s\": PCRE regular expression parsing failed on "
+ "offset %d: %s", pleaf->ptnstr, erroffset, error);
+#ifdef CONFIG_REGEX_PCRE_JIT
+ pleaf->regex_pcre_extra = pcre_study(pleaf->regex_pcre,
+ PCRE_STUDY_JIT_COMPILE, &error);
+ if (!pleaf->regex_pcre_extra) {
+ printf("Pattern \"%s\": PCRE regular expression study failed: %s",
+ pleaf->ptnstr, error);
+ }
+#endif
+
+ // Free the target string
+ // free(pleaf->tgt);
+ // pleaf->tgt = NULL;
+#else
+ c2_error("PCRE regular expression support not compiled in.");
+#endif
+ }
+
+ return true;
+}
+/**
+ * Free a condition tree.
+ */
+static void
+c2_free(c2_ptr_t p) {
+ // For a branch element
+ if (p.isbranch) {
+ c2_b_t * const pbranch = p.b;
+
+ if (!pbranch)
+ return;
+
+ c2_free(pbranch->opr1);
+ c2_free(pbranch->opr2);
+ free(pbranch);
+ }
+ // For a leaf element
+ else {
+ c2_l_t * const pleaf = p.l;
+
+ if (!pleaf)
+ return;
+
+ free(pleaf->tgt);
+ free(pleaf->ptnstr);
+#ifdef CONFIG_REGEX_PCRE
+ pcre_free(pleaf->regex_pcre);
+ LPCRE_FREE_STUDY(pleaf->regex_pcre_extra);
+#endif
+ free(pleaf);
+ }
+}
+
+/**
+ * Free a condition tree in c2_lptr_t.
+ */
+c2_lptr_t *
+c2_free_lptr(c2_lptr_t *lp) {
+ if (!lp)
+ return NULL;
+
+ c2_lptr_t *pnext = lp->next;
+ c2_free(lp->ptr);
+ free(lp);
+
+ return pnext;
+}
+
+/**
+ * Get a string representation of a rule target.
+ */
+static const char *
+c2h_dump_str_tgt(const c2_l_t *pleaf) {
+ if (pleaf->predef)
+ return C2_PREDEFS[pleaf->predef].name;
+ else
+ return pleaf->tgt;
+}
+
+/**
+ * Get a string representation of a target.
+ */
+static const char *
+c2h_dump_str_type(const c2_l_t *pleaf) {
+ switch (pleaf->type) {
+ case C2_L_TWINDOW: return "w";
+ case C2_L_TDRAWABLE: return "d";
+ case C2_L_TCARDINAL: return "c";
+ case C2_L_TSTRING: return "s";
+ case C2_L_TATOM: return "a";
+ case C2_L_TUNDEFINED: break;
+ }
+
+ return NULL;
+}
+
+/**
+ * Dump a condition tree.
+ */
+static void
+c2_dump_raw(c2_ptr_t p) {
+ // For a branch
+ if (p.isbranch) {
+ const c2_b_t * const pbranch = p.b;
+
+ if (!pbranch)
+ return;
+
+ if (pbranch->neg)
+ putchar('!');
+
+ printf("(");
+ c2_dump_raw(pbranch->opr1);
+
+ switch (pbranch->op) {
+ case C2_B_OAND: printf(" && "); break;
+ case C2_B_OOR: printf(" || "); break;
+ case C2_B_OXOR: printf(" XOR "); break;
+ default: assert(0); break;
+ }
+
+ c2_dump_raw(pbranch->opr2);
+ printf(")");
+ }
+ // For a leaf
+ else {
+ const c2_l_t * const pleaf = p.l;
+
+ if (!pleaf)
+ return;
+
+ if (C2_L_OEXISTS == pleaf->op && pleaf->neg)
+ putchar('!');
+
+ // Print target name, type, and format
+ {
+ printf("%s", c2h_dump_str_tgt(pleaf));
+ if (pleaf->tgt_onframe)
+ putchar('@');
+ if (pleaf->index >= 0)
+ printf("[%d]", pleaf->index);
+ printf(":%d%s", pleaf->format, c2h_dump_str_type(pleaf));
+ }
+
+ // Print operator
+ putchar(' ');
+
+ if (C2_L_OEXISTS != pleaf->op && pleaf->neg)
+ putchar('!');
+
+ switch (pleaf->match) {
+ case C2_L_MEXACT: break;
+ case C2_L_MCONTAINS: putchar('*'); break;
+ case C2_L_MSTART: putchar('^'); break;
+ case C2_L_MPCRE: putchar('~'); break;
+ case C2_L_MWILDCARD: putchar('%'); break;
+ }
+
+ if (pleaf->match_ignorecase)
+ putchar('?');
+
+ switch (pleaf->op) {
+ case C2_L_OEXISTS: break;
+ case C2_L_OEQ: fputs("=", stdout); break;
+ case C2_L_OGT: fputs(">", stdout); break;
+ case C2_L_OGTEQ: fputs(">=", stdout); break;
+ case C2_L_OLT: fputs("<", stdout); break;
+ case C2_L_OLTEQ: fputs("<=", stdout); break;
+ }
+
+ if (C2_L_OEXISTS == pleaf->op)
+ return;
+
+ // Print pattern
+ putchar(' ');
+ switch (pleaf->ptntype) {
+ case C2_L_PTINT:
+ printf("%ld", pleaf->ptnint);
+ break;
+ case C2_L_PTSTRING:
+ // TODO: Escape string before printing out?
+ printf("\"%s\"", pleaf->ptnstr);
+ break;
+ default:
+ assert(0);
+ break;
+ }
+ }
+}
+
+/**
+ * Get the type atom of a condition.
+ */
+static Atom
+c2_get_atom_type(const c2_l_t *pleaf) {
+ switch (pleaf->type) {
+ case C2_L_TCARDINAL:
+ return XA_CARDINAL;
+ case C2_L_TWINDOW:
+ return XA_WINDOW;
+ case C2_L_TSTRING:
+ return XA_STRING;
+ case C2_L_TATOM:
+ return XA_ATOM;
+ case C2_L_TDRAWABLE:
+ return XA_DRAWABLE;
+ default:
+ assert(0);
+ break;
+ }
+
+ assert(0);
+ return AnyPropertyType;
+}
+
+/**
+ * Match a window against a single leaf window condition.
+ *
+ * For internal use.
+ */
+static inline void
+c2_match_once_leaf(session_t *ps, win *w, const c2_l_t *pleaf,
+ bool *pres, bool *perr) {
+ assert(pleaf);
+
+ const Window wid = (pleaf->tgt_onframe ? w->client_win: w->id);
+
+ // Return if wid is missing
+ if (!pleaf->predef && !wid)
+ return;
+
+ const int idx = (pleaf->index < 0 ? 0: pleaf->index);
+
+ switch (pleaf->ptntype) {
+ // Deal with integer patterns
+ case C2_L_PTINT:
+ {
+ long tgt = 0;
+
+ // Get the value
+ // A predefined target
+ if (pleaf->predef) {
+ *perr = false;
+ switch (pleaf->predef) {
+ case C2_L_PID: tgt = wid; break;
+ case C2_L_POVREDIR: tgt = w->a.override_redirect; break;
+ case C2_L_PFOCUSED: tgt = w->focused_real; break;
+ case C2_L_PWMWIN: tgt = w->wmwin; break;
+ case C2_L_PCLIENT: tgt = w->client_win; break;
+ case C2_L_PLEADER: tgt = w->leader; break;
+ default: *perr = true; assert(0); break;
+ }
+ }
+ // A raw window property
+ else {
+ winprop_t prop = wid_get_prop_adv(ps, wid, pleaf->tgtatom,
+ idx, 1L, c2_get_atom_type(pleaf), pleaf->format);
+ if (prop.nitems) {
+ *perr = false;
+ tgt = winprop_get_int(prop);
+ }
+ free_winprop(&prop);
+ }
+
+ if (*perr)
+ return;
+
+ // Do comparison
+ switch (pleaf->op) {
+ case C2_L_OEXISTS:
+ *pres = (pleaf->predef ? tgt: true);
+ break;
+ case C2_L_OEQ: *pres = (tgt == pleaf->ptnint); break;
+ case C2_L_OGT: *pres = (tgt > pleaf->ptnint); break;
+ case C2_L_OGTEQ: *pres = (tgt >= pleaf->ptnint); break;
+ case C2_L_OLT: *pres = (tgt < pleaf->ptnint); break;
+ case C2_L_OLTEQ: *pres = (tgt <= pleaf->ptnint); break;
+ default: *perr = true; assert(0); break;
+ }
+ }
+ break;
+ // String patterns
+ case C2_L_PTSTRING:
+ {
+ const char *tgt = NULL;
+ char *tgt_free = NULL;
+
+ // A predefined target
+ if (pleaf->predef) {
+ switch (pleaf->predef) {
+ case C2_L_PWINDOWTYPE: tgt = WINTYPES[w->window_type];
+ break;
+ case C2_L_PNAME: tgt = w->name; break;
+ case C2_L_PCLASSG: tgt = w->class_general; break;
+ case C2_L_PCLASSI: tgt = w->class_instance; break;
+ case C2_L_PROLE: tgt = w->role; break;
+ default: assert(0); break;
+ }
+ }
+ // If it's an atom type property, convert atom to string
+ else if (C2_L_TATOM == pleaf->type) {
+ winprop_t prop = wid_get_prop_adv(ps, wid, pleaf->tgtatom,
+ idx, 1L, c2_get_atom_type(pleaf), pleaf->format);
+ Atom atom = winprop_get_int(prop);
+ if (atom) {
+ tgt_free = XGetAtomName(ps->dpy, atom);
+ }
+ if (tgt_free) {
+ tgt = tgt_free;
+ }
+ free_winprop(&prop);
+ }
+ // Otherwise, just fetch the string list
+ else {
+ char **strlst = NULL;
+ int nstr;
+ if (wid_get_text_prop(ps, wid, pleaf->tgtatom, &strlst,
+ &nstr) && nstr > idx) {
+ tgt_free = mstrcpy(strlst[idx]);
+ tgt = tgt_free;
+ }
+ if (strlst)
+ XFreeStringList(strlst);
+ }
+
+ if (tgt) {
+ *perr = false;
+ }
+ else {
+ return;
+ }
+
+ // Actual matching
+ switch (pleaf->op) {
+ case C2_L_OEXISTS:
+ *pres = true;
+ break;
+ case C2_L_OEQ:
+ switch (pleaf->match) {
+ case C2_L_MEXACT:
+ if (pleaf->match_ignorecase)
+ *pres = !strcasecmp(tgt, pleaf->ptnstr);
+ else
+ *pres = !strcmp(tgt, pleaf->ptnstr);
+ break;
+ case C2_L_MCONTAINS:
+ if (pleaf->match_ignorecase)
+ *pres = strcasestr(tgt, pleaf->ptnstr);
+ else
+ *pres = strstr(tgt, pleaf->ptnstr);
+ break;
+ case C2_L_MSTART:
+ if (pleaf->match_ignorecase)
+ *pres = !strncasecmp(tgt, pleaf->ptnstr,
+ strlen(pleaf->ptnstr));
+ else
+ *pres = !strncmp(tgt, pleaf->ptnstr,
+ strlen(pleaf->ptnstr));
+ break;
+ case C2_L_MWILDCARD:
+ {
+ int flags = 0;
+ if (pleaf->match_ignorecase)
+ flags |= FNM_CASEFOLD;
+ *pres = !fnmatch(pleaf->ptnstr, tgt, flags);
+ }
+ break;
+ case C2_L_MPCRE:
+#ifdef CONFIG_REGEX_PCRE
+ *pres = (pcre_exec(pleaf->regex_pcre,
+ pleaf->regex_pcre_extra,
+ tgt, strlen(tgt), 0, 0, NULL, 0) >= 0);
+#else
+ assert(0);
+#endif
+ break;
+ }
+ break;
+ default:
+ *perr = true;
+ assert(0);
+ }
+
+ // Free the string after usage, if necessary
+ if (tgt_free) {
+ if (C2_L_TATOM == pleaf->type)
+ XFree(tgt_free);
+ else
+ free(tgt_free);
+ }
+ }
+ break;
+ default:
+ assert(0);
+ break;
+ }
+}
+
+/**
+ * Match a window against a single window condition.
+ *
+ * @return true if matched, false otherwise.
+ */
+static bool
+c2_match_once(session_t *ps, win *w, const c2_ptr_t cond) {
+ bool result = false;
+ bool error = true;
+
+ // Handle a branch
+ if (cond.isbranch) {
+ const c2_b_t *pb = cond.b;
+
+ if (!pb)
+ return false;
+
+ error = false;
+
+ switch (pb->op) {
+ case C2_B_OAND:
+ result = (c2_match_once(ps, w, pb->opr1)
+ && c2_match_once(ps, w, pb->opr2));
+ break;
+ case C2_B_OOR:
+ result = (c2_match_once(ps, w, pb->opr1)
+ || c2_match_once(ps, w, pb->opr2));
+ break;
+ case C2_B_OXOR:
+ result = (c2_match_once(ps, w, pb->opr1)
+ != c2_match_once(ps, w, pb->opr2));
+ break;
+ default:
+ error = true;
+ assert(0);
+ }
+
+#ifdef DEBUG_WINMATCH
+ printf_dbgf("(%#010lx): branch: result = %d, pattern = ", w->id, result);
+ c2_dump(cond);
+#endif
+ }
+ // Handle a leaf
+ else {
+ const c2_l_t *pleaf = cond.l;
+
+ if (!pleaf)
+ return false;
+
+ c2_match_once_leaf(ps, w, pleaf, &result, &error);
+
+ // For EXISTS operator, no errors are fatal
+ if (C2_L_OEXISTS == pleaf->op && error) {
+ result = false;
+ error = false;
+ }
+
+#ifdef DEBUG_WINMATCH
+ printf_dbgf("(%#010lx): leaf: result = %d, error = %d, "
+ "client = %#010lx, pattern = ",
+ w->id, result, error, w->client_win);
+ c2_dump(cond);
+#endif
+ }
+
+ // Postprocess the result
+ if (error)
+ result = false;
+
+ if (cond.isbranch ? cond.b->neg: cond.l->neg)
+ result = !result;
+
+ return result;
+}
+
+/**
+ * Match a window against a condition linked list.
+ *
+ * @param cache a place to cache the last matched condition
+ * @return true if matched, false otherwise.
+ */
+bool
+c2_match(session_t *ps, win *w, const c2_lptr_t *condlst,
+ const c2_lptr_t **cache) {
+ // Check if the cached entry matches firstly
+ if (cache && *cache && c2_match_once(ps, w, (*cache)->ptr))
+ return true;
+
+ // Then go through the whole linked list
+ for (; condlst; condlst = condlst->next) {
+ if (c2_match_once(ps, w, condlst->ptr)) {
+ if (cache)
+ *cache = condlst;
+ return true;
+ }
+ }
+
+ return false;
+}
+
diff --git a/c2.h b/c2.h
new file mode 100644
index 000000000..000c68448
--- /dev/null
+++ b/c2.h
@@ -0,0 +1,326 @@
+/*
+ * Compton - a compositor for X11
+ *
+ * Based on `xcompmgr` - Copyright (c) 2003, Keith Packard
+ *
+ * Copyright (c) 2011-2013, Christopher Jeffrey
+ * See LICENSE for more information.
+ *
+ */
+
+#include "common.h"
+
+#include <fnmatch.h>
+#include <ctype.h>
+
+// libpcre
+#ifdef CONFIG_REGEX_PCRE
+#include <pcre.h>
+
+// For compatiblity with <libpcre-8.20
+#ifndef PCRE_STUDY_JIT_COMPILE
+#define PCRE_STUDY_JIT_COMPILE 0
+#define LPCRE_FREE_STUDY(extra) pcre_free(extra)
+#else
+#define LPCRE_FREE_STUDY(extra) pcre_free_study(extra)
+#endif
+
+#endif
+
+#define C2_MAX_LEVELS 10
+
+typedef struct _c2_b c2_b_t;
+typedef struct _c2_l c2_l_t;
+
+/// Pointer to a condition tree.
+typedef struct {
+ bool isbranch : 1;
+ union {
+ c2_b_t *b;
+ c2_l_t *l;
+ };
+} c2_ptr_t;
+
+/// Initializer for c2_ptr_t.
+#define C2_PTR_INIT { \
+ .isbranch = false, \
+ .l = NULL, \
+}
+
+const static c2_ptr_t C2_PTR_NULL = C2_PTR_INIT;
+
+/// Operator of a branch element.
+typedef enum {
+ C2_B_OUNDEFINED,
+ C2_B_OAND,
+ C2_B_OOR,
+ C2_B_OXOR,
+} c2_b_op_t;
+
+/// Structure for branch element in a window condition
+struct _c2_b {
+ bool neg : 1;
+ c2_b_op_t op;
+ c2_ptr_t opr1;
+ c2_ptr_t opr2;
+};
+
+/// Initializer for c2_b_t.
+#define C2_B_INIT { \
+ .neg = false, \
+ .op = C2_B_OUNDEFINED, \
+ .opr1 = C2_PTR_INIT, \
+ .opr2 = C2_PTR_INIT, \
+}
+
+/// Structure for leaf element in a window condition
+struct _c2_l {
+ bool neg : 1;
+ enum {
+ C2_L_OEXISTS,
+ C2_L_OEQ,
+ C2_L_OGT,
+ C2_L_OGTEQ,
+ C2_L_OLT,
+ C2_L_OLTEQ,
+ } op : 3;
+ enum {
+ C2_L_MEXACT,
+ C2_L_MSTART,
+ C2_L_MCONTAINS,
+ C2_L_MWILDCARD,
+ C2_L_MPCRE,
+ } match : 3;
+ bool match_ignorecase : 1;
+ char *tgt;
+ Atom tgtatom;
+ bool tgt_onframe;
+ int index;
+ enum {
+ C2_L_PUNDEFINED,
+ C2_L_PID,
+ C2_L_POVREDIR,
+ C2_L_PFOCUSED,
+ C2_L_PWMWIN,
+ C2_L_PCLIENT,
+ C2_L_PWINDOWTYPE,
+ C2_L_PLEADER,
+ C2_L_PNAME,
+ C2_L_PCLASSG,
+ C2_L_PCLASSI,
+ C2_L_PROLE,
+ } predef;
+ enum c2_l_type {
+ C2_L_TUNDEFINED,
+ C2_L_TSTRING,
+ C2_L_TCARDINAL,
+ C2_L_TWINDOW,
+ C2_L_TATOM,
+ C2_L_TDRAWABLE,
+ } type;
+ int format;
+ enum {
+ C2_L_PTUNDEFINED,
+ C2_L_PTSTRING,
+ C2_L_PTINT,
+ } ptntype;
+ char *ptnstr;
+ long ptnint;
+#ifdef CONFIG_REGEX_PCRE
+ pcre *regex_pcre;
+ pcre_extra *regex_pcre_extra;
+#endif
+};
+
+/// Initializer for c2_l_t.
+#define C2_L_INIT { \
+ .neg = false, \
+ .op = C2_L_OEXISTS, \
+ .match = C2_L_MEXACT, \
+ .match_ignorecase = false, \
+ .tgt = NULL, \
+ .tgtatom = 0, \
+ .tgt_onframe = false, \
+ .predef = C2_L_PUNDEFINED, \
+ .index = -1, \
+ .type = C2_L_TUNDEFINED, \
+ .format = 0, \
+ .ptntype = C2_L_PTUNDEFINED, \
+ .ptnstr = NULL, \
+ .ptnint = 0, \
+}
+
+const static c2_l_t leaf_def = C2_L_INIT;
+
+/// Linked list type of conditions.
+struct _c2_lptr {
+ c2_ptr_t ptr;
+ struct _c2_lptr *next;
+};
+
+/// Initializer for c2_lptr_t.
+#define C2_LPTR_INIT { \
+ .ptr = C2_PTR_INIT, \
+ .next = NULL, \
+}
+
+/// Structure representing a predefined target.
+typedef struct {
+ const char *name;
+ enum c2_l_type type;
+ int format;
+} c2_predef_t;
+
+// Predefined targets.
+const static c2_predef_t C2_PREDEFS[] = {
+ [C2_L_PID ] = { "id" , C2_L_TCARDINAL , 0 },
+ [C2_L_POVREDIR ] = { "override_redirect" , C2_L_TCARDINAL , 0 },
+ [C2_L_PFOCUSED ] = { "focused" , C2_L_TCARDINAL , 0 },
+ [C2_L_PWMWIN ] = { "wmwin" , C2_L_TCARDINAL , 0 },
+ [C2_L_PCLIENT ] = { "client" , C2_L_TWINDOW , 0 },
+ [C2_L_PWINDOWTYPE ] = { "window_type" , C2_L_TSTRING , 0 },
+ [C2_L_PLEADER ] = { "leader" , C2_L_TWINDOW , 0 },
+ [C2_L_PNAME ] = { "name" , C2_L_TSTRING , 0 },
+ [C2_L_PCLASSG ] = { "class_g" , C2_L_TSTRING , 0 },
+ [C2_L_PCLASSI ] = { "class_i" , C2_L_TSTRING , 0 },
+ [C2_L_PROLE ] = { "role" , C2_L_TSTRING , 0 },
+};
+
+#define mstrncmp(s1, s2) strncmp((s1), (s2), strlen(s1))
+
+/**
+ * Compare next word in a string with another string.
+ */
+static inline int
+strcmp_wd(const char *needle, const char *src) {
+ int ret = mstrncmp(needle, src);
+ if (ret)
+ return ret;
+
+ char c = src[strlen(needle)];
+ if (isalnum(c) || '_' == c)
+ return 1;
+ else
+ return 0;
+}
+
+/**
+ * Return whether a c2_ptr_t is empty.
+ */
+static inline bool
+c2_ptr_isempty(const c2_ptr_t p) {
+ return !(p.isbranch ? (bool) p.b: (bool) p.l);
+}
+
+/**
+ * Reset a c2_ptr_t.
+ */
+static inline void
+c2_ptr_reset(c2_ptr_t *pp) {
+ if (pp)
+ memcpy(pp, &C2_PTR_NULL, sizeof(c2_ptr_t));
+}
+
+/**
+ * Combine two condition trees.
+ */
+static inline c2_ptr_t
+c2h_comb_tree(c2_b_op_t op, c2_ptr_t p1, c2_ptr_t p2) {
+ c2_ptr_t p = {
+ .isbranch = true,
+ .b = malloc(sizeof(c2_b_t))
+ };
+
+ p.b->opr1 = p1;
+ p.b->opr2 = p2;
+ p.b->op = op;
+
+ return p;
+}
+
+/**
+ * Get the precedence value of a condition branch operator.
+ */
+static inline int
+c2h_b_opp(c2_b_op_t op) {
+ switch (op) {
+ case C2_B_OAND: return 2;
+ case C2_B_OOR: return 1;
+ case C2_B_OXOR: return 1;
+ default: break;
+ }
+
+ assert(0);
+ return 0;
+}
+
+/**
+ * Compare precedence of two condition branch operators.
+ *
+ * Associativity is left-to-right, forever.
+ *
+ * @return positive number if op1 > op2, 0 if op1 == op2 in precedence,
+ * negative number otherwise
+ */
+static inline int
+c2h_b_opcmp(c2_b_op_t op1, c2_b_op_t op2) {
+ return c2h_b_opp(op1) - c2h_b_opp(op2);
+}
+
+static int
+c2_parse_grp(session_t *ps, const char *pattern, int offset, c2_ptr_t *presult, int level);
+
+static int
+c2_parse_target(session_t *ps, const char *pattern, int offset, c2_ptr_t *presult);
+
+static int
+c2_parse_op(const char *pattern, int offset, c2_ptr_t *presult);
+
+static int
+c2_parse_pattern(session_t *ps, const char *pattern, int offset, c2_ptr_t *presult);
+
+static int
+c2_parse_legacy(session_t *ps, const char *pattern, int offset, c2_ptr_t *presult);
+
+static bool
+c2_l_postprocess(session_t *ps, c2_l_t *pleaf);
+
+static void
+c2_free(c2_ptr_t p);
+
+/**
+ * Wrapper of c2_free().
+ */
+static inline void
+c2_freep(c2_ptr_t *pp) {
+ if (pp) {
+ c2_free(*pp);
+ c2_ptr_reset(pp);
+ }
+}
+
+static const char *
+c2h_dump_str_tgt(const c2_l_t *pleaf);
+
+static const char *
+c2h_dump_str_type(const c2_l_t *pleaf);
+
+static void
+c2_dump_raw(c2_ptr_t p);
+
+/**
+ * Wrapper of c2_dump_raw().
+ */
+static inline void
+c2_dump(c2_ptr_t p) {
+ c2_dump_raw(p);
+ printf("\n");
+ fflush(stdout);
+}
+
+static Atom
+c2_get_atom_type(const c2_l_t *pleaf);
+
+static bool
+c2_match_once(session_t *ps, win *w, const c2_ptr_t cond);
+
diff --git a/common.h b/common.h
index 004d9553b..bc057aa8d 100644
--- a/common.h
+++ b/common.h
@@ -76,20 +76,6 @@
#include <X11/extensions/Xrandr.h>
#include <X11/extensions/Xdbe.h>
-// libpcre
-#ifdef CONFIG_REGEX_PCRE
-#include <pcre.h>
-
-// For compatiblity with <libpcre-8.20
-#ifndef PCRE_STUDY_JIT_COMPILE
-#define PCRE_STUDY_JIT_COMPILE 0
-#define LPCRE_FREE_STUDY(extra) pcre_free(extra)
-#else
-#define LPCRE_FREE_STUDY(extra) pcre_free_study(extra)
-#endif
-
-#endif
-
// libconfig
#ifdef CONFIG_LIBCONFIG
#include <libgen.h>
@@ -257,18 +243,6 @@ enum wincond_type {
#define CONDF_IGNORECASE 0x0001
-typedef struct _wincond {
- enum wincond_target target;
- enum wincond_type type;
- char *pattern;
-#ifdef CONFIG_REGEX_PCRE
- pcre *regex_pcre;
- pcre_extra *regex_pcre_extra;
-#endif
- int16_t flags;
- struct _wincond *next;
-} wincond_t;
-
/// VSync modes.
typedef enum {
VSYNC_NONE,
@@ -297,13 +271,13 @@ struct _timeout_t;
struct _win;
-#ifdef CONFIG_C2
typedef struct _c2_lptr c2_lptr_t;
-#endif
/// Structure representing all options.
typedef struct {
// === General ===
+ /// The configuration file we used.
+ char *config_file;
/// The display name we used. NULL means we are using the value of the
/// <code>DISPLAY</code> environment variable.
char *display;
@@ -350,7 +324,7 @@ typedef struct {
double shadow_opacity;
bool clear_shadow;
/// Shadow blacklist. A linked list of conditions.
- wincond_t *shadow_blacklist;
+ c2_lptr_t *shadow_blacklist;
/// Whether bounding-shaped window should be ignored.
bool shadow_ignore_shaped;
/// Whether to respect _COMPTON_SHADOW.
@@ -368,7 +342,7 @@ typedef struct {
/// Whether to disable fading on window open/close.
bool no_fading_openclose;
/// Fading blacklist. A linked list of conditions.
- wincond_t *fade_blacklist;
+ c2_lptr_t *fade_blacklist;
// === Opacity ===
/// Default opacity for specific window types
@@ -404,7 +378,7 @@ typedef struct {
/// based on window opacity.
bool inactive_dim_fixed;
/// Conditions of windows to have inverted colors.
- wincond_t *invert_color_list;
+ c2_lptr_t *invert_color_list;
// === Focus related ===
/// Consider windows of specific types to be always focused.
@@ -412,7 +386,7 @@ typedef struct {
/// Whether to use EWMH _NET_ACTIVE_WINDOW to find active window.
bool use_ewmh_active_win;
/// A list of windows always to be considered focused.
- wincond_t *focus_blacklist;
+ c2_lptr_t *focus_blacklist;
/// Whether to do window grouping with <code>WM_TRANSIENT_FOR</code>.
bool detect_transient;
/// Whether to do window grouping with <code>WM_CLIENT_LEADER</code>.
@@ -736,10 +710,10 @@ typedef struct _win {
char *class_general;
/// <code>WM_WINDOW_ROLE</code> value of the window.
char *role;
- wincond_t *cache_sblst;
- wincond_t *cache_fblst;
- wincond_t *cache_fcblst;
- wincond_t *cache_ivclst;
+ const c2_lptr_t *cache_sblst;
+ const c2_lptr_t *cache_fblst;
+ const c2_lptr_t *cache_fcblst;
+ const c2_lptr_t *cache_ivclst;
// Opacity-related members
/// Current window opacity.
@@ -1056,10 +1030,13 @@ print_timestamp(session_t *ps) {
/**
* Allocate the space and copy a string.
*/
-static inline char * __attribute__((const))
+static inline char *
mstrcpy(const char *src) {
char *str = malloc(sizeof(char) * (strlen(src) + 1));
+ if (!str)
+ printf_errfq(1, "(): Failed to allocate memory.");
+
strcpy(str, src);
return str;
@@ -1068,10 +1045,13 @@ mstrcpy(const char *src) {
/**
* Allocate the space and copy a string.
*/
-static inline char * __attribute__((const))
+static inline char *
mstrncpy(const char *src, unsigned len) {
char *str = malloc(sizeof(char) * (len + 1));
+ if (!str)
+ printf_errfq(1, "(): Failed to allocate memory.");
+
strncpy(str, src, len);
str[len] = '\0';
@@ -1479,7 +1459,7 @@ win_set_invert_color_force(session_t *ps, win *w, switch_t val);
///@{
c2_lptr_t *
-c2_parse(session_t *ps, c2_lptr_t **pcondlst, char *pattern);
+c2_parse(session_t *ps, c2_lptr_t **pcondlst, const char *pattern);
c2_lptr_t *
c2_free_lptr(c2_lptr_t *lp);
diff --git a/compton.c b/compton.c
index 814bf4a3b..cbb5e7b61 100644
--- a/compton.c
+++ b/compton.c
@@ -567,7 +567,7 @@ wid_get_prop_adv(const session_t *ps, Window w, Atom atom, long offset,
if (Success == XGetWindowProperty(ps->dpy, w, atom, offset, length,
False, rtype, &type, &format, &nitems, &after, &data)
&& nitems && (AnyPropertyType == type || type == rtype)
- && (!format || format == rformat)
+ && (!rformat || format == rformat)
&& (8 == format || 16 == format || 32 == format)) {
return (winprop_t) {
.data.p8 = data,
@@ -630,243 +630,19 @@ win_rounded_corners(session_t *ps, win *w) {
}
/**
- * Match a window against a single window condition.
- *
- * @return true if matched, false otherwise.
- */
-static bool
-win_match_once(win *w, const wincond_t *cond) {
- const char *target;
- bool matched = false;
-
-#ifdef DEBUG_WINMATCH
- printf("win_match_once(%#010lx \"%s\"): cond = %p", w->id, w->name,
- cond);
-#endif
-
- if (InputOnly == w->a.class) {
-#ifdef DEBUG_WINMATCH
- printf(": InputOnly\n");
-#endif
- return false;
- }
-
- // Determine the target
- target = NULL;
- switch (cond->target) {
- case CONDTGT_NAME:
- target = w->name;
- break;
- case CONDTGT_CLASSI:
- target = w->class_instance;
- break;
- case CONDTGT_CLASSG:
- target = w->class_general;
- break;
- case CONDTGT_ROLE:
- target = w->role;
- break;
- }
-
- if (!target) {
-#ifdef DEBUG_WINMATCH
- printf(": Target not found\n");
-#endif
- return false;
- }
-
- // Determine pattern type and match
- switch (cond->type) {
- case CONDTP_EXACT:
- if (cond->flags & CONDF_IGNORECASE)
- matched = !strcasecmp(target, cond->pattern);
- else
- matched = !strcmp(target, cond->pattern);
- break;
- case CONDTP_ANYWHERE:
- if (cond->flags & CONDF_IGNORECASE)
- matched = strcasestr(target, cond->pattern);
- else
- matched = strstr(target, cond->pattern);
- break;
- case CONDTP_FROMSTART:
- if (cond->flags & CONDF_IGNORECASE)
- matched = !strncasecmp(target, cond->pattern,
- strlen(cond->pattern));
- else
- matched = !strncmp(target, cond->pattern,
- strlen(cond->pattern));
- break;
- case CONDTP_WILDCARD:
- {
- int flags = 0;
- if (cond->flags & CONDF_IGNORECASE)
- flags = FNM_CASEFOLD;
- matched = !fnmatch(cond->pattern, target, flags);
- }
- break;
- case CONDTP_REGEX_PCRE:
-#ifdef CONFIG_REGEX_PCRE
- matched = (pcre_exec(cond->regex_pcre, cond->regex_pcre_extra,
- target, strlen(target), 0, 0, NULL, 0) >= 0);
-#endif
- break;
- }
-
-#ifdef DEBUG_WINMATCH
- printf(", matched = %d\n", matched);
-#endif
-
- return matched;
-}
-
-/**
- * Match a window against a condition linked list.
- *
- * @param cache a place to cache the last matched condition
- * @return true if matched, false otherwise.
- */
-static bool
-win_match(win *w, wincond_t *condlst, wincond_t **cache) {
- // Check if the cached entry matches firstly
- if (cache && *cache && win_match_once(w, *cache))
- return true;
-
- // Then go through the whole linked list
- for (; condlst; condlst = condlst->next) {
- if (win_match_once(w, condlst)) {
- if (cache)
- *cache = condlst;
- return true;
- }
- }
-
- return false;
-}
-
-/**
* Add a pattern to a condition linked list.
*/
static bool
-condlst_add(wincond_t **pcondlst, const char *pattern) {
+condlst_add(session_t *ps, c2_lptr_t **pcondlst, const char *pattern) {
if (!pattern)
return false;
- unsigned plen = strlen(pattern);
- wincond_t *cond;
- const char *pos;
-
- if (plen < 4 || ':' != pattern[1] || !strchr(pattern + 2, ':')) {
- printf("Pattern \"%s\": Format invalid.\n", pattern);
- return false;
- }
-
- // Allocate memory for the new condition
- cond = malloc(sizeof(wincond_t));
-
- // Determine the pattern target
- switch (pattern[0]) {
- case 'n':
- cond->target = CONDTGT_NAME;
- break;
- case 'i':
- cond->target = CONDTGT_CLASSI;
- break;
- case 'g':
- cond->target = CONDTGT_CLASSG;
- break;
- case 'r':
- cond->target = CONDTGT_ROLE;
- break;
- default:
- printf("Pattern \"%s\": Target \"%c\" invalid.\n",
- pattern, pattern[0]);
- free(cond);
- return false;
- }
-
- // Determine the pattern type
- switch (pattern[2]) {
- case 'e':
- cond->type = CONDTP_EXACT;
- break;
- case 'a':
- cond->type = CONDTP_ANYWHERE;
- break;
- case 's':
- cond->type = CONDTP_FROMSTART;
- break;
- case 'w':
- cond->type = CONDTP_WILDCARD;
- break;
-#ifdef CONFIG_REGEX_PCRE
- case 'p':
- cond->type = CONDTP_REGEX_PCRE;
- break;
-#endif
- default:
- printf("Pattern \"%s\": Type \"%c\" invalid.\n",
- pattern, pattern[2]);
- free(cond);
- return false;
- }
-
- // Determine the pattern flags
- pos = &pattern[3];
- cond->flags = 0;
- while (':' != *pos) {
- switch (*pos) {
- case 'i':
- cond->flags |= CONDF_IGNORECASE;
- break;
- default:
- printf("Pattern \"%s\": Flag \"%c\" invalid.\n",
- pattern, *pos);
- break;
- }
- ++pos;
- }
-
- // Copy the pattern
- ++pos;
- cond->pattern = NULL;
-#ifdef CONFIG_REGEX_PCRE
- cond->regex_pcre = NULL;
- cond->regex_pcre_extra = NULL;
-#endif
- if (CONDTP_REGEX_PCRE == cond->type) {
-#ifdef CONFIG_REGEX_PCRE
- const char *error = NULL;
- int erroffset = 0;
- int options = 0;
-
- if (cond->flags & CONDF_IGNORECASE)
- options |= PCRE_CASELESS;
-
- cond->regex_pcre = pcre_compile(pos, options, &error, &erroffset,
- NULL);
- if (!cond->regex_pcre) {
- printf("Pattern \"%s\": PCRE regular expression parsing failed on "
- "offset %d: %s\n", pattern, erroffset, error);
- free(cond);
- return false;
- }
-#ifdef CONFIG_REGEX_PCRE_JIT
- cond->regex_pcre_extra = pcre_study(cond->regex_pcre, PCRE_STUDY_JIT_COMPILE, &error);
- if (!cond->regex_pcre_extra) {
- printf("Pattern \"%s\": PCRE regular expression study failed: %s",
- pattern, error);
- }
-#endif
+#ifdef CONFIG_C2
+ if (!c2_parse(ps, pcondlst, pattern))
+ exit(1);
+#else
+ printf_errfq(1, "(): Condition support not compiled in.");
#endif
- }
- else {
- cond->pattern = mstrcpy(pos);
- }
-
- // Insert it into the linked list
- cond->next = *pcondlst;
- *pcondlst = cond;
return true;
}
@@ -2313,7 +2089,7 @@ win_determine_shadow(session_t *ps, win *w) {
w->shadow = (UNSET == w->shadow_force ?
(ps->o.wintype_shadow[w->window_type]
- && !win_match(w, ps->o.shadow_blacklist, &w->cache_sblst)
+ && !win_match(ps, w, ps->o.shadow_blacklist, &w->cache_sblst)
&& !(ps->o.shadow_ignore_shaped && w->bounding_shaped
&& !w->rounded_corners)
&& !(ps->o.respect_prop_shadow && 0 == w->prop_shadow))
@@ -2347,7 +2123,7 @@ win_determine_invert_color(session_t *ps, win *w) {
if (UNSET != w->invert_color_force)
w->invert_color = w->invert_color_force;
else
- w->invert_color = win_match(w, ps->o.invert_color_list, &w->cache_ivclst);
+ w->invert_color = win_match(ps, w, ps->o.invert_color_list, &w->cache_ivclst);
if (w->invert_color != invert_color_old)
add_damage_win(ps, w);
@@ -2361,13 +2137,15 @@ win_on_wtype_change(session_t *ps, win *w) {
win_determine_shadow(ps, w);
win_determine_fade(ps, w);
win_update_focused(ps, w);
+ if (ps->o.invert_color_list)
+ win_determine_invert_color(ps, w);
}
/**
* Function to be called on window data changes.
*/
static void
-win_on_wdata_change(session_t *ps, win *w) {
+win_on_factor_change(session_t *ps, win *w) {
if (ps->o.shadow_blacklist)
win_determine_shadow(ps, w);
if (ps->o.fade_blacklist)
@@ -2481,9 +2259,11 @@ win_mark_client(session_t *ps, win *w, Window client) {
win_get_name(ps, w);
win_get_class(ps, w);
win_get_role(ps, w);
- win_on_wdata_change(ps, w);
}
+ // Update everything related to conditions
+ win_on_factor_change(ps, w);
+
// Update window focus state
win_update_focused(ps, w);
}
@@ -3048,7 +2828,7 @@ win_update_focused(session_t *ps, win *w) {
|| (ps->o.mark_wmwin_focused && w->wmwin)
|| (ps->o.mark_ovredir_focused
&& w->id == w->client_win && !w->wmwin)
- || win_match(w, ps->o.focus_blacklist, &w->cache_fcblst))
+ || win_match(ps, w, ps->o.focus_blacklist, &w->cache_fcblst))
w->focused = true;
// If window grouping detection is enabled, mark the window active if
@@ -3102,6 +2882,9 @@ win_set_focused(session_t *ps, win *w, bool focused) {
else {
win_update_focused(ps, w);
}
+
+ // Update everything related to conditions
+ win_on_factor_change(ps, w);
}
}
/**
@@ -3153,6 +2936,9 @@ win_set_leader(session_t *ps, win *w, Window nleader) {
else {
win_update_focused(ps, w);
}
+
+ // Update everything related to conditions
+ win_on_factor_change(ps, w);
}
}
@@ -3746,7 +3532,7 @@ ev_property_notify(session_t *ps, XPropertyEvent *ev) {
&& (ps->atom_name == ev->atom || ps->atom_name_ewmh == ev->atom)) {
win *w = find_toplevel(ps, ev->window);
if (w && 1 == win_get_name(ps, w)) {
- win_on_wdata_change(ps, w);
+ win_on_factor_change(ps, w);
}
}
@@ -3755,7 +3541,7 @@ ev_property_notify(session_t *ps, XPropertyEvent *ev) {
win *w = find_toplevel(ps, ev->window);
if (w) {
win_get_class(ps, w);
- win_on_wdata_change(ps, w);
+ win_on_factor_change(ps, w);
}
}
@@ -3763,7 +3549,7 @@ ev_property_notify(session_t *ps, XPropertyEvent *ev) {
if (ps->o.track_wdata && ps->atom_role == ev->atom) {
win *w = find_toplevel(ps, ev->window);
if (w && 1 == win_get_role(ps, w)) {
- win_on_wdata_change(ps, w);
+ win_on_factor_change(ps, w);
}
}
@@ -3790,7 +3576,7 @@ ev_property_notify(session_t *ps, XPropertyEvent *ev) {
if (!w)
w = find_toplevel(ps, ev->window);
if (w)
- win_on_wdata_change(ps, w);
+ win_on_factor_change(ps, w);
break;
}
}
@@ -4095,24 +3881,7 @@ usage(void) {
" inverted color. Resource-hogging, and is not well tested.\n"
"--dbus\n"
" Enable remote control via D-Bus. See the D-BUS API section in the\n"
- " man page for more details.\n"
- "\n"
- "Format of a condition:\n"
- "\n"
- " condition = <target>:<type>[<flags>]:<pattern>\n"
- "\n"
- " <target> is one of \"n\" (window name), \"i\" (window class\n"
- " instance), \"g\" (window general class), and \"r\"\n"
- " (window role).\n"
- "\n"
- " <type> is one of \"e\" (exact match), \"a\" (match anywhere),\n"
- " \"s\" (match from start), \"w\" (wildcard), and \"p\" (PCRE\n"
- " regular expressions, if compiled with the support).\n"
- "\n"
- " <flags> could be a series of flags. Currently the only defined\n"
- " flag is \"i\" (ignore case).\n"
- "\n"
- " <pattern> is the actual pattern string.\n";
+ " man page for more details.\n";
fputs(usage_text , stderr);
exit(1);
@@ -4270,8 +4039,6 @@ open_config_file(char *cpath, char **ppath) {
f = fopen(path, "r");
if (f && ppath)
*ppath = path;
- else
- free(path);
return f;
}
@@ -4356,7 +4123,7 @@ parse_vsync(session_t *ps, const char *optarg) {
* Parse a condition list in configuration file.
*/
static void
-parse_cfg_condlst(const config_t *pcfg, wincond_t **pcondlst,
+parse_cfg_condlst(session_t *ps, const config_t *pcfg, c2_lptr_t **pcondlst,
const char *name) {
config_setting_t *setting = config_lookup(pcfg, name);
if (setting) {
@@ -4364,12 +4131,12 @@ parse_cfg_condlst(const config_t *pcfg, wincond_t **pcondlst,
if (config_setting_is_array(setting)) {
int i = config_setting_length(setting);
while (i--) {
- condlst_add(pcondlst, config_setting_get_string_elem(setting, i));
+ condlst_add(ps, pcondlst, config_setting_get_string_elem(setting, i));
}
}
// Treat it as a single pattern if it's a string
else if (CONFIG_TYPE_STRING == config_setting_type(setting)) {
- condlst_add(pcondlst, config_setting_get_string(setting));
+ condlst_add(ps, pcondlst, config_setting_get_string(setting));
}
}
}
@@ -4378,7 +4145,7 @@ parse_cfg_condlst(const config_t *pcfg, wincond_t **pcondlst,
* Parse a configuration file from default location.
*/
static void
-parse_config(session_t *ps, char *cpath, struct options_tmp *pcfgtmp) {
+parse_config(session_t *ps, struct options_tmp *pcfgtmp) {
char *path = NULL;
FILE *f;
config_t cfg;
@@ -4386,10 +4153,14 @@ parse_config(session_t *ps, char *cpath, struct options_tmp *pcfgtmp) {
double dval = 0.0;
const char *sval = NULL;
- f = open_config_file(cpath, &path);
+ f = open_config_file(ps->o.config_file, &path);
if (!f) {
- if (cpath)
- printf_errfq(1, "(): Failed to read the specified configuration file.");
+ if (ps->o.config_file) {
+ printf_errfq(1, "(): Failed to read configuration file \"%s\".",
+ ps->o.config_file);
+ free(ps->o.config_file);
+ ps->o.config_file = NULL;
+ }
return;
}
@@ -4417,7 +4188,10 @@ parse_config(session_t *ps, char *cpath, struct options_tmp *pcfgtmp) {
}
config_set_auto_convert(&cfg, 1);
- free(path);
+ if (path != ps->o.config_file) {
+ free(ps->o.config_file);
+ ps->o.config_file = path;
+ }
// Get options from the configuration file. We don't do range checking
// right now. It will be done later
@@ -4512,11 +4286,11 @@ parse_config(session_t *ps, char *cpath, struct options_tmp *pcfgtmp) {
lcfg_lookup_bool(&cfg, "detect-client-leader",
&ps->o.detect_client_leader);
// --shadow-exclude
- parse_cfg_condlst(&cfg, &ps->o.shadow_blacklist, "shadow-exclude");
+ parse_cfg_condlst(ps, &cfg, &ps->o.shadow_blacklist, "shadow-exclude");
// --focus-exclude
- parse_cfg_condlst(&cfg, &ps->o.focus_blacklist, "focus-exclude");
+ parse_cfg_condlst(ps, &cfg, &ps->o.focus_blacklist, "focus-exclude");
// --invert-color-include
- parse_cfg_condlst(&cfg, &ps->o.invert_color_list, "invert-color-include");
+ parse_cfg_condlst(ps, &cfg, &ps->o.invert_color_list, "invert-color-include");
// --blur-background
lcfg_lookup_bool(&cfg, "blur-background", &ps->o.blur_background);
// --blur-background-frame
@@ -4554,7 +4328,7 @@ parse_config(session_t *ps, char *cpath, struct options_tmp *pcfgtmp) {
* Process arguments and configuration files.
*/
static void
-get_cfg(session_t *ps, int argc, char *const *argv) {
+get_cfg(session_t *ps, int argc, char *const *argv, bool first_pass) {
const static char *shortopts = "D:I:O:d:r:o:m:l:t:i:e:hscnfFCaSzGb";
const static struct option longopts[] = {
{ "help", no_argument, NULL, 'h' },
@@ -4595,14 +4369,33 @@ get_cfg(session_t *ps, int argc, char *const *argv) {
{ NULL, 0, NULL, 0 },
};
+ int o = 0, longopt_idx = -1, i = 0;
+
+ if (first_pass) {
+ // Pre-parse the commandline arguments to check for --config and invalid
+ // switches
+ // Must reset optind to 0 here in case we reread the commandline
+ // arguments
+ optind = 1;
+ while (-1 !=
+ (o = getopt_long(argc, argv, shortopts, longopts, &longopt_idx))) {
+ if (256 == o)
+ ps->o.config_file = mstrcpy(optarg);
+ else if ('d' == o)
+ ps->o.display = mstrcpy(optarg);
+ else if ('?' == o || ':' == o)
+ usage();
+ }
+
+ return;
+ }
+
struct options_tmp cfgtmp = {
.no_dock_shadow = false,
.no_dnd_shadow = false,
.menu_opacity = 1.0,
};
bool shadow_enable = false, fading_enable = false;
- int o, longopt_idx, i;
- char *config_file = NULL;
char *lc_numeric_old = mstrcpy(setlocale(LC_NUMERIC, NULL));
for (i = 0; i < NUM_WINTYPES; ++i) {
@@ -4611,21 +4404,8 @@ get_cfg(session_t *ps, int argc, char *const *argv) {
ps->o.wintype_opacity[i] = 1.0;
}
- // Pre-parse the commandline arguments to check for --config and invalid
- // switches
- // Must reset optind to 0 here in case we reread the commandline
- // arguments
- optind = 1;
- while (-1 !=
- (o = getopt_long(argc, argv, shortopts, longopts, &longopt_idx))) {
- if (256 == o)
- config_file = mstrcpy(optarg);
- else if ('?' == o || ':' == o)
- usage();
- }
-
#ifdef CONFIG_LIBCONFIG
- parse_config(ps, config_file, &cfgtmp);
+ parse_config(ps, &cfgtmp);
#endif
// Parse commandline arguments. Range checking will be done later.
@@ -4643,7 +4423,6 @@ get_cfg(session_t *ps, int argc, char *const *argv) {
usage();
break;
case 'd':
- ps->o.display = mstrcpy(optarg);
break;
case 'D':
ps->o.fade_delta = atoi(optarg);
@@ -4732,7 +4511,7 @@ get_cfg(session_t *ps, int argc, char *const *argv) {
break;
case 263:
// --shadow-exclude
- condlst_add(&ps->o.shadow_blacklist, optarg);
+ condlst_add(ps, &ps->o.shadow_blacklist, optarg);
break;
case 264:
// --mark-ovredir-focused
@@ -4796,7 +4575,7 @@ get_cfg(session_t *ps, int argc, char *const *argv) {
break;
case 279:
// --focus-exclude
- condlst_add(&ps->o.focus_blacklist, optarg);
+ condlst_add(ps, &ps->o.focus_blacklist, optarg);
break;
case 280:
// --inactive-dim-fixed
@@ -4832,7 +4611,7 @@ get_cfg(session_t *ps, int argc, char *const *argv) {
break;
case 288:
// --invert-color-include
- condlst_add(&ps->o.invert_color_list, optarg);
+ condlst_add(ps, &ps->o.invert_color_list, optarg);
break;
default:
usage();
@@ -4884,11 +4663,6 @@ get_cfg(session_t *ps, int argc, char *const *argv) {
ps->o.track_focus = true;
}
- // Determine whether we need to track window name and class
- if (ps->o.shadow_blacklist || ps->o.fade_blacklist
- || ps->o.focus_blacklist || ps->o.invert_color_list)
- ps->o.track_wdata = true;
-
// Determine whether we track window grouping
if (ps->o.detect_transient || ps->o.detect_client_leader) {
ps->o.track_leader = true;
@@ -5702,7 +5476,8 @@ session_init(session_t *ps_old, int argc, char **argv) {
ps->o.wintype_focus[WINTYPE_NORMAL] = false;
ps->o.wintype_focus[WINTYPE_UTILITY] = false;
- get_cfg(ps, argc, argv);
+ // First pass
+ get_cfg(ps, argc, argv, true);
// Inherit old Display if possible, primarily for resource leak checking
if (ps_old && ps_old->dpy)
@@ -5712,11 +5487,13 @@ session_init(session_t *ps_old, int argc, char **argv) {
if (!ps->dpy) {
ps->dpy = XOpenDisplay(ps->o.display);
if (!ps->dpy) {
- fprintf(stderr, "Can't open display\n");
- exit(1);
+ printf_errfq(1, "(): Can't open display.");
}
}
+ // Second pass
+ get_cfg(ps, argc, argv, false);
+
XSetErrorHandler(error);
if (ps->o.synchronize) {
XSynchronize(ps->dpy, 1);
@@ -5973,11 +5750,24 @@ session_destroy(session_t *ps) {
ps->alpha_picts = NULL;
}
+#ifdef CONFIG_C2
// Free blacklists
free_wincondlst(&ps->o.shadow_blacklist);
free_wincondlst(&ps->o.fade_blacklist);
free_wincondlst(&ps->o.focus_blacklist);
free_wincondlst(&ps->o.invert_color_list);
+#endif
+
+ // Free tracked atom list
+ {
+ latom_t *next = NULL;
+ for (latom_t *this = ps->track_atom_lst; this; this = next) {
+ next = this->next;
+ free(this);
+ }
+
+ ps->track_atom_lst = NULL;
+ }
// Free ignore linked list
{
@@ -6025,6 +5815,7 @@ session_destroy(session_t *ps) {
free(ps->gaussian_map);
free(ps->o.display);
free(ps->o.logpath);
+ free(ps->o.config_file);
free(ps->pfds_read);
free(ps->pfds_write);
free(ps->pfds_except);
@@ -6164,11 +5955,6 @@ main(int argc, char **argv) {
printf_errf("Failed to create new session.");
return 1;
}
-#ifdef DEBUG_C2
- // c2_parse(ps_g, NULL, "name ~= \"master\"");
- // c2_parse(ps_g, NULL, "n:e:Notification");
- c2_parse(ps_g, NULL, "(WM_NAME:16s = 'Notification' || class_g = 'fox') && class_g = 'fox'");
-#endif
session_run(ps_g);
ps_old = ps_g;
session_destroy(ps_g);
diff --git a/compton.h b/compton.h
index 7670424e9..75d517ec8 100644
--- a/compton.h
+++ b/compton.h
@@ -15,7 +15,6 @@
#include <unistd.h>
#include <getopt.h>
#include <locale.h>
-#include <fnmatch.h>
#include <signal.h>
#ifdef CONFIG_VSYNC_DRM
@@ -165,37 +164,16 @@ free_damage(session_t *ps, Damage *p) {
}
}
+#ifdef CONFIG_C2
/**
- * Destroy a <code>wincond_t</code>.
+ * Destroy a condition list.
*/
-inline static void
-free_wincond(wincond_t *cond) {
- if (cond->pattern)
- free(cond->pattern);
-#ifdef CONFIG_REGEX_PCRE
- if (cond->regex_pcre_extra)
- LPCRE_FREE_STUDY(cond->regex_pcre_extra);
- if (cond->regex_pcre)
- pcre_free(cond->regex_pcre);
-#endif
- free(cond);
-}
-
-/**
- * Destroy a linked list of <code>wincond_t</code>.
- */
-inline static void
-free_wincondlst(wincond_t **cond_lst) {
- wincond_t *next = NULL;
-
- for (wincond_t *cond = *cond_lst; cond; cond = next) {
- next = cond->next;
-
- free_wincond(cond);
- }
-
- *cond_lst = NULL;
+static inline void
+free_wincondlst(c2_lptr_t **pcondlst) {
+ while ((*pcondlst = c2_free_lptr(*pcondlst)))
+ continue;
}
+#endif
/**
* Destroy all resources in a <code>struct _win</code>.
@@ -396,14 +374,20 @@ win_is_fullscreen(session_t *ps, const win *w) {
static void
win_rounded_corners(session_t *ps, win *w);
-static bool
-win_match_once(win *w, const wincond_t *cond);
-
-static bool
-win_match(win *w, wincond_t *condlst, wincond_t * *cache);
+/**
+ * Wrapper of c2_match().
+ */
+static inline bool
+win_match(session_t *ps, win *w, c2_lptr_t *condlst, const c2_lptr_t **cache) {
+#ifdef CONFIG_C2
+ return c2_match(ps, w, condlst, cache);
+#else
+ return false;
+#endif
+}
static bool
-condlst_add(wincond_t **pcondlst, const char *pattern);
+condlst_add(session_t *ps, c2_lptr_t **pcondlst, const char *pattern);
static long
determine_evmask(session_t *ps, Window wid, win_evmode_t mode);
@@ -594,7 +578,7 @@ static void
win_on_wtype_change(session_t *ps, win *w);
static void
-win_on_wdata_change(session_t *ps, win *w);
+win_on_factor_change(session_t *ps, win *w);
static void
win_upd_run(session_t *ps, win *w, win_upd_t *pupd);
@@ -858,15 +842,15 @@ static FILE *
open_config_file(char *cpath, char **path);
static void
-parse_cfg_condlst(const config_t *pcfg, wincond_t **pcondlst,
+parse_cfg_condlst(session_t *ps, const config_t *pcfg, c2_lptr_t **pcondlst,
const char *name);
static void
-parse_config(session_t *ps, char *cpath, struct options_tmp *pcfgtmp);
+parse_config(session_t *ps, struct options_tmp *pcfgtmp);
#endif
static void
-get_cfg(session_t *ps, int argc, char *const *argv);
+get_cfg(session_t *ps, int argc, char *const *argv, bool first_pass);
static void
init_atoms(session_t *ps);
diff --git a/dbus.c b/dbus.c
index a86ed174d..44f1369d7 100644
--- a/dbus.c
+++ b/dbus.c
@@ -859,6 +859,7 @@ cdbus_process_opts_get(session_t *ps, DBusMessage *msg) {
return true;
}
+ cdbus_m_opts_get_do(config_file, cdbus_reply_string);
cdbus_m_opts_get_do(mark_wmwin_focused, cdbus_reply_bool);
cdbus_m_opts_get_do(mark_ovredir_focused, cdbus_reply_bool);
cdbus_m_opts_get_do(fork_after_register, cdbus_reply_bool);