Input Validation Patterns

Table Limits

A small table can keep validation limits close to the code that applies them.

rule table Each row stores the minimum and maximum accepted by one validation rule.
selected rule The selected row drives the same validation function without duplicating branches.

Table Limits

ruleIndex
table_limits.c
Replay: real traced execution (multi-file project)
#include <stdio.h>

int withinLimits(int minValue, int maxValue, int value) {
    if (value < minValue) {
        return 0;
    }
    if (value > maxValue) {
        return 0;
    }
    return 1;
}

int main(void) {
    int ruleIndex = 1;
    int value = 45;
    int limits[3][2] = {
        {0, 10},
        {20, 60},
        {70, 90}
    };

    int minValue = limits[ruleIndex][0];
    int maxValue = limits[ruleIndex][1];
    int ok = withinLimits(minValue, maxValue, value);

    printf("ruleIndex=%d min=%d max=%d value=%d ok=%d\n", ruleIndex, minValue, maxValue, value, ok);
    return 0;
}

#include <stdio.h>

int withinLimits(int minValue, int maxValue, int value) {
    if (value < minValue) {
        return 0;
    }
    if (value > maxValue) {
        return 0;
    }
    return 1;
}

int main(void) {
    int ruleIndex = 0;
    int value = 45;
    int limits[3][2] = {
        {0, 10},
        {20, 60},
        {70, 90}
    };

    int minValue = limits[ruleIndex][0];
    int maxValue = limits[ruleIndex][1];
    int ok = withinLimits(minValue, maxValue, value);

    printf("ruleIndex=%d min=%d max=%d value=%d ok=%d\n", ruleIndex, minValue, maxValue, value, ok);
    return 0;
}

#include <stdio.h>

int withinLimits(int minValue, int maxValue, int value) {
    if (value < minValue) {
        return 0;
    }
    if (value > maxValue) {
        return 0;
    }
    return 1;
}

int main(void) {
    int ruleIndex = 2;
    int value = 45;
    int limits[3][2] = {
        {0, 10},
        {20, 60},
        {70, 90}
    };

    int minValue = limits[ruleIndex][0];
    int maxValue = limits[ruleIndex][1];
    int ok = withinLimits(minValue, maxValue, value);

    printf("ruleIndex=%d min=%d max=%d value=%d ok=%d\n", ruleIndex, minValue, maxValue, value, ok);
    return 0;
}

  1. ruleIndex ← 1, value ← 45, limits ← ⟨addr A⟩, minValue ← 20, maxValue ← 60

    13int main(void) {14    int ruleIndex→ 1 = 1; //@ruleIndex=0, 215    int value→ 45 = 45;16    int limits→ ⟨addr A⟩[3][2] = {17        {0, 10},18        {20, 60},19        {70, 90}20    };2122    int minValue→ 20 = limits[ruleIndex][0]20;23    int maxValue→ 60 = limits[ruleIndex][1]60;24    int ok = withinLimits(minValue20, maxValue60, value45);

  2. int withinLimits(int minValue, int maxValue, int value)

    3int withinLimits(int minValue20, int maxValue60, int value45) {4    if (value < minValue) {5        return 0;6    }7    if (value > maxValue) {8        return 0;9    }10    return 1;11}

  3. ok ← 1

    23    int maxValue = limits[ruleIndex][1];24    int ok→ 1 = withinLimits(minValue20, maxValue60, value45);2526    printf("ruleIndex=%d min=%d max=%d value=%d ok=%d\n", ruleIndex1, minValue20, maxValue60, value45, ok1);27    return 0;28}
    outputruleIndex=1 min=20 max=60 value=45 ok=1

  1. ruleIndex ← 0, value ← 45, limits ← ⟨addr A⟩, minValue ← 0, maxValue ← 10

    13int main(void) {14    int ruleIndex→ 0 = 0;15    int value→ 45 = 45;16    int limits→ ⟨addr A⟩[3][2] = {17        {0, 10},18        {20, 60},19        {70, 90}20    };2122    int minValue→ 0 = limits[ruleIndex][0]0;23    int maxValue→ 10 = limits[ruleIndex][1]10;24    int ok = withinLimits(minValue0, maxValue10, value45);

  2. int withinLimits(int minValue, int maxValue, int value)

    3int withinLimits(int minValue0, int maxValue10, int value45) {4    if (value < minValue) {

  3. if (value > maxValue)

    6}7if (value45 > maxValue10) {8    return 0;9}

  4. ok ← 0

    23    int maxValue = limits[ruleIndex][1];24    int ok→ 0 = withinLimits(minValue0, maxValue10, value45);2526    printf("ruleIndex=%d min=%d max=%d value=%d ok=%d\n", ruleIndex0, minValue0, maxValue10, value45, ok0);27    return 0;28}
    outputruleIndex=0 min=0 max=10 value=45 ok=0

  1. ruleIndex ← 2, value ← 45, limits ← ⟨addr A⟩, minValue ← 70, maxValue ← 90

    13int main(void) {14    int ruleIndex→ 2 = 2;15    int value→ 45 = 45;16    int limits→ ⟨addr A⟩[3][2] = {17        {0, 10},18        {20, 60},19        {70, 90}20    };2122    int minValue→ 70 = limits[ruleIndex][0]70;23    int maxValue→ 90 = limits[ruleIndex][1]90;24    int ok = withinLimits(minValue70, maxValue90, value45);

  2. int withinLimits(int minValue, int maxValue, int value)

    3int withinLimits(int minValue70, int maxValue90, int value45) {4    if (value < minValue) {

  3. if (value < minValue)

    3int withinLimits(int minValue, int maxValue, int value) {4    if (value45 < minValue70) {5        return 0;6    }

  4. ok ← 0

    23    int maxValue = limits[ruleIndex][1];24    int ok→ 0 = withinLimits(minValue70, maxValue90, value45);2526    printf("ruleIndex=%d min=%d max=%d value=%d ok=%d\n", ruleIndex2, minValue70, maxValue90, value45, ok0);27    return 0;28}
    outputruleIndex=2 min=70 max=90 value=45 ok=0