Extract pattern and word following it from a Makefile variable - filter

Question

I have a Makefile question and I can’t seem to figure this out.
I have the following variable in my Makefile
AA := word1 word2 word3 word4 word5
AAA = $(patsubst word2% $(word 1, %), word22, $(AA))
What I want AAA to be is
AAA := word1 word22 word4 word5
I want to search for a known pattern word2 and the unknown word following it and replace it with word22. Unfortunately I don’t know word3 before hand all I know is I need to replace word2 and the next word following it. Is there a clever way to do this?. I thought of using $filter and $filter-out Makefile functions but don't know how to extract the pattern and the word(s) following it.
I would also like a variation where I would replace word2 with word22 and insert word33 after the word following word2. So AAA would look like:
AAA := word1 word22 word3 word33 word4 word5
Thanks for your help. I was trying to do this without invoking shell and sed

Answer 1

The built-in functions of make do not allow for complex string process. In particular, the patterns are limited using '%' as wildcard. Given this limitations, few choices:
Use external program (sed, etc) to perform the translation
Use the built-in guile (if compiled into make).
Complex: use foreach to find the match, the and remove the following word. Unfortunately, this very challenging as make does not ahve any arithmetic/logic.
The simplest approach is to use external program (sed, awk, perl) to perform translation. Solution using 'sed'
AA := word1 word2 word3 word4 word5
P := word2
AAA = $(shell echo ${AA} | sed -e 's/$P *[^ ]*/word22/')
t:
echo "AAA=${AAA}"
The output is: AAA=word1 word22 word4 word5

Answer 2

For make-only solution, consider the following, which is using foreach to perform the substitution/token removal as needed
AA := word1 word2 word3 word4 word5
P := word2
R := word22
PREV=
# Loop with X over items
# Replace P with R
# Ignore word following P
# Set PREV=$X
DDD := $(foreach X, ${AA}, $(if $(findstring $X,$P),$R,$(if $(findstring $(PREV),$P),,$X)) $(eval PREV=$X))
x:
echo 'C=${DDD}'

Answer 3

I take your comment
Based on a command line switch to make I am switching compilers so the arguments passed to compiler 1 will need to be altered for compiler 2.
as the true problem you want to solve. You can try to solve it with ad-hoc programming, either in make or with the help of command line tools like sed. The former has the problem of being quite hard to comprehend after some time or with the code in the hands of a different programmer, the latter can be equally involved and needs those tools installed. The third option is to use gmtt which is a GNUmake library written for such build configuration tasks:
include gmtt/gmtt.mk
# Define a table which selects the executable depending on cmd-line parameter 1
define COMPILER_EXECUTABLE
2
foo gcc
bar clang
baz arm-none-eabi-gcc
endef
# Additional command line args depending on compiler
define ADDITIONAL_CFLAGS
2
gcc -E
gcc -O2
clang -DUSE_CLANG
arm-none-eabi-gcc -mcpu=cortex-m7
arm-none-eabi-gcc -mthumb
endef
# Select column 2 from COMPILER_EXECUTABLE where cmd-line parameter 1 == first column
CC := $(call select,2,$(COMPILER_EXECUTABLE),$$(call str-eq,$(CMD_LINE_PARAM_1),$$1))
# Fetch additional CFLAGS
CFLAGS += $(call select,2,$(ADDITIONAL_CFLAGS),$$(call str-eq,$(CC),$$1))
$(info compiler: $(CC))
$(info CFLAGS: $(CFLAGS))
Testing it:
make CMD_LINE_PARAM_1=foo
Output:
compiler: gcc
CFLAGS: -E -O2
The rationale is to simply save the time for your first attempt - if you lay down your information in tabular format, nothing is lost if you later want to switch to a build method better fitting your software process. The interface to the select (and most other gmtt functions) aren't particularly complicated, neither to comprehend nor to replicate in another language.