explicitly setting and unsetting some pins of a port - arduino

Question

I have two shields which conveniently (ie no pin clash) share a port and I need to be able to manipulate just SOME pins on the port. But I cannot be sure if I am manipulating pins on or off, I just want to set them arbitrarily as the need arrises, ie, in one operation I may be turning some pins on and some off.
I do know:
PORTX |= B11110000 // turns on bits 4-7
PORTX &= B11000011 // turns off bits 2-5
PORTX ^= B00111111 // toggles bits 0-5
My challenge has been to turn on AND off only some pins, leaving others unchanged.
I have achieved the desired result, and in as far as I think I have done it in a safe way, I want to confirm it is in fact SAFE, and have I gone about it the right (best) way, or can I achieve this a much simpler way.
First, I am using PORTD, pins 4-7. I set those pins as outputs and then set them all as low to ensure my program starts with them (4x relays) all off.
void initRelays(){
RELAYDDR |= B11110000;
RELAYPORT &= ~RELAYDDR;
}
I believe tis will set pins 4-7 off without modifying the lower bits due to the bitwise AND with ZERO. I believe this will leave bit 0-3 as they were previously set.
Inverting this value and ANDing it with the existing port value, will ensure those pins are off and leaves the other bits unchanged. I'm sure this line is not required, I am having it here for safety sake :)
I have left the comments in the below code in order for you to try and understand what I am doing.
void relayPush(byte stack){
// stack has bit 1 to relay 1 (pin 4), thru bit 4 to relay 4 (pin 7)
// take stack and isolate the four bottom bits (the information we want to convert)
stack &= B00001111; // (1) I think this line is probably not required
// now shift to the position we need
stack <<= 4; // (2)
// OR the new stack with the PORT
// (this turns on any relays set in stack)
RELAYPORT |= stack; // (3)
// we need to NOT modify the bottom bits of the port
// mark those with a '1' so as to not turn them off
// bottom of stack mask = 0x0f
// XOR stack and mask
stack ^= 0x0f; // (4)
// AND new stack and port to turn off appropriate relays
RELAYPORT &= stack; // (5)
}
I know I have done it in two PORT operations, and I could make this one by using a temp variable, that's not of a major concern since it's only turning everything required to be on in the first instance and then turning everything off thats required in the second instance.
Have a missed a simpler way of doing this?
edit: I have had a look at what #Ignacio has said about changing the final operations and this is what I've come up with:
0011 0011 current port assignment
xxxx 1010 current stack assignment (we only want the lower nibble)
1010 0011 desired result
0011 0011 current port
xxxx 1010 current stack
0000 1111 step 1 - apply this mask to stack
0000 1010 resultant stack
1010 0000 step 2 - stack << 4
0011 0011 PORT
1010 0000 STACK
1010 0011 step 3 - resultant PORT (port OR stack)
0000 1111 (MASK for step 4)
1010 0000 stack at step 4
1010 1111 step 4 - resultant stack (mask XOR stack)
1010 0011 port from step 3
1010 1111 stack from step 4
1010 0011 port AND stack (desired result)
/// changing steps 4 and 5 to drop XOR, and applying complement
1010 0000 stack prior to step 4
0101 1111 ~stack
1010 0011 port from step 3
0000 0011 stack AND port (not the desired result)
summary:
XOR is needed to populate the bottom nibble to B00001111 and leaving top nibble unchanged. Since we know the bottom nibble is ZERO (from earlier shift), we could simply add 0x0F. XOR achieves the same thing.
For the final AND operation, we need to switch off top nibble ZEROs. Hence, no complement.
New idea from my comment to #Ignacio:
0011 0011 current port
xxxx 1010 current stack
1010 0000 shifted stack
0000 0011 temp = port AND 0x0F
1010 0011 stack OR temp (desired result)
Sorry for the long post, but I think that is a better solution, although it does use another variable.

Answer 1

Your and operation with RELAYPORT clears the upper 4 bits. You should not perform the earlier xor operation and instead should just and it with the complement.
RELAYPORT &= ~stack;

Answer 2

Some thoughts ... based on my experience with megaAVR's (esp. AT90USB1287)
When you split a port and operate some bits as input and some bits as output, I recommend to take extra care when writing the whole output port. There are good BIT instructions in the AVR. If you want to write a complete port, keep in mind that writing to bits configured as input does have an effect, namely to activate (PORTxy<-1) or deactivate (PORTxy<-0) internal pullup resistors - so depending on your hardware you have to choose what to use for the "unwanted" bits (with another dependency on MCUCR(PUD). In other words, the (to-be-ignored) input bits in a register you write out can't contain any random values but exactly the ones that support the configuration of the internal pullups. Insofar it's not usefull to read in a PINx before writing (parts) back to the port. (This was used on older processors with port hardware less elaborated than the AVR processors)
When writing out a PORTx insert a NOP before reading back PINx (due to the internal latch).
In initRelays() I'd use a constant, because it compiles faster (single instruction) rather than a function of RELAYDDR which involves reading back RELAYDDR into a register and writing the register to RELAYPORT.