The Weird and The Wonderful

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);
    }