mirror of
https://github.com/ganelson/inform.git
synced 2024-07-03 07:24:58 +03:00
648 lines
23 KiB
OpenEdge ABL
648 lines
23 KiB
OpenEdge ABL
[Kinds::Constructors::] Kind Constructors.
|
|
|
|
The mechanism by which Inform records the characteristics of different
|
|
kinds.
|
|
|
|
@ Constructors are divided into four groups:
|
|
|
|
@d PUNCTUATION_GRP 1 /* used in the construction of other kinds only */
|
|
@d PROTOCOL_GRP 2 /* such as |arithmetic value| */
|
|
@d BASE_CONSTRUCTOR_GRP 3 /* such as |number| */
|
|
@d PROPER_CONSTRUCTOR_GRP 4 /* with positive arity, such as "list of ..." */
|
|
|
|
@ Besides all the properties of kinds used in this module, Inform also needs
|
|
to store further metadata in order to be able to make the extensive run-time
|
|
code needed to support all these kinds in actual programs. All of this means
|
|
that a //kind_constructor// object is a great big rag-bag of properties, some
|
|
set by commands in Neptune files, others set by calls from Inform.
|
|
|
|
So, deep breath:
|
|
|
|
@d MAX_KIND_CONSTRUCTION_ARITY 2
|
|
|
|
=
|
|
typedef struct kind_constructor {
|
|
struct noun *dt_tag; /* text of name */
|
|
int group; /* one of the four values above */
|
|
|
|
/* A: how this came into being */
|
|
int is_incompletely_defined; /* newly defined and ambiguous as yet */
|
|
struct parse_node *where_defined_in_source_text; /* if so */
|
|
struct kind *stored_as; /* currently unused: if this is a typedef for some construction */
|
|
|
|
/* B: constructing kinds */
|
|
int constructor_arity; /* 0 for base, 1 for unary, 2 for binary */
|
|
int variance[MAX_KIND_CONSTRUCTION_ARITY]; /* must be |COVARIANT| or |CONTRAVARIANT| */
|
|
int tupling[MAX_KIND_CONSTRUCTION_ARITY]; /* extent to which tupling is permitted */
|
|
struct kind *cached_kind; /* cached result of |Kinds::base_construction| */
|
|
|
|
/* C: compatibility with other kinds */
|
|
struct parse_node *superkind_set_at; /* where it says, e.g., "A rabbit is a kind of animal" */
|
|
struct kind_constructor_casting_rule *first_casting_rule; /* list of these */
|
|
struct kind_constructor_instance *first_instance_rule; /* list of these */
|
|
|
|
/* D: how constant values of this kind are expressed */
|
|
struct literal_pattern *ways_to_write_literals; /* list of ways to write this */
|
|
struct table *named_values_created_with_table; /* alternatively... */
|
|
int next_free_value; /* to make distinguishable instances of this kind */
|
|
int constant_compilation_method; /* one of the |*_CCM| values */
|
|
|
|
/* E: knowledge about values of this kind */
|
|
struct inference_subject *base_as_infs; /* inferences about properties */
|
|
struct text_stream *default_value; /* used for built-in types only */
|
|
|
|
/* F: behaviour as a property as well */
|
|
int can_coincide_with_property; /* allowed to coincide in name with a property */
|
|
struct property *coinciding_property; /* property of the same name, if any */
|
|
|
|
/* G: performing arithmetic */
|
|
struct text_stream *comparison_routine; /* for instance, when sorting table or list entries */
|
|
struct dimensional_rules dim_rules; /* how arithmetic operations work here */
|
|
struct unit_sequence dimensional_form; /* dimensions of this kind */
|
|
int dimensional_form_fixed; /* whether they are derived */
|
|
|
|
/* H: representing this kind at run-time */
|
|
int weak_kind_ID; /* as used at run-time by Inter code */
|
|
struct text_stream *name_in_template_code; /* an Inter identifier */
|
|
int class_number; /* for classes of object */
|
|
#ifdef CORE_MODULE
|
|
struct inter_name *con_iname;
|
|
struct package_request *kc_package;
|
|
#endif
|
|
int small_block_size; /* if stored as a block value, size in words of the SB */
|
|
|
|
/* I: storing values at run-time */
|
|
int multiple_block; /* TRUE for flexible-size values stored on the heap */
|
|
int heap_size_estimate; /* typical number of bytes used */
|
|
int can_exchange; /* with external files and therefore other story files */
|
|
struct text_stream *distinguishing_routine; /* Inter routine to see if values distinguishable */
|
|
struct kind_constructor_comparison_schema *first_comparison_schema; /* list of these */
|
|
struct text_stream *loop_domain_schema; /* how to compile a loop over the instances */
|
|
|
|
/* J: printing and parsing values at run-time */
|
|
#ifdef BYTECODE_MODULE
|
|
struct inter_name *kind_GPR_iname;
|
|
struct inter_name *instance_GPR_iname;
|
|
struct inter_name *first_instance_iname;
|
|
struct inter_name *next_instance_iname;
|
|
struct inter_name *pr_iname;
|
|
struct inter_name *inc_iname;
|
|
struct inter_name *dec_iname;
|
|
struct inter_name *ranger_iname;
|
|
struct inter_name *trace_iname;
|
|
#endif
|
|
struct text_stream *print_identifier; /* an Inter identifier used for compiling printing rules */
|
|
struct text_stream *ACTIONS_identifier; /* ditto but for ACTIONS testing command */
|
|
struct command_grammar *understand_as_values; /* used when parsing such values */
|
|
int needs_GPR; /* a GPR is actually required to be compiled */
|
|
struct text_stream *explicit_GPR_identifier; /* routine name, when not compiled automatically */
|
|
struct text_stream *recognition_routine; /* for recognising an explicit value as preposition */
|
|
|
|
/* K: indexing and documentation */
|
|
struct text_stream *specification_text; /* text for pseudo-property */
|
|
struct text_stream *index_default_value; /* and its description in the Kinds index */
|
|
struct text_stream *index_maximum_value; /* ditto */
|
|
struct text_stream *index_minimum_value; /* ditto */
|
|
int index_priority; /* from 1 (highest) to |LOWEST_INDEX_PRIORITY| (lowest) */
|
|
int linguistic; /* divide off as having linguistics content */
|
|
int indexed_grey_if_empty; /* shaded grey in the Kinds index */
|
|
struct text_stream *documentation_reference; /* documentation symbol, if any */
|
|
|
|
CLASS_DEFINITION
|
|
} kind_constructor;
|
|
|
|
@ A few of the settings connect pairs of kinds together, so structures like
|
|
the following are also needed.
|
|
|
|
=
|
|
typedef struct kind_constructor_casting_rule {
|
|
struct text_stream *cast_from_kind_unparsed; /* to the one which has the rule */
|
|
struct kind_constructor *cast_from_kind; /* to the one which has the rule */
|
|
struct kind_constructor_casting_rule *next_casting_rule;
|
|
} kind_constructor_casting_rule;
|
|
|
|
@ And this is the analogous structure for giving Inter schemas to compare
|
|
data of two different kinds:
|
|
|
|
=
|
|
typedef struct kind_constructor_comparison_schema {
|
|
struct text_stream *comparator_unparsed;
|
|
struct kind_constructor *comparator;
|
|
struct text_stream *comparison_schema;
|
|
struct kind_constructor_comparison_schema *next_comparison_schema;
|
|
} kind_constructor_comparison_schema;
|
|
|
|
@ And this is the analogous structure for giving Inter schemas to compare
|
|
data of two different kinds:
|
|
|
|
=
|
|
typedef struct kind_constructor_instance {
|
|
struct text_stream *instance_of_this_unparsed;
|
|
struct kind_constructor *instance_of_this;
|
|
struct kind_constructor_instance *next_instance_rule;
|
|
} kind_constructor_instance;
|
|
|
|
@ The "tupling" of an argument is the extent to which an argument can be
|
|
allowed to hold a variable-length list of kinds, rather than a single one.
|
|
There aren't actually many possibilities.
|
|
|
|
@d NO_TUPLING 0 /* a single kind */
|
|
@d ALLOW_NOTHING_TUPLING 1 /* a single kind, or "nothing" */
|
|
@d ARBITRARY_TUPLING 10000 /* a list of kinds of any length */
|
|
|
|
@ Constant compilation modes are:
|
|
|
|
@d NONE_CCM 1 /* constant values of this kind cannot exist */
|
|
@d LITERAL_CCM 2 /* a numerical annotation decides the value */
|
|
@d NAMED_CONSTANT_CCM 3 /* an |instance| annotation decides the value */
|
|
@d SPECIAL_CCM 4 /* special code specific to the kind of value is needed */
|
|
|
|
@ We keep track of the newest-created base kind of value (which isn't a kind
|
|
of object) here:
|
|
|
|
= (early code)
|
|
int next_free_data_type_ID = 2; /* i.e., leaving room for |UNKNOWN_TY| to be 1 at run-time */
|
|
kind *latest_base_kind_of_value = NULL;
|
|
|
|
@h Creation.
|
|
Constructors come from two sources. Built-in ones like |number| or
|
|
|list of K| come from commands in //Neptune Files//, while source-created
|
|
ones ("Air pressure is a kind of value") result in calls here from
|
|
//Kinds::new_base// -- which, as the name suggests, can only make
|
|
base kinds, not proper constructors.
|
|
|
|
Here |super| will be the super-constructor, the one which this will construct
|
|
subkinds of. In practice this will be |NULL| when |CON_VALUE| is created, and
|
|
then |CON_VALUE| for kinds like "number" or this one:
|
|
|
|
>> Weight is a kind of value.
|
|
|
|
but will be the constructor for "door" for kinds like this one:
|
|
|
|
>> Portal is a kind of door.
|
|
|
|
=
|
|
kind_constructor *Kinds::Constructors::new(kind_constructor *super,
|
|
text_stream *source_name, text_stream *initialisation_macro, int group) {
|
|
kind_constructor *con = CREATE(kind_constructor);
|
|
kind_constructor **pC = FamiliarKinds::known_con(source_name);
|
|
if (pC) *pC = con;
|
|
|
|
if (super == Kinds::get_construct(K_value)) @<Fill in a new constructor@>
|
|
else @<Copy the new constructor from its superconstructor@>;
|
|
con->group = group;
|
|
|
|
con->name_in_template_code = Str::new();
|
|
#ifdef CORE_MODULE
|
|
con->con_iname = NULL;
|
|
con->kc_package = NULL;
|
|
#endif
|
|
if (Str::len(source_name) > 0) WRITE_TO(con->name_in_template_code, "%S", source_name);
|
|
#ifdef CORE_MODULE
|
|
KindSubjects::new(con);
|
|
#endif
|
|
con->where_defined_in_source_text = current_sentence;
|
|
|
|
kind **pK = FamiliarKinds::known_kind(source_name);
|
|
if (pK) *pK = Kinds::base_construction(con);
|
|
return con;
|
|
}
|
|
|
|
@ If our new constructor is wholly new, and isn't a subkind of something else,
|
|
we need to initialise the entire data structure; but note that, having done so,
|
|
we apply any defaults set in Neptune files.
|
|
|
|
@d LOWEST_INDEX_PRIORITY 100
|
|
|
|
@<Fill in a new constructor@> =
|
|
con->dt_tag = NULL;
|
|
con->group = 0; /* which is invalid, so the interpreter needs to set it */
|
|
|
|
/* A: how this came into being */
|
|
con->is_incompletely_defined = FALSE;
|
|
con->where_defined_in_source_text = NULL; /* but will be filled in imminently */
|
|
con->stored_as = NULL;
|
|
|
|
/* B: constructing kinds */
|
|
con->constructor_arity = 0; /* by default a base constructor */
|
|
int i;
|
|
for (i=0; i<MAX_KIND_CONSTRUCTION_ARITY; i++) {
|
|
con->variance[i] = COVARIANT;
|
|
con->tupling[i] = NO_TUPLING;
|
|
}
|
|
con->cached_kind = NULL;
|
|
|
|
/* C: compatibility with other kinds */
|
|
con->superkind_set_at = NULL;
|
|
con->first_casting_rule = NULL;
|
|
con->first_instance_rule = NULL;
|
|
|
|
/* D: how constant values of this kind are expressed */
|
|
con->ways_to_write_literals = NULL;
|
|
con->named_values_created_with_table = NULL;
|
|
con->next_free_value = 1;
|
|
con->constant_compilation_method = NONE_CCM;
|
|
|
|
/* E: knowledge about values of this kind */
|
|
con->base_as_infs = NULL; /* but will be filled in imminently, in almost all cases */
|
|
con->default_value = Str::new();
|
|
|
|
/* F: behaviour as a property as well */
|
|
con->can_coincide_with_property = FALSE;
|
|
con->coinciding_property = NULL;
|
|
|
|
/* G: performing arithmetic */
|
|
con->comparison_routine = Str::new();
|
|
WRITE_TO(con->comparison_routine, "UnsignedCompare");
|
|
if ((con == CON_KIND_VARIABLE) || (con == CON_INTERMEDIATE) ||
|
|
((Str::eq_wide_string(source_name, L"NUMBER_TY")) ||
|
|
(Str::eq_wide_string(source_name, L"REAL_NUMBER_TY"))))
|
|
con->dimensional_form =
|
|
Kinds::Dimensions::fundamental_unit_sequence(NULL);
|
|
else
|
|
con->dimensional_form =
|
|
Kinds::Dimensions::fundamental_unit_sequence(Kinds::base_construction(con));
|
|
con->dimensional_form_fixed = FALSE;
|
|
Kinds::Dimensions::dim_initialise(&(con->dim_rules));
|
|
|
|
/* H: representing this kind at run-time */
|
|
con->weak_kind_ID = next_free_data_type_ID++;
|
|
con->name_in_template_code = Str::new();
|
|
con->class_number = 0;
|
|
|
|
/* I: storing values at run-time */
|
|
con->multiple_block = FALSE;
|
|
con->small_block_size = 1;
|
|
con->heap_size_estimate = 0;
|
|
con->can_exchange = FALSE;
|
|
con->first_comparison_schema = NULL;
|
|
con->distinguishing_routine = NULL;
|
|
con->loop_domain_schema = NULL;
|
|
|
|
/* J: printing and parsing values at run-time */
|
|
con->print_identifier = Str::new();
|
|
con->ACTIONS_identifier = Str::new();
|
|
#ifdef BYTECODE_MODULE
|
|
con->kind_GPR_iname = NULL;
|
|
con->instance_GPR_iname = NULL;
|
|
con->first_instance_iname = NULL;
|
|
con->next_instance_iname = NULL;
|
|
con->pr_iname = NULL;
|
|
con->inc_iname = NULL;
|
|
con->dec_iname = NULL;
|
|
con->ranger_iname = NULL;
|
|
con->trace_iname = NULL;
|
|
if (Str::len(source_name) == 0) {
|
|
package_request *R = Kinds::Constructors::package(con);
|
|
con->pr_iname = Hierarchy::make_iname_in(PRINT_DASH_FN_HL, R);
|
|
con->trace_iname = con->pr_iname;
|
|
}
|
|
#endif
|
|
|
|
con->understand_as_values = NULL;
|
|
con->needs_GPR = FALSE;
|
|
con->explicit_GPR_identifier = NULL;
|
|
con->recognition_routine = NULL;
|
|
|
|
/* K: indexing and documentation */
|
|
con->specification_text = NULL;
|
|
con->index_default_value = I"--";
|
|
con->index_maximum_value = I"--";
|
|
con->index_minimum_value = I"--";
|
|
con->index_priority = LOWEST_INDEX_PRIORITY;
|
|
if ((group == PUNCTUATION_GRP) || (group == PROTOCOL_GRP))
|
|
con->index_priority = 0;
|
|
con->linguistic = FALSE;
|
|
con->indexed_grey_if_empty = FALSE;
|
|
con->documentation_reference = NULL;
|
|
|
|
kind_macro_definition *set_defaults = NULL;
|
|
switch (group) {
|
|
case PUNCTUATION_GRP: set_defaults = NeptuneMacros::parse_name(I"#PUNCTUATION"); break;
|
|
case PROTOCOL_GRP:set_defaults = NeptuneMacros::parse_name(I"#PROTOCOL"); break;
|
|
case BASE_CONSTRUCTOR_GRP: set_defaults = NeptuneMacros::parse_name(I"#BASE"); break;
|
|
case PROPER_CONSTRUCTOR_GRP: set_defaults = NeptuneMacros::parse_name(I"#CONSTRUCTOR"); break;
|
|
}
|
|
if (set_defaults) NeptuneMacros::play_back(set_defaults, con, NULL);
|
|
|
|
if (Str::len(initialisation_macro) > 0)
|
|
NeptuneMacros::play_back(NeptuneMacros::parse_name(initialisation_macro), con, NULL);
|
|
|
|
@ However, if we create our constructor as a subkind, like so:
|
|
|
|
>> A turtle is a kind of animal.
|
|
|
|
then we copy the entire "animal" constructor to initialise the "turtle" one.
|
|
|
|
Note that the weak ID number is one of the things copied; this is deliberate.
|
|
It means that all kinds of object share the same weak ID as "object".
|
|
|
|
@<Copy the new constructor from its superconstructor@> =
|
|
int I = con->allocation_id;
|
|
void *N = con->next_structure;
|
|
void *P = con->prev_structure;
|
|
*con = *super;
|
|
con->allocation_id = I;
|
|
con->next_structure = N;
|
|
con->prev_structure = P;
|
|
con->cached_kind = NULL; /* otherwise the superkind's cache is used by mistake */
|
|
con->name_in_template_code = Str::new(); /* otherwise this will be called |OBJECT_TY| by mistake */
|
|
|
|
@h The noun.
|
|
It's a requirement that the following be called soon after the creation
|
|
of the constructor:
|
|
|
|
=
|
|
void Kinds::Constructors::attach_noun(kind_constructor *con, noun *nt) {
|
|
if ((con == NULL) || (nt == NULL)) internal_error("bad noun attachment");
|
|
con->dt_tag = nt;
|
|
}
|
|
|
|
wording Kinds::Constructors::get_name(kind_constructor *con, int plural_form) {
|
|
if (con->dt_tag) {
|
|
noun *nt = con->dt_tag;
|
|
if (nt) return Nouns::nominative(nt, plural_form);
|
|
}
|
|
return EMPTY_WORDING;
|
|
}
|
|
|
|
wording Kinds::Constructors::get_name_in_play(kind_constructor *con, int plural_form,
|
|
NATURAL_LANGUAGE_WORDS_TYPE *nl) {
|
|
if (con->dt_tag) {
|
|
noun *nt = con->dt_tag;
|
|
if (nt) return Nouns::nominative_in_language(nt, plural_form, nl);
|
|
}
|
|
return EMPTY_WORDING;
|
|
}
|
|
|
|
noun *Kinds::Constructors::get_noun(kind_constructor *con) {
|
|
if (con == NULL) return NULL;
|
|
return con->dt_tag;
|
|
}
|
|
|
|
@h Inter identifiers.
|
|
An identifier like |WHATEVER_TY|, then, begins life in a definition inside an
|
|
Neptune file; becomes attached to a constructor here; and finally winds up
|
|
back in Inter code, because we define it as the constant for the weak kind ID
|
|
of the kind which the constructor makes:
|
|
|
|
=
|
|
#ifdef CORE_MODULE
|
|
void Kinds::Constructors::emit_constants(void) {
|
|
kind_constructor *con;
|
|
LOOP_OVER(con, kind_constructor) {
|
|
text_stream *tn = Kinds::Constructors::name_in_template_code(con);
|
|
if (Str::len(tn) > 0) {
|
|
con->con_iname = Hierarchy::make_iname_with_specific_name(WEAK_ID_HL,
|
|
tn, Kinds::Constructors::package(con));
|
|
Hierarchy::make_available(Emit::tree(), con->con_iname);
|
|
Emit::named_numeric_constant(con->con_iname, (inter_ti) con->weak_kind_ID);
|
|
}
|
|
}
|
|
|
|
inter_name *hwm = Hierarchy::find(BASE_KIND_HWM_HL);
|
|
Emit::named_numeric_constant(hwm, (inter_ti) next_free_data_type_ID);
|
|
Hierarchy::make_available(Emit::tree(), hwm);
|
|
}
|
|
inter_name *Kinds::Constructors::UNKNOWN_iname(void) {
|
|
return CON_UNKNOWN->con_iname;
|
|
}
|
|
package_request *Kinds::Constructors::package(kind_constructor *con) {
|
|
if (con->kc_package == NULL) {
|
|
if (con->where_defined_in_source_text) {
|
|
compilation_unit *C = CompilationUnits::find(con->where_defined_in_source_text);
|
|
con->kc_package = Hierarchy::package(C, KIND_HAP);
|
|
} else if (con->superkind_set_at) {
|
|
compilation_unit *C = CompilationUnits::find(con->superkind_set_at);
|
|
con->kc_package = Hierarchy::package(C, KIND_HAP);
|
|
} else {
|
|
con->kc_package = Hierarchy::synoptic_package(KIND_HAP);
|
|
}
|
|
wording W = Kinds::Constructors::get_name(con, FALSE);
|
|
if (Wordings::nonempty(W))
|
|
Hierarchy::markup_wording(con->kc_package, KIND_NAME_HMD, W);
|
|
else if (Str::len(con->name_in_template_code) > 0)
|
|
Hierarchy::markup(con->kc_package, KIND_NAME_HMD, con->name_in_template_code);
|
|
else
|
|
Hierarchy::markup(con->kc_package, KIND_NAME_HMD, I"(anonymous kind)");
|
|
}
|
|
return con->kc_package;
|
|
}
|
|
inter_name *Kinds::Constructors::iname(kind_constructor *con) {
|
|
return con->con_iname;
|
|
}
|
|
inter_name *Kinds::Constructors::first_instance_iname(kind_constructor *con) {
|
|
return con->first_instance_iname;
|
|
}
|
|
void Kinds::Constructors::set_first_instance_iname(kind_constructor *con, inter_name *iname) {
|
|
con->first_instance_iname = iname;
|
|
}
|
|
inter_name *Kinds::Constructors::next_instance_iname(kind_constructor *con) {
|
|
return con->next_instance_iname;
|
|
}
|
|
void Kinds::Constructors::set_next_instance_iname(kind_constructor *con, inter_name *iname) {
|
|
con->next_instance_iname = iname;
|
|
}
|
|
#endif
|
|
|
|
text_stream *Kinds::Constructors::name_in_template_code(kind_constructor *con) {
|
|
return con->name_in_template_code;
|
|
}
|
|
|
|
@ We also need to parse this, occasionally (if we needed this more than a
|
|
small and bounded number of times we'd want a faster method, but we don't):
|
|
|
|
=
|
|
kind_constructor *Kinds::Constructors::parse(text_stream *sn) {
|
|
if (sn == NULL) return NULL;
|
|
kind_constructor *con;
|
|
LOOP_OVER(con, kind_constructor)
|
|
if (Str::eq(sn, con->name_in_template_code))
|
|
return con;
|
|
return NULL;
|
|
}
|
|
|
|
@h Transformations.
|
|
Conversions of an existing constructor to make it a unit or enumeration also
|
|
require running macros in the kind interpreter:
|
|
|
|
=
|
|
int Kinds::Constructors::convert_to_unit(kind_constructor *con) {
|
|
if (con->is_incompletely_defined == TRUE) {
|
|
NeptuneMacros::play_back(NeptuneMacros::parse_name(I"#UNIT"), con, NULL);
|
|
return TRUE;
|
|
}
|
|
if (Kinds::Constructors::is_arithmetic(con)) return TRUE; /* i.e., if it succeeded */
|
|
return FALSE;
|
|
}
|
|
|
|
int Kinds::Constructors::convert_to_enumeration(kind_constructor *con) {
|
|
if (con->is_incompletely_defined == TRUE) {
|
|
NeptuneMacros::play_back(NeptuneMacros::parse_name(I"#ENUMERATION"), con, NULL);
|
|
if (con->linguistic)
|
|
NeptuneMacros::play_back(NeptuneMacros::parse_name(I"#LINGUISTIC"), con, NULL);
|
|
return TRUE;
|
|
}
|
|
if (Kinds::Constructors::is_enumeration(con)) return TRUE; /* i.e., if it succeeded */
|
|
return FALSE;
|
|
}
|
|
|
|
@ And similarly:
|
|
|
|
=
|
|
void Kinds::Constructors::convert_to_real(kind_constructor *con) {
|
|
NeptuneMacros::play_back(NeptuneMacros::parse_name(I"#REAL"), con, NULL);
|
|
}
|
|
|
|
@ A few base kinds are marked as "linguistic", which simply enables us to fence
|
|
them tidily off in the index.
|
|
|
|
=
|
|
void Kinds::Constructors::mark_as_linguistic(kind_constructor *con) {
|
|
con->linguistic = TRUE;
|
|
}
|
|
|
|
@h For construction purposes.
|
|
|
|
=
|
|
kind **Kinds::Constructors::cache_location(kind_constructor *con) {
|
|
if (con) return &(con->cached_kind);
|
|
return NULL;
|
|
}
|
|
|
|
int Kinds::Constructors::arity(kind_constructor *con) {
|
|
if (con == NULL) return 0;
|
|
if (con->group == PROPER_CONSTRUCTOR_GRP) return con->constructor_arity;
|
|
return 0;
|
|
}
|
|
|
|
int Kinds::Constructors::tupling(kind_constructor *con, int b) {
|
|
return con->tupling[b];
|
|
}
|
|
|
|
int Kinds::Constructors::variance(kind_constructor *con, int b) {
|
|
return con->variance[b];
|
|
}
|
|
|
|
@h Questions about constructors.
|
|
The rest of Inform is not encouraged to poke at constructors directly; it
|
|
ought to ask questions about kinds instead (see "Using Kinds"). However:
|
|
|
|
=
|
|
int Kinds::Constructors::is_definite(kind_constructor *con) {
|
|
if ((con->group == BASE_CONSTRUCTOR_GRP) ||
|
|
(con->group == PROPER_CONSTRUCTOR_GRP))
|
|
return TRUE;
|
|
if ((con == CON_VOID) || (con == CON_NIL) || (con == CON_INTERMEDIATE))
|
|
return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
int Kinds::Constructors::get_weak_ID(kind_constructor *con) {
|
|
if (con == NULL) return 0;
|
|
return con->weak_kind_ID;
|
|
}
|
|
|
|
int Kinds::Constructors::offers_I6_GPR(kind_constructor *con) {
|
|
if (con == NULL) return FALSE;
|
|
if ((Kinds::Constructors::is_definite(con)) &&
|
|
(Kinds::Constructors::compatible(con,
|
|
Kinds::get_construct(K_understandable_value), FALSE))) return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
int Kinds::Constructors::is_arithmetic(kind_constructor *con) {
|
|
if (con == NULL) return FALSE;
|
|
if ((Kinds::Constructors::is_definite(con)) &&
|
|
(Kinds::Constructors::compatible(con,
|
|
Kinds::get_construct(K_arithmetic_value), FALSE))) return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
int Kinds::Constructors::is_arithmetic_and_real(kind_constructor *con) {
|
|
if (con == NULL) return FALSE;
|
|
if ((Kinds::Constructors::is_definite(con)) &&
|
|
(Kinds::Constructors::compatible(con,
|
|
Kinds::get_construct(K_real_arithmetic_value), FALSE))) return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
int Kinds::Constructors::is_enumeration(kind_constructor *con) {
|
|
if (con == NULL) return FALSE;
|
|
if ((Kinds::Constructors::is_definite(con)) &&
|
|
(Kinds::Constructors::compatible(con,
|
|
Kinds::get_construct(K_enumerated_value), FALSE))) return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
@h Cast and instance lists.
|
|
Each constructor has a list of other constructors (all of the |PROTOCOL_GRP|
|
|
group) which it's an instance of: value, word value, arithmetic value, and so on.
|
|
|
|
=
|
|
int Kinds::Constructors::find_cast(kind_constructor *from, kind_constructor *to) {
|
|
if (to) {
|
|
kind_constructor_casting_rule *dtcr;
|
|
for (dtcr = to->first_casting_rule; dtcr; dtcr = dtcr->next_casting_rule) {
|
|
if (Str::len(dtcr->cast_from_kind_unparsed) > 0) {
|
|
dtcr->cast_from_kind =
|
|
Kinds::Constructors::parse(dtcr->cast_from_kind_unparsed);
|
|
Str::clear(dtcr->cast_from_kind_unparsed);
|
|
}
|
|
if (from == dtcr->cast_from_kind)
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
@ Each constructor has a list of other constructors (all of the |BASE_CONSTRUCTOR_GRP|
|
|
group or |PROPER_CONSTRUCTOR_GRP|) which it can cast to.
|
|
|
|
=
|
|
int Kinds::Constructors::find_instance(kind_constructor *from, kind_constructor *to) {
|
|
kind_constructor_instance *dti;
|
|
for (dti = from->first_instance_rule; dti; dti = dti->next_instance_rule) {
|
|
if (Str::len(dti->instance_of_this_unparsed) > 0) {
|
|
dti->instance_of_this =
|
|
Kinds::Constructors::parse(dti->instance_of_this_unparsed);
|
|
Str::clear(dti->instance_of_this_unparsed);
|
|
}
|
|
if (dti->instance_of_this == to) return TRUE;
|
|
if (Kinds::Constructors::find_instance(dti->instance_of_this, to)) return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
@h Compatibility.
|
|
The following tests if |from| is compatible with |to|.
|
|
|
|
=
|
|
int Kinds::Constructors::compatible(kind_constructor *from, kind_constructor *to,
|
|
int allow_casts) {
|
|
if (to == from) return TRUE;
|
|
if ((to == NULL) || (from == NULL)) return FALSE;
|
|
if ((allow_casts) && (Kinds::Constructors::find_cast(from, to))) return TRUE;
|
|
if (Kinds::Constructors::find_instance(from, to)) return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
@ And more elaborately:
|
|
|
|
=
|
|
int Kinds::Constructors::uses_pointer_values(kind_constructor *con) {
|
|
if (con == NULL) return FALSE;
|
|
if ((Kinds::Constructors::is_definite(con)) &&
|
|
(Kinds::Constructors::compatible(con, Kinds::get_construct(K_pointer_value), FALSE)))
|
|
return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
int Kinds::Constructors::allow_word_as_pointer(kind_constructor *left,
|
|
kind_constructor *right) {
|
|
if (Kinds::Constructors::uses_pointer_values(left) == FALSE) return FALSE;
|
|
if (Kinds::Constructors::uses_pointer_values(right) == TRUE) return FALSE;
|
|
if (Kinds::Constructors::compatible(right, left, TRUE)) return TRUE;
|
|
return FALSE;
|
|
}
|