•  Home Page 
•  RAQUEL the Language 
•  RAQUEL the Architecture 
•  Applications 
•  Current Prototype 
•  Project History 

RAQUEL the Architecture

• Architecture
  • Logical Architecture
  • Memory Architecture
  • Physical Architecture
• RAQUEL Tokens
  • Archive
• Input Stack
  • Tokeniser
  • Compactor
  • Parser
  • Recursive Parameters
• Parse Tree Stack
• Meta Stack
• Execution Stack
  • Relational Handler
  • Dyadic Handler
• Scalar Type Plug-Ins
• Storage Stacks
  • B-Tree File
  • In-Memory Hash File

Recursive Parameters

Certain RAQUEL operators and assignments take statements or expressions as parameters. The statements/expressions refer to scalar data that is contained within the relation(s) concerned. However, if a relation can itself contain nested relations, then some of these statements/expressions may refer to the nested relational values.

For this reason, and also because it is simpler for the user to write all expressions and statements in the same style and with the same syntactic and semantic rules, these parameter statements/expressions are tokenised, compacted and parsed in an identical way to that in which the relational statements and expressions containing the parameters are treated.

Consequently it is preferable to use the same tokeniser, compactor and parser code to deal with both the RAQUEL statements & expressions and the statements & expressions that appear as parameters within the RAQUEL statements & expressions.

Thus there is a module in the input stack which inspects the parse tree of RAQUEL statements & expressions, and for the relevant operators/assignments, recursively applies the tokeniser, compactor and parser again to those parameters which are also statements or expressions. Note that it is recursive because it is possible for the parameter statements/expresssions to also contain operators/assignments that utilise parameter statements/expresssions, and so on recursively to any level of nesting. This is because relations may contain nested relation values which themselves contain nested relation values, and so on, to any required depth of nesting.

The following summarises the documentation available on this recursive handling.

• The Recursive Parameter Handler. Overview, design, examples and pseudocode explaining how the handler works.
• A list of the operators and assignments to which the recursive handling applies.
• Ancillary Information. Some practical points concerning the handler.
• Token conversion notes. This concerns the conversion of version 2 to version 3 tokens, to make the tokens suitable for input to the recursive parameter statement handler.