Inter constants for, say, extremal number values, which depend only on the target we are compiling to, and are generally low-level in nature.

§1.

void GenericModule::compile(void) {
    Emit::rudimentary_kinds();
    GenericModule::compile_basic_constants();
    RTVerbs::compile_generic_constants();
    RTCommandGrammars::compile_generic_constants();
    RTPlayer::compile_generic_constants();
    RTRelations::compile_generic_constants();
}

§2. The generic module depends on the VM, but on nothing else.

void GenericModule::compile_basic_constants?Usage of GenericModule::compile_basic_constants:
§1(void) {
    target_vm *VM = Task::vm();
    if (VM == NULL) internal_error("target VM not set yet");

    if (TargetVMs::debug_enabled(VM)) GenericModule::emit_one(DEBUG_HL, 1);

    if (TargetVMs::is_16_bit(VM)) 16-bit constants2.1
    else 32-bit constants2.2;
}

§2.1. These constants mostly have obvious meanings, but a few notes:

• (1) NULL, in our runtime, is -1, and not 0 as it would be in C. This is emitted as "unchecked" to avoid the value being rejected as being too large, as it would be if it were viewed as a signed rather than unsigned integer.
• (2) IMPROBABLE_VALUE is one which is unlikely even if possible to be a genuine I7 value. The efficiency of runtime code handling tables depends on how well chosen this is: it would ran badly if we chose 1, for instance.
• (3) REPARSE_CODE is a magic value used in CommandParserKit to signal that some code which ought to have been parsing a command has in fact rewritten it, so that the whole command must be re-parsed afresh. That doesn't sound very "fundamental", but in fact it depends on the word size, because it needs to be a large number but also such that an address in the VM can be added to it without it becoming negative.

16-bit constants2.1 =

    GenericModule::emit_one(WORDSIZE_HL,                         2);
    GenericModule::emit_unchecked_hex(NULL_HL,              0xffff);
    GenericModule::emit_hex(WORD_HIGHBIT_HL,                0x8000);
    GenericModule::emit_hex(WORD_NEXTTOHIGHBIT_HL,          0x4000);
    GenericModule::emit_hex(IMPROBABLE_VALUE_HL,            0x7fe3);
    GenericModule::emit_hex(REPARSE_CODE_HL,                 10000);
    GenericModule::emit_one(MAX_POSITIVE_NUMBER_HL,          32767);
    GenericModule::emit_signed(MIN_NEGATIVE_NUMBER_HL,      -32768);
    GenericModule::emit_one(TARGET_ZCODE_HL,                     1);
    GenericModule::emit_one(DICT_WORD_SIZE_HL,                   6);

• This code is used in §2.

§2.2. 32-bit constants2.2 =

    GenericModule::emit_one(WORDSIZE_HL,                         4);
    GenericModule::emit_unchecked_hex(NULL_HL,          0xffffffff);
    GenericModule::emit_hex(WORD_HIGHBIT_HL,            0x80000000);
    GenericModule::emit_hex(WORD_NEXTTOHIGHBIT_HL,      0x40000000);
    GenericModule::emit_hex(IMPROBABLE_VALUE_HL,        0xdeadce11);
    GenericModule::emit_hex(REPARSE_CODE_HL,            0x40000000);
    GenericModule::emit_one(MAX_POSITIVE_NUMBER_HL,     2147483647);
    GenericModule::emit_signed(MIN_NEGATIVE_NUMBER_HL, -2147483648);
    GenericModule::emit_one(TARGET_GLULX_HL,                     1);
    GenericModule::emit_one(DICT_WORD_SIZE_HL,                   9);
    GenericModule::emit_one(INDIV_PROP_START_HL,                 0);

• This code is used in §2.

§3. Note that all of these constants are made available for linking:

void GenericModule::emit_one?Usage of GenericModule::emit_one:
§2, §2.1, §2.2(int id, inter_ti val) {
    inter_name *iname = Hierarchy::find(id);
    Hierarchy::make_available(iname);
    Emit::numeric_constant(iname, val);
}
void GenericModule::emit_signed?Usage of GenericModule::emit_signed:
§2.1, §2.2(int id, int val) {
    inter_name *iname = Hierarchy::find(id);
    Hierarchy::make_available(iname);
    Emit::named_numeric_constant_signed(iname, val);
}
void GenericModule::emit_hex?Usage of GenericModule::emit_hex:
§2.1, §2.2(int id, inter_ti val) {
    inter_name *iname = Hierarchy::find(id);
    Hierarchy::make_available(iname);
    Emit::named_numeric_constant_hex(iname, val);
}
void GenericModule::emit_unchecked_hex?Usage of GenericModule::emit_unchecked_hex:
§2.1, §2.2(int id, inter_ti val) {
    inter_name *iname = Hierarchy::find(id);
    Hierarchy::make_available(iname);
    Emit::named_unchecked_constant_hex(iname, val);
}