The core of the Inform compiler, as a module.
-
Chapter 1: Configuration and Control
The chief executive: the main routine through which Inform 7 begins execution, and which reads command-line switches supplied by its customers.
-
Main Routine -
As with all C programs, Inform begins execution in a |main| routine, reading command-line arguments to modify its behaviour.
-
Core Module -
Setting up the use of this module.
-
Progress Percentages -
This tiny section, the Lichtenstein of Inform, prints percentage of completion estimates onto |stderr| so that the host application can intercept them and update its graphical progress bar.
-
Where Everything Lives -
To configure the many locations used in the host filing system.
-
Chapter 2: Bridge to Problems Module
The issuing of Problem messages, and the debugging log file.
-
Chapter 3: Bridge to Words Module
Reading source text as a stream of characters and dividing it up into words.
-
Read Source Text -
This is where source text is read in, whether from extension files or from the main source text file, and fed into the lexer.
-
Natural Languages -
To manage definitions of natural languages, such as English or French, which may be used either to write Inform or to read the works it compiles.
-
Plural Dictionary -
To parse sentences like "The plural of woman is women".
-
Chapter 4: Bridge to Linguistics Module
Miscellaneous grammatical features other than nouns, verbs and adjectives.
-
Chapter 5: Nouns
Nouns, mainly proper, and notations for constant values such as 10:03 AM, six, 34 kg, and so on.
-
Literal Patterns -
To manage the possible notations with which literal values can be written.
-
Times of Day -
To make a built-in kind of value for times of day, such as "11:22 AM".
-
Using Excerpt Meanings -
To register and deregister meanings for excerpts of text as nouns, adjectives, imperative phrases and other usages.
-
Unicode Translations -
To manage the names assigned to Unicode character values.
-
Using Nametags -
Nametags provide for a more contextual parsing of nouns, allowing them to be given in an inexact verbal form.
-
Instances -
To manage constant values of enumerated kinds, including kinds of object.
-
Nonlocal Variables -
To manage variables whose scope is wider than the current rule.
-
Index Physical World -
This section masterminds the creation of the World and Kinds index pages, though it delegates much of the work elsewhere. Though it does belong to core Inform, these indexes will look pretty sparse if the spatial Plugins aren't plugged in.
-
Chapter 6: Verbs
Verbs which establish relationships between nouns, and which give meaning to binary predicates.
-
Binary Predicates -
To create and manage binary predicates, which are the underlying data structures beneath Inform's relations.
-
Relations -
What Inform internally calls "binary predicates", the user calls "relations". In this section, we parse definitions of new relations and create the resulting |binary_predicate| objects.
-
Explicit Relations -
To draw inferences from the relations created explicitly by the source text.
-
The Universal Relation -
To define the universal relation, which can apply and therefore subsumes all other relations.
-
New Verbs -
To define verbal forms for relations, in different tenses and numbers.
-
Chapter 7: Sentences
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.
-
Parse Tree Usage -
Shims for the parse tree.
-
Structural Sentences -
To parse structurally important sentences.
-
Headings -
To keep track of the hierarchy of headings and subheadings found in the source text.
-
Nonstructural Sentences -
To construct verb-phrase nodes in the parse tree.
-
Of and From -
To verify that "of" and "from" subtrees in assertion sentence noun phrases are validly used, and reconstruct their sentences without them if they are not.
-
Rule Subtrees -
To tidy up |INVOCATION_LIST_NT| nodes into a list of children under the relevant |ROUTINE_NT| node, and so turn each rule definition into a single subtree.
-
Chapter 8: Extensions
Extensions of more sentences must be Included as requested; because of which, we also handle extension installation, uninstallation and documentation here.
-
Extension Files -
To keep details of the extensions currently loaded, their authors, titles, versions and rubrics, and to index and credit them suitably.
-
Including Extensions -
To fulfill requests to include extensions, adding their material to the parse tree as needed, and removing INCLUDE nodes.
-
Extension Identifiers -
To store, hash code and compare title/author pairs used to identify extensions which, though installed, are not necessarily used in the present source text.
-
Extension Census -
To conduct a census of all the extensions installed (whether used on this run or not), and keep the documentation index for them up to date.
-
Extension Dictionary -
To maintain a database of names and constructions in all extensions so far used by this installation of Inform, and spot potential namespace clashes.
-
Extension Documentation -
To generate HTML documentation for extensions.
-
Chapter 9: The A-Parser
We work through the assertion sentences in the parse tree one by one, and formulate logical propositions which must be true statements about the model world.
-
Introduction to Assertions -
A general introduction to how the A-parser deals with assertions.
-
Traverse for Assertions -
To manage the overall process of traversing the parse tree for assertion sentences.
-
To Be and To Have -
To handle sentences with primary verb "to be" or "to have".
-
Refine Parse Tree -
To determine which subjects are referred to by noun phrases such as "the table" and "a paper cup" found in assertion sentences being parsed.
-
The Creator -
This is where all objects, kinds of object, named values, kinds of value and global variables are made.
-
Make Assertions -
To read assertion sentences, sort them according to a detailed grammatical classification and take the primary actions necessary either to generate problem messages, or to infer information.
-
Property Knowledge -
This section draws inferences from assertions which seem to be about the properties of things, independent of their location.
-
Relation Knowledge -
This section draws inferences about the relationships between objects or values.
-
Assemblies -
To build the complex multi-object assemblies which result from allowing the source text to say things like "in every room is a vehicle".
-
Implications -
To keep track of a dangerous form of super-assertion called an implication, which is allowed to generalise about properties.
-
Property Declarations -
To parse sentences which create new properties, or assert that particular kinds of value can possess them.
-
Chapter 10: The S-Parser
In which the S-parser is put to work: excerpts of several words at a time are assigned meanings, and compound statements formed of these are parsed, producing lists of possible interpretations.
-
Architecture of the S-Parser -
Top-level structure of the S-parser, which turns text into S-nodes.
-
Parse Literals -
To decide if an excerpt of text is a value referred to notationally rather than by name.
-
Constants and Descriptions -
To parse noun phrases in constant contexts, which specify values either explicitly or by describing them more or less vaguely.
-
Type Expressions and Values -
To parse two forms of noun: a noun phrase in a sentence, and a description of what text can be written in a given situation.
-
Verbal and Relative Clauses -
To break down an excerpt into NP and VP-like clauses, perhaps with a primary verb (to make a sentence), perhaps only a relative clause (to make a more complex NP).
-
Conditions and Phrases -
To parse the text of To... phrases, say phrases and conditions.
-
Chapter 11: Predicate Calculus
In which the meaning of an S-parsed sentence is converted to a statement in predicate calculus, so that verbs and prepositions become relations, while determiners express quantifiers; this produces a mathematical proposition which can be simplified according to logical rules which change its form but not its meaning.
-
Introduction to Predicate Calculus -
An exposition of the form of predicate calculus used by Inform.
-
Terms -
Terms are the representations of values in predicate calculus: variables, constants or functions of other terms.
-
Atomic Propositions -
To build and modify atoms, the syntactic pieces from which propositions are built up.
-
Propositions -
To build and modify structures representing propositions in predicate calculus.
-
Binding and Substitution -
To substitute constants into propositions in place of variables, and to apply quantifiers to bind any unbound variables.
-
Tree Conversions -
The second of the three sources of propositions to conjure with: those which arise from subtrees constructed by the A-parser.
-
Sentence Conversions -
The third of the three sources of propositions to conjure with: those which arise by the parsing of complex sentence trees in the S-grammar.
-
Simplifications -
A set of operations each of which takes a proposition and either leaves it unchanged or replaces it with a simpler one logically equivalent to the original.
-
Type Check Propositions -
Predicate calculus is a largely symbolic exercise, and its rules of working tend to assume that all predicates are meaningful for all terms: this means, for instance, that "if blue is 14" is likely to make a well-formed sentence in predicate calculus. In this section we reject such propositions on the grounds that they violate type-checking requirements on relations -- in this example, the equality relation.
-
Chapter 12: Use of Propositions
This is where the propositions generated by the A-parser and the S-parser are at last acted upon, either immediately (generating inferences) or at run-time (by causing code to be compiled which will some day test or assert the truth of the proposition).
-
The Equality Relation -
To define that prince among predicates, the equality relation.
-
Quasinumeric Relations -
To define the binary predicates corresponding to numerical comparisons.
-
Assert Propositions -
To declare that a given proposition is a true statement about the state of the world when play begins.
-
I6 Schemas -
To create, and later expand upon, short prototypes of I6 syntax for such run-time tasks as the setting, unsetting or testing of a relation.
-
Compile Atoms -
In this section, given an atom of a proposition we compile I6 code as required for any of three possible outcomes: (i) to test whether it is true, (ii) to make it henceforth true, or (iii) to make it henceforth false.
-
Deciding to Defer -
To decide whether a proposition can be compiled immediately, in the body of the current routine, or whether it must be deferred to a routine of its own, which is called from the current routine.
-
Cinders and Deferrals -
To compile terms, having carefully preserved any constants which might have been lost in the process of deferring a proposition (such tricky constants being called "cinders").
-
Compile Deferred Propositions -
To compile the I6 routines needed to perform the tests or tasks deferred as being too difficult in their original contexts.
-
Chapter 13: Bridge to Kinds Module
In which values are categorised by their natures, and these in turn occupy a hierarchy.
-
Knowledge about Kinds -
How kinds can be inference subjects.
-
Compile Arithmetic -
To compile code performing an arithmetic operation.
-
Runtime Support for Kinds -
To compile I6 material needed at runtime to enable kinds to function as they should.
-
Kinds Index -
To produce most of the Kinds page in the Index for a project: the chart at the top, and the detailed entries below.
-
Chapter 14: Specifications
In which the meanings of excerpts are systematically catalogued according to what they specify; a categorisation much broader than working out kinds of value, since it applies to a much broader range of excerpts than values.
-
Value Holsters -
To manage requests for compilation to Inter.
-
Specifications -
To create, manage and compare specifications.
-
RValues -
Utility functions for specifications representing rvalues.
-
Lvalues -
Utility functions for specifications representing lvalues, that is, storage locations for values at run-time.
-
Conditions -
Utility functions for condition nodes.
-
Descriptions -
Description nodes represent text such as "even numbers", which can either define a set of values or a predicate on them.
-
Compiling from Specifications -
To compile specifications into Inform 6 values, conditions or void expressions.
-
Dash -
Dash is the part of Inform most nearly like a typechecker in a conventional compiler.
-
Chapter 15: Properties
Properties are named values attached to elements of the world model; not only objects, but also other enumerated constant values, and so on.
-
Properties -
Elements of the model world, such as objects, have properties associated with them. Here we look after the identities of these different properties.
-
Either-Or Properties -
Properties which can either be present or not, but have no value attached.
-
Valued Properties -
Properties which consist of an attached value, always having a given kind.
-
Condition Properties -
Properties which hold one of an enumerated set of named states of something.
-
Indefinite Appearance -
To look after the indefinite appearance pseudo-property, used when the source text comments on something with a sentence consisting only of a double-quoted literal text.
-
The Provision Relation -
To define the provision relation, which determines which properties can be held by which objects.
-
Measurement Adjectives -
To define adjectives such as large, wide or roomy, which make implicit comparisons of the size of some numerical property, and which (unlike other adjectives) lead to comparative and superlative forms.
-
Comparative Relations -
When a measurement adjective like "tall" is defined, so is a comparative relation like "taller than".
-
Same Property Relation -
Each value property has an associated relation to compare its value between two holders.
-
Setting Property Relation -
Each value property has an associated relation to set its value.
-
Properties of Values -
Two unrelated but minor support needs for properties of values which are not objects.
-
Emit Property Values -
To feed the hierarchy of instances and their property values into Inter.
-
Chapter 16: Inference and Model
Having now essentially disposed of the original assertion sentences by converting them to propositions, which in turn generated basic inferences about the model world, we must now resolve this mass of facts, applying Occam's Razor to construct the simplest explicit model of the world which fits this knowledge.
-
Inference Subjects -
The different data structures for elements of the model world are all unified by a single concept, the inference subject, about which facts can be known.
-
Property Permissions -
To enforce the domain of properties: for instance, that a door can be open or closed but that an animal cannot, or that a person can have a carrying capacity but that a door cannot.
-
Inferences -
To manage the individual pieces of information gathered, with varying degrees of certainty, from assertion sentences. This is mostly information about which objects have what properties.
-
Complete Model World -
Once the assertions have all been read and reduced to inferences, and all the creations have been made, we take stock; sometimes we spot inconsistencies, sometimes we make deductions, and we try to complete our picture of the model world.
-
Compile Model World -
To manage the compilation of the diverse run-time arrays and/or code needed to set up the initial state of the model world.
-
Instance Counting -
A plugin which maintains run-time-accessible linked lists of instances of kinds, in order to speed up loops; and instance counts within kinds, in order to speed up relation storage; and the object-kind hierarchy, in order to speed up run-time checking of the type safety of property usage.
-
Chapter 17: Text Data
Text literals, which may be constant strings, or may be functions in order to implement substitutions.
-
Chapter 18: List Data
List literals.
-
Chapter 19: Table Data
Inform's preferred data structure for small initialised databases.
-
Table Columns -
To manage the named columns which appear in tables.
-
Tables -
To manage and compile tables, which are two-dimensional arrays with associative look-up facilities provided at run-time.
-
Runtime Support for Tables -
To compile run-time data structures holding tables.
-
Tables of Definitions -
To support tables which amount to massed groups of assertions.
-
Listed-In Relations -
To define the binary predicates corresponding to table columns, and which determine whether a given value is listed in that column.
-
Chapter 20: Equations
Simple mathematical or scientific equations, which can be solved at run-time.
-
Chapter 21: Rules and Rulebooks
Rules are named phrases which are invoked in a particular way, and rulebooks a way to organise lists of them.
-
Rules -
Rule structures abstract the Inform 7 concept of a rule, which may be defined either by an Inform 6 routine or by higher-level source text from a phrase structure.
-
Rule Bookings -
Bookings are assignments of rules to rulebooks. We can think of them as being looseleaf pages, of which we have an unlimited supply: any rule can be written on them, and they can be bound into any rulebook at any specified position.
-
Rulebooks -
To create, manage, compile and index rulebooks, the content of which is a linked list of booked rules together with some general conventions as to how they are to be used.
-
Focus and Outcome -
To look after the value or action on which a rulebook acts, and the possible outcomes it produces.
-
Rule Placement Sentences -
To parse and act upon explicit sentences like "The fire alarm rule is listed after the burglar alarm rule in the House Security rules."
-
Stacked Variables -
To permit variables to have scopes intermediate between local and global: for example, to be shared by all rules in a given rulebook.
-
Activities -
To create and manage activities, which are action-like bundles of rules controlling how the I6 runtime code carries out tasks such as "printing the name of something". Each has its own page in the I7 documentation. An activity list is a disjunction of actitivies.
-
Chapter 22: Phrases
In which rules, To... phrases (and similar explicit instructions to do with specific changes in the world) have their preambles parsed and their premisses worked out, and are then collected together into rulebooks, before being compiled as a great mass of Inform 6 routines and arrays.
-
Introduction to Phrases -
An exposition of the data structures used inside Inform to hold phrases, rules and rulebooks.
-
Construction Sequence -
To deal with all the |.i6t| interpreted commands which bring about the compilation of phrases, and to ensure that they are used in the correct order.
-
Phrases -
To create one |phrase| object for each phrase declaration in the source text.
-
Phrase Usage -
To parse the preamble of a phrase declaration to a phrase usage (PHUD) structure containing a mostly textual representation of the conditions for its usage.
-
Phrase Runtime Context Data -
To store the circumstances in which a rule phrase should fire.
-
Phrase Type Data -
To create, manage, compare the logical specificity of, and assist excerpt parsing concerning, the type of a To phrase. This involves whether it is void, determines a condition or returns a value (and if so, what kind of value); and also what parameters it takes (possibly values, possible other types used by inline definitions) and their types in turn.
-
Describing Phrase Type Data -
To convert phrase type data to and from text.
-
Phrase Options -
To create and subsequently parse against the list of phrase options with which the user can choose to invoke a To phrase.
-
Phrases as Values -
To provide the names of phrases as first-class values.
-
To Phrases -
To manage the sorting of To... phrases in logical precedence order, and keep track of which kinds they are being applied to.
-
Timed Phrases -
Another way phrases can be invoked is as timed events, which need no special Inform data structure and are simply compiled into a pair of timetable I6 arrays to be processed at run-time.
-
Phrasebook Index -
To compile most of the HTML page for the Phrasebook index.
-
Chapter 23: Calculated Adjectives
Adjectives whose truth or falsity at run-time has to be determined by running code.
-
Chapter 24: Compilation Context
Preparing a context at run-time in which code can be executed: creating local variables, and so on.
-
Local Variables -
Local variables are used for call parameters, temporary values, and other ephemeral workspace.
-
Phrase Blocks -
Blocks of code are used to give conditionals and loops greater scope, as in more traditional programming languages.
-
Stack Frames -
When Inform compiles phrase invocations, or implied forms of these such as text substitutions, it does so in the context of a "stack frame". This provides for local "let" values, manages loop blocks, and in general looks after any information shared between a whole sequence of invocations.
-
Chronology -
To keep track of the state of things so that it will be possible in future to ask questions concerning the past.
-
Chapter 25: Compilation
Generating code to perform individual phrases.
-
Invocations -
Specifications which ask to use a phrase (which are "phrasal") indicate which phrase they intend by means of a list of "invocations". This list goes on to record the outcome of type-checking and provides instructions for code generation, as we see here.
-
Parse Invocations -
To register phrases with the excerpt parser, and to provide the excerpt parser with help in putting invocations together.
-
Compile Invocations -
Here we generate Inform 6 code to execute the phrase(s) called for by an invocation list.
-
Compile Invocations As Calls -
Here we generate Inform 6 code to execute the phrase(s) called for by an invocation list.
-
Compile Invocations Inline -
Here we generate Inform 6 code to execute the phrase(s) called for by an invocation list.
-
Compile Phrases -
Phrases defined with a list of invocations, rather than inline, have to be compiled to I6 routines, and this is where we organise that.
-
Chapter 26: Compilation Utilities
Mainly low-level utilities for compiling code.
-
Virtual Machines -
I7 supports a variety of virtual machines as targets. Most source text should be independent of the target VM, but sometimes numbering is needed, and this is where any VM dependencies are decided.
-
Inform 6 Inclusions -
To include Inform 6 code almost verbatim in the output, as instructed by low-level Inform 7 sentences.
-
Use Options -
To control compiler settings, pragma-style.
-
List Together -
To write support code for the Standard Library's "group together" phrases.
-
Jump Labels -
I7 is has no Dijkstra-like conscience about compiling code which is full of |jump| statements, and these require labels to jump to. This section provides those labels, and other related unique-ID-number counters.
-
Compiled Text -
To compile string constants and comments.
-
Routines -
To compile the bones of functions, and their local variable declarations.
-
Translate to Identifiers -
To provide a way to map high-level I7 constructs onto explicitly named identifiers in I6 code.
-
I6 Template Interpreter -
Inform 6 meta-language is the language used by template files (with extension |.i6t|). It is not itself I6 code, but a list of instructions for making I6 code: most of the content is to be copied over verbatim, but certain escape sequences cause Inform to insert more elaborate material, or to do something active. The entire top-level logic of Inform is carried out by interpreting the |Main.i6t| file in this way.
-
Plugins -
To manage the interface between core Inform and some of its outlying or domain-specific components.
-
Plugin Calls -
To place calls to the plugins.
-
Test Scripts -
A rudimentary but useful testing system built in to IF produced by Inform, allowing short sequences of commands to be concisely noted in the source text and tried out in the Inform application using the TEST command.
-
Chapter 27: Bridge to Inter Module
Emitting Inter code ready for the code-generator.