gperf on structs that have interdependent foreign keys

Question

I have, potentially, lots of static data, including foreign keys to other static data that need to be resolved. I want the data files to be compiled as constants into my programme. I have written a simple C code generator that takes as input the type information,

Animal
string key
text description
~
Creature
string name
Animal animal
~

And the data,

X
Neil
~
Animal
Bear
A bear is eating all the food.
.
Animal
Ostrich
An Ostrich is chilling.
.
Creature
Steve
Bear
Creature
Sam
Ostrich
Creature
Alice
Bear

And produces a .h file from the type information,

/** Auto-generated from ./ by Loader. */

#include <stddef.h> /* size_t */

/* These are datatypes that are loaded from ./. */

struct AutoAnimal;
struct AutoCreature;

struct AutoAnimal {
    const char *const key; /* key */
    const char *const description;
};

struct AutoCreature {
    const char *const name; /* key */
    const struct AutoAnimal *animal;
};

/* Search. */
struct AutoAnimal *AutoAnimalSearch(const char *const animal);
struct AutoCreature *AutoCreatureSearch(const char *const creature);

And .c from the combined type information and data. For example, this resolves the foreign key for Alice as &auto_animal[0] which is a Bear.

/** Auto-generated from ./ by Loader. */

#include <stdlib.h> /* bsearch */
#include <string.h> /* strcmp */
#include "x.h"

/*
 ./X.lore: "X" by Neil
*/

/* forward reference */
const struct AutoAnimal auto_animal[];
const struct AutoCreature auto_creature[];

/* loaded 5 lores */

const struct AutoAnimal auto_animal[] = {
    { "Bear", "A bear is eating all the food." },
    { "Ostrich", "An Ostrich is chilling." }
};
const int max_auto_animal = sizeof auto_animal / sizeof *auto_animal;

const struct AutoCreature auto_creature[] = {
    { "Alice", &auto_animal[0]/*Bear*/ },
    { "Sam", &auto_animal[1]/*Ostrich*/ },
    { "Steve", &auto_animal[0]/*Bear*/ }
};
const int max_auto_creature = sizeof auto_creature / sizeof *auto_creature;

static int animal_comp(const void *key, const void *elem) {
    const char *const k = key;
    const char *const e = ((const struct AutoAnimal *)elem)->key;
    return strcmp(k, e);
}

struct AutoAnimal *AutoAnimalSearch(const char *const key) {
    return bsearch(&key, auto_animal, max_auto_animal, sizeof *auto_animal, &animal_comp);
}

static int creature_comp(const char *const *key_ptr, const struct AutoCreature *elem) {
    const char *const k = *key_ptr;
    const char *const e = elem->name;
    return strcmp(k, e);
}

struct AutoCreature *AutoCreatureSearch(const char *const key) {
    return bsearch(&key, auto_creature, max_auto_creature, sizeof(struct AutoCreature), (int (*)(const void *, const void *))&creature_comp);
}

The output is sorted so that I can run bsearch on it. If I link the programme with the auto-generated source,

#include <stdlib.h>
#include <stdio.h>
#include "x.h"

int main(void) {
    const struct AutoCreature *creatures[] = {
        AutoCreatureSearch("Sam"),
        AutoCreatureSearch("Alice"),
        AutoCreatureSearch("Eve")
    }, **ac, **ac_end, *c;
    const size_t creatures_size = sizeof creatures / sizeof *creatures;
    for(ac = creatures, ac_end = creatures + creatures_size; ac < ac_end; ac++){
        if(!(c = *ac)) { printf("Creature is not on record.\n"); continue; }
        printf("Creature %s is a(n) %s. %s\n", c->name, c->animal->key,
            c->animal->description);
    }
    return EXIT_SUCCESS;
}

It gives,

Creature Sam is a(n) Ostrich. An Ostrich is chilling.
Creature Alice is a(n) Bear. A bear is eating all the food.
Creature is not on record.

However, I don't have to search. I would like to run gperf on the entire 'database' and get the results in O(1). gperf and my loader both output finished C code, but I can't resolve the foreign keys without knowing the positions in the other table. Is there any way to automate foreign key closures and perfect hash tables that doesn't involve writing a full-blown parser for C?