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
Generating C - §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 private to this section.

§2. And they are mass-produced here:

int cgts_made = FALSE;

void CodeGen::Targets::make_targets?Usage of CodeGen::Targets::make_targets:
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();
        CodeGen::C::create_target();
    }
}

§3.

enum BEGIN_GENERATION_MTID
enum END_GENERATION_MTID

INT_METHOD_TYPE(BEGIN_GENERATION_MTID, code_generation_target *cgt, code_generation *gen)
INT_METHOD_TYPE(END_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;
}
int CodeGen::Targets::end_generation?Usage of CodeGen::Targets::end_generation:
Code Generation - §1(code_generation *gen) {
    int rv = FALSE;
    INT_METHOD_CALL(rv, gen->target, END_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 MANGLE_IDENTIFIER_MTID

VOID_METHOD_TYPE(MANGLE_IDENTIFIER_MTID, code_generation_target *cgt, text_stream *OUT, text_stream *identifier)
void CodeGen::Targets::mangle?Usage of CodeGen::Targets::mangle:
§12, §18
Frame Control - §2
Constants and Literals - §2(code_generation *gen, text_stream *OUT, text_stream *identifier) {
    VOID_METHOD_CALL(gen->target, MANGLE_IDENTIFIER_MTID, OUT, identifier);
}

§6.

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;
}

§7.

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);
}

§8.

enum COMPILE_LITERAL_NUMBER_MTID

VOID_METHOD_TYPE(COMPILE_LITERAL_NUMBER_MTID, code_generation_target *cgt, code_generation *gen, inter_ti val, int hex_mode)
void CodeGen::Targets::compile_literal_number?Usage of CodeGen::Targets::compile_literal_number:
Constants and Literals - §2(code_generation *gen, inter_ti val, int hex_mode) {
    VOID_METHOD_CALL(gen->target, COMPILE_LITERAL_NUMBER_MTID, gen, val, hex_mode);
}

§9.

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
Instances and Properties - §5.11.1(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);
}

§10.

enum DECLARE_PROPERTY_MTID
enum DECLARE_ATTRIBUTE_MTID

VOID_METHOD_TYPE(DECLARE_PROPERTY_MTID, code_generation_target *cgt, code_generation *gen, inter_symbol *prop_name, int used)
VOID_METHOD_TYPE(DECLARE_ATTRIBUTE_MTID, code_generation_target *cgt, code_generation *gen, text_stream *prop_name)
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);
}
void CodeGen::Targets::declare_attribute?Usage of CodeGen::Targets::declare_attribute:
Instances and Properties - §4.5(code_generation *gen, text_stream *prop_name) {
    VOID_METHOD_CALL(gen->target, DECLARE_ATTRIBUTE_MTID, gen, prop_name);
}

§11.

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, int pass, 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 - §1, §2(int pass, code_generation *gen, inter_tree_node *P, inter_symbol *var_name) {
    VOID_METHOD_CALL(gen->target, DECLARE_LOCAL_VARIABLE_MTID, pass, gen, P, var_name);
}

§12.

enum DECLARE_CLASS_MTID
enum END_CLASS_MTID
enum DECLARE_INSTANCE_MTID
enum END_INSTANCE_MTID
enum ASSIGN_PROPERTY_MTID
enum PROPERTY_OFFSET_MTID

VOID_METHOD_TYPE(DECLARE_CLASS_MTID, code_generation_target *cgt, code_generation *gen, text_stream *class_name)
VOID_METHOD_TYPE(END_CLASS_MTID, code_generation_target *cgt, code_generation *gen, text_stream *class_name)
void CodeGen::Targets::declare_class?Usage of CodeGen::Targets::declare_class:
Instances and Properties - §5.8.1, §5.9(code_generation *gen, text_stream *class_name) {
    VOID_METHOD_CALL(gen->target, DECLARE_CLASS_MTID, gen, class_name);
}
void CodeGen::Targets::end_class?Usage of CodeGen::Targets::end_class:
Instances and Properties - §5.8.1, §5.9(code_generation *gen, text_stream *class_name) {
    VOID_METHOD_CALL(gen->target, END_CLASS_MTID, gen, class_name);
}
VOID_METHOD_TYPE(DECLARE_INSTANCE_MTID, code_generation_target *cgt, code_generation *gen, text_stream *class_name, text_stream *instance_name)
VOID_METHOD_TYPE(END_INSTANCE_MTID, code_generation_target *cgt, code_generation *gen, text_stream *class_name, text_stream *instance_name)
void CodeGen::Targets::declare_instance?Usage of CodeGen::Targets::declare_instance:
Instances and Properties - §5.5, §5.8(code_generation *gen, text_stream *class_name, text_stream *instance_name) {
    VOID_METHOD_CALL(gen->target, DECLARE_INSTANCE_MTID, gen, class_name, instance_name);
}
void CodeGen::Targets::end_instance?Usage of CodeGen::Targets::end_instance:
Instances and Properties - §5.5, §5.8(code_generation *gen, text_stream *class_name, text_stream *instance_name) {
    VOID_METHOD_CALL(gen->target, END_INSTANCE_MTID, gen, class_name, instance_name);
}
VOID_METHOD_TYPE(ASSIGN_PROPERTY_MTID, code_generation_target *cgt, code_generation *gen, text_stream *property_name, text_stream *val, int as_att)
void CodeGen::Targets::assign_property?Usage of CodeGen::Targets::assign_property:
Instances and Properties - §5.5, §5.8, §8(code_generation *gen, text_stream *property_name, text_stream *val, int as_att) {
    VOID_METHOD_CALL(gen->target, ASSIGN_PROPERTY_MTID, gen, property_name, val, as_att);
}
void CodeGen::Targets::assign_mangled_property?Usage of CodeGen::Targets::assign_mangled_property:
Instances and Properties - §5.8.4(code_generation *gen, text_stream *property_name, text_stream *val, int as_att) {
    TEMPORARY_TEXT(mangled)
    CodeGen::Targets::mangle(gen, mangled, val);
    CodeGen::Targets::assign_property(gen, property_name, mangled, as_att);
    DISCARD_TEXT(mangled)
}

VOID_METHOD_TYPE(PROPERTY_OFFSET_MTID, code_generation_target *cgt, code_generation *gen, text_stream *property_name, int pos, int as_att)
void CodeGen::Targets::property_offset?Usage of CodeGen::Targets::property_offset:
Instances and Properties - §5.11(code_generation *gen, text_stream *property_name, int pos, int as_att) {
    VOID_METHOD_CALL(gen->target, PROPERTY_OFFSET_MTID, gen, property_name, pos, as_att);
}

§13.

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);
}

§14.

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, int ifndef_me)
VOID_METHOD_TYPE(END_CONSTANT_MTID, code_generation_target *cgt, code_generation *gen, text_stream *const_name, int ifndef_me)
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, int ifndef_me) {
    VOID_METHOD_CALL(gen->target, BEGIN_CONSTANT_MTID, gen, const_name, continues, ifndef_me);
}
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, int ifndef_me) {
    VOID_METHOD_CALL(gen->target, END_CONSTANT_MTID, gen, const_name, ifndef_me);
}

§15.

enum BEGIN_FUNCTION_MTID
enum BEGIN_FUNCTION_CODE_MTID
enum PLACE_LABEL_MTID
enum END_FUNCTION_MTID

VOID_METHOD_TYPE(BEGIN_FUNCTION_MTID, code_generation_target *cgt, int pass, code_generation *gen, inter_symbol *fn)
VOID_METHOD_TYPE(BEGIN_FUNCTION_CODE_MTID, code_generation_target *cgt, code_generation *gen)
VOID_METHOD_TYPE(PLACE_LABEL_MTID, code_generation_target *cgt, code_generation *gen, text_stream *label_name)
VOID_METHOD_TYPE(END_FUNCTION_MTID, code_generation_target *cgt, int pass, code_generation *gen, inter_symbol *fn)
void CodeGen::Targets::begin_function?Usage of CodeGen::Targets::begin_function:
Frame Control - §1
Constants and Literals - §2(int pass, code_generation *gen, inter_symbol *fn) {
    VOID_METHOD_CALL(gen->target, BEGIN_FUNCTION_MTID, pass, gen, fn);
}
void CodeGen::Targets::begin_function_code?Usage of CodeGen::Targets::begin_function_code:
Frame Control - §2(code_generation *gen) {
    VOID_METHOD_CALL(gen->target, BEGIN_FUNCTION_CODE_MTID, gen);
}
void CodeGen::Targets::place_label?Usage of CodeGen::Targets::place_label:
Frame Control - §2(code_generation *gen, text_stream *label_name) {
    VOID_METHOD_CALL(gen->target, PLACE_LABEL_MTID, gen, label_name);
}
void CodeGen::Targets::end_function?Usage of CodeGen::Targets::end_function:
Frame Control - §1
Constants and Literals - §2(int pass, code_generation *gen, inter_symbol *fn) {
    VOID_METHOD_CALL(gen->target, END_FUNCTION_MTID, pass, gen, fn);
}

§16.

enum BEGIN_FUNCTION_CALL_MTID
enum ARGUMENT_MTID
enum END_FUNCTION_CALL_MTID

VOID_METHOD_TYPE(BEGIN_FUNCTION_CALL_MTID, code_generation_target *cgt, code_generation *gen, inter_symbol *fn, int argc)
VOID_METHOD_TYPE(ARGUMENT_MTID, code_generation_target *cgt, code_generation *gen, inter_tree_node *F, inter_symbol *fn, int argc, int of_argc)
VOID_METHOD_TYPE(END_FUNCTION_CALL_MTID, code_generation_target *cgt, code_generation *gen, inter_symbol *fn, int argc)
void CodeGen::Targets::begin_function_call?Usage of CodeGen::Targets::begin_function_call:
Frame Control - §3(code_generation *gen, inter_symbol *fn, int argc) {
    VOID_METHOD_CALL(gen->target, BEGIN_FUNCTION_CALL_MTID, gen, fn, argc);
}
void CodeGen::Targets::argument?Usage of CodeGen::Targets::argument:
Frame Control - §3(code_generation *gen, inter_tree_node *F, inter_symbol *fn, int argc, int of_argc) {
    VOID_METHOD_CALL(gen->target, ARGUMENT_MTID, gen, F, fn, argc, of_argc);
}
void CodeGen::Targets::end_function_call?Usage of CodeGen::Targets::end_function_call:
Frame Control - §3(code_generation *gen, inter_symbol *fn, int argc) {
    VOID_METHOD_CALL(gen->target, END_FUNCTION_CALL_MTID, gen, fn, argc);
}

§17.

enum BEGIN_OPCODE_MTID
enum SUPPLY_OPERAND_MTID
enum END_OPCODE_MTID

VOID_METHOD_TYPE(BEGIN_OPCODE_MTID, code_generation_target *cgt, code_generation *gen, text_stream *opcode)
VOID_METHOD_TYPE(SUPPLY_OPERAND_MTID, code_generation_target *cgt, code_generation *gen, inter_tree_node *F, int is_label)
VOID_METHOD_TYPE(END_OPCODE_MTID, code_generation_target *cgt, code_generation *gen)
void CodeGen::Targets::begin_opcode?Usage of CodeGen::Targets::begin_opcode:
Frame Control - §3(code_generation *gen, text_stream *opcode) {
    VOID_METHOD_CALL(gen->target, BEGIN_OPCODE_MTID, gen, opcode);
}
void CodeGen::Targets::supply_operand?Usage of CodeGen::Targets::supply_operand:
Frame Control - §3(code_generation *gen, inter_tree_node *F, int is_label) {
    VOID_METHOD_CALL(gen->target, SUPPLY_OPERAND_MTID, gen, F, is_label);
}
void CodeGen::Targets::end_opcode?Usage of CodeGen::Targets::end_opcode:
Frame Control - §3(code_generation *gen) {
    VOID_METHOD_CALL(gen->target, END_OPCODE_MTID, gen);
}

§18.

enum BEGIN_ARRAY_MTID
enum ARRAY_ENTRY_MTID
enum END_ARRAY_MTID
define WORD_ARRAY_FORMAT 1
define BYTE_ARRAY_FORMAT 2
define TABLE_ARRAY_FORMAT 3
define BUFFER_ARRAY_FORMAT 4

VOID_METHOD_TYPE(BEGIN_ARRAY_MTID, code_generation_target *cgt, code_generation *gen, text_stream *const_name, int format)
VOID_METHOD_TYPE(ARRAY_ENTRY_MTID, code_generation_target *cgt, code_generation *gen, text_stream *entry, int format)
VOID_METHOD_TYPE(END_ARRAY_MTID, code_generation_target *cgt, code_generation *gen, int format)
void CodeGen::Targets::begin_array?Usage of CodeGen::Targets::begin_array:
Constants and Literals - §2
Instances and Properties - §5.7, §5.8.3, §5.8.5.1, §5.11(code_generation *gen, text_stream *const_name, int format) {
    VOID_METHOD_CALL(gen->target, BEGIN_ARRAY_MTID, gen, const_name, format);
}
void CodeGen::Targets::array_entry?Usage of CodeGen::Targets::array_entry:
Constants and Literals - §2
Instances and Properties - §5.7, §5.8.3, §5.8.5.1, §5.8.5.1.1, §5.11.1(code_generation *gen, text_stream *entry, int format) {
    VOID_METHOD_CALL(gen->target, ARRAY_ENTRY_MTID, gen, entry, format);
}
void CodeGen::Targets::mangled_array_entry?Usage of CodeGen::Targets::mangled_array_entry:
Instances and Properties - §5.7, §5.8.3, §5.11, §5.11.2.1, §5.11.2.2(code_generation *gen, text_stream *entry, int format) {
    TEMPORARY_TEXT(mangled)
    CodeGen::Targets::mangle(gen, mangled, entry);
    VOID_METHOD_CALL(gen->target, ARRAY_ENTRY_MTID, gen, mangled, format);
    DISCARD_TEXT(mangled)
}
void CodeGen::Targets::end_array?Usage of CodeGen::Targets::end_array:
Constants and Literals - §2
Instances and Properties - §5.7, §5.8.3, §5.8.5.1, §5.11(code_generation *gen, int format) {
    VOID_METHOD_CALL(gen->target, END_ARRAY_MTID, gen, format);
}

§19.

enum NEW_FAKE_ACTION_MTID

VOID_METHOD_TYPE(NEW_FAKE_ACTION_MTID, code_generation_target *cgt, code_generation *gen, text_stream *name)
void CodeGen::Targets::new_fake_action?Usage of CodeGen::Targets::new_fake_action:
Constants and Literals - §2(code_generation *gen, text_stream *name) {
    VOID_METHOD_CALL(gen->target, NEW_FAKE_ACTION_MTID, gen, name);
}