convert the input of this Json file to a C struct

Question

I have a Json file named name.json An example of such a Json file can be seen bellow

{
  "set": 5,
  "low": 0,
  "draw_set": "0.1 up to 0.3",
  "Wupet": "Hold",
  "": null
}

But it can be also the case that another time the Json file has another structure.

{
  "set": 5,
  "low": 0,
  "draw_set": "0.1 up to 0.3",
  "W_set": "Ramp 1.5 ∞C/min",
  "Wset": 0,
  "Wupet": "Hold",
  "": null
}

I want to convert the input of this Json file (the attributes and their types can be different in each file) to a C struct where the structs automatically detects which attributes (and their types) there are in the Json file. The attribute "" in "": null (can be given a random attribute name)

Then I want to automatically assign the values of Json value to the struct of object Book1.

Plan of my code

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct Books {
   float  set[50];
   int  low[50];
   char  draw_set[100];
   char  Wupet[100];
};

int main( ) {
    /* Read name.Json file */


   struct Books Book1;        /* Declare Book1 of type Book */
   /* Convert content Json to Struct Book1 with it's actual values*/

   return 0;
}

Edit: I don't want to ignore "Wset" and "W_set" keys if they exist in the Json file. The keys of the Json files are changing everything time (there are many unknown attributes that can occur in the future). The number of keys is not guarantee. The 'split over multiple lines' property is guaranteed? The null key name should be given a random name (multiple keys can occurs with like the null key name) The attribute types of the struct should be automatically detected and created. The Json file contains a single record (object)

I want to deal with these structures at runtime.

Answer 1

The attribute types of the struct should be automatically detected and created.

You can't do it without some wacky macros. The fields of a structs in C are fixed at compile time.

Automatically populating your struct would require being able to figure out the fields and types of your struct: reflection. C does not have reflection. You could write up some clever macros, but it's probably not worth it for something this simple.

Automatically adding fields to your struct based on the JSON is also impossible without some wacky macros.

Instead, we'll parse the JSON into a flexible data structure and you can do whatever you like with that. If you want to put them all into a struct, that struct would have to contain all possible fields. There are techniques to write extend structs so you can have a basic Book and then additional extended structs for different types of books.

JSON-Glib provides both. It parses the JSON into JsonNodes which can be JsonArrays or JsonObjects. Then you can do whatever you want with them.

---

Before we do that, the struct needs some work.

struct Books {
    gint64      set;
    gint64      low;
    const char  *draw_set;
    const char  *wupet;
};

set is not a float, but an integer.

We're using the GLib types to match what the GLib library returns and to avoid overflow with large numbers.

Fixed sized buffers should be avoided when reading input, they can easily overflow. Instead JSON-Glib can allocate the correct amount of memory. We'll duplicate that and store a pointer to it.

---

Here's an example of parsing your JSON file using JSON-Glib and manually populating your struct.

#include <stdlib.h>
#include <stdio.h>
#include <glib-object.h>
#include <json-glib/json-glib.h>

struct Books {
    gint64      set;
    gint64      low;
    char        *draw_set;
    char        *wupet;
};

int main(int argc, char** argv) {
    GError *error = NULL;

    if (argc < 2) {
        printf("Usage: test <filename.json>\n");
        return EXIT_FAILURE;
    }

    // Parse the JSON from the file
    JsonParser *parser = json_parser_new();
    json_parser_load_from_file(parser, argv[1], &error);
    if(error) {
        printf("Unable to parse `%s': %s\n", argv[1], error->message);
        g_error_free(error);
        g_object_unref(parser);
        return EXIT_FAILURE;
    }

    // Get the root
    JsonNode *root = json_parser_get_root(parser);

    // Turn the root into a JSON object
    JsonObject *stuff = json_node_get_object(root);

    // Get each object member and assign it to the struct.
    struct Books book = {
        .set = json_object_get_int_member(stuff, "set"),
        .low = json_object_get_int_member(stuff, "low"),
        // Duplicate the strings to avoid pointing to memory inside the parser.
        .draw_set = g_strdup(json_object_get_string_member(stuff, "draw_set")),
        .wupet = g_strdup(json_object_get_string_member(stuff, "Wupet"))
    };

    printf(
        "set = %ld, low = %ld, draw_set = '%s', wupet = '%s'\n",
        book.set, book.low, book.draw_set, book.wupet
    );

    // We're finished working with the parser. Deallocate the
    // parser and all the memory it has allocated, including
    // the nodes.
    g_object_unref(parser);

    return EXIT_SUCCESS;
}