|
| 1 | +/** |
| 2 | + * Module for parsing access paths from CSV models, both the identifying access path used |
| 3 | + * by dynamic languages, and the input/output specifications for summary steps. |
| 4 | + * |
| 5 | + * This file is used by the shared data flow library and by the JavaScript libraries |
| 6 | + * (which does not use the shared data flow libraries). |
| 7 | + */ |
| 8 | + |
| 9 | +/** |
| 10 | + * Convenience-predicate for extracting two capture groups at once. |
| 11 | + */ |
| 12 | +bindingset[input, regexp] |
| 13 | +private predicate regexpCaptureTwo(string input, string regexp, string capture1, string capture2) { |
| 14 | + capture1 = input.regexpCapture(regexp, 1) and |
| 15 | + capture2 = input.regexpCapture(regexp, 2) |
| 16 | +} |
| 17 | + |
| 18 | +/** Companion module to the `AccessPath` class. */ |
| 19 | +module AccessPath { |
| 20 | + /** A string that should be parsed as an access path. */ |
| 21 | + abstract class Range extends string { |
| 22 | + bindingset[this] |
| 23 | + Range() { any() } |
| 24 | + } |
| 25 | + |
| 26 | + /** |
| 27 | + * Parses an integer constant `n` or interval `n1..n2` (inclusive) and gets the value |
| 28 | + * of the constant or any value contained in the interval. |
| 29 | + */ |
| 30 | + bindingset[arg] |
| 31 | + int parseInt(string arg) { |
| 32 | + result = arg.toInt() |
| 33 | + or |
| 34 | + // Match "n1..n2" |
| 35 | + exists(string lo, string hi | |
| 36 | + regexpCaptureTwo(arg, "(-?\\d+)\\.\\.(-?\\d+)", lo, hi) and |
| 37 | + result = [lo.toInt() .. hi.toInt()] |
| 38 | + ) |
| 39 | + } |
| 40 | + |
| 41 | + /** |
| 42 | + * Parses a lower-bounded interval `n..` and gets the lower bound. |
| 43 | + */ |
| 44 | + bindingset[arg] |
| 45 | + private int parseLowerBound(string arg) { |
| 46 | + result = arg.regexpCapture("(-?\\d+)\\.\\.", 1).toInt() |
| 47 | + } |
| 48 | + |
| 49 | + /** |
| 50 | + * Parses an integer constant or interval (bounded or unbounded) that explicitly |
| 51 | + * references the arity, such as `N-1` or `N-3..N-1`. |
| 52 | + * |
| 53 | + * Note that expressions of form `N-x` will never resolve to a negative index, |
| 54 | + * even if `N` is zero (it will have no result in that case). |
| 55 | + */ |
| 56 | + bindingset[arg, arity] |
| 57 | + private int parseIntWithExplicitArity(string arg, int arity) { |
| 58 | + result >= 0 and // do not allow N-1 to resolve to a negative index |
| 59 | + exists(string lo | |
| 60 | + // N-x |
| 61 | + lo = arg.regexpCapture("N-(\\d+)", 1) and |
| 62 | + result = arity - lo.toInt() |
| 63 | + or |
| 64 | + // N-x.. |
| 65 | + lo = arg.regexpCapture("N-(\\d+)\\.\\.", 1) and |
| 66 | + result = [arity - lo.toInt(), arity - 1] |
| 67 | + ) |
| 68 | + or |
| 69 | + exists(string lo, string hi | |
| 70 | + // x..N-y |
| 71 | + regexpCaptureTwo(arg, "(-?\\d+)\\.\\.N-(\\d+)", lo, hi) and |
| 72 | + result = [lo.toInt() .. arity - hi.toInt()] |
| 73 | + or |
| 74 | + // N-x..N-y |
| 75 | + regexpCaptureTwo(arg, "N-(\\d+)\\.\\.N-(\\d+)", lo, hi) and |
| 76 | + result = [arity - lo.toInt() .. arity - hi.toInt()] and |
| 77 | + result >= 0 |
| 78 | + or |
| 79 | + // N-x..y |
| 80 | + regexpCaptureTwo(arg, "N-(\\d+)\\.\\.(\\d+)", lo, hi) and |
| 81 | + result = [arity - lo.toInt() .. hi.toInt()] and |
| 82 | + result >= 0 |
| 83 | + ) |
| 84 | + } |
| 85 | + |
| 86 | + /** |
| 87 | + * Parses an integer constant or interval (bounded or unbounded) and gets any |
| 88 | + * of the integers contained within (of which there may be infinitely many). |
| 89 | + * |
| 90 | + * Has no result for arguments involving an explicit arity, such as `N-1`. |
| 91 | + */ |
| 92 | + bindingset[arg, result] |
| 93 | + int parseIntUnbounded(string arg) { |
| 94 | + result = parseInt(arg) |
| 95 | + or |
| 96 | + result >= parseLowerBound(arg) |
| 97 | + } |
| 98 | + |
| 99 | + /** |
| 100 | + * Parses an integer constant or interval (bounded or unbounded) that |
| 101 | + * may reference the arity of a call, such as `N-1` or `N-3..N-1`. |
| 102 | + * |
| 103 | + * Note that expressions of form `N-x` will never resolve to a negative index, |
| 104 | + * even if `N` is zero (it will have no result in that case). |
| 105 | + */ |
| 106 | + bindingset[arg, arity] |
| 107 | + int parseIntWithArity(string arg, int arity) { |
| 108 | + result = parseInt(arg) |
| 109 | + or |
| 110 | + result in [parseLowerBound(arg) .. arity - 1] |
| 111 | + or |
| 112 | + result = parseIntWithExplicitArity(arg, arity) |
| 113 | + } |
| 114 | +} |
| 115 | + |
| 116 | +/** Gets the `n`th token on the access path as a string. */ |
| 117 | +private string getRawToken(AccessPath path, int n) { |
| 118 | + // Avoid splitting by '.' since tokens may contain dots, e.g. `Field[foo.Bar.x]`. |
| 119 | + // Instead use regexpFind to match valid tokens, and supplement with a final length |
| 120 | + // check (in `AccessPath.hasSyntaxError`) to ensure all characters were included in a token. |
| 121 | + result = path.regexpFind("\\w+(?:\\[[^\\]]*\\])?(?=\\.|$)", n, _) |
| 122 | +} |
| 123 | + |
| 124 | +/** |
| 125 | + * A string that occurs as an access path (either identifying or input/output spec) |
| 126 | + * which might be relevant for this database. |
| 127 | + */ |
| 128 | +class AccessPath extends string instanceof AccessPath::Range { |
| 129 | + /** Holds if this string is not a syntactically valid access path. */ |
| 130 | + predicate hasSyntaxError() { |
| 131 | + // If the lengths match, all characters must haven been included in a token |
| 132 | + // or seen by the `.` lookahead pattern. |
| 133 | + this != "" and |
| 134 | + not this.length() = sum(int n | | getRawToken(this, n).length() + 1) - 1 |
| 135 | + } |
| 136 | + |
| 137 | + /** Gets the `n`th token on the access path (if there are no syntax errors). */ |
| 138 | + AccessPathToken getToken(int n) { |
| 139 | + result = getRawToken(this, n) and |
| 140 | + not this.hasSyntaxError() |
| 141 | + } |
| 142 | + |
| 143 | + /** Gets the number of tokens on the path (if there are no syntax errors). */ |
| 144 | + int getNumToken() { |
| 145 | + result = count(int n | exists(getRawToken(this, n))) and |
| 146 | + not this.hasSyntaxError() |
| 147 | + } |
| 148 | +} |
| 149 | + |
| 150 | +/** |
| 151 | + * An access part token such as `Argument[1]` or `ReturnValue`, appearing in one or more access paths. |
| 152 | + */ |
| 153 | +class AccessPathToken extends string { |
| 154 | + AccessPathToken() { this = getRawToken(any(AccessPath path), _) } |
| 155 | + |
| 156 | + private string getPart(int part) { |
| 157 | + result = this.regexpCapture("([^\\[]+)(?:\\[([^\\]]*)\\])?", part) |
| 158 | + } |
| 159 | + |
| 160 | + /** Gets the name of the token, such as `Member` from `Member[x]` */ |
| 161 | + string getName() { result = this.getPart(1) } |
| 162 | + |
| 163 | + /** |
| 164 | + * Gets the argument list, such as `1,2` from `Member[1,2]`, |
| 165 | + * or has no result if there are no arguments. |
| 166 | + */ |
| 167 | + string getArgumentList() { result = this.getPart(2) } |
| 168 | + |
| 169 | + /** Gets the `n`th argument to this token, such as `x` or `y` from `Member[x,y]`. */ |
| 170 | + string getArgument(int n) { result = this.getArgumentList().splitAt(",", n).trim() } |
| 171 | + |
| 172 | + /** Gets an argument to this token, such as `x` or `y` from `Member[x,y]`. */ |
| 173 | + string getAnArgument() { result = this.getArgument(_) } |
| 174 | + |
| 175 | + /** Gets the number of arguments to this token, such as 2 for `Member[x,y]` or zero for `ReturnValue`. */ |
| 176 | + int getNumArgument() { result = count(int n | exists(this.getArgument(n))) } |
| 177 | +} |
0 commit comments