To compile run-time support for instances.

§1.

typedef struct instance_compilation_data {
    struct package_request *instance_package;
    struct inter_name *instance_iname;
    int instance_emitted;
} instance_compilation_data;

void RTInstances::initialise_icd(instance *I) {
    I->icd.instance_package = Hierarchy::local_package(INSTANCES_HAP);
    NounIdentifiers::noun_compose_identifier(I->icd.instance_package,
        I->as_noun, I->allocation_id);
    I->icd.instance_iname = NounIdentifiers::iname(I->as_noun);
    Hierarchy::markup_wording(I->icd.instance_package, INSTANCE_NAME_HMD,
        Nouns::nominative(I->as_noun, FALSE));
    I->icd.instance_emitted = FALSE;
}

inter_name *RTInstances::iname?Usage of RTInstances::iname:
§2, §4
Test Scripts - §3
Runtime Support for Kinds - §5, §27.3
Naming - §2
The Player - §1
Backdrops - §2.1
Regions - §2
The Map - §2.2, §3, §4
Action Patterns - §5, §6.1.1.1
Tokens Parsing Values - §1.1(instance *I) {
    if (I == NULL) return NULL;
    return I->icd.instance_iname;
}

• The structure instance_compilation_data is private to this section.

§2.

int RTInstances::emit_element_of_condition(inference_subject_family *family,
    inference_subject *infs, inter_symbol *t0_s) {
    instance *I = InstanceSubjects::to_instance(infs);
    Produce::inv_primitive(Emit::tree(), EQ_BIP);
    Produce::down(Emit::tree());
        Produce::val_symbol(Emit::tree(), K_value, t0_s);
        Produce::val_iname(Emit::tree(), K_value, RTInstances::iname(I));
    Produce::up(Emit::tree());
    return TRUE;
}

§3. Compilation looks tricky only because we need to compile instances in a set order which is not the order of their creation. (This is because objects must be compiled in containment-tree traversal order in the final Inform 6 code.) So in reply to a request to compile all instances, we first delegate the object instances, then compile the non-object ones (all just constant declarations) and finally return TRUE to indicate that the task is finished.

int RTInstances::emit_all(inference_subject_family *family, int ignored) {
    instance *I;
    LOOP_THROUGH_INSTANCE_ORDERING(I)
        RTInstances::emit_one(family, Instances::as_subject(I));
    LOOP_OVER(I, instance)
        if (Kinds::Behaviour::is_object(Instances::to_kind(I)) == FALSE)
            RTInstances::emit_one(family, Instances::as_subject(I));
    RTNaming::compile_small_names();
    return TRUE;
}

§4. Either way, the actual compilation happens here:

void RTInstances::emit_one?Usage of RTInstances::emit_one:
§3(inference_subject_family *family, inference_subject *infs) {
    instance *I = InstanceSubjects::to_instance(infs);
    RTInstances::emitted_iname(I);
    RTProperties::emit_instance_permissions(I);
    RTPropertyValues::emit_subject(infs);
}

inter_name *RTInstances::emitted_iname?Usage of RTInstances::emitted_iname:
Emitting Inter - §3
Properties - §6
Emit Property Values - §1
Instance Counting - §9
Runtime Support for Kinds - §7
The Map - §2.1, §2.2(instance *I) {
    if (I == NULL) return NULL;
    inter_name *iname = RTInstances::iname(I);
    if (I->icd.instance_emitted == FALSE) {
        I->icd.instance_emitted = TRUE;
        Emit::instance(iname, Instances::to_kind(I), I->enumeration_index);
    }
    return iname;
}

package_request *RTInstances::package?Usage of RTInstances::package:
Emit Property Values - §2
Naming - §2
Parsing - §2
Backdrops - §1
Regions - §1
The Map - §3
Actions - §1(instance *I) {
    RTInstances::iname(I);  Thus forcing this to exist...
    return I->icd.instance_package;
}