To create the range of possible targets into which Inter can be converted.

• §1. Creation
• §4. The Go mechanism
• §5. Methods called by Vanilla
• §7. Methods called by Vanilla Constants
• §13. Methods called by Vanilla Code
• §17. Methods called by Vanilla Objects
• §20. Methods used for compiling from Inter pairs

classdef code_generator {
    struct text_stream *generator_name;
    struct method_set *methods;
}

code_generator *Generators::new?Usage of Generators::new:
Final Textual Inter - §1
Final Binary Inter - §1
Final Inventory - §1
Final Inform 6 - §1
Final C - §1(text_stream *name) {
    code_generator *generator = CREATE(code_generator);
    generator->generator_name = Str::duplicate(name);
    generator->methods = Methods::new_set();
    return generator;
}

• The structure code_generator is accessed in 2/cg and here.

code_generator *Generators::find(text_stream *name) {
    Generators::make_all();
    code_generator *generator;
    LOOP_OVER(generator, code_generator)
        if (Str::eq_insensitive(generator->generator_name, name))
            return generator;
    return NULL;
}

code_generator *Generators::find_for?Usage of Generators::find_for:
Code Generation - §6(target_vm *VM) {
    return Generators::find(TargetVMs::family(VM));
}

int generators_have_been_made = FALSE;

void Generators::make_all?Usage of Generators::make_all:
§2(void) {
    if (generators_have_been_made == FALSE) {
        generators_have_been_made = TRUE;
        TextualTarget::create_generator();
        BinaryTarget::create_generator();
        InvTarget::create_generator();
        I6Target::create_generator();
        CTarget::create_generator();
    }
}

enumerate BEGIN_GENERATION_MTID 

enumerate END_GENERATION_MTID 

INT_METHOD_TYPE(BEGIN_GENERATION_MTID, code_generator *generator, code_generation *gen)
INT_METHOD_TYPE(END_GENERATION_MTID, code_generator *generator, code_generation *gen)

void Generators::go?Usage of Generators::go:
Code Generation - §1(code_generation *gen) {
    CodeGen::clear_all_transients(gen->from);
    int rv = FALSE;
    INT_METHOD_CALL(rv, gen->generator, BEGIN_GENERATION_MTID, gen);
    if (rv) return;
    Vanilla::go(gen);
    INT_METHOD_CALL(rv, gen->generator, END_GENERATION_MTID, gen);
    if (rv) return;
    CodeGen::write_segments(gen->to_stream, gen);
}

enumerate OFFER_PRAGMA_MTID 

VOID_METHOD_TYPE(OFFER_PRAGMA_MTID, code_generator *generator, code_generation *gen,
    inter_tree_node *P, text_stream *tag, text_stream *content)
void Generators::offer_pragma?Usage of Generators::offer_pragma:
Vanilla - §1.2(code_generation *gen, inter_tree_node *P, text_stream *tag,
    text_stream *content) {
    VOID_METHOD_CALL(gen->generator, OFFER_PRAGMA_MTID, gen, P, tag, content);
}

§6.

enumerate PREDECLARE_FUNCTION_MTID 

VOID_METHOD_TYPE(PREDECLARE_FUNCTION_MTID, code_generator *generator, code_generation *gen,
    vanilla_function *vf)
VOID_METHOD_TYPE(END_FUNCTION_MTID, code_generator *generator, int pass, code_generation *gen,
    inter_symbol *fn)
void Generators::predeclare_function?Usage of Generators::predeclare_function:
Vanilla Functions - §2(code_generation *gen, vanilla_function *vf) {
    VOID_METHOD_CALL(gen->generator, PREDECLARE_FUNCTION_MTID, gen, vf);
}

§7. Methods called by Vanilla Constants.

enumerate NEW_ACTION_MTID 

VOID_METHOD_TYPE(NEW_ACTION_MTID, code_generator *generator, code_generation *gen,
    text_stream *name, int true_action, int N)
void Generators::new_action?Usage of Generators::new_action:
Vanilla Constants - §1.1, §1.2(code_generation *gen, text_stream *name, int true_action, int N) {
    VOID_METHOD_CALL(gen->generator, NEW_ACTION_MTID, gen, name, true_action, N);
}

§8.

enumerate PSEUDO_OBJECT_MTID 

VOID_METHOD_TYPE(PSEUDO_OBJECT_MTID, code_generator *generator, code_generation *gen,
    text_stream *obj_name)
void Generators::pseudo_object?Usage of Generators::pseudo_object:
Vanilla Constants - §1.4(code_generation *gen, text_stream *obj_name) {
    VOID_METHOD_CALL(gen->generator, PSEUDO_OBJECT_MTID, gen, obj_name);
}

§9.

enumerate DECLARE_FUNCTION_MTID 

VOID_METHOD_TYPE(DECLARE_FUNCTION_MTID, code_generator *generator, code_generation *gen,
    vanilla_function *vf)
void Generators::declare_function?Usage of Generators::declare_function:
Vanilla Functions - §8(code_generation *gen, vanilla_function *vf) {
    VOID_METHOD_CALL(gen->generator, DECLARE_FUNCTION_MTID, gen, vf);
}

§10.

enumerate BEGIN_ARRAY_MTID 

enumerate ARRAY_ENTRY_MTID 

enumerate ARRAY_ENTRIES_MTID 

enumerate END_ARRAY_MTID 

define WORD_ARRAY_FORMAT 1

define BYTE_ARRAY_FORMAT 2

define TABLE_ARRAY_FORMAT 3

define BUFFER_ARRAY_FORMAT 4

INT_METHOD_TYPE(BEGIN_ARRAY_MTID, code_generator *generator, code_generation *gen,
    text_stream *const_name, inter_symbol *array_s, inter_tree_node *P, int zero_count,
    int format, segmentation_pos *saved)
VOID_METHOD_TYPE(ARRAY_ENTRY_MTID, code_generator *generator, code_generation *gen,
    text_stream *entry, int format)
VOID_METHOD_TYPE(ARRAY_ENTRIES_MTID, code_generator *generator, code_generation *gen,
    int how_many, int format)
VOID_METHOD_TYPE(END_ARRAY_MTID, code_generator *generator, code_generation *gen,
    int format, int zero_count, segmentation_pos *saved)
int Generators::begin_array?Usage of Generators::begin_array:
Vanilla Constants - §1.5, §1.6
Vanilla Objects - §2.2.1, §4.1.1.1.1.1
Vanilla IF - §5.1, §5.2, §7, §12(code_generation *gen, text_stream *const_name,
    inter_symbol *array_s, inter_tree_node *P, int format, int zero_count,
    segmentation_pos *saved) {
    int rv = FALSE;
    INT_METHOD_CALL(rv, gen->generator, BEGIN_ARRAY_MTID, gen, const_name, array_s,
        P, format, zero_count, saved);
    return rv;
}
void Generators::array_entry?Usage of Generators::array_entry:
Vanilla Constants - §1.5, §1.6
Vanilla Objects - §2.2.1.1, §2.2.1.2, §4.1.1.1.1.1, §4.1.1.1.1.1.1
Vanilla IF - §6, §7, §12
Inform 6 Objects - §4.6
C Object Model - §20.2(code_generation *gen, text_stream *entry, int format) {
    VOID_METHOD_CALL(gen->generator, ARRAY_ENTRY_MTID, gen, entry, format);
}
void Generators::mangled_array_entry?Usage of Generators::mangled_array_entry:
Vanilla Objects - §2.2.1, §2.2.1.3.3(code_generation *gen, text_stream *entry, int format) {
    TEMPORARY_TEXT(mangled)
    Generators::mangle(gen, mangled, entry);
    VOID_METHOD_CALL(gen->generator, ARRAY_ENTRY_MTID, gen, mangled, format);
    DISCARD_TEXT(mangled)
}
void Generators::symbol_array_entry?Usage of Generators::symbol_array_entry:
Vanilla Objects - §2.2.1.3.1, §2.2.1.3.2, §2.2.1.3.3(code_generation *gen, inter_symbol *entry, int format) {
    Generators::mangled_array_entry(gen, InterSymbol::trans(entry), format);
}

void Generators::end_array?Usage of Generators::end_array:
Vanilla Constants - §1.5, §1.6
Vanilla Objects - §2.2.1, §4.1.1.1.1.1
Vanilla IF - §5.1, §5.2, §7, §12(code_generation *gen, int format, int zero_count,
    segmentation_pos *saved) {
    VOID_METHOD_CALL(gen->generator, END_ARRAY_MTID, gen, format, zero_count, saved);
}

§11.

enumerate DECLARE_CONSTANT_MTID 

define DATA_GDCFORM 1

define COMPUTED_GDCFORM 2

define LITERAL_TEXT_GDCFORM 3

define RAW_GDCFORM 4

define MANGLED_GDCFORM 5

VOID_METHOD_TYPE(DECLARE_CONSTANT_MTID, code_generator *generator, code_generation *gen,
    inter_symbol *const_s, int form, text_stream *val)
void Generators::declare_constant?Usage of Generators::declare_constant:
Vanilla Constants - §1.7, §1.8, §4
Inform 6 Objects - §7.2
C Object Model - §25(code_generation *gen, inter_symbol *const_s, int form,
    text_stream *val) {
    VOID_METHOD_CALL(gen->generator, DECLARE_CONSTANT_MTID, gen, const_s, form, val);
}

§12.

enumerate WORD_TO_BYTE_MTID 

VOID_METHOD_TYPE(WORD_TO_BYTE_MTID, code_generator *generator, code_generation *gen,
    text_stream *to_write, text_stream *val, int b)
void Generators::word_to_byte?Usage of Generators::word_to_byte:
Vanilla IF - §8.2.2.2.1, §11(code_generation *gen, text_stream *to_write,
    text_stream *val, int b) {
    VOID_METHOD_CALL(gen->generator, WORD_TO_BYTE_MTID, gen, to_write, val, b);
}

enumerate PLACE_LABEL_MTID 

enumerate EVALUATE_LABEL_MTID 

VOID_METHOD_TYPE(PLACE_LABEL_MTID, code_generator *generator, code_generation *gen,
    text_stream *label_name)
VOID_METHOD_TYPE(EVALUATE_LABEL_MTID, code_generator *generator, code_generation *gen,
    text_stream *label_name)
void Generators::place_label?Usage of Generators::place_label:
Vanilla Code - §2(code_generation *gen, text_stream *label_name) {
    VOID_METHOD_CALL(gen->generator, PLACE_LABEL_MTID, gen, label_name);
}
void Generators::evaluate_label?Usage of Generators::evaluate_label:
Vanilla Code - §5(code_generation *gen, text_stream *label_name) {
    VOID_METHOD_CALL(gen->generator, EVALUATE_LABEL_MTID, gen, label_name);
}

enumerate PLACE_PROVENANCE_MTID 

VOID_METHOD_TYPE(PLACE_PROVENANCE_MTID, code_generator *generator, code_generation *gen,
    text_provenance *source_loc)
void Generators::place_provenance?Usage of Generators::place_provenance:
Vanilla Code - §7(code_generation *gen, text_provenance *source_loc) {
    VOID_METHOD_CALL(gen->generator, PLACE_PROVENANCE_MTID, gen, source_loc);
}

enumerate INVOKE_PRIMITIVE_MTID 

enumerate INVOKE_FUNCTION_MTID 

enumerate INVOKE_OPCODE_MTID 

enumerate ASSEMBLY_MARKER_MTID 

VOID_METHOD_TYPE(INVOKE_PRIMITIVE_MTID, code_generator *generator, code_generation *gen,
    inter_symbol *prim_name, inter_tree_node *P, int void_context)
VOID_METHOD_TYPE(INVOKE_FUNCTION_MTID, code_generator *generator, code_generation *gen,
    inter_tree_node *P, vanilla_function *vf, int void_context)
VOID_METHOD_TYPE(INVOKE_OPCODE_MTID, code_generator *generator, code_generation *gen,
    text_stream *opcode, int operand_count, inter_tree_node **operands,
    inter_tree_node *label, int label_sense)
VOID_METHOD_TYPE(ASSEMBLY_MARKER_MTID, code_generator *generator, code_generation *gen,
    inter_ti marker)
void Generators::invoke_primitive?Usage of Generators::invoke_primitive:
Vanilla Code - §3.1(code_generation *gen, inter_symbol *prim_name,
    inter_tree_node *P, int void_context) {
    VOID_METHOD_CALL(gen->generator, INVOKE_PRIMITIVE_MTID, gen, prim_name, P, void_context);
}
void Generators::invoke_function?Usage of Generators::invoke_function:
Vanilla Functions - §9(code_generation *gen, inter_tree_node *P,
    vanilla_function *vf, int void_context) {
    VOID_METHOD_CALL(gen->generator, INVOKE_FUNCTION_MTID, gen, P, vf, void_context);
}
void Generators::invoke_opcode?Usage of Generators::invoke_opcode:
Vanilla Code - §3.3(code_generation *gen, text_stream *opcode, int operand_count,
    inter_tree_node **operands, inter_tree_node *label, int label_sense) {
    VOID_METHOD_CALL(gen->generator, INVOKE_OPCODE_MTID, gen, opcode, operand_count,
        operands, label, label_sense);
}
void Generators::assembly_marker?Usage of Generators::assembly_marker:
Vanilla Code - §6(code_generation *gen, inter_ti marker) {
    VOID_METHOD_CALL(gen->generator, ASSEMBLY_MARKER_MTID, gen, marker);
}

§16.

enumerate MANGLE_IDENTIFIER_MTID 

VOID_METHOD_TYPE(MANGLE_IDENTIFIER_MTID, code_generator *generator, text_stream *OUT,
    text_stream *identifier)
void Generators::mangle?Usage of Generators::mangle:
§10
Vanilla Constants - §2
Vanilla IF - §7, §8.2.2.2.1, §8.2.2.2.3, §8.2.2.3, §8.2.3, §12
C Literals - §2
C Object Model - §4, §7, §10, §13, §17, §20.1, §20.2, §22, §24, §25.2
C Function Model - §3, §7, §8.2(code_generation *gen, text_stream *OUT, text_stream *identifier) {
    VOID_METHOD_CALL(gen->generator, MANGLE_IDENTIFIER_MTID, OUT, identifier);
}

§17. Methods called by Vanilla Objects.

enumerate DECLARE_PROPERTY_MTID 

VOID_METHOD_TYPE(DECLARE_PROPERTY_MTID, code_generator *generator, code_generation *gen,
    inter_symbol *prop_name, linked_list *all_forms)
void Generators::declare_property?Usage of Generators::declare_property:
Vanilla Objects - §2.2.1(code_generation *gen, inter_symbol *prop_name,
    linked_list *all_forms) {
    VOID_METHOD_CALL(gen->generator, DECLARE_PROPERTY_MTID, gen, prop_name, all_forms);
}

§18.

enumerate PREPARE_VARIABLE_MTID 

enumerate DECLARE_VARIABLE_MTID 

enumerate DECLARE_VARIABLES_MTID 

enumerate EVALUATE_VARIABLE_MTID 

INT_METHOD_TYPE(PREPARE_VARIABLE_MTID, code_generator *generator, code_generation *gen,
    inter_tree_node *P, inter_symbol *var_name, int k)
INT_METHOD_TYPE(DECLARE_VARIABLE_MTID, code_generator *generator, code_generation *gen,
    inter_tree_node *P, inter_symbol *var_name, int k, int of)
VOID_METHOD_TYPE(DECLARE_VARIABLES_MTID, code_generator *generator, code_generation *gen,
    linked_list *L)
VOID_METHOD_TYPE(DECLARE_LOCAL_VARIABLE_MTID, code_generator *generator,
    code_generation *gen, inter_tree_node *P, inter_symbol *var_name)
VOID_METHOD_TYPE(EVALUATE_VARIABLE_MTID, code_generator *generator, code_generation *gen,
    inter_symbol *var_name, int as_reference)
int Generators::prepare_variable(code_generation *gen, inter_tree_node *P,
    inter_symbol *var_name, int k) {
    int rv = 0;
    INT_METHOD_CALL(rv, gen->generator, PREPARE_VARIABLE_MTID, gen, P, var_name, k);
    return rv;
}
int Generators::declare_variable(code_generation *gen, inter_tree_node *P,
    inter_symbol *var_name, int k, int of) {
    int rv = 0;
    INT_METHOD_CALL(rv, gen->generator, DECLARE_VARIABLE_MTID, gen, P, var_name, k, of);
    return rv;
}
void Generators::declare_variables?Usage of Generators::declare_variables:
Vanilla - §1(code_generation *gen, linked_list *L) {
    VOID_METHOD_CALL(gen->generator, DECLARE_VARIABLES_MTID, gen, L);
}
void Generators::evaluate_variable?Usage of Generators::evaluate_variable:
Vanilla Code - §4(code_generation *gen, inter_symbol *var_name,
    int as_reference) {
    VOID_METHOD_CALL(gen->generator, EVALUATE_VARIABLE_MTID, gen, var_name, as_reference);
}

§19.

enumerate DECLARE_KIND_MTID 

enumerate END_KIND_MTID 

enumerate DECLARE_INSTANCE_MTID 

enumerate END_INSTANCE_MTID 

enumerate ASSIGN_PROPERTY_MTID 

enumerate ASSIGN_PROPERTIES_MTID 

VOID_METHOD_TYPE(DECLARE_KIND_MTID, code_generator *generator, code_generation *gen,
    inter_symbol *kind_s, segmentation_pos *saved)
VOID_METHOD_TYPE(END_KIND_MTID, code_generator *generator, code_generation *gen,
    inter_symbol *kind_s, segmentation_pos saved)
void Generators::declare_kind?Usage of Generators::declare_kind:
Vanilla Objects - §4.1, §4.2(code_generation *gen, inter_symbol *kind_s,
    segmentation_pos *saved) {
    VOID_METHOD_CALL(gen->generator, DECLARE_KIND_MTID, gen, kind_s, saved);
}
void Generators::end_kind?Usage of Generators::end_kind:
Vanilla Objects - §4.1, §4.2(code_generation *gen, inter_symbol *kind_s, segmentation_pos saved) {
    VOID_METHOD_CALL(gen->generator, END_KIND_MTID, gen, kind_s, saved);
}

VOID_METHOD_TYPE(DECLARE_INSTANCE_MTID, code_generator *generator, code_generation *gen,
    inter_symbol *inst_s, inter_symbol *kind_s, int enumeration, segmentation_pos *saved)
VOID_METHOD_TYPE(END_INSTANCE_MTID, code_generator *generator, code_generation *gen,
    inter_symbol *inst_s, inter_symbol *kind_s, segmentation_pos saved)
void Generators::declare_instance?Usage of Generators::declare_instance:
Vanilla Objects - §4.3(code_generation *gen, inter_symbol *inst_s,
    inter_symbol *kind_s, int enumeration, segmentation_pos *saved) {
    VOID_METHOD_CALL(gen->generator, DECLARE_INSTANCE_MTID, gen, inst_s, kind_s, enumeration, saved);
}
void Generators::end_instance?Usage of Generators::end_instance:
Vanilla Objects - §4.3(code_generation *gen, inter_symbol *inst_s,
    inter_symbol *kind_s, segmentation_pos saved) {
    VOID_METHOD_CALL(gen->generator, END_INSTANCE_MTID, gen, inst_s, kind_s, saved);
}

VOID_METHOD_TYPE(ASSIGN_PROPERTY_MTID, code_generator *generator, code_generation *gen,
    inter_symbol *prop_name, inter_pair val, inter_tree_node *X)
VOID_METHOD_TYPE(ASSIGN_PROPERTIES_MTID, code_generator *generator, code_generation *gen,
    inter_symbol *kind_name, inter_symbol *prop_name, text_stream *array)
void Generators::assign_property?Usage of Generators::assign_property:
Vanilla Objects - §4.2.1(code_generation *gen, inter_symbol *prop_name,
    inter_pair val, inter_tree_node *X) {
    VOID_METHOD_CALL(gen->generator, ASSIGN_PROPERTY_MTID, gen, prop_name, val, X);
}
void Generators::assign_properties?Usage of Generators::assign_properties:
Vanilla Objects - §4.1.1.1.1(code_generation *gen, inter_symbol *kind_name,
    inter_symbol *prop_name, text_stream *array) {
    VOID_METHOD_CALL(gen->generator, ASSIGN_PROPERTIES_MTID, gen, kind_name, prop_name, array);
}

§20. Methods used for compiling from Inter pairs.

enumerate COMPILE_DICTIONARY_WORD_MTID 

enumerate COMPILE_LITERAL_NUMBER_MTID 

enumerate COMPILE_LITERAL_REAL_MTID 

enumerate COMPILE_LITERAL_SYMBOL_MTID 

enumerate COMPILE_LITERAL_TEXT_MTID 

VOID_METHOD_TYPE(COMPILE_LITERAL_NUMBER_MTID, code_generator *generator,
    code_generation *gen, inter_ti val, int hex_mode)
VOID_METHOD_TYPE(COMPILE_LITERAL_REAL_MTID, code_generator *generator,
    code_generation *gen, text_stream *textual)
VOID_METHOD_TYPE(COMPILE_LITERAL_SYMBOL_MTID, code_generator *generator,
    code_generation *gen, inter_symbol *aliased)
VOID_METHOD_TYPE(COMPILE_LITERAL_TEXT_MTID, code_generator *generator,
    code_generation *gen, text_stream *S, int escape_mode)
VOID_METHOD_TYPE(COMPILE_DICTIONARY_WORD_MTID, code_generator *generator,
    code_generation *gen, text_stream *S, int pluralise)

void Generators::compile_literal_number?Usage of Generators::compile_literal_number:
Code Generation - §18.1
Vanilla Constants - §2(code_generation *gen, inter_ti val, int hex_mode) {
    VOID_METHOD_CALL(gen->generator, COMPILE_LITERAL_NUMBER_MTID, gen, val, hex_mode);
}
void Generators::compile_literal_real?Usage of Generators::compile_literal_real:
Code Generation - §18.1(code_generation *gen, text_stream *textual) {
    VOID_METHOD_CALL(gen->generator, COMPILE_LITERAL_REAL_MTID, gen, textual);
}
void Generators::compile_literal_symbol?Usage of Generators::compile_literal_symbol:
Code Generation - §18.1
Vanilla Code - §4(code_generation *gen, inter_symbol *aliased) {
    VOID_METHOD_CALL(gen->generator, COMPILE_LITERAL_SYMBOL_MTID, gen, aliased);
}
void Generators::compile_literal_text?Usage of Generators::compile_literal_text:
Code Generation - §18.1
Vanilla Constants - §2
Vanilla Objects - §2.2.1.2
Inform 6 Code - §4(code_generation *gen, text_stream *S, int escape_mode) {
    VOID_METHOD_CALL(gen->generator, COMPILE_LITERAL_TEXT_MTID, gen, S, escape_mode);
}
void Generators::compile_dictionary_word?Usage of Generators::compile_dictionary_word:
Code Generation - §18.1(code_generation *gen, text_stream *S, int pluralise) {
    if ((Str::len(S) > gen->dictionary_resolution) && (gen->dictionary_resolution >= 9)) {
        TEMPORARY_TEXT(truncation)
        WRITE_TO(truncation, "%S", S);
        Str::truncate(truncation, gen->dictionary_resolution);
        if (Dictionaries::find(gen->long_words, truncation) == NULL) {
            Dictionaries::create(gen->long_words, truncation);
            WRITE_TO(Dictionaries::get_text(gen->long_words, truncation), "%S", S);
        } else {
            text_stream *previous = Dictionaries::get_text(gen->long_words, truncation);
            #ifdef CORE_MODULE
            if (Str::ne_insensitive(previous, S)) {
                if (Dictionaries::find(gen->warned_about_words, S) == NULL) {
                    Dictionaries::create(gen->warned_about_words, S);
                    Problems::quote_stream(1, S);
                    Problems::quote_stream(2, previous);
                    Problems::quote_number(3, &(gen->dictionary_resolution));
                    StandardProblems::handmade_warning(Task::syntax_tree(), _p_(WM_LongWords));
                    Problems::issue_problem_segment(
                        "This project places two words '%1' and '%2' into the dictionary "
                        "used for reading player commands. But because they differ only "
                        "after %3 characters, which is the current setting for "
                        "'Use dictionary resolution', this might cause confusion.");
                    Problems::issue_warning_end();
                }
            }
            #endif
            #ifndef CORE_MODULE
            LOG("%S could be mixed up with %S\n", S, previous);
            #endif
        }
        DISCARD_TEXT(truncation)
    }
    VOID_METHOD_CALL(gen->generator, COMPILE_DICTIONARY_WORD_MTID, gen, S, pluralise);
}