109 lines
3.5 KiB
Text
109 lines
3.5 KiB
Text
[Enumerations::] Enumerated Constants.
|
|
|
|
To define sequentially numbered values for families of constants.
|
|
|
|
@ The idea here is that each enumeration set is a sequence of named constants
|
|
with a given postfix: for example, [[HARRY_ST]], [[NEVILLE_ST]], [[ANGELINA_ST]]
|
|
form the [[*_ST]] set. By definition, the postfix part is the portion of the
|
|
name following the final underscore, so in this case [[ST]].
|
|
|
|
Each set of constants begins at a given value (typically 0) and then
|
|
increments sequentially in definition order.
|
|
|
|
<<*>>=
|
|
typedef struct enumeration_set {
|
|
struct text_stream *postfix;
|
|
struct text_stream *stub;
|
|
int first_value;
|
|
int next_free_value;
|
|
struct source_line *last_observed_at;
|
|
CLASS_DEFINITION
|
|
} enumeration_set;
|
|
|
|
@ There won't be enough sets to make a hash table worth the overhead, so
|
|
compare all against all:
|
|
|
|
<<*>>=
|
|
enumeration_set *Enumerations::find(text_stream *post) {
|
|
enumeration_set *es = NULL;
|
|
LOOP_OVER(es, enumeration_set)
|
|
if (Str::eq(post, es->postfix))
|
|
return es;
|
|
return NULL;
|
|
}
|
|
|
|
@ The following is called when an enumeration is found. If [[from]] has a
|
|
sensible value, this is the start of a new enumeration set; otherwise it's
|
|
a further constant in what ought to be an existing set.
|
|
|
|
<<*>>=
|
|
void Enumerations::define(OUTPUT_STREAM, text_stream *symbol,
|
|
text_stream *from, source_line *L) {
|
|
TEMPORARY_TEXT(pf)
|
|
<<Find the postfix in this symbol name>>;
|
|
enumeration_set *es = Enumerations::find(pf);
|
|
if (from == NULL) <<Continue existing set>>
|
|
else <<Begin new set>>;
|
|
DISCARD_TEXT(pf)
|
|
if (es) es->last_observed_at = L;
|
|
}
|
|
|
|
@ So for instance [[HARRY_ST]] to [[ST]]:
|
|
|
|
<<Find the postfix in this symbol name>>=
|
|
match_results mr = Regexp::create_mr();
|
|
if (Regexp::match(&mr, symbol, L"%c*_(%C+?)")) Str::copy(pf, mr.exp[0]);
|
|
else {
|
|
Main::error_in_web(I"enumeration constants must belong to a _FAMILY", L);
|
|
WRITE_TO(pf, "BOGUS");
|
|
}
|
|
Regexp::dispose_of(&mr);
|
|
|
|
<<Continue existing set>>=
|
|
if (es) {
|
|
if (es->stub) WRITE("(%S+", es->stub);
|
|
WRITE("%d", es->next_free_value++);
|
|
if (es->stub) WRITE(")");
|
|
} else Main::error_in_web(I"this enumeration _FAMILY is unknown", L);
|
|
|
|
<<Begin new set>>=
|
|
if (es) Main::error_in_web(I"this enumeration _FAMILY already exists", L);
|
|
else {
|
|
es = CREATE(enumeration_set);
|
|
es->postfix = Str::duplicate(pf);
|
|
es->stub = NULL;
|
|
if ((Str::len(from) < 8) &&
|
|
((Regexp::match(NULL, from, L"%d+")) ||
|
|
(Regexp::match(NULL, from, L"-%d+")))) {
|
|
es->first_value = Str::atoi(from, 0);
|
|
es->next_free_value = es->first_value + 1;
|
|
} else {
|
|
es->stub = Str::duplicate(from);
|
|
es->first_value = 0;
|
|
es->next_free_value = 1;
|
|
}
|
|
}
|
|
if (es->stub) WRITE("(%S+", es->stub);
|
|
WRITE("%d", es->first_value);
|
|
if (es->stub) WRITE(")");
|
|
|
|
@ For each set, a further constant is defined to give the range; for example,
|
|
we would have [[NO_DEFINED_ST_VALUES]] set to 3. This is notionally placed in
|
|
the code at the last line on which an [[*_ST]] value was defined.
|
|
|
|
<<*>>=
|
|
void Enumerations::define_extents(OUTPUT_STREAM, tangle_target *target, programming_language *lang) {
|
|
enumeration_set *es;
|
|
LOOP_OVER(es, enumeration_set) {
|
|
TEMPORARY_TEXT(symbol)
|
|
TEMPORARY_TEXT(value)
|
|
WRITE_TO(symbol, "NO_DEFINED_%S_VALUES", es->postfix);
|
|
WRITE_TO(value, "%d", es->next_free_value - es->first_value);
|
|
LanguageMethods::start_definition(OUT, lang, symbol, value,
|
|
es->last_observed_at->owning_section, es->last_observed_at);
|
|
LanguageMethods::end_definition(OUT, lang,
|
|
es->last_observed_at->owning_section, es->last_observed_at);
|
|
DISCARD_TEXT(symbol)
|
|
DISCARD_TEXT(value)
|
|
}
|
|
}
|