I decided just to code a table. Here is the basics:
SLL R15,2
L R1,=A(@MASKS)
LA R1,0(R15,R1)
MVC WF_MASK,0(R15)
MASKALL DC X'FF'
MASK0 DC X'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00'
DC X'00000000000000000000000000000000'
MASK1 DC X'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF80'
DC X'00000000000000000000000000000000'
MASK2 DC X'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC0'
DC X'00000000000000000000000000000000'
MASK3 DC X'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE0'
DC X'00000000000000000000000000000000'
MASK4 DC X'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0'
DC X'00000000000000000000000000000000'
MASK5 DC X'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF8'
DC X'00000000000000000000000000000000'
MASK6 DC X'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC'
DC X'00000000000000000000000000000000'
MASK7 DC X'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE'
DC X'00000000000000000000000000000000'
@MASKS DS 0D
DC A(MASK0+15),A(MASK1+15),A(MASK2+15),A(MASK3+15)
DC A(MASK4+15),A(MASK5+15),A(MASK6+15),A(MASK7+15)
DC A(MASK0+14),A(MASK1+14),A(MASK2+14),A(MASK3+14)
DC A(MASK4+14),A(MASK5+14),A(MASK6+14),A(MASK7+14)
DC A(MASK0+13),A(MASK1+13),A(MASK2+13),A(MASK3+13)
DC A(MASK4+13),A(MASK5+13),A(MASK6+13),A(MASK7+13)
DC A(MASK0+12),A(MASK1+12),A(MASK2+12),A(MASK3+12)
DC A(MASK4+12),A(MASK5+12),A(MASK6+12),A(MASK7+12)
DC A(MASK0+11),A(MASK1+11),A(MASK2+11),A(MASK3+11)
DC A(MASK4+11),A(MASK5+11),A(MASK6+11),A(MASK7+11)
DC A(MASK0+10),A(MASK1+10),A(MASK2+10),A(MASK3+10)
DC A(MASK4+10),A(MASK5+10),A(MASK6+10),A(MASK7+10)
DC A(MASK0+09),A(MASK1+09),A(MASK2+09),A(MASK3+09)
DC A(MASK4+09),A(MASK5+09),A(MASK6+09),A(MASK7+09)
DC A(MASK0+08),A(MASK1+08),A(MASK2+08),A(MASK3+08)
DC A(MASK4+08),A(MASK5+08),A(MASK6+08),A(MASK7+08)
DC A(MASK0+07),A(MASK1+07),A(MASK2+07),A(MASK3+07)
DC A(MASK4+07),A(MASK5+07),A(MASK6+07),A(MASK7+07)
DC A(MASK0+06),A(MASK1+06),A(MASK2+06),A(MASK3+06)
DC A(MASK4+06),A(MASK5+06),A(MASK6+06),A(MASK7+06)
DC A(MASK0+05),A(MASK1+05),A(MASK2+05),A(MASK3+05)
DC A(MASK4+05),A(MASK5+05),A(MASK6+05),A(MASK7+05)
DC A(MASK0+04),A(MASK1+04),A(MASK2+04),A(MASK3+04)
DC A(MASK4+04),A(MASK5+04),A(MASK6+04),A(MASK7+04)
DC A(MASK0+03),A(MASK1+03),A(MASK2+03),A(MASK3+03)
DC A(MASK4+03),A(MASK5+03),A(MASK6+03),A(MASK7+03)
DC A(MASK0+02),A(MASK1+02),A(MASK2+02),A(MASK3+02)
DC A(MASK4+02),A(MASK5+02),A(MASK6+02),A(MASK7+02)
DC A(MASK0+01),A(MASK1+01),A(MASK2+01),A(MASK3+01)
DC A(MASK4+01),A(MASK5+01),A(MASK6+01),A(MASK7+01)
DC A(MASK0+00),A(MASK1+00),A(MASK2+00),A(MASK3+00)
DC A(MASK4+00),A(MASK5+00),A(MASK6+00),A(MASK7+00)
DC A(MASKALL)
DC X'FFFFFFFF'
Tony Thigpen
-----Original Message -----
From: robin
Sent: 05/29/2012 08:00 AM
From: Tony Thigpen
Sent: Tuesday, 29 May 2012 12:51 PM
I am working with some IPv6 addresses that are 128 bits long. The input
to the program is an ip name or address and the number of high bits that
I need to use for a compare against another ip address.
So, I want to create run time routine to build the a 16 byte 'and' bit
field based on the input number of bits. (I will then 'and' both
addresses and then use a simple CLC.)
A good way is to determine the bit start position.
Put 8 bits in a GPR. If shift is 1 thru 7, shift right the required no.
of bits.
Then store that.
For the end byte, do the same, only shift left.
For the bytes between the initial byte and end byte,
store zero or more characters (each of 8 one-bits).
Although a table built at compile time might be a reasonable solution,
How so? You say that the number of bits is input -- i.e. not a
compile-time value.
I thought this would be a good time to learn a new trick if someone has
one they can share.
