HomeSort by: relevance | last modified time | path
    Searched refs:expression (Results 1 - 25 of 128) sorted by relevancy

1 2 3 4 5 6

  /src/usr.bin/make/unit-tests/
directive-export-literal.exp 1 value with ${UNEXPANDED} expression
varparse-errors.exp 15 make: varparse-errors.mk:81: Unclosed expression, expecting "}" for modifier "Q"
17 make: varparse-errors.mk:83: Unclosed expression, expecting "}" for modifier "sh"
19 make: varparse-errors.mk:85: Unclosed expression, expecting "}" for modifier "tA"
21 make: varparse-errors.mk:87: Unclosed expression, expecting "}" for modifier "tsX"
23 make: varparse-errors.mk:89: Unclosed expression, expecting "}" for modifier "ts"
25 make: varparse-errors.mk:91: Unclosed expression, expecting "}" for modifier "ts\040"
27 make: varparse-errors.mk:93: Unclosed expression, expecting "}" for modifier "u"
29 make: varparse-errors.mk:95: Unclosed expression, expecting "}" for modifier "H"
31 make: varparse-errors.mk:97: Unclosed expression, expecting "}" for modifier "[1]"
33 make: varparse-errors.mk:99: Unclosed expression, expecting "}" for modifier "hash
    [all...]
char-005c-reverse-solidus.exp 1 make: char-005c-reverse-solidus.mk:57: Unclosed expression, expecting "}" for modifier "Mx\}"
3 make: char-005c-reverse-solidus.mk:64: Unclosed expression, expecting "}" for modifier "Mx\\}"
5 make: char-005c-reverse-solidus.mk:71: Unclosed expression, expecting "}" for modifier "Mx\\\\\\\\}"
9 make: char-005c-reverse-solidus.mk:111: Unclosed expression, expecting "}" for modifier "M${:U\\\\}} != "\\""
cmd-errors-lint.mk 8 all: undefined unclosed-expression unclosed-modifier unknown-modifier end
16 unclosed-expression:
18 # expect-not: : unclosed-expression
22 # expect: make: Unclosed expression, expecting "}"
cmd-errors.mk 6 all: undefined unclosed-expression unclosed-modifier unknown-modifier end
14 unclosed-expression:
16 # expect-not: : unclosed-expression-
20 # expect: make: Unclosed expression, expecting "}"
varparse-errors.mk 20 ERR_UNCLOSED= An ${UNCLOSED expression.
22 ERR_BAD_MOD= An ${:Uindirect:Z} expression with an unknown modifier.
26 # In a conditional, an expression that is not enclosed in quotes is
80 # expect+1: Unclosed expression, expecting "}" for modifier "Q"
82 # expect+1: Unclosed expression, expecting "}" for modifier "sh"
84 # expect+1: Unclosed expression, expecting "}" for modifier "tA"
86 # expect+1: Unclosed expression, expecting "}" for modifier "tsX"
88 # expect+1: Unclosed expression, expecting "}" for modifier "ts"
90 # expect+1: Unclosed expression, expecting "}" for modifier "ts\040"
92 # expect+1: Unclosed expression, expecting "}" for modifier "u
    [all...]
cmd-errors-lint.exp 4 in target "unclosed-expression"
5 make: Unclosed expression, expecting "}"
cmd-errors.exp 4 in target "unclosed-expression"
5 make: Unclosed expression, expecting "}"
cond-token-var.mk 5 # Note the fine distinction between a variable and an expression.
7 # expression of the form ${VAR}. This is a simple
8 # expression. Expressions can get more complicated by adding
11 # XXX: Strictly speaking, variable modifiers should be called expression
12 # modifiers instead since they only modify the expression, not the variable.
40 # A defined variable may appear as an expression of its own.
49 # The :U modifier turns an undefined expression into a defined expression.
50 # Since the expression is defined now, it doesn't generate any parse error.
72 # A defined variable may appear as an expression of its own
    [all...]
varparse-undef-partial.mk 4 # initial '$' of the expression is skipped by the parser, while
5 # the remaining expression is evaluated. In edge cases this can lead to
12 # The expression ${VAR.${PARAM}} refers to the variable named "VAR.:Q",
14 # therefore the initial '$' of that whole expression is skipped by the parser
15 # (see VarSubstExpr) and the rest of the expression is expanded as usual.
17 # The resulting expression is ${VAR.:Q}, which means that the
29 # At this point, the variable "VAR." is defined, therefore the expression
39 # variable name, as would be expected from reading the expression.
46 # Should the whole expression be skipped for now, or should the inner
54 # expression is expanded early, or whether the whole ${COPTS.${COMPILER}} i
    [all...]
opt-debug-jobs.exp 4 echo ": expanded expression"
5 { : expanded expression
20 : expanded expression
varmod-subst-regex.mk 13 # The expression expands to 4 words. Of these words, none matches
14 # the regular expression "a b" since these words don't contain any
21 # means to apply at most 1 replacement in the whole expression.
27 # containing whitespace. This big word matches the regular expression,
40 # expression a single word. The 'g' modifier then replaces all occurrences
49 # The regular expression does not match in the first word.
51 # In the third word, the regular expression matches as early as possible,
54 # and that cannot match the regular expression "..". Therefore only the
61 # expression value, no matter whether it is a single big word or many small
71 # A regular expression that matches the empty string applies before ever
    [all...]
varmod-indirect.mk 14 # modifier must be put into a single expression.
15 # The following expression generates a parse error since its indirect
16 # modifier contains more than a sole expression.
45 # If an expression for an indirect modifier evaluates to anything else than an
71 # The nested expression expands to "tu", and this is interpreted as
77 # The nested expression expands to "tl", and this is interpreted as
84 # The nested expression is ${1 != 1:?Z:tl}, consisting of the
94 # brain twisters since by reading the expression alone, it is not possible
96 # as the immediate value of the expression.
115 # The dollar signs need to be doubled in the above modifier expression,
    [all...]
parse-var.mk 71 # What's the value of the expression (return value)?
89 # 2023-02-18, the exact way of parsing an expression with subexpressions
90 # depended on whether the expression was actually evaluated or merely parsed.
95 # If the expression was merely parsed but not evaluated (for example, because
97 # first pass of the ':@var@body@' modifier), and the expression contained a
98 # modifier, and that modifier contained a nested expression, the nested
99 # expression was not parsed correctly. Instead, make only counted the opening
105 # understand. If the expression ${BRACE_PAIR:...} had been replaced with the
115 # Due to the always-true condition '1', the outer expression is relevant and
119 # Due to the always-false condition '0', the outer expression is irrelevant
    [all...]
varmod-order.exp 5 make: varmod-order.mk:20: Unclosed expression, expecting "}" for modifier "O"
7 make: varmod-order.mk:22: Unclosed expression, expecting "}" for modifier "On"
9 make: varmod-order.mk:24: Unclosed expression, expecting "}" for modifier "Onr"
cond-func-empty.mk 4 # expression for emptiness.
7 # expression. That name may be followed by ':...' modifiers.
29 # applying the :S modifier to the expression, its value is 'empty', so it is
31 # a few modifiers that turn an undefined expression into a defined expression,
33 # expression, the expression is still undefined, so its final value becomes an
43 # The :U modifier changes the state of a previously undefined expression from
44 # DEF_UNDEF to DEF_DEFINED. This marks the expression as "being interesting
51 # When an expression is based on an undefined variable, its modifiers interac
    [all...]
varmod-no-match.mk 3 # Tests for the expression modifier ':N', which filters words that do not
38 # Idiom: single-word expression equals any of several words or patterns
40 # If an expression is guaranteed to consist of a single word, the modifier
41 # ':N' can be chained to compare the expression to several words or even
43 # expression will be the empty string.
64 # The '!= ""' can be omitted if the expression cannot have the numeric value
66 # as 'neither' or 'nor', which makes the expression sound more natural.
82 # due to the '!empty', the expression to be evaluated no longer starts with
varmod-range.mk 10 # word of the expression's value.
22 # expression. If that expression is undefined, the range is
28 # An empty expression results in a sequence of a single number, even though
29 # the expression contains 0 words.
35 # range independent from the value or the name of the expression.
40 # expression into a defined one, even though it does not depend on the value
41 # of the expression. This looks like an oversight.
char-005c-reverse-solidus.mk 52 # expect+5: Unclosed expression, expecting "}" for modifier "Mx\}"
53 # At the point where the unclosed expression is detected, the ":M" modifier
54 # has been applied to the expression. Its pattern is "x}", which doesn't
63 # expect+1: Unclosed expression, expecting "}" for modifier "Mx\\}"
70 # expect+1: Unclosed expression, expecting "}" for modifier "Mx\\\\\\\\}"
98 # an expression. There, the usual escaping rules for modifiers apply.
106 # Trying to bypass the parser by using a direct expression doesn't work, as
110 # expect+1: Unclosed expression, expecting "}" for modifier "M${:U\\\\}} != "\\""
varmod-l-name-to-value.mk 10 # The variable name is converted into an expression with the variable name
16 # The value of the expression can be modified afterwards.
21 # The name of the expression is still the same as before. Using the :L
32 # the below :L did not update the definedness of the enclosing expression.
varparse-mod.mk 11 # expression with 2 modifiers. The first modifier is
16 # of the expression.
19 # ':' or the closing brace or parenthesis of the expression. The modifiers
53 # of the expression, which is either ')' or '}':
varmod-remember.mk 3 # Tests for the :_ modifier, which saves the current expression value
8 # expression is needed at the same time as a sequence of numbers. In these
9 # cases, the value of the expression is saved in the temporary variable '_',
10 # from where it is taken later in the same expression.
29 # The expression ${GHI} therefore evaluated to '1=D 2=E 3=F', reusing the
69 # the value of the temporary variable '_' from the inner expression leaks into
70 # the evaluation of the outer expression. If the expressions were evaluated
varmod-ifelse.mk 4 # the then-expression or the else-expression, depending on the condition.
13 # The variable name of the expression is expanded and then taken as the
19 # word "expression". If the name were expanded lazily, everything would be
43 # context, an undefined expression is not an error. The "variable name" then
65 # expression" by ApplyModifier_IfElse. The expression containing that
83 # value of the expression is still undefined. CondParser_String is
103 # expression in the condition to be evaluated at exactly the right point,
105 # expression ${:U\$}. Because of this escaping, the variable "VAR" and thu
    [all...]
  /src/lib/libform/
type_regex.c 59 char *expression; local in function:create_regex_args
65 expression = va_arg(*args, char *);
66 if ((regcomp(&new->compiled, expression,
  /src/sys/dev/microcode/aic7xxx/
aicasm_gram.y 103 static void type_check(symbol_t *symbol, expression_t *expression, int and_op);
118 expression_t expression;
207 %type <expression> expression immediate immediate_or_a
450 | T_FIELD T_SYMBOL expression
458 | T_FIELD T_SYMBOL expression
472 | T_ENUM T_SYMBOL expression
493 | T_SYMBOL expression
501 T_MASK T_SYMBOL expression
593 expression label
    [all...]

Completed in 15 milliseconds

1 2 3 4 5 6