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

• §1. Targets

§1. Targets. Single, steel-cut artisanal targets are made here:

typedef struct code_generation_target {
    struct text_stream *target_name;
    struct method_set *methods;
    CLASS_DEFINITION
} code_generation_target;

code_generation_target *CodeGen::Targets::new?Usage of CodeGen::Targets::new:
Final Textual Inter - §1
Final Binary Inter - §1
Final Inventory - §1
Generating Inform 6 - §1(text_stream *name) {
    code_generation_target *cgt = CREATE(code_generation_target);
    cgt->target_name = Str::duplicate(name);
    cgt->methods = Methods::new_set();
    return cgt;
}

• The structure code_generation_target is accessed in 1/ppl and here.

§2. And they are mass-produced here:

int cgts_made = FALSE;

void CodeGen::Targets::make_targets?Usage of CodeGen::Targets::make_targets:
Pipelines - §3
Frame Control - §2(void) {
    if (cgts_made == FALSE) {
        cgts_made = TRUE;
        CodeGen::Textual::create_target();
        CodeGen::Binary::create_target();
        CodeGen::Inventory::create_target();
        CodeGen::I6::create_target();
    }
}

§3.

enum BEGIN_GENERATION_MTID

INT_METHOD_TYPE(BEGIN_GENERATION_MTID, code_generation_target *cgt, code_generation *gen)
int CodeGen::Targets::begin_generation?Usage of CodeGen::Targets::begin_generation:
Code Generation - §1(code_generation *gen) {
    int rv = FALSE;
    INT_METHOD_CALL(rv, gen->target, BEGIN_GENERATION_MTID, gen);
    return rv;
}

§4.

enum GENERAL_SEGMENT_MTID
enum DEFAULT_SEGMENT_MTID
enum BASIC_CONSTANT_SEGMENT_MTID
enum CONSTANT_SEGMENT_MTID
enum PROPERTY_SEGMENT_MTID
enum TL_SEGMENT_MTID

INT_METHOD_TYPE(GENERAL_SEGMENT_MTID, code_generation_target *cgt, code_generation *gen, inter_tree_node *P)
INT_METHOD_TYPE(DEFAULT_SEGMENT_MTID, code_generation_target *cgt, code_generation *gen)
INT_METHOD_TYPE(BASIC_CONSTANT_SEGMENT_MTID, code_generation_target *cgt, code_generation *gen, int depth)
INT_METHOD_TYPE(CONSTANT_SEGMENT_MTID, code_generation_target *cgt, code_generation *gen)
INT_METHOD_TYPE(PROPERTY_SEGMENT_MTID, code_generation_target *cgt, code_generation *gen)
INT_METHOD_TYPE(TL_SEGMENT_MTID, code_generation_target *cgt, code_generation *gen)

int CodeGen::Targets::general_segment?Usage of CodeGen::Targets::general_segment:
Frame Control - §1(code_generation *gen, inter_tree_node *P) {
    int rv = 0;
    INT_METHOD_CALL(rv, gen->target, GENERAL_SEGMENT_MTID, gen, P);
    return rv;
}

int CodeGen::Targets::default_segment?Usage of CodeGen::Targets::default_segment:
Instances and Properties - §1(code_generation *gen) {
    int rv = 0;
    INT_METHOD_CALL(rv, gen->target, DEFAULT_SEGMENT_MTID, gen);
    return rv;
}

int CodeGen::Targets::constant_segment?Usage of CodeGen::Targets::constant_segment:
Instances and Properties - §4.6, §5(code_generation *gen) {
    int rv = 0;
    INT_METHOD_CALL(rv, gen->target, CONSTANT_SEGMENT_MTID, gen);
    return rv;
}

int CodeGen::Targets::basic_constant_segment?Usage of CodeGen::Targets::basic_constant_segment:
Constants and Literals - §2
Instances and Properties - §4.5(code_generation *gen, int depth) {
    int rv = 0;
    INT_METHOD_CALL(rv, gen->target, BASIC_CONSTANT_SEGMENT_MTID, gen, depth);
    return rv;
}

int CodeGen::Targets::property_segment(code_generation *gen) {
    int rv = 0;
    INT_METHOD_CALL(rv, gen->target, PROPERTY_SEGMENT_MTID, gen);
    return rv;
}

int CodeGen::Targets::tl_segment?Usage of CodeGen::Targets::tl_segment:
Constants and Literals - §2(code_generation *gen) {
    int rv = 0;
    INT_METHOD_CALL(rv, gen->target, TL_SEGMENT_MTID, gen);
    return rv;
}

§5.

enum COMPILE_PRIMITIVE_MTID

INT_METHOD_TYPE(COMPILE_PRIMITIVE_MTID, code_generation_target *cgt, code_generation *gen, inter_symbol *prim_name, inter_tree_node *P)
int CodeGen::Targets::compile_primitive?Usage of CodeGen::Targets::compile_primitive:
Frame Control - §3(code_generation *gen, inter_symbol *prim_name, inter_tree_node *P) {
    int rv = FALSE;
    INT_METHOD_CALL(rv, gen->target, COMPILE_PRIMITIVE_MTID, gen, prim_name, P);
    return rv;
}

§6.

enum COMPILE_DICTIONARY_WORD_MTID

VOID_METHOD_TYPE(COMPILE_DICTIONARY_WORD_MTID, code_generation_target *cgt, code_generation *gen, text_stream *S, int pluralise)
void CodeGen::Targets::compile_dictionary_word?Usage of CodeGen::Targets::compile_dictionary_word:
Constants and Literals - §2(code_generation *gen, text_stream *S, int pluralise) {
    VOID_METHOD_CALL(gen->target, COMPILE_DICTIONARY_WORD_MTID, gen, S, pluralise);
}

§7.

enum COMPILE_LITERAL_TEXT_MTID

VOID_METHOD_TYPE(COMPILE_LITERAL_TEXT_MTID, code_generation_target *cgt, code_generation *gen, text_stream *S, int print_mode, int box_mode)
void CodeGen::Targets::compile_literal_text?Usage of CodeGen::Targets::compile_literal_text:
Constants and Literals - §2(code_generation *gen, text_stream *S, int print_mode, int box_mode) {
    VOID_METHOD_CALL(gen->target, COMPILE_LITERAL_TEXT_MTID, gen, S, print_mode, box_mode);
}

§8.

enum DECLARE_PROPERTY_MTID

VOID_METHOD_TYPE(DECLARE_PROPERTY_MTID, code_generation_target *cgt, code_generation *gen, inter_symbol *prop_name, int used)
void CodeGen::Targets::declare_property?Usage of CodeGen::Targets::declare_property:
Instances and Properties - §5.1, §5.12(code_generation *gen, inter_symbol *prop_name, int used) {
    VOID_METHOD_CALL(gen->target, DECLARE_PROPERTY_MTID, gen, prop_name, used);
}

§9.

enum PREPARE_VARIABLE_MTID
enum DECLARE_VARIABLE_MTID
enum DECLARE_LOCAL_VARIABLE_MTID

INT_METHOD_TYPE(PREPARE_VARIABLE_MTID, code_generation_target *cgt, code_generation *gen, inter_tree_node *P, inter_symbol *var_name, int k)
INT_METHOD_TYPE(DECLARE_VARIABLE_MTID, code_generation_target *cgt, code_generation *gen, inter_tree_node *P, inter_symbol *var_name, int k, int of)
VOID_METHOD_TYPE(DECLARE_LOCAL_VARIABLE_MTID, code_generation_target *cgt, code_generation *gen, inter_tree_node *P, inter_symbol *var_name)
int CodeGen::Targets::prepare_variable?Usage of CodeGen::Targets::prepare_variable:
Variables - §1(code_generation *gen, inter_tree_node *P, inter_symbol *var_name, int k) {
    int rv = 0;
    INT_METHOD_CALL(rv, gen->target, PREPARE_VARIABLE_MTID, gen, P, var_name, k);
    return rv;
}
int CodeGen::Targets::declare_variable?Usage of CodeGen::Targets::declare_variable:
Variables - §1(code_generation *gen, inter_tree_node *P, inter_symbol *var_name, int k, int of) {
    int rv = 0;
    INT_METHOD_CALL(rv, gen->target, DECLARE_VARIABLE_MTID, gen, P, var_name, k, of);
    return rv;
}
void CodeGen::Targets::declare_local_variable?Usage of CodeGen::Targets::declare_local_variable:
Frame Control - §2(code_generation *gen, inter_tree_node *P, inter_symbol *var_name) {
    VOID_METHOD_CALL(gen->target, DECLARE_LOCAL_VARIABLE_MTID, gen, P, var_name);
}

§10.

enum OFFER_PRAGMA_MTID

VOID_METHOD_TYPE(OFFER_PRAGMA_MTID, code_generation_target *cgt, code_generation *gen, inter_tree_node *P, text_stream *tag, text_stream *content)
void CodeGen::Targets::offer_pragma?Usage of CodeGen::Targets::offer_pragma:
Code Generation - §9(code_generation *gen, inter_tree_node *P, text_stream *tag, text_stream *content) {
    VOID_METHOD_CALL(gen->target, OFFER_PRAGMA_MTID, gen, P, tag, content);
}

§11.

enum BEGIN_CONSTANT_MTID
enum END_CONSTANT_MTID

VOID_METHOD_TYPE(BEGIN_CONSTANT_MTID, code_generation_target *cgt, code_generation *gen, text_stream *const_name, int continues)
VOID_METHOD_TYPE(END_CONSTANT_MTID, code_generation_target *cgt, code_generation *gen, text_stream *const_name)
void CodeGen::Targets::begin_constant?Usage of CodeGen::Targets::begin_constant:
Constants and Literals - §2
Instances and Properties - §4.6, §5, §6(code_generation *gen, text_stream *const_name, int continues) {
    VOID_METHOD_CALL(gen->target, BEGIN_CONSTANT_MTID, gen, const_name, continues);
}
void CodeGen::Targets::end_constant?Usage of CodeGen::Targets::end_constant:
Constants and Literals - §2
Instances and Properties - §4.6, §5, §6(code_generation *gen, text_stream *const_name) {
    VOID_METHOD_CALL(gen->target, END_CONSTANT_MTID, gen, const_name);
}