Some issue with pointers

[Marco Trapanese]

Hello,

I need some help to understand what I'm doing :)

I'm writing code for an embedded system and I need to create a navigable
menu system. I'm going to use these structures:

typedef struct {
char *name[2];
int type;
int num_param;
void *ptr;
} menuitem_t;

typedef struct {
char *name[2];
int num_items;
menuitem_t *items;
} menu_t;
The latter defines each menu or submenu with a name, a number of items
and a pointer to the items structure.

The former defines each menu item with a name, a type (see below) the
number of parameters - if any - and finally a generic pointer (see below
again).

In this way I can generate menus of any complexity and very flexible.
The void pointer should point to another menu_t struct if the item leads
to a submenu, to an array if it leads to a parameter list. But it could
also leads to a function if the selection of this item needs an action
to be executed.

Actually I have two questions:

1) I can't cast correctly the void *ptr. Let's say I want to access to:

char *par[] = {"First", "Second"};

ot invoke:

void myfunc();

Please, may you help me to understand how to cast and then to use that
pointer in these cases?

2) It would be nice if I can know the path the user is following. For
example:

mainmenu -seconditem -firstitem

where each of these entities are menu_t structs.
How would you implement such a dynamic path?

Thank you and I apologize for my poor English
Marco / iw2nzm

[Marco Trapanese]

Keith Thompson ha scritto:

Imagine that you work the day shift, and you share an office with
someone who works the night shift. You're never in the office at the
same time. You both have the same address, but you're two different
people. And somebody who wants to visit one of you need to know what
time it is to know which one of you to expect.

Got it.

C99 lets you choose which member you want to initialize, but since you
apparently want to initialize the first one anyway, you don't need
that feature.

mmm, I guess I can't have two items in a union of the same type, can I?
The compiler will know what is the item I'm going to initialize if they
are different. In effect, it doesn't make any sense to use a union with
two fields of the same type.

Marco / iw2nzm

[Ben Bacarisse]

Marco Trapanese <ma************ ******@gmail.co mwrites:

Keith Thompson ha scritto:

>Imagine that you work the day shift, and you share an office with
someone who works the night shift. You're never in the office at the
same time. You both have the same address, but you're two different
people. And somebody who wants to visit one of you need to know what
time it is to know which one of you to expect.

Got it.

>C99 lets you choose which member you want to initialize, but since you
apparently want to initialize the first one anyway, you don't need
that feature.

mmm, I guess I can't have two items in a union of the same type, can I?
The compiler will know what is the item I'm going to initialize if
they are different. In effect, it doesn't make any sense to use a
union with two fields of the same type.

It doesn't work like that -- the type of the expression used to
initialise a union has no effect in choosing which member is
initialised. When a union is initialised, it is the first
member that is chosen unless (in C99 code) a designator is given:

union eg1 {
double d;
int i;
} example1 = { 1.2 };

This initialises the double, and this:

union eg2 {
int i;
double d;
} example2 = { 1.2 };

initialises the int (converting the 1.2 in the process). You can have
several members of the same type but although that would be pointless
it has no effect on the compiler initialises the union.

--
Ben.

[Marco Trapanese]

Ben Bacarisse ha scritto:

union eg1 {
double d;
int i;
} example1 = { 1.2 };

This initialises the double, and this:

union eg2 {
int i;
double d;
} example2 = { 1.2 };

initialises the int (converting the 1.2 in the process). You can have
several members of the same type but although that would be pointless
it has no effect on the compiler initialises the union.

I'm feeling a bit stupid but I don't understand the whole thing.
Why in my code I can initialize the function pointer that is the second
element?

Is it related to C90/C99 stuff?

Marco / iw2nzm

[Marco Trapanese]

Ben Bacarisse ha scritto:

typedef struct {
char *name[2];
int type;
union {
void *vp;
void (*fp)();
struct menu_t *items;
} ptr;
} menu_t;

Hello again, this time I'm trying to initialize the union with the third
entry, that is another menu_t struct.

const menu_t mn_menu = {
{"Main Menu", "Menu"},
MIT_SUBMENU,
{{mn_setup, mn_about}}
};

Where mn_setup and mn_about are other two const structs previously
defined. The compilers complains about type mismatch. I thought I was
able to initialize this damn unions but I was wrong.

It works with an array, it works with a function pointer why doesn't
work with a struct?

Marco / iw2nzm

[Keith Thompson]

Marco Trapanese <ma************ ******@gmail.co mwrites:

Ben Bacarisse ha scritto:

union eg1 {
double d;
int i;
} example1 = { 1.2 };
This initialises the double, and this:
union eg2 {
int i;
double d;
} example2 = { 1.2 };
initialises the int (converting the 1.2 in the process). You can
have
several members of the same type but although that would be pointless
it has no effect on the compiler initialises the union.

I'm feeling a bit stupid but I don't understand the whole thing.
Why in my code I can initialize the function pointer that is the
second element?

Is it related to C90/C99 stuff?

I had to go back up the thread to see what you're talking about:

union {
void *vp;
void (*fp)();
struct menu *items;
} ptr;

This was part of a larger structure. You initialized ptr to {mypar},
where mypar is the name of an array of char.

The result of evaluating ``mypar'', of type char*, was implicitly
converted to void* and used to initialize ptr.vp. (This indirectly
assigns a value to the space occupied by ptr.fp and ptr.items, but
accessing those members is unsafe.)

Any initialization of this union, unless you use a C99 designated
initializer, is going to initialize ptr.vp.

If this doesn't match your understanding, can you post a small example
that illustrates the issue?

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[Ben Bacarisse]

Marco Trapanese <ma************ ******@gmail.co mwrites:

Ben Bacarisse ha scritto:

>typedef struct {
char *name[2];
int type;
union {
void *vp;
void (*fp)();
struct menu_t *items;
} ptr;
} menu_t;

Hello again, this time I'm trying to initialize the union with the
third entry,

You can't. You don't have a C99 compiler so any initialiser you use
will be used to initialise the first union member. Always the first.
OK?

In fact, given that you can't use the union in the way it is intended
(C99 designated initialisers) I advice you don't use a union. It
would be fine if you set the union at runtime, but bending the type
rules by initialising always the first element is probably more
problematic than converting everything to and from a void *. There
are machines on which this breaks:

int i;

union {
void *vp;
int *ip;
} u = { &i };

followed by an access of, say, u.ip[0]. It may be best just to force
the conversion to and from a single void * all the time.

that is another menu_t struct.

const menu_t mn_menu = {
{"Main Menu", "Menu"},
MIT_SUBMENU,
{{mn_setup, mn_about}}
};

Where mn_setup and mn_about are other two const structs previously
defined. The compilers complains about type mismatch. I thought I was
able to initialize this damn unions but I was wrong.

You can, but you need a pointer, not another set of {}s. You really
need to go over this in a C textbook -- you can't learn this by trial
and error. For the record, you do it like this:

struct menu_t submenuitem = {mn_setup, mn_about};

const menu_t mn_menu = {
{"Main Menu", "Menu"},
MIT_SUBMENU,
&submenuitem
};

You'll be thrilled that C99 can do this directly with a compound
literal like this:

const menu_t mn_menu = {
{"Main Menu", "Menu"},
MIT_SUBMENU,
&(struct menu_t){mn_setu p, mn_about};
};

Ask you compiler vendor to support C99!

It works with an array, it works with a function pointer why doesn't
work with a struct?

Because you need a pointer and both arrays and functions get converted
to pointers in this context -- structs don't.

--
Ben.

[Barry Schwarz]

On Tue, 01 Jul 2008 17:52:15 +0200, Marco Trapanese
<ma************ ******@gmail.co mwrote:

>Ben Bacarisse ha scritto:

>(1) Use C99 designated initialiser syntax:

{ .fp = myfunc }

This one doesn't work. I bet Dynamic C is not C99 compliant.

>(2) Let the compiler complain about the type-mismatch (if it works):

{ myfunc }

(3) Convert to void * (again, if that is permitted):

{ (void *)myfunc }

These works, or at least the compiler says nothing about.

Now I have to verify that myfunc is actually assigned to fp and not to vp.

Since fp and vp overlap (occupy the same memory), how do propose to
accomplish this?
Remove del for email

[Barry Schwarz]

On Tue, 01 Jul 2008 19:56:49 +0200, Marco Trapanese
<ma************ ******@gmail.co mwrote:

>Ben Bacarisse ha scritto:

>union eg1 {
double d;
int i;
} example1 = { 1.2 };

This initialises the double, and this:

union eg2 {
int i;
double d;
} example2 = { 1.2 };

initialises the int (converting the 1.2 in the process). You can have
several members of the same type but although that would be pointless
it has no effect on the compiler initialises the union.

I'm feeling a bit stupid but I don't understand the whole thing.
Why in my code I can initialize the function pointer that is the second
element?

You can't. You are initializing the void* that occupies the same
space as your function pointer. You also don't know if the void*
representation is acceptable as a function pointer.

>
Is it related to C90/C99 stuff?

No. The only difference between C90 and C99 is that in C99 you can
specify which member of the union you want to initialize.
Remove del for email

[Marco Trapanese]

Ben Bacarisse ha scritto:

You can't. You don't have a C99 compiler so any initialiser you use
will be used to initialise the first union member. Always the first.
OK?

Ok.
I was confused because in your first post on this thread you wrote:

I can't see why you'd have two. I'd merge them like this:

typedef struct menu {
char *name[2];
int type;
int num_param;
union {
void *vp;
struct menu *items;
} ptr;
} menu_t;

So I assumed I can use (and initialize) both the void pointer and the
menu_t struct.

So I must return to use two different structs.

In fact, given that you can't use the union in the way it is intended
(C99 designated initialisers) I advice you don't use a union. It
would be fine if you set the union at runtime,

Yeah, but this is code space consuming. It could be done for few
entries, but it isn't so elegant ;-)

but bending the type
rules by initialising always the first element is probably more
problematic than converting everything to and from a void *. There
are machines on which this breaks:

int i;

union {
void *vp;
int *ip;
} u = { &i };

followed by an access of, say, u.ip[0]. It may be best just to force
the conversion to and from a single void * all the time.

Ok, but given that I need three different types of pointers (generic
void, function, struct) I'll set them at runtime or it will be better to
separate each one - at the cost of more memory of course.

You can, but you need a pointer, not another set of {}s. You really
need to go over this in a C textbook -- you can't learn this by trial
and error.

I'll do that.

Ask you compiler vendor to support C99!

Perhaps the pay version of the compiler does, but it costs several
thousand dollars...

Because you need a pointer and both arrays and functions get converted
to pointers in this context -- structs don't.

Ok, these limitations are beyond my knowledge. I search another way to
build my menu system.

I thank you very much for your patience
Marco / iw2nzm

[Ben Bacarisse]

Marco Trapanese <ma************ ******@gmail.co mwrites:

Ben Bacarisse ha scritto:

>You can't. You don't have a C99 compiler so any initialiser you use
will be used to initialise the first union member. Always the first.
OK?

Ok.
I was confused because in your first post on this thread you wrote:

>I can't see why you'd have two. I'd merge them like this:

typedef struct menu {
char *name[2];
int type;
int num_param;
union {
void *vp;
struct menu *items;
} ptr;
} menu_t;

So I assumed I can use (and initialize) both the void pointer and the
menu_t struct.

So I must return to use two different structs.

Oh dear. We've gone off the rails here! Your code will get very
messy if you have two menu structs just because at some point you
need one of two types of pointer in it. It will get worse if you have
three types, and so on.

If you had C99, a union is the simplest way to build your menus using
static initialisers -- that is why I suggested it. You don't have C99
so your options are:

(a) One menu struct with a data pointer of type void *. The only down
side of this if that you keep having to convert between the pointer
types. This is not hard and has the advantage of being about as
portable you can get. You can continue to use static initialisation.

(b) Use a union to avoid some of the type conversions. This can have
portability problems because some type conversion are essential (on
some systems). Had I know that you wanted to use static
initialisation for all the menus and that you did not have C99, I
would not have suggested a union. Just ditch that idea.

I *still* would have suggested having only one menu struct -- with a
void * data member.

<snip>

Ok, but given that I need three different types of pointers (generic
void, function, struct) I'll set them at runtime or it will be better
to separate each one - at the cost of more memory of course.

Your choice. You can use a struct with just a void * and use static
initialisation, or a struct with union and use some run-time member
setting.

<snip>

Ok, these limitations are beyond my knowledge. I search another way to
build my menu system.

Just forget I suggested a union! Keep the idea of simplifying it to
one structure; keep the static initialisation. You can get the best
of all worlds that way. Some people use macros to wrap up the casts:

typedef struct menu {
char *name[2];
int type;
int num_param;
void *data;
} menu_t;

#define SUBMENU_PTR(m_p tr) ((menu_t *)(m_ptr)->data)
#define STRINGS_PTR(m_p tr) ((char **)(m_ptr)->data)
#define ACTION_PTR(m_pt r) ((menu_function *)(m_ptr)->data)

--
Ben.