Hello everyone,

I create below code after reading some reference code. What is 'gSaveMap' in the main function?
The print message is:
50cff730

I know it is initialization of a doubly list. 'gSaveMap' is just a garbage of a random list head address?

Thanks in advance

///////////////////
#include <stdio.h>

#define INITIALIZE_LIST_HEAD_VAR(ListHead) {&(ListHead), &(ListHead)}

typedef struct _LIST_ENTRY LIST_ENTRY;

struct _LIST_ENTRY {
LIST_ENTRY* ForwardLink;
LIST_ENTRY* BackLink;
};

LIST_ENTRY gSaveMap = INITIALIZE_LIST_HEAD_VAR(gSaveMap);

int main()
{ printf("hello world\n");
printf("gSaveMap=%x\n", gSaveMap);
return 0;
}

On Thu, 25 Nov 2021 09:52:52 -0800, fl wrote:

> Hello everyone,
>
> I create below code after reading some reference code. What is
> 'gSaveMap' in the main function?
> The print message is:
> 50cff730
>
> I know it is initialization of a doubly list. 'gSaveMap' is just a
> garbage of a random list head address?
>
>
> Thanks in advance

Order changed for readability...

> ///////////////////
> #include <stdio.h>

> typedef struct _LIST_ENTRY LIST_ENTRY;

Defines a type alias "LIST_ENTRY" that represents a struct _LIST_ENTRY.
So, where-ever the compiler encounters a LIST_ENTRY type, it interprets
it as a
struct _LIST_ENTRY
type

> struct _LIST_ENTRY {
> LIST_ENTRY* ForwardLink; LIST_ENTRY* BackLink;
> };

Defines a
struct _LIST_ENTRY with members ForwardLink and BackLink

ForwardLink is of type LIST_ENTRY *, which, because of the
typedef, is really struct _LIST_ENTRY.

BackLink is of type LIST_ENTRY *, which, because of the
typedef, is really struct _LIST_ENTRY.
So, in all, the definition of
struct _LIST_ENTRY
contains
struct _LIST_ENTRY *ForwardLink;
and
struct _LIST_ENTRY *BackLink;

> #define INITIALIZE_LIST_HEAD_VAR(ListHead) {&(ListHead),&(ListHead)}

Macro definition for a string of parameterized tokens. Note that ListHead
is a placeholder variable, such that
INITIALIZE_LIST_HEAD_VAR(x)
will generate tokens
{ & ( x ) , & ( x ) }
while
INITIALIZE_LIST_HEAD_VAR(mylist)
will generate tokens
{ & ( mylist ) , & ( mylist ) }

> LIST_ENTRY gSaveMap = INITIALIZE_LIST_HEAD_VAR(gSaveMap);

Defines a
struct _LIST_ENTRY
called
gSaveMap
and initializes it with the pair of values
{ &(gSaveMap),&(gSaveMap) }

>
> int main()
> {
> printf("hello world\n"); printf("gSaveMap=%x\n", gSaveMap);
> return 0;
> }

--
Lew Pitcher
"In Skills, We Trust"

fl <rxjwg98@gmail.com> writes:
> I create below code after reading some reference code. What is 'gSaveMap' in the main function?
> The print message is:
> 50cff730
>
> I know it is initialization of a doubly list. 'gSaveMap' is just a garbage of a random list head address?
>
>
> Thanks in advance
>
> ///////////////////
> #include <stdio.h>
>
> #define INITIALIZE_LIST_HEAD_VAR(ListHead) {&(ListHead), &(ListHead)}
>
> typedef struct _LIST_ENTRY LIST_ENTRY;
>
> struct _LIST_ENTRY {
> LIST_ENTRY* ForwardLink;
> LIST_ENTRY* BackLink;
> };
>
> LIST_ENTRY gSaveMap = INITIALIZE_LIST_HEAD_VAR(gSaveMap);
>
> int main()
> {
> printf("hello world\n");
> printf("gSaveMap=%x\n", gSaveMap);
> return 0;
> }

Lew explained the macros. In your main function, you're calling printf
with a "%x" format specifier, which requires an argument of type
unsigned int. You're passing it an argument of a struct type.
The behavior is undefined, but one likely result is that you'll
print the value of the ForwardLink pointer in hexadecimal.

If you really want to print the values of the two pointer members, you
can do something like this (untested):

printf("gSaveMap.ForwardLink=%p\n", (void*)gSaveMap.ForwardLink);
printf("gSaveMap.BackLink=%p\n", (void*)gSaveMap.BackLink);

%p will print the pointer values in some implementation-defined
human-readable format (likely hexadecimal on most implementations).

I note that your doubly-linked list definition has forward and backward
links, but no payload, so there's not much you can do with it.
Presumably that will be added later.

--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
Working, but not speaking, for Philips
void Void(void) { Void(); } /* The recursive call of the void */

On 11/25/2021 11:57 AM, Keith Thompson wrote:
> fl <rxjwg98@gmail.com> writes:
>> I create below code after reading some reference code. What is 'gSaveMap' in the main function?
>> The print message is:
>> 50cff730
>>
>> I know it is initialization of a doubly list. 'gSaveMap' is just a garbage of a random list head address?
>>
>>
>> Thanks in advance
>>
>> ///////////////////
>> #include <stdio.h>
>>
>> #define INITIALIZE_LIST_HEAD_VAR(ListHead) {&(ListHead), &(ListHead)}
>>
>> typedef struct _LIST_ENTRY LIST_ENTRY;
[...]
> I note that your doubly-linked list definition has forward and backward
> links, but no payload, so there's not much you can do with it.
> Presumably that will be added later.
>

One could use it for an intrusive list:

struct foo
{ LIST_ENTRY list;
int bar;
};

I am quite fond of them, and the offsetof macro comes in very handy.
Love the container_of macro... ;^)

On Thu, 25 Nov 2021 18:22:54 -0000 (UTC), Lew Pitcher
<lew.pitcher@digitalfreehold.ca> wrote:

>On Thu, 25 Nov 2021 09:52:52 -0800, fl wrote:
>
>> Hello everyone,
>>
>> I create below code after reading some reference code. What is
>> 'gSaveMap' in the main function?
>> The print message is:
>> 50cff730
>>
>> I know it is initialization of a doubly list. 'gSaveMap' is just a
>> garbage of a random list head address?
>>
>>
>> Thanks in advance
>
>Order changed for readability...
>
>
>> ///////////////////
>> #include <stdio.h>
>
>> typedef struct _LIST_ENTRY LIST_ENTRY;
>
>Defines a type alias "LIST_ENTRY" that represents a struct _LIST_ENTRY.
>So, where-ever the compiler encounters a LIST_ENTRY type, it interprets
>it as a
> struct _LIST_ENTRY
>type
>
>
>> struct _LIST_ENTRY {
>> LIST_ENTRY* ForwardLink; LIST_ENTRY* BackLink;
>> };
>
>Defines a
> struct _LIST_ENTRY with members ForwardLink and BackLink
>
> ForwardLink is of type LIST_ENTRY *, which, because of the
> typedef, is really struct _LIST_ENTRY.
>
> BackLink is of type LIST_ENTRY *, which, because of the
> typedef, is really struct _LIST_ENTRY.

Of course you meant struct _LIST_ENTRY * for both

--
Remove del for email

On Thu, 25 Nov 2021 14:00:00 -0800, Barry Schwarz wrote:

> On Thu, 25 Nov 2021 18:22:54 -0000 (UTC), Lew Pitcher
> <lew.pitcher@digitalfreehold.ca> wrote:
>
>>On Thu, 25 Nov 2021 09:52:52 -0800, fl wrote:
>>
>>> Hello everyone,
>>>
>>> I create below code after reading some reference code. What is
>>> 'gSaveMap' in the main function?
>>> The print message is:
>>> 50cff730
>>>
>>> I know it is initialization of a doubly list. 'gSaveMap' is just a
>>> garbage of a random list head address?
>>>
>>>
>>> Thanks in advance
>>
>>Order changed for readability...
>>
>>
>>> ///////////////////
>>> #include <stdio.h>
>>
>>> typedef struct _LIST_ENTRY LIST_ENTRY;
>>
>>Defines a type alias "LIST_ENTRY" that represents a struct _LIST_ENTRY.
>>So, where-ever the compiler encounters a LIST_ENTRY type, it interprets
>>it as a
>> struct _LIST_ENTRY
>>type
>>
>>
>>> struct _LIST_ENTRY {
>>> LIST_ENTRY* ForwardLink; LIST_ENTRY* BackLink;
>>> };
>>
>>Defines a
>> struct _LIST_ENTRY with members ForwardLink and BackLink
>>
>> ForwardLink is of type LIST_ENTRY *, which, because of the typedef, is
>> really struct _LIST_ENTRY.
>>
>> BackLink is of type LIST_ENTRY *, which, because of the typedef, is
>> really struct _LIST_ENTRY.
>
> Of course you meant struct _LIST_ENTRY * for both

Of course.

Thanks for the catch.

--
Lew Pitcher
"In Skills, We Trust"

On 2021-11-25, fl <rxjwg98@gmail.com> wrote:
> Hello everyone,
>
> I create below code after reading some reference code. What is 'gSaveMap' in the main function?
> The print message is:
> 50cff730
>
> I know it is initialization of a doubly list. 'gSaveMap' is just a garbage of a random list head address?
>
> LIST_ENTRY gSaveMap = INITIALIZE_LIST_HEAD_VAR(gSaveMap);

This is some macro to generate a structure initializer: { .... }.

In C, structures can be initialized to refer to themselves; cycles are
allowed.

struct list entry g_list = { &g_list, &g_list };

here, the next and prev pointers point back to the g_list itself;
the list is doubly-linked and circular, rather than null-terminated
on both ends. The empty list is represented by an empty sentinel node
which points to itself. (This is not garbage at all, but an important
detail.)

If you want to hide that sentinel initialization behind the macro, the
macro needs to know the name of the object being initialized so it can
insert it:

#define list_entry_init(varname) { &varname, &varname }

now you can write:

struct list entry g_list = list_entry_init(g_list);

which generates the same thing.