OK. Let me try again. (And, PLEASE use code tags surrounding the contents of your input and output files.)

I do not see any difference in your sample output between condition Equals and condition Contains. If the string listed in the 2nd field in the Rules file appears in the field in the Input file field with the heading named by the first column in your Rules file, that string is replaced by the string in the 4th field in your Rules file. You said:
but when field1 is XX31 (which is not equal to XX), your desired output changed the XX to rc anyway??? And you say that 'Contains' is a "pattern match", but don't define what pattern matching rules are to be used. (Is it shell pattern matching, filename pattern matching, basic regular expression matching, extended regular expression matching, or something else?) In the possible solution below, I assume that anytime the string in the 2nd field in the Rules file is found in the specified field in the Input file it will be replaced by the string in the 4th field in the Rules file. This matches the behavior shown given your Input file, Rules file, and Output file even though it doesn't match your description. Since your examples do not show any difference in the expected output between Equals and Contains, the possible solution below ignores the 3rd field in the Rules file.

You say that only Equals and Contains appear in the 3rd field in the Rules file. But, your sample Rules file 3rd field is contains on three lines and is never Contains (with an upper case C). But, since the possible solution below ignores the 3rd field in the Rules file, it doesn't make any difference.

The following produces the Output file you specify when given the Input and Rules files you specified, except for two issues:There are corresponding differences in what this script produces in the Reject file compared to what you said should appear in the Reject file.

Anyway, play around with the following to see how it works:

Code:

#!/bin/ksh
rejectfile="Reject"
awk -F "|" -v rejf="$rejectfile" 'BEGIN {OFS = "|"}
FNR==NR{
if(debug)printf("# rules record read: %s\n", $0)
        if(FNR == 1) next #skip Rules file header.
        ruleF[++rc] = $1
        ruleS[rc] = $2
        cnt = gsub(/./, "[[.&.]]", ruleS[rc])
        ruleC[rc] = $3
        ruleR[rc] = $4
        gsub(/\\/, "\\", ruleR[rc]);
        gsub(/[.&.]/, "\\\\&", ruleR[rc])
if(debug)printf("ruleF[%d]=%s, ruleS[%d]=%s (%d elements), ruleC[%d]=%s, ruleR[%d]=\"%s\"\n",
rc,ruleF[rc],rc,ruleS[rc],cnt,rc,ruleC[rc],rc,ruleR[rc])
        next
}
FNR==1{ # Process input file header
if(debug)printf("@ input header read:\n")
        for(i = 1; i <= NF; i++) {
                mF[$i] = i
if(debug)printf("@ mF[%s]=%d\n",$i,i)
        }
        fc = NF
        print
        print > rejf
        next
}
{       cc = 0 # of changes made to this line
        o0 = $0
if(debug)printf("@ input record read: %s\n", $0);
        for(i = 1; i <= rc; i++) {
if(debug)printf("@ f:%s(%d): s/%s/%s/\n", ruleF[i], mF[ruleF[i]], ruleS[i], ruleR[i])
                if((cnt = sub(ruleS[i], ruleR[i], $mF[ruleF[i]]))) {
                        cc += cnt
if(debug)printf("@ %s changed to \"%s\"\n", ruleF[i], $mF[ruleF[i]])
                }
        }
        if(cc) print o0 > rejf
        print
}' Rules Input > Output

Note that if you change the line:

Code:

awk -F "|" -v rejf="$rejectfile" 'BEGIN {OFS = "|"}

to:

Code:

awk -F "|" -v rejf="$rejectfile" 'BEGIN {OFS = "|"; debug = 1}

you'll get lots of debugging data in Outfile showing how it evaluates input lines, how it transforms search and replace patterns into extended regular expressions and replacement patterns, respectively, and which rules cause transformations of input fields.

If you want to make "Equals" behave as you described it (instead of as your expected Output file contents demonstrate, you just need to add ERE anchoring chracters to the start and end of "ruleS[x]" after the gsub() call converts each character to be matched into its corresponding collating symbol matching expression (which is used to avoid having "special" characters in EREs being treated specially).