+2008-02-25 Frank Ch. Eigler <fche@elastic.org>
+
+ PR5792.
+ * parse.cxx (eval_pp_conditional): Support wildcards in
+ %( kernel_v/kernel_vr/arch ==/!= "*foo?" %) operands.
+ * NEWS, stap.1.in: Document this.
+
2008-02-22 Frank Ch. Eigler <fche@elastic.org>
PR5787, PR2608, .statement()
* What's new in version 0.6 / 0.6.1
+- Preprocessor conditional expressions can now include wildcard style
+ matches on kernel versions.
+ %( kernel_vr != "*xen" %? foo %: bar %)
+
- Prototype support for user-space probing is showing some progress.
No symbolic notations are supported yet (so no probing by function names,
file names, process names, and no access to $context variables), but at
#include <sstream>
#include <cstring>
#include <cctype>
+extern "C" {
+#include <fnmatch.h>
+}
using namespace std;
if (! (r->type == tok_string))
throw parse_error ("expected string literal", r);
- string query_kernel_vr = r->content;
-
+
+ string target = (l->content == "kernel_vr" ?
+ target_kernel_vr.c_str() :
+ target_kernel_v.c_str());
+ string query = r->content;
+ bool rhs_wildcard = (strpbrk (query.c_str(), "*?[") != 0);
+
// collect acceptable strverscmp results.
int rvc_ok1, rvc_ok2;
+ bool wc_ok = false;
if (op->type == tok_operator && op->content == "<=")
{ rvc_ok1 = -1; rvc_ok2 = 0; }
else if (op->type == tok_operator && op->content == ">=")
else if (op->type == tok_operator && op->content == ">")
{ rvc_ok1 = 1; rvc_ok2 = 1; }
else if (op->type == tok_operator && op->content == "==")
- { rvc_ok1 = 0; rvc_ok2 = 0; }
+ { rvc_ok1 = 0; rvc_ok2 = 0; wc_ok = true; }
else if (op->type == tok_operator && op->content == "!=")
- { rvc_ok1 = -1; rvc_ok2 = 1; }
+ { rvc_ok1 = -1; rvc_ok2 = 1; wc_ok = true; }
else
throw parse_error ("expected comparison operator", op);
-
- int rvc_result = strverscmp ((l->content == "kernel_vr" ?
- target_kernel_vr.c_str() :
- target_kernel_v.c_str()),
- query_kernel_vr.c_str());
- // normalize rvc_result
- if (rvc_result < 0) rvc_result = -1;
- if (rvc_result > 0) rvc_result = 1;
-
- return (rvc_result == rvc_ok1 || rvc_result == rvc_ok2);
+
+ if ((!wc_ok) && rhs_wildcard)
+ throw parse_error ("wildcard not allowed with order comparison operators", op);
+
+ if (rhs_wildcard)
+ {
+ int rvc_result = fnmatch (query.c_str(), target.c_str(),
+ FNM_NOESCAPE); // spooky
+ bool badness = (rvc_result == 0) ^ (op->content == "==");
+ return !badness;
+ }
+ else
+ {
+ int rvc_result = strverscmp (target.c_str(), query.c_str());
+ // normalize rvc_result
+ if (rvc_result < 0) rvc_result = -1;
+ if (rvc_result > 0) rvc_result = 1;
+ return (rvc_result == rvc_ok1 || rvc_result == rvc_ok2);
+ }
}
else if (l->type == tok_identifier && l->content == "arch")
{
throw parse_error ("expected string literal", r);
string query_architecture = r->content;
+ int nomatch = fnmatch (query_architecture.c_str(),
+ target_architecture.c_str(),
+ FNM_NOESCAPE); // still spooky
+
bool result;
if (op->type == tok_operator && op->content == "==")
- result = target_architecture == query_architecture;
+ result = !nomatch;
else if (op->type == tok_operator && op->content == "!=")
- result = target_architecture != query_architecture;
+ result = nomatch;
else
throw parse_error ("expected '==' or '!='", op);
if (rvc_result < 0) rvc_result = -1;
if (rvc_result > 0) rvc_result = 1;
+ // NB: no wildcarding option here
+
return (rvc_result == rvc_ok1 || rvc_result == rvc_ok2);
}
else if (l->type == tok_string && r->type == tok_number
option) compares to the given version string. The comparison is
performed by the glibc function
.BR strverscmp .
+As a special case, if the operator is for simple equality
+.RB ( == ),
+or inequality
+.RB ( != ),
+and the third part contains any wildcard characters
+.RB ( * " or " ? " or " [ "),"
+then the expression is treated as a wildcard (mis)match as evaluated
+by
+.BR fnmatch .
.PP
If, on the other hand, the first part is the identifier
.BR arch
then the second part is one of the two string comparison operators
.BR == " or " != ,
and the third part is a string literal for matching it. This
-comparison is simple string (in)equality.
+comparison is a wildcard (mis)match.
.PP
Otherwise, the CONDITION is expected to be a comparison between two string
literals or two numeric literals. In this case, the arguments are the only
+2008-02-25 Frank Ch. Eigler <fche@elastic.org>
+
+ PR5792.
+ * systemtap.base/preprocessor.exp: New test.
+
2008-02-23 Frank Ch. Eigler <fche@elastic.org>
* systemtap.printf/*.exp: Canonicalize pass/fail messages.
--- /dev/null
+
+set kvr [exec uname -r]
+set kv [exec uname -r | cut -f1 -d-]
+# a pattern bound to match
+set kr {2?[0-9]*}
+# a pattern bound to mismatch
+set krx {?noSuchKernel*}
+
+set arch [exec uname -m]
+set ar "?[string range $arch 1 end-1]?"
+set arx {?noSuchArch?}
+
+# This test works so that if all the preprocessor conditionals
+# work as expected, stap will indicate no error.
+
+set test "preprocessor basic ops"
+spawn stap -p2 -e "probe never {}
+%( kernel_v == \"$kv\" %? %: ERROR %)
+%( kernel_v == \"$kr\" %? %: ERROR %)
+%( kernel_v == \"$krx\" %? ERROR %: %)
+%( kernel_v != \"$kv\" %? ERROR %: %)
+%( kernel_v != \"$kr\" %? ERROR %: %)
+%( kernel_v != \"$krx\" %? %: ERROR %)
+%( kernel_v < \"9.9999\" %? %: ERROR %)
+%( kernel_v <= \"9.9999\" %? %: ERROR %)
+%( kernel_v > \"9.9999\" %? ERROR %: %)
+%( kernel_v >= \"9.9999\" %? ERROR %: %)
+%( kernel_vr == \"$kvr\" %? %: ERROR %)
+%( kernel_vr == \"$kr\" %? %: ERROR %)
+%( kernel_vr == \"$krx\" %? ERROR %: %)
+%( kernel_vr != \"$kvr\" %? ERROR %: %)
+%( kernel_vr != \"$kr\" %? ERROR %: %)
+%( kernel_vr != \"$krx\" %? %: ERROR %)
+%( kernel_vr < \"9.9999\" %? %: ERROR %)
+%( kernel_vr <= \"9.9999\" %? %: ERROR %)
+%( kernel_vr > \"9.9999\" %? ERROR %: %)
+%( kernel_vr >= \"9.9999\" %? ERROR %: %)
+%( arch == \"$arch\" %? %: ERROR %)
+%( arch == \"$ar\" %? %: ERROR %)
+%( arch == \"$arx\" %? ERROR %: %)
+%( arch != \"$arch\" %? ERROR %: %)
+%( arch != \"$ar\" %? ERROR %: %)
+%( arch != \"$arx\" %? %: ERROR %)
+"
+set ok 0
+expect {
+ "never" { incr ok }
+ eof { }
+ timeout { }
+}
+catch {close; wait}
+if {$ok == 1} { pass $test } { fail $test }