diff options
Diffstat (limited to 'contrib/bmake/unit-tests/varmod-match.mk')
-rw-r--r-- | contrib/bmake/unit-tests/varmod-match.mk | 356 |
1 files changed, 338 insertions, 18 deletions
diff --git a/contrib/bmake/unit-tests/varmod-match.mk b/contrib/bmake/unit-tests/varmod-match.mk index 9b56fb451eda..d93d1839192d 100644 --- a/contrib/bmake/unit-tests/varmod-match.mk +++ b/contrib/bmake/unit-tests/varmod-match.mk @@ -1,42 +1,234 @@ -# $NetBSD: varmod-match.mk,v 1.6 2020/11/15 18:33:41 rillig Exp $ +# $NetBSD: varmod-match.mk,v 1.20 2023/12/17 23:19:02 rillig Exp $ # -# Tests for the :M variable modifier, which filters words that match the +# Tests for the ':M' modifier, which keeps only those words that match the # given pattern. # -# See ApplyModifier_Match and ModifyWord_Match for the implementation. +# Table of contents +# +# 1. Pattern characters '*', '?' and '\' +# 2. Character lists and character ranges +# 3. Parsing and escaping +# 4. Interaction with other modifiers +# 5. Performance +# 6. Error handling +# 7. Historical bugs +# +# See ApplyModifier_Match, ParseModifier_Match, ModifyWord_Match and +# Str_Match. + + +# 1. Pattern characters '*', '?' and '\' +# +# * matches 0 or more characters +# ? matches 1 character +# \x matches the character 'x' + +# The pattern is anchored both at the beginning and at the end of the word. +# Since the pattern 'e' does not contain any pattern matching characters, it +# matches exactly the word 'e', twice. +.if ${a c e aa cc ee e f g:L:Me} != "e e" +. error +.endif + +# The pattern character '?' matches exactly 1 character, the pattern character +# '*' matches 0 or more characters. The whole pattern matches all words that +# start with 's' and have 3 or more characters. +.if ${One Two Three Four five six seven:L:Ms??*} != "six seven" +. error +.endif + +# Ensure that a pattern without placeholders only matches itself. +.if ${a aa aaa b ba baa bab:L:Ma} != "a" +. error +.endif + +# Ensure that a pattern that ends with '*' is properly anchored at the +# beginning. +.if ${a aa aaa b ba baa bab:L:Ma*} != "a aa aaa" +. error +.endif -.MAKEFLAGS: -dc +# Ensure that a pattern that starts with '*' is properly anchored at the end. +.if ${a aa aaa b ba baa bab:L:M*a} != "a aa aaa ba baa" +. error +.endif + +# Test the fast code path for '*' followed by a regular character. +.if ${:U file.c file.*c file.h file\.c :M*.c} != "file.c file\\.c" +. error +.endif +# Ensure that the fast code path correctly handles the backslash. +.if ${:U file.c file.*c file.h file\.c :M*\.c} != "file.c file\\.c" +. error +.endif +# Ensure that the fast code path correctly handles '\*'. +.if ${:U file.c file.*c file.h file\.c :M*\*c} != "file.*c" +. error +.endif +# Ensure that the partial match '.c' doesn't confuse the fast code path. +.if ${:U file.c.cc file.cc.cc file.cc.c :M*.cc} != "file.c.cc file.cc.cc" +. error +.endif +# Ensure that the substring '.cc' doesn't confuse the fast code path for '.c'. +.if ${:U file.c.cc file.cc.cc file.cc.c :M*.c} != "file.cc.c" +. error +.endif -NUMBERS= One Two Three Four five six seven + +# 2. Character lists and character ranges +# +# [...] matches 1 character from the listed characters +# [^...] matches 1 character from the unlisted characters +# [a-z] matches 1 character from the range 'a' to 'z' +# [z-a] matches 1 character from the range 'a' to 'z' # Only keep words that start with an uppercase letter. -.if ${NUMBERS:M[A-Z]*} != "One Two Three Four" +.if ${One Two Three Four five six seven:L:M[A-Z]*} != "One Two Three Four" . error .endif # Only keep words that start with a character other than an uppercase letter. -.if ${NUMBERS:M[^A-Z]*} != "five six seven" +.if ${One Two Three Four five six seven:L:M[^A-Z]*} != "five six seven" +. error +.endif + +# [] matches never +.if ${ ab a[]b a[b a b :L:M[]} != "" +. error +.endif + +# a[]b matches never +.if ${ ab a[]b a[b a b [ ] :L:Ma[]b} != "" +. error +.endif + +# [^] matches exactly 1 arbitrary character +.if ${ ab a[]b a[b a b [ ] :L:M[^]} != "a b [ ]" +. error +.endif + +# a[^]b matches 'a', then exactly 1 arbitrary character, then 'b' +.if ${ ab a[]b a[b a b :L:Ma[^]b} != "a[b" +. error +.endif + +# [Nn0] matches exactly 1 character from the set 'N', 'n', '0' +.if ${ a b N n 0 Nn0 [ ] :L:M[Nn0]} != "N n 0" +. error +.endif + +# [a-c] matches exactly 1 character from the range 'a' to 'c' +.if ${ A B C a b c d [a-c] [a] :L:M[a-c]} != "a b c" +. error +.endif + +# [c-a] matches the same as [a-c] +.if ${ A B C a b c d [a-c] [a] :L:M[c-a]} != "a b c" +. error +.endif + +# [^a-c67] +# matches a single character, except for 'a', 'b', 'c', '6' or +# '7' +.if ${ A B C a b c d 5 6 7 8 [a-c] [a] :L:M[^a-c67]} != "A B C d 5 8" +. error +.endif + +# [\] matches a single backslash; no escaping takes place in +# character ranges +# Without the 'b' in the below words, the backslash would end a word and thus +# influence how the string is split into words. +WORDS= a\b a[\]b ab a\\b +.if ${WORDS:Ma[\]b} != "a\\b" +. error +.endif + +# [[-]] May look like it would match a single '[', '\' or ']', but +# the inner ']' has two roles: it is the upper bound of the +# character range as well as the closing character of the +# character list. The outer ']' is just a regular character. +WORDS= [ ] [] \] ]] +.if ${WORDS:M[[-]]} != "[] \\] ]]" +. error +.endif + +# [b[-]a] +# Same as for '[[-]]': the character list stops at the first +# ']', and the 'a]' is treated as a literal string. +WORDS= [a \a ]a []a \]a ]]a [a] \a] ]a] ba] +.if ${WORDS:M[b[-]a]} != "[a] \\a] ]a] ba]" +. error +.endif + +# [-] Matches a single '-' since the '-' only becomes part of a +# character range if it is preceded and followed by another +# character. +WORDS= - -] +.if ${WORDS:M[-]} != "-" . error .endif # Only keep words that don't start with s and at the same time end with # either of [ex]. # -# This test case ensures that the negation from the first character class -# does not propagate to the second character class. -.if ${NUMBERS:M[^s]*[ex]} != "One Three five" +# This test case ensures that the negation from the first character list +# '[^s]' does not propagate to the second character list '[ex]'. +.if ${One Two Three Four five six seven:L:M[^s]*[ex]} != "One Three five" . error .endif -# Before 2020-06-13, this expression took quite a long time in Str_Match, -# calling itself 601080390 times for 16 asterisks. -.if ${:U****************:M****************b} + +# 3. Parsing and escaping +# +# * matches 0 or more characters +# ? matches 1 character +# \ outside a character list, escapes the following character +# [ starts a character list for matching 1 character +# ] ends a character list for matching 1 character +# - in a character list, forms a character range +# ^ at the beginning of a character list, negates the list +# ( while parsing the pattern, starts a nesting level +# ) while parsing the pattern, ends a nesting level +# { while parsing the pattern, starts a nesting level +# } while parsing the pattern, ends a nesting level +# : while parsing the pattern, terminates the pattern +# $ while parsing the pattern, starts a nested expression +# # in a line except a shell command, starts a comment + +# The pattern can come from an expression. For single-letter +# variables, either the short form or the long form can be used, just as +# everywhere else. +PRIMES= 2 3 5 7 11 +n= 2 +.if ${PRIMES:M$n} != "2" +. error +.endif +.if ${PRIMES:M${n}} != "2" +. error +.endif +.if ${PRIMES:M${:U2}} != "2" +. error +.endif + +# : terminates the pattern +.if ${ A * :L:M:} != "" +. error +.endif + +# \: matches a colon +.if ${ ${:U\: \:\:} :L:M\:} != ":" +. error +.endif + +# ${:U\:} matches a colon +.if ${ ${:U\:} ${:U\:\:} :L:M${:U\:}} != ":" +. error .endif # To match a dollar sign in a word, double it. # -# This is different from the :S and :C variable modifiers, where a '$' -# has to be escaped as '\$'. +# This is different from the :S and :C modifiers, where a '$' has to be +# escaped as '\$'. .if ${:Ua \$ sign:M*$$*} != "\$" . error .endif @@ -45,7 +237,7 @@ NUMBERS= One Two Three Four five six seven # interpreted as a backslash followed by whatever expression the # '$' starts. # -# This differs from the :S, :C and several other variable modifiers. +# This differs from the :S, :C and several other modifiers. ${:U*}= asterisk .if ${:Ua \$ sign any-asterisk:M*\$*} != "any-asterisk" . error @@ -56,5 +248,133 @@ ${:U*}= asterisk # TODO: ${VAR:M${UNBALANCED}} # TODO: ${VAR:M${:U(((\}\}\}}} -all: - @:; + +# 4. Interaction with other modifiers + +# The modifier ':tW' prevents splitting at whitespace. Even leading and +# trailing whitespace is preserved. +.if ${ plain string :L:tW:M*} != " plain string " +. error +.endif + +# Without the modifier ':tW', the string is split into words. All whitespace +# around and between the words is normalized to a single space. +.if ${ plain string :L:M*} != "plain string" +. error +.endif + + +# 5. Performance + +# Before 2020-06-13, this expression called Str_Match 601,080,390 times. +# Since 2020-06-13, this expression calls Str_Match 1 time. +.if ${:U****************:M****************b} +.endif + +# Before 2023-06-22, this expression called Str_Match 2,621,112 times. +# Adding another '*?' to the pattern called Str_Match 20,630,572 times. +# Adding another '*?' to the pattern called Str_Match 136,405,672 times. +# Adding another '*?' to the pattern called Str_Match 773,168,722 times. +# Adding another '*?' to the pattern called Str_Match 3,815,481,072 times. +# Since 2023-06-22, Str_Match no longer backtracks. +.if ${:U..................................................b:M*?*?*?*?*?a} +.endif + + +# 6. Error handling + +# [ Incomplete empty character list, never matches. +WORDS= a a[ +# expect+1: warning: Unfinished character list in pattern 'a[' of modifier ':M' +.if ${WORDS:Ma[} != "" +. error +.endif + +# [^ Incomplete negated empty character list, matches any single +# character. +WORDS= a a[ aX +# expect+1: warning: Unfinished character list in pattern 'a[^' of modifier ':M' +.if ${WORDS:Ma[^} != "a[ aX" +. error +.endif + +# [-x1-3 Incomplete character list, matches those elements that can be +# parsed without lookahead. +WORDS= - + x xx 0 1 2 3 4 [x1-3 +# expect+1: warning: Unfinished character list in pattern '[-x1-3' of modifier ':M' +.if ${WORDS:M[-x1-3} != "- x 1 2 3" +. error +.endif + +# *[-x1-3 Incomplete character list after a wildcard, matches those +# words that end with one of the characters from the list. +WORDS= - + x xx 0 1 2 3 4 00 01 10 11 000 001 010 011 100 101 110 111 [x1-3 +# expect+1: warning: Unfinished character list in pattern '*[-x1-3' of modifier ':M' +.if ${WORDS:M*[-x1-3} != "- x xx 1 2 3 01 11 001 011 101 111 [x1-3" +. warning ${WORDS:M*[-x1-3} +.endif + +# [^-x1-3 +# Incomplete negated character list, matches any character +# except those elements that can be parsed without lookahead. +WORDS= - + x xx 0 1 2 3 4 [x1-3 +# expect+1: warning: Unfinished character list in pattern '[^-x1-3' of modifier ':M' +.if ${WORDS:M[^-x1-3} != "+ 0 4" +. error +.endif + +# [\ Incomplete character list containing a single '\'. +# +# A word can only end with a backslash if the preceding +# character is a backslash as well; in all other cases the final +# backslash would escape the following space, making the space +# part of the word. Only the very last word of a string can be +# '\', as there is no following space that could be escaped. +WORDS= \\ \a ${:Ux\\} +PATTERN= ${:U?[\\} +# expect+1: warning: Unfinished character list in pattern '?[\' of modifier ':M' +.if ${WORDS:M${PATTERN}} != "\\\\ x\\" +. error +.endif + +# [x- Incomplete character list containing an incomplete character +# range, matches only the 'x'. +WORDS= [x- x x- y +# expect+1: warning: Unfinished character range in pattern '[x-' of modifier ':M' +.if ${WORDS:M[x-} != "x" +. error +.endif + +# [^x- Incomplete negated character list containing an incomplete +# character range; matches each word that does not have an 'x' +# at the position of the character list. +# +# XXX: Even matches strings that are longer than a single +# character. +WORDS= [x- x x- y yyyyy +# expect+1: warning: Unfinished character range in pattern '[^x-' of modifier ':M' +.if ${WORDS:M[^x-} != "[x- y yyyyy" +. error +.endif + +# [:] matches never since the ':' starts the next modifier +# expect+3: warning: Unfinished character list in pattern '[' of modifier ':M' +# expect+2: Unknown modifier "]" +# expect+1: Malformed conditional (${ ${:U\:} ${:U\:\:} :L:M[:]} != ":") +.if ${ ${:U\:} ${:U\:\:} :L:M[:]} != ":" +. error +.else +. error +.endif + + +# 7. Historical bugs + +# Before var.c 1.1031 from 2022-08-24, the following expressions caused an +# out-of-bounds read beyond the indirect ':M' modifiers. +.if ${:U:${:UM\\}} # The ':M' pattern need not be unescaped, the +. error # resulting pattern is '\', it never matches +.endif # anything. +.if ${:U:${:UM\\\:\\}} # The ':M' pattern must be unescaped, the +. error # resulting pattern is ':\', it never matches +.endif # anything. |