471,873 Members | 1,767 Online
Bytes | Software Development & Data Engineering Community
Post +

Home Posts Topics Members FAQ

Join Bytes to post your question to a community of 471,873 software developers and data experts.

Accessing high and low bytes of a unsigned short in a struct.

I am having a little trouble getting my union/struct to work correctly.

I am creating a struct that will contain information about the status of
various Z80 cpu registers in an emulator i am trying to write.

some of the registers such as "DE" can be accessed as 16 bit data or the
high and low bytes can be accessed separately. SO, "DE" refers to the
16 bit data, where "D" and "E" refer to the high and low bytes respectively.

Here is what i have so far.

typedef union {
struct {
unsigned char L; //Swapped cause i am little endian
unsigned char H;
} B;
unsigned short W;
} PAIR;

struct Registers {
unsigned char A; // A Register, all is good here.
PAIR DE; // use the above union to emulate.
};

Now, all is ok, when i access the registers like this.

Registers regs1;
regs1.A = 0xFF; //Works as expected
regs1.DE.W = 0xCAFE; //Set 16 bit register

//therefore

regs1.DE.B.H == 0xCA
regs1.DE.B.L == 0xFE

The problem is i find this too ugly. and i would like for the above
code to look more like this and still work exactly the same.

Registers regs1;
regs1.A = 0xFF; //Works as expected
regs1.DE = 0xCAFE; //Set 16 bit register

//therefore

regs1.D == 0xCA
regs1.E == 0xFE
How would i go about defining this union/structure so that i can access
them more gracefully? Does it involve anonymous unions/structures, and
are anonymous unions and structs valid standard C++?

Thanks

James
Jul 23 '05 #1
4 4167

James Roberge wrote:
I am having a little trouble getting my union/struct to work correctly.
I am creating a struct that will contain information about the status of various Z80 cpu registers in an emulator i am trying to write.

some of the registers such as "DE" can be accessed as 16 bit data or the high and low bytes can be accessed separately. SO, "DE" refers to the 16 bit data, where "D" and "E" refer to the high and low bytes respectively.
Here is what i have so far.

typedef union {
struct {
unsigned char L; //Swapped cause i am little endian
unsigned char H;
} B;
unsigned short W;
} PAIR;

struct Registers {
unsigned char A; // A Register, all is good here.
PAIR DE; // use the above union to emulate.
};

Now, all is ok, when i access the registers like this.

Registers regs1;
regs1.A = 0xFF; //Works as expected
regs1.DE.W = 0xCAFE; //Set 16 bit register

//therefore

regs1.DE.B.H == 0xCA
regs1.DE.B.L == 0xFE

The problem is i find this too ugly. and i would like for the above
code to look more like this and still work exactly the same.

Registers regs1;
regs1.A = 0xFF; //Works as expected
regs1.DE = 0xCAFE; //Set 16 bit register

//therefore

regs1.D == 0xCA
regs1.E == 0xFE
How would i go about defining this union/structure so that i can access them more gracefully? Does it involve anonymous unions/structures, and are anonymous unions and structs valid standard C++?

Thanks

James

You could write a wrapper class containing a union and define members
SetHi(unsigned char h) and SetLo(unsigned char l), as well as
corresponding Get methods. An overloaded operator= could be used to
assign unsigned shorts to the register as a whole. Of course, it's a
matter of taste whether you think it is prettier to say
regs1.SetLo(0xCA) than regs1.B.L = 0xCA. Of course you could write much
more sophisticated methods that behave more like you want.

Some people consider unions not proper C++, but this seems like a
proper use for them. You could define a class that stores the data as
two bytes and calculates the conversions to and from a 16 bit word on
the fly, or do it the other way around - store as a word, and have
member functions calculate or manipulate the byte values. I think a
union would do nicely here though.

regards Mark

Jul 23 '05 #2
On Thu, 12 May 2005 06:41:02 +0000, James Roberge wrote:
I am having a little trouble getting my union/struct to work correctly.

I am creating a struct that will contain information about the status of
various Z80 cpu registers in an emulator i am trying to write.

some of the registers such as "DE" can be accessed as 16 bit data or the
high and low bytes can be accessed separately. SO, "DE" refers to the
16 bit data, where "D" and "E" refer to the high and low bytes respectively.

Here is what i have so far.

typedef union {
struct {
unsigned char L; //Swapped cause i am little endian
unsigned char H;
} B;
unsigned short W;
} PAIR;

struct Registers {
unsigned char A; // A Register, all is good here.
PAIR DE; // use the above union to emulate.
};

Now, all is ok, when i access the registers like this.

Registers regs1;
regs1.A = 0xFF; //Works as expected
regs1.DE.W = 0xCAFE; //Set 16 bit register

//therefore

regs1.DE.B.H == 0xCA
regs1.DE.B.L == 0xFE

The problem is i find this too ugly. and i would like for the above
code to look more like this and still work exactly the same.

Registers regs1;
regs1.A = 0xFF; //Works as expected
regs1.DE = 0xCAFE; //Set 16 bit register

//therefore

regs1.D == 0xCA
regs1.E == 0xFE
How would i go about defining this union/structure so that i can access
them more gracefully? Does it involve anonymous unions/structures, and
are anonymous unions and structs valid standard C++?


Seems like you could use an alias (aka "reference"):

typedef union {
struct {
unsigned char L; //Swapped cause i am little endian
unsigned char H;
} B;
unsigned short W;
} PAIR;

struct Registers
{
Registers() : DE(DEReg.W), D(DEReg.B.H), E(DEReg.B.L)
{
}

unsigned char A;
unsigned short& DE;
unsigned char& D;
unsigned char& E;

private:
PAIR DEReg; // Don't want direct access.
};

int main()
{
Registers r;

r.A = 0x71;
r.D = 0xa0;
r.E = 0x65;
return 0;
}

HTH

- Jay
Jul 23 '05 #3
James Roberge wrote:
Now, all is ok, when i access the registers like this.

Registers regs1;
regs1.A = 0xFF; //Works as expected
regs1.DE.W = 0xCAFE; //Set 16 bit register

//therefore

regs1.DE.B.H == 0xCA
regs1.DE.B.L == 0xFE

The problem is i find this too ugly. and i would like for the above
code to look more like this and still work exactly the same.


there are annonymous unions:

struct register {
unsigned short W;
union {
unsigned char h;
unsigned char l;
};
};

you use it:

int main()
{
register x;
x.W = 1; // 16 bit access
x.h = 3; // 8 bit access
x.l = 1;
}

cheers,
Michael

Jul 23 '05 #4
James Roberge wrote:
I am having a little trouble getting my union/struct to work correctly.

[SNIP]

Ok, welli seem to have it working a bit more to my liking. here is what
i have.

typedef unsigned char BYTE;
typedef unsigned short WORD;

typedef union Z80RegisterPair {
struct {
BYTE L;
BYTE H;
};
WORD W;
} PAIR;

struct Z80Registers {
BYTE A, Ax;
PAIR BC, BCx;
PAIR DE, DEx;
PAIR HL, HLx;
};

This allows me to access like this

Z80Registers regs1;

regs1.DE.W = 0xCAFE; //For the 16 bit value.
//therefore
regs1.DE.H == 0xCA;
regs1.DE.L == 0xFE;
Any other suggestions would be great though.

James
Jul 23 '05 #5

This discussion thread is closed

Replies have been disabled for this discussion.

Similar topics

27 posts views Thread by Daniel Lidström | last post: by
2 posts views Thread by Steven T. Hatton | last post: by
19 posts views Thread by Lorenzo J. Lucchini | last post: by
21 posts views Thread by Hallvard B Furuseth | last post: by
33 posts views Thread by Hahnemann | last post: by
6 posts views Thread by ssubbarayan | last post: by
reply views Thread by zermasroor | last post: by

By using Bytes.com and it's services, you agree to our Privacy Policy and Terms of Use.

To disable or enable advertisements and analytics tracking please visit the manage ads & tracking page.