The Weird and The Wonderful

#define SetPinA( pin, shift ) \
      ( pin > 31 ) ? ( ( pins_h >> ( ( pin - 32 ) & 31 ) & 1 ) << shift ) : \
                     ( ( pins_l >> pin ) & 1 << shift )

if( has_data_low_pins && has_data_high_pins )
{
   b |= SetPinA( pin_d1, 1 );
   b |= SetPinA( pin_d2, 2 );
   b |= SetPinA( pin_d3, 3 );
   b |= SetPinA( pin_d4, 4 );
   b |= SetPinA( pin_d5, 5 );
   b |= SetPinA( pin_d6, 6 );
   b |= SetPinA( pin_d7, 7 );
}

honey the codewitch wrote:

I am a stickler about namespace polution

jschell wrote:

The form suggested by the other response seems much more maintainable.

honey the codewitch wrote:

so I'm confused as to how you could say it was more maintainable having never seen it.

honey the codewitch wrote:

Furthermore, it is not feasible to limit said preprocessor macros to a single file as doing so would increase maintenance since several processors with their own instructions are presented, each in its own header. To combine them would create a monolithic header that included every single build target. No.

honey the codewitch wrote:

Finally, unit testing this is not feasible, as I don't have the money to set up the hardware array necessary to unit test this across all build targets

honey the codewitch wrote:

I did not write it that way, and I'm not rewriting six files of macros.

honey the codewitch wrote:

the *first* time I do it in the code.

M.D.V.

If something has a solution... Why do we have to worry about?. If it has no solution... For what reason do we have to worry about?
Help me to understand what I'm saying, and I'll explain it better to you
Rating helpful answers is nice, but saying thanks can be even nicer.

if(pin_d0>31) {
    b = (pins_h>>(pin_d0&31))&1;
} else if(pin_d0>-1) {
    b = (pins_l>>pin_d0)&1;
} else {
    b=0;
}

const int NUM_BUS_BITS = 8;     // Dealing with an eight bit bus
const int NUM_GPIO_PINS = 40;   // ESP32 has GPIOs 0 to 39

// Last read state of the GPIO bus
static uint32_t sGPIOLow, sGPIOHigh;

// Map data bus to GPIO bits
static struct
{
    uint32_t* pSource;          // Which GPIO variable to use
    unsigned shift;             // Shift to apply for this bit
} sDataMap[NUM_BUS_BITS];

// Initialise mapping between input data bit and GPIO pin - call for each data bit prior to readInput()
static void mapInputPin(unsigned dataBit, unsigned gpioPin)
{
    if (dataBit < NUM_BUS_BITS && gpioPin < NUM_GPIO_PINS)
    {
        sDataMap[dataBit].pSource = gpioPin >= 32 ? &sGPIOHigh : &sGPIOLow;
        sDataMap[dataBit].shift = gpioPin & 31;
    }
}

// Read our eight bit bus value from the appropriate GPIO pins
static uint8_t readInput(void)
{
    // Read the hardware bus (the need for 3x reads should be investigated)
    sGPIOLow = gpio_input_get();
    sGPIOLow = gpio_input_get();
    sGPIOLow = gpio_input_get();
    sGPIOHigh = gpio_input_get_high();

    // Decode from GPIO to eight bit bus
    uint8_t dataRead = 0;
    dataRead |= (((*sDataMap[0].pSource) >> sDataMap[0].shift) & 1) << 0;
    dataRead |= (((*sDataMap[1].pSource) >> sDataMap[1].shift) & 1) << 1;
    dataRead |= (((*sDataMap[2].pSource) >> sDataMap[2].shift) & 1) << 2;
    dataRead |= (((*sDataMap[3].pSource) >> sDataMap[3].shift) & 1) << 3;
    dataRead |= (((*sDataMap[4].pSource) >> sDataMap[4].shift) & 1) << 4;
    dataRead |= (((*sDataMap[5].pSource) >> sDataMap[5].shift) & 1) << 5;
    dataRead |= (((*sDataMap[6].pSource) >> sDataMap[6].shift) & 1) << 6;
    dataRead |= (((*sDataMap[7].pSource) >> sDataMap[7].shift) & 1) << 7;

    return dataRead;
}

int main(void)
{
    // Initialise mapping for GPIO allocation
    // (Use defines or named constants for a real implementation)
    mapInputPin(0, 4);
    mapInputPin(1, 5);
    mapInputPin(2, 6);
    mapInputPin(3, 7);
    mapInputPin(4, 36);
    mapInputPin(5, 37);
    mapInputPin(6, 38);
    mapInputPin(7, 39);

    // Read input
    uint8_t readData = readInput();

    return readData;
}

// Data pin GPIO allocation - purely an example
const unsigned pin_d0 = 4;
const unsigned pin_d1 = 5;
const unsigned pin_d2 = 6;
const unsigned pin_d3 = 7;
const unsigned pin_d4 = 36;
const unsigned pin_d5 = 37;
const unsigned pin_d6 = 38;
const unsigned pin_d7 = 39;

// Read our eight bit bus value from the appropriate GPIO pins
static uint8_t readInput(void)
{
    // Add delay here

    // Read the hardware bus
    uint32_t GPIOLow = gpio_input_get();
    uint32_t GPIOHigh = gpio_input_get_high();

    // Decode from GPIO to eight bit bus
    uint8_t dataRead = 0;
    dataRead |= (((pin_d0 > 31 ? GPIOHigh : GPIOLow) >> (pin_d0 & 31)) & 1) << 0;
    dataRead |= (((pin_d1 > 31 ? GPIOHigh : GPIOLow) >> (pin_d1 & 31)) & 1) << 1;
    dataRead |= (((pin_d2 > 31 ? GPIOHigh : GPIOLow) >> (pin_d2 & 31)) & 1) << 2;
    dataRead |= (((pin_d3 > 31 ? GPIOHigh : GPIOLow) >> (pin_d3 & 31)) & 1) << 3;
    dataRead |= (((pin_d4 > 31 ? GPIOHigh : GPIOLow) >> (pin_d4 & 31)) & 1) << 4;
    dataRead |= (((pin_d5 > 31 ? GPIOHigh : GPIOLow) >> (pin_d5 & 31)) & 1) << 5;
    dataRead |= (((pin_d6 > 31 ? GPIOHigh : GPIOLow) >> (pin_d6 & 31)) & 1) << 6;
    dataRead |= (((pin_d7 > 31 ? GPIOHigh : GPIOLow) >> (pin_d7 & 31)) & 1) << 7;

    return dataRead;
}

if(pin_d1>31) {
        b |= (((pins_h>>((pin_d1-32)&31))&1)<<1);
    } else if(pin_d1>-1) {
        b |= (((pins_l>>(pin_d1))&1)<<1);
    }