了解C中的结构类型的指针转​​换

Question

I'm trying to understanding the pointer casting in this case.

# https://github.com/udp/json-parser/blob/master/json.c#L408

#define json_char char
typedef struct _json_object_entry
{
   json_char * name;
   unsigned int name_length;

   struct _json_value * value;

} json_object_entry;
typedef struct _json_value
{
struct
  {
     unsigned int length;

     json_object_entry * values;

     #if defined(__cplusplus) && __cplusplus >= 201103L
     decltype(values) begin () const
     {  return values;
     }
     decltype(values) end () const
     {  return values + length;
     }
     #endif

  } object;
}
(*(json_char **) &top->u.object.values) += string_length + 1;

Due to what I see top->u.object.values has the address of the first element of values ( type : json_object_entry ), and then we get the address of values, casting it to char, .. And from here I'm lost. I don't really understand the purpose of this.

// Notes : This is two pass parser for those who wonders what is this.

Thanks

Answer 1

_json_value::values is a pointer to the beginning of (or into) an array of json_object_entry s. The code adjusts its value by a few bytes, eg in order to skip a header or such before the actual data. Because the pointer is typed one can without casting only change its value in quants of sizeof(_json_object_entry) , but apparently the offset can have any value, depending on some string_length . So the address of the pointer is taken, cast to the address of a char pointer (a char pointer can be changed in 1 increments), dereferenced so the result is a pointer to char residing at the same place as the real u.object.values , and then assigned to.

One should add that such code may break at run time if the architecture demands a minimal alignment for structures (possibly depending on their first element, here a pointer) and the string length can have a value which is not a multiple of that alignment. That would make the code UB. I'm not exactly sure whether the code is nominally UB if the alignment is preserved.

Answer 2

Author here (guilty as charged...)

In the first pass, values hasn't yet been allocated, so the parser cheats by using the same field to store the amount of memory (length) that's going to be required when it's actually allocated in the second pass.

if (state.first_pass)
    (*(json_char **) &top->u.object.values) += string_length + 1;

The cast to json_char is so that we add multiples of char to the length, rather than multiples of json_object_entry .

It is a bit (...OK, more than a bit...) of a dirty hack re-using the field like that, but it was to save adding another field to json_value or using a union (C89 unions can't be anonymous, so it would have made the structure of json_value a bit weird).

There's no UB here, because we're not actually using values as an array of structs at this point, just subverting the type system and using it as an integer.

Answer 3

    json_object_entry * values;
...
}

(*(json_char **) &top->u.object.values) += string_length + 1;

forgetting type correctness, you can collapse the & and *:

((json_char **) top->u.object.values) += string_length + 1;

top->u.object.values is indeed the pointer to first element of values array. It is typecasted to a pointer to a pointer to json_char, and then advanced string_length + 1 characters. The net result is that top->u.object.values now points (string_length + 1) json_chars ahead of what it used to.