Setting up the use of this module.
+ +§1. This section simoly sets up the module in ways expected by foundation, and +contains no code of interest. The following constant exists only in tools +which use this module: +
+ +define ASSERTIONS_MODULE TRUE ++
§2. Like all modules, this one must define a start and end function: +
+ ++void AssertionsModule::start(void) { +} +void AssertionsModule::end(void) { +} ++ + +
To keep track of the current object and subject of discussion.
+ +§1. Inform is deliberately minimal when allowing the use of pronouns which carry +meanings from one sentence to another. It is unclear exactly how natural +language does this, and while some theories are more persuasive than others, +all seem vulnerable to odd cases that they get "wrong". It's therefore +hard to program a computer to understand "it" so that human users are +happy with the result. +
+ +But we try, just a little, by keeping track of the subject and object +under discussion. Even this is tricky. Consider: +
+ +++ +The Pavilion is a room. East is the Cricket Square.
+
East of where? Clearly of the current subject, the Pavilion (not +the room kind). On the other hand, +
+ +++ +On the desk is a pencil. It has description "2B."
+
"It" here is the pencil, not the desk. To disentangle such things, +we keep track of two different running references: the current subject and +the current object. English is an SVO language, so that in assertions of the +form "X is Y", X is the subject and Y the object. But it will turn out to +be more complicated than that, because we disregard all references which are +not to tangible things and kinds. +
+ ++inference_subject *Anaphora::get_current_subject(void) { + return global_pass_state.subject_of_sentences; +} + +inference_subject *Anaphora::get_current_object(void) { + return global_pass_state.object_of_sentences; +} + +int Anaphora::get_current_subject_plurality(void) { + return global_pass_state.subject_seems_to_be_plural; +} ++
§2. The routine Anaphora::new_discussion is called when we reach a +heading or other barrier in the source text, to make clear that there has +been a change of the topic discussed. +
+ +Anaphora::change_discussion_topic is called once at the end of +processing each assertion during each pass. +
+ +Note that we are careful to avoid changing the subject with sentences like: +
+ +++ +East is the Central Plaza.
+
where this does not have the subject "east", but has instead an implicit +subject carried over from previous sentences. +
+ ++void Anaphora::new_discussion(void) { + if (global_pass_state.subject_of_sentences) + LOGIF(PRONOUNS, "[Forgotten subject of sentences: $j]\n", + global_pass_state.subject_of_sentences); + if (global_pass_state.subject_of_sentences) + LOGIF(PRONOUNS, "[Forgotten object of sentences: $j]\n", + global_pass_state.object_of_sentences); + global_pass_state.subject_of_sentences = NULL; + global_pass_state.object_of_sentences = NULL; + global_pass_state.subject_seems_to_be_plural = FALSE; +} ++
§3. The slight asymmetry in what follows is partly pragmatic, partly the result +of subject-verb inversion ("in the bag is the ball" not "the ball is in the +bag"). We extract a subject from a relationship node on the left, but not on +the right, and we don't extract an object from one. Consider: +
+ +++ +A billiards table is in the Gazebo. On it is a trophy cup.
+
What does "it" mean, and why? A human reader goes for the billiards table at +once, because it seems more likely as a supporter than the Gazebo, but that's +not how Inform gets the same answer. It all hangs on "billiards table" being +the object of the first sentence, not the Gazebo; if we descended the RHS, +which is RELATIONSHIP_NT -> PROPER_NOUN_NT pointing to the Gazebo, that's the +conclusion we would have reached. +
+ ++void Anaphora::change_discussion_from_coupling(parse_node *px, parse_node *py) { + inference_subject *infsx = NULL, *infsy = NULL, *infsy_full = NULL; + infsx = Anaphora::discussed_at_node(px); + infsy_full = Anaphora::discussed_at_node(py); + if (Node::get_type(py) != KIND_NT) infsy = Node::get_subject(py); + Anaphora::change_discussion_topic(infsx, infsy, infsy_full); + if (Node::get_type(px) == AND_NT) Anaphora::subject_of_discussion_a_list(); + if (Annotations::read_int(current_sentence, clears_pronouns_ANNOT)) + Anaphora::new_discussion(); +} + +void Anaphora::change_discussion_topic(inference_subject *infsx, + inference_subject *infsy, inference_subject *infsy_full) { + inference_subject *old_sub = global_pass_state.subject_of_sentences, + *old_obj = global_pass_state.object_of_sentences; + global_pass_state.subject_seems_to_be_plural = FALSE; + if (Wordings::length(Node::get_text(current_sentence)) > 1) + global_pass_state.near_start_of_extension = 0; + Node::set_interpretation_of_subject(current_sentence, + global_pass_state.subject_of_sentences); + + if (Annotations::node_has(current_sentence, implicit_in_creation_of_ANNOT)) + return; + #ifdef IF_MODULE + if ((PL::Map::is_a_direction(infsx)) && + ((InferenceSubjects::as_object_instance(infsx) == NULL) || + (InferenceSubjects::as_object_instance(infsy_full)))) infsx = NULL; + #endif + if (infsx) global_pass_state.subject_of_sentences = infsx; + if ((infsy) && (InferenceSubjects::domain(infsy) == NULL)) + global_pass_state.object_of_sentences = infsy; + else if (infsx) global_pass_state.object_of_sentences = infsx; + + if (global_pass_state.subject_of_sentences != old_sub) + LOGIF(PRONOUNS, "[Changed subject of sentences to $j]\n", + global_pass_state.subject_of_sentences); + if (global_pass_state.object_of_sentences != old_obj) + LOGIF(PRONOUNS, "[Changed object of sentences to $j]\n", + global_pass_state.object_of_sentences); +} ++ + +
+inference_subject *Anaphora::discussed_at_node(parse_node *pn) { + inference_subject *infs = NULL; + if (Node::get_type(pn) != KIND_NT) infs = Node::get_subject(pn); + if ((Node::get_type(pn) == RELATIONSHIP_NT) && (pn->down) && + (Node::get_type(pn->down) == PROPER_NOUN_NT)) + infs = Node::get_subject(pn->down); + if ((Node::get_type(pn) == WITH_NT) && (pn->down) && + (Node::get_type(pn->down) == PROPER_NOUN_NT)) + infs = Node::get_subject(pn->down); + return infs; +} ++
§5. Occasionally we need to force the issue, though: +
+ ++void Anaphora::subject_of_discussion_a_list(void) { + global_pass_state.subject_seems_to_be_plural = TRUE; +} ++ + +
In Inform even verbs are created with natural language sentences, but this process has to start somewhere.
+ +§1. "Booting" is the traditional computing term for "pulling yourself up by +your own bootstraps": when a computer switches on it has no program to run, +but to load in a program would require a program. The circularity is broken +by having a minimal "boot" program wired into the hardware. +
+ +So too with Inform. The opening sentence of the Basic Inform extension, always +the first sentence read in, is: +
+ +++ +The verb to mean means the meaning relation.
+
(See Preamble (in basic_inform).) But this is circular: if we have not yet +defined "to mean", how can we recognise "means" as the verb, or know what it +means? We break this circularity by hard-wiring it, as follows. +
+ ++void BootVerbs::make_built_in(void) { + verb *to_mean; + special_meaning_holder *meaning_of_mean; + Create the special meanings1.3; + Create the verbs to be and to mean1.5; + Give meaning to mean1.6; +} ++
§1.1. "Regular" meanings involve relations between two values: for example, carrying +and numerical greater-than are both regular meanings, of the verbs "to carry" +and > respectively. +
+ +"Special" meanings are different. The noun phrases need not represent values, +there need not be two of them, and the meaning can have internal significance +to the Inform compiler. For example, +
+ +++ +Black king chess piece translates into Unicode as 9818.
+
is one of three special meanings of "to translate into". The linguistics +module decides which if any is meant in a given case by calling the "special +meaning functions" to see if wants to accept the sentence in question. +
+ +§1.2. When the linguistics module looks for a primary verb, it may find +multiple candidates: consider "fruit flies like a banana", where "flies" and +"like" are both candidate verbs. We decide by (a) ranking verbs in tiers by +"priority number", and failing that (b) choosing the leftmost. Priority 0 +verbs are never considered, but otherwise low priority numbers beat higher. +(See Verb Usages (in linguistics).) +
+ +Inform adopts the following convention for the priority of regular meanings: +
+ +As can be seen below, special meanings have priorities between 1 and 4. Note +that "to mean" itself has both a special meaning (priority 3) and a regular +meaning (priority 4). This is why the sentence: +
+ +++ +The verb to mean means the meaning relation.
+
is not circular. It uses the special meaning of "mean" (priority 3) to create +the regular one (4). +
+ +§1.3. So, then, here are the core module's special meanings. Just like regular +meanings, which have names like "containment relation", special meanings have +names. But as these names are only used in early boot sentences in the +basic_inform extension, the user never sees them. They are required to +be a single word, and are hyphenated. +
+ +Create the special meanings1.3 = +
+ ++ SpecialMeanings::declare(RelationRequests::new_relation_SMF, I"new-relation", 1); + SpecialMeanings::declare(Rules::Placement::substitutes_for_SMF, I"rule-substitutes-for", 1); + SpecialMeanings::declare(Rules::Placement::does_nothing_SMF, I"rule-does-nothing", 1); + SpecialMeanings::declare(Rules::Placement::does_nothing_if_SMF, I"rule-does-nothing-if", 1); + SpecialMeanings::declare(Rules::Placement::does_nothing_unless_SMF, I"rule-does-nothing-unless", 1); + SpecialMeanings::declare(Translations::translates_into_unicode_as_SMF, I"translates-into-unicode", 1); + SpecialMeanings::declare(Translations::translates_into_Inter_as_SMF, I"translates-into-i6", 1); + SpecialMeanings::declare(Translations::translates_into_language_as_SMF, I"translates-into-language", 1); + + SpecialMeanings::declare(TestRequests::test_with_SMF, I"test-with", 1); + + SpecialMeanings::declare(NewVerbRequests::new_verb_SMF, I"new-verb", 2); + SpecialMeanings::declare(Plurals::plural_SMF, I"new-plural", 2); + SpecialMeanings::declare(ActivityRequests::new_activity_SMF, I"new-activity", 2); + SpecialMeanings::declare(NewAdjectiveRequests::new_adjective_SMF, I"new-adjective", 2); + SpecialMeanings::declare(NewPropertyRequests::either_SMF, I"new-either-or", 2); + SpecialMeanings::declare(DefineByTable::defined_by_SMF, I"defined-by-table", 2); + SpecialMeanings::declare(Rules::Placement::listed_in_SMF, I"rule-listed-in", 2); + SpecialMeanings::declare(NewPropertyRequests::optional_either_SMF, I"can-be", 2); + + meaning_of_mean = SpecialMeanings::declare(NewVerbRequests::verb_means_SMF, I"verb-means", 3); + + SpecialMeanings::declare(LPRequests::specifies_SMF, I"specifies-notation", 4); + SpecialMeanings::declare(NewUseOptions::use_translates_as_SMF, I"use-translates", 4); + SpecialMeanings::declare(UseOptions::use_SMF, I"use", 4); + SpecialMeanings::declare(Sentences::DLRs::include_in_SMF, I"include-in", 4); + SpecialMeanings::declare(Sentences::DLRs::omit_from_SMF, I"omit-from", 4); + + #ifdef MULTIMEDIA_MODULE + MultimediaMeanings::bootstrap(); + #endif + #ifdef IF_MODULE + IFModuleMeanings::bootstrap(); + #endif ++
§1.4. We need the English infinitive forms of two verbs to get started. In each +case we use the inflections module to conjugate them — i.e., to generate +all the other forms, "is", "did not mean" and so on — and then hand them to +the linguistics module to add to its stock of known verbs. (It starts out +with none, so these are initially the only two.) +
+ +We need to create "to be" first because (a) it is the only copular verb in +Inform, and there is no way to create a copular verb using Inform source text; +and (b) because this enables us to conjugate forms of "mean" such as "X is +meant by" — note the use of "is". +
+ ++<bootstrap-verb> ::= + be | + mean ++
§1.5. Create the verbs to be and to mean1.5 = +
+ ++ word_assemblage infinitive = PreformUtilities::wording(<bootstrap-verb>, 0); + verb_conjugation *vc = Conjugation::conjugate(infinitive, DefaultLanguage::get(NULL)); + verb *to_be = Verbs::new_verb(vc, TRUE); note that "to be" is created as copular + vc->vc_conjugates = to_be; + VerbUsages::register_all_usages_of_verb(to_be, FALSE, 2, NULL); + + infinitive = PreformUtilities::wording(<bootstrap-verb>, 1); + vc = Conjugation::conjugate(infinitive, DefaultLanguage::get(NULL)); + to_mean = Verbs::new_verb(vc, FALSE); but "to mean" is not + vc->vc_conjugates = to_mean; + VerbUsages::register_all_usages_of_verb(to_mean, FALSE, 3, NULL); ++
§1.6. Those two verbs are now part of our linguistic stock, but do not yet mean +anything. We need to give the build-in "verb-means" meaning to "to mean": +
+ +Give meaning to mean1.6 = +
+ ++ if ((to_mean == NULL) || (meaning_of_mean == NULL)) internal_error("could not make to mean"); + Verbs::add_form(to_mean, NULL, NULL, VerbMeanings::special(meaning_of_mean), SVO_FS_BIT); ++
To work out the verbs used and to diagram sentences in the source.
+ +§1. Traversing for primary verbs. The story so far: the supervisor module has arranged for the source +text to be read in by words and has made a rudimentary parse tree for +it using syntax. Certain "structural" sentences, such as headings, have +been taken care of, and turned into nodes with types like HEADING_NT. +
+ +But the assertions we want to read — such as "The Mona Lisa is in the Louvre", +or "The plural of major general is majors general" — are all simply +SENTENCE_NT nodes with no children. The following traverse begins Inform's +compilation process in earnest: for each such SENTENCE_NT node, it asks +the linguistics module to identify a primary verb, noun phrases and so +on, placing them in a subtree. +
+ +§2. Textual sentences. "Textual" sentences are not really sentences at all, and are just double-quoted +text used in isolation — Inform sometimes recognises these as being implicit +property values, as for the description of a room just created. These sentences +are necessarily exempt from having a primary verb. +
+ ++int Classifying::sentence_is_textual(parse_node *p) { + if ((Wordings::length(Node::get_text(p)) == 1) && + (Vocabulary::test_flags( + Wordings::first_wn(Node::get_text(p)), TEXT_MC+TEXTWITHSUBS_MC))) + return TRUE; + return FALSE; +} ++
§3. Classifying a single sentence. Every SENTENCE_NT node, however it is constructed, therefore ends up here, +and we ask the linguistics module to "diagram" it. +
+ +See About Sentence Diagrams (in linguistics) for many examples. +
+ ++void Classifying::sentence(parse_node *p) { + if (Annotations::read_int(p, classified_ANNOT)) return; + Annotations::write_int(p, classified_ANNOT, TRUE); + parse_node *save = current_sentence; + current_sentence = p; + if (Classifying::sentence_is_textual(p) == FALSE) { + wording W = Node::get_text(p); + if (<sentence-without-occurrences>(W)) { + parse_node *VP_PN = <<rp>>; + switch (Annotations::read_int(VP_PN, linguistic_error_here_ANNOT)) { + case TwoLikelihoods_LINERROR: Issue PM_TwoLikelihoods problem3.1; break; + } + SyntaxTree::graft(Task::syntax_tree(), VP_PN, p); + if (SyntaxTree::is_trace_set(Task::syntax_tree())) LOG("$T\n", p); + Check that this is allowed, if it occurs in the Options file3.3; + #ifdef IF_MODULE + PL::MapDirections::look_for_direction_creation(p); + #endif + PropertySentences::look_for_property_creation(p); + Issue problem message if either subject or object contains mismatched brackets3.4; + Issue problem message if subject starts with double-quoted literal text3.5; + if ((VP_PN->next) && (VP_PN->next->next) && (Diagrams::is_possessive_RELATIONSHIP(VP_PN->next->next))) + Diagram property callings3.6; + } else { + LOG("$T\n", p); + <no-primary-verb-diagnosis>(W); + } + } + current_sentence = save; +} ++
§3.1. Issue PM_TwoLikelihoods problem3.1 = +
+ ++ StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_TwoLikelihoods), + "this sentence seems to have a likelihood qualification on both " + "sides of the verb", + "which is not allowed. 'The black door certainly is usually open' " + "might possibly be grammatical English in some idioms, but Inform " + "doesn't like a sentence in this shape because the 'certainly' " + "on one side of the verb and the 'usually' on the other are " + "rival indications of certainty."); ++
§3.2. Only special-meaning sentences are allowed in Options files, and not all +of those. +
+ +enum ALLOW_IN_OPTIONS_FILE_SMFT ++
§3.3. Check that this is allowed, if it occurs in the Options file3.3 = +
+ ++ if (Wordings::within(Node::get_text(p), options_file_wording)) { + special_meaning_holder *sm = Node::get_special_meaning(p->down); + if ((sm == NULL) || + (SpecialMeanings::call(sm, ALLOW_IN_OPTIONS_FILE_SMFT, NULL, NULL) == FALSE)) { + StandardProblems::unlocated_problem(Task::syntax_tree(), + _p_(BelievedImpossible), not convenient to test automatically, anyway + "The options file placed in this installation of Inform's folder " + "is incorrect, making use of a sentence form which isn't allowed " + "in that situation. The options file is only allowed to contain " + "use options, Test ... with..., and Release along with... " + "instructions."); + return; + } + } ++
§3.4. The linguistics module no longer makes sentence diagrams with this defect, +so the following problem ought now to be impossible to generate. But I'm leaving +the test here in case of future changes. +
+ +Issue problem message if either subject or object contains mismatched brackets3.4 = +
+ ++ if ((VP_PN->next) && (VP_PN->next->next)) { + if ((Wordings::mismatched_brackets(Node::get_text(VP_PN->next))) || + (Wordings::mismatched_brackets(Node::get_text(VP_PN->next->next)))) { + Problems::quote_source(1, current_sentence); + Problems::quote_wording(2, + Wordings::one_word(Wordings::last_wn(Node::get_text(VP_PN->next)) + 1)); + Problems::quote_wording(3, Node::get_text(VP_PN->next)); + Problems::quote_wording(4, Node::get_text(VP_PN->next->next)); + StandardProblems::handmade_problem(Task::syntax_tree(), _p_(BelievedImpossible)); + if (Wordings::nonempty(Node::get_text(VP_PN->next->next))) + Problems::issue_problem_segment( + "I must be misreading the sentence %1. The verb " + "looks to me like '%2', but then the brackets don't " + "match in what I have left: '%3' and '%4'."); + else + Problems::issue_problem_segment( + "I must be misreading the sentence %1. The verb " + "looks to me like '%2', but then the brackets don't " + "match in what I have left: '%3'."); + Problems::issue_problem_end(); + return; + } + } ++
§3.5. This is a pragmatic sort of problem message. A priori, assertion sentences +like this might be okay, but in practice they cannot be useful and are far +more likely to occur as a result of something like: +
+ +++ +"This is a dining room" East is the Ballroom.
+
where the lack of a closing full stop in the quoted text means that linguistics +read this as one single sentence, equating "This is a dining room" East +with the Ballroom. +
+ +Special-meaning sentences are exempt; this is needed because subject phrases +for "Understand ... as ..." are indeed sometimes multiword clauses the first +word of which is quoted. +
+ +Issue problem message if subject starts with double-quoted literal text3.5 = +
+ ++ special_meaning_holder *sm = Node::get_special_meaning(VP_PN); + if ((sm == NULL) + && (Wordings::length(Node::get_text(VP_PN->next)) > 1) + && (Vocabulary::test_flags( + Wordings::first_wn(Node::get_text(VP_PN->next)), TEXT_MC+TEXTWITHSUBS_MC))) { + StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_TextNotClosing), + "it looks as if perhaps you did not intend that to read as a " + "single sentence", + "and possibly the text in quotes was supposed to stand as " + "as a sentence on its own? (The convention is that if text " + "ends in a full stop, exclamation or question mark, perhaps " + "with a close bracket or quotation mark involved as well, then " + "that punctuation mark also closes the sentence to which the " + "text belongs: but otherwise the words following the quoted " + "text are considered part of the same sentence.)"); + return; + } ++
§3.6. Here py is a CALLED_NT subtree for "an A called B", which we relabel +as a PROPERTYCALLED_NT subtree and hang beneath an ALLOWED_NT node; +or else it's a property or list of properties, as in "carrying capacity 7". +
+ +Diagram property callings3.6 = +
+ ++ parse_node *px = VP_PN->next; + parse_node *py = VP_PN->next->next->down; + if (Node::get_type(py) == CALLED_NT) { + if (Wordings::match(Node::get_text(py->down->next), Node::get_text(py->down))) { + StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_SuperfluousCalled), + "'called' should be used only when the name is different from the kind", + "so this sentence should be simplified. For example, 'A door has a " + "colour called colour' should be written more simply as 'A door has " + "a colour'; but 'called' can be used for something like 'A door has " + "a number called the street number'."); + return; + } + Node::set_type(py, PROPERTYCALLED_NT); + if (Node::get_type(py->down) == AND_NT) { +internal_error("Og yeah?"); + int L = Node::left_edge_of(py->down), + R = Node::right_edge_of(py->down); + <np-articled>(Wordings::new(L, R)); + parse_node *pn = <<rp>>; + pn->next = py->down->next; + py->down = pn; + LOG("Thus $T", py); + } + px->next = Node::new(ALLOWED_NT); + px->next->down = py; + int prohibited = <prohibited-property-owners>(Node::get_text(px)); + if (!prohibited) { + <np-articled-list>(Node::get_text(py->down->next)); + py->down->next = <<rp>>; + } + } else { + Node::set_type(py, PROPERTY_LIST_NT); + } ++
§4. From the earliest beta-testing, the problem message for "I can't find a verb" +split into cases. Inform is quite sensitive to punctuation errors as between +comma, paragraph break and semicolon, and this is where that sensitivity begins +to bite. The grammar below is just a set of heuristics, really: once we enter +this, a problem message of some kind will certainly result. +
+ ++<no-primary-verb-diagnosis> ::= + ... <no-primary-verb-diagnosis-tail> | + before/every/after/when/instead/check/carry/report ... | ==> Issue PM_RuleWithoutColon problem4.1 + if ... | ==> Issue PM_IfOutsidePhrase problem4.2 + ... , ... | ==> Issue PM_NoSuchVerbComma problem4.3 + ... ==> Issue PM_NoSuchVerb problem4.4 + +<no-primary-verb-diagnosis-tail> ::= + <rc-marker> <certainty> <nonimperative-verb> ... | ==> { advance Wordings::delta(WR[1], W) } + <rc-marker> <nonimperative-verb> ... | ==> { advance Wordings::delta(WR[1], W) } + <past-tense-verb> ... | ==> Issue PM_NonPresentTense problem4.5 + <negated-verb> ... ==> Issue PM_NegatedVerb1 problem4.6 ++
§4.1. Issue PM_RuleWithoutColon problem4.1 = +
+ ++ StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_RuleWithoutColon), + "I can't find a verb that I know how to deal with, so can't do anything " + "with this sentence. It looks as if it might be a rule definition", + "but if so then it is lacking the necessary colon (or comma). " + "The punctuation style for rules is 'Rule conditions: do this; " + "do that; do some more.' Perhaps you used a full stop instead " + "of the colon?"); ++
§4.2. Issue PM_IfOutsidePhrase problem4.2 = +
+ ++ StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_IfOutsidePhrase), + "I can't find a verb that I know how to deal with. This looks like an 'if' " + "phrase which has slipped its moorings", + "so I am ignoring it. ('If' phrases, like all other such " + "instructions, belong inside definitions of rules or phrases - " + "not as sentences which have no context. Maybe a full stop or a " + "skipped line was accidentally used instead of semicolon, so that you " + "inadvertently ended the last rule early?)"); ++
§4.3. Issue PM_NoSuchVerbComma problem4.3 = +
+ ++ Problems::quote_source(1, current_sentence); + StandardProblems::handmade_problem(Task::syntax_tree(), _p_(PM_NoSuchVerbComma)); + Problems::issue_problem_segment( + "In the sentence %1, I can't find a verb that I know how to deal with. " + "(I notice there's a comma here, which is sometimes used to abbreviate " + "rules which would normally be written with a colon - for instance, " + "'Before taking: say \"You draw breath.\"' can be abbreviated to 'Before " + "taking, say...' - but that's only allowed for Before, Instead and " + "After rules. I mention all this in case you meant this sentence " + "as a rule in some rulebook, but used a comma where there should " + "have been a colon ':'?)"); + Problems::issue_problem_end(); ++
§4.4. Issue PM_NoSuchVerb problem4.4 = +
+ ++ Problems::quote_source(1, current_sentence); + StandardProblems::handmade_problem(Task::syntax_tree(), _p_(PM_NoSuchVerb)); + Problems::issue_problem_segment( + "In the sentence %1, I can't find a verb that I know how to deal with."); + Problems::issue_problem_end(); ++
§4.5. Issue PM_NonPresentTense problem4.5 = +
+ ++ if (Annotations::read_int(current_sentence, verb_problem_issued_ANNOT) == FALSE) { + Annotations::write_int(current_sentence, verb_problem_issued_ANNOT, TRUE); + StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_NonPresentTense), + "assertions about the initial state of play must be given in the " + "present tense", + "so 'The cat is in the basket' is fine but not 'The cat has been in " + "the basket'. Time is presumed to start only when the game begins, so " + "there is no anterior state which we can speak of."); + } ++
§4.6. Issue PM_NegatedVerb1 problem4.6 = +
+ ++ if (Annotations::read_int(current_sentence, verb_problem_issued_ANNOT) == FALSE) { + Annotations::write_int(current_sentence, verb_problem_issued_ANNOT, TRUE); + StandardProblems::negative_sentence_problem(Task::syntax_tree(), _p_(PM_NegatedVerb1)); + } ++
§5. The following is needed to handle something like "colour of the box", +where "colour" is a property name. We must be careful, though, to avoid +confusion with variable declarations: +
+ +++ +The interesting var is a description of numbers that varies.
+
which would otherwise be misread as an attempt to set the "description" +property of something. +
+ +define ALLOW_OF_LINGUISTICS_CALLBACK Classifying::allow_of ++
+<allow-of-x> ::= + in the presence | ==> { fail } + <property-name-v> ==> { -, - } + +<allow-of-y> ::= + ... that varies | ==> { fail} + ... variable | ==> { fail } + ... ==> { -, - } ++
+int Classifying::allow_of(wording XW, wording YW) { + if ((<allow-of-x>(XW)) && (<allow-of-y>(YW))) return TRUE; + return FALSE; +} ++ + +
To manage the overall process of traversing the parse tree for top-level declarations and assertion sentences.
+ +§1. The first thing Inform does when compiling source text is to make three +passes through its top-level definitions: a "pre-pass", in which names of +things like tables and equations are discovered, and assertion sentences +are diagrammed; "pass 1", when instance, kinds, properties and so on are +created; and "pass 2", when property values and relationships are found. +
+ ++void MajorNodes::pre_pass(void) { + MajorNodes::traverse(0); +} +void MajorNodes::pass_1(void) { + MajorNodes::traverse(1); +} +void MajorNodes::pass_2(void) { + MajorNodes::traverse(2); +} ++
§2. During these passes, some global state is kept here. This is not elegant, +but saves a deal of passing parameters around. +
+ ++typedef struct pass_state { + int pass; during a pass, 0, 1 or 2: 0 is the pre-pass + int near_start_of_extension; + struct parse_node *assembly_position; + struct inference_subject *object_of_sentences; + struct inference_subject *subject_of_sentences; + int subject_seems_to_be_plural; +} pass_state; + +pass_state global_pass_state = { -1, 0, NULL, NULL, NULL, FALSE }; + +void MajorNodes::traverse(int pass) { + global_pass_state.pass = pass; + global_pass_state.near_start_of_extension = 0; + global_pass_state.assembly_position = NULL; + global_pass_state.object_of_sentences = NULL; + global_pass_state.subject_of_sentences = NULL; + global_pass_state.subject_seems_to_be_plural = FALSE; + SyntaxTree::clear_trace(Task::syntax_tree()); + Anaphora::new_discussion(); + + parse_node *last = NULL; + SyntaxTree::traverse_nodep(Task::syntax_tree(), MajorNodes::visit, &last); + + if (pass == 1) Extend the pass to invented sentences from kinds2.1; + if (pass == 2) Extend the pass to sentences needed when implicit kinds are set2.2; +} ++
§2.1. Extend the pass to invented sentences from kinds2.1 = +
+ ++ parse_node *extras = last; + ParseTreeUsage::add_kind_inventions(); + current_sentence = extras; + global_pass_state.assembly_position = extras; + global_pass_state.pass = 0; + SyntaxTree::traverse_nodep_from(extras, MajorNodes::visit, &last); + current_sentence = extras; + global_pass_state.assembly_position = extras; + global_pass_state.pass = 1; + SyntaxTree::traverse_nodep_from(extras, MajorNodes::visit, &last); ++
§2.2. Here's a tricky timing problem, or rather, here's the fix for it. Assemblies +are made when the kinds of objects are set, and they're made by inserting +appropriate sentences. For instance, given the generalisation: +
+ +++ +Every room contains a vehicle.
+
we would insert the following sentence into the tree: +
+ +++ +Ballroom West contains a vehicle.
+
as soon as we discover that Ballroom West is a room. That works fine if we +discover this fact during traverses 1 or 2, but sometimes the room-ness of +a room cannot be established until the world model is constructed. So we +call the model-maker right now, and prolong pass 2 artificially to pick up +any additional sentences generated. +
+ +Extend the pass to sentences needed when implicit kinds are set2.2 = +
+ ++ current_sentence = last; + global_pass_state.assembly_position = current_sentence; + Plugins::Call::complete_model(1); + SyntaxTree::traverse_nodep_from(last, MajorNodes::visit, &last); ++
§3. Let us go, and make our visit: +
+ ++void MajorNodes::visit(parse_node *p, parse_node **last) { + global_pass_state.assembly_position = current_sentence; + compilation_unit *cm = CompilationUnits::current(); + CompilationUnits::set_current(p); + *last = p; + Deal with an individual major node3.1; + CompilationUnits::set_current_to(cm); +} ++
§3.1. Headings cause us to begin a fresh topic of discussion, on a fresh piece of +paper, as it were: this wipes out any meanings of pronouns like "it" making +anaphoric references to previous sentences. In other respects, headings are for +organisation, and are not directly functional in themselves. +
+ +Deal with an individual major node3.1 = +
+ ++ if ((SyntaxTree::is_trace_set(Task::syntax_tree())) && (Node::get_type(p) != TRACE_NT)) + LOG("\n[%W]\n", Node::get_text(p)); + + switch (Node::get_type(p)) { + case ROOT_NT: break; + + case HEADING_NT: Anaphora::new_discussion(); break; + case BEGINHERE_NT: Anaphora::new_discussion(); + global_pass_state.near_start_of_extension = 1; break; + case ENDHERE_NT: Anaphora::new_discussion(); + global_pass_state.near_start_of_extension = 0; break; + + case RULE_NT: Pass through a RULE node3.1.1; break; + case SENTENCE_NT: Pass through a SENTENCE node3.1.2; break; + case TRACE_NT: Pass through a TRACE node3.1.5; break; + + case TABLE_NT: if (global_pass_state.pass == 0) Tables::create_table(p); + break; + case EQUATION_NT: if (global_pass_state.pass == 0) Equations::new_at(p, FALSE); + break; + case INFORM6CODE_NT: + if (global_pass_state.pass == 2) Config::Inclusions::inform_6_inclusion(p); + break; + case BIBLIOGRAPHIC_NT: + #ifdef IF_MODULE + if (global_pass_state.pass == 2) PL::Bibliographic::bibliographic_data(p); + #endif + break; + + case INVOCATION_LIST_NT: break; for error recovery; shouldn't be here otherwise + + default: + LOG("$T\n", p); + internal_error("passed through major node of unexpected type"); + } ++
§3.1.1. This is a little convoluted. The linguistics module turns sentences in +rule form into a RULE_NT node followed by subsequent INVOCATION_NT nodes, +and the first call here makes them into a neat subtree. After that, we look +out for adjectives defined by phrases, and for phrases with names, since +both will affect how we read sentences in passes 1 and 2. +
+ +Pass through a RULE node3.1.1 = +
+ ++ if (global_pass_state.pass == 0) { + SyntaxTree::traverse_run(p, RuleSubtrees::demote_command_nodes, RULE_NT); + Phrases::Adjectives::look_for_headers(p); + Phrases::Usage::predeclare_name_in(p); + } ++
§3.1.2. SENTENCE_NT nodes are by far the most varied and difficult. In the pre-pass, +we call Classifying::sentence to have them diagrammed, which determines +whether they have special or regular meanings. +
+ +Pass through a SENTENCE node3.1.2 = +
+ ++ if (global_pass_state.pass == 0) { + Classifying::sentence(p); + } else { + if (SyntaxTree::is_trace_set(Task::syntax_tree())) LOG("$T", p); + if ((Annotations::read_int(p, language_element_ANNOT) == FALSE) && + (Annotations::read_int(p, you_can_ignore_ANNOT) == FALSE)) { + if (Classifying::sentence_is_textual(p)) { + if (global_pass_state.pass == 2) { + prevailing_mood = UNKNOWN_CE; + Assertions::make_appearance(p); + } + } else { + if (p->down == NULL) internal_error("sentence misclassified"); + internal_error_if_node_type_wrong(Task::syntax_tree(), p->down, VERB_NT); + prevailing_mood = Annotations::read_int(p->down, verbal_certainty_ANNOT); + if (Node::get_special_meaning(p->down)) Act on special meaning3.1.2.2 + else Act on regular meaning3.1.2.3; + } + } + } ++
§3.1.2.1. Special meanings are handled just by calling the relevant SMF functions +with one of the following task codes. They don't get the benefit of +"refinement" (see below) unless they arrange for it themselves. +
+ +enum PASS_1_SMFT +enum PASS_2_SMFT ++
§3.1.2.2. Act on special meaning3.1.2.2 = +
+ ++ if (global_pass_state.pass == 1) + MajorNodes::try_special_meaning(PASS_1_SMFT, p->down); + if (global_pass_state.pass == 2) + MajorNodes::try_special_meaning(PASS_2_SMFT, p->down); ++
§3.1.2.3. Regular meanings are more subtle: on pass 1, we "refine" them, which means +identifying unparsed noun phrases. Refiner::refine_coupling +returns TRUE if it succeeds in this. +
+ +After that, there are two cases: existential sentences (such as "there are +two cases") and all others (such as "regular meaning are more subtle"). +
+ +Act on regular meaning3.1.2.3 = +
+ ++ parse_node *px = p->down->next; + parse_node *py = px->next; + if ((global_pass_state.pass > 1) || + (Refiner::refine_coupling(px, py, FALSE))) { + if (Node::get_type(px) == DEFECTIVE_NOUN_NT) { + Assertions::make_existential(py); + Anaphora::change_discussion_from_coupling(py, py); + } else { + Assertions::make_coupling(px, py); + Anaphora::change_discussion_from_coupling(px, py); + } + } ++
+void MajorNodes::try_special_meaning(int task, parse_node *p) { + SpecialMeanings::call(Node::get_special_meaning(p), task, p, NULL); +} ++
§3.1.4. A few "invention" sentences only come along later than the pre-pass, which +means they miss out on being classified at that time. When that happens, the +syntax module signals us by calling this function: +
+ +define NEW_NONSTRUCTURAL_SENTENCE_SYNTAX_CALLBACK MajorNodes::extra_sentence ++
+void MajorNodes::extra_sentence(parse_node *new) { + if (global_pass_state.pass >= 0) Classifying::sentence(new); +} ++
§3.1.5. TRACE_NT nodes result from asterisked sentences; this is a debugging feature of +Inform. An asterisk on its own toggles logging of work on sentences. An asterisk +followed by double-quoted text is a note for the telemetry file. +
+ +Pass through a TRACE node3.1.5 = +
+ ++ if (Wordings::length(Node::get_text(p)) > 1) { + int tr = telemetry_recording; + telemetry_recording = TRUE; + Telemetry::write_to_telemetry_file( + Lexer::word_text(Wordings::last_wn(Node::get_text(p)))); + telemetry_recording = FALSE; + StandardProblems::sentence_problem(Task::syntax_tree(), + _p_(PM_TelemetryAccepted), + "that's a message for the Author, not me", + "so I'll note it down in the Telemetry file (if you're keeping one.)"); + telemetry_recording = tr; + } else { + SyntaxTree::toggle_trace(Task::syntax_tree()); + text_stream *pass_name = NULL; + switch (global_pass_state.pass) { + case 0: pass_name = I"Pre-Pass"; break; + case 1: pass_name = I"Pass 1"; break; + case 2: pass_name = I"Pass 2"; break; + } + Log::tracing_on(SyntaxTree::is_trace_set(Task::syntax_tree()), pass_name); + } ++
define TRACING_LINGUISTICS_CALLBACK MajorNodes::trace_parsing ++
+int MajorNodes::trace_parsing(int A) { + if (SyntaxTree::is_trace_set(Task::syntax_tree())) return TRUE; + return FALSE; +} ++ + +
Special sentences for changing what goes into the debugging log.
+ +§1. These are the special meaning functions for the sentences: +
+ +++ +Include ... in the debugging log. Omit ... from the debugging log.
+
Which have identical semantics except for the positive or negative sense. +The object phrase has to be exactly "the debugging log", so: +
+ ++<debugging-log-sentence-object> ::= + the debugging log ++
+int Sentences::DLRs::include_in_SMF(int task, parse_node *V, wording *NPs) { + return Sentences::DLRs::dl_SMF(task, V, NPs, TRUE); +} + +int Sentences::DLRs::omit_from_SMF(int task, parse_node *V, wording *NPs) { + return Sentences::DLRs::dl_SMF(task, V, NPs, FALSE); +} ++
§3. The subject phrase, however, can be a list... +
+ ++int Sentences::DLRs::dl_SMF(int task, parse_node *V, wording *NPs, int sense) { + wording SW = (NPs)?(NPs[2]):EMPTY_WORDING; + wording OW = (NPs)?(NPs[1]):EMPTY_WORDING; + switch (task) { + case ACCEPT_SMFT: + if (<debugging-log-sentence-object>(OW)) { + <np-articled-list>(SW); + V->next = <<rp>>; + Sentences::DLRs::switch_dl_mode(V->next, sense); + return TRUE; + } + return FALSE; + case ALLOW_IN_OPTIONS_FILE_SMFT: + return TRUE; + } + return FALSE; +} + +void Sentences::DLRs::switch_dl_mode(parse_node *PN, int sense) { + if (Node::get_type(PN) == AND_NT) { + Sentences::DLRs::switch_dl_mode(PN->down, sense); + Sentences::DLRs::switch_dl_mode(PN->down->next, sense); + return; + } + Sentences::DLRs::set_aspect_from_text(Node::get_text(PN), sense); +} ++
§4. Each list entry must match the following, which returns a bitmap of +modifiers and a pointer to a Preform nonterminal if one has been named. +
+ +define ONLY_DLR 1 +define EVERYTHING_DLR 2 +define NOTHING_DLR 4 +define SOMETHING_DLR 8 +define PREFORM_DLR 16 ++
+<debugging-log-sentence-subject> ::= + only <debugging-log-request> | ==> { R[1] | ONLY_DLR, RP[1] } + <debugging-log-request> ==> { pass 1 } + +<debugging-log-request> ::= + everything | ==> { EVERYTHING_DLR, NULL } + nothing | ==> { NOTHING_DLR, NULL } + <preform-nonterminal> | ==> { PREFORM_DLR, RP[1] } + ... ==> { SOMETHING_DLR, NULL } ++
+void Sentences::DLRs::set_aspect_from_text(wording W, int new_state) { + LOGIF(DEBUGGING_LOG_INCLUSIONS, + "Set contents of debugging log: %W -> %s\n", + W, new_state?"TRUE":"FALSE"); + + <debugging-log-sentence-subject>(W); + if (<<r>> & ONLY_DLR) Log::set_all_aspects(new_state?FALSE:TRUE); + if (<<r>> & EVERYTHING_DLR) { Log::set_all_aspects(new_state); return; } + if (<<r>> & NOTHING_DLR) { Log::set_all_aspects(1-new_state); return; } + if (<<r>> & SOMETHING_DLR) { + TEMPORARY_TEXT(req) + WRITE_TO(req, "%W", GET_RW(<debugging-log-request>, 1)); + int rv = Log::set_aspect_from_command_line(req, FALSE); + DISCARD_TEXT(req) + if (rv) return; + } + if (<<r>> & PREFORM_DLR) { Instrumentation::watch(<<rp>>, new_state); return; } + + Problems::quote_source(1, current_sentence); + Problems::quote_wording(2, W); + StandardProblems::handmade_problem(Task::syntax_tree(), _p_(PM_UnknownDA)); + Problems::issue_problem_segment( + "In the sentence %1, you asked to include '%2' in the " + "debugging log, but there is no such debugging log topic."); + Problems::issue_problem_end(); +} ++ + +
Special sentences for creating new use options.
+ +§1. Use options in Inform are akin to #pragma directives for the C family of +compilers: they are written in the source code of the program being compiled, +but they're not really part of that program, and are instead instructions to +the compiler to do something in a different way.1 +
+ +Use options have natural-language names, and are created with sentences like: +
+ +++ +Use American dialect translates as (- Constant DIALECT_US; -).
+
This syntax is now rather odd-looking, but most users never need it: it's used +mainly in the Basic Inform extension to create the standard set of use options. +Note the Inform 6 notation used for the Inter code between the (- and -) +brackets. +
+ +1 The design of use options is arguably more muddled, because they do not all +correspond to compiler features: some affect the behaviour of Inter kits, and +some can be user-defined entirely. + ↩
§2. A "... translates as ..." sentence has this special meaning if its SP and +OP match the following: +
+ ++<use-translates-as-sentence-subject> ::= + use <np-unparsed> ==> { TRUE, RP[1] } + +<use-translates-as-sentence-object> ::= + (- ### | ==> { -, - } + ... ==> Issue PM_UseTranslatesNotI6 problem2.1 ++
§2.1. Issue PM_UseTranslatesNotI6 problem2.1 = +
+ ++ StandardProblems::sentence_problem(Task::syntax_tree(), + _p_(PM_UseTranslatesNotI6), + "that translates into something which isn't a simple Inter inclusion", + "placed in '(-' and '-)' markers."); + ==> { FALSE, - }; ++
+int NewUseOptions::use_translates_as_SMF(int task, parse_node *V, wording *NPs) { + wording SW = (NPs)?(NPs[0]):EMPTY_WORDING; + wording OW = (NPs)?(NPs[1]):EMPTY_WORDING; + switch (task) { "Use American dialect means ..." + case ACCEPT_SMFT: + if ((<use-translates-as-sentence-object>(OW)) && + (<use-translates-as-sentence-subject>(SW))) { + V->next = <<rp>>; + <np-unparsed>(OW); + V->next->next = <<rp>>; + return TRUE; + } + break; + case PASS_1_SMFT: + Create a new use option3.2; + break; + } + return FALSE; +} ++
§3.1. Use options correspond to instances of the following: +
+ ++typedef struct use_option { + struct wording name; word range where name is stored + struct wording expansion; definition as given in source + struct parse_node *where_used; where the option is taken in the source + int option_used; set if this option has been taken + int source_file_scoped; scope is the current source file only? + int minimum_setting_value; for those which are numeric + int notable_option_code; or negative if not notable + CLASS_DEFINITION +} use_option; ++
§3.2. Create a new use option3.2 = +
+ ++ wording SP = Node::get_text(V->next); + wording OP = Node::get_text(V->next->next); + <use-setting>(SP); always passes + int N = <<r>>; + + use_option *uo = CREATE(use_option); + uo->name = GET_RW(<use-setting>, 1); + uo->expansion = OP; + uo->option_used = FALSE; + uo->minimum_setting_value = (N > 0) ? N : -1; + uo->source_file_scoped = FALSE; + uo->notable_option_code = -1; + if (<notable-use-option-name>(uo->name)) uo->notable_option_code = <<r>>; + if (uo->notable_option_code == AUTHORIAL_MODESTY_UO) uo->source_file_scoped = TRUE; + Nouns::new_proper_noun(uo->name, NEUTER_GENDER, ADD_TO_LEXICON_NTOPT, + MISCELLANEOUS_MC, Rvalues::from_use_option(uo), Task::language_of_syntax()); ++
§4. Having registered the use option names as miscellaneous, we need to parse +them back that way too: +
+ ++use_option *NewUseOptions::parse_uo(wording OW) { + parse_node *p = Lexicon::retrieve(MISCELLANEOUS_MC, OW); + if (Rvalues::is_CONSTANT_of_kind(p, K_use_option)) return Rvalues::to_use_option(p); + return NULL; +} ++
§5. The following sets an option. +
+ ++void NewUseOptions::set(use_option *uo, int min_setting, source_file *from) { + if (uo->minimum_setting_value == -1) { + if (min_setting != -1) + StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_UONotNumerical), + "that 'Use' option does not have a numerical setting", + "but is either used or not used."); + } else { + if (min_setting >= uo->minimum_setting_value) + uo->minimum_setting_value = min_setting; + } + if (uo->source_file_scoped) { + inform_extension *E = Extensions::corresponding_to(from); + if (E == NULL) { that is, if used in the main source text + uo->option_used = TRUE; + uo->where_used = current_sentence; + } + } else { + uo->option_used = TRUE; + uo->where_used = current_sentence; + } + CompilationSettings::set(uo->notable_option_code, + uo->minimum_setting_value, from); +} ++
§6. And this is what the rest of Inform calls to find out whether a particular +pragma is set: +
+ ++int NewUseOptions::uo_set_from(use_option *uo, int category, inform_extension *E) { + source_file *sf = (uo->where_used)? + (Lexer::file_of_origin(Wordings::first_wn(Node::get_text(uo->where_used)))):NULL; + inform_extension *efo = (sf)?(Extensions::corresponding_to(sf)):NULL; + switch (category) { + case 1: if ((sf) && (efo == NULL)) return TRUE; break; + case 2: if (sf == NULL) return TRUE; break; + case 3: if ((sf) && (efo == E)) return TRUE; break; + } + return FALSE; +} ++
§7. We can also meddle with the I6 memory settings which will be used to finish +compiling the story file. We need this because we have no practical way to +predict when our code will break I6's limits: the only reasonable way it can +work is for the user to hit the limit occasionally, and then raise that limit +by hand with a sentence in the source text. +
+ ++typedef struct i6_memory_setting { + struct text_stream *ICL_identifier; see the DM4 for the I6 memory setting names + int number; e.g., 50000 means "at least 50,000" + CLASS_DEFINITION +} i6_memory_setting; ++
+void NewUseOptions::memory_setting(text_stream *identifier, int n) { + i6_memory_setting *ms; + LOOP_OVER(ms, i6_memory_setting) + if (Str::eq(identifier, ms->ICL_identifier)) { + if (ms->number < n) ms->number = n; + return; + } + ms = CREATE(i6_memory_setting); + ms->ICL_identifier = Str::duplicate(identifier); + ms->number = n; +} ++
§9. Now for indexing, where there's nothing much to see. +
+ +define MAIN_TEXT_UO_ORIGIN 1 +define OPTIONS_FILE_UO_ORIGIN 2 +define EXTENSION_UO_ORIGIN 3 ++
+void NewUseOptions::index(OUTPUT_STREAM) { + HTML_OPEN("p"); WRITE("The following use options are in force:"); HTML_CLOSE("p"); + NewUseOptions::index_options_in_force_from(OUT, MAIN_TEXT_UO_ORIGIN, NULL); + NewUseOptions::index_options_in_force_from(OUT, OPTIONS_FILE_UO_ORIGIN, NULL); + inform_extension *E; + LOOP_OVER(E, inform_extension) + NewUseOptions::index_options_in_force_from(OUT, EXTENSION_UO_ORIGIN, E); + int nt = 0; + use_option *uo; + LOOP_OVER(uo, use_option) { + if (uo->source_file_scoped) continue; + if ((uo->option_used == FALSE) && (uo->minimum_setting_value < 0)) nt++; + } + if (nt > 0) { + HTML_OPEN("p"); WRITE("Whereas these are not in force:"); HTML_CLOSE("p"); + HTML::open_indented_p(OUT, 2, "tight"); + LOOP_OVER(uo, use_option) { + if (uo->source_file_scoped) continue; + if ((uo->option_used == FALSE) && (uo->minimum_setting_value < 0)) { + Write in the index line for a use option not taken9.1; + if (--nt > 0) WRITE(", "); + } + } + HTML_CLOSE("p"); + } +} ++
§9.1. Write in the index line for a use option not taken9.1 = +
+ ++ HTML_OPEN_WITH("span", "style=\"white-space:nowrap\";"); + TEMPORARY_TEXT(TEMP) + WRITE_TO(TEMP, "Use %+W.", uo->name); + PasteButtons::paste_text(OUT, TEMP); + DISCARD_TEXT(TEMP) + WRITE(" %+W", uo->name); + HTML_CLOSE("span"); ++
+void NewUseOptions::index_options_in_force_from(OUTPUT_STREAM, int category, inform_extension *E) { + int N = 0; + use_option *uo; + LOOP_OVER(uo, use_option) { + if (uo->source_file_scoped) continue; + if ((uo->option_used) && (uo->minimum_setting_value < 0) && + (NewUseOptions::uo_set_from(uo, category, E))) { + if (N++ == 0) Write in the use option subheading10.1; + Write in the index line for a use option taken10.2; + } + } + LOOP_OVER(uo, use_option) { + if (uo->source_file_scoped) continue; + if (((uo->option_used) && (uo->minimum_setting_value >= 0)) && + (NewUseOptions::uo_set_from(uo, category, E))) { + if (N++ == 0) Write in the use option subheading10.1; + Write in the index line for a use option taken10.2; + } + } +} ++
§10.1. Write in the use option subheading10.1 = +
+ ++ HTML::open_indented_p(OUT, 2, "tight"); + HTML::begin_colour(OUT, I"808080"); + WRITE("Set from "); + switch (category) { + case MAIN_TEXT_UO_ORIGIN: + WRITE("the source text"); break; + case OPTIONS_FILE_UO_ORIGIN: + WRITE("the Options.txt configuration file"); + Index::DocReferences::link(OUT, I"OPTIONSFILE"); break; + case EXTENSION_UO_ORIGIN: + if (Extensions::is_standard(E)) WRITE("the "); + else WRITE("the extension "); + WRITE("%S", E->as_copy->edition->work->title); + break; + } + WRITE(":"); + HTML::end_colour(OUT); + HTML_CLOSE("p"); ++
§10.2. Write in the index line for a use option taken10.2 = +
+ ++ HTML::open_indented_p(OUT, 3, "tight"); + WRITE("Use %+W", uo->name); + if (uo->minimum_setting_value >= 0) WRITE(" of at least %d", uo->minimum_setting_value); + if (uo->where_used) Index::link(OUT, Wordings::first_wn(Node::get_text(uo->where_used))); + if (uo->minimum_setting_value >= 0) { + WRITE(" "); + TEMPORARY_TEXT(TEMP) + WRITE_TO(TEMP, "Use %+W of at least %d.", uo->name, 2*(uo->minimum_setting_value)); + PasteButtons::paste_text(OUT, TEMP); + DISCARD_TEXT(TEMP) + WRITE(" <i>Double this</i>"); + } + HTML_CLOSE("p"); ++
Special sentences for setting exotic plural forms of nouns.
+ +§1. Sentences like "the plural of cherub is cherubim" are hardly needed now, +because the inflections module now contains a full implementation of +Conway's algorithm. Still, we keep the syntax around, and it may one day be +useful again for languages other than English. +
+ +The subject phrase must match: +
+ ++<plural-sentence-subject> ::= + <article> plural of <np-articled> | ==> { pass 2 } + plural of <np-articled> ==> { pass 1 } ++
§2. Note that we are saved later grief by not allowing a plural form which +would be illegal as a new noun: allowing "The plural of thing is ," would not +end well. +
+ +Otherwise, though, we simply send the request to Pluralisation (in inflections). +
+ ++int Plurals::plural_SMF(int task, parse_node *V, wording *NPs) { + wording SW = (NPs)?(NPs[0]):EMPTY_WORDING; + wording OW = (NPs)?(NPs[1]):EMPTY_WORDING; + switch (task) { "The plural of seraph is seraphim." + case ACCEPT_SMFT: + if (<plural-sentence-subject>(SW)) { + V->next = <<rp>>; + <np-unparsed>(OW); + V->next->next = <<rp>>; + wording S = Node::get_text(V->next); + wording P = Node::get_text(V->next->next); + Forbid plural declarations containing quoted text2.1; + if (Assertions::Creator::vet_name_for_noun(P) == FALSE) return TRUE; + Pluralisation::register(S, P, DefaultLanguage::get(NULL)); + return TRUE; + } + break; + } + return FALSE; +} ++
§2.1. In general names of things which we need plurals for cannot contain quoted +text anyway, so the following problem messages are not too gratuitous. +
+ +Forbid plural declarations containing quoted text2.1 = +
+ ++ LOOP_THROUGH_WORDING(i, S) + if (Vocabulary::test_flags(i, TEXT_MC + TEXTWITHSUBS_MC)) { + StandardProblems::sentence_problem(Task::syntax_tree(), + _p_(PM_PluralOfQuoted), + "declares a plural for a phrase containing quoted text", + "which is forbidden. Sentences like this are supposed to " + "declare plurals without quotation marks: for instance, " + "'The plural of attorney general is attorneys general.'"); + return TRUE; + } + LOOP_THROUGH_WORDING(i, P) + if (Vocabulary::test_flags(i, TEXT_MC + TEXTWITHSUBS_MC)) { + StandardProblems::sentence_problem(Task::syntax_tree(), + _p_(PM_PluralIsQuoted), + "declares a plural for a phrase using quoted text", + "which is forbidden. Sentences like this are supposed to " + "declare plurals without quotation marks: for instance, " + "'The plural of procurator fiscal is procurators fiscal.'"); + return TRUE; + } ++
Three unrelated senses of "X translates into Y as Z" sentences.
+ +§1. Translation into natural languages. The sentence "X translates into Y as Z" has this sense provided Y matches: +
+ ++<translation-target-language> ::= + <natural-language> ==> { pass 1 } ++
+int Translations::translates_into_language_as_SMF(int task, parse_node *V, wording *NPs) { + wording SW = (NPs)?(NPs[0]):EMPTY_WORDING; + wording OW = (NPs)?(NPs[1]):EMPTY_WORDING; + wording O2W = (NPs)?(NPs[2]):EMPTY_WORDING; + switch (task) { "Thing translates into French as chose" + case ACCEPT_SMFT: + if (<translation-target-language>(O2W)) { + inform_language *nl = (inform_language *) (<<rp>>); + <np-articled>(SW); + V->next = <<rp>>; + <np-articled>(OW); + V->next->next = <<rp>>; + Node::set_defn_language(V->next->next, nl); + return TRUE; + } + break; + case PASS_1_SMFT: + Parse subject phrase and send the translation to the linguistics module2.2; + break; + } + return FALSE; +} ++
§2.1. The subject phrase can only be parsed on traverse 1, since it only makes +sense once kinds and instances exist. +
+ +define TRANS_KIND 1 +define TRANS_INSTANCE 2 ++
+<translates-into-language-sentence-subject> ::= + <k-kind> | ==> { TRANS_KIND, RP[1] } + <instance> ==> { TRANS_INSTANCE, RP[1] } ++
§2.2. Parse subject phrase and send the translation to the linguistics module2.2 = +
+ ++ wording SP = Node::get_text(V->next); + wording OP = Node::get_text(V->next->next); + inform_language *L = Node::get_defn_language(V->next->next); + int g = Annotations::read_int(V->next->next, explicit_gender_marker_ANNOT); + if (L == NULL) internal_error("No such NL"); + if (L == DefaultLanguage::get(NULL)) { + StandardProblems::sentence_problem(Task::syntax_tree(), + _p_(PM_CantTranslateIntoEnglish), + "you can't translate from a language into itself", + "only from the current language to a different one."); + return FALSE; + } + + if ((<translates-into-language-sentence-subject>(SP)) == FALSE) { + StandardProblems::sentence_problem(Task::syntax_tree(), + _p_(PM_CantTranslateValue), + "this isn't something which can be translated", + "that is, it isn't a kind or instance."); + return FALSE; + } + + switch (<<r>>) { + case TRANS_INSTANCE: { + instance *I = <<rp>>; + noun *t = Instances::get_noun(I); + if (t == NULL) internal_error("stuck on instance name"); + Nouns::supply_text(t, OP, L, g, SINGULAR_NUMBER, ADD_TO_LEXICON_NTOPT); + break; + } + case TRANS_KIND: { + kind *K = <<rp>>; + kind_constructor *KC = Kinds::get_construct(K); + if (KC == NULL) internal_error("stuck on kind name"); + noun *t = Kinds::Constructors::get_noun(KC); + if (t == NULL) internal_error("further stuck on kind name"); + Nouns::supply_text(t, OP, L, g, SINGULAR_NUMBER, + ADD_TO_LEXICON_NTOPT + WITH_PLURAL_FORMS_NTOPT); + break; + } + default: internal_error("bad translation category"); + } ++
§3. Translation into Unicode. The following handles sentences like: +
+ +++ +leftwards harpoon with barb upwards translates into Unicode as 8636.
+
The subject "leftwards harpoon with barb upwards" is parsed against the +Unicode character names known already to make sure that this new translation +doesn't disagree with an existing one (that is, doesn't translate to a +different code number). +
+ +The sentence "X translates into Y as Z" has this sense provided Y matches: +
+ ++<translation-target-unicode> ::= + unicode ++
+int Translations::translates_into_unicode_as_SMF(int task, parse_node *V, wording *NPs) { + wording SW = (NPs)?(NPs[0]):EMPTY_WORDING; + wording OW = (NPs)?(NPs[1]):EMPTY_WORDING; + wording O2W = (NPs)?(NPs[2]):EMPTY_WORDING; + switch (task) { "Black king chess piece translates into Unicode as 9818" + case ACCEPT_SMFT: + if (<translation-target-unicode>(O2W)) { + <np-articled>(SW); + V->next = <<rp>>; + <np-articled>(OW); + V->next->next = <<rp>>; + return TRUE; + } + break; + case PASS_2_SMFT: + Create the Unicode character name4.1; + break; + } + return FALSE; +} ++
§5. And this parses the noun phrases of such sentences. Note that the numeric +values has to be given in decimal — I was tempted to allow hexadecimal here, +but life's too short. Unicode translation sentences are really only +technicalities needed by the built-in extensions, and those are mechanically +generated anyway; Inform authors never type them. +
+ ++<translates-into-unicode-sentence-subject> ::= + <unicode-character-name> | ==> { pass 1 } + ... ==> { -1, - } + +<translates-into-unicode-sentence-object> ::= + <cardinal-number-unlimited> | ==> { UnicodeLiterals::range(R[1]), - } + ... ==> Issue PM_UnicodeNonLiteral problem5.1 ++
§5.1. Issue PM_UnicodeNonLiteral problem5.1 = +
+ ++ StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_UnicodeNonLiteral), + "a Unicode character name must be translated into a literal decimal " + "number written out in digits", + "which this seems not to be."); + return FALSE; ++
§4.1. And here the name is created as a miscellaneous excerpt meaning. +
+ +Create the Unicode character name4.1 = +
+ ++ wording SP = Node::get_text(V->next); + wording OP = Node::get_text(V->next->next); + if (<translates-into-unicode-sentence-object>(OP) == FALSE) return FALSE; + int cc = <<r>>; + + <translates-into-unicode-sentence-subject>(SP); + if ((<<r>> != -1) && (<<r>> != cc)) { + StandardProblems::sentence_problem(Task::syntax_tree(), + _p_(PM_UnicodeAlready), + "this Unicode character name has already been translated", + "so there must be some duplication somewhere."); + return FALSE; + } + + Nouns::new_proper_noun(SP, NEUTER_GENDER, ADD_TO_LEXICON_NTOPT, MISCELLANEOUS_MC, + Diagrams::new_PROPER_NOUN(OP), Task::language_of_syntax()); ++
§6. Translation into Inter. The sentence "X translates into Y as Z" has this sense provided Y matches the +following. Before the coming of Inter code, the only conceivable compilation +target was Inform 6, but these now set Inter identifiers, so really the first +wording is to be preferred. +
+ ++<translation-target-i6> ::= + inter | + i6 | + inform 6 ++
enum INTER_NAMING_SMFT ++
+int Translations::translates_into_Inter_as_SMF(int task, parse_node *V, wording *NPs) { + wording SW = (NPs)?(NPs[0]):EMPTY_WORDING; + wording OW = (NPs)?(NPs[1]):EMPTY_WORDING; + wording O2W = (NPs)?(NPs[2]):EMPTY_WORDING; + switch (task) { "The taking inventory action translates into Inter as "Inv"" + case ACCEPT_SMFT: + if (<translation-target-i6>(O2W)) { + <np-articled>(SW); + V->next = <<rp>>; + <np-articled>(OW); + V->next->next = <<rp>>; + return TRUE; + } + break; + case PASS_1_SMFT: + case PASS_2_SMFT: + Act on the Inter translation7.2; + break; + case INTER_NAMING_SMFT: + Act on late naming7.5; + break; + } + return FALSE; +} ++
§8. Translations can be made in a number of contexts: +
+ +define INVALID_I6TR -1 +define PROPERTY_I6TR 0 "The open property translates into I6 as "open"." +define NOUN_I6TR 1 "The north object translates into I6 as "n_obj"." +define RULE_I6TR 2 "The baffling rule translates into I6 as "BAFFLING_R"." +define VARIABLE_I6TR 3 "The sludge count variable translates into I6 as "sldgc". +define ACTION_I6TR 4 "The taking action translates into I6 as "Take". +define GRAMMAR_TOKEN_I6TR 5 "The grammar token "[whatever]" translates into I6 as "WHATEVER". ++
+<translates-into-i6-sentence-subject> ::= + ... property | ==> { PROPERTY_I6TR, - } + ... object/kind | ==> { NOUN_I6TR, - } + {... rule} | ==> { RULE_I6TR, - } + ... variable | ==> { VARIABLE_I6TR, - } + ... action | ==> { ACTION_I6TR, - } + understand token ... | ==> { GRAMMAR_TOKEN_I6TR, - } + ... ==> Issue PM_TranslatedUnknownCategory problem8.1 ++
§8.1. Issue PM_TranslatedUnknownCategory problem8.1 = +
+ ++ StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_TranslatedUnknownCategory), + "that isn't one of the things which can be translated to I6", + "and should be '... variable', '... property', '... object', " + "'... kind', '... rule', or '... action'. For instance, 'The yourself " + "object translates into I6 as \"selfobj\".'"); + ==> { INVALID_I6TR, - }; ++
§7.1. The object noun phrase is usually just an I6 identifier in quotation marks, +but it's also possible to list literal texts (for the benefit of rules). +Following the optional "with" is an articled list, each entry of which +will be required to pass <extra-response>. +
+ ++<translates-into-i6-sentence-object> ::= + <quoted-text> with <np-articled-list> | ==> { R[1], RP[2] } + <quoted-text> ==> { R[1], NULL } ++
§7.2. Act on the Inter translation7.2 = +
+ ++ parse_node *p1 = V->next; + parse_node *p2 = V->next->next; + parse_node *responses_list = NULL; + int category = INVALID_I6TR; + <translates-into-i6-sentence-subject>(Node::get_text(p1)); + category = <<r>>; + if (category != INVALID_I6TR) { + wording W = GET_RW(<translates-into-i6-sentence-subject>, 1); + + if (global_pass_state.pass == 1) { + Annotations::write_int(V, category_of_I6_translation_ANNOT, INVALID_I6TR); + Ensure that we are translating to a quoted I6 identifier7.2.1; + Annotations::write_int(V, category_of_I6_translation_ANNOT, category); + if (responses_list) SyntaxTree::graft(Task::syntax_tree(), responses_list, p2); + } else category = Annotations::read_int(V, category_of_I6_translation_ANNOT); + + Take action in pass 1 or 2 where possible7.2.2; + } ++
§7.2.1. Ensure that we are translating to a quoted I6 identifier7.2.1 = +
+ ++ int valid = TRUE; + if (<translates-into-i6-sentence-object>(Node::get_text(p2)) == FALSE) valid = FALSE; + else responses_list = <<rp>>; + if (valid) Dequote it and see if it's valid7.2.1.1; + if (valid == FALSE) { + StandardProblems::sentence_problem(Task::syntax_tree(), + _p_(PM_TranslatedToNonIdentifier), + "Inform 7 constructions can only translate into quoted I6 identifiers", + "which must be strings of 1 to 31 characters drawn from 1, 2, ..., 9, " + "a or A, b or B, ..., z or Z, or underscore '_', except that the " + "first character is not allowed to be a digit."); + return FALSE; + } ++
§7.2.1.1. If it turns out not to be, we simply set valid to false. +
+ +Dequote it and see if it's valid7.2.1.1 = +
+ ++ int wn = Wordings::first_wn(Node::get_text(p2)); + Node::set_text(p2, Wordings::one_word(wn)); + Word::dequote(wn); + if (valid) valid = Identifiers::valid(Lexer::word_text(wn)); ++
§7.2.2. In some cases, we act on pass 1, but in others pass 2, and in the case of +NOUN_I6TR, later even than that. There are messy timing issues here. +
+ +Take action in pass 1 or 2 where possible7.2.2 = +
+ ++ switch(category) { + case PROPERTY_I6TR: + Properties::translates(W, p2); + Annotations::write_int(V, category_of_I6_translation_ANNOT, INVALID_I6TR); + break; + case NOUN_I6TR: break; + case RULE_I6TR: + if (global_pass_state.pass == 1) + Rules::declare_I6_written_rule(W, p2); + if ((global_pass_state.pass == 2) && (p2->down) && (<rule-name>(W))) + Translations::plus_responses(p2->down, <<rp>>); + break; + case VARIABLE_I6TR: + if (global_pass_state.pass == 2) NonlocalVariables::translates(W, p2); + break; + #ifdef IF_MODULE + case ACTION_I6TR: + if (global_pass_state.pass == 2) PL::Actions::translates(W, p2); + break; + case GRAMMAR_TOKEN_I6TR: + if (global_pass_state.pass == 2) PL::Parsing::Verbs::translates(W, p2); + break; + #endif + } ++
§7.3. Extra responses look just as they would in running code. +
+ ++<extra-response> ::= + <quoted-text> ( <response-letter> ) ==> { pass 2 } ++
+void Translations::plus_responses(parse_node *p, rule *R) { + if (Node::get_type(p) == AND_NT) { + Translations::plus_responses(p->down, R); + Translations::plus_responses(p->down->next, R); + } else { + if (<extra-response>(Node::get_text(p))) { + int code = <<r>>; + response_message *resp = Strings::response_cue(NULL, R, + code, Node::get_text(p), NULL, TRUE); + Rules::now_rule_defines_response(R, code, resp); + } else { + StandardProblems::sentence_problem(Task::syntax_tree(), + _p_(PM_I6ResponsesAwry), + "additional information about I6 translation of a rule can " + "only take the form of a list of responses", + "each quoted and followed by a bracketed letter."); + } + } +} ++
§7.5. As noted above, NOUN_I6TR renamings happen much later on. +
+ +Act on late naming7.5 = +
+ ++ wording SP = Node::get_text(V->next); + wording OP = Node::get_text(V->next->next); + int category = Annotations::read_int(V, category_of_I6_translation_ANNOT); + switch(category) { + case NOUN_I6TR: { + wording W = Wordings::trim_last_word(SP); + parse_node *res = Lexicon::retrieve(NOUN_MC, W); + if (res) { + noun_usage *nu = Nouns::disambiguate(res, FALSE); + noun *nt = (nu)?(nu->noun_used):NULL; + if (nt) { + TEMPORARY_TEXT(i6r) + WRITE_TO(i6r, "%N", Wordings::first_wn(OP)); + UseNouns::noun_set_I6_representation(nt, i6r); + DISCARD_TEXT(i6r) + } + } else { + StandardProblems::sentence_problem(Task::syntax_tree(), + _p_(PM_BadObjectTranslation), + "there is no such object or kind of object", + "so its name will never be translated into an Inter " + "identifier in any event."); + } + break; + } + } ++
Special sentences for setting compilation options.
+ +§1. The Use sentence. Note that any sentence beginning with the word "Use" is accepted here, which +is a very wide net: unlike most special meaning sentences, there's no attempt +to cut down the risk of false positives by screening the noun phrase. +
+ ++int UseOptions::use_SMF(int task, parse_node *V, wording *NPs) { + wording OW = (NPs)?(NPs[1]):EMPTY_WORDING; + switch (task) { "Use American dialect." + case ACCEPT_SMFT: + <np-articled-list>(OW); + V->next = <<rp>>; + return TRUE; + case ALLOW_IN_OPTIONS_FILE_SMFT: + return TRUE; + case PASS_1_SMFT: + case PASS_2_SMFT: + UseOptions::set_use_options(V->next); + break; + } + return FALSE; +} ++
§2. "Use" sentences are simple in structure. Their object noun phrases are +articled lists: +
+ +++ +Use American dialect and the serial comma.
+
+void UseOptions::set_use_options(parse_node *p) { + if (Node::get_type(p) == AND_NT) { + UseOptions::set_use_options(p->down); + UseOptions::set_use_options(p->down->next); + return; + } + Set a single use option2.2; +} ++
§2.1. Each of the entries in this list must match the following; the text of the +option name is taken from the ... or ### as appropriate: +
+ ++<use-inter-pipeline> ::= + inter pipeline {<quoted-text>} ==> { TRUE, - } + +<use-memory-setting> ::= + ### of <cardinal-number-unlimited> ==> { R[1], - } + +<use-setting> ::= + ... of at least <cardinal-number-unlimited> | ==> { R[1], - } + <definite-article> ... | ==> { -1, - } + ... ==> { -1, - } ++
§2.2. Set a single use option2.2 = +
+ ++ wording S = Node::get_text(p); + if (<use-inter-pipeline>(S)) + Set the pipeline given in this word range2.2.1 + else if (<use-memory-setting>(S)) + Set a memory setting2.2.2 + else if (<use-setting>(S)) + Set the option given in this word range2.2.3 ++
§2.2.1. This is an undocumented feature used during the transition from I6 to Inter: +
+ +Set the pipeline given in this word range2.2.1 = +
+ ++ wording CW = GET_RW(<use-inter-pipeline>, 1); + if (global_pass_state.pass == 1) { + TEMPORARY_TEXT(p) + WRITE_TO(p, "%W", CW); + Str::delete_first_character(p); + Str::delete_last_character(p); + Supervisor::set_inter_pipeline(p); + DISCARD_TEXT(p) + } ++
§2.2.2. ICL, the "Inform 6 control language", is a set of a pragma-like settings for +the I6 compiler. Of course, in the age in Inter, those might well be ignored, +since the compiler next down the chain may no longer be I6. +
+ +See //runtime:Use Options at Run Time// for what happens to these. +
+ +Set a memory setting2.2.2 = +
+ ++ int n = <<r>>, w1 = Wordings::first_wn(S); + TEMPORARY_TEXT(icl_identifier) + WRITE_TO(icl_identifier, "%+W", Wordings::one_word(w1)); + if (Str::len(icl_identifier) > 63) { + StandardProblems::sentence_problem(Task::syntax_tree(), + _p_(PM_BadICLIdentifier), + "that is too long to be an ICL identifier", + "so can't be the name of any I6 memory setting."); + } + NewUseOptions::memory_setting(icl_identifier, n); + DISCARD_TEXT(icl_identifier) ++
§2.2.3. Whereas thus is the standard use option syntax: +
+ +Set the option given in this word range2.2.3 = +
+ ++ int min_setting = <<r>>; + wording OW = GET_RW(<use-setting>, 1); + use_option *uo = NewUseOptions::parse_uo(OW); + if (uo) NewUseOptions::set(uo, min_setting, + Lexer::file_of_origin(Wordings::first_wn(OW))); + else if (global_pass_state.pass > 1) { + LOG("Used: %W\n", S); + StandardProblems::sentence_problem(Task::syntax_tree(), + _p_(PM_UnknownUseOption), + "that isn't a 'Use' option known to me", + "and needs to be one of the ones listed in the documentation."); + } ++
Turning regular assertion sentences into propositions about the model world.
+
Verbs which establish relationships between nouns, and which give meaning to binary predicates.
+ Chapter 5: Basic Adjectives and Relations +Predicates for the calculus module to use.
@@ -256,14 +261,9 @@ To define the binary predicates corresponding to numerical comparisons.
-
-
+
@@ -271,61 +271,29 @@ To draw inferences from the relations created explicitly by the source text.
-
-
+
In which the stream of words is broken up into sentences and built into a parse tree, recording primary verbs, noun phrases and some sub-clauses; and in which these sentences are collected under a hierarchy of headings, with material intended only for certain target virtual machines included or excluded as need be.
-
-
-
-
Inform's preferred data structure for small initialised databases.
+
+
-
+
Setting up the use of this module.
+§1. This section simoly sets up the module in ways expected by foundation, and
contains no code of interest. The following constant exists only in tools
which use this module:
@@ -272,7 +261,7 @@ or other text streams.
COMPILE_WRITER(extension_dictionary_entry *, ExtensionDictionary::log_entry)
COMPILE_WRITER(parse_node *, Invocations::log_list)
COMPILE_WRITER(parse_node *, Invocations::log)
-COMPILE_WRITER(heading *, Sentences::Headings::log)
+COMPILE_WRITER(heading *, IndexHeadings::log)
COMPILE_WRITER(ph_type_data *, Phrases::TypeData::Textual::log)
COMPILE_WRITER(inference *, World::Inferences::log)
COMPILE_WRITER(i6_schema *, Calculus::Schemas::log)
@@ -307,7 +296,7 @@ or other text streams.
Relations::Universal::start();
Relations::Explicit::start();
EqualityDetails::start();
- Declare the tree annotations6.10;
+ ParseTreeUsage::declare_annotations();
}
void CoreModule::end(void) {
}
@@ -349,7 +338,7 @@ we need to use the equivalent of traditional
- Writers::register_writer_I('B', &CoreModule::writer);
+ Writers::register_writer_I('B', &CoreModule::writer);
Writers::register_writer('I', &Instances::writer);
Writers::register_writer('L', &LocalVariables::writer);
@@ -453,7 +442,7 @@ we need to use the equivalent of traditional REGISTER_WRITER('d', ExtensionDictionary::log_entry);
REGISTER_WRITER('E', Invocations::log_list);
REGISTER_WRITER('e', Invocations::log);
- REGISTER_WRITER('H', Sentences::Headings::log);
+ REGISTER_WRITER('H', IndexHeadings::log);
REGISTER_WRITER('h', Phrases::TypeData::Textual::log);
REGISTER_WRITER('I', World::Inferences::log);
REGISTER_WRITER('i', Calculus::Schemas::log);
@@ -470,7 +459,7 @@ we need to use the equivalent of traditional REGISTER_WRITER('z', Nouns::log);
§6.8. This module uses syntax, and adds the following annotations to the syntax
-tree; though it's a little like itemising the baubles on a Christmas tree.
+ §8. Built-in relation names. These have to be defined somewhere, and it may as well be here.
§6.9. So we itemise the pointer-valued annotations below, and the macro expands
-to provide their get and set functions:
+ §9. These are the English names of the built-in relations. The use of hyphenation
+here is a fossil from the times when Inform allowed only single-word relation
+names; but it doesn't seem worth changing, especially as the hyphenated
+relations are almost never needed for anything. All the same, translators into
+other languages may as well drop the hyphens.
§6.10. And we have declare all of those:
- Declare the tree annotations6.10 =
- Itemising the baubles on a Christmas tree. §2. So we itemise the pointer-valued annotations below, and the macro expands
+to provide their get and set functions:
+ §3. And we have declare all of those:
+ §7. The next specification nodes are the rvalues. These express I6 values —
+numbers, objects, text and so on — but cannot be assigned to, so that in an
+assignment of the form "change L to R" they can be used only as R, not L. This
+is not the same thing as a constant: for instance, "location of the player"
+evaluates differently at different times, but cannot be changed in an
+assignment.
+ §8. Lvalue nodes represent stored I6 data at run-time, which means that they can
+be assigned to. (The traditional terms "lvalue" and "rvalue" refer to the left
+and right hand side of assignment statements written A = B.) For instance, a
+table entry qualifies as an lvalue because it can be both read and changed. To
+qualify as an lvalue, text must exactly specify the storage location referred
+to: "Table of Corvettes" only indicates a table, not an entry in a table, so
+is merely an rvalue. Similarly, "carrying capacity" (as a property name not
+indicating an owner) is a mere rvalue.
+ §9. Condition nodes represent atomic conditions, and also Boolean operations on
+them. It's convenient to represent these operations as nodes in their own right
+rather than as (for example) phrases: this reduces parsing ambiguities, but
+also makes it easier for us to manipulate the results.
+ §15. Further classification:
+
-
+
void CoreModule::writer(OUTPUT_STREAM, char *format_string, int wn) {
@@ -483,685 +472,67 @@ we need to use the equivalent of traditional }
}
-enum action_meaning_ANNOT action_pattern: meaning in parse tree when used as noun
-enum predicate_ANNOT unary_predicate: which adjective is asserted
-enum category_of_I6_translation_ANNOT int: what sort of "translates into I6" sentence this is
-enum classified_ANNOT int: this sentence has been classified
-enum clears_pronouns_ANNOT int: this sentence erases the current value of "it"
-enum colon_block_command_ANNOT int: this COMMAND uses the ":" not begin/end syntax
-enum condition_tense_ANNOT time_period: for specification nodes
-enum constant_action_name_ANNOT action_name: for constant values
-enum constant_action_pattern_ANNOT action_pattern: for constant values
-enum constant_activity_ANNOT activity: for constant values
-enum constant_binary_predicate_ANNOT binary_predicate: for constant values
-enum constant_constant_phrase_ANNOT constant_phrase: for constant values
-enum constant_enumeration_ANNOT int: which one from an enumerated kind
-enum constant_equation_ANNOT equation: for constant values
-enum constant_grammar_verb_ANNOT grammar_verb: for constant values
-enum constant_instance_ANNOT instance: for constant values
-enum constant_local_variable_ANNOT local_variable: for constant values
-enum constant_named_action_pattern_ANNOT named_action_pattern: for constant values
-enum constant_named_rulebook_outcome_ANNOT named_rulebook_outcome: for constant values
-enum constant_nonlocal_variable_ANNOT nonlocal_variable: for constant values
-enum constant_number_ANNOT int: which integer this is
-enum constant_property_ANNOT property: for constant values
-enum constant_rule_ANNOT rule: for constant values
-enum constant_rulebook_ANNOT rulebook: for constant values
-enum constant_scene_ANNOT scene: for constant values
-enum constant_table_ANNOT table: for constant values
-enum constant_table_column_ANNOT table_column: for constant values
-enum constant_text_ANNOT text_stream: for constant values
-enum constant_use_option_ANNOT use_option: for constant values
-enum constant_verb_form_ANNOT verb_form: for constant values
-enum control_structure_used_ANNOT control_structure_phrase: for CODE BLOCK nodes only
-enum converted_SN_ANNOT int: marking descriptions
-enum creation_proposition_ANNOT pcalc_prop: proposition which newly created value satisfies
-enum creation_site_ANNOT int: whether an instance was created from this node
-enum defn_language_ANNOT inform_language: what language this definition is in
-enum end_control_structure_used_ANNOT control_structure_phrase: for CODE BLOCK nodes only
-enum epistemological_status_ANNOT int: a bitmap of results from checking an ambiguous reading
-enum evaluation_ANNOT parse_node: result of evaluating the text
-enum explicit_iname_ANNOT inter_name: is this value explicitly an iname?
-enum explicit_literal_ANNOT int: my value is an explicit integer or text
-enum explicit_vh_ANNOT value_holster: used for compiling I6-level properties
-enum from_text_substitution_ANNOT int: whether this is an implicit say invocation
-enum explicit_gender_marker_ANNOT int: used by PROPER NOUN nodes for evident genders
-enum grammar_token_code_ANNOT int: used to identify grammar tokens
-enum grammar_token_literal_ANNOT int: for grammar tokens which are literal words
-enum grammar_token_relation_ANNOT binary_predicate: for relation tokens
-enum grammar_value_ANNOT parse_node: used as a marker when evaluating Understand grammar
-enum implicit_in_creation_of_ANNOT inference_subject: for assemblies
-enum implicitness_count_ANNOT int: keeping track of recursive assemblies
-enum indentation_level_ANNOT int: for routines written with Pythonesque indentation
-enum interpretation_of_subject_ANNOT inference_subject: subject, during passes
-enum is_phrase_option_ANNOT int: this unparsed text is a phrase option
-enum kind_of_new_variable_ANNOT kind: what if anything is returned
-enum kind_of_value_ANNOT kind: for specification nodes
-enum kind_required_by_context_ANNOT kind: what if anything is expected here
-enum kind_resulting_ANNOT kind: what if anything is returned
-enum kind_variable_declarations_ANNOT kind_variable_declaration: and of these
-enum rule_placement_sense_ANNOT int: are we listing a rule into something, or out of it?
-enum lpe_options_ANNOT int: options set for a literal pattern part
-enum modal_verb_ANNOT verb_conjugation: relevant only for that: e.g., "might"
-enum multiplicity_ANNOT int: e.g., 5 for "five gold rings"
-enum new_relation_here_ANNOT binary_predicate: new relation as subject of "relates" sentence
-enum nothing_object_ANNOT int: this represents nothing at run-time
-enum nowhere_ANNOT int: used by the spatial plugin to show this represents "nowhere"
-enum phrase_invoked_ANNOT phrase: the phrase believed to be invoked...
-enum phrase_option_ANNOT int: \(2^i\) where \(i\) is the option number, \(0\leq i<16\)
-enum phrase_options_invoked_ANNOT invocation_options: details of any options used
-enum property_name_used_as_noun_ANNOT int: in ambiguous cases such as "open"
-enum proposition_ANNOT pcalc_prop: for specification nodes
-enum quant_ANNOT quantifier: for quantified excerpts like "three baskets"
-enum quantification_parameter_ANNOT int: e.g., 3 for "three baskets"
-enum record_as_self_ANNOT int: record recipient as self when writing this
-enum refined_ANNOT int: this subtree has had its nouns parsed
-enum response_code_ANNOT int: for responses only
-enum results_from_splitting_ANNOT int: node in a routine's parse tree from comma block notation
-enum row_amendable_ANNOT int: a candidate row for a table amendment
-enum save_self_ANNOT int: this invocation must save and preserve self at run-time
-enum say_adjective_ANNOT adjective: ...or the adjective to be agreed with by "say"
-enum say_verb_ANNOT verb_conjugation: ...or the verb to be conjugated by "say"
-enum say_verb_negated_ANNOT relevant only for that
-enum self_object_ANNOT int: this represents self at run-time
-enum slash_class_ANNOT int: used when partitioning grammar tokens
-enum slash_dash_dash_ANNOT int: used when partitioning grammar tokens
-enum ssp_closing_segment_wn_ANNOT int: identifier for the last of these, or -1
-enum ssp_segment_count_ANNOT int: number of subsequent complex-say phrases in stream
-enum subject_ANNOT inference_subject: what this node describes
-enum suppress_newlines_ANNOT int: whether the next say term runs on
-enum table_cell_unspecified_ANNOT int: used to mark table entries as unset
-enum tense_marker_ANNOT grammatical_usage: for specification nodes
-enum text_unescaped_ANNOT int: flag used only for literal texts
-enum token_as_parsed_ANNOT parse_node: what if anything is returned
-enum token_check_to_do_ANNOT parse_node: what if anything is returned
-enum token_to_be_parsed_against_ANNOT parse_node: what if anything is returned
-enum turned_already_ANNOT int: aliasing like "player" to "yourself" performed already
-enum unit_ANNOT compilation_unit: set only for headings, routines and sentences
-enum unproven_ANNOT int: this invocation needs run-time typechecking
-enum verb_problem_issued_ANNOT int: has a problem message about the primary verb been issued already?
-enum you_can_ignore_ANNOT int: for assertions now drained of meaning
+
define EQUALITY_RELATION_NAME 0
+define UNIVERSAL_RELATION_NAME 1
+define MEANING_RELATION_NAME 2
+define PROVISION_RELATION_NAME 3
+define GE_RELATION_NAME 4
+define GT_RELATION_NAME 5
+define LE_RELATION_NAME 6
+define LT_RELATION_NAME 7
+define ADJACENCY_RELATION_NAME 8
+define REGIONAL_CONTAINMENT_RELATION_NAME 9
+define CONTAINMENT_RELATION_NAME 10
+define SUPPORT_RELATION_NAME 11
+define INCORPORATION_RELATION_NAME 12
+define CARRYING_RELATION_NAME 13
+define HOLDING_RELATION_NAME 14
+define WEARING_RELATION_NAME 15
+define POSSESSION_RELATION_NAME 16
+define VISIBILITY_RELATION_NAME 17
+define TOUCHABILITY_RELATION_NAME 18
+define CONCEALMENT_RELATION_NAME 19
+define ENCLOSURE_RELATION_NAME 20
+define ROOM_CONTAINMENT_RELATION_NAME 21
-
-DECLARE_ANNOTATION_FUNCTIONS(condition_tense, time_period)
-DECLARE_ANNOTATION_FUNCTIONS(constant_activity, activity)
-DECLARE_ANNOTATION_FUNCTIONS(constant_binary_predicate, binary_predicate)
-DECLARE_ANNOTATION_FUNCTIONS(constant_constant_phrase, constant_phrase)
-DECLARE_ANNOTATION_FUNCTIONS(constant_equation, equation)
-DECLARE_ANNOTATION_FUNCTIONS(constant_instance, instance)
-DECLARE_ANNOTATION_FUNCTIONS(constant_local_variable, local_variable)
-DECLARE_ANNOTATION_FUNCTIONS(constant_named_rulebook_outcome, named_rulebook_outcome)
-DECLARE_ANNOTATION_FUNCTIONS(constant_nonlocal_variable, nonlocal_variable)
-DECLARE_ANNOTATION_FUNCTIONS(constant_property, property)
-DECLARE_ANNOTATION_FUNCTIONS(constant_rule, rule)
-DECLARE_ANNOTATION_FUNCTIONS(constant_rulebook, rulebook)
-DECLARE_ANNOTATION_FUNCTIONS(constant_table_column, table_column)
-DECLARE_ANNOTATION_FUNCTIONS(constant_table, table)
-DECLARE_ANNOTATION_FUNCTIONS(constant_text, text_stream)
-DECLARE_ANNOTATION_FUNCTIONS(constant_use_option, use_option)
-DECLARE_ANNOTATION_FUNCTIONS(constant_verb_form, verb_form)
-DECLARE_ANNOTATION_FUNCTIONS(control_structure_used, control_structure_phrase)
-DECLARE_ANNOTATION_FUNCTIONS(creation_proposition, pcalc_prop)
-DECLARE_ANNOTATION_FUNCTIONS(defn_language, inform_language)
-DECLARE_ANNOTATION_FUNCTIONS(end_control_structure_used, control_structure_phrase)
-DECLARE_ANNOTATION_FUNCTIONS(evaluation, parse_node)
-DECLARE_ANNOTATION_FUNCTIONS(explicit_vh, value_holster)
-DECLARE_ANNOTATION_FUNCTIONS(grammar_token_relation, binary_predicate)
-DECLARE_ANNOTATION_FUNCTIONS(grammar_value, parse_node)
-DECLARE_ANNOTATION_FUNCTIONS(implicit_in_creation_of, inference_subject)
-DECLARE_ANNOTATION_FUNCTIONS(interpretation_of_subject, inference_subject)
-DECLARE_ANNOTATION_FUNCTIONS(kind_of_new_variable, kind)
-DECLARE_ANNOTATION_FUNCTIONS(kind_of_value, kind)
-DECLARE_ANNOTATION_FUNCTIONS(kind_required_by_context, kind)
-DECLARE_ANNOTATION_FUNCTIONS(kind_resulting, kind)
-DECLARE_ANNOTATION_FUNCTIONS(kind_variable_declarations, kind_variable_declaration)
-DECLARE_ANNOTATION_FUNCTIONS(explicit_iname, inter_name)
-DECLARE_ANNOTATION_FUNCTIONS(modal_verb, verb_conjugation)
-DECLARE_ANNOTATION_FUNCTIONS(new_relation_here, binary_predicate)
-DECLARE_ANNOTATION_FUNCTIONS(phrase_invoked, phrase)
-DECLARE_ANNOTATION_FUNCTIONS(phrase_options_invoked, invocation_options)
-DECLARE_ANNOTATION_FUNCTIONS(predicate, unary_predicate)
-DECLARE_ANNOTATION_FUNCTIONS(proposition, pcalc_prop)
-DECLARE_ANNOTATION_FUNCTIONS(quant, quantifier)
-DECLARE_ANNOTATION_FUNCTIONS(say_adjective, adjective)
-DECLARE_ANNOTATION_FUNCTIONS(say_verb, verb_conjugation)
-DECLARE_ANNOTATION_FUNCTIONS(subject, inference_subject)
-DECLARE_ANNOTATION_FUNCTIONS(tense_marker, grammatical_usage)
-DECLARE_ANNOTATION_FUNCTIONS(token_as_parsed, parse_node)
-DECLARE_ANNOTATION_FUNCTIONS(token_check_to_do, parse_node)
-DECLARE_ANNOTATION_FUNCTIONS(token_to_be_parsed_against, parse_node)
-DECLARE_ANNOTATION_FUNCTIONS(unit, compilation_unit)
-
-
-MAKE_ANNOTATION_FUNCTIONS(condition_tense, time_period)
-MAKE_ANNOTATION_FUNCTIONS(constant_activity, activity)
-MAKE_ANNOTATION_FUNCTIONS(constant_binary_predicate, binary_predicate)
-MAKE_ANNOTATION_FUNCTIONS(constant_constant_phrase, constant_phrase)
-MAKE_ANNOTATION_FUNCTIONS(constant_equation, equation)
-MAKE_ANNOTATION_FUNCTIONS(constant_instance, instance)
-MAKE_ANNOTATION_FUNCTIONS(constant_local_variable, local_variable)
-MAKE_ANNOTATION_FUNCTIONS(constant_named_rulebook_outcome, named_rulebook_outcome)
-MAKE_ANNOTATION_FUNCTIONS(constant_nonlocal_variable, nonlocal_variable)
-MAKE_ANNOTATION_FUNCTIONS(constant_property, property)
-MAKE_ANNOTATION_FUNCTIONS(constant_rule, rule)
-MAKE_ANNOTATION_FUNCTIONS(constant_rulebook, rulebook)
-MAKE_ANNOTATION_FUNCTIONS(constant_table_column, table_column)
-MAKE_ANNOTATION_FUNCTIONS(constant_table, table)
-MAKE_ANNOTATION_FUNCTIONS(constant_text, text_stream)
-MAKE_ANNOTATION_FUNCTIONS(constant_use_option, use_option)
-MAKE_ANNOTATION_FUNCTIONS(constant_verb_form, verb_form)
-MAKE_ANNOTATION_FUNCTIONS(control_structure_used, control_structure_phrase)
-MAKE_ANNOTATION_FUNCTIONS(creation_proposition, pcalc_prop)
-MAKE_ANNOTATION_FUNCTIONS(defn_language, inform_language)
-MAKE_ANNOTATION_FUNCTIONS(end_control_structure_used, control_structure_phrase)
-MAKE_ANNOTATION_FUNCTIONS(evaluation, parse_node)
-MAKE_ANNOTATION_FUNCTIONS(explicit_vh, value_holster)
-MAKE_ANNOTATION_FUNCTIONS(grammar_token_relation, binary_predicate)
-MAKE_ANNOTATION_FUNCTIONS(grammar_value, parse_node)
-MAKE_ANNOTATION_FUNCTIONS(implicit_in_creation_of, inference_subject)
-MAKE_ANNOTATION_FUNCTIONS(interpretation_of_subject, inference_subject)
-MAKE_ANNOTATION_FUNCTIONS(kind_of_new_variable, kind)
-MAKE_ANNOTATION_FUNCTIONS(kind_of_value, kind)
-MAKE_ANNOTATION_FUNCTIONS(kind_required_by_context, kind)
-MAKE_ANNOTATION_FUNCTIONS(kind_resulting, kind)
-MAKE_ANNOTATION_FUNCTIONS(kind_variable_declarations, kind_variable_declaration)
-MAKE_ANNOTATION_FUNCTIONS(modal_verb, verb_conjugation)
-MAKE_ANNOTATION_FUNCTIONS(new_relation_here, binary_predicate)
-MAKE_ANNOTATION_FUNCTIONS(phrase_invoked, phrase)
-MAKE_ANNOTATION_FUNCTIONS(phrase_options_invoked, invocation_options)
-MAKE_ANNOTATION_FUNCTIONS(predicate, unary_predicate)
-MAKE_ANNOTATION_FUNCTIONS(proposition, pcalc_prop)
-MAKE_ANNOTATION_FUNCTIONS(quant, quantifier)
-MAKE_ANNOTATION_FUNCTIONS(say_adjective, adjective)
-MAKE_ANNOTATION_FUNCTIONS(say_verb, verb_conjugation)
-MAKE_ANNOTATION_FUNCTIONS(subject, inference_subject)
-MAKE_ANNOTATION_FUNCTIONS(tense_marker, grammatical_usage)
-MAKE_ANNOTATION_FUNCTIONS(token_as_parsed, parse_node)
-MAKE_ANNOTATION_FUNCTIONS(token_check_to_do, parse_node)
-MAKE_ANNOTATION_FUNCTIONS(token_to_be_parsed_against, parse_node)
-
-
- Annotations::declare_type(action_meaning_ANNOT, NULL);
- Annotations::declare_type(predicate_ANNOT, NULL);
- Annotations::declare_type(category_of_I6_translation_ANNOT, NULL);
- Annotations::declare_type(classified_ANNOT, NULL);
- Annotations::declare_type(clears_pronouns_ANNOT, NULL);
- Annotations::declare_type(colon_block_command_ANNOT, NULL);
- Annotations::declare_type(condition_tense_ANNOT,
- CoreModule::write_condition_tense_ANNOT);
- Annotations::declare_type(constant_action_name_ANNOT, NULL);
- Annotations::declare_type(constant_action_pattern_ANNOT, NULL);
- Annotations::declare_type(constant_activity_ANNOT, NULL);
- Annotations::declare_type(constant_binary_predicate_ANNOT, NULL);
- Annotations::declare_type(constant_constant_phrase_ANNOT, NULL);
- Annotations::declare_type(constant_enumeration_ANNOT, NULL);
- Annotations::declare_type(constant_equation_ANNOT, NULL);
- Annotations::declare_type(constant_grammar_verb_ANNOT, NULL);
- Annotations::declare_type(constant_instance_ANNOT,
- CoreModule::write_constant_instance_ANNOT);
- Annotations::declare_type(constant_local_variable_ANNOT,
- CoreModule::write_constant_local_variable_ANNOT);
- Annotations::declare_type(constant_named_action_pattern_ANNOT, NULL);
- Annotations::declare_type(constant_named_rulebook_outcome_ANNOT, NULL);
- Annotations::declare_type(constant_nonlocal_variable_ANNOT,
- CoreModule::write_constant_nonlocal_variable_ANNOT);
- Annotations::declare_type(constant_number_ANNOT, NULL);
- Annotations::declare_type(constant_property_ANNOT, NULL);
- Annotations::declare_type(constant_rule_ANNOT, NULL);
- Annotations::declare_type(constant_rulebook_ANNOT, NULL);
- Annotations::declare_type(constant_scene_ANNOT, NULL);
- Annotations::declare_type(constant_table_ANNOT, NULL);
- Annotations::declare_type(constant_table_column_ANNOT, NULL);
- Annotations::declare_type(constant_text_ANNOT, NULL);
- Annotations::declare_type(constant_use_option_ANNOT, NULL);
- Annotations::declare_type(constant_verb_form_ANNOT, NULL);
- Annotations::declare_type(control_structure_used_ANNOT,
- CoreModule::write_control_structure_used_ANNOT);
- Annotations::declare_type(converted_SN_ANNOT, NULL);
- Annotations::declare_type(creation_proposition_ANNOT,
- CoreModule::write_creation_proposition_ANNOT);
- Annotations::declare_type(creation_site_ANNOT,
- CoreModule::write_creation_site_ANNOT);
- Annotations::declare_type(defn_language_ANNOT,
- CoreModule::write_defn_language_ANNOT);
- Annotations::declare_type(end_control_structure_used_ANNOT, NULL);
- Annotations::declare_type(epistemological_status_ANNOT, NULL);
- Annotations::declare_type(evaluation_ANNOT,
- CoreModule::write_evaluation_ANNOT);
- Annotations::declare_type(explicit_iname_ANNOT, NULL);
- Annotations::declare_type(explicit_literal_ANNOT, NULL);
- Annotations::declare_type(explicit_vh_ANNOT, NULL);
- Annotations::declare_type(from_text_substitution_ANNOT, NULL);
- Annotations::declare_type(explicit_gender_marker_ANNOT, NULL);
- Annotations::declare_type(grammar_token_code_ANNOT, NULL);
- Annotations::declare_type(grammar_token_literal_ANNOT, NULL);
- Annotations::declare_type(grammar_token_relation_ANNOT, NULL);
- Annotations::declare_type(grammar_value_ANNOT, NULL);
- Annotations::declare_type(implicit_in_creation_of_ANNOT, NULL);
- Annotations::declare_type(implicitness_count_ANNOT, NULL);
- Annotations::declare_type(indentation_level_ANNOT,
- CoreModule::write_indentation_level_ANNOT);
- Annotations::declare_type(interpretation_of_subject_ANNOT, NULL);
- Annotations::declare_type(is_phrase_option_ANNOT, NULL);
- Annotations::declare_type(kind_of_new_variable_ANNOT,
- CoreModule::write_kind_of_new_variable_ANNOT);
- Annotations::declare_type(kind_of_value_ANNOT,
- CoreModule::write_kind_of_value_ANNOT);
- Annotations::declare_type(kind_required_by_context_ANNOT,
- CoreModule::write_kind_required_by_context_ANNOT);
- Annotations::declare_type(kind_resulting_ANNOT, NULL);
- Annotations::declare_type(kind_variable_declarations_ANNOT, NULL);
- Annotations::declare_type(rule_placement_sense_ANNOT, NULL);
- Annotations::declare_type(lpe_options_ANNOT, NULL);
- Annotations::declare_type(modal_verb_ANNOT, NULL);
- Annotations::declare_type(multiplicity_ANNOT,
- CoreModule::write_multiplicity_ANNOT);
- Annotations::declare_type(new_relation_here_ANNOT, NULL);
- Annotations::declare_type(nothing_object_ANNOT,
- CoreModule::write_nothing_object_ANNOT);
- Annotations::declare_type(nowhere_ANNOT, NULL);
- Annotations::declare_type(phrase_invoked_ANNOT, NULL);
- Annotations::declare_type(phrase_option_ANNOT, NULL);
- Annotations::declare_type(phrase_options_invoked_ANNOT, NULL);
- Annotations::declare_type(property_name_used_as_noun_ANNOT, NULL);
- Annotations::declare_type(proposition_ANNOT,
- CoreModule::write_proposition_ANNOT);
- Annotations::declare_type(quant_ANNOT, NULL);
- Annotations::declare_type(quantification_parameter_ANNOT, NULL);
- Annotations::declare_type(record_as_self_ANNOT, NULL);
- Annotations::declare_type(refined_ANNOT, NULL);
- Annotations::declare_type(response_code_ANNOT, NULL);
- Annotations::declare_type(results_from_splitting_ANNOT, NULL);
- Annotations::declare_type(row_amendable_ANNOT, NULL);
- Annotations::declare_type(save_self_ANNOT, NULL);
- Annotations::declare_type(say_adjective_ANNOT, NULL);
- Annotations::declare_type(say_verb_ANNOT, NULL);
- Annotations::declare_type(say_verb_negated_ANNOT, NULL);
- Annotations::declare_type(self_object_ANNOT,
- CoreModule::write_self_object_ANNOT);
- Annotations::declare_type(slash_class_ANNOT,
- CoreModule::write_slash_class_ANNOT);
- Annotations::declare_type(slash_dash_dash_ANNOT,
- CoreModule::write_slash_dash_dash_ANNOT);
- Annotations::declare_type(ssp_closing_segment_wn_ANNOT, NULL);
- Annotations::declare_type(ssp_segment_count_ANNOT, NULL);
- Annotations::declare_type(subject_ANNOT, NULL);
- Annotations::declare_type(suppress_newlines_ANNOT, NULL);
- Annotations::declare_type(table_cell_unspecified_ANNOT, NULL);
- Annotations::declare_type(tense_marker_ANNOT, NULL);
- Annotations::declare_type(text_unescaped_ANNOT, NULL);
- Annotations::declare_type(token_as_parsed_ANNOT, NULL);
- Annotations::declare_type(token_check_to_do_ANNOT, NULL);
- Annotations::declare_type(token_to_be_parsed_against_ANNOT, NULL);
- Annotations::declare_type(turned_already_ANNOT, NULL);
- Annotations::declare_type(unit_ANNOT, NULL);
- Annotations::declare_type(unproven_ANNOT, NULL);
- Annotations::declare_type(verb_problem_issued_ANNOT, NULL);
- Annotations::declare_type(you_can_ignore_ANNOT, NULL);
-
-
-
-
-
-void CoreModule::write_action_meaning_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_predicate_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_category_of_I6_translation_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_classified_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_clears_pronouns_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_colon_block_command_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_condition_tense_ANNOT(text_stream *OUT, parse_node *p) {
- if (Node::get_condition_tense(p)) {
- WRITE(" {condition tense: ");
- Occurrence::log(OUT, Node::get_condition_tense(p));
- WRITE("}");
- }
-}
-void CoreModule::write_constant_action_name_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_constant_action_pattern_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_constant_activity_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_constant_binary_predicate_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_constant_constant_phrase_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_constant_enumeration_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_constant_equation_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_constant_grammar_verb_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_constant_instance_ANNOT(text_stream *OUT, parse_node *p) {
- if (Node::get_constant_instance(p)) {
- WRITE(" {instance: ");
- Instances::write(OUT, Node::get_constant_instance(p));
- WRITE("}");
- }
-}
-void CoreModule::write_constant_local_variable_ANNOT(text_stream *OUT, parse_node *p) {
- local_variable *lvar = Node::get_constant_local_variable(p);
- if (lvar) {
- WRITE(" {local: ");
- LocalVariables::write(OUT, lvar);
- WRITE(" ");
- Kinds::Textual::write(OUT, LocalVariables::unproblematic_kind(lvar));
- WRITE("}");
- }
-}
-void CoreModule::write_constant_named_action_pattern_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_constant_named_rulebook_outcome_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_constant_nonlocal_variable_ANNOT(text_stream *OUT, parse_node *p) {
- nonlocal_variable *q = Node::get_constant_nonlocal_variable(p);
- if (q) {
- WRITE(" {nonlocal: ");
- NonlocalVariables::write(OUT, q);
- WRITE("}");
- }
-}
-void CoreModule::write_constant_number_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_constant_property_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_constant_rule_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_constant_rulebook_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_constant_scene_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_constant_table_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_constant_table_column_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_constant_text_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_constant_use_option_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_constant_verb_form_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_control_structure_used_ANNOT(text_stream *OUT, parse_node *p) {
- control_structure_phrase *csp = Node::get_control_structure_used(p);
- if (csp) {
- WRITE(" {"); ControlStructures::log(OUT, csp); WRITE("}");
- }
-}
-void CoreModule::write_converted_SN_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_creation_proposition_ANNOT(text_stream *OUT, parse_node *p) {
- if (Node::get_creation_proposition(p))
- WRITE(" {creation: $D}", Node::get_creation_proposition(p));
-}
-void CoreModule::write_creation_site_ANNOT(text_stream *OUT, parse_node *p) {
- if (Annotations::read_int(p, creation_site_ANNOT))
- WRITE(" {created here}");
-}
-void CoreModule::write_defn_language_ANNOT(text_stream *OUT, parse_node *p) {
- if (Node::get_defn_language(p))
- WRITE(" {language: %J}", Node::get_defn_language(p));
-}
-void CoreModule::write_end_control_structure_used_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_epistemological_status_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_evaluation_ANNOT(text_stream *OUT, parse_node *p) {
- if (Node::get_evaluation(p))
- WRITE(" {eval: $P}", Node::get_evaluation(p));
-}
-void CoreModule::write_explicit_iname_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_explicit_literal_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_explicit_vh_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_from_text_substitution_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_explicit_gender_marker_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_grammar_token_code_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_grammar_token_literal_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_grammar_token_relation_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_grammar_value_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_implicit_in_creation_of_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_implicitness_count_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_indentation_level_ANNOT(text_stream *OUT, parse_node *p) {
- if (Annotations::read_int(p, indentation_level_ANNOT) > 0)
- WRITE(" {indent: %d}", Annotations::read_int(p, indentation_level_ANNOT));
-}
-void CoreModule::write_interpretation_of_subject_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_is_phrase_option_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_kind_of_new_variable_ANNOT(text_stream *OUT, parse_node *p) {
- if (Node::get_kind_of_new_variable(p)) {
- WRITE(" {new var: ");
- Kinds::Textual::write(OUT, Node::get_kind_of_new_variable(p));
- WRITE("}");
- }
-}
-void CoreModule::write_kind_of_value_ANNOT(text_stream *OUT, parse_node *p) {
- if (Node::get_kind_of_value(p)) {
- WRITE(" {kind: ");
- Kinds::Textual::write(OUT, Node::get_kind_of_value(p));
- WRITE("}");
- }
-}
-void CoreModule::write_kind_required_by_context_ANNOT(text_stream *OUT, parse_node *p) {
- if (Node::get_kind_required_by_context(p)) {
- WRITE(" {required: ");
- Kinds::Textual::write(OUT, Node::get_kind_required_by_context(p));
- WRITE("}");
- }
-}
-void CoreModule::write_kind_resulting_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_kind_variable_declarations_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_rule_placement_sense_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_lpe_options_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_modal_verb_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_multiplicity_ANNOT(text_stream *OUT, parse_node *p) {
- if (Annotations::read_int(p, multiplicity_ANNOT))
- WRITE(" {multiplicity %d}", Annotations::read_int(p, multiplicity_ANNOT));
-}
-void CoreModule::write_new_relation_here_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_nothing_object_ANNOT(text_stream *OUT, parse_node *p) {
- if (Annotations::read_int(p, nothing_object_ANNOT)) LOG(" {nothing}");
-}
-void CoreModule::write_nowhere_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_phrase_invoked_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_phrase_option_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_phrase_options_invoked_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_property_name_used_as_noun_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_proposition_ANNOT(text_stream *OUT, parse_node *p) {
- if (Node::get_proposition(p)) {
- WRITE(" {proposition: ");
- Propositions::write(OUT, Node::get_proposition(p));
- WRITE("}");
- }
-}
-void CoreModule::write_quant_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_quantification_parameter_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_record_as_self_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_refined_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_response_code_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_results_from_splitting_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_row_amendable_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_save_self_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_say_adjective_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_say_verb_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_say_verb_negated_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_self_object_ANNOT(text_stream *OUT, parse_node *p) {
- if (Annotations::read_int(p, self_object_ANNOT)) LOG(" {self}");
-}
-void CoreModule::write_slash_class_ANNOT(text_stream *OUT, parse_node *p) {
- if (Annotations::read_int(p, slash_class_ANNOT) > 0)
- WRITE(" {slash: %d}", Annotations::read_int(p, slash_class_ANNOT));
-}
-void CoreModule::write_slash_dash_dash_ANNOT(text_stream *OUT, parse_node *p) {
- if (Annotations::read_int(p, slash_dash_dash_ANNOT) > 0)
- WRITE(" {slash-dash-dash: %d}", Annotations::read_int(p, slash_dash_dash_ANNOT));
-}
-void CoreModule::write_ssp_closing_segment_wn_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_ssp_segment_count_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_subject_ANNOT(text_stream *OUT, parse_node *p) {
- if (Node::get_subject(p))
- WRITE(" {refers: $j}", Node::get_subject(p));
-}
-void CoreModule::write_suppress_newlines_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_table_cell_unspecified_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_tense_marker_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_text_unescaped_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_token_as_parsed_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_token_check_to_do_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_token_to_be_parsed_against_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_turned_already_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_unit_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_unproven_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_verb_problem_issued_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
-void CoreModule::write_you_can_ignore_ANNOT(text_stream *OUT, parse_node *p) {
- WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
-}
+
+<relation-names> ::=
+ equality |
+ universal |
+ meaning |
+ provision |
+ numerically-greater-than-or-equal-to |
+ numerically-greater-than |
+ numerically-less-than-or-equal-to |
+ numerically-less-than |
+ adjacency |
+ regional-containment |
+ containment |
+ support |
+ incorporation |
+ carrying |
+ holding |
+ wearing |
+ possession |
+ visibility |
+ touchability |
+ concealment |
+ enclosure |
+ room-containment
+
diff --git a/docs/core-module/1-cp.html b/docs/core-module/1-cp.html
index 5b0c257f4..fb5eaa9ac 100644
--- a/docs/core-module/1-cp.html
+++ b/docs/core-module/1-cp.html
@@ -177,7 +177,7 @@ bit or the <k-kind> bit set, which as we see above is }
diff --git a/docs/core-module/1-cs.html b/docs/core-module/1-cs.html
index ac95a59c4..ca587a75f 100644
--- a/docs/core-module/1-cs.html
+++ b/docs/core-module/1-cs.html
@@ -244,7 +244,7 @@ the above settings can be changed.)
}
diff --git a/docs/core-module/1-htc.html b/docs/core-module/1-htc.html
index 5aefa1840..bc13eb798 100644
--- a/docs/core-module/1-htc.html
+++ b/docs/core-module/1-htc.html
@@ -196,8 +196,8 @@ will divide according to these units.
Task::advance_stage_to(SUBDIVIDING_CSEQ, I"Dividing source into compilation units", -1);
BENCH(CompilationSettings::initialise_gcs)
BENCH(Emit::begin);
- BENCH(Sentences::Headings::make_the_tree)
- BENCH(Sentences::Headings::write_as_xml)
+ BENCH(NameResolution::make_the_tree)
+ BENCH(IndexHeadings::write_as_xml)
BENCH(CompilationUnits::determine)
@@ -224,7 +224,7 @@ so on. Those absolute basics are made here.
Task::advance_stage_to(SEMANTIC_ANALYSIS_CSEQ, I"Pre-pass through major nodes", 1);
BENCH(MajorNodes::pre_pass)
- BENCH(ParseTreeUsage::verify)
+ BENCH(ParseTreeUsage::verify)
Task::advance_stage_to(ASSERTIONS_PASS_1_CSEQ, I"First pass through major nodes", 2);
BENCH(MajorNodes::pass_1)
BENCH(Tables::traverse_to_stock)
@@ -300,7 +300,7 @@ so on. Those absolute basics are made here.
BENCH(Activities::Activity_for_rulebooks_array)
BENCH(Activities::Activity_after_rulebooks_array)
BENCH(Activities::Activity_atb_rulebooks_array)
- BENCH(Relations::compile_defined_relation_constants)
+ BENCH(RTRelations::compile_defined_relation_constants)
BENCH(Kinds::RunTime::compile_data_type_support_routines)
BENCH(Kinds::RunTime::I7_Kind_Name_routine)
BENCH(World::Compile::compile)
@@ -326,7 +326,7 @@ so on. Those absolute basics are made here.
BENCH(PL::Files::arrays)
BENCH(Rulebooks::rulebook_var_creators)
BENCH(Activities::activity_var_creators)
- BENCH(Relations::IterateRelations)
+ BENCH(RTRelations::IterateRelations)
BENCH(Phrases::Manager::RulebookNames_array)
BENCH(Phrases::Manager::RulePrintingRule_routine)
BENCH_IF(parsing_plugin, PL::Parsing::Verbs::prepare)
@@ -335,7 +335,7 @@ so on. Those absolute basics are made here.
BENCH_IF(parsing_plugin, PL::Parsing::Tokens::Values::truth_state)
BENCH_IF(parsing_plugin, PL::Parsing::Tokens::Values::time)
BENCH_IF(parsing_plugin, PL::Parsing::Tokens::Values::compile_type_gprs)
- BENCH(VerbsAtRunTime::ConjugateVerb)
+ BENCH(RTVerbs::ConjugateVerb)
BENCH(Adjectives::Meanings::agreements)
if (debugging) {
@@ -353,7 +353,7 @@ so on. Those absolute basics are made here.
BENCH(Strings::compile_responses)
BENCH(Lists::check)
BENCH(Lists::compile)
- BENCH(Relations::compile_defined_relations)
+ BENCH(RTRelations::compile_defined_relations)
BENCH(Phrases::Manager::compile_as_needed)
BENCH(Strings::TextSubstitutions::allow_no_further_text_subs)
BENCH_IF(parsing_plugin, PL::Parsing::Tokens::Filters::compile)
@@ -392,7 +392,7 @@ so on. Those absolute basics are made here.
diff --git a/docs/core-module/1-inaa.html b/docs/core-module/1-inaa.html
new file mode 100644
index 000000000..4a386858f
--- /dev/null
+++ b/docs/core-module/1-inaa.html
@@ -0,0 +1,1155 @@
+
+
+
+ enum action_meaning_ANNOT action_pattern: meaning in parse tree when used as noun
+enum predicate_ANNOT unary_predicate: which adjective is asserted
+enum category_of_I6_translation_ANNOT int: what sort of "translates into I6" sentence this is
+enum classified_ANNOT int: this sentence has been classified
+enum clears_pronouns_ANNOT int: this sentence erases the current value of "it"
+enum colon_block_command_ANNOT int: this COMMAND uses the ":" not begin/end syntax
+enum condition_tense_ANNOT time_period: for specification nodes
+enum constant_action_name_ANNOT action_name: for constant values
+enum constant_action_pattern_ANNOT action_pattern: for constant values
+enum constant_activity_ANNOT activity: for constant values
+enum constant_binary_predicate_ANNOT binary_predicate: for constant values
+enum constant_constant_phrase_ANNOT constant_phrase: for constant values
+enum constant_enumeration_ANNOT int: which one from an enumerated kind
+enum constant_equation_ANNOT equation: for constant values
+enum constant_grammar_verb_ANNOT grammar_verb: for constant values
+enum constant_instance_ANNOT instance: for constant values
+enum constant_local_variable_ANNOT local_variable: for constant values
+enum constant_named_action_pattern_ANNOT named_action_pattern: for constant values
+enum constant_named_rulebook_outcome_ANNOT named_rulebook_outcome: for constant values
+enum constant_nonlocal_variable_ANNOT nonlocal_variable: for constant values
+enum constant_number_ANNOT int: which integer this is
+enum constant_property_ANNOT property: for constant values
+enum constant_rule_ANNOT rule: for constant values
+enum constant_rulebook_ANNOT rulebook: for constant values
+enum constant_scene_ANNOT scene: for constant values
+enum constant_table_ANNOT table: for constant values
+enum constant_table_column_ANNOT table_column: for constant values
+enum constant_text_ANNOT text_stream: for constant values
+enum constant_use_option_ANNOT use_option: for constant values
+enum constant_verb_form_ANNOT verb_form: for constant values
+enum control_structure_used_ANNOT control_structure_phrase: for CODE BLOCK nodes only
+enum converted_SN_ANNOT int: marking descriptions
+enum creation_proposition_ANNOT pcalc_prop: proposition which newly created value satisfies
+enum creation_site_ANNOT int: whether an instance was created from this node
+enum defn_language_ANNOT inform_language: what language this definition is in
+enum end_control_structure_used_ANNOT control_structure_phrase: for CODE BLOCK nodes only
+enum epistemological_status_ANNOT int: a bitmap of results from checking an ambiguous reading
+enum evaluation_ANNOT parse_node: result of evaluating the text
+enum explicit_iname_ANNOT inter_name: is this value explicitly an iname?
+enum explicit_literal_ANNOT int: my value is an explicit integer or text
+enum explicit_vh_ANNOT value_holster: used for compiling I6-level properties
+enum from_text_substitution_ANNOT int: whether this is an implicit say invocation
+enum explicit_gender_marker_ANNOT int: used by PROPER NOUN nodes for evident genders
+enum grammar_token_code_ANNOT int: used to identify grammar tokens
+enum grammar_token_literal_ANNOT int: for grammar tokens which are literal words
+enum grammar_token_relation_ANNOT binary_predicate: for relation tokens
+enum grammar_value_ANNOT parse_node: used as a marker when evaluating Understand grammar
+enum implicit_in_creation_of_ANNOT inference_subject: for assemblies
+enum implicitness_count_ANNOT int: keeping track of recursive assemblies
+enum indentation_level_ANNOT int: for routines written with Pythonesque indentation
+enum interpretation_of_subject_ANNOT inference_subject: subject, during passes
+enum is_phrase_option_ANNOT int: this unparsed text is a phrase option
+enum kind_of_new_variable_ANNOT kind: what if anything is returned
+enum kind_of_value_ANNOT kind: for specification nodes
+enum kind_required_by_context_ANNOT kind: what if anything is expected here
+enum kind_resulting_ANNOT kind: what if anything is returned
+enum kind_variable_declarations_ANNOT kind_variable_declaration: and of these
+enum rule_placement_sense_ANNOT int: are we listing a rule into something, or out of it?
+enum lpe_options_ANNOT int: options set for a literal pattern part
+enum modal_verb_ANNOT verb_conjugation: relevant only for that: e.g., "might"
+enum multiplicity_ANNOT int: e.g., 5 for "five gold rings"
+enum new_relation_here_ANNOT binary_predicate: new relation as subject of "relates" sentence
+enum nothing_object_ANNOT int: this represents nothing at run-time
+enum nowhere_ANNOT int: used by the spatial plugin to show this represents "nowhere"
+enum phrase_invoked_ANNOT phrase: the phrase believed to be invoked...
+enum phrase_option_ANNOT int: \(2^i\) where \(i\) is the option number, \(0\leq i<16\)
+enum phrase_options_invoked_ANNOT invocation_options: details of any options used
+enum property_name_used_as_noun_ANNOT int: in ambiguous cases such as "open"
+enum proposition_ANNOT pcalc_prop: for specification nodes
+enum quant_ANNOT quantifier: for quantified excerpts like "three baskets"
+enum quantification_parameter_ANNOT int: e.g., 3 for "three baskets"
+enum record_as_self_ANNOT int: record recipient as self when writing this
+enum refined_ANNOT int: this subtree has had its nouns parsed
+enum response_code_ANNOT int: for responses only
+enum results_from_splitting_ANNOT int: node in a routine's parse tree from comma block notation
+enum row_amendable_ANNOT int: a candidate row for a table amendment
+enum save_self_ANNOT int: this invocation must save and preserve self at run-time
+enum say_adjective_ANNOT adjective: ...or the adjective to be agreed with by "say"
+enum say_verb_ANNOT verb_conjugation: ...or the verb to be conjugated by "say"
+enum say_verb_negated_ANNOT relevant only for that
+enum self_object_ANNOT int: this represents self at run-time
+enum slash_class_ANNOT int: used when partitioning grammar tokens
+enum slash_dash_dash_ANNOT int: used when partitioning grammar tokens
+enum ssp_closing_segment_wn_ANNOT int: identifier for the last of these, or -1
+enum ssp_segment_count_ANNOT int: number of subsequent complex-say phrases in stream
+enum subject_ANNOT inference_subject: what this node describes
+enum suppress_newlines_ANNOT int: whether the next say term runs on
+enum table_cell_unspecified_ANNOT int: used to mark table entries as unset
+enum tense_marker_ANNOT grammatical_usage: for specification nodes
+enum text_unescaped_ANNOT int: flag used only for literal texts
+enum token_as_parsed_ANNOT parse_node: what if anything is returned
+enum token_check_to_do_ANNOT parse_node: what if anything is returned
+enum token_to_be_parsed_against_ANNOT parse_node: what if anything is returned
+enum turned_already_ANNOT int: aliasing like "player" to "yourself" performed already
+enum unit_ANNOT compilation_unit: set only for headings, routines and sentences
+enum unproven_ANNOT int: this invocation needs run-time typechecking
+enum verb_problem_issued_ANNOT int: has a problem message about the primary verb been issued already?
+enum you_can_ignore_ANNOT int: for assertions now drained of meaning
+
+
+DECLARE_ANNOTATION_FUNCTIONS(condition_tense, time_period)
+DECLARE_ANNOTATION_FUNCTIONS(constant_activity, activity)
+DECLARE_ANNOTATION_FUNCTIONS(constant_binary_predicate, binary_predicate)
+DECLARE_ANNOTATION_FUNCTIONS(constant_constant_phrase, constant_phrase)
+DECLARE_ANNOTATION_FUNCTIONS(constant_equation, equation)
+DECLARE_ANNOTATION_FUNCTIONS(constant_instance, instance)
+DECLARE_ANNOTATION_FUNCTIONS(constant_local_variable, local_variable)
+DECLARE_ANNOTATION_FUNCTIONS(constant_named_rulebook_outcome, named_rulebook_outcome)
+DECLARE_ANNOTATION_FUNCTIONS(constant_nonlocal_variable, nonlocal_variable)
+DECLARE_ANNOTATION_FUNCTIONS(constant_property, property)
+DECLARE_ANNOTATION_FUNCTIONS(constant_rule, rule)
+DECLARE_ANNOTATION_FUNCTIONS(constant_rulebook, rulebook)
+DECLARE_ANNOTATION_FUNCTIONS(constant_table_column, table_column)
+DECLARE_ANNOTATION_FUNCTIONS(constant_table, table)
+DECLARE_ANNOTATION_FUNCTIONS(constant_text, text_stream)
+DECLARE_ANNOTATION_FUNCTIONS(constant_use_option, use_option)
+DECLARE_ANNOTATION_FUNCTIONS(constant_verb_form, verb_form)
+DECLARE_ANNOTATION_FUNCTIONS(control_structure_used, control_structure_phrase)
+DECLARE_ANNOTATION_FUNCTIONS(creation_proposition, pcalc_prop)
+DECLARE_ANNOTATION_FUNCTIONS(defn_language, inform_language)
+DECLARE_ANNOTATION_FUNCTIONS(end_control_structure_used, control_structure_phrase)
+DECLARE_ANNOTATION_FUNCTIONS(evaluation, parse_node)
+DECLARE_ANNOTATION_FUNCTIONS(explicit_vh, value_holster)
+DECLARE_ANNOTATION_FUNCTIONS(grammar_token_relation, binary_predicate)
+DECLARE_ANNOTATION_FUNCTIONS(grammar_value, parse_node)
+DECLARE_ANNOTATION_FUNCTIONS(implicit_in_creation_of, inference_subject)
+DECLARE_ANNOTATION_FUNCTIONS(interpretation_of_subject, inference_subject)
+DECLARE_ANNOTATION_FUNCTIONS(kind_of_new_variable, kind)
+DECLARE_ANNOTATION_FUNCTIONS(kind_of_value, kind)
+DECLARE_ANNOTATION_FUNCTIONS(kind_required_by_context, kind)
+DECLARE_ANNOTATION_FUNCTIONS(kind_resulting, kind)
+DECLARE_ANNOTATION_FUNCTIONS(kind_variable_declarations, kind_variable_declaration)
+DECLARE_ANNOTATION_FUNCTIONS(explicit_iname, inter_name)
+DECLARE_ANNOTATION_FUNCTIONS(modal_verb, verb_conjugation)
+DECLARE_ANNOTATION_FUNCTIONS(new_relation_here, binary_predicate)
+DECLARE_ANNOTATION_FUNCTIONS(phrase_invoked, phrase)
+DECLARE_ANNOTATION_FUNCTIONS(phrase_options_invoked, invocation_options)
+DECLARE_ANNOTATION_FUNCTIONS(predicate, unary_predicate)
+DECLARE_ANNOTATION_FUNCTIONS(proposition, pcalc_prop)
+DECLARE_ANNOTATION_FUNCTIONS(quant, quantifier)
+DECLARE_ANNOTATION_FUNCTIONS(say_adjective, adjective)
+DECLARE_ANNOTATION_FUNCTIONS(say_verb, verb_conjugation)
+DECLARE_ANNOTATION_FUNCTIONS(subject, inference_subject)
+DECLARE_ANNOTATION_FUNCTIONS(tense_marker, grammatical_usage)
+DECLARE_ANNOTATION_FUNCTIONS(token_as_parsed, parse_node)
+DECLARE_ANNOTATION_FUNCTIONS(token_check_to_do, parse_node)
+DECLARE_ANNOTATION_FUNCTIONS(token_to_be_parsed_against, parse_node)
+DECLARE_ANNOTATION_FUNCTIONS(unit, compilation_unit)
+
+
+MAKE_ANNOTATION_FUNCTIONS(condition_tense, time_period)
+MAKE_ANNOTATION_FUNCTIONS(constant_activity, activity)
+MAKE_ANNOTATION_FUNCTIONS(constant_binary_predicate, binary_predicate)
+MAKE_ANNOTATION_FUNCTIONS(constant_constant_phrase, constant_phrase)
+MAKE_ANNOTATION_FUNCTIONS(constant_equation, equation)
+MAKE_ANNOTATION_FUNCTIONS(constant_instance, instance)
+MAKE_ANNOTATION_FUNCTIONS(constant_local_variable, local_variable)
+MAKE_ANNOTATION_FUNCTIONS(constant_named_rulebook_outcome, named_rulebook_outcome)
+MAKE_ANNOTATION_FUNCTIONS(constant_nonlocal_variable, nonlocal_variable)
+MAKE_ANNOTATION_FUNCTIONS(constant_property, property)
+MAKE_ANNOTATION_FUNCTIONS(constant_rule, rule)
+MAKE_ANNOTATION_FUNCTIONS(constant_rulebook, rulebook)
+MAKE_ANNOTATION_FUNCTIONS(constant_table_column, table_column)
+MAKE_ANNOTATION_FUNCTIONS(constant_table, table)
+MAKE_ANNOTATION_FUNCTIONS(constant_text, text_stream)
+MAKE_ANNOTATION_FUNCTIONS(constant_use_option, use_option)
+MAKE_ANNOTATION_FUNCTIONS(constant_verb_form, verb_form)
+MAKE_ANNOTATION_FUNCTIONS(control_structure_used, control_structure_phrase)
+MAKE_ANNOTATION_FUNCTIONS(creation_proposition, pcalc_prop)
+MAKE_ANNOTATION_FUNCTIONS(defn_language, inform_language)
+MAKE_ANNOTATION_FUNCTIONS(end_control_structure_used, control_structure_phrase)
+MAKE_ANNOTATION_FUNCTIONS(evaluation, parse_node)
+MAKE_ANNOTATION_FUNCTIONS(explicit_vh, value_holster)
+MAKE_ANNOTATION_FUNCTIONS(grammar_token_relation, binary_predicate)
+MAKE_ANNOTATION_FUNCTIONS(grammar_value, parse_node)
+MAKE_ANNOTATION_FUNCTIONS(implicit_in_creation_of, inference_subject)
+MAKE_ANNOTATION_FUNCTIONS(interpretation_of_subject, inference_subject)
+MAKE_ANNOTATION_FUNCTIONS(kind_of_new_variable, kind)
+MAKE_ANNOTATION_FUNCTIONS(kind_of_value, kind)
+MAKE_ANNOTATION_FUNCTIONS(kind_required_by_context, kind)
+MAKE_ANNOTATION_FUNCTIONS(kind_resulting, kind)
+MAKE_ANNOTATION_FUNCTIONS(kind_variable_declarations, kind_variable_declaration)
+MAKE_ANNOTATION_FUNCTIONS(modal_verb, verb_conjugation)
+MAKE_ANNOTATION_FUNCTIONS(new_relation_here, binary_predicate)
+MAKE_ANNOTATION_FUNCTIONS(phrase_invoked, phrase)
+MAKE_ANNOTATION_FUNCTIONS(phrase_options_invoked, invocation_options)
+MAKE_ANNOTATION_FUNCTIONS(predicate, unary_predicate)
+MAKE_ANNOTATION_FUNCTIONS(proposition, pcalc_prop)
+MAKE_ANNOTATION_FUNCTIONS(quant, quantifier)
+MAKE_ANNOTATION_FUNCTIONS(say_adjective, adjective)
+MAKE_ANNOTATION_FUNCTIONS(say_verb, verb_conjugation)
+MAKE_ANNOTATION_FUNCTIONS(subject, inference_subject)
+MAKE_ANNOTATION_FUNCTIONS(tense_marker, grammatical_usage)
+MAKE_ANNOTATION_FUNCTIONS(token_as_parsed, parse_node)
+MAKE_ANNOTATION_FUNCTIONS(token_check_to_do, parse_node)
+MAKE_ANNOTATION_FUNCTIONS(token_to_be_parsed_against, parse_node)
+
+
+void ParseTreeUsage::declare_annotations(void) {
+ Annotations::declare_type(action_meaning_ANNOT, NULL);
+ Annotations::declare_type(predicate_ANNOT, NULL);
+ Annotations::declare_type(category_of_I6_translation_ANNOT, NULL);
+ Annotations::declare_type(classified_ANNOT, NULL);
+ Annotations::declare_type(clears_pronouns_ANNOT, NULL);
+ Annotations::declare_type(colon_block_command_ANNOT, NULL);
+ Annotations::declare_type(condition_tense_ANNOT,
+ ParseTreeUsage::write_condition_tense_ANNOT);
+ Annotations::declare_type(constant_action_name_ANNOT, NULL);
+ Annotations::declare_type(constant_action_pattern_ANNOT, NULL);
+ Annotations::declare_type(constant_activity_ANNOT, NULL);
+ Annotations::declare_type(constant_binary_predicate_ANNOT, NULL);
+ Annotations::declare_type(constant_constant_phrase_ANNOT, NULL);
+ Annotations::declare_type(constant_enumeration_ANNOT, NULL);
+ Annotations::declare_type(constant_equation_ANNOT, NULL);
+ Annotations::declare_type(constant_grammar_verb_ANNOT, NULL);
+ Annotations::declare_type(constant_instance_ANNOT,
+ ParseTreeUsage::write_constant_instance_ANNOT);
+ Annotations::declare_type(constant_local_variable_ANNOT,
+ ParseTreeUsage::write_constant_local_variable_ANNOT);
+ Annotations::declare_type(constant_named_action_pattern_ANNOT, NULL);
+ Annotations::declare_type(constant_named_rulebook_outcome_ANNOT, NULL);
+ Annotations::declare_type(constant_nonlocal_variable_ANNOT,
+ ParseTreeUsage::write_constant_nonlocal_variable_ANNOT);
+ Annotations::declare_type(constant_number_ANNOT, NULL);
+ Annotations::declare_type(constant_property_ANNOT, NULL);
+ Annotations::declare_type(constant_rule_ANNOT, NULL);
+ Annotations::declare_type(constant_rulebook_ANNOT, NULL);
+ Annotations::declare_type(constant_scene_ANNOT, NULL);
+ Annotations::declare_type(constant_table_ANNOT, NULL);
+ Annotations::declare_type(constant_table_column_ANNOT, NULL);
+ Annotations::declare_type(constant_text_ANNOT, NULL);
+ Annotations::declare_type(constant_use_option_ANNOT, NULL);
+ Annotations::declare_type(constant_verb_form_ANNOT, NULL);
+ Annotations::declare_type(control_structure_used_ANNOT,
+ ParseTreeUsage::write_control_structure_used_ANNOT);
+ Annotations::declare_type(converted_SN_ANNOT, NULL);
+ Annotations::declare_type(creation_proposition_ANNOT,
+ ParseTreeUsage::write_creation_proposition_ANNOT);
+ Annotations::declare_type(creation_site_ANNOT,
+ ParseTreeUsage::write_creation_site_ANNOT);
+ Annotations::declare_type(defn_language_ANNOT,
+ ParseTreeUsage::write_defn_language_ANNOT);
+ Annotations::declare_type(end_control_structure_used_ANNOT, NULL);
+ Annotations::declare_type(epistemological_status_ANNOT, NULL);
+ Annotations::declare_type(evaluation_ANNOT,
+ ParseTreeUsage::write_evaluation_ANNOT);
+ Annotations::declare_type(explicit_iname_ANNOT, NULL);
+ Annotations::declare_type(explicit_literal_ANNOT, NULL);
+ Annotations::declare_type(explicit_vh_ANNOT, NULL);
+ Annotations::declare_type(from_text_substitution_ANNOT, NULL);
+ Annotations::declare_type(explicit_gender_marker_ANNOT, NULL);
+ Annotations::declare_type(grammar_token_code_ANNOT, NULL);
+ Annotations::declare_type(grammar_token_literal_ANNOT, NULL);
+ Annotations::declare_type(grammar_token_relation_ANNOT, NULL);
+ Annotations::declare_type(grammar_value_ANNOT, NULL);
+ Annotations::declare_type(implicit_in_creation_of_ANNOT, NULL);
+ Annotations::declare_type(implicitness_count_ANNOT, NULL);
+ Annotations::declare_type(indentation_level_ANNOT,
+ ParseTreeUsage::write_indentation_level_ANNOT);
+ Annotations::declare_type(interpretation_of_subject_ANNOT, NULL);
+ Annotations::declare_type(is_phrase_option_ANNOT, NULL);
+ Annotations::declare_type(kind_of_new_variable_ANNOT,
+ ParseTreeUsage::write_kind_of_new_variable_ANNOT);
+ Annotations::declare_type(kind_of_value_ANNOT,
+ ParseTreeUsage::write_kind_of_value_ANNOT);
+ Annotations::declare_type(kind_required_by_context_ANNOT,
+ ParseTreeUsage::write_kind_required_by_context_ANNOT);
+ Annotations::declare_type(kind_resulting_ANNOT, NULL);
+ Annotations::declare_type(kind_variable_declarations_ANNOT, NULL);
+ Annotations::declare_type(rule_placement_sense_ANNOT, NULL);
+ Annotations::declare_type(lpe_options_ANNOT, NULL);
+ Annotations::declare_type(modal_verb_ANNOT, NULL);
+ Annotations::declare_type(multiplicity_ANNOT,
+ ParseTreeUsage::write_multiplicity_ANNOT);
+ Annotations::declare_type(new_relation_here_ANNOT, NULL);
+ Annotations::declare_type(nothing_object_ANNOT,
+ ParseTreeUsage::write_nothing_object_ANNOT);
+ Annotations::declare_type(nowhere_ANNOT, NULL);
+ Annotations::declare_type(phrase_invoked_ANNOT, NULL);
+ Annotations::declare_type(phrase_option_ANNOT, NULL);
+ Annotations::declare_type(phrase_options_invoked_ANNOT, NULL);
+ Annotations::declare_type(property_name_used_as_noun_ANNOT, NULL);
+ Annotations::declare_type(proposition_ANNOT,
+ ParseTreeUsage::write_proposition_ANNOT);
+ Annotations::declare_type(quant_ANNOT, NULL);
+ Annotations::declare_type(quantification_parameter_ANNOT, NULL);
+ Annotations::declare_type(record_as_self_ANNOT, NULL);
+ Annotations::declare_type(refined_ANNOT, NULL);
+ Annotations::declare_type(response_code_ANNOT, NULL);
+ Annotations::declare_type(results_from_splitting_ANNOT, NULL);
+ Annotations::declare_type(row_amendable_ANNOT, NULL);
+ Annotations::declare_type(save_self_ANNOT, NULL);
+ Annotations::declare_type(say_adjective_ANNOT, NULL);
+ Annotations::declare_type(say_verb_ANNOT, NULL);
+ Annotations::declare_type(say_verb_negated_ANNOT, NULL);
+ Annotations::declare_type(self_object_ANNOT,
+ ParseTreeUsage::write_self_object_ANNOT);
+ Annotations::declare_type(slash_class_ANNOT,
+ ParseTreeUsage::write_slash_class_ANNOT);
+ Annotations::declare_type(slash_dash_dash_ANNOT,
+ ParseTreeUsage::write_slash_dash_dash_ANNOT);
+ Annotations::declare_type(ssp_closing_segment_wn_ANNOT, NULL);
+ Annotations::declare_type(ssp_segment_count_ANNOT, NULL);
+ Annotations::declare_type(subject_ANNOT, NULL);
+ Annotations::declare_type(suppress_newlines_ANNOT, NULL);
+ Annotations::declare_type(table_cell_unspecified_ANNOT, NULL);
+ Annotations::declare_type(tense_marker_ANNOT, NULL);
+ Annotations::declare_type(text_unescaped_ANNOT, NULL);
+ Annotations::declare_type(token_as_parsed_ANNOT, NULL);
+ Annotations::declare_type(token_check_to_do_ANNOT, NULL);
+ Annotations::declare_type(token_to_be_parsed_against_ANNOT, NULL);
+ Annotations::declare_type(turned_already_ANNOT, NULL);
+ Annotations::declare_type(unit_ANNOT, NULL);
+ Annotations::declare_type(unproven_ANNOT, NULL);
+ Annotations::declare_type(verb_problem_issued_ANNOT, NULL);
+ Annotations::declare_type(you_can_ignore_ANNOT, NULL);
+}
+
+
+
+
+void ParseTreeUsage::write_action_meaning_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_predicate_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_category_of_I6_translation_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_classified_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_clears_pronouns_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_colon_block_command_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_condition_tense_ANNOT(text_stream *OUT, parse_node *p) {
+ if (Node::get_condition_tense(p)) {
+ WRITE(" {condition tense: ");
+ Occurrence::log(OUT, Node::get_condition_tense(p));
+ WRITE("}");
+ }
+}
+void ParseTreeUsage::write_constant_action_name_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_constant_action_pattern_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_constant_activity_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_constant_binary_predicate_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_constant_constant_phrase_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_constant_enumeration_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_constant_equation_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_constant_grammar_verb_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_constant_instance_ANNOT(text_stream *OUT, parse_node *p) {
+ if (Node::get_constant_instance(p)) {
+ WRITE(" {instance: ");
+ Instances::write(OUT, Node::get_constant_instance(p));
+ WRITE("}");
+ }
+}
+void ParseTreeUsage::write_constant_local_variable_ANNOT(text_stream *OUT, parse_node *p) {
+ local_variable *lvar = Node::get_constant_local_variable(p);
+ if (lvar) {
+ WRITE(" {local: ");
+ LocalVariables::write(OUT, lvar);
+ WRITE(" ");
+ Kinds::Textual::write(OUT, LocalVariables::unproblematic_kind(lvar));
+ WRITE("}");
+ }
+}
+void ParseTreeUsage::write_constant_named_action_pattern_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_constant_named_rulebook_outcome_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_constant_nonlocal_variable_ANNOT(text_stream *OUT, parse_node *p) {
+ nonlocal_variable *q = Node::get_constant_nonlocal_variable(p);
+ if (q) {
+ WRITE(" {nonlocal: ");
+ NonlocalVariables::write(OUT, q);
+ WRITE("}");
+ }
+}
+void ParseTreeUsage::write_constant_number_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_constant_property_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_constant_rule_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_constant_rulebook_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_constant_scene_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_constant_table_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_constant_table_column_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_constant_text_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_constant_use_option_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_constant_verb_form_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_control_structure_used_ANNOT(text_stream *OUT, parse_node *p) {
+ control_structure_phrase *csp = Node::get_control_structure_used(p);
+ if (csp) {
+ WRITE(" {"); ControlStructures::log(OUT, csp); WRITE("}");
+ }
+}
+void ParseTreeUsage::write_converted_SN_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_creation_proposition_ANNOT(text_stream *OUT, parse_node *p) {
+ if (Node::get_creation_proposition(p))
+ WRITE(" {creation: $D}", Node::get_creation_proposition(p));
+}
+void ParseTreeUsage::write_creation_site_ANNOT(text_stream *OUT, parse_node *p) {
+ if (Annotations::read_int(p, creation_site_ANNOT))
+ WRITE(" {created here}");
+}
+void ParseTreeUsage::write_defn_language_ANNOT(text_stream *OUT, parse_node *p) {
+ if (Node::get_defn_language(p))
+ WRITE(" {language: %J}", Node::get_defn_language(p));
+}
+void ParseTreeUsage::write_end_control_structure_used_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_epistemological_status_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_evaluation_ANNOT(text_stream *OUT, parse_node *p) {
+ if (Node::get_evaluation(p))
+ WRITE(" {eval: $P}", Node::get_evaluation(p));
+}
+void ParseTreeUsage::write_explicit_iname_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_explicit_literal_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_explicit_vh_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_from_text_substitution_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_explicit_gender_marker_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_grammar_token_code_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_grammar_token_literal_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_grammar_token_relation_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_grammar_value_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_implicit_in_creation_of_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_implicitness_count_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_indentation_level_ANNOT(text_stream *OUT, parse_node *p) {
+ if (Annotations::read_int(p, indentation_level_ANNOT) > 0)
+ WRITE(" {indent: %d}", Annotations::read_int(p, indentation_level_ANNOT));
+}
+void ParseTreeUsage::write_interpretation_of_subject_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_is_phrase_option_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_kind_of_new_variable_ANNOT(text_stream *OUT, parse_node *p) {
+ if (Node::get_kind_of_new_variable(p)) {
+ WRITE(" {new var: ");
+ Kinds::Textual::write(OUT, Node::get_kind_of_new_variable(p));
+ WRITE("}");
+ }
+}
+void ParseTreeUsage::write_kind_of_value_ANNOT(text_stream *OUT, parse_node *p) {
+ if (Node::get_kind_of_value(p)) {
+ WRITE(" {kind: ");
+ Kinds::Textual::write(OUT, Node::get_kind_of_value(p));
+ WRITE("}");
+ }
+}
+void ParseTreeUsage::write_kind_required_by_context_ANNOT(text_stream *OUT, parse_node *p) {
+ if (Node::get_kind_required_by_context(p)) {
+ WRITE(" {required: ");
+ Kinds::Textual::write(OUT, Node::get_kind_required_by_context(p));
+ WRITE("}");
+ }
+}
+void ParseTreeUsage::write_kind_resulting_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_kind_variable_declarations_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_rule_placement_sense_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_lpe_options_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_modal_verb_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_multiplicity_ANNOT(text_stream *OUT, parse_node *p) {
+ if (Annotations::read_int(p, multiplicity_ANNOT))
+ WRITE(" {multiplicity %d}", Annotations::read_int(p, multiplicity_ANNOT));
+}
+void ParseTreeUsage::write_new_relation_here_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_nothing_object_ANNOT(text_stream *OUT, parse_node *p) {
+ if (Annotations::read_int(p, nothing_object_ANNOT)) LOG(" {nothing}");
+}
+void ParseTreeUsage::write_nowhere_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_phrase_invoked_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_phrase_option_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_phrase_options_invoked_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_property_name_used_as_noun_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_proposition_ANNOT(text_stream *OUT, parse_node *p) {
+ if (Node::get_proposition(p)) {
+ WRITE(" {proposition: ");
+ Propositions::write(OUT, Node::get_proposition(p));
+ WRITE("}");
+ }
+}
+void ParseTreeUsage::write_quant_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_quantification_parameter_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_record_as_self_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_refined_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_response_code_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_results_from_splitting_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_row_amendable_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_save_self_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_say_adjective_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_say_verb_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_say_verb_negated_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_self_object_ANNOT(text_stream *OUT, parse_node *p) {
+ if (Annotations::read_int(p, self_object_ANNOT)) LOG(" {self}");
+}
+void ParseTreeUsage::write_slash_class_ANNOT(text_stream *OUT, parse_node *p) {
+ if (Annotations::read_int(p, slash_class_ANNOT) > 0)
+ WRITE(" {slash: %d}", Annotations::read_int(p, slash_class_ANNOT));
+}
+void ParseTreeUsage::write_slash_dash_dash_ANNOT(text_stream *OUT, parse_node *p) {
+ if (Annotations::read_int(p, slash_dash_dash_ANNOT) > 0)
+ WRITE(" {slash-dash-dash: %d}", Annotations::read_int(p, slash_dash_dash_ANNOT));
+}
+void ParseTreeUsage::write_ssp_closing_segment_wn_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_ssp_segment_count_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_subject_ANNOT(text_stream *OUT, parse_node *p) {
+ if (Node::get_subject(p))
+ WRITE(" {refers: $j}", Node::get_subject(p));
+}
+void ParseTreeUsage::write_suppress_newlines_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_table_cell_unspecified_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_tense_marker_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_text_unescaped_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_token_as_parsed_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_token_check_to_do_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_token_to_be_parsed_against_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_turned_already_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_unit_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_unproven_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_verb_problem_issued_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+void ParseTreeUsage::write_you_can_ignore_ANNOT(text_stream *OUT, parse_node *p) {
+ WRITE("{}", Annotations::read_int(p, heading_level_ANNOT));
+}
+
+
+
+define ANNOTATION_COPY_SYNTAX_CALLBACK ParseTreeUsage::copy_annotations
+
+
+void ParseTreeUsage::copy_annotations(parse_node_annotation *to, parse_node_annotation *from) {
+ if (from->annotation_id == proposition_ANNOT)
+ to->annotation_pointer =
+ STORE_POINTER_pcalc_prop(
+ Propositions::copy(
+ RETRIEVE_POINTER_pcalc_prop(
+ from->annotation_pointer)));
+}
+
+
+
+enum ALLOWED_NT "An animal is allowed to have a description"
+enum EVERY_NT "every container"
+enum ACTION_NT "taking something closed"
+enum ADJECTIVE_NT "open"
+enum PROPERTYCALLED_NT "A man has a number called age"
+enum CREATED_NT "a vehicle called Sarah Jane's car"
+enum TOKEN_NT Used for tokens in grammar
+enum CODE_BLOCK_NT Holds a block of source material
+enum INVOCATION_LIST_SAY_NT Single thing to be said
+enum INVOCATION_NT Usage of a phrase
+enum VOID_CONTEXT_NT When a void phrase is required
+enum RVALUE_CONTEXT_NT Arguments, in effect
+enum LVALUE_CONTEXT_NT Named storage location
+enum LVALUE_TR_CONTEXT_NT Table reference
+enum SPECIFIC_RVALUE_CONTEXT_NT Argument must be an exact value
+enum MATCHING_RVALUE_CONTEXT_NT Argument must match a description
+enum NEW_LOCAL_CONTEXT_NT Argument which creates a local
+enum LVALUE_LOCAL_CONTEXT_NT Argument which names a local
+enum CONDITION_CONTEXT_NT Used for "now" conditions
+
+enum CONSTANT_NT "7", "the can't lock a locked door rule", etc.
+enum PHRASE_TO_DECIDE_VALUE_NT "holder of the black box"
+
+enum LOCAL_VARIABLE_NT "the running total", say
+enum NONLOCAL_VARIABLE_NT "the location"
+enum PROPERTY_VALUE_NT "the carrying capacity of the cedarwood box"
+enum TABLE_ENTRY_NT "tonnage in row X of the Table of Corvettes"
+enum LIST_ENTRY_NT "item 4 in L"
+
+enum LOGICAL_NOT_NT "not A"
+enum LOGICAL_TENSE_NT in the past, A
+enum LOGICAL_AND_NT "A and B"
+enum LOGICAL_OR_NT "A or B"
+enum TEST_PROPOSITION_NT if "the cat is on the mat"
+enum TEST_PHRASE_OPTION_NT "giving full details", say
+enum TEST_VALUE_NT when a value is used as a condition
+
+
+
+enum LVALUE_NCAT
+enum RVALUE_NCAT
+enum COND_NCAT
+
+
+
+define MORE_NODE_METADATA_SETUP_SYNTAX_CALLBACK ParseTreeUsage::md
+
+
+void ParseTreeUsage::md(void) {
+ first, the structural nodes:
+ NodeType::new(ALLOWED_NT, I"ALLOWED_NT", 1, 1, L3_NCAT, ASSERT_NFLAG);
+ NodeType::new(EVERY_NT, I"EVERY_NT", 0, INFTY, L3_NCAT, ASSERT_NFLAG);
+ NodeType::new(ACTION_NT, I"ACTION_NT", 0, INFTY, L3_NCAT, ASSERT_NFLAG);
+ NodeType::new(ADJECTIVE_NT, I"ADJECTIVE_NT", 0, INFTY, L3_NCAT, ASSERT_NFLAG);
+ NodeType::new(PROPERTYCALLED_NT, I"PROPERTYCALLED_NT", 2, 2, L3_NCAT, 0);
+ NodeType::new(TOKEN_NT, I"TOKEN_NT", 0, INFTY, L3_NCAT, 0);
+ NodeType::new(CREATED_NT, I"CREATED_NT", 0, 0, L3_NCAT, ASSERT_NFLAG);
+
+ NodeType::new(CODE_BLOCK_NT, I"CODE_BLOCK_NT", 0, INFTY, L4_NCAT, 0);
+ NodeType::new(INVOCATION_LIST_NT, I"INVOCATION_LIST_NT", 0, INFTY, L4_NCAT, 0);
+ NodeType::new(INVOCATION_LIST_SAY_NT, I"INVOCATION_LIST_SAY_NT", 0, INFTY, L4_NCAT, 0);
+ NodeType::new(INVOCATION_NT, I"INVOCATION_NT", 0, INFTY, L4_NCAT, 0);
+ NodeType::new(VOID_CONTEXT_NT, I"VOID_CONTEXT_NT", 0, INFTY, L4_NCAT, 0);
+ NodeType::new(RVALUE_CONTEXT_NT, I"RVALUE_CONTEXT_NT", 0, INFTY, L4_NCAT, 0);
+ NodeType::new(LVALUE_CONTEXT_NT, I"LVALUE_CONTEXT_NT", 0, INFTY, L4_NCAT, 0);
+ NodeType::new(LVALUE_TR_CONTEXT_NT, I"LVALUE_TR_CONTEXT_NT", 0, INFTY, L4_NCAT, 0);
+ NodeType::new(SPECIFIC_RVALUE_CONTEXT_NT, I"SPECIFIC_RVALUE_CONTEXT_NT", 0, INFTY, L4_NCAT, 0);
+ NodeType::new(MATCHING_RVALUE_CONTEXT_NT, I"MATCHING_RVALUE_CONTEXT_NT", 0, INFTY, L4_NCAT, 0);
+ NodeType::new(NEW_LOCAL_CONTEXT_NT, I"NEW_LOCAL_CONTEXT_NT", 0, INFTY, L4_NCAT, 0);
+ NodeType::new(LVALUE_LOCAL_CONTEXT_NT, I"LVALUE_LOCAL_CONTEXT_NT", 0, INFTY, L4_NCAT, 0);
+ NodeType::new(CONDITION_CONTEXT_NT, I"CONDITION_CONTEXT_NT", 0, INFTY, L4_NCAT, 0);
+
+ now the specification nodes:
+ NodeType::new(CONSTANT_NT, I"CONSTANT_NT", 0, 0, RVALUE_NCAT, 0);
+ NodeType::new(PHRASE_TO_DECIDE_VALUE_NT, I"PHRASE_TO_DECIDE_VALUE_NT", 1, 1, RVALUE_NCAT, PHRASAL_NFLAG);
+
+ NodeType::new(LOCAL_VARIABLE_NT, I"LOCAL_VARIABLE_NT", 0, 0, LVALUE_NCAT, 0);
+ NodeType::new(NONLOCAL_VARIABLE_NT, I"NONLOCAL_VARIABLE_NT", 0, 0, LVALUE_NCAT, 0);
+ NodeType::new(PROPERTY_VALUE_NT, I"PROPERTY_VALUE_NT", 2, 2, LVALUE_NCAT, 0);
+ NodeType::new(TABLE_ENTRY_NT, I"TABLE_ENTRY_NT", 1, 4, LVALUE_NCAT, 0);
+ NodeType::new(LIST_ENTRY_NT, I"LIST_ENTRY_NT", 2, 2, LVALUE_NCAT, 0);
+
+ NodeType::new(LOGICAL_NOT_NT, I"LOGICAL_NOT_NT", 1, 1, COND_NCAT, 0);
+ NodeType::new(LOGICAL_TENSE_NT, I"LOGICAL_TENSE_NT", 1, 1, COND_NCAT, 0);
+ NodeType::new(LOGICAL_AND_NT, I"LOGICAL_AND_NT", 2, 2, COND_NCAT, 0);
+ NodeType::new(LOGICAL_OR_NT, I"LOGICAL_OR_NT", 2, 2, COND_NCAT, 0);
+ NodeType::new(TEST_PROPOSITION_NT, I"TEST_PROPOSITION_NT", 0, 0, COND_NCAT, 0);
+ NodeType::new(TEST_PHRASE_OPTION_NT, I"TEST_PHRASE_OPTION_NT", 0, 0, COND_NCAT, 0);
+ NodeType::new(TEST_VALUE_NT, I"TEST_VALUE_NT", 1, 1, COND_NCAT, 0);
+}
+
+
+
+define PARENTAGE_PERMISSIONS_SYNTAX_CALLBACK ParseTreeUsage::write_parentage_permissions
+
+
+void ParseTreeUsage::write_parentage_permissions(void) {
+ NodeType::allow_parentage_for_categories(L2_NCAT, L3_NCAT);
+ NodeType::allow_parentage_for_categories(L3_NCAT, L3_NCAT);
+ NodeType::allow_parentage_for_categories(L2_NCAT, L4_NCAT);
+ NodeType::allow_parentage_for_categories(L4_NCAT, L4_NCAT);
+ NodeType::allow_parentage_for_categories(L4_NCAT, UNKNOWN_NCAT);
+
+ NodeType::allow_parentage_for_categories(L4_NCAT, LVALUE_NCAT);
+ NodeType::allow_parentage_for_categories(L4_NCAT, RVALUE_NCAT);
+ NodeType::allow_parentage_for_categories(L4_NCAT, COND_NCAT);
+
+ NodeType::allow_parentage_for_categories(LVALUE_NCAT, UNKNOWN_NCAT);
+ NodeType::allow_parentage_for_categories(RVALUE_NCAT, UNKNOWN_NCAT);
+ NodeType::allow_parentage_for_categories(COND_NCAT, UNKNOWN_NCAT);
+ NodeType::allow_parentage_for_categories(LVALUE_NCAT, LVALUE_NCAT);
+ NodeType::allow_parentage_for_categories(RVALUE_NCAT, LVALUE_NCAT);
+ NodeType::allow_parentage_for_categories(COND_NCAT, LVALUE_NCAT);
+ NodeType::allow_parentage_for_categories(LVALUE_NCAT, RVALUE_NCAT);
+ NodeType::allow_parentage_for_categories(RVALUE_NCAT, RVALUE_NCAT);
+ NodeType::allow_parentage_for_categories(COND_NCAT, RVALUE_NCAT);
+ NodeType::allow_parentage_for_categories(LVALUE_NCAT, COND_NCAT);
+ NodeType::allow_parentage_for_categories(RVALUE_NCAT, COND_NCAT);
+ NodeType::allow_parentage_for_categories(COND_NCAT, COND_NCAT);
+}
+
+
+
+define ANNOTATION_PERMISSIONS_SYNTAX_CALLBACK ParseTreeUsage::write_permissions
+
+
+void ParseTreeUsage::write_permissions(void) {
+ Annotations::allow_for_category(L1_NCAT, clears_pronouns_ANNOT);
+ Annotations::allow(HEADING_NT, embodying_heading_ANNOT);
+ Annotations::allow(HEADING_NT, inclusion_of_extension_ANNOT);
+ Annotations::allow(HEADING_NT, interpretation_of_subject_ANNOT);
+ Annotations::allow(HEADING_NT, suppress_heading_dependencies_ANNOT);
+ Annotations::allow(HEADING_NT, implied_heading_ANNOT);
+ Annotations::allow_for_category(L1_NCAT, unit_ANNOT);
+
+ Annotations::allow_for_category(L2_NCAT, clears_pronouns_ANNOT);
+ Annotations::allow_for_category(L2_NCAT, interpretation_of_subject_ANNOT);
+ Annotations::allow_for_category(L2_NCAT, verb_problem_issued_ANNOT);
+ Annotations::allow(RULE_NT, indentation_level_ANNOT);
+ Annotations::allow(SENTENCE_NT, implicit_in_creation_of_ANNOT);
+ Annotations::allow(SENTENCE_NT, implicitness_count_ANNOT);
+ Annotations::allow(SENTENCE_NT, you_can_ignore_ANNOT);
+ Annotations::allow(SENTENCE_NT, classified_ANNOT);
+ Annotations::allow_for_category(L2_NCAT, unit_ANNOT);
+ LOOP_OVER_ENUMERATED_NTS(t)
+ if (NodeType::has_flag(t, ASSERT_NFLAG))
+ Annotations::allow(t, refined_ANNOT);
+
+ Annotations::allow_for_category(L3_NCAT, unit_ANNOT);
+ Annotations::allow_for_category(L3_NCAT, creation_proposition_ANNOT);
+ Annotations::allow_for_category(L3_NCAT, evaluation_ANNOT);
+ Annotations::allow_for_category(L3_NCAT, subject_ANNOT);
+ Annotations::allow_for_category(L3_NCAT, explicit_gender_marker_ANNOT);
+ Annotations::allow(ACTION_NT, action_meaning_ANNOT);
+ Annotations::allow(ADJECTIVE_NT, predicate_ANNOT);
+ Annotations::allow(VERB_NT, category_of_I6_translation_ANNOT);
+ Annotations::allow(VERB_NT, rule_placement_sense_ANNOT);
+ Annotations::allow(COMMON_NOUN_NT, action_meaning_ANNOT);
+ Annotations::allow(COMMON_NOUN_NT, creation_site_ANNOT);
+ Annotations::allow(COMMON_NOUN_NT, multiplicity_ANNOT);
+ Annotations::allow(COMMON_NOUN_NT, quant_ANNOT);
+ Annotations::allow(COMMON_NOUN_NT, quantification_parameter_ANNOT);
+ Annotations::allow(PROPER_NOUN_NT, predicate_ANNOT);
+ Annotations::allow(PROPER_NOUN_NT, creation_site_ANNOT);
+ Annotations::allow(UNPARSED_NOUN_NT, defn_language_ANNOT);
+ Annotations::allow(PROPER_NOUN_NT, defn_language_ANNOT);
+ Annotations::allow(PROPER_NOUN_NT, lpe_options_ANNOT);
+ Annotations::allow(PROPER_NOUN_NT, multiplicity_ANNOT);
+ Annotations::allow(UNPARSED_NOUN_NT, new_relation_here_ANNOT);
+ Annotations::allow(PROPER_NOUN_NT, new_relation_here_ANNOT);
+ Annotations::allow(PROPER_NOUN_NT, nowhere_ANNOT);
+ Annotations::allow(PROPER_NOUN_NT, quant_ANNOT);
+ Annotations::allow(PROPER_NOUN_NT, quantification_parameter_ANNOT);
+ Annotations::allow(PROPER_NOUN_NT, row_amendable_ANNOT);
+ Annotations::allow(PROPER_NOUN_NT, slash_dash_dash_ANNOT);
+ Annotations::allow(PROPER_NOUN_NT, table_cell_unspecified_ANNOT);
+ Annotations::allow(PROPER_NOUN_NT, turned_already_ANNOT);
+ Annotations::allow(TOKEN_NT, grammar_token_literal_ANNOT);
+ Annotations::allow(TOKEN_NT, grammar_token_relation_ANNOT);
+ Annotations::allow(TOKEN_NT, grammar_value_ANNOT);
+ Annotations::allow(TOKEN_NT, slash_class_ANNOT);
+
+ Annotations::allow_for_category(L4_NCAT, colon_block_command_ANNOT);
+ Annotations::allow_for_category(L4_NCAT, control_structure_used_ANNOT);
+ Annotations::allow_for_category(L4_NCAT, end_control_structure_used_ANNOT);
+ Annotations::allow_for_category(L4_NCAT, evaluation_ANNOT);
+ Annotations::allow_for_category(L4_NCAT, indentation_level_ANNOT);
+ Annotations::allow_for_category(L4_NCAT, kind_of_new_variable_ANNOT);
+ Annotations::allow_for_category(L4_NCAT, kind_required_by_context_ANNOT);
+ Annotations::allow_for_category(L4_NCAT, results_from_splitting_ANNOT);
+ Annotations::allow_for_category(L4_NCAT, token_as_parsed_ANNOT);
+ Annotations::allow_for_category(L4_NCAT, token_check_to_do_ANNOT);
+ Annotations::allow_for_category(L4_NCAT, token_to_be_parsed_against_ANNOT);
+ Annotations::allow_for_category(L4_NCAT, verb_problem_issued_ANNOT);
+ Annotations::allow_for_category(L4_NCAT, problem_falls_under_ANNOT);
+ Annotations::allow_for_category(L4_NCAT, unit_ANNOT);
+ Annotations::allow(INVOCATION_LIST_NT, from_text_substitution_ANNOT);
+ Annotations::allow(INVOCATION_LIST_SAY_NT, suppress_newlines_ANNOT);
+ Annotations::allow(INVOCATION_NT, epistemological_status_ANNOT);
+ Annotations::allow(INVOCATION_NT, kind_resulting_ANNOT);
+ Annotations::allow(INVOCATION_NT, kind_variable_declarations_ANNOT);
+ Annotations::allow(INVOCATION_NT, modal_verb_ANNOT);
+ Annotations::allow(INVOCATION_NT, phrase_invoked_ANNOT);
+ Annotations::allow(INVOCATION_NT, phrase_options_invoked_ANNOT);
+ Annotations::allow(INVOCATION_NT, say_adjective_ANNOT);
+ Annotations::allow(INVOCATION_NT, say_verb_ANNOT);
+ Annotations::allow(INVOCATION_NT, say_verb_negated_ANNOT);
+ Annotations::allow(INVOCATION_NT, ssp_closing_segment_wn_ANNOT);
+ Annotations::allow(INVOCATION_NT, ssp_segment_count_ANNOT);
+ Annotations::allow(INVOCATION_NT, suppress_newlines_ANNOT);
+ Annotations::allow(INVOCATION_NT, save_self_ANNOT);
+ Annotations::allow(INVOCATION_NT, unproven_ANNOT);
+
+ ParseTreeUsage::allow_annotation_to_specification(meaning_ANNOT);
+ ParseTreeUsage::allow_annotation_to_specification(converted_SN_ANNOT);
+ ParseTreeUsage::allow_annotation_to_specification(subject_term_ANNOT);
+ ParseTreeUsage::allow_annotation_to_specification(epistemological_status_ANNOT);
+ Annotations::allow(CONSTANT_NT, constant_action_name_ANNOT);
+ Annotations::allow(CONSTANT_NT, constant_action_pattern_ANNOT);
+ Annotations::allow(CONSTANT_NT, constant_activity_ANNOT);
+ Annotations::allow(CONSTANT_NT, constant_binary_predicate_ANNOT);
+ Annotations::allow(CONSTANT_NT, constant_constant_phrase_ANNOT);
+ Annotations::allow(CONSTANT_NT, constant_enumeration_ANNOT);
+ Annotations::allow(CONSTANT_NT, constant_equation_ANNOT);
+ Annotations::allow(CONSTANT_NT, constant_grammar_verb_ANNOT);
+ Annotations::allow(CONSTANT_NT, constant_instance_ANNOT);
+ Annotations::allow(CONSTANT_NT, constant_named_action_pattern_ANNOT);
+ Annotations::allow(CONSTANT_NT, constant_named_rulebook_outcome_ANNOT);
+ Annotations::allow(CONSTANT_NT, constant_number_ANNOT);
+ Annotations::allow(CONSTANT_NT, constant_property_ANNOT);
+ Annotations::allow(CONSTANT_NT, constant_rule_ANNOT);
+ Annotations::allow(CONSTANT_NT, constant_rulebook_ANNOT);
+ Annotations::allow(CONSTANT_NT, constant_scene_ANNOT);
+ Annotations::allow(CONSTANT_NT, constant_table_ANNOT);
+ Annotations::allow(CONSTANT_NT, constant_table_column_ANNOT);
+ Annotations::allow(CONSTANT_NT, constant_text_ANNOT);
+ Annotations::allow(CONSTANT_NT, constant_use_option_ANNOT);
+ Annotations::allow(CONSTANT_NT, constant_verb_form_ANNOT);
+ Annotations::allow(CONSTANT_NT, explicit_literal_ANNOT);
+ Annotations::allow(CONSTANT_NT, explicit_vh_ANNOT);
+ Annotations::allow(CONSTANT_NT, grammar_token_code_ANNOT);
+ Annotations::allow(CONSTANT_NT, kind_of_value_ANNOT);
+ Annotations::allow(CONSTANT_NT, nothing_object_ANNOT);
+ Annotations::allow(CONSTANT_NT, property_name_used_as_noun_ANNOT);
+ Annotations::allow(CONSTANT_NT, proposition_ANNOT);
+ Annotations::allow(CONSTANT_NT, response_code_ANNOT);
+ Annotations::allow(CONSTANT_NT, self_object_ANNOT);
+ Annotations::allow(CONSTANT_NT, text_unescaped_ANNOT);
+ Annotations::allow(LOCAL_VARIABLE_NT, constant_local_variable_ANNOT);
+ Annotations::allow(LOCAL_VARIABLE_NT, kind_of_value_ANNOT);
+ Annotations::allow(LOGICAL_TENSE_NT, condition_tense_ANNOT);
+ Annotations::allow(LOGICAL_TENSE_NT, tense_marker_ANNOT);
+ Annotations::allow(NONLOCAL_VARIABLE_NT, constant_nonlocal_variable_ANNOT);
+ Annotations::allow(NONLOCAL_VARIABLE_NT, kind_of_value_ANNOT);
+ Annotations::allow(PROPERTY_VALUE_NT, record_as_self_ANNOT);
+ Annotations::allow(TEST_PHRASE_OPTION_NT, phrase_option_ANNOT);
+ Annotations::allow(TEST_PROPOSITION_NT, proposition_ANNOT);
+ Annotations::allow(UNKNOWN_NT, preposition_ANNOT);
+ Annotations::allow(UNKNOWN_NT, verb_ANNOT);
+}
+void ParseTreeUsage::allow_annotation_to_specification(int annot) {
+ Annotations::allow(UNKNOWN_NT, annot);
+ Annotations::allow_for_category(LVALUE_NCAT, annot);
+ Annotations::allow_for_category(RVALUE_NCAT, annot);
+ Annotations::allow_for_category(COND_NCAT, annot);
+}
+
+
+
+define PARENTAGE_EXCEPTIONS_SYNTAX_CALLBACK ParseTreeUsage::parentage_exceptions
+
+
+int ParseTreeUsage::parentage_exceptions(node_type_t t_parent, int cat_parent,
+ node_type_t t_child, int cat_child) {
+ if ((t_parent == PHRASE_TO_DECIDE_VALUE_NT) && (t_child == INVOCATION_LIST_NT)) return TRUE;
+ return FALSE;
+}
+
+define IMMUTABLE_NODE ParseTreeUsage::immutable
+define IS_SENTENCE_NODE_SYNTAX_CALLBACK ParseTreeUsage::second_level
+
+
+int ParseTreeUsage::second_level(node_type_t t) {
+ node_type_metadata *metadata = NodeType::get_metadata(t);
+ if ((metadata) && (metadata->category == L2_NCAT)) return TRUE;
+ return FALSE;
+}
+
+int ParseTreeUsage::immutable(node_type_t t) {
+ if (ParseTreeUsage::is_specification_node_type(t)) return TRUE;
+ return FALSE;
+}
+
+int ParseTreeUsage::is_specification_node_type(node_type_t t) {
+ if (t == UNKNOWN_NT) return TRUE;
+ node_type_metadata *metadata = NodeType::get_metadata(t);
+ if ((metadata) &&
+ ((metadata->category == RVALUE_NCAT) ||
+ (metadata->category == LVALUE_NCAT) ||
+ (metadata->category == COND_NCAT))) return TRUE;
+ return FALSE;
+}
+
+int ParseTreeUsage::is_lvalue(parse_node *pn) {
+ node_type_metadata *metadata = NodeType::get_metadata(Node::get_type(pn));
+ if ((metadata) && (metadata->category == LVALUE_NCAT)) return TRUE;
+ return FALSE;
+}
+
+int ParseTreeUsage::is_rvalue(parse_node *pn) {
+ node_type_metadata *metadata = NodeType::get_metadata(Node::get_type(pn));
+ if ((metadata) && (metadata->category == RVALUE_NCAT)) return TRUE;
+ return FALSE;
+}
+
+int ParseTreeUsage::is_value(parse_node *pn) {
+ node_type_metadata *metadata = NodeType::get_metadata(Node::get_type(pn));
+ if ((metadata) &&
+ ((metadata->category == LVALUE_NCAT) || (metadata->category == RVALUE_NCAT)))
+ return TRUE;
+ return FALSE;
+}
+
+int ParseTreeUsage::is_condition(parse_node *pn) {
+ node_type_metadata *metadata = NodeType::get_metadata(Node::get_type(pn));
+ if ((metadata) && (metadata->category == COND_NCAT)) return TRUE;
+ return FALSE;
+}
+
+int ParseTreeUsage::is_phrasal(parse_node *pn) {
+ if (NodeType::has_flag(Node::get_type(pn), PHRASAL_NFLAG)) return TRUE;
+ return FALSE;
+}
+
+void ParseTreeUsage::add_kind_inventions(void) {
+ StarTemplates::transcribe_all(Task::syntax_tree());
+}
+
+void ParseTreeUsage::verify(void) {
+ VerifyTree::verify_integrity(Task::syntax_tree());
+ VerifyTree::verify_structure(Task::syntax_tree());
+}
+
+
+
+
+
To tidy up |INVOCATION_LIST_NT| nodes into a list of children under the relevant |RULE_NT| node, and so turn each rule definition into a single subtree.
+ +§1. Initially, the phrases (INVOCATION_LIST_NT) making up a rule (RULE_NT) are +simply listed after it in the parse tree, but we want them to become its +children: this is the only thing the \(A\)-grammar does with rules, which +otherwise wait until later to be dealt with. +
+ +The code in this section accomplishes the regrouping: after it runs, every +INVOCATION_LIST_NT is a child of the RULE_NT header to which it belongs. +
+ +§2. This routine is used whenever new material is added. Whenever it finds a +childless RULE_NT followed by a sequence of INVOCATION_LIST_NT nodes, it +joins these in sequence as children of the RULE_NT. Since it always +acts so as to leave a non-zero number of children, and since it acts only +on childless nodes, it cannot ever act on the same node twice. +
+ ++void RuleSubtrees::register_recently_lexed_phrases(void) { + if (problem_count > 0) return; for then the tree is perhaps broken anyway + SyntaxTree::traverse(Task::syntax_tree(), RuleSubtrees::demote_command_nodes); + SyntaxTree::traverse(Task::syntax_tree(), RuleSubtrees::detect_loose_command_nodes); +} ++
§3. Command nodes are demoted to be children of routine nodes: +
+ ++void RuleSubtrees::demote_command_nodes(parse_node *p) { + if ((Node::get_type(p) == RULE_NT) && (p->down == NULL)) { + parse_node *end_def = p; + while ((end_def->next) && (Node::get_type(end_def->next) == INVOCATION_LIST_NT)) + end_def = end_def->next; + if (p == end_def) return; RULE_NT not followed by any INVOCATION_LIST_NTs + splice so that p->next to end_def become the children of p: + p->down = p->next; + p->next = end_def->next; + end_def->next = NULL; + RuleSubtrees::parse_routine_structure(p); + } +} ++ + +
+void RuleSubtrees::detect_loose_command_nodes(parse_node *p) { + if (Node::get_type(p) == INVOCATION_LIST_NT) + internal_error("loose COMMAND node outside of rule definition"); +} ++
§5. Parsing Routine Structure. There are now two possible syntaxes to express the structural makeup of a +routine. Traditional I7 syntax for blocks is to place them within begin/end +markers: the "begin" occurring at the end of the conditional or loop header, +and the "end if", "end while", etc., as a phrase of its own at the end of +the block. Newer I7 syntax (March 2008) is to use Python-style colons and +indentation. Both are allowed, but not in the same routine. +
+ +This routine opens with the routine's parse tree consisting of a simple +linked list of code-point nodes, one for each phrase. We must work out +which syntax is used, decipher it, and turn the list into a proper tree +structure in a single unified format. +
+ +How much simpler this would all be if we could abolish the old format, but +it's kept for the benefit of partially sighted users, who find tabbed +indentation difficult to manage with screen-readers. +
+ ++void RuleSubtrees::parse_routine_structure(parse_node *routine_node) { + int initial_problem_count = problem_count; + + parse_node *uses_colon_syntax = NULL; + parse_node *uses_begin_end_syntax = NULL; + parse_node *mispunctuates_begin_end_syntax = NULL; + parse_node *requires_colon_syntax = NULL; + + (a.1) See which block syntax is used by conditionals and loops5.1; + (a.2) Report problems if the two syntaxes are mixed up with each other5.2; + if (problem_count > initial_problem_count) return; + + if (uses_colon_syntax) (b.1) Annotate the parse tree with indentation levels5.3; + (b.2) Annotate the parse tree with control structure usage5.4; + + (c) Expand comma notation for blocks5.5; + if (problem_count > initial_problem_count) return; + + if (uses_colon_syntax) (d) Insert end nodes and check the indentation5.6; + if (problem_count > initial_problem_count) return; + + (e) Structure the parse tree to match the use of control structures5.7; + if (problem_count > initial_problem_count) return; + + (f) Police the structure of the parse tree5.8; + if (problem_count > initial_problem_count) return; + + (g) Optimise out the otherwise if nodes5.9; + if (problem_count > initial_problem_count) return; + + (h) Remove any end markers as no longer necessary5.11; + if (problem_count > initial_problem_count) return; + + if (uses_colon_syntax == FALSE) + (i) Remove any begin markers as no longer necessary5.13; + + (j) Insert code block nodes so that nodes needing to be parsed are childless5.15; + (k) Insert instead marker nodes5.17; + (l) Break up say phrases5.19; +} ++
§5.1. (a.1) See which block syntax is used by conditionals and loops5.1 = +
+ ++ parse_node *p; + for (p = routine_node->down; p; p = p->next) { + control_structure_phrase *csp = + ControlStructures::detect(Node::get_text(p)); + if (csp) { + int syntax_used = Annotations::read_int(p, colon_block_command_ANNOT); + if (syntax_used == FALSE) { i.e., doesn't end with a colon + don't count "if x is 1, let y be 2" — with no block — as deciding it + if ((csp->subordinate_to == NULL) && + (!(<phrase-beginning-block>(Node::get_text(p))))) + syntax_used = NOT_APPLICABLE; + } + if (syntax_used != NOT_APPLICABLE) { + if (syntax_used) { + if (uses_colon_syntax == NULL) uses_colon_syntax = p; + } else { + Note what looks like a begin-end piece of syntax5.1.1; + } + } + if ((csp->requires_new_syntax) && (requires_colon_syntax == NULL)) + requires_colon_syntax = p; + } + if (ControlStructures::detect_end(Node::get_text(p))) { + if (uses_begin_end_syntax == NULL) + uses_begin_end_syntax = p; + } + } ++
§5.1.1. It's possible in oddball cases to mis-punctuate such as to fool us, so: +
+ +Note what looks like a begin-end piece of syntax5.1.1 = +
+ ++ if ((uses_begin_end_syntax == NULL) && (mispunctuates_begin_end_syntax == NULL)) { + if (<phrase-beginning-block>(Node::get_text(p))) + uses_begin_end_syntax = p; + else + mispunctuates_begin_end_syntax = p; + } ++
§5.2. (a.2) Report problems if the two syntaxes are mixed up with each other5.2 = +
+ ++ if ((uses_colon_syntax) && (mispunctuates_begin_end_syntax)) { + current_sentence = routine_node; + Problems::quote_source(1, current_sentence); + Problems::quote_source(2, mispunctuates_begin_end_syntax); + StandardProblems::handmade_problem(Task::syntax_tree(), _p_(PM_BadOldSyntax)); + Problems::issue_problem_segment( + "The rule or phrase definition %1 seems to use indentation and " + "colons to group phrases together into 'if', 'repeat' or 'while' " + "blocks. That's fine, but then this phrase seems to be missing " + "some punctuation - %2. Perhaps a colon is missing?"); + Problems::issue_problem_end(); + return; + } + + if ((uses_colon_syntax) && (uses_begin_end_syntax)) { + current_sentence = routine_node; + Problems::quote_source(1, current_sentence); + Problems::quote_source(2, uses_colon_syntax); + Problems::quote_source(3, uses_begin_end_syntax); + StandardProblems::handmade_problem(Task::syntax_tree(), _p_(PM_BothBlockSyntaxes)); + Problems::issue_problem_segment( + "The rule or phrase definition %1 seems to use both ways of grouping " + "phrases together into 'if', 'repeat' and 'while' blocks at once. " + "Inform allows two alternative forms, but they cannot be mixed in " + "the same definition. %POne way is to end the 'if', 'repeat' or " + "'while' phrases with a 'begin', and then to match that with an " + "'end if' or similar. ('Otherwise' or 'otherwise if' clauses are " + "phrases like any other, and end with semicolons in this case.) " + "You use this begin/end form here, for instance - %3. %P" + "The other way is to end with a colon ':' and then indent the " + "subsequent phrases underneath, using tabs. (Note that any " + "'otherwise' or 'otherwise if' clauses also have to end with " + "colons in this case.) You use this indented form here - %2."); + Problems::issue_problem_end(); + return; + } + + if ((requires_colon_syntax) && (uses_begin_end_syntax)) { + current_sentence = routine_node; + Problems::quote_source(1, current_sentence); + Problems::quote_source(2, requires_colon_syntax); + StandardProblems::handmade_problem(Task::syntax_tree(), _p_(PM_NotInOldSyntax)); + Problems::issue_problem_segment( + "The construction %2, in the rule or phrase definition %1, " + "is only allowed if the rule is written in the 'new' format, " + "that is, with the phrases written one to a line with " + "indentation showing how they are grouped together, and " + "with colons indicating the start of such a group."); + Problems::issue_problem_end(); + return; + } ++
§5.3. If we're using Pythonesque notation, then the number of tab stops of +indentation of a phrase tells us where it belongs in the structure, so +we mark up the tree with that information. +
+ +(b.1) Annotate the parse tree with indentation levels5.3 = +
+ ++ Annotations::write_int(routine_node, indentation_level_ANNOT, + Lexer::indentation_level(Wordings::first_wn(Node::get_text(routine_node)))); + parse_node *p; + for (p = routine_node->down; p; p = p->next) { + int I = Lexer::indentation_level(Wordings::first_wn(Node::get_text(p))); + Annotations::write_int(p, indentation_level_ANNOT, I); + } ++
§5.4. Note that we are a little cautious about recognising phrases which will +open blocks, such as "repeat...", because of the dangers of false positives; +so we look for the "begin" keyword, or the colon. We're less cautious with +subordinate phrases (such as "otherwise") because we know their wonding +more certainly, and similarly for "end X" phrases. +
+ +(b.2) Annotate the parse tree with control structure usage5.4 = +
+ ++ for (parse_node *p = routine_node->down; p; p = p->next) { + control_structure_phrase *csp; + csp = ControlStructures::detect(Node::get_text(p)); + if (csp) { + if ((Annotations::read_int(p, colon_block_command_ANNOT)) || + (<phrase-beginning-block>(Node::get_text(p))) || + (csp->subordinate_to)) { + Node::set_control_structure_used(p, csp); + if (csp == case_CSP) Trim a switch case to just the case value5.4.1; + } + } + csp = ControlStructures::detect_end(Node::get_text(p)); + if (csp) Node::set_end_control_structure_used(p, csp); + } ++
§5.4.1. At this point anything at all can be a case value: it won't be parsed +or type-checked until compilation. +
+ +Trim a switch case to just the case value5.4.1 = +
+ ++ Node::set_text(p, GET_RW(<control-structure-phrase>, 1)); ++
§5.5. "Comma notation" is when a comma is used in an "if" statement to divide +off only a single consequential phrase, as in +
+ +++ +if the hat is worn, try dropping the hat;
+
Such a line occupies a single node in its routine's parse tree, and we need +to break this up. +
+ +(c) Expand comma notation for blocks5.5 = +
+ ++ for (parse_node *p = routine_node->down; p; p = p->next) + if (Node::get_control_structure_used(p) == NULL) { + control_structure_phrase *csp; + csp = ControlStructures::detect(Node::get_text(p)); + if ((csp == if_CSP) && (<phrase-with-comma-notation>(Node::get_text(p)))) + Effect a comma expansion5.5.1; + } ++
§5.5.1. Effect a comma expansion5.5.1 = +
+ ++ wording BCW = GET_RW(<phrase-with-comma-notation>, 1); text before the comma + wording ACW = GET_RW(<phrase-with-comma-notation>, 2); text after the comma + + First trim and annotate the "if ..." part + Annotations::write_int(p, colon_block_command_ANNOT, TRUE); it previously had no colon... + Node::set_control_structure_used(p, csp); ...and therefore didn't have its CSP set + Node::set_text(p, BCW); + + Now make a new node for the "then" part, indenting it one step inward + parse_node *then_node = Node::new(INVOCATION_LIST_NT); + Annotations::write_int(then_node, results_from_splitting_ANNOT, TRUE); + Annotations::write_int(then_node, indentation_level_ANNOT, + Annotations::read_int(p, indentation_level_ANNOT) + 1); + Node::set_text(then_node, ACW); + + parse_node *last_node_of_if_construction = then_node, *rest_of_routine = p->next; + + Attach the "then" node after the "if" node: + p->next = then_node; + + Deal with an immediately following otherwise node, if there is one5.5.1.1; + + if (uses_colon_syntax == FALSE) { + last_node_of_if_construction->next = RuleSubtrees::end_node(p); + last_node_of_if_construction->next->next = rest_of_routine; + } else { + last_node_of_if_construction->next = rest_of_routine; + } ++
§5.5.1.1. Deal with an immediately following otherwise node, if there is one5.5.1.1 = +
+ ++ if (rest_of_routine) + if ((uses_colon_syntax == FALSE) || + (Annotations::read_int(p, indentation_level_ANNOT) == + Annotations::read_int(rest_of_routine, indentation_level_ANNOT))) { + if (Node::get_control_structure_used(rest_of_routine) == otherwise_CSP) + Deal with an immediately following otherwise5.5.1.1.1 + else if (ControlStructures::abbreviated_otherwise(Node::get_text(rest_of_routine))) + Deal with an abbreviated otherwise node5.5.1.1.2; + } ++
§5.5.1.1.1. We string a plain "otherwise" node onto the "if" construction. +
+ +Deal with an immediately following otherwise5.5.1.1.1 = +
+ ++ then_node->next = rest_of_routine; + last_node_of_if_construction = last_node_of_if_construction->next; + rest_of_routine = rest_of_routine->next; ++
§5.5.1.1.2. An abbreviated otherwise clause looks like this: +
+ +++ +otherwise award 4 points;
+
and we want to split this, too, into distinct nodes. +
+ +Deal with an abbreviated otherwise node5.5.1.1.2 = +
+ ++ parse_node *otherwise_node = Node::new(CODE_BLOCK_NT); + Annotations::write_int(otherwise_node, results_from_splitting_ANNOT, TRUE); + Annotations::write_int(otherwise_node, indentation_level_ANNOT, + Annotations::read_int(p, indentation_level_ANNOT)); + Node::set_text(otherwise_node, + Wordings::one_word(Wordings::first_wn(Node::get_text(rest_of_routine)))); extract just the word "otherwise" + Node::set_control_structure_used(otherwise_node, otherwise_CSP); + + then_node->next = otherwise_node; + otherwise_node->next = rest_of_routine; + + Node::set_text(rest_of_routine, + Wordings::trim_first_word(Node::get_text(rest_of_routine))); to remove the "otherwise" + + Annotations::write_int(rest_of_routine, indentation_level_ANNOT, + Annotations::read_int(rest_of_routine, indentation_level_ANNOT) + 1); + + last_node_of_if_construction = rest_of_routine; + rest_of_routine = rest_of_routine->next; ++
§5.6. If the old-style syntax is used, there are explicit "end if", "end repeat" +and "end while" nodes in the list already. But if the Pythonesque syntax is +used then we need to create these nodes and insert them into the list; we +do these by reading off the structure from the pattern of indentation. It's +quite a long task, since this pattern may contain errors, which we have to +report more or less helpfully. +
+ +(d) Insert end nodes and check the indentation5.6 = +
+ ++ parse_node *p, *prev, *run_on_at = NULL; + parse_node *first_misaligned_phrase = NULL, *first_overindented_phrase = NULL; + int k, indent, expected_indent = 1, indent_misalign = FALSE, indent_overmuch = FALSE, + just_opened_block = FALSE; + + the blocks open stack holds blocks currently open + parse_node *blstack_opening_phrase[GROSS_AMOUNT_OF_INDENTATION+1]; + control_structure_phrase *blstack_construct[GROSS_AMOUNT_OF_INDENTATION+1]; + int blstack_stage[GROSS_AMOUNT_OF_INDENTATION+1]; + int blo_sp = 0, suppress_further_problems = FALSE; + + if (Annotations::read_int(routine_node, indentation_level_ANNOT) != 0) + Issue problem message for failing to start flush on the left margin5.6.1; + + for (prev = NULL, p = routine_node->down, k=1; p; prev = p, p = p->next, k++) { + control_structure_phrase *csp = Node::get_control_structure_used(p); + Determine actual indentation of this phrase5.6.2; + Compare actual indentation to what we expect from structure so far5.6.3; + Insert begin marker and increase expected indentation if a block begins here5.6.4; + } + + indent = 1; + Try closing blocks to bring expected indentation down to match5.6.5; + + if (indent_overmuch) Issue problem message for an excess of indentation5.6.7 + else if (run_on_at) Issue problem message for run-ons within phrase definition5.6.8 + else if (indent_misalign) Issue problem message for misaligned indentation5.6.6; ++
Issue problem message for failing to start flush on the left margin5.6.1 = +
+ ++ current_sentence = routine_node; + Problems::quote_source_eliding_begin(1, current_sentence); + StandardProblems::handmade_problem(Task::syntax_tree(), _p_(PM_NonflushRule)); + Problems::issue_problem_segment( + "The phrase or rule definition %1 is written using tab indentations " + "to show how its phrases are to be grouped together. But in that " + "case the opening line needs to be on the left margin, not indented."); + Problems::issue_problem_end(); + suppress_further_problems = TRUE; ++
§5.6.2. Here we set indent to the number of tab-stops in from the margin, or to +expected_indent if the text does not appear to be at the start of its own +line in the source (because it runs on from a previous phrase, in +which case we set the run_on_at flag: except for following on from cases +in switches with a non-control-structure, which is allowed, because otherwise +the lines often look silly and short). +
+ +Determine actual indentation of this phrase5.6.2 = +
+ ++ indent = expected_indent; + if (Annotations::read_int(p, indentation_level_ANNOT) > 0) + indent = Annotations::read_int(p, indentation_level_ANNOT); + else if (Wordings::nonempty(Node::get_text(p))) { + switch (Lexer::break_before(Wordings::first_wn(Node::get_text(p)))) { + case '\n': indent = 0; break; + case '\t': indent = 1; break; + default: + if ((prev) && (csp == NULL)) { + control_structure_phrase *pcsp = Node::get_control_structure_used(prev); + if ((pcsp) && (pcsp->allow_run_on)) break; + } + if ((Annotations::read_int(p, results_from_splitting_ANNOT) == FALSE) && + (run_on_at == NULL)) run_on_at = p; + break; + } + } + if (indent >= GROSS_AMOUNT_OF_INDENTATION) Record an excess of indentation5.6.2.1; ++
§5.6.3. We now know the indent level of the line as read, and also the +expected_indent given the definition so far. If they agree, fine. If they +don't agree, it isn't necessarily bad news — if each line's indentation were +a function of the last, there would be no information in it, after all. +Roughly speaking, when indent is greater than we expect, that must be +wrong — it means indentation has jumped inward as if to open a new block, +but blocks are opened explicitly and not by simply raising the indent. +But when indent is less than we expect, this may simply mean that the +current block(s) has or have been closed, because blocks are indeed closed +implicitly just by moving the indentation back in. +
+ +Compare actual indentation to what we expect from structure so far5.6.3 = +
+ ++ if (indent == 0) { + Record a misalignment of indentation5.6.3.3; + Record a phrase within current block5.6.3.2; + } else { + if ((csp) && (csp->subordinate_to)) { + Compare actual indentation to what we expect for an intermediate phrase5.6.3.1; + just_opened_block = TRUE; + } else { + if (expected_indent < indent) Record a misalignment of indentation5.6.3.3; + if (expected_indent > indent) + Try closing blocks to bring expected indentation down to match5.6.5; + expected_indent = indent; + Record a phrase within current block5.6.3.2; + } + } + if (expected_indent < 1) expected_indent = 1; ++
§5.6.3.1. This is a small variation used for an intermediate phrase like "otherwise". +These are required to be at the same indentation as the line which opened the +block, rather than being one tab step in from there: in other words they are +not deemed part of the block itself. They can also occur in "stages", which +is a way to enforce one intermediate phrase only being allowed after another +one — for instance, "otherwise if..." is not allowed after an "otherwise" +within an "if". +
+ +Compare actual indentation to what we expect for an intermediate phrase5.6.3.1 = +
+ ++ expected_indent--; + if (expected_indent < indent) { + Issue problem for an intermediate phrase not matching5.6.3.1.1; + } else { + Try closing blocks to bring expected indentation down to match5.6.5; + if ((blo_sp == 0) || + (csp->subordinate_to != blstack_construct[blo_sp-1])) { + Issue problem for an intermediate phrase not matching5.6.3.1.1; + } else { + if (blstack_stage[blo_sp-1] > csp->used_at_stage) + Issue problem for an intermediate phrase out of sequence5.6.3.1.2; + blstack_stage[blo_sp-1] = csp->used_at_stage; + } + } + expected_indent++; ++
§5.6.4. In colon syntax, blocks are explicitly opened; they are only implicitly +closed. Here is the opening: +
+ +If p is a node representing a phrase beginning a block, and we're in the +colon syntax, then it is followed by a word which is the colon: thus if p +reads "if x is 2" then the word following the "2" will be ":". +
+ +Insert begin marker and increase expected indentation if a block begins here5.6.4 = +
+ ++ if ((csp) && (csp->subordinate_to == NULL) && (Annotations::read_int(p, colon_block_command_ANNOT))) { + expected_indent++; + if (csp->indent_subblocks) expected_indent++; + blstack_construct[blo_sp] = csp; + blstack_stage[blo_sp] = 0; + blstack_opening_phrase[blo_sp++] = p; + just_opened_block = TRUE; + } ++
§5.6.5. Now for the closing of colon-syntax blocks. We know that blocks must be +being closed if the indentation has jumped backwards: but it may be that many +blocks are being closed at once. (It may also be that the indentation has +gone awry.) +
+ +Try closing blocks to bring expected indentation down to match5.6.5 = +
+ ++ if ((just_opened_block) && + (blo_sp > 0) && + (!(blstack_construct[blo_sp-1]->body_empty_except_for_subordinates)) && (p)) + Issue problem for an empty block5.6.5.2; + while (indent < expected_indent) { + parse_node *opening; + if (blo_sp == 0) { + Record a misalignment of indentation5.6.3.3; + indent = expected_indent; + break; + } + if ((blstack_construct[blo_sp-1]->body_empty_except_for_subordinates) && + (expected_indent - indent == 1)) { + indent = expected_indent; + break; + } + expected_indent--; + if (blstack_construct[blo_sp-1]->indent_subblocks) expected_indent--; + opening = blstack_opening_phrase[--blo_sp]; + Insert end marker to match the opening of the block phrase5.6.5.1; + } ++ +
§5.6.3.2. Record a phrase within current block5.6.3.2 = +
+ ++ if ((blo_sp > 0) && + (blstack_stage[blo_sp-1] == 0) && + (blstack_construct[blo_sp-1]->body_empty_except_for_subordinates)) { + Issue problem for non-case in a switch5.6.3.2.1; + } + just_opened_block = FALSE; ++
§5.6.5.1. An end marker is a phrase like "end if" which matches the "if... begin" +above it: here we insert such a marker at a place where the source text +indentation implicitly requires it. +
+ +Insert end marker to match the opening of the block phrase5.6.5.1 = +
+ ++ parse_node *implicit_end = RuleSubtrees::end_node(opening); + implicit_end->next = prev->next; prev->next = implicit_end; + prev = implicit_end; ++
§5.6.3.3. Here we throw what amounts to an exception... +
+ +Record a misalignment of indentation5.6.3.3 = +
+ ++ indent_misalign = TRUE; + if (first_misaligned_phrase == NULL) first_misaligned_phrase = p; ++ +
§5.6.6. ...and catch it with something of a catch-all message: +
+ +Issue problem message for misaligned indentation5.6.6 = +
+ ++ if (suppress_further_problems == FALSE) { + LOG("$T\n", routine_node); + current_sentence = routine_node; + Problems::quote_source_eliding_begin(1, current_sentence); + Problems::quote_source_eliding_begin(2, first_misaligned_phrase); + StandardProblems::handmade_problem(Task::syntax_tree(), _p_(PM_MisalignedIndentation)); + Problems::issue_problem_segment( + "The phrase or rule definition %1 is written using the 'colon " + "and indentation' syntax for its 'if's, 'repeat's and 'while's, " + "where blocks of phrases grouped together are indented one " + "tab step inward from the 'if ...:' or similar phrase to which " + "they belong. But the tabs here seem to be misaligned, and I can't " + "determine the structure. The first phrase going awry in the " + "definition seems to be %2, in case that helps. %PThis sometimes " + "happens even when the code looks about right, to the eye, if rows " + "of spaces have been used to indent phrases instead of tabs."); + Problems::Using::diagnose_further(); + Problems::issue_problem_end(); + } ++
Record an excess of indentation5.6.2.1 = +
+ ++ indent_overmuch = TRUE; + if (first_overindented_phrase == NULL) first_overindented_phrase = p; ++
Issue problem message for an excess of indentation5.6.7 = +
+ ++ if (suppress_further_problems == FALSE) { + current_sentence = routine_node; + Problems::quote_source_eliding_begin(1, current_sentence); + Problems::quote_source_eliding_begin(2, first_overindented_phrase); + StandardProblems::handmade_problem(Task::syntax_tree(), _p_(PM_TooMuchIndentation)); + Problems::issue_problem_segment( + "The phrase or rule definition %1 is written using tab indentations " + "to show how its phrases are to be grouped together. But the level " + "of indentation goes far too deep, reaching more than 25 tab stops " + "from the left margin."); + Problems::issue_problem_end(); + } ++
§5.6.8. Issue problem message for run-ons within phrase definition5.6.8 = +
+ ++ if (suppress_further_problems == FALSE) { + current_sentence = routine_node; + Problems::quote_source_eliding_begin(1, current_sentence); + Problems::quote_source_eliding_begin(2, run_on_at); + StandardProblems::handmade_problem(Task::syntax_tree(), _p_(PM_RunOnsInTabbedRoutine)); + Problems::issue_problem_segment( + "The phrase or rule definition %1 is written using the 'colon " + "and indentation' syntax for its 'if's, 'repeat's and 'while's, " + "but that's only allowed if each phrase in the definition " + "occurs on its own line. So phrases like %2, which follow " + "directly on from the previous phrase, aren't allowed."); + Problems::issue_problem_end(); + } ++
§5.6.5.2. It's a moot point whether the following should be incorrect syntax, but it +far more often happens as an accident than anything else, and it's hard to +think of a sensible use. +
+ +Issue problem for an empty block5.6.5.2 = +
+ ++ if (suppress_further_problems == FALSE) { + LOG("$T\n", routine_node); + current_sentence = routine_node; + Problems::quote_source_eliding_begin(1, current_sentence); + Problems::quote_source_eliding_begin(2, prev); + Problems::quote_source_eliding_begin(3, p); + StandardProblems::handmade_problem(Task::syntax_tree(), _p_(PM_EmptyIndentedBlock)); + Problems::issue_problem_segment( + "The phrase or rule definition %1 is written using the 'colon " + "and indentation' syntax for its 'if's, 'repeat's and 'while's, " + "where blocks of phrases grouped together are indented one " + "tab step inward from the 'if ...:' or similar phrase to which " + "they belong. But the phrase %2, which ought to begin a block, " + "is immediately followed by %3 at the same or a lower indentation, " + "so the block seems to be empty - this must mean there has been " + "a mistake in indenting the phrases."); + Problems::issue_problem_end(); + } ++
§5.6.3.2.1. Issue problem for non-case in a switch5.6.3.2.1 = +
+ ++ if (suppress_further_problems == FALSE) { + current_sentence = routine_node; + Problems::quote_source_eliding_begin(1, current_sentence); + Problems::quote_source_eliding_begin(2, p); + StandardProblems::handmade_problem(Task::syntax_tree(), _p_(PM_NonCaseInIf)); + Problems::issue_problem_segment( + "In the phrase or rule definition %1, the phrase %2 came as a " + "surprise since it was not a case in an 'if X is...' but was " + "instead some other miscellaneous instruction."); + Problems::issue_problem_end(); + } ++
§5.6.3.1.1. Issue problem for an intermediate phrase not matching5.6.3.1.1 = +
+ ++ if ((indent_misalign == FALSE) && (suppress_further_problems == FALSE)) { + current_sentence = p; + if (csp->subordinate_to == if_CSP) { + LOG("$T\n", routine_node); + StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_MisalignedOtherwise), + "this doesn't match a corresponding 'if'", + "as it must. An 'otherwise' must be vertically underneath the " + "'if' to which it corresponds, at the same indentation, and " + "if the 'otherwise' uses a colon to begin a block then the " + "'if' must do the same."); + } + if (csp->subordinate_to == switch_CSP) + StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_MisalignedCase), + "this seems to be misplaced since it is not a case within an " + "'if X is...'", + "as it must be. Each case must be placed one tab stop in from " + "the 'if X is...' to which it belongs, and the instructions " + "for what to do in that case should be one tab stop further in " + "still."); + } ++
§5.6.3.1.2. Issue problem for an intermediate phrase out of sequence5.6.3.1.2 = +
+ ++ if ((indent_misalign == FALSE) && (suppress_further_problems == FALSE)) { + current_sentence = p; + if ((csp == default_case_CSP) || (csp == case_CSP)) + StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_DefaultCaseNotLast), + "'otherwise' must be the last clause if an 'if ... is:'", + "and in particular it has to come after all the '-- V:' " + "case values supplied."); + else + StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_MisarrangedOtherwise), + "this seems to be misplaced since it is out of sequence within its 'if'", + "with an 'otherwise if...' coming after the more general 'otherwise' " + "rather than before. (Note that an 'otherwise' or 'otherwise if' must " + "be vertically underneath the 'if' to which it corresponds, at the " + "same indentation."); + } ++
§5.7. And after all that work, the routine's parse tree still consists only of a +linked list of nodes; but at least it now contains the same pattern of nodes +whichever syntax is used. We finally make a meaningful tree out of it. +
+ +(e) Structure the parse tree to match the use of control structures5.7 = +
+ ++ parse_node *routine_list = routine_node->down; + parse_node *top_level = Node::new(CODE_BLOCK_NT); + + routine_node->down = top_level; + + parse_node *attach_owners[MAX_BLOCK_NESTING+1]; + parse_node *attach_points[MAX_BLOCK_NESTING+1]; + control_structure_phrase *attach_csps[MAX_BLOCK_NESTING+1]; + int attach_point_sp = 0; + + push the top level code block onto the stack + attach_owners[attach_point_sp] = NULL; + attach_csps[attach_point_sp] = NULL; + attach_points[attach_point_sp++] = top_level; + + parse_node *overflow_point = NULL; if any overflow is found + for (parse_node *pn = routine_list, *pn_prev = NULL; pn; pn_prev = pn, pn = pn->next) { + unstring this node from the old list + if (pn_prev) pn_prev->next = NULL; + Attach the node to the routine's growing parse tree5.7.1; + } + if (overflow_point) { + current_sentence = overflow_point; + StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_BlockNestingTooDeep), + "compound phrases have gone too deep", + "perhaps because many have begun but not been properly ended?"); + } ++
§5.7.1. Attach the node to the routine's growing parse tree5.7.1 = +
+ ++ int go_up = FALSE, go_down = FALSE; + control_structure_phrase *csp = Node::get_end_control_structure_used(pn); + if (csp) go_up = TRUE; + else { + csp = Node::get_control_structure_used(pn); + if (csp) { + go_down = TRUE; + if (ControlStructures::opens_block(csp) == FALSE) { + go_up = TRUE; + Node::set_type(pn, CODE_BLOCK_NT); + } + } + } + if (go_up) Move the attachment point up in the tree5.7.1.1; + Attach this latest node5.7.1.2; + if (go_down) Move the attachment point down in the tree5.7.1.3; ++
§5.7.1.1. Move the attachment point up in the tree5.7.1.1 = +
+ ++ control_structure_phrase *superior_csp = attach_csps[attach_point_sp-1]; + if ((superior_csp) && (superior_csp->subordinate_to)) Pop the CSP stack5.7.1.1.1; + if (go_down == FALSE) Pop the CSP stack5.7.1.1.1; ++
§5.7.1.2. Attach this latest node5.7.1.2 = +
+ ++ parse_node *to = attach_points[attach_point_sp-1]; + if ((go_up) && (go_down) && (attach_owners[attach_point_sp-1])) + to = attach_owners[attach_point_sp-1]; + SyntaxTree::graft(Task::syntax_tree(), pn, to); ++
§5.7.1.3. Move the attachment point down in the tree5.7.1.3 = +
+ ++ parse_node *next_attach_point = pn; + if (go_up == FALSE) { + pn->down = Node::new(CODE_BLOCK_NT); + next_attach_point = pn->down; + } + Push the CSP stack5.7.1.3.1; ++
§5.7.1.1.1. It's an error to let this underflow, but we'll catch that problem later. +
+ +Pop the CSP stack5.7.1.1.1 = +
+ ++ if (attach_point_sp != 1) attach_point_sp--; ++
§5.7.1.3.1. An overflow, however, we must catch right here. +
+ +Push the CSP stack5.7.1.3.1 = +
+ ++ if (attach_point_sp <= MAX_BLOCK_NESTING) { + attach_owners[attach_point_sp] = pn; + attach_csps[attach_point_sp] = csp; + attach_points[attach_point_sp++] = next_attach_point; + } else { + if (overflow_point == NULL) overflow_point = pn; + } ++
§5.8. We now have a neatly structured tree, so from here on anything we do will +need a recursive procedure. +
+ +Firstly, the tree is certainly neat, but it can still contain all kinds +of nonsense: "if" blocks with multiple "otherwise"s, for example. This is +where we look for such mistakes. +
+ +(f) Police the structure of the parse tree5.8 = +
+ ++ int n = problem_count; + RuleSubtrees::police_code_block(routine_node->down, NULL); + if (problem_count > n) LOG("Local parse tree: $T\n", routine_node); ++
§6. Which recursively uses the following: +
+ ++void RuleSubtrees::police_code_block(parse_node *block, control_structure_phrase *context) { + for (parse_node *p = block->down, *prev_p = NULL; p; prev_p = p, p = p->next) { + current_sentence = p; + + control_structure_phrase *prior = + (prev_p)?Node::get_control_structure_used(prev_p):NULL; + control_structure_phrase *csp = Node::get_end_control_structure_used(p); + if ((csp) && (csp != prior)) { + if (prior == NULL) Issue problem for end without begin6.1 + else Issue problem for wrong sort of end6.2; + } + + csp = Node::get_control_structure_used(p); + if (csp) { + if (ControlStructures::opens_block(csp)) { + if ((p->next == NULL) || + (Node::get_end_control_structure_used(p->next) == NULL)) + Issue problem for begin without end6.3; + } else { + if (context == NULL) + Choose a problem for a loose clause6.4 + else if (context != csp->subordinate_to) + Choose a problem for the wrong clause6.5 + else if ((csp == otherwise_CSP) && (p->next)) + Choose a problem for otherwise not occurring last6.6 + else if ((csp == default_case_CSP) && (p->next)) + Issue a problem for the default case not occurring last6.7; + } + } + + if (p->down) RuleSubtrees::police_code_block(p, csp); + } +} ++
§6.1. These used to be much-seen problem messages, until Inform moved to Pythonesque +structure-by-indentation. Nowadays "end if", "end while" and such are +automatically inserted into the stream of commands, always in the right place, +and always passing these checks. But the problem messages are kept for the sake +of old-format source text, and for refuseniks. +
+ +Issue problem for end without begin6.1 = +
+ ++ StandardProblems::sentence_problem_with_note(Task::syntax_tree(), _p_(PM_EndWithoutBegin), + "this is an 'end' with no matching 'begin'", + "which should not happen: every phrase like 'if ... begin;' " + "should eventually be followed by its bookend 'end if'. " + "It makes no sense to have an 'end ...' on its own.", + "Perhaps the problem is actually that you opened several " + "such begin... end 'blocks' and accidentally closed them " + "once too many? This is very easily done."); ++
§6.2. Issue problem for wrong sort of end6.2 = +
+ ++ Problems::quote_source(1, current_sentence); + Problems::quote_wide_text(2, prior->keyword); + Problems::quote_source(3, prev_p); + StandardProblems::handmade_problem(Task::syntax_tree(), _p_(PM_WrongEnd)); + Problems::issue_problem_segment( + "You wrote %1, but the end I was expecting next was 'end %2', " + "finishing the block you began with %3."); + Problems::issue_problem_end(); ++
§6.3. Issue problem for begin without end6.3 = +
+ ++ StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_BeginWithoutEnd), + "the definition of the phrase ended with no matching 'end' for " + "this 'begin'", + "bearing in mind that every begin must have a matching end, and " + "that the one most recently begun must be the one first to end. For " + "instance, 'if ... begin' must have a matching 'end if'."); ++
§6.4. Choose a problem for a loose clause6.4 = +
+ ++ if (csp == otherwise_CSP) + StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_OtherwiseWithoutIf), + "this is an 'else' or 'otherwise' with no matching 'if' (or 'unless')", + "which must be wrong."); + else if (csp == otherwise_if_CSP) + StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_OtherwiseIfMisplaced), + "the 'otherwise if' clause here seems not to be occurring inside " + "a large 'if'", + "and seems to be freestanding instead. (Though 'otherwise ...' can " + "usually be used after simple one-line 'if's to provide an alternative " + "course of action, 'otherwise if...' is a different matter, and is " + "used to divide up larger-scale instructions.)"); + else + StandardProblems::sentence_problem(Task::syntax_tree(), _p_(BelievedImpossible), + "this clause can't occur outside of a control phrase", + "which suggests that the structure of this routine is wrong."); ++
§6.5. Choose a problem for the wrong clause6.5 = +
+ ++ if ((csp == otherwise_CSP) || (csp == otherwise_if_CSP)) { + Problems::quote_source(1, current_sentence); + Problems::quote_wide_text(2, context->keyword); + StandardProblems::handmade_problem(Task::syntax_tree(), _p_(PM_OtherwiseInNonIf)); + Problems::issue_problem_segment( + "The %1 here did not make sense inside a " + "'%2' structure: it's provided for 'if' (or 'unless')."); + Problems::issue_problem_end(); + } else + StandardProblems::sentence_problem(Task::syntax_tree(), _p_(BelievedImpossible), + "this clause is wrong for the phrase containing it", + "which suggests that the structure of this routine is wrong."); ++
§6.6. Choose a problem for otherwise not occurring last6.6 = +
+ ++ int doubled = FALSE, oi = FALSE; + for (parse_node *p2 = p->next; p2; p2 = p2->next) { + if (Node::get_control_structure_used(p2) == otherwise_CSP) { + current_sentence = p2; + doubled = TRUE; + } + if (Node::get_control_structure_used(p2) == otherwise_if_CSP) + oi = TRUE; + } + if (doubled) + StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_DoubleOtherwise), + "that makes two unconditional 'otherwise' or 'else' clauses " + "for this 'if'", + "which is forbidden since 'otherwise' is meant to be a single " + "(optional) catch-all clause at the end."); + else if (oi) + StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_OtherwiseIfAfterOtherwise), + "this seems to be misplaced since it is out of sequence within its 'if'", + "with an 'otherwise if...' coming after the more general 'otherwise' " + "rather than before. (If there's an 'otherwise' clause, it has to be " + "the last clause of the 'if'.)"); + else + StandardProblems::sentence_problem(Task::syntax_tree(), _p_(BelievedImpossible), + "'otherwise' must be the last clause", + "but it seems not to be."); ++
§6.7. This shouldn't happen because the switch construct requires Python syntax +and the structure of that was checked at indentation time, but just in case. +
+ +Issue a problem for the default case not occurring last6.7 = +
+ ++ StandardProblems::sentence_problem(Task::syntax_tree(), _p_(BelievedImpossible), + "'otherwise' must be the last clause", + "which must be wrong."); ++
§5.9. The tree is now known to be correctly structured, and there are no possible +problem messages left to issue. It's therefore safe to begin rearranging it. +We'll first eliminate one whole construction: "otherwise if whatever: ..." +can now become "otherwise: if whatever: ...". +
+ +(g) Optimise out the otherwise if nodes5.9 = +
+ ++ int n = problem_count; + RuleSubtrees::purge_otherwise_if(routine_node->down); + if (problem_count > n) LOG("Local parse tree: $T\n", routine_node); ++
§5.10. We made a similar manoeuvre above, but for one-line "otherwise do something" +phrases following one-line "if", not for the wider case of "otherwise if". We +didn't handle this back then because to do so would have made it impossible +to issue good problem messages for failures to use "otherwise if" correctly. +
+ ++void RuleSubtrees::purge_otherwise_if(parse_node *block) { + for (parse_node *p = block->down, *prev_p = NULL; p; prev_p = p, p = p->next) { + if (Node::get_control_structure_used(p) == otherwise_if_CSP) { + parse_node *former_contents = p->down; + parse_node *former_successors = p->next; + + put an otherwise node in the position previously occupied by p + parse_node *otherwise_node = Node::new(CODE_BLOCK_NT); + Node::set_control_structure_used(otherwise_node, otherwise_CSP); + extract just the word "otherwise" + Node::set_text(otherwise_node, Wordings::one_word(Wordings::first_wn(Node::get_text(p)))); + if (prev_p) prev_p->next = otherwise_node; else block->down = otherwise_node; + + move p to below the otherwise node + otherwise_node->down = p; + Node::set_type(p, INVOCATION_LIST_NT); + Node::set_control_structure_used(p, if_CSP); + p->next = NULL; + Node::set_text(p, Wordings::trim_first_word(Node::get_text(p))); + + put the code previously under p under a new code block node under p + p->down = Node::new(CODE_BLOCK_NT); + p->down->down = former_contents; + + any further "otherwise if" or "otherwise" nodes after p follow + p->down->next = former_successors; + } + if (p->down) RuleSubtrees::purge_otherwise_if(p); + } +} ++
§5.11. End nodes are now redundant: maybe they got here as explicit "end if" phrases +in the source text, or maybe they were auto-inserted by the indentation reader, +but now that the structure is known to be correct they serve no further purpose. +We remove them. +
+ +(h) Remove any end markers as no longer necessary5.11 = +
+ ++ RuleSubtrees::purge_end_markers(routine_node->down); ++
+void RuleSubtrees::purge_end_markers(parse_node *block) { + for (parse_node *p = block->down, *prev_p = NULL; p; prev_p = p, p = p->next) { + if (Node::get_end_control_structure_used(p)) { + if (prev_p) prev_p->next = p->next; else block->down = p->next; + } + if (p->down) RuleSubtrees::purge_end_markers(p); + } +} ++
§5.13. The "begin" keyword at the end of control constructs in the old-style syntax +can now be removed, too. +
+ +(i) Remove any begin markers as no longer necessary5.13 = +
+ ++ RuleSubtrees::purge_begin_markers(routine_node->down); ++
+void RuleSubtrees::purge_begin_markers(parse_node *block) { + for (parse_node *p = block->down, *prev_p = NULL; p; prev_p = p, p = p->next) { + if (Node::get_control_structure_used(p)) + if (<phrase-beginning-block>(Node::get_text(p))) + Node::set_text(p, GET_RW(<phrase-beginning-block>, 1)); + if (p->down) RuleSubtrees::purge_begin_markers(p); + } +} ++
§5.15. This all makes a nice tree, but it has the defect that the statements heading +block-opening phrases (the ifs, whiles, repeats) have child nodes (the blocks +of code consequent on them). We want them to be leaves for now, so that we +can append statement-parsing data underneath them later. So we insert blank +code block nodes to mark these phrases, and transfer the control structure +annotations to them. +
+ +(j) Insert code block nodes so that nodes needing to be parsed are childless5.15 = +
+ ++ RuleSubtrees::insert_cb_nodes(routine_node->down); ++
+void RuleSubtrees::insert_cb_nodes(parse_node *block) { + for (parse_node *p = block->down, *prev_p = NULL; p; prev_p = p, p = p->next) { + if (ControlStructures::opens_block(Node::get_control_structure_used(p))) { + parse_node *blank_cb_node = Node::new(CODE_BLOCK_NT); + Node::set_control_structure_used(blank_cb_node, + Node::get_control_structure_used(p)); + Node::set_control_structure_used(p, NULL); + blank_cb_node->down = p; + blank_cb_node->next = p->next; + p->next = p->down; + p->down = NULL; + if (prev_p) prev_p->next = blank_cb_node; else block->down = blank_cb_node; + p = blank_cb_node; + } + if (p->down) RuleSubtrees::insert_cb_nodes(p); + } +} ++ + +
(k) Insert instead marker nodes5.17 = +
+ ++ RuleSubtrees::read_instead_markers(routine_node->down); ++
+void RuleSubtrees::read_instead_markers(parse_node *block) { + for (parse_node *p = block->down, *prev_p = NULL; p; prev_p = p, p = p->next) { + if (<instead-keyword>(Node::get_text(p))) { + Node::set_text(p, GET_RW(<instead-keyword>, 1)); + parse_node *instead_node = Node::new(CODE_BLOCK_NT); + Node::set_control_structure_used(instead_node, instead_CSP); + instead_node->next = p->next; + p->next = instead_node; + } + if (p->down) RuleSubtrees::read_instead_markers(p); + } +} ++ + +
(l) Break up say phrases5.19 = +
+ ++ RuleSubtrees::break_up_says(routine_node->down); ++
+void RuleSubtrees::break_up_says(parse_node *block) { + for (parse_node *p = block->down, *prev_p = NULL; p; prev_p = p, p = p->next) { + int sf = NO_SIGF; + wording W = Node::get_text(p); + if (Annotations::read_int(p, from_text_substitution_ANNOT)) sf = SAY_SIGF; + else if (<other-significant-phrase>(W)) { + sf = <<r>>; W = GET_RW(<other-significant-phrase>, 1); + } + switch (sf) { + case SAY_SIGF: { + parse_node *blank_cb_node = Node::new(CODE_BLOCK_NT); + Node::set_control_structure_used(blank_cb_node, say_CSP); + blank_cb_node->next = p->next; + Node::set_text(blank_cb_node, Node::get_text(p)); + p->next = NULL; + if (prev_p) prev_p->next = blank_cb_node; else block->down = blank_cb_node; + + current_sentence = p; + RuleSubtrees::unroll_says(blank_cb_node, W, 0); + p = blank_cb_node; + break; + } + case NOW_SIGF: { + Node::set_control_structure_used(p, now_CSP); + parse_node *cond_node = Node::new(CONDITION_CONTEXT_NT); + Node::set_text(cond_node, W); + p->down = cond_node; + break; + } + } + if (p->down) RuleSubtrees::break_up_says(p); + } +} + +void RuleSubtrees::unroll_says(parse_node *cb_node, wording W, int depth) { + while (<phrase-with-comma-notation>(W)) { + wording AW = GET_RW(<phrase-with-comma-notation>, 1); + wording BW = GET_RW(<phrase-with-comma-notation>, 2); + W = AW; + Bite off a say term7.1; + W = BW; + } + Bite off a say term7.1; +} ++
§7.1. Bite off a say term7.1 = +
+ ++ if ((Wordings::length(W) > 1) || (Wide::cmp(Lexer::word_text(Wordings::first_wn(W)), L"\"\"") != 0)) { + if ((Wordings::length(W) == 1) && (Vocabulary::test_flags(Wordings::first_wn(W), TEXTWITHSUBS_MC)) && (depth == 0)) { + wchar_t *p = Lexer::word_raw_text(Wordings::first_wn(W)); + Check that substitution does not contain suspicious punctuation7.1.1; + wording A = Feeds::feed_C_string_expanding_strings(p); + if (<verify-expanded-text-substitution>(A)) + RuleSubtrees::unroll_says(cb_node, A, depth+1); + } else { + parse_node *say_term_node = Node::new(INVOCATION_LIST_SAY_NT); + Node::set_text(say_term_node, W); + SyntaxTree::graft(Task::syntax_tree(), say_term_node, cb_node); + } + } ++
§7.1.1. Check that substitution does not contain suspicious punctuation7.1.1 = +
+ ++ int k, sqb = 0; + for (k=0; p[k]; k++) { + switch (p[k]) { + case '[': sqb++; if (sqb > 1) Issue problem message for nested substitution7.1.1.2; break; + case ']': sqb--; if (sqb < 0) Issue problem message for unopened substitution7.1.1.4; break; + case ':': if ((k>0) && (Characters::isdigit(p[k-1])) && (Characters::isdigit(p[k+1]))) break; + case ';': + if (sqb > 0) Issue PM_TSWithPunctuation problem7.1.1.6; + break; + case ',': + if (sqb > 0) Issue problem message for comma in a substitution7.1.1.1; + break; + } + } + if (sqb != 0) Issue problem message for unclosed substitution7.1.1.3; ++
§7.1.1.1. And the more specialised: +
+ +Issue problem message for comma in a substitution7.1.1.1 = +
+ ++ Strings::TextSubstitutions::it_is_not_worth_adding(); + StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_TSWithComma), + "a substitution contains a comma ','", + "which is against the rules, because 'say' is a special phrase in " + "which the comma divides items in a list of things to say, and so it " + "loses its ordinary meanings. Because of this, no text substitution " + "can contain a comma. " + "(If you're trying to use a value produced by a phrase with a phrase " + "option - say 'the best route from A to B, using even locked doors' - " + "you'll need to put this in a 'let' variable first and then say that, " + "or else define a better text substitution to do the job for you.)"); + Strings::TextSubstitutions::it_is_worth_adding(); + return; ++
§7.1.1.2. Issue problem message for nested substitution7.1.1.2 = +
+ ++ Strings::TextSubstitutions::it_is_not_worth_adding(); + if ((p[k+1] == 'u') && (p[k+2] == 'n') && (p[k+3] == 'i') && (p[k+4] == 'c') && + (p[k+5] == 'o') && (p[k+6] == 'd') && (p[k+7] == 'e') && (p[k+8] == ' ')) { + StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_NestedUSubstitution), + "the text here contains one substitution '[...]' inside another", + "which is not allowed. Actually, it looks as if you might have got " + "into this by typing an exotic character as part of the name of a " + "text substitution - those get rewritten automatically as '[unicode N]' " + "for the appropriate Unicode character code number N. Either way - " + "this isn't allowed."); + } else { + StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_NestedSubstitution), + "the text here contains one substitution '[...]' inside another", + "which is not allowed. (If you just wanted a literal open and closed " + "square bracket, use '[bracket]' and '[close bracket]'.)"); + } + Strings::TextSubstitutions::it_is_worth_adding(); + return; ++
§7.1.1.3. Issue problem message for unclosed substitution7.1.1.3 = +
+ ++ Strings::TextSubstitutions::it_is_not_worth_adding(); + StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_UnclosedSubstitution), + "the text here uses an open square bracket '[', which opens a substitution " + "in the text, but doesn't close it again", + "so that the result is malformed. (If you just wanted a literal open " + "square bracket, use '[bracket]'.)"); + Strings::TextSubstitutions::it_is_worth_adding(); + return; ++
§7.1.1.4. Issue problem message for unopened substitution7.1.1.4 = +
+ ++ Strings::TextSubstitutions::it_is_not_worth_adding(); + StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_UnopenedSubstitution), + "the text here uses a close square bracket ']', which closes a substitution " + "in the text, but never actually opened it", + "with a matching '['. (If you just wanted a literal close square bracket, " + "use '[close bracket]'.)"); + Strings::TextSubstitutions::it_is_worth_adding(); + return; ++
§7.1.1.5. Something devious happens when production (b) of <s-say-phrase> is matched. +Double-quoted text is literal if it contains no square brackets, but is +expanded if it includes text substitutions in squares. When (b) matches, +Inform expands a text such as +
+ +++ +"Look, [the noun] said."
+
into: +
+ +++ +"Look, ", the noun, " said."
+
and then re-parses the result with the following nonterminal; note that we +make sure commas are used correctly before handing back to <s-say-phrase> +to parse the list. +
+ ++<verify-expanded-text-substitution> ::= + *** . *** | ==> Issue PM_TSWithPunctuation problem7.1.1.6; ==> { fail } + , *** | ==> Issue PM_EmptySubstitution problem7.1.1.5.1; ==> { fail } + *** , | ==> Issue PM_EmptySubstitution problem7.1.1.5.1; ==> { fail } + *** , , *** | ==> Issue PM_EmptySubstitution problem7.1.1.5.1; ==> { fail } + ... ++
§7.1.1.6. So now just the problem messages: +
+ +Issue PM_TSWithPunctuation problem7.1.1.6 = +
+ ++ Strings::TextSubstitutions::it_is_not_worth_adding(); + StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_TSWithPunctuation), + "a substitution contains a '.', ':' or ';'", + "which suggests that a close square bracket ']' may have gone astray."); + Strings::TextSubstitutions::it_is_worth_adding(); ++ + + +
Issue PM_EmptySubstitution problem7.1.1.5.1 = +
+ ++ Strings::TextSubstitutions::it_is_not_worth_adding(); + StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_EmptySubstitution), + "the text here contains an empty substitution '[]'", + "which is not allowed. To say nothing - well, say nothing."); + Strings::TextSubstitutions::it_is_worth_adding(); ++
§8. That just leaves one utility routine, for manufacturing end nodes which +match a given begin node. +
+ ++parse_node *RuleSubtrees::end_node(parse_node *opening) { + parse_node *implicit_end = Node::new(INVOCATION_LIST_NT); + Node::set_end_control_structure_used(implicit_end, + Node::get_control_structure_used(opening)); + Annotations::write_int(implicit_end, indentation_level_ANNOT, + Annotations::read_int(opening, indentation_level_ANNOT)); + return implicit_end; +} ++ + +
§3. Timed events are stored in two simple arrays, processed by run-time code.
@@ -243,7 +243,7 @@ arguably shouldn't block compilation. Then again...§3. A local variable needs to be stored somewhere at run-time. The obvious correspondence is to put these into I6 local variables, which are, in effect, CPU registers. We won't need to do much in the way of register-allocation, diff --git a/docs/imperative-module/5-ci.html b/docs/imperative-module/5-ci.html index 388f19409..0f289752d 100644 --- a/docs/imperative-module/5-ci.html +++ b/docs/imperative-module/5-ci.html @@ -142,7 +142,7 @@ earlier invocation list (in what may be another setting entirely). LOOP_THROUGH_INVOCATION_LIST(inv, invl) { LOGIF(MATCHING, "C%d: $e\n", pos, inv); pos++; if (Node::get_say_verb(inv)) { - VerbsAtRunTime::ConjugateVerb_invoke_emit( + RTVerbs::ConjugateVerb_invoke_emit( Node::get_say_verb(inv), Node::get_modal_verb(inv), Annotations::read_int(inv, say_verb_negated_ANNOT)); @@ -540,7 +540,7 @@ no subsequent lines are looked at.
if (Node::get_say_verb(inv)) - VerbsAtRunTime::ConjugateVerb_invoke_emit( + RTVerbs::ConjugateVerb_invoke_emit( Node::get_say_verb(inv), Node::get_modal_verb(inv), Annotations::read_int(inv, say_verb_negated_ANNOT)); @@ -561,7 +561,7 @@ no subsequent lines are looked at.if (Node::get_say_verb(inv)) - VerbsAtRunTime::ConjugateVerb_invoke_emit( + RTVerbs::ConjugateVerb_invoke_emit( Node::get_say_verb(inv), Node::get_modal_verb(inv), Annotations::read_int(inv, say_verb_negated_ANNOT)); diff --git a/docs/imperative-module/index.html b/docs/imperative-module/index.html index 91040ee87..e45038632 100644 --- a/docs/imperative-module/index.html +++ b/docs/imperative-module/index.html @@ -125,6 +125,11 @@Introduction to Phrases - An exposition of the data structures used inside Inform to hold phrases, rules and rulebooks.
+
-void Index::below_link(OUTPUT_STREAM, text_stream *p) { +void Index::below_link(OUTPUT_STREAM, text_stream *p) { WRITE(" "); HTML_OPEN_WITH("a", "href=#%S", p); HTML_TAG_WITH("img", "border=0 src=inform:/doc_images/Below.png"); HTML_CLOSE("a"); } -void Index::anchor(OUTPUT_STREAM, text_stream *p) { +void Index::anchor(OUTPUT_STREAM, text_stream *p) { HTML_OPEN_WITH("a", "name=%S", p); HTML_CLOSE("a"); } -void Index::below_link_numbered(OUTPUT_STREAM, int n) { +void Index::below_link_numbered(OUTPUT_STREAM, int n) { WRITE(" "); HTML_OPEN_WITH("a", "href=#A%d", n); HTML_TAG_WITH("img", "border=0 src=inform:/doc_images/Below.png"); HTML_CLOSE("a"); } -void Index::anchor_numbered(OUTPUT_STREAM, int n) { +void Index::anchor_numbered(OUTPUT_STREAM, int n) { HTML_OPEN_WITH("a", "name=A%d", n); HTML_CLOSE("a"); }
§12. "Show extra" links, and also a spacer of equivalent width.
-void Index::extra_link(OUTPUT_STREAM, int id) { +void Index::extra_link(OUTPUT_STREAM, int id) { HTML_OPEN_WITH("a", "href=\"#\" onclick=\"showExtra('extra%d', 'plus%d'); return false;\"", id, id); HTML_TAG_WITH("img", "border=0 id=\"plus%d\" src=inform:/doc_images/extra.png", id); HTML_CLOSE("a"); @@ -1042,13 +1042,13 @@ code.diff --git a/docs/index-module/2-ki.html b/docs/index-module/2-ki.html index 5980ee8ce..dd42a332f 100644 --- a/docs/index-module/2-ki.html +++ b/docs/index-module/2-ki.html @@ -571,7 +571,7 @@ as "0 kg", "0 hectares", or whatever is appropriate.-void Index::extra_div_open(OUTPUT_STREAM, int id, int indent, char *colour) { +void Index::extra_div_open(OUTPUT_STREAM, int id, int indent, char *colour) { HTML_OPEN_WITH("div", "id=\"extra%d\" style=\"display: none;\"", id); HTML::open_indented_p(OUT, indent, ""); HTML::open_coloured_box(OUT, colour, ROUND_BOX_TOP+ROUND_BOX_BOTTOM); } -void Index::extra_div_close(OUTPUT_STREAM, char *colour) { +void Index::extra_div_close(OUTPUT_STREAM, char *colour) { HTML::close_coloured_box(OUT, colour, ROUND_BOX_TOP+ROUND_BOX_BOTTOM); HTML_CLOSE("p"); HTML_CLOSE("div"); @@ -1092,7 +1092,7 @@ quotes. }diff --git a/docs/index-module/2-ih.html b/docs/index-module/2-ih.html new file mode 100644 index 000000000..1e7c04249 --- /dev/null +++ b/docs/index-module/2-ih.html @@ -0,0 +1,359 @@ + + + +Index Headings + + + + + + + + + + + + + + + + + + + + + ++ + + + + + diff --git a/docs/index-module/2-ipw.html b/docs/index-module/2-ipw.html index e5bd1d474..a67204ce6 100644 --- a/docs/index-module/2-ipw.html +++ b/docs/index-module/2-ipw.html @@ -509,7 +509,7 @@ table of Kinds. }To produce the index contents listing and the XML headings file.
+ +
+ +§1. The debugging log. Finally, three ways to describe the run of headings: to the debugging log, +to the index of the project, and to a freestanding XML file. +
+ ++void IndexHeadings::log(heading *h) { + if (h==NULL) { LOG("<null heading>\n"); return; } + heading *pseud = NameResolution::pseudo_heading(); + if (h == pseud) { LOG("<pseudo_heading>\n"); return; } + LOG("H%d ", h->allocation_id); + if (h->start_location.file_of_origin) + LOG("<%f, line %d>", + TextFromFiles::get_filename(h->start_location.file_of_origin), + h->start_location.line_number); + else LOG("<nowhere>"); + LOG(" level:%d indentation:%d", h->level, h->indentation); +} ++§2. And here we log the whole heading tree by recursing through it, and +surreptitiously check that it is correctly formed at the same time. +
+ ++void IndexHeadings::log_all_headings(void) { + heading *h; + parse_node_tree *T = Task::syntax_tree(); + LOOP_OVER_LINKED_LIST(h, heading, T->headings->subordinates) LOG("$H\n", h); + LOG("\n"); + IndexHeadings::log_headings_recursively(NameResolution::pseudo_heading(), 0); +} + +void IndexHeadings::log_headings_recursively(heading *h, int depth) { + int i; + if (h==NULL) return; + for (i=0; i<depth; i++) LOG(" "); + LOG("$H\n", h); + if (depth-1 != h->indentation) LOG("*** indentation should be %d ***\n", depth-1); + IndexHeadings::log_headings_recursively(h->child_heading, depth+1); + IndexHeadings::log_headings_recursively(h->next_heading, depth); +} ++ + ++typedef struct contents_entry { + struct heading *heading_entered; + struct contents_entry *next; + CLASS_DEFINITION +} contents_entry; + +int headings_indexed = 0; +void IndexHeadings::index(OUTPUT_STREAM) { + #ifdef IF_MODULE + HTML_OPEN("p"); + WRITE("<b>"); PL::Bibliographic::contents_heading(OUT); WRITE("</b>"); + HTML_CLOSE("p"); + #endif + HTML_OPEN("p"); + WRITE("CONTENTS"); + HTML_CLOSE("p"); + IndexHeadings::index_heading_recursively(OUT, + NameResolution::pseudo_heading()->child_heading); + contents_entry *ce; + int min_positive_level = 10; + LOOP_OVER(ce, contents_entry) + if ((ce->heading_entered->level > 0) && + (ce->heading_entered->level < min_positive_level)) + min_positive_level = ce->heading_entered->level; + LOOP_OVER(ce, contents_entry) + Index this entry in the contents3.1; + + if (NUMBER_CREATED(contents_entry) == 1) { + HTML_OPEN("p"); WRITE("(This would look more like a contents page if the source text " + "were divided up into headings."); + Index::DocReferences::link(OUT, I"HEADINGS"); + WRITE(")"); + HTML_CLOSE("p"); + WRITE("\n"); + } +} +++
- The structure contents_entry is private to this section.
§3.1. Index this entry in the contents3.1 = +
+ ++ heading *h = ce->heading_entered; + indent to correct tab position + HTML_OPEN_WITH("ul", "class=\"leaders\""); WRITE("\n"); + int ind_used = h->indentation; + if (h->level == 0) ind_used = 1; + HTML_OPEN_WITH("li", "class=\"leaded indent%d\"", ind_used); + HTML_OPEN("span"); + if (h->level == 0) { + if (NUMBER_CREATED(contents_entry) == 1) + WRITE("Source text"); + else + WRITE("Preamble"); + } else { + write the text of the heading title + WRITE("%+W", Node::get_text(h->sentence_declaring)); + } + HTML_CLOSE("span"); + HTML_OPEN("span"); + contents_entry *next_ce = NEXT_OBJECT(ce, contents_entry); + if (h->level != 0) + while ((next_ce) && (next_ce->heading_entered->level > ce->heading_entered->level)) + next_ce = NEXT_OBJECT(next_ce, contents_entry); + int start_word = Wordings::first_wn(Node::get_text(ce->heading_entered->sentence_declaring)); + int end_word = (next_ce)?(Wordings::first_wn(Node::get_text(next_ce->heading_entered->sentence_declaring))) + : (TextFromFiles::last_lexed_word(FIRST_OBJECT(source_file))); + + int N = 0; + for (int i = start_word; i < end_word; i++) + N += TextFromFiles::word_count(i); + if (h->level > min_positive_level) HTML::begin_colour(OUT, I"808080"); + WRITE("%d words", N); + if (h->level > min_positive_level) HTML::end_colour(OUT); + place a link to the relevant line of the primary source text + Index::link_location(OUT, h->start_location); + HTML_CLOSE("span"); + HTML_CLOSE("li"); + HTML_CLOSE("ul"); + WRITE("\n"); + List all the objects and kinds created under the given heading, one tap stop deeper3.1.2; +++
- This code is used in §3.
§3.1.1. We index only headings of level 1 and up — so, not the pseudo-heading or the +File (0) ones — and which are not within any extensions — so, are in the +primary source text written by the user. +
+ ++void IndexHeadings::index_heading_recursively(OUTPUT_STREAM, heading *h) { + if (h == NULL) return; + int show_heading = TRUE; + heading *next = h->child_heading; + if (next == NULL) next = h->next_heading; + if ((next) && + (Extensions::corresponding_to(next->start_location.file_of_origin))) + next = NULL; + if (h->level == 0) { + show_heading = FALSE; + if ((headings_indexed == 0) && + ((next == NULL) || + (Wordings::first_wn(Node::get_text(next->sentence_declaring)) != + Wordings::first_wn(Node::get_text(h->sentence_declaring))))) + show_heading = TRUE; + } + if (Extensions::corresponding_to(h->start_location.file_of_origin)) + show_heading = FALSE; + if (show_heading) { + contents_entry *ce = CREATE(contents_entry); + ce->heading_entered = h; + headings_indexed++; + } + + IndexHeadings::index_heading_recursively(OUT, h->child_heading); + IndexHeadings::index_heading_recursively(OUT, h->next_heading); +} ++§3.1.2. We skip any objects or kinds without names (i.e., whose creator is null). +The rest appear in italic type, and without links to source text since this +in practice strews distractingly many orange berries across the page. +
+ +List all the objects and kinds created under the given heading, one tap stop deeper3.1.2 = +
+ ++ noun *nt; + int c = 0; + LOOP_OVER_NOUNS_UNDER(nt, h) { + wording W = Nouns::nominative(nt, FALSE); + if (Wordings::nonempty(W)) { + if (c++ == 0) { + HTML::open_indented_p(OUT, ind_used+1, "hanging"); + HTML::begin_colour(OUT, I"808080"); + } else WRITE(", "); + WRITE("<i>%+W</i>", W); + } + } + if (c > 0) { HTML::end_colour(OUT); HTML_CLOSE("p"); } +++
- This code is used in §3.1.
§4. The XML file. This is provided as a convenience to the application using Inform, which may want +to have a pull-down menu or similar gadget allowing the user to jump to a given +heading. This tells the interface where every heading is, thus saving it from +having to parse the source. +
+ +The property list contains a single dictionary, whose keys are the numbers +0, 1, 2, ..., \(n-1\), where there are \(n\) headings in all. (The pseudo-heading +is not included.) A special key, the only non-numerical one, called "Application +Version", contains the Inform build number in its usual form: "4Q34", for instance. +
+ ++void IndexHeadings::write_as_xml(void) { + text_stream xf_struct; text_stream *xf = &xf_struct; + filename *F = Task::xml_headings_file(); + if (STREAM_OPEN_TO_FILE(xf, F, UTF8_ENC) == FALSE) + Problems::fatal_on_file("Can't open headings file", F); + IndexHeadings::write_headings_as_xml_inner(xf); + STREAM_CLOSE(xf); +} + +void IndexHeadings::write_headings_as_xml_inner(OUTPUT_STREAM) { + heading *h; + Write DTD indication for XML headings file4.1; + WRITE("<plist version=\"1.0\"><dict>\n"); + INDENT; + WRITE("<key>Application Version</key><string>%B (build %B)</string>\n", FALSE, TRUE); + parse_node_tree *T = Task::syntax_tree(); + LOOP_OVER_LINKED_LIST(h, heading, T->headings->subordinates) { + WRITE("<key>%d</key><dict>\n", h->allocation_id); + INDENT; + Write the dictionary of properties for a single heading4.2; + OUTDENT; + WRITE("</dict>\n"); + } + OUTDENT; + WRITE("</dict></plist>\n"); +} ++§4.1. We use a convenient Apple DTD: +
+ +Write DTD indication for XML headings file4.1 = +
+ ++ WRITE("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + "<!DOCTYPE plist PUBLIC \"-Apple Computer//DTD PLIST 1.0//EN\" " + "\"http:www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"); +++
- This code is used in §4.
§4.2. Note that a level of 0, and a title of --, signifies a File (0) level +heading: external tools can probably ignore such records. Similarly, it is +unlikely that they will ever see a record without a "Filename" key — +this would mean a heading arising from text created internally within Inform, +which will only happen if someone has done something funny with .i6t files — +but should this arise then the best recourse is to ignore the heading. +
+ +Write the dictionary of properties for a single heading4.2 = +
+ ++ if (h->start_location.file_of_origin) + WRITE("<key>Filename</key><string>%f</string>\n", + TextFromFiles::get_filename(h->start_location.file_of_origin)); + WRITE("<key>Line</key><integer>%d</integer>\n", h->start_location.line_number); + if (Wordings::nonempty(h->heading_text)) + WRITE("<key>Title</key><string>%+W</string>\n", h->heading_text); + else + WRITE("<key>Title</key><string>--</string>\n"); + WRITE("<key>Level</key><integer>%d</integer>\n", h->level); + WRITE("<key>Indentation</key><integer>%d</integer>\n", h->indentation); +++ + +
- This code is used in §4.
+
Setting up the use of this module.
-§1. This section simoly sets up the module in ways expected by foundation, and +
§1. This section simoly sets up the module in ways expected by foundation, and contains no code of interest. The following constant exists only in tools which use this module:
define INFLECTIONS_MODULE TRUE-
§2. This module defines the following classes: +
§2. This module defines the following classes:
enum lexical_cluster_CLASS @@ -79,7 +85,7 @@ which use this module: DECLARE_CLASS(plural_dictionary_entry) DECLARE_CLASS(verb_conjugation)-
§3. Like all modules, this one must define a start and end function: +
§3. Like all modules, this one must define a start and end function:
enum CONSTRUCTED_PAST_PARTICIPLES_DA diff --git a/docs/inflections-module/2-ai.html b/docs/inflections-module/2-ai.html index 33dfedb39..6dbb459a1 100644 --- a/docs/inflections-module/2-ai.html +++ b/docs/inflections-module/2-ai.html @@ -32,7 +32,11 @@
To inflect "a" into "an", and so forth.
-§1. Here we take text such as "UNESCO document" and put an article in front, to +
§1. Here we take text such as "UNESCO document" and put an article in front, to get "a UNESCO document" (and not "an UNESCO document": these things are much trickier than they look).
diff --git a/docs/inflections-module/2-ga.html b/docs/inflections-module/2-ga.html index 6a398d5bb..49376d693 100644 --- a/docs/inflections-module/2-ga.html +++ b/docs/inflections-module/2-ga.html @@ -33,7 +33,11 @@To inflect adjectives into comparative and superlative forms.
-§1. In English, the comparative of an adjective can generally be formed by +
§1. In English, the comparative of an adjective can generally be formed by suffixing the inflected form with "than"; thus, "big" to "bigger than". The following does the suffixing:
@@ -69,7 +75,7 @@ The following does the suffixing: ... than§2. This is essentially a wrapper function for the trie <adjective-to-comparative>. +
§2. This is essentially a wrapper function for the trie <adjective-to-comparative>.
@@ -96,7 +102,7 @@ The following does the suffixing: return PW; }-
§3. This is essentially a wrapper function for the trie <adjective-to-superlative>. +
§3. This is essentially a wrapper function for the trie <adjective-to-superlative>.
@@ -119,7 +125,7 @@ The following does the suffixing: return PW; }-
§4. This is essentially a wrapper function for the trie <adjective-to-quiddity>. +
§4. This is essentially a wrapper function for the trie <adjective-to-quiddity>. There has to be a better term than "quiddity" for this grammatical concept (it is some sort of morphological nominalisation) but what I mean is the property of which the given adjective makes a comparison: for instance, diff --git a/docs/inflections-module/2-plr.html b/docs/inflections-module/2-plr.html index 9fcd118f5..718bf520d 100644 --- a/docs/inflections-module/2-plr.html +++ b/docs/inflections-module/2-plr.html @@ -40,7 +40,11 @@ function togglePopup(material_id) {
§1. Dictionary. A modest dictionary of plurals is maintained to allow the user to record +
§1. Dictionary. A modest dictionary of plurals is maintained to allow the user to record better plurals than the ones we would make ourselves. This assumes that a plural can be constructed without knowledge of context, but that works in almost all cases. (Arguably "dwarf" should pluralise to "dwarfs" when @@ -85,7 +91,7 @@ to be hoped that few works of IF will contain both at once.) } plural_dictionary_entry;
§2. Note that we are entirely allowed to register a new plural for a phrase +
§2. Note that we are entirely allowed to register a new plural for a phrase which already has a plural in the dictionary, even for the same language, which is why we do not trouble to search the existing dictionary here.
@@ -99,7 +105,7 @@ which is why we do not trouble to search the existing dictionary here. LOGIF(CONSTRUCTED_PLURALS, "[Registering plural of %W as %W]\n", S, P); } -§3. Searching the plural dictionary. The following routine can either be called once only — in which case it +
§3. Searching the plural dictionary. The following routine can either be called once only — in which case it yields up the best known plural for the phrase — or iteratively, in which case it serves up all known plurals of the given phrase, starting with the best (the earliest defined in the text, if any plural for this phrase has @@ -131,7 +137,7 @@ one not found in the dictionary). return NULL; } -
§3.1. When the dictionary fails us, we use lexical rewriting to construct plurals +
§3.1. When the dictionary fails us, we use lexical rewriting to construct plurals of phrases found only in the singular in the source. For instance, if the designer says that "A wicker basket is a kind of container" then Inform will need to recognise not only "wicker basket" but also "wicker baskets", a @@ -163,7 +169,7 @@ it can be rebuilt quickly whenever needed again. LOGIF(CONSTRUCTED_PLURALS, "[Constructing plural of %W as %W]\n", W, *PW);
§4. The pluralizing trie. The following takes a single word, assumes it to be a noun which meaningfully +
§4. The pluralizing trie. The following takes a single word, assumes it to be a noun which meaningfully has a plural, and modifies it to the plural form.
diff --git a/docs/inflections-module/2-pp.html b/docs/inflections-module/2-pp.html index d1825bfe5..a6c1bd6e9 100644 --- a/docs/inflections-module/2-pp.html +++ b/docs/inflections-module/2-pp.html @@ -40,7 +40,11 @@ function togglePopup(material_id) {§1. Constructing past participles. For example, "turning away" to "turned away". +
§1. Constructing past participles. For example, "turning away" to "turned away".
@@ -95,7 +101,7 @@ function togglePopup(material_id) {
return PLW;
}
-§2. The pasturising trie. This is the process of turning a present participle, like "turning", to +
§2. The pasturising trie. This is the process of turning a present participle, like "turning", to a past participle, like "turned". Note that it returns NULL if it fails to recognise the word in question as a present participle; this is needed above. It expects only a single word. diff --git a/docs/inflections-module/2-tai.html b/docs/inflections-module/2-tai.html index 58253b7ed..9ecc53060 100644 --- a/docs/inflections-module/2-tai.html +++ b/docs/inflections-module/2-tai.html @@ -40,7 +40,11 @@ function togglePopup(material_id) {
§1. Suffix inflections. The following inflects the ending of the supplied text. It does so by +
§1. Suffix inflections. The following inflects the ending of the supplied text. It does so by running the text through an avinue: see Tries and Avinues (in foundation), which is where the asterisk notation is handled.
@@ -79,7 +85,7 @@ which is where the asterisk notation is handled. return Inflect::follow_suffix_instruction(OUT, from, result); } -§2. The foundation code returns a result which may be null, if no match +
§2. The foundation code returns a result which may be null, if no match was found. In that event, we leave the text unchanged, just as if the result had been 0 — meaning "change nothing".
@@ -96,7 +102,7 @@ had been 0 &mda return success; } -§2.1. In general the result either has an initial digit, in which case it removes +
§2.1. In general the result either has an initial digit, in which case it removes that many terminal letters, or does not, in which case it removes all the letters (and thus the result text replaces the original entirely). The special character + after a digit means "duplicate the last character"; @@ -125,7 +131,7 @@ add "ize". }
§2.2. Write the output, interpreting plus signs as word breaks2.2 = +
§2.2. Write the output, interpreting plus signs as word breaks2.2 =
@@ -134,7 +140,7 @@ add "ize". else PUT(Str::get(pos));
§3. General tries. Here we take a word assemblage and apply suffix inflection to the first word +
§3. General tries. Here we take a word assemblage and apply suffix inflection to the first word alone, preserving the rest: for example, "make the tea" might become "making the tea". However, if the result of this inflection contains any + signs, those once again become word boundaries. diff --git a/docs/inflections-module/3-dcl.html b/docs/inflections-module/3-dcl.html index 9c36ac6fe..318342e11 100644 --- a/docs/inflections-module/3-dcl.html +++ b/docs/inflections-module/3-dcl.html @@ -54,7 +54,11 @@ MathJax = {
Declensions are sets of inflected variations of a common stem according to grammatical case.
-§1. The traditional term "declension" refers to the set of inflected forms of a +
§1. The traditional term "declension" refers to the set of inflected forms of a
word which does not serve as a verb: nouns, adjectives and pronouns all have
"declensions". These forms generally vary according to gender, number and
also "case", which expresses context.
@@ -102,7 +108,7 @@ taken care of by what are less elegantly called } declension;
§2. Cases in a language are itemised in the special nonterminal <grammatical-case-names>:
+ §2. Cases in a language are itemised in the special nonterminal <grammatical-case-names>:
§3. The following is useful for debugging:
+ §3. The following is useful for debugging:
§4. And this function extracts the right form for a given case c:
+ §4. And this function extracts the right form for a given case c:
§5. So much for using declensions; now to generate them. They are inflected from
+ §5. So much for using declensions; now to generate them. They are inflected from
the stem by special Preform nonterminals:
§5.1. If a word comes from a given file and line number in the source text, then
+ §5.1. If a word comes from a given file and line number in the source text, then
we will say that so does any inflected form of it:
§6. For the format of the table expressed by the nonterminal nt, see
+ §6. For the format of the table expressed by the nonterminal nt, see
What This Module Does.
§6.1. Decline according to this row in declension NT6.1 =
+ §6.1. Decline according to this row in declension NT6.1 =
§7. This is for the two-token form of row, gender table:
+ §7. This is for the two-token form of row, gender table:
§8. And this is for the three-token form of row, gender grouper table:
+ §8. And this is for the three-token form of row, gender grouper table:
§8.1. Set the group number8.1 =
+ §8.1. Set the group number8.1 =
§9. We have now found the actual declension table NT; if there are \(N\) cases
+ §9. We have now found the actual declension table NT; if there are \(N\) cases
in the language, there will be \(2N\) productions in this table, each of which
consists of a single word giving the rewriting instruction to use.
§1. Constants. First, we support three genders:
+ §1. Constants. First, we support three genders:
§2. There are six "persons". The sequence corresponds to the defined constants
+ §2. There are six "persons". The sequence corresponds to the defined constants
in the English Language extension, which we assume will be followed by other
languages.
§6. 25 cases sounds like plenty, but some languages are pretty scary this
+ §6. 25 cases sounds like plenty, but some languages are pretty scary this
way: Hungarian has 18. We only require two cases to exist, the nominative
and accusative, which are required to be cases 0 and 1.
§7. There are at least five tenses, the first four of which are used by Inform
+ §7. There are at least five tenses, the first four of which are used by Inform
in English. Some languages can use optional extras; French, for example, uses
tense 5 for the past historic.
§8. Packed references. The following enables even a 32-bit integer to hold an ID reference in the
+ §8. Packed references. The following enables even a 32-bit integer to hold an ID reference in the
range 0 to 128K, together with any combination of gender, person, number,
voice, case, tense, and sense. This could be optimised further, exploiting
for example that no grammatical concept ever simultaneously has voice and
@@ -161,7 +167,7 @@ values, and at present Preform return values are define lcon_ti int
- §9. And here's how we pack everything in:
+ §9. And here's how we pack everything in:
§11. Axes. We can think of a combination of the seven grammatical attributes above as
+ §11. Axes. We can think of a combination of the seven grammatical attributes above as
being like a position in seven-dimensional space, with each being a coordinate
on one of these sevem axes.
§12. And desiderata in the following function is exactly that sort of set.
+ §12. And desiderata in the following function is exactly that sort of set.
§13. The parameter axis in the following must, on the other hand, be a pure power
+ §13. The parameter axis in the following must, on the other hand, be a pure power
of 2, that is, it must be a single *_LCW value.
§14. Writing sets. Suppose we have a list of lcon_ti constants and want to print out their
+ §14. Writing sets. Suppose we have a list of lcon_ti constants and want to print out their
grammatical attributes. If we do that in the obvious way, by calling
Lcon::write on each of the constants in turn, we tend to get a list
of tiresome length. We want to abbreviate so that, e.g.,
@@ -408,7 +414,7 @@ code is really only needed for printing tidy debugging and test logs, so
it's probably not worth any further effort.
§15. To avoid the C extension for variable-length arrays, and to avoid memory
+ §15. To avoid the C extension for variable-length arrays, and to avoid memory
allocation, we're simply going to make our working arrays quite large. But
this is fine — the function is for printing, so it's not used much.
§16. We are going to aggregate items in the list into numbered cuboids. The
+ §16. We are going to aggregate items in the list into numbered cuboids. The
strategy is simple: start with the first item; make the largest-volume cuboid
inside our set which contains that item; then take the next item not already
included, and continue.
@@ -434,7 +440,7 @@ included, and continue.
}
}
- §16.1. Note that there is always at least one cuboid containing the item \(i\) —
+ §16.1. Note that there is always at least one cuboid containing the item \(i\) —
the \(1\times 1\times 1\times 1\times 1\times 1\times 1\) cuboid containing
just that one point. So the following certainly finds something. The
elongated_sides value accumulates the set of axis directions in which
@@ -452,7 +458,7 @@ the cuboid is longer than 1.
Write the resulting cuboid out16.1.2;
§16.1.1. So now we are at item \(i\). We repeatedly do the following: try to expand
+ §16.1.1. So now we are at item \(i\). We repeatedly do the following: try to expand
the cuboid into each of the seven axis directions, then choose the one
which expands it the most. We stop when no further expansion is possible.
§16.1.1.1. We start with the current cuboid. The enlarged array will be the same as
+ §16.1.1.1. We start with the current cuboid. The enlarged array will be the same as
the cuboid_number array except that some additional points x for which
cuboid_number[x] is \(-1\) — i.e., points not yet placed in any cuboid —
will have enlarged[x] set to cuboid — i.e., will be placed in the current
@@ -504,7 +510,7 @@ coordinates are the same as those for \(i\).
if (allow == FALSE) elongation = 0;
§16.1.1.1.1. For example, if \(i = (2, 1, 0, 0, 0, 0, 0)\) and \(d\) is the second axis, then
+ §16.1.1.1.1. For example, if \(i = (2, 1, 0, 0, 0, 0, 0)\) and \(d\) is the second axis, then
one variation would be 1 (the \(d\) coordinate of \(i\) itself) and if, say,
\((2, 7, 0, 0, 0, 0, 0)\) were an unplaced point then 7 would also be a variation.
§16.1.1.1.2. Now suppose our variation set is indeed \(\lbrace 1, 7\rbrace\), as in the
+ §16.1.1.1.2. Now suppose our variation set is indeed \(\lbrace 1, 7\rbrace\), as in the
above example. The idea is that we will use this set as the new side for the
cuboid. We know that we can vary \(i\) by these values; that's how they were
found. But we must also check that we can vary every other point currently
@@ -550,7 +556,7 @@ in the cuboid in the same way. If we can't, the attempt fails.
}
§16.1.2. And finally, but also not quite trivially, printing out the cuboid. We
+ §16.1.2. And finally, but also not quite trivially, printing out the cuboid. We
handle the elongated sides differently from the unelongated ones, which
are relegated to the Lcon::write call at the end. Note that this prints
nothing if remainder is zero.
diff --git a/docs/inflections-module/3-lc2.html b/docs/inflections-module/3-lc2.html
index 9b46d6152..c767f375c 100644
--- a/docs/inflections-module/3-lc2.html
+++ b/docs/inflections-module/3-lc2.html
@@ -40,7 +40,11 @@ function togglePopup(material_id) {
§1. Cluster. A cluster is a linked list of declensions, annotated with lingistic roles. For
+ §1. Cluster. A cluster is a linked list of declensions, annotated with lingistic roles. For
example, the cluster of forms for the common noun "man" might be:
§3. The following can add either a single form, or a form and its plural(s):
+ §3. The following can add either a single form, or a form and its plural(s):
§3.1. The following makes all possible plurals and registers those too. (Note
+ §3.1. The following makes all possible plurals and registers those too. (Note
that every instance gets a plural form: even something palpably unique, like
"the Koh-i-Noor diamond".) The plural dictionary supports multiple plurals,
so there may be any number of forms registered: for instance, the kind
@@ -156,7 +162,7 @@ so there may be any number of forms registered: for instance, the kind
} while (pde);
§4. The following is more suited to adjectives, or to words which are used
+ §4. The following is more suited to adjectives, or to words which are used
adjectivally, such as past participles in French. This time we generate all
possible gender and number agreements.
§4.1. We use tries to modify the base text, which is taken to be the neuter
+ §4.1. We use tries to modify the base text, which is taken to be the neuter
singular form, into the other five forms.
-
@@ -121,7 +127,7 @@ taken care of by what are less elegantly called return -1;
}
-
@@ -150,7 +156,7 @@ taken care of by what are less elegantly called internal_error("<grammatical-case-names> not provided for this language");
}
-
@@ -160,7 +166,7 @@ taken care of by what are less elegantly called return D->wording_cased[c];
}
-
-
@@ -243,7 +249,7 @@ we will say that so does any inflected form of it:
if (found) return D;
-
@@ -284,7 +290,7 @@ we will say that so does any inflected form of it:
return D;
}
-
@@ -319,7 +325,7 @@ we will say that so does any inflected form of it:
return D;
}
-
@@ -335,7 +341,7 @@ we will say that so does any inflected form of it:
}
-
diff --git a/docs/inflections-module/3-lc.html b/docs/inflections-module/3-lc.html
index cae5d6522..fc3f8464a 100644
--- a/docs/inflections-module/3-lc.html
+++ b/docs/inflections-module/3-lc.html
@@ -54,7 +54,11 @@ MathJax = {
Inform7 Modules
Services
@@ -82,7 +88,7 @@ MathJax = {
-define NO_KNOWN_GENDERS 3
@@ -90,7 +96,7 @@ MathJax = {
define MASCULINE_GENDER 2
define FEMININE_GENDER 3
-define NO_KNOWN_NUMBERS 2
define SINGULAR_NUMBER 0
define PLURAL_NUMBER 1
-
define NO_KNOWN_VOICES 2
define ACTIVE_VOICE 0
define PASSIVE_VOICE 1
-
define NO_KNOWN_SENSES 2
define POSITIVE_SENSE 0
define NEGATIVE_SENSE 1
-
@@ -268,7 +274,7 @@ values, and at present Preform return values are }
}
-
+
int Lcon::same_but_for_gender(lcon_ti A, lcon_ti B) {
@@ -306,7 +312,7 @@ values, and at present Preform return values are return FALSE;
}
-
@@ -337,7 +343,7 @@ sum of these can represent a set of things we're interested in:
}
}
-
-
-
-
-
-Inform7 Modules
Services
@@ -68,7 +74,7 @@ function togglePopup(material_id) {
-
-
@@ -109,7 +115,7 @@ which it would be fairly easy to convert our
return forms;
}
-
@@ -131,7 +137,7 @@ which it would be fairly easy to convert our
return L;
}
-
-
§4.1.1. Not much of a pipeline, really: we start with the base case and work +
§4.1.1. Not much of a pipeline, really: we start with the base case and work through one or two tries.
@@ -231,7 +237,7 @@ through one or two tries. FW = WordAssemblages::to_wording(&wa);§5. Plural fixing. Less elegantly, we can force the plural of a form in a cluster to a given +
§5. Plural fixing. Less elegantly, we can force the plural of a form in a cluster to a given fixed text, overwriting it if it's already there. In practice this is done only when the built-in kinds are being given plural forms; some of these (those for kind constructors with optional wordings) have a peculiar format, @@ -250,7 +256,7 @@ and wouldn't pass through the pluralising tries intact. Clusters::add(cl, W, NULL, NEUTER_GENDER, PLURAL_NUMBER, FALSE); } -
§6. Searching declensions. These are always quite small, so there's no need for any efficient device +
§6. Searching declensions. These are always quite small, so there's no need for any efficient device to search them.
@@ -269,7 +275,7 @@ or plural): return EMPTY_WORDING; } -§7. The following variant finds the earliest form in the language of play, +
§7. The following variant finds the earliest form in the language of play, falling back on English if there's none registered:
@@ -286,7 +292,7 @@ falling back on English if there's none registered: return Clusters::get_form(cl, plural_flag); } -§8. A more specific search, which can optionally test for number and gender. +
§8. A more specific search, which can optionally test for number and gender.
@@ -305,7 +311,7 @@ falling back on English if there's none registered: return in->declined.within_language; }-
diff --git a/docs/inflections-module/3-vc.html b/docs/inflections-module/3-vc.html
index 39d026cf4..4dca46ecb 100644
--- a/docs/inflections-module/3-vc.html
+++ b/docs/inflections-module/3-vc.html
@@ -41,7 +41,11 @@ function togglePopup(material_id) {
§1. We will need to turn a base form of a verb — in English, this is always the +
§1. We will need to turn a base form of a verb — in English, this is always the infinitive — into up to 123 variants; we manage this with quite an extensive data structure. There will typically only be a few dozen fully conjugated verbs in any source text, though, so the memory cost isn't too extreme. For @@ -104,7 +110,7 @@ English it looks wasteful, since so many forms are the same, but for French } verb_tabulation;
§2. Finding. Most of the time, conjugations can be identified by their infinitives: +
§2. Finding. Most of the time, conjugations can be identified by their infinitives:
@@ -116,7 +122,7 @@ English it looks wasteful, since so many forms are the same, but for French return NULL; }-
§3. But in fact multiple conjugations can be given with the same infinitive... +
§3. But in fact multiple conjugations can be given with the same infinitive...
@@ -129,7 +135,7 @@ English it looks wasteful, since so many forms are the same, but for French return NULL; }-
§4. ...and those may or may not be identical, so a more detailed test is: +
§4. ...and those may or may not be identical, so a more detailed test is:
@@ -158,7 +164,7 @@ English it looks wasteful, since so many forms are the same, but for French return FALSE; }-
§5. The following prints out a tidy form of a verb conjugation table: +
§5. The following prints out a tidy form of a verb conjugation table:
@@ -195,7 +201,7 @@ English it looks wasteful, since so many forms are the same, but for French &(vc->tabulations[PASSIVE_VOICE].to_be_auxiliary)); }-
§6. Making conjugations. The following will make more sense if read alongside the examples in "English +
§6. Making conjugations. The following will make more sense if read alongside the examples in "English Inflections", which explains the format in full.
@@ -230,7 +236,7 @@ conjugation to another. Use the verb forms and the tabulation to make the conjugation6.3; } -§6.1. Initialise all verb forms to the base text6.1 = +
§6.1. Initialise all verb forms to the base text6.1 =
@@ -238,7 +244,7 @@ conjugation to another. for (k=0; k<=MAX_FORM_TYPES; k++) verb_forms[k] = base_text;
§6.2. This feature is provided so that English verb definitions can override the +
§6.2. This feature is provided so that English verb definitions can override the usual grammatical rules, which enables us to create new irregular verbs. For example, Inform will by default make the past participle "blended" out of the verb "to blend", but a definition like @@ -266,7 +272,7 @@ anybody else try this one on.) verb_forms[k] = overrides[k];
§6.3. Use the verb forms and the tabulation to make the conjugation6.3 = +
§6.3. Use the verb forms and the tabulation to make the conjugation6.3 =
@@ -291,7 +297,7 @@ anybody else try this one on.) return vc;
§6.3.1. Start by blanking out all the passive and active slots6.3.1 = +
§6.3.1. Start by blanking out all the passive and active slots6.3.1 =
@@ -308,7 +314,7 @@ anybody else try this one on.)
}
§6.3.2. A tabulation is a sort of program laying out what to put in which slots, +
§6.3.2. A tabulation is a sort of program laying out what to put in which slots, active or passive. Each production is a step in this program, and it consists of a "selector" followed by a "line". For example, the production:
@@ -340,7 +346,7 @@ rest. (The selector is always just a single token.) }§6.3.2.1. Apply the given tabulation line to the slots selected6.3.2.1 = +
§6.3.2.1. Apply the given tabulation line to the slots selected6.3.2.1 =
@@ -363,7 +369,7 @@ rest. (The selector is always just a single token.)
}
§6.3.2.1.1. Apply to the active voice6.3.2.1.1 = +
§6.3.2.1.1. Apply to the active voice6.3.2.1.1 =
@@ -372,7 +378,7 @@ rest. (The selector is always just a single token.) &(vc->tabulations[ACTIVE_VOICE].modal_auxiliary_usage[tense][sense][p][n]));
§6.3.2.1.2. Apply to the passive voice6.3.2.1.2 = +
§6.3.2.1.2. Apply to the passive voice6.3.2.1.2 =
@@ -381,7 +387,7 @@ rest. (The selector is always just a single token.) &(vc->tabulations[PASSIVE_VOICE].modal_auxiliary_usage[tense][sense][p][n]));
§6.3.2.1.3. The selector tells us which tense(s), sense(s) and voice(s) to apply the +
§6.3.2.1.3. The selector tells us which tense(s), sense(s) and voice(s) to apply the line to; a3, for example, means active voice, tense 3, in both positive and negative senses.
@@ -411,7 +417,7 @@ and negative senses. }§7. This routine is really an interloper from core. It provides the run-time +
§7. This routine is really an interloper from core. It provides the run-time values representing verbs in story files compiled by Inform.
@@ -429,7 +435,7 @@ values representing verbs in story files compiled by Inform. vc->vc_iname = Hierarchy::make_iname_in(MODAL_CONJUGATION_FN_HL, R); } else { package_request *R = - VerbsAtRunTime::package(vc->vc_conjugates, vc->where_vc_created); + RTVerbs::package(vc->vc_conjugates, vc->where_vc_created); TEMPORARY_TEXT(ANT) WRITE_TO(ANT, "to %A", &(vc->infinitive)); Hierarchy::markup(R, VERB_NAME_HMD, ANT); @@ -441,7 +447,7 @@ values representing verbs in story files compiled by Inform. } #endif -§8. Follow instructions. That completes the top level of the routine, but it depended on two major +
§8. Follow instructions. That completes the top level of the routine, but it depended on two major sub-steps: a preliminary pass called Conjugation::follow_instructions and a routine to deal with the final results called Conjugation::merge.
@@ -474,7 +480,7 @@ participles and then chooses the tabulation return tabulation_nt; } -§8.1. Pattern match on the base text to decide which conjugation to use8.1 = +
§8.1. Pattern match on the base text to decide which conjugation to use8.1 =
@@ -493,7 +499,7 @@ participles and then chooses the tabulation }
§8.1.1. Each production in this language's <verb-conjugation-instructions> grammar +
§8.1.1. Each production in this language's <verb-conjugation-instructions> grammar consists of a (possibly empty) pattern to match, followed by the name of a nonterminal to use as the conjugation if it matches. For example, in
@@ -540,7 +546,7 @@ infinitive" form is set to the part matched by "malformed line");§8.1.1.1. Try to match the base text against the pattern part of the production8.1.1.1 = +
§8.1.1.1. Try to match the base text against the pattern part of the production8.1.1.1 =
@@ -563,7 +569,7 @@ infinitive" form is set to the part matched by }
§8.2. In a conjugation, productions have two possible forms: either just a single +
§8.2. In a conjugation, productions have two possible forms: either just a single nonterminal, which usually identifies the tabulation, or a number followed by some tokens.
@@ -604,7 +610,7 @@ tokens. }§8.2.1. So here we check the more interesting case. The number identifies which +
§8.2.1. So here we check the more interesting case. The number identifies which verb form to set, and the token which follows it provides the content. For example:
@@ -636,7 +642,7 @@ example: } else malformed = TRUE;§9. Merge verb material. Now the final main step. row points to a list of ptokens containing text, +
§9. Merge verb material. Now the final main step. row points to a list of ptokens containing text, and we have to copy that text into a word assemblage and return it.
@@ -683,7 +689,7 @@ a different verb's conjugation "lifting". return Conjugation::shorten_with_contractions(wa); } -§9.1. To take the easiest case first. If we read a word like trailing, we simply +
§9.1. To take the easiest case first. If we read a word like trailing, we simply add it. But note that Conjugation::expand_with_endings has other tricks up its sleeve, and might expand 3+ed to "trailed".
@@ -699,7 +705,7 @@ and might expand 3+ed< }§9.2. If we read a nonterminal name, such as <fr-vivre-present>, then this must +
§9.2. If we read a nonterminal name, such as <fr-vivre-present>, then this must be a grammar with six productions, giving the text to use for the six different persons. We consult person and extract the relevant text. For example, if person is 3, we extract "vivons". Note that this material is itself read @@ -728,7 +734,7 @@ make use of the same fancy features we're allowing here. }
§9.3. A number followed by a verb in brackets, like so: +
§9.3. A number followed by a verb in brackets, like so:
@@ -751,7 +757,7 @@ on the next iteration.
}
§9.4. And now the lift takes place. We might at this point have verb_form_to_lift +
§9.4. And now the lift takes place. We might at this point have verb_form_to_lift set, in which case we should lift a verb form, or we might not, in which case we should lift an ordinary usage, such as third-person singular in a particular tense. A lift can optionally change tense or sense: for example, @@ -804,7 +810,7 @@ make use of the numbered verb forms if we want it to. }
§9.5. A plus-plus-digit indicates auxiliary modal usage9.5 = +
§9.5. A plus-plus-digit indicates auxiliary modal usage9.5 =
@@ -820,7 +826,7 @@ make use of the numbered verb forms if we want it to.
}
§10. Whenever we read a single word, it passes through the following. A word +
§10. Whenever we read a single word, it passes through the following. A word
like "fish" will pass through unchanged; a number like "7" will convert
to verb form 7 in the current verb (for example, 2 becomes the present
participle); a plus sign joins two pieces together; and a tilde is a tie,
@@ -857,7 +863,7 @@ joining but with a space. Thus return WordAssemblages::lit_1(ve);
}
- §11. The final step in merging verb material is to pass the result through the
+ §11. The final step in merging verb material is to pass the result through the
following, which attends to contractions. (Most of the time it does nothing.)
For example, suppose we have:
§11.1. We contract if the following word starts with a (possibly accented) vowel,
+ §11.1. We contract if the following word starts with a (possibly accented) vowel,
and we construe "y" (but not "h" or "w") as a vowel.
§12. Parsing verb form numbers. These are easy: they're just written as arabic numbers.
+ §12. Parsing verb form numbers. These are easy: they're just written as arabic numbers.
§13. Parsing tense and sense indicators. These are a little harder: for example, t2+ or t3.
+ §13. Parsing tense and sense indicators. These are a little harder: for example, t2+ or t3.
§15. In the following, for example, "breveter" as ve would match "-veter"
+ §15. In the following, for example, "breveter" as ve would match "-veter"
as pattern.
§17. Testing. Similarly, the following helps translators by giving them unit tests for their
+ §17. Testing. Similarly, the following helps translators by giving them unit tests for their
conjugations:
§18. This is for testing English only; it helps with the test suite cases derived
+ §18. This is for testing English only; it helps with the test suite cases derived
from our dictionary of 14,000 or so present and past participles.
§19. As noted above, these nonterminals have no parsing function, and are used only
+ §19. As noted above, these nonterminals have no parsing function, and are used only
as markers in verb conjugations.
To keep track of what the default natural language is. §1. The following mechanism may become more sophisticated later.
+ §1. The following mechanism may become more sophisticated later.
§1. Noun inflections. The following trie looks at the start of a word, which we assume to be a
+ §1. Noun inflections. The following trie looks at the start of a word, which we assume to be a
noun, and decides whether to use the indefinite article "a" or "an".
This is much more complicated than simply looking for a vowel as the first
letter, as people often think until they try a few cases.
@@ -78,7 +84,7 @@ dictionary and the "Official Scrabble Wordlist".
<en-trie-indef-c>
§2. Exceptions to the exceptions:
+ §2. Exceptions to the exceptions:
§4. And finally the basic rules:
+ §4. And finally the basic rules:
§5. Plural inflections. The following takes a single word, assumes it to be a noun which meaningfully
+ §5. Plural inflections. The following takes a single word, assumes it to be a noun which meaningfully
has a plural, and modifies it to the plural form. ("Golf" is a noun which
doesn't sensibly have a plural; the algorithm here would return "golves".)
§6. See Conway's table A.2. The following nouns, mostly names of kinds of animal,
+ §6. See Conway's table A.2. The following nouns, mostly names of kinds of animal,
have the same plural as singular form: for example, chamois, salmon, goldfish.
§7. We may as well pluralise pronouns while we're at it.
+ §7. We may as well pluralise pronouns while we're at it.
§8. We now reach Conway step 4. These are irregular plurals mostly coming
+ §8. We now reach Conway step 4. These are irregular plurals mostly coming
from archaisms.
§9. Step 5. Now we reach a batch of irregular but fairly general inflected
+ §9. Step 5. Now we reach a batch of irregular but fairly general inflected
endings; for example, protozoon to protozoa, or metamorphosis to metamorphoses.
Note that we differ from Conway in pluralizing blouse as blouses, not blice.
§10. Step 6. These are inflections from Latin and Greek which have survived
+ §10. Step 6. These are inflections from Latin and Greek which have survived
into modern English:
§11. Step 11a. (We're not implementing Conway's steps in sequence: see below.)
+ §11. Step 11a. (We're not implementing Conway's steps in sequence: see below.)
These -o endings are mostly loan words from Romance languages whose original
inflections are assimilated.
§12. Conway steps 8 to 11. These are regular inflections depending only on
+ §12. Conway steps 8 to 11. These are regular inflections depending only on
word endings.
§13. Lastly, the fallback if none of the above cases match: append an -s, of
+ §13. Lastly, the fallback if none of the above cases match: append an -s, of
course.
§14. Verb inflections. "Le verbe est l'âme d'une langue" (attributed to Georges Duhamel). And the
+ §14. Verb inflections. "Le verbe est l'âme d'une langue" (attributed to Georges Duhamel). And the
care of the soul is, of course, complicated. For example, the source text can
say something like this:
§15. This gives us a certain amount of choice. What exactly is "too irregular"?
+ §15. This gives us a certain amount of choice. What exactly is "too irregular"?
In French, are all -er, -ir, and -re verbs "regular"? (Consider "aller",
for example.) In English, it's possible to say that there are seven or so
classes of verbs, all regular by their own standards; but most people say
@@ -634,7 +640,7 @@ example, to set has just three distinct forms — to set, he sets, he set, h
had set, setting.
§16. Form types are numbered from 0 up to, potentially, a constant
+ §16. Form types are numbered from 0 up to, potentially, a constant
called MAX_FORM_TYPES. (This is so large that there shouldn't ever be need
for more.) Form type 0 is always the original text, and is used as the basis
from which the others are generated. For English verbs Inform always sets form
@@ -661,7 +667,7 @@ each language. English needs two: the present (5) and past (6) forms.
define ADJOINT_INFINITIVE_FORM_TYPE 4
define MAX_FORM_TYPES 123
- §17. We're now ready to write the <verb-conjugation-instructions>. This is
+ §17. We're now ready to write the <verb-conjugation-instructions>. This is
a block which looks at the infinitive of the verb and decides which of
several conjugations should be used. Badly irregular verbs get
conjugations of their own, and others are grouped together. In French,
@@ -687,7 +693,7 @@ least one line, and the best way to ensure that is to finish up with
- §18. The instructions for English are quite concise, except for the presence
+ §18. The instructions for English are quite concise, except for the presence
of the awkward contracted informal forms of verbs. (These aren't used in
Inform assertion sentences, but are needed for text substitutions.)
§19. We will start with two auxiliary verbs, that is, verbs used to construct
+ §19. We will start with two auxiliary verbs, that is, verbs used to construct
forms of other verbs. The first is "to have"; as we'll see, English uses
this to construct perfect tenses:
§20. Tabulations give instructions for how to construct 120 possible versions
+ §20. Tabulations give instructions for how to construct 120 possible versions
of the verb. These are divided up first into active and passive "voices":
§21. And this is an example of splitting into cases for the six persons,
+ §21. And this is an example of splitting into cases for the six persons,
1PS, 2PS, 3PS, 1PP, 2PP, 3PP. I have, you have, he has, we have, you have,
they have. (This is more excitingly varied in other languages, of course.)
§22. Next we have "to do", which is like "to have" in being fairly regular,
+ §22. Next we have "to do", which is like "to have" in being fairly regular,
as irregular verbs go. But we treat this as a special case because, again,
we're going to need as an auxiliary verb when forming negatives ("Peter
does not wear the hat" — note the "does not"). But this time we give
@@ -999,7 +1005,7 @@ may have to revisit this for languages other than English.)
do | do | does | do | do | do
§23. Regular English verbs, then, look like so. We will, for the first time,
+ §23. Regular English verbs, then, look like so. We will, for the first time,
make heavy use of our numbered verb forms: for example, for the verb
"to take", they would be "take" (1), "taking" (2), "taken" (3),
"takes" (5) and "took" (6). We start with the infinitive ("take")
@@ -1031,7 +1037,7 @@ to "grabs onto", "grabbing onto" and so on.
<regular-verb-tabulation>
§24. Here we see our auxiliary verbs in use. For the negated present tense,
+ §24. Here we see our auxiliary verbs in use. For the negated present tense,
"Peter does not carry the ball"; for the negated past tense, "Peter did
not carry the ball" — in both cases, this is "to do" plus the infinitive
"take". For the perfect tenses, "to have" plus the past participle —
@@ -1055,7 +1061,7 @@ a bequest".)
p* 3 by
§25. This looks odd, but what it says is that the present tense of a regular
+ §25. This looks odd, but what it says is that the present tense of a regular
English verb is always the infinitive (I take, you take, we take, and so on)
except for third person singular (he takes), which is different. (It's usually
what the plural of the infinitive would be if the infinitive were a noun,
@@ -1067,7 +1073,7 @@ as we'll see.)
1 | 1 | 5 | 1 | 1 | 1
§26. Now for our most irregular verb: "to be".
+ §26. Now for our most irregular verb: "to be".
§27. Except for tense formation (Peter "will" take the ball), the most common
+ §27. Except for tense formation (Peter "will" take the ball), the most common
modal verb which can be used in Inform source text is "can". For example:
§28. Inform has only a simple understanding of what "can" means, so it doesn't
+ §28. Inform has only a simple understanding of what "can" means, so it doesn't
allow the source text to use "can" in combination with arbitrary verbs.
Instead, each legal combination has to be declared explicitly:
§29. The following handles the other English modal verbs ("might", "should"
+ §29. The following handles the other English modal verbs ("might", "should"
and so on) surprisingly easily. The notation ++1 means that the verb
being modified should appear in verb form 1, and so on: for example,
"might not lead" as "might not" plus form 1 of "to lead", i.e., "lead".
@@ -1200,7 +1206,7 @@ being modified should appear in verb form 1, and so on: for example,
a5- 4 not ++1
§30. That completes our basic kit of verbs nicely. What's left is used only
+ §30. That completes our basic kit of verbs nicely. What's left is used only
for generating text at run-time — for printing adaptive messages, that is;
none of these oddball exceptional cases is otherwise used as a verb in
Inform source text. None of them has any meaning to Inform.
@@ -1262,7 +1268,7 @@ dialects — and we aren't even going to try to cope with that.
wasn't | weren't | wasn't | weren't | weren't | weren't
§31. And now "to 've", the contracted form of "to have". A subtle dialect
+ §31. And now "to 've", the contracted form of "to have". A subtle dialect
point here concerns the negated present tense:
§32. Now we come to "aren't", a negated form of "to be", but where the
+ §32. Now we come to "aren't", a negated form of "to be", but where the
contraction occurs between the verb and the "not" rather than between
the subject and the verb.
§33. And finally: the contracted informal negatives of various modal verbs which
+ §33. And finally: the contracted informal negatives of various modal verbs which
it's useful to be able to print, like the "can't" in
§34. Together with special rules for can't, which is inevitably slightly different:
+ §34. Together with special rules for can't, which is inevitably slightly different:
§35. We have special tries just to list the forms of the cases we will
+ §35. We have special tries just to list the forms of the cases we will
deal with. Tries can do fancy things (see below), but here they act just as
a look-up table: for example, "won't" has present "won't", past
"wouldn't" and future "won't".
@@ -1450,7 +1456,7 @@ signs can be used if we absolutely have to introduce spaces.
shouldn't shouldn't
§36. That's the end of the conjugations — the easy part, it turns out. We now
+ §36. That's the end of the conjugations — the easy part, it turns out. We now
need to create the four tries to make verb forms out of the infinitive:
the present participle, the past participle, the third-person singular
present tense, and the past tense.
@@ -1493,7 +1499,7 @@ no easy way to tell. Consider deter to deterring (stress on second syllable
of deter), but meter to metering (stress on first syllable of meter).
§37. The following algorithm is due to Toby Nelson, who produced it from a
+ §37. The following algorithm is due to Toby Nelson, who produced it from a
dictionary of 14,689 English verbs, some of them quite obscure (to torpefy,
anyone? to spuilzie? to cachinnate?). It's essentially a more detailed
version of Greenbaum's rules above.
@@ -1508,7 +1514,7 @@ version of Greenbaum's rules above.
... <en-trie-regular-c-present-participle>
§38. First of all there are some irregular cases — some for the usual suspects,
+ §38. First of all there are some irregular cases — some for the usual suspects,
but others for oddball verbs where English breaks the normal phonetic rules
for the sake of clarity. For example, the participle of "singe" ought to
be "singing", but in fact we write "singeing", purely to make it different
@@ -1704,7 +1710,7 @@ from the act of producing a song.
undersaye 1ing
§39. Now some exceptional forms where consonant doubling doesn't occur:
+ §39. Now some exceptional forms where consonant doubling doesn't occur:
§40. And now rules for consonant doubling:
+ §40. And now rules for consonant doubling:
§42. Next the past participle. As noted above, for most verbs this is the same
+ §42. Next the past participle. As noted above, for most verbs this is the same
as the past (e.g., he agreed and it was agreed); but there's a list of
exceptions for Anglo-Saxon survivals (e.g., he chose and it was chosen).
The exceptional cases were derived from Wikipedia's catalogue of irregular
@@ -1958,7 +1964,7 @@ removed.
write written
§43. That's the mandatory participles sorted out; so now we move on to the two
+ §43. That's the mandatory participles sorted out; so now we move on to the two
additional verb forms used by English. First, the present form: a curiosity
of English is that this is almost always formed as if it were the plural of the
infinitive — thus "touch" becomes "touches". There are just a handful
@@ -1976,7 +1982,7 @@ of exceptions to this.
do does
§44. Second, the past. This is harder. Once again we have a catalogue of
+ §44. Second, the past. This is harder. Once again we have a catalogue of
Anglo-Saxon past forms (e.g., he chose, not he chooses); and after those
are out of the way, the rules are the same as for the present participle,
except for adding -ed instead of -ing. The tricky part, again, is spotting
@@ -2609,7 +2615,7 @@ when to double the consonant, which again depends on stress.
* 0ed
§45. Present to past participles. Sentences like
+ §45. Present to past participles. Sentences like
§46. Adjective agreements. English doesn't inflect adjectives at all (let's not argue about "blond"
+ §46. Adjective agreements. English doesn't inflect adjectives at all (let's not argue about "blond"
and "blonde"), so the following are just stubs.
§47. Grading of adjectives is more interesting. These spelling rules are taken
+ §47. Grading of adjectives is more interesting. These spelling rules are taken
from the Oxford English Grammar at 4.24, "Gradability and comparison".
Something we can't easily implement is that a final vowel plus consonant
doesn't result in doubling the consonant (in the way that "big" becomes
@@ -3171,7 +3177,7 @@ rare in English adjectives.
* 0est
§48. To the best of my knowledge there's no technical term for "the noun which
+ §48. To the best of my knowledge there's no technical term for "the noun which
is formed from an adjective to refer to the quality it measures", so the
Inform source code calls this the "quiddity". English permits several
competing forms of these to be constructed, depending on the adjective's
@@ -3191,7 +3197,7 @@ sometimes less elegant, but never means the wrong thing.
* 0ness
§49. English has almost no noun cases at all, with the only exceptions being
+ §49. English has almost no noun cases at all, with the only exceptions being
Anglo-Saxon pronouns (thus we distinguish "they" and "them" as nominative
and accusative, for example); and pronouns we handle separately in any
case. We won't bother to distinguish gender:
@@ -3205,7 +3211,7 @@ case. We won't bother to distinguish gender:
* <en-noun-declension-group> <en-noun-declension-tables>
§50. And the sorting into groups sorts everything into "group 1", the only group:
+ §50. And the sorting into groups sorts everything into "group 1", the only group:
§51. And in this single group, nominative and accusative forms are identical
+ §51. And in this single group, nominative and accusative forms are identical
to the stem in both singular and plural.
§52. English articles only inflect slightly, to show indefinite plurals; they
+ §52. English articles only inflect slightly, to show indefinite plurals; they
don't distinguish nominative from accusative.
§1. Status. The inflections module is provided as one of the "services" suite of modules,
+ §1. Status. The inflections module is provided as one of the "services" suite of modules,
which means that it was built with a view to potential incorporation in
multiple tools. It can be found, for example, in inform7 and
inflections-test.
@@ -74,7 +80,7 @@ other modules except for words and syntax.
§2. Importing the module. We'll use the term "parent" to mean the tool which is importing inflections,
+ §2. Importing the module. We'll use the term "parent" to mean the tool which is importing inflections,
that is, which will include its code and be able to use it. As with any
imported module,
§3. This module has no callback functions to modify its behaviour.
+ §3. This module has no callback functions to modify its behaviour.
-
@@ -956,7 +962,7 @@ and we construe "y" (but not "h" or "w") as a vowel.
return -1;
}
-
@@ -986,7 +992,7 @@ and we construe "y" (but not "h" or "w") as a vowel.
return -1;
}
-
+
int Conjugation::ptoken_as_bracket(ptoken *pt) {
@@ -998,7 +1004,7 @@ and we construe "y" (but not "h" or "w") as a vowel.
return 0;
}
-
void Conjugation::error(word_assemblage base_text, nonterminal *nt,
@@ -1026,7 +1032,7 @@ as pattern.
exit(1);
}
-Inform7 Modules
Services
@@ -66,7 +72,7 @@ function togglePopup(material_id) {
diff --git a/docs/inflections-module/4-ei.html b/docs/inflections-module/4-ei.html
index 3f4137c30..13e9efd1f 100644
--- a/docs/inflections-module/4-ei.html
+++ b/docs/inflections-module/4-ei.html
@@ -33,7 +33,11 @@
Inform7 Modules
Services
@@ -61,7 +67,7 @@
-
-
@@ -91,7 +97,7 @@ dictionary and the "Official Scrabble Wordlist".
uvarovite* an a rare emerald-green garnet, Ca3Cr2(SiO4)3
-
@@ -161,7 +167,7 @@ dictionary and the "Official Scrabble Wordlist".
uvu* a
-
@@ -221,7 +227,7 @@ dictionary and the "Official Scrabble Wordlist".
yw* an
-
-
-
@@ -354,7 +360,7 @@ have the same plural as singular form: for example, chamois, salmon, goldfish.
oneself oneselves
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
@@ -1093,7 +1099,7 @@ as we'll see.)
was | were | was | were | were | were
-
-
-
-
-
-
-
-
@@ -1402,7 +1408,7 @@ of "modal" itself arguable. This is the best we can do.
a5+ won't be able to ++1
-
-
-
-
@@ -1725,7 +1731,7 @@ from the act of producing a song.
*daub 0ing daubing, bedaubing
-
@@ -1777,7 +1783,7 @@ from the act of producing a song.
*iz 0zing
-
@@ -1791,7 +1797,7 @@ from the act of producing a song.
* 0ing
-
-
-
-
@@ -3118,7 +3124,7 @@ cases followed by two general rules.
*ing 3ed e.g., "smashing" to "smashed"
-
-
-
-
-
@@ -3216,7 +3222,7 @@ case. We won't bother to distinguish gender:
<en-noun-declension-uninflected>
-
-Inform7 Modules
Services
@@ -60,7 +66,7 @@
-