To generate final code from intermediate code.

• §1. Pipeline stage
• §4. Sorting by annotation value
• §5. Sorting by metadata value
• §6. Ad hoc generation
• §7. Literal text modes
• §8. Segmentation
• §16. Transients
• §18. Value pairs

§1. Pipeline stage. This whole module exists to provide a single pipeline stage, making the final generation of code from a tree of fully-linked and generally complete Inter.

It comes in two forms (the optional one writes nothing if no filename is supplied to it; the compulsory one throws an error in that case), but note that both call the same function.

void CodeGen::create_pipeline_stage(void) {
    ParsingPipelines::new_stage(I"generate", CodeGen::run_pipeline_stage,
        TEXT_OUT_STAGE_ARG, FALSE);
    ParsingPipelines::new_stage(I"optionally-generate", CodeGen::run_pipeline_stage,
        OPTIONAL_TEXT_OUT_STAGE_ARG, FALSE);
}

int CodeGen::run_pipeline_stage(pipeline_step *step) {
    if (step->generator_argument) {
        code_generation *gen = CodeGen::new_generation(step, step->ephemera.parsed_filename,
            step->ephemera.to_stream, step->ephemera.tree, step->ephemera.package_argument,
            step->generator_argument, step->ephemera.for_VM, FALSE);
        Generators::go(gen);
    }
    return TRUE;
}

§2. A "generation" is a single act of translating inter code into final code. It will be carried out by the "generator", using the data held in the following object.

typedef struct code_generation {
    struct code_generator *generator;
    struct pipeline_step *from_step;
    struct target_vm *for_VM;
    void *generator_private_data;  depending on the target generated to

    struct filename *to_file;       filename of output, and/or...
    struct text_stream *to_stream;  stream for textual output

    struct inter_tree *from;
    struct inter_package *just_this_package;

    struct segmentation_data segmentation;
    int void_level;
    int literal_text_mode;
    struct linked_list *global_variables;
    struct linked_list *text_literals;
    struct linked_list *assimilated_properties;
    struct linked_list *unassimilated_properties;
    struct linked_list *instances;
    struct linked_list *kinds;
    struct linked_list *kinds_in_declaration_order;
    struct linked_list *instances_in_declaration_order;

    int true_action_count;
    int fake_action_count;
    struct linked_list *actions;  of text_stream
    int dword_count;
    struct linked_list *words;  of vanilla_dword
    struct dictionary *dword_dictionary;  of vanilla_dword
    int verb_count;
    struct linked_list *verbs;  of vanilla_dword
    struct linked_list *verb_grammar;  of text_stream

    CLASS_DEFINITION
} code_generation;

code_generation *CodeGen::new_generation?Usage of CodeGen::new_generation:
§1, §6(pipeline_step *step, filename *F,
    text_stream *T, inter_tree *I, inter_package *just, code_generator *generator,
    target_vm *VM, int temp) {
    code_generation *gen = CREATE(code_generation);
    gen->from_step = step;
    gen->to_file = F;
    gen->to_stream = T;
    if ((VM == NULL) && (generator == NULL)) internal_error("no way to determine format");
    if (VM == NULL) VM = TargetVMs::find(generator->generator_name);
    gen->for_VM = VM;
    gen->from = I;
    gen->generator = generator;
    if (just) gen->just_this_package = just;
    else gen->just_this_package = LargeScale::main_package(I);
    gen->segmentation = CodeGen::new_segmentation_data();
    gen->void_level = -1;
    gen->literal_text_mode = REGULAR_LTM;
    gen->global_variables = NEW_LINKED_LIST(inter_symbol);
    gen->text_literals = NEW_LINKED_LIST(text_literal_holder);
    gen->assimilated_properties = NEW_LINKED_LIST(inter_symbol);
    gen->unassimilated_properties = NEW_LINKED_LIST(inter_symbol);
    gen->instances = NEW_LINKED_LIST(inter_symbol);
    gen->kinds = NEW_LINKED_LIST(inter_symbol);
    gen->kinds_in_declaration_order = NEW_LINKED_LIST(inter_symbol);
    gen->instances_in_declaration_order = NEW_LINKED_LIST(inter_symbol);
    gen->true_action_count = 0;
    gen->fake_action_count = 0;
    gen->actions = NEW_LINKED_LIST(text_stream);
    gen->dword_count = 0;
    gen->words = NEW_LINKED_LIST(vanilla_dword);
    gen->dword_dictionary = Dictionaries::new(1024, FALSE);
    gen->verb_count = 0;
    gen->verbs = NEW_LINKED_LIST(vanilla_dword);
    gen->verb_grammar = NEW_LINKED_LIST(text_stream);
    if (temp == FALSE) Traverse for global bric-a-brac2.1;
    return gen;
}

• The structure code_generation is accessed in 2/cg2, 2/vnl, 2/vc, 2/vf, 2/vo, 2/vc2, 2/vi, 3/fti, 3/fbi, 3/fi, 4/fi6, 4/i6c, 4/i6o, 4/i6c2, 5/fnc, 5/cnm, 5/crf, 5/cmm, 5/cpc, 5/ccn, 5/clt, 5/com, 5/cfm and here.

§2.1. Traverse for global bric-a-brac2.1 =

    InterTree::traverse(gen->from, CodeGen::gather_up, gen, NULL, 0);
    CodeGen::sort_symbol_list(gen->kinds_in_declaration_order, gen->kinds,
        CodeGen::in_declaration_md_order);
    CodeGen::sort_symbol_list(gen->instances_in_declaration_order, gen->instances,
        CodeGen::in_declaration_md_order);

• This code is used in §2.

§3.

void CodeGen::gather_up?Usage of CodeGen::gather_up:
§2.1(inter_tree *I, inter_tree_node *P, void *state) {
    code_generation *gen = (code_generation *) state;
    switch (Inode::get_construct_ID(P)) {
        case VARIABLE_IST: {
            inter_symbol *var_name = VariableInstruction::variable(P);
            ADD_TO_LINKED_LIST(var_name, inter_symbol, gen->global_variables);
            break;
        }
        case PROPERTY_IST: {
            inter_symbol *prop_name = PropertyInstruction::property(P);
            if (SymbolAnnotation::get_b(prop_name, ASSIMILATED_IANN))
                ADD_TO_LINKED_LIST(prop_name, inter_symbol, gen->assimilated_properties);
            else
                ADD_TO_LINKED_LIST(prop_name, inter_symbol, gen->unassimilated_properties);
            break;
        }
        case INSTANCE_IST: {
            inter_symbol *inst_name = InstanceInstruction::instance(P);
            ADD_TO_LINKED_LIST(inst_name, inter_symbol, gen->instances);
            break;
        }
        case TYPENAME_IST: {
            inter_symbol *typename = TypenameInstruction::typename(P);
            ADD_TO_LINKED_LIST(typename, inter_symbol, gen->kinds);
            break;
        }
    }
}

void CodeGen::sort_symbol_list?Usage of CodeGen::sort_symbol_list:
§2.1(linked_list *to_L, linked_list *L,
    int (*sorter)(const void *elem1, const void *elem2)) {
    int N = LinkedLists::len(L);
    if (N > 0) {
        inter_symbol **array = (inter_symbol **)
            (Memory::calloc(N, sizeof(inter_symbol *), CODE_GENERATION_MREASON));
        int i=0;
        inter_symbol *sym;
        LOOP_OVER_LINKED_LIST(sym, inter_symbol, L) array[i++] = sym;
        qsort(array, (size_t) N, sizeof(inter_symbol *), sorter);
        for (int j=0; j<N; j++) ADD_TO_LINKED_LIST(array[j], inter_symbol, to_L);
        Memory::I7_array_free(array, CODE_GENERATION_MREASON, N, sizeof(inter_symbol *));
    }
}

§4. Sorting by annotation value. We stopped doing this in March 2022, but the function seems worth keeping around. It provides a criterion for sorting a list of symbols by looking at the values of a numerical annotation, with symbols not having that annotation pushed to the back.

int CodeGen::in_annotation_order(const void *elem1, const void *elem2, inter_ti annot) {
    const inter_symbol **e1 = (const inter_symbol **) elem1;
    const inter_symbol **e2 = (const inter_symbol **) elem2;
    if ((*e1 == NULL) || (*e2 == NULL))
        internal_error("Disaster while sorting kinds");
    int s1 = CodeGen::sequence_number(*e1, annot);
    int s2 = CodeGen::sequence_number(*e2, annot);
    if (s1 != s2) return s1-s2;
    return InterSymbol::sort_number(*e1) - InterSymbol::sort_number(*e2);
}
int CodeGen::sequence_number(const inter_symbol *kind_name, inter_ti annot) {
    int N = SymbolAnnotation::get_i(kind_name, annot);
    if (N >= 0) return N;
    return 100000000;
}

§5. Sorting by metadata value. The preferred alternative is to sort by the value of a metadata key present in the same packages as the symbols:

int CodeGen::in_source_md_order(const void *elem1, const void *elem2) {
    return CodeGen::in_md_order(elem1, elem2, I"^source_order");
}
int CodeGen::in_declaration_md_order?Usage of CodeGen::in_declaration_md_order:
§2.1(const void *elem1, const void *elem2) {
    return CodeGen::in_md_order(elem1, elem2, I"^declaration_order");
}
int CodeGen::in_md_order(const void *elem1, const void *elem2, text_stream *key) {
    const inter_symbol **e1 = (const inter_symbol **) elem1;
    const inter_symbol **e2 = (const inter_symbol **) elem2;
    if ((*e1 == NULL) || (*e2 == NULL))
        internal_error("Disaster while sorting kinds");
    int s1 = CodeGen::md_number(*e1, key);
    int s2 = CodeGen::md_number(*e2, key);
    if (s1 != s2) return s1-s2;
    return InterSymbol::sort_number(*e1) - InterSymbol::sort_number(*e2);
}
int CodeGen::md_number(const inter_symbol *owner_name, text_stream *key) {
    inter_package *pack = InterSymbol::package((inter_symbol *) owner_name);
    if (Metadata::exists(pack, key))
        return (int) Metadata::read_optional_numeric(pack, key);
    return 100000000;
}

§6. Ad hoc generation. This module would be more elegant if the following function did not exist. But it is a consequence of the (+ ... +) feature of Inform, which plunges right through all kinds of conceptual barriers better left unplunged-through. Happily, it's both limited and little-used. The task is to turn a single Inter value-pair into the text of an expression which will represent it at run-time.

This is called by Inform 7 during a drastically earlier phase of compilation, long before the final module would otherwise be involved, and there's no question of performing a full generation of an entire Inter tree. So we make a sort of mock-generation object, the ad_hoc_generation, just for the purpose of this function call. We could make a new mock object every time, because there aren't such a lot of calls to this function, but instead we make just one and re-use it.

The mock generator makes no use of segmentation (see below) except for the single temporary segment, which is set to OUT.

code_generation *ad_hoc_generation = NULL;

void CodeGen::val_to_text(OUTPUT_STREAM, inter_bookmark *IBM, inter_pair val, target_vm *VM) {
    if (ad_hoc_generation == NULL) {
        if (VM == NULL) internal_error("no VM given");
        code_generator *generator = Generators::find_for(VM);
        if (generator == NULL) internal_error("VM family with no generator");
        ad_hoc_generation =
            CodeGen::new_generation(NULL, NULL, NULL, InterBookmark::tree(IBM),
                NULL, generator, VM, TRUE);
    }
    code_generator *generator = Generators::find_for(VM);
    if (generator == NULL) internal_error("VM family with no generator");
    ad_hoc_generation->for_VM = VM;
    ad_hoc_generation->generator = generator;

    CodeGen::select_temporary(ad_hoc_generation, OUT);
    CodeGen::pair_at_bookmark(ad_hoc_generation, IBM, val);
    CodeGen::deselect_temporary(ad_hoc_generation);
}

§7. Literal text modes. There are three of these. PRINTING_LTM is used when text is needed only immediately as an operand for, say, !print and will therefore never be a value at runtime; BOX_LTM for "quotation box" text; REGULAR_LTM for everything else.

define REGULAR_LTM 0
define BOX_LTM 1
define PRINTING_LTM 2

void CodeGen::lt_mode?Usage of CodeGen::lt_mode:
Inform 6 Code - §6.9
C Input-Output Model - §2(code_generation *gen, int m) {
    gen->literal_text_mode = m;
}

§8. Segmentation. Generators have flexibility in how they go about their business, but if they are making what amounts to a text file with a lot of internal structure then the following system may be a convenience. It allows text to be assembled as a set of "segments" which can be appended to in any order, and which are then put together in a logical order at the end.

Segments are identified by ID numbers counting up from 0, 1, 2, ...: but ID number 0 is no_I7CGS, reserved to mean "not a segment".

A segment is itself internally stratified into numbered "layers", and these are used to help generators cope with more nuanced ordering issues — e.g., where two declarations are of basically the same sort of thing, and should be in the same segment as each other; but where one must nevertheless precede the other. This can be achieved by putting the one to come first at a lower-numbered level.

enum no_I7CGS from 0
define MAX_LAYERS_PER_SEGMENT 128

typedef struct generated_segment {
    int layers;
    struct text_stream *generated_code[MAX_LAYERS_PER_SEGMENT];
    CLASS_DEFINITION
} generated_segment;

generated_segment *CodeGen::new_segment?Usage of CodeGen::new_segment:
§10, §11(void) {
    generated_segment *seg = CREATE(generated_segment);
    seg->layers = MAX_LAYERS_PER_SEGMENT;
    for (int i=0; i<seg->layers; i++) seg->generated_code[i] = Str::new();
    return seg;
}

• The structure generated_segment is private to this section.

§9. Each generation has its own copy of every possible numbered segment, though by default those are NULL.

typedef struct segmentation_data {
    struct generated_segment *segments[NO_DEFINED_I7CGS_VALUES];
    struct linked_list *segment_sequence;  of generated_segment
    struct linked_list *additional_segment_sequence;  of generated_segment
    struct text_stream *temporarily_diverted_to;
    int temporarily_diverted;  to the temporary segment
    struct segmentation_pos pos;
} segmentation_data;

typedef struct segmentation_pos {
    struct generated_segment *current_segment;  the one currently being written to
    int current_layer;  within that segment: in the range 0 to current_segment->layers - 1
} segmentation_pos;

segmentation_data CodeGen::new_segmentation_data?Usage of CodeGen::new_segmentation_data:
§2(void) {
    segmentation_data sd;
    sd.segment_sequence = NEW_LINKED_LIST(generated_segment);
    sd.additional_segment_sequence = NEW_LINKED_LIST(generated_segment);
    sd.temporarily_diverted = FALSE;
    sd.temporarily_diverted_to = NULL;
    for (int i=0; i<NO_DEFINED_I7CGS_VALUES; i++) sd.segments[i] = NULL;
    sd.pos.current_segment = NULL;
    sd.pos.current_layer = 1;
    return sd;
}

• The structure segmentation_data is accessed in 5/fnc and here.
• The structure segmentation_pos is private to this section.

§10. If a generator wants to use this system, it should call CodeGen::create_segments to say which segments it wants to be created, passing an array of ID numbers. The order of these is significant — it's the order in which they will appear in the final output.

void CodeGen::create_segments?Usage of CodeGen::create_segments:
Generating Inform 6 - §4
Final C - §5(code_generation *gen, void *data, int codes[]) {
    gen->segmentation.segment_sequence = NEW_LINKED_LIST(generated_segment);
    for (int i=0; codes[i] >= 0; i++) {
        if ((codes[i] >= NO_DEFINED_I7CGS_VALUES) ||
            (codes[i] == no_I7CGS)) internal_error("bad segment sequence");
        gen->segmentation.segments[codes[i]] = CodeGen::new_segment();
        ADD_TO_LINKED_LIST(gen->segmentation.segments[codes[i]], generated_segment,
            gen->segmentation.segment_sequence);
    }
    gen->generator_private_data = data;
}

§11. An optional "alternative" set can also be created.

void CodeGen::additional_segments?Usage of CodeGen::additional_segments:
Final C - §5(code_generation *gen, int codes[]) {
    gen->segmentation.additional_segment_sequence = NEW_LINKED_LIST(generated_segment);
    for (int i=0; codes[i] >= 0; i++) {
        if ((codes[i] >= NO_DEFINED_I7CGS_VALUES) ||
            (codes[i] == no_I7CGS)) internal_error("bad segment sequence");
        gen->segmentation.segments[codes[i]] = CodeGen::new_segment();
        ADD_TO_LINKED_LIST(gen->segmentation.segments[codes[i]], generated_segment,
            gen->segmentation.additional_segment_sequence);
    }
}

§12. At any given time, a generation has a "current" segment, to which output is being written. The generator should use CodeGen::select to switch to a given segment, which must be one of those it has created, and then use CodeGen::deselect to go back to where it was. These calls must be made in properly nested pairs.

At some point we may want to make the cap on the number of layers flexible, but for now about 10 layers is plenty.

segmentation_pos CodeGen::select?Usage of CodeGen::select:
Generating Inform 6 - §4.1, §4.2, §5
Inform 6 Constants - §3.1, §3.2, §5
Inform 6 Global Variables - §2.1, §2.2, §2.3, §2.4
Inform 6 Objects - §4.3, §4.4, §4.5, §4.6, §5.1, §9, §13.1, §13.2, §13.3
Inform 6 Code - §2, §9
Final C - §5.2, §5.3, §6.1
C Global Variables - §2, §3, §3.1, §3.2, §3.3, §3.4, §4
C Memory Model - §2, §3, §4.1, §4.2, §4.2.2, §5, §6
C Assembly - §5.2
C Literals - §7, §8
C Object Model - §2, §4, §7, §10, §13, §16, §17, §20.1, §20.3, §24, §34
C Function Model - §2, §4, §6, §8, §12, §14.1, §14.2, §14.3(code_generation *gen, int i) {
    return CodeGen::select_layered(gen, i, 1);
}

segmentation_pos CodeGen::select_layered?Usage of CodeGen::select_layered:
Inform 6 Constants - §2
C Namespace - §7(code_generation *gen, int i, int layer) {
    segmentation_pos previous_pos = gen->segmentation.pos;
    if (gen->segmentation.temporarily_diverted) internal_error("poorly timed selection");
    if ((i < 0) || (i >= NO_DEFINED_I7CGS_VALUES)) internal_error("out of range");
    if (gen->segmentation.segments[i] == NULL)
        internal_error("generator does not use this segment ID");
    if (layer >= gen->segmentation.segments[i]->layers)
        internal_error("too many layers");
    gen->segmentation.pos.current_segment = gen->segmentation.segments[i];
    gen->segmentation.pos.current_layer = layer;
    return previous_pos;
}

void CodeGen::deselect?Usage of CodeGen::deselect:
Generating Inform 6 - §4.1, §4.2, §5
Inform 6 Constants - §2, §4, §5
Inform 6 Global Variables - §2.1, §2.2, §2.3, §2.4
Inform 6 Objects - §4.3, §4.4, §4.5, §4.6, §6, §9, §13.1, §13.2, §13.3
Inform 6 Code - §2, §9
Final C - §5.2, §5.3, §6.1
C Namespace - §7
C Global Variables - §2, §3, §3.1, §3.2, §3.3, §3.4, §4
C Memory Model - §2, §3, §4.2.2, §5, §6
C Assembly - §5.2
C Literals - §7, §8
C Object Model - §2, §4, §7, §10, §13, §16, §17, §20.1, §20.3, §24, §34
C Function Model - §2, §4, §6, §8, §12, §14.1, §14.2, §14.3(code_generation *gen, segmentation_pos saved) {
    if (gen->segmentation.temporarily_diverted) internal_error("poorly timed deselection");
    gen->segmentation.pos = saved;
}

§13. However, we can also temporarily divert the whole system to send its text to some temporary stream somewhere. For that, use the following pair:

void CodeGen::select_temporary?Usage of CodeGen::select_temporary:
§6
Vanilla Constants - §1.6
Vanilla Objects - §2.2.1.2, §4.1.1.1.1.1.1
Inform 6 Objects - §11
C Assembly - §6.3
C Object Model - §21(code_generation *gen, text_stream *T) {
    if (gen->segmentation.temporarily_diverted) internal_error("nested temporary segments");
    gen->segmentation.temporarily_diverted_to = T;
    gen->segmentation.temporarily_diverted = TRUE;
}

void CodeGen::deselect_temporary?Usage of CodeGen::deselect_temporary:
§6
Vanilla Constants - §1.6
Vanilla Objects - §2.2.1.2, §4.1.1.1.1.1.1
Inform 6 Objects - §11
C Assembly - §6.3
C Object Model - §21(code_generation *gen) {
    gen->segmentation.temporarily_diverted_to = NULL;
    gen->segmentation.temporarily_diverted = FALSE;
}

§14. The following returns the text stream a generator should write to. Note that if it has been "temporarily diverted" then the regular selection is ignored.

text_stream *CodeGen::current?Usage of CodeGen::current:
§18.1
Vanilla - §4
Vanilla Constants - §2
Vanilla Objects - §5
Generating Inform 6 - §4.1, §4.2, §5
Inform 6 Constants - §2, §3.1, §3.2, §4, §5, §6, §7, §8, §9
Inform 6 Global Variables - §2.1, §2.2, §2.3, §2.4, §3
Inform 6 Objects - §4.3, §4.4, §4.5, §4.6, §5.1, §6, §9, §10, §11, §13.1, §13.2, §13.3
Inform 6 Code - §2, §3, §4, §5, §6, §6.4, §9
Final C - §5.2, §5.3, §6.1
C Namespace - §7
C References - §2
C Global Variables - §2, §3, §3.1, §3.2, §3.3, §3.4, §4, §5
C Memory Model - §2, §3, §4.2.2, §5, §6, §7
C Assembly - §5.2, §6, §7
C Arithmetic - §1
C Program Control - §1, §2, §2.12
C Conditions - §1, §2
C Literals - §2, §3, §4, §5, §7, §8, §10
C Object Model - §2, §4, §7, §10, §13, §16, §17, §20.1, §20.3, §24, §26, §34
C Function Model - §2, §4, §5, §6, §8, §10, §11, §12, §14.1, §14.2, §14.3, §15
C Input-Output Model - §2(code_generation *gen) {
    if (gen->segmentation.temporarily_diverted)
        return gen->segmentation.temporarily_diverted_to;
    if (gen->segmentation.pos.current_segment == NULL) return NULL;
    return gen->segmentation.pos.current_segment->
        generated_code[gen->segmentation.pos.current_layer];
}

§15. And then all we do is concatenate them in order:

void CodeGen::write_segments?Usage of CodeGen::write_segments:
Code Generators - §4(OUTPUT_STREAM, code_generation *gen) {
    generated_segment *seg;
    LOOP_OVER_LINKED_LIST(seg, generated_segment,
        gen->segmentation.segment_sequence)
            CodeGen::write_segment(OUT, seg);
}

void CodeGen::write_additional_segments(OUTPUT_STREAM, code_generation *gen) {
    generated_segment *seg;
    LOOP_OVER_LINKED_LIST(seg, generated_segment,
        gen->segmentation.additional_segment_sequence)
            CodeGen::write_segment(OUT, seg);
}

void CodeGen::write_segment?Usage of CodeGen::write_segment:
Final C - §6.2(OUTPUT_STREAM, generated_segment *seg) {
    for (int i=0; i<seg->layers; i++)
        WRITE("%S", seg->generated_code[i]);
}

§16. Transients. Transient flags on symbols are used temporarily during code generation, but do not change the meaning of the tree: they're just a way to keep track of, say, what we've worked on so far.

void CodeGen::clear_all_transients?Usage of CodeGen::clear_all_transients:
Code Generators - §4(inter_tree *I) {
    InterTree::traverse(I, CodeGen::clear_transients, NULL, NULL, PACKAGE_IST);
}

void CodeGen::clear_transients(inter_tree *I, inter_tree_node *P, void *state) {
    inter_package *pack = PackageInstruction::at_this_head(P);
    inter_symbols_table *T = InterPackage::scope(pack);
    LOOP_OVER_SYMBOLS_TABLE(S, T)
        InterSymbol::clear_transient_flags(S);
}

§17. In particular the TRAVERSE_MARK_ISYMF flag is sometimes convenient to use.

int CodeGen::marked?Usage of CodeGen::marked:
Vanilla Objects - §4.1.1.1(inter_symbol *symb_name) {
    return InterSymbol::get_flag(symb_name, TRAVERSE_MARK_ISYMF);
}

void CodeGen::mark?Usage of CodeGen::mark:
Vanilla Objects - §4.1.1.1(inter_symbol *symb_name) {
    InterSymbol::set_flag(symb_name, TRAVERSE_MARK_ISYMF);
}

void CodeGen::unmark?Usage of CodeGen::unmark:
Vanilla Objects - §4.1(inter_symbol *symb_name) {
    InterSymbol::clear_flag(symb_name, TRAVERSE_MARK_ISYMF);
}

§18. Value pairs. We will very often need to compile an expression from a pair val1, val2 extracted from some Inter instruction.

void CodeGen::pair_at_bookmark?Usage of CodeGen::pair_at_bookmark:
§6(code_generation *gen, inter_bookmark *IBM, inter_pair val) {
    inter_symbols_table *T = IBM?(InterBookmark::scope(IBM)):NULL;
    Generate from a value pair18.1;
}

void CodeGen::pair?Usage of CodeGen::pair:
Vanilla Constants - §1.6, §2
Vanilla Objects - §4.1.1.1.1.1.1
Vanilla Code - §4
Inform 6 Constants - §3.1
Inform 6 Global Variables - §2.2, §2.4
Inform 6 Objects - §11
C Global Variables - §3.4
C Object Model - §21(code_generation *gen, inter_tree_node *P, inter_pair val) {
    inter_symbols_table *T = P?(InterPackage::scope_of(P)):NULL;
    Generate from a value pair18.1;
}

§18.1. Generate from a value pair18.1 =

    inter_tree *I = gen->from;
    text_stream *OUT = CodeGen::current(gen);
    if (InterValuePairs::is_symbolic(val)) {
        inter_symbol *s = InterValuePairs::to_symbol(val, T);
        if (s == NULL) internal_error("bad symbol in Inter pair");
        Generators::compile_literal_symbol(gen, s);
    } else if (InterValuePairs::is_number(val)) {
        Generators::compile_literal_number(gen, InterValuePairs::to_number(val), FALSE);
    } else if (InterValuePairs::is_real(val)) {
        Generators::compile_literal_real(gen, InterValuePairs::to_textual_real(I, val));
    } else if (InterValuePairs::is_singular_dword(val)) {
        Generators::compile_dictionary_word(gen, InterValuePairs::to_dictionary_word(I, val), FALSE);
    } else if (InterValuePairs::is_plural_dword(val)) {
        Generators::compile_dictionary_word(gen, InterValuePairs::to_dictionary_word(I, val), TRUE);
    } else if (InterValuePairs::is_text(val)) {
        Generators::compile_literal_text(gen, InterValuePairs::to_text(I, val), TRUE);
    } else if (InterValuePairs::is_glob(val)) {
        WRITE("%S", InterValuePairs::to_glob_text(I, val));
    } else {
        internal_error("unimplemented data pair format");
    }

• This code is used in §18 (twice).