General Information

 o Eli: Translator Construction Made Easy
 o Global Index
 o Frequently Asked Questions

Tutorials

 o Quick Reference Card
 o Guide For new Eli Users
 o Release Notes of Eli
 o Tutorial on Name Analysis
 o Tutorial on Type Analysis

Reference Manuals

 o User Interface
 o Eli products and parameters
 o LIDO Reference Manual

Libraries

 o Eli library routines
 o Specification Module Library

Translation Tasks

 o Lexical analysis specification
 o Syntactic Analysis Manual
 o Computation in Trees

Tools

 o LIGA Control Language
 o Debugging Information for LIDO
 o Graphical ORder TOol

 o FunnelWeb User's Manual

 o Pattern-based Text Generator
 o Property Definition Language
 o Operator Identification Language
 o Tree Grammar Specification Language
 o Command Line Processing
 o COLA Options Reference Manual

 o Generating Unparsing Code

 o Monitoring a Processor's Execution

Administration

 o System Administration Guide

 Questions, Comments, ....

Global Index

Table of Contents


Global Index

!

!
novice: Hints on Session Management
ui: The Odinfile

"

"unavailable" error report
pp: test -- Check Whether an Object has been Modified

$

$ modification
syntax: Conflict resolution by ignoring possible structures
$ symbol
idem: Overriding PTG patterns
`$elipkg/Scan/ScanProc.h'
news4.3: Auxiliary scanner and token processor definitions

%

%
ui: The Odinfile
novice: Hints on Session Management

&

& marker for actions
syntax: Carrying Out Actions During Parsing

*

*
lex: Building complex regular expressions

+

+
lex: Building complex regular expressions
+=
fw: Macros
+arg and mongdb
news4.3: Monitoring products
+lang
idem: Deriving structural unparsers
+nomain
news4.4: Eli-generated code as a component
+parser
news4.4: Eli-generated code as a component
cola: Introduction
+patterns
idem: Establishing a basis
+prefix
idem: Establishing a basis

-

-
lex: Character classes
-c
faq: Where to Find Eli Locally
-c command line argument
novice: Hints on Cache Management
-g flag
pp: debug -- Request debugging information in object files
-r
faq: Why is my cache so big?
faq: How do I get new or improved components?
-r command line parameter
novice: Hints on Cache Management
novice: Hints on Cache Management

.

.
lex: Character classes
.c files
comptrees: Implementing Tree Computations
.clp
clp: The general format of the command line
clp: Specifying the command line interface
`.cola'
cola: Introduction
`.con' file format
syntax: Grammars for the Specification Files
`.con' file, example
syntax: Mapping expressions for overload resolution
`.con' file, purpose
syntax: How to describe a context-free grammar
.con files
comptrees: Tree Construction
`.dapto' file format
mon: Dapto Grammar
.finl files
comptrees: Implementing Tree Computations
.FINL.phi files
comptrees: Implementing Tree Computations
.fw
fw:
.fwi
fw:
fw: Include Files
.h files
comptrees: Implementing Tree Computations
.head files
comptrees: Implementing Tree Computations
.HEAD.phi files
comptrees: Implementing Tree Computations
.init files
comptrees: Implementing Tree Computations
.INIT.phi files
comptrees: Implementing Tree Computations
.lido files
comptrees: Supplying Tree Computation Specifications to Eli
`.map' file, example
syntax: Mapping expressions for overload resolution
`.map' file, format
syntax: Grammars for the Specification Files
`.noosarc'
mon: User Initialisation
.odinrc
faq: Is the file `.odinrc' still read?
.pdl
deftbl: How to declare properties
`.perr' file, format
syntax: Grammars for the Specification Files
.specs files
comptrees: Implementing Tree Computations
.sym files
comptrees: Tree Construction

1

1
info: Some Advanced Info Commands

2

2
info: Some Advanced Info Commands

3

3
info: Some Advanced Info Commands

4

4
info: Some Advanced Info Commands

5

5
info: Some Advanced Info Commands

<

<
novice: Common Derived Objects
ui: Extracting and Editing Objects

=

==
fw: Macros
ui: The Odinfile
novice: Hints on Session Management

>

>
novice: Common Derived Objects
ui: Extracting and Editing Objects

?

?
lex: Building complex regular expressions
info: C-l

@

@ modification
syntax: Conflict resolution by ignoring possible structures
@!
fw: Comments
@+
fw: Inserting End of Line Markers
@-
fw: Suppressing End of Line Markers
@1...
fw: Formal Parameter Lists
@i
fw: Include Files
@M
fw: Macros
@Z
fw: Macros

[

[ ]
lex: Character classes

\

\040
lex: Restoring the Default Behavior for White Space
lex: Matching operator characters
\040+
lex: Definitions of Canned Descriptions
\b
lex: Matching operator characters
\t
lex: Matching operator characters

^

^
lex: Character classes

_

_obstack
lib: Memory Object Management

A

A Complete Example
ptg: A Complete Example
abort
pp: Diagnosing Specification Inconsistencies
abstract data type
syntax: Carrying Out Actions During Parsing
oil: Relating an OIL specification to library function calls
Abstract Data Types
adt:
abstract syntax tree display
news4.1: Monitoring
abstracting from literals
syntax: Abstracting information from literals
abstree
pp: abstree -- Abstract Tree Grammar
absyntax
pp: absyntax -- Abstract Syntax
accepting a basic symbol
syntax: How the generated parser determines phrase structure
ACCESS
deftbl: How to declare operations
action
tp: Rules
tp: Actions Carried Out During Parsing
action macro
tp: Implementing Actions
action routine
tp: Implementing Actions
action signature
tp: Implementing Actions
tp: Actions and Values
actions during parsing
syntax: Carrying Out Actions During Parsing
ADA_COMMENT
lex: Canned Symbol Descriptions
lex: Available Descriptions
lex: Definitions of Canned Descriptions
ADA_IDENTIFIER
lex: Definitions of Canned Descriptions
lex: Available Descriptions
AdaptOil
oldmod: Migration of Eli Version 3.8 modules
ADD
lidoref: Predefined Entities
`Add.fw'
idem: Using an Unparser
AddIdn
name: Environment Module
lib: Contour-Model Environment
additional information
idem: Using an Unparser
AddKind
prop: Associate Sets of Kinds to Objects
AddKindSet
prop: Associate Sets of Kinds to Objects
AddToOrderedSet
adt: Linear Lists of Any Type
news4.3: Linear Lists of Any Type
AddToOrderedSetTYPEList
news4.2: List-Module
AddToSet
adt: Linear Lists of Any Type
AddToSetTYPEList
news4.2: List-Module
adjacent context
comptrees: Tree Structure
Algol-like
name: Basic Scope Rules
Algol-like basic scope rules
name: Basic Scope Rules
AlgRangeSeq
name: Predefined Identifiers
AlgScope
name: Basic Scope Rules
AlgScope module
novice: Managing source text definitions
AlgScopeProp
news4.4: Scope Properties without Ordering Restrictions
name: Joined Ranges C-like Bottom-up
type: Types Having Scope Properties
alignment
lib: Memory Object Management
Allocation
lib: Memory Object Management
alterations
faq: Eli didn't notice that I changed my input file!
altering files
pp: help -- Cross-Reference to Documentation
alternation
lex: Building complex regular expressions
syntax: Using extended BNF to describe more complex rules
ambiguity
syntax: How to Resolve Parsing Conflicts
ambiguity resolved by grammar changes
syntax: Conflict resolution by changing the grammar
ambiguity resolved by modifications
syntax: Conflict resolution by ignoring possible structures
`Analysis.fw'
idem: Languages describing tree structure
AND
lidoref: Predefined Entities
anonymous entities
deftbl: Criteria for selecting entities
AnyScope
name: Algol-like Basic Scope Rules
name: C-like Basic Scope Rules
App
adt: Linear Lists of Any Type
AppEl
adt: Linear Lists of Any Type
application language, selecting
idem: Deriving structural unparsers
application languages, CPP
idem: Languages describing tree structure
application languages, Java
idem: Languages describing tree structure
application languages, other
idem: Languages describing tree structure
application languages, XML
idem: Languages describing tree structure
applied occurrences
name:
APPLY
lidoref: Predefined Entities
arbitrary actions during parsing
syntax: Carrying Out Actions During Parsing
arbitrary characters, inserting into text
fw: Inserting Arbitrary Characters into the Text
arg
pp: arg -- Supply Command Line Parameters
argc
clp: What is a command line interface?
ARGTOONE
lidoref: Predefined Entities
argument separator
idem: Overriding PTG patterns
idem: Using an Unparser
idem: Changing IdemPtg computations
argument type
oil: Set of Possible Types
oil: Looking at an operator's type signature
ArgumentDeListElem
news4.3: Oil
ArgumentDeListRoot
news4.3: Oil
ArgumentListElem
news4.3: Oil
ArgumentListRoot
news4.3: Oil
arguments
mon: Controlling Your Program
lidoref: Syntax
argv
clp: What is a command line interface?
arithmetic expressions
tp: Tree Structure
arity
tp: Tree Structure
array types
type: Properties of Types
type: Properties of Types
type: Properties of Types
ArrayStorage
lib: Storage Layout
AsIs, Ptg-Pattern
output: Frequently Used Patterns
aspect
mon: Aspects
association rules
syntax: Operator associativity
ATTR
comptrees: Value Dependencies
lidoref: Syntax
AttrClass
lidoref: Syntax
attribute
comptrees: Dependent Computations
lidoref: Syntax
novice: How to Decompose a Text Processing Problem
attribute Bind
name: C-like Basic Scope Rules
name: Algol-like Basic Scope Rules
name: Basic Scope Rules
attribute class
lidoref: Attributes
lidoref: Types and Classes of Attributes
lidoref: Examples
lidoref: Syntax
comptrees: Value Dependencies
lidoref: Examples
attribute class in conflict
comptrees: Specification Errors
attribute Cnt
prop: Count Occurrences of Objects
attribute computations
lidoref: Examples
attribute Count
problems: Counting Symbol Occurrences
attribute CountResult
problems: Counting Symbol Occurrences
attribute DefCond
name: C-like Basic Scope Rules
attribute DeferredKey
type: Deferred Property Association
attribute Elem
adt: Lists in LIDO Specifications
attribute Env
name: Algol-like Basic Scope Rules
name: C-like Basic Scope Rules
attribute GENTREE
lidoref: Examples
attribute GotAllInh
name: Inheritance with Algol-like Scope Rules
attribute GotCnt
prop: Count Occurrences of Objects
attribute GotDeferProp
type: Deferred Property Association
attribute GotInh
name: Inheritance of Scopes
attribute GotInhNest
name: Inheritance with Algol-like Scope Rules
attribute GotInhScopes
name: Inheritance of Scopes
name: Inheritance with Algol-like Scope Rules
name: Inheritance with C-like Scope Rules
attribute GotKeys
name: C-like Basic Scope Rules
name: Algol-like Basic Scope Rules
attribute GotKind
prop: Associate Sets of Kinds to Objects
prop: Associate Kinds to Objects
attribute GotLocKeys
name: Algol-like Basic Scope Rules
attribute GotProp
type: Basic Type Analysis
attribute GotScopeProp
name: Scope Properties C-like
name: Scope Properties without Ordering Restrictions
attribute GotType
type: Basic Type Analysis
attribute grammar
novice: Creating structured output text
novice: Creating structured output text
novice: Managing source text definitions
attribute HasKind
prop: Associate Kinds to Objects
attribute HasKindSet
prop: Associate Sets of Kinds to Objects
attribute Increment
problems: Counting Symbol Occurrences
attribute IncrementCnt
prop: Map Objects to Integers
attribute InheritOk
name: Inheritance of Scopes
name: Inheritance of Scopes
attribute InhKey
name: Inheritance of Scopes
attribute InhPrecond
name: C-like Inheritance Bottom-Up
attribute InitCount
problems: Counting Symbol Occurrences
attribute InitObjCnt
prop: Map Objects to Integers
attribute InnerScope
name: Inheritance of Scopes
attribute IsFirstOcc
prop: Check for Unique Object Occurrences
attribute Key
modlib: Instantiation and Use of Modules
prop: Common Aspects of Property Modules
name: C-like Basic Scope Rules
name: Basic Scope Rules
name: Algol-like Basic Scope Rules
attribute Kind
prop: Associate Kinds to Objects
prop: Associate Sets of Kinds to Objects
attribute KindSet
prop: Associate Sets of Kinds to Objects
attribute List
adt: Lists in LIDO Specifications
attribute ListTail
adt: Lists in LIDO Specifications
Attribute monitoring and browsing
news4.3: Attributes
attribute NewScope
name: C-like Inheritance Bottom-Up
attribute ObjNo
prop: Map Objects to Integers
attribute OpenPrecond
name: Scope Properties C-like Bottom-Up
attribute OuterScope
name: Inheritance of Scopes
attribute Scope
name: Scope Properties without Ordering Restrictions
name: C-like Basic Scope Rules
name: Algol-like Basic Scope Rules
attribute ScopeKey
name: Scope Properties C-like Bottom-Up
name: Scope Properties without Ordering Restrictions
name: Scope Properties without Ordering Restrictions
attribute Sym
output:
name: Algol-like Basic Scope Rules
name: C-like Basic Scope Rules
name:
name: Tree Grammar Preconditions
attribute TakeIt
adt: Lists in LIDO Specifications
adt: Lists in LIDO Specifications
attribute TotalCnt
prop: Count Occurrences of Objects
attribute TotalObjNo
prop: Map Objects to Integers
attribute type
lidoref: Types and Classes of Attributes
type: Basic Type Analysis
lidoref: Examples
lidoref: Restrictions
lidoref: Examples
comptrees: Value Dependencies
attribute TypeIsSet
type: Basic Type Analysis
attribute types
tp: Actions and Values
attribute Unique
prop: Set a Property at the First Object Occurrence
attribute value display
news4.1: Monitoring
attribute values
mon: Trees and Attribute Values
attribute, IdemOrigPtg
idem: Changing IdemPtg computations
attributes
idem: Computations for plain productions
lidoref: Attributes
idem: Computations for LISTOF productions
tp: The Tree To Be Parsed
tp: Rules
lidoref: Attributes
tp: Decorating Nodes
idem: Computations for plain productions
AttrName
lidoref: Syntax
AttrNames
lidoref: Syntax
AttrSpecs
lidoref: Syntax
autoloading handlers
mon: User Initialisation
mon: Breakpoints and events
auxCChar
lex: Available scanners
lex: Definitions of Canned Descriptions
auxCComment
lex: Available scanners
lex: Definitions of Canned Descriptions
auxCString
lex: Definitions of Canned Descriptions
lex: Available scanners
auxEOF
lex: Available scanners
auxEOL
lex: Definitions of Canned Descriptions
lex: Auxiliary Scanners
lex: Available scanners
auxiliary scanner
lex: Auxiliary Scanners
auxM2String
lex: Available scanners
auxM2StringDQ
lex: Definitions of Canned Descriptions
auxM2StringSQ
lex: Definitions of Canned Descriptions
auxM3Comment
lex: Definitions of Canned Descriptions
lex: Available scanners
auxNewLine
lex: Available scanners
auxNoEOL
lex: Available scanners
news4.3: Scanning to, but not including, a newline
auxNUL
lex: Available scanners
news4.3: Processing NUL characters during lexical analysis
auxPascalComment
lex: Available scanners
lex: Definitions of Canned Descriptions
auxPascalString
lex: Available scanners
lex: Definitions of Canned Descriptions
auxTab
lex: Definitions of Canned Descriptions
lex: Available scanners
AWK_COMMENT
lex: Available Descriptions
lex: Definitions of Canned Descriptions
axiom
novice: How to Decompose a Text Processing Problem
syntax: Context-Free Grammars and Parsing
axiom, recognition of
syntax: How the generated parser determines phrase structure

B

b
info: C-l
backslash
lex: Matching operator characters
Backus Naur Form
syntax: How to describe a context-free grammar
balancing
oil: Set of Possible Types
basic scope rules
name: Tree Grammar Preconditions
basic symbol
pp: printtokens -- Request Token Printing Code
syntax:
basic symbol, how parser accepts
syntax: How the generated parser determines phrase structure
Basic Type Analysis
type:
basis
idem: Deriving an Unparser
Bind
name: Basic Scope Rules
name: Algol-like Basic Scope Rules
news4.3: Predefined Identifiers
name: C-like Basic Scope Rules
BindIdn
name: Environment Module
Binding
name: C-like Basic Scope Rules
name: Environment Module
name: Basic Scope Rules
news4.1: Environment Module Enhancements
name: Algol-like Basic Scope Rules
name: Environment Module
BindingInEnv
name: Environment Module
BindingInScope
name: Environment Module
Bindings (Binding)
mon: Trees and Attribute Values
BindInScope
name: Environment Module
BindKey
name: Environment Module
BindKeyInScope
name: Environment Module
BinTgtOpr
type: Operator Identification
BITAND
lidoref: Predefined Entities
BITOR
lidoref: Predefined Entities
BITXOR
lidoref: Predefined Entities
block print module
idem: Computations for plain productions
block-structure
output: Restrictions
BNF
syntax: How to describe a context-free grammar
Bool
oldmod: Migration of Eli Version 3.8 modules
boolean
clp: Options that are either there or not
boolean option
clp: Options that are either there or not
boolean options repeated
clp: Accessing options that appear more than once
booleans
clp: Options that are either there or not
bottom-up
name: Basic Scope Rules
input:
name: Scope Properties C-like
input:
name: Inheritance with C-like Scope Rules
news4.1: Bottom-up Evaluation
name: C-like Basic Scope Rules
bottom-up computations
lidoref: Examples
lidoref: Restrictions
BOTTOM_UP
news4.0: Bottom-Up Evaluation
news4.1: Bottom-up Evaluation
BOTTOMUP
comptrees: Early Computations During Tree Construction
name: Joined Ranges C-like
input: Insert a File into the Input Stream
lidoref: Pragmas
news4.1: Bottom-up Evaluation
name: C-like Basic Scope Rules
pp: pgram -- Parsing Grammar
lidoref: Syntax
lidoref: Restrictions
BP_BeginBlock
output: Typesetting for Block Structured Output
BP_BeginBlockI
output: Typesetting for Block Structured Output
idem: Computations for plain productions
BP_BreakLine
output: Typesetting for Block Structured Output
idem: Computations for plain productions
BP_EndBlock
output: Typesetting for Block Structured Output
BP_EndBlockI
output: Typesetting for Block Structured Output
idem: Computations for plain productions
BP_Newline
output: Typesetting for Block Structured Output
BP_Out
idem: Computations for plain productions
BP_Out(PTGNode n)
output: Additional functions
BP_OutFile
idem: Deriving multiple unparsers
BP_OutFile(char *filename, PTGNode n)
output: Additional functions
BP_OutFPtr(FILE *f, PTGNode n)
output: Additional functions
BP_SetEndline(char *endline)
output: Additional functions
BP_SetIndentationWidth(int width)
output: Additional functions
BP_SetLineWidth(int width)
output: Additional functions
BP_SetSoftBreakShortcut(char)
output: Additional functions
breakpoints
mon: Breakpoints and events
browser session
novice: Exercises
browsing attribute values
news4.1: Monitoring
mon: Trees and Attribute Values
browsing chain values
mon: Trees and Attribute Values
browsing non-standard types
mon: Browsing non-standard types
browsing the abstract tree
mon: Trees and Attribute Values
BuildHosts
ui: Variables
built-in symbols
lex: Canned Symbol Descriptions
BuRangeSeq
name: Predefined Identifiers
name: Joined Ranges C-like
BuScope
name: Basic Scope Rules
BuScopeProp
news4.4: Scope Properties without Ordering Restrictions
name: Joined Ranges C-like Bottom-up
BuType
oldmod: Migration of Eli Version 3.8 modules

C

c
info: Complaining about things
news4.4: Name analysis for declarators as in C
C code
syntax: Carrying Out Actions During Parsing
C compilation
pp: define -- Set C Pre-Processor Symbols
C constant
novice: How to Decompose a Text Processing Problem
C declarator
news4.4: Name analysis for declarators as in C
C literals
lidoref: Simple Expressions
C macro
novice: Creating structured output text
C module
ptg: Introduction to PTG
c parameter of the eli command
faq: Where to Find Eli Locally
C return statements
mon: Operations
C++
news4.4: New functionality for unparser generation
C-g
info: Some advanced Info commands
C-l
info: C-l
C-like
name: Basic Scope Rules
C-like basic scope rules
name: C-like Basic Scope Rules
name: Algol-like Basic Scope Rules
C-like inheritance bottom-up
name: Inheritance with C-like Scope Rules
C-p
info: Printing things from inside Info
C-style comment
novice: Descriptive Mechanisms Known to Eli
novice: Nonliteral character sequences and comments
C-t
info: Printing things from inside Info
C_Char
lidoref: Syntax
C_CHAR_CONSTANT
lex: Available Descriptions
lex: Definitions of Canned Descriptions
C_COMMENT
lex: Definitions of Canned Descriptions
novice: Nonliteral character sequences and comments
lex: Available Descriptions
C_Float
lidoref: Syntax
lex: Definitions of Canned Descriptions
lex: Available Descriptions
C_IDENTIFIER
lex: Definitions of Canned Descriptions
lex: Available Descriptions
lex: Canned Symbol Descriptions
C_INT_DENOTATION
lex: Definitions of Canned Descriptions
lex: Available Descriptions
C_Integer
lidoref: Syntax
lex: Definitions of Canned Descriptions
lex: Available Descriptions
c_mkchar
lex: Definitions of Canned Descriptions
lex: Available processors
c_mkint
lex: Available processors
lex: Definitions of Canned Descriptions
c_mkstr
lex: Available processors
faq: Why does C_STRING_LIT not use c_mkstr?
C_Name
lidoref: Syntax
C_Separator
idem: Using an Unparser
`C_Separator.fw'
idem: Computations for plain productions
C_String
lidoref: Syntax
C_STRING_LIT
lex: Definitions of Canned Descriptions
output: Special Situation when Using C String Literals
lex: Available Descriptions
lex: Canned Symbol Descriptions
faq: Why does C_STRING_LIT not use c_mkstr?
cache
novice: Customizing Eli's Behavior
cache size
faq: Why is my cache so big?
canned description
novice: Nonliteral character sequences and comments
canned symbols
lex: Canned Symbol Descriptions
Cannot connect to Odin server
faq: Eli reports Cannot connect to Odin server
case-insensitivity
pp: fold -- Make the Processor Case-Insensitive
CatStrInd
problems:
problems: Error Reports
input: Insert a File into the Input Stream
CatStrStr
problems:
problems: Error Reports
CChar, Ptg-Pattern
output: Frequently Used Patterns
CHAIN
lidoref: CHAIN
lidoref: CHAIN
ptg: Using LIDO CHAINs
comptrees: Basic Symbol Computations
comptrees: Left-to-Right Dependencies
oldmod: Migration of Eli Version 3.8 modules
lidoref: Remote Attribute Access
comptrees: Remote Dependencies in Trees
chain attributes
mon: Trees and Attribute Values
chain production
news4.1: Bottom-up Evaluation
chain productions
lidoref: Tree Construction Functions
chain rule
tp: Chain Rules
chain rule, omitted
idem: Changing IdemPtg computations
chain rules
syntax: Chain rule definitions
ChainName
lidoref: Syntax
ChainPtg
oldmod: Migration of Eli Version 3.8 modules
news4.1: Module ChainPtg obsolete
CHAINSTART
news4.0: Separated CHAINSTART
lidoref: Examples
news4.1: CHAIN in Empty Rules
comptrees: Left-to-Right Dependencies
lidoref: Syntax
changing a component
mon: Adding Monitoring Support To A Component
char
ptg: Typed Insertion Points
character sequences
novice: How to Decompose a Text Processing Problem
novice: Descriptive Mechanisms Known to Eli
character strings
pp: kwd -- Recognize Specified Literals as Identifiers
CharPtr
problems: Error Reports
child
novice: How to Decompose a Text Processing Problem
child, omitting in the unparsed output
idem: Overriding PTG patterns
ChkIdUse
name: Basic Scope Rules
name: Algol-like Basic Scope Rules
name: C-like Basic Scope Rules
ChkInhIdUse
name: Inheritance with C-like Scope Rules
name: Inheritance of Scopes
name: Inheritance with Algol-like Scope Rules
name: C-like Inheritance Bottom-Up
ChkInhIdUseScopeProp
name: Inheritance with C-like Scope Rules
name: Inheritance with Algol-like Scope Rules
name: Inheritance of Scopes
name: C-like Inheritance Bottom-Up
ChkSetDeferId
type: Deferred Property Association
ChkTypeDefDefId
type: Example for Basic Type Analysis
type: Basic Type Analysis
ChkTypeDefUseId
type: Basic Type Analysis
type: Example for Basic Type Analysis
ChkTypedUseId
type: Example for Basic Type Analysis
type: Basic Type Analysis
chunk size
lib: Memory Object Management
class
comptrees: Value Dependencies
lidoref: Syntax
class definition
oil: Statement types
oil: Class definition
class of attributes
lidoref: Examples
lidoref: Types and Classes of Attributes
lidoref: Attributes
lidoref: Examples
lidoref: Syntax
CLASS symbol
comptrees: Reuse of Symbol Computations
news4.0: CLASS and TREE SYMBOLS
oldmod: Migration of Eli Version 3.8 modules
class symbol computation
idem: Changing IdemPtg computations
CLASS symbols
lidoref: Remote Attribute Access
lidoref: Inheritance of Computations
lidoref: Symbol Specifications
lidoref: Examples
classes
oil: OIL's Specification Language
lex: Character classes
CloneKey
deftbl: How to create and use definition table keys
news4.3: Definition table
cloning keys
deftbl: How to create and use definition table keys
`clp'
novice: Descriptive Mechanisms Known to Eli
cmd
pp: cmd -- Command Line to be Executed
CmdLineIncl
oldmod: Migration of Eli Version 3.8 modules
CmpFctType
adt: Linear Lists of Any Type
coercion
oil: Coercion sequence
oil: A review of an example OIL Specification
oil: Coercion operator definition
oil: Set of Possible Types
coercion operator
oil: Set of Possible Types
coercion operator definition
oil: Coercion operator definition
oil: Statement types
coercion sequence
oil: Library Types
oil: Coercion sequences
oil: Coercion sequence
coercion sequence, empty
oil: Coercion sequences
coercion sequence, error
oil: Coercion sequences
coercion sequence, head of
oil: Coercion sequences
coercion sequence, tail of
oil: Coercion sequences
coercions
syntax: Chain rule definitions
COL
lidoref: Predefined Entities
news4.0: LINE, COL, COORDREF
COLA
pp: parser -- Choose the parser generator
COLA parser generating system
mon: Phrase Structure
`colaOptInfo'
cola: Options
ColOf
lib: Source Text Coordinates and Error Reporting
colours
mon: X resources used by Noosa
CombFctName
lidoref: Syntax
combining properties
deftbl: Criteria for grouping data values
combining related specifications
novice: Creating structured output text
comma expression
tp: Tree Structure
command line
clp: What is a command line interface?
command line argument
novice: Descriptive Mechanisms Known to Eli
command line arguments
input: Accessing the Current Token
novice: Hints on Cache Management
command line format
clp: The general format of the command line
command line parameters
pp: arg -- Supply Command Line Parameters
command-line options
mon: Controlling Your Program
command-line processing
news4.1: Command-line processing
CommaSeq, Ptg-Pattern.
output: Frequently Used Patterns
comment
novice: Nonliteral character sequences and comments
comments
ptg: Pattern Specifications
lidoref: Syntax
deftbl: The property definition language
fw: Comments
ptg: Syntax of PTG Specifications
commutativity
tp: Rules
tp: Commutative Actions
Comp
adt: Linear Lists of Any Type
compatibility with token processor
idem: Overriding PTG patterns
compiler messages
comptrees: Specification Errors
complaining
info: Complaining about things
complement
lex: Character classes
completion
info: Completing Input
component selection
type: Function Types
computation
novice: How to Decompose a Text Processing Problem
comptrees: Dependent Computations
novice: Descriptive Mechanisms Known to Eli
computation, class symbol
idem: Changing IdemPtg computations
computation, IdemPtg
idem: Changing Structure or Representation
idem: Changing IdemPtg computations
computation, rule
idem: Changing IdemPtg computations
idem: Changing IdemPtg computations
computation, tree symbol
idem: Changing IdemPtg computations
idem: Changing IdemPtg computations
Computations
lidoref: Computations
lidoref: Syntax
computations for LISTOF productions
idem: Computations for LISTOF productions
idem: Computations for LISTOF productions
computations for plain productions
idem: Computations for plain productions
idem: Computations for plain productions
COMPUTE
lidoref: Syntax
news4.0: LIDO Tokens
computed sub-tree
idem: Deriving multiple unparsers
Computed Subtrees
lidoref: Computed Subtrees
news4.4: Eli-generated code as a component
computed trees
news4.1: Bottom-up Evaluation
`con'
novice: Descriptive Mechanisms Known to Eli
`con' file format
syntax: Grammars for the Specification Files
`con' file, example
syntax: Mapping expressions for overload resolution
`con' file, purpose
syntax: How to describe a context-free grammar
Concatenate
lib: Storage Layout
concatenation
lex: Building complex regular expressions
concrete grammar
comptrees: Tree Construction
lidoref: Syntax
CONDITION
news4.0: LIDO Tokens
conditional compilation
novice: Descriptive Mechanisms Known to Eli
conditional expression
tp: Tree Structure
tp: Rules Describing Tree Fragments
conflict
syntax: How to Resolve Parsing Conflicts
conflict due to user-defined actions
syntax: Carrying Out Actions During Parsing
conflict solved by $ modification
syntax: Conflict resolution by ignoring possible structures
conflict solved by @ modification
syntax: Conflict resolution by ignoring possible structures
conflict, shift-reduce
novice: Exercises
connections
cola: Options
Cons
adt: Linear Lists of Any Type
consistent renaming
name:
CONSTITUENT
lidoref: Terminals
lidoref: Syntax
CONSTITUENT(S)
lidoref: Remote Attribute Access
lidoref: CONSTITUENT(S)
CONSTITUENTS
comptrees: Remote Dependencies in Trees
comptrees: Access to Contexts within a Subtree
news4.1: CONSTITUENTS Restrictions Removed
novice: Creating structured output text
lidoref: Syntax
lidoref: Terminals
news4.2: List-Module
comptrees: Basic Symbol Computations
ptg: Using LIDO CONSTITUENTS
constructing a separator module
idem: Computations for plain productions
constructing generic modules
pp: inst -- Instantiate a Generic Module
construction function
tp: Node Construction Functions
consyntax
pp: consyntax -- Concrete Syntax
context, lower
novice: Managing source text definitions
context-free grammar
novice: How to Decompose a Text Processing Problem
syntax: Context-Free Grammars and Parsing
novice: How to Decompose a Text Processing Problem
novice: Specifying the desired phrase structure
Continue command
mon: Controlling Your Program
control characters, inserting into text
fw: Inserting Arbitrary Characters into the Text
controlled execution
pp: Debugging -- Debug a Program Interactively at the Source Level
controlling execution
mon: Controlling Your Program
controlling program
mon: Controlling Your Program
coordAdjust
lex: Available scanners
CoordLess
prop: Set a Property at the First Object Occurrence
CoordMap
oldmod: Migration of Eli Version 3.8 modules
CoordPtr
lib: Source Text Coordinates and Error Reporting
COORDREF
news4.0: LINE, COL, COORDREF
lidoref: Predefined Entities
Copy
adt: Linear Lists of Any Type
copy commands
ui: Extracting and Editing Objects
CopyStorage
lib: Storage Layout
core
pp: Debugging -- Debug a Program Interactively at the Source Level
cost
tp: Rules
tp: The Tree Patterns
Count
problems: Counting Symbol Occurrences
prop: Count Occurrences of Objects
count occurrences of objects
prop: Count Occurrences of Objects
Counter
news4.3: Counting Symbol Occurrences
coupling between specifications
novice: Creating structured output text
CPP
idem: Languages describing tree structure
comptrees: Implementing Tree Computations
`Cpp.fw'
idem: Languages describing tree structure
CPtgOutchar
output: Useful Embedded Functions
CPtgOutstr
output: Useful Embedded Functions
CRangeSeq
name: Predefined Identifiers
CreateNewScope
name: Scope Properties C-like Bottom-Up
name: C-like Basic Scope Rules Computed Bottom-Up
name: C-like Inheritance Bottom-Up
creating keys
deftbl: How to create and use definition table keys
creating new names
oil: Name Functions
critical attributes
gorto: Symbols
CScope
name: Basic Scope Rules
CScopeProp
name: Joined Ranges C-like Bottom-up
news4.4: Scope Properties without Ordering Restrictions
csm.h
lib: Character String Storage
Csm_obstk
lib: Character String Storage
CsmStrPtr
lib: Character String Storage
CString, Ptg-Pattern
output: Frequently Used Patterns
Ctext
lex: Available scanners
`ctl'
novice: Descriptive Mechanisms Known to Eli
CType
oldmod: Migration of Eli Version 3.8 modules
cumulative column
lex: Setting coordinate values
cumulative coordinates
mon: Input Text Display
curpos
lib: Source Text Coordinates and Error Reporting
CurrTok
oldmod: Migration of Eli Version 3.8 modules
customisation
mon: User Initialisation
CYCLE IN INDUCED GRAPHS
gorto: Using GORTO within ELI
CYCLE IN PARTITIONED GRAPHS
gorto: Using GORTO within ELI
cyclic dependencies
comptrees: Specification Errors
lidoref: Restrictions
lidoref: Restrictions
Cygwin
news4.4: Eli can now run under Windows

D

d
info: Some advanced Info commands
dangling else problem
syntax: How the generated parser determines phrase structure
dangling else solved by $ modification
syntax: Conflict resolution by ignoring possible structures
dangling else solved by grammar change
syntax: Conflict resolution by changing the grammar
`dapto' file format
mon: Dapto Grammar
dapto scoping rules
mon: Dapto Grammar
DAPTO_ARG and non-standard types
mon: Non-standard types
DAPTO_RESULT and non-standard types
mon: Non-standard types
DAPTO_RESULT_INT
mon: Operations
DAPTO_RESULT_INTVAL
mon: Operations
DAPTO_RESULT_LONG
mon: Operations
DAPTO_RESULT_LONGVAL
mon: Operations
DAPTO_RESULT_PTR
mon: Operations
DAPTO_RESULT_PTRVAL
mon: Operations
DAPTO_RESULT_STR
mon: Operations
dash
lex: Character classes
database
mon: Monitoring Database
mon: Implementing Monitoring Interfaces
dbx
pp: Debugging -- Debug a Program Interactively at the Source Level
pp: Debugging -- Debug a Program Interactively at the Source Level
novice: Exercises
dbxtool
pp: Debugging -- Debug a Program Interactively at the Source Level
DEADLY
lib: Source Text Coordinates and Error Reporting
debug
pp: debug -- Request debugging information in object files
novice: Exercises
pp: monitor -- Request monitoring support
debugging
pp: Debugging -- Debug a Program Interactively at the Source Level
novice: Exercises
novice: How On-line Documentation Supports Debugging
novice: Common Derived Objects
declaration
tp: Declarations
declarations
ptg: Using LIDO CONSTITUENTS
declarations, scope issues
syntax: Scope rules for declarations
DeclaratorWithId
name: C-like Basic Scope Rules
decomposition
novice: How to Decompose a Text Processing Problem
default behavior for white space
lex: Spaces, Tabs and Newlines
default interface
clp: What happens by default?
default special character
fw: Special Sequences
Defer
type: Basic Type Analysis
type: Operator Identification
Deferred Property Association
type: Operator Identification
DeferredKey
type: Deferred Property Association
define
pp: define -- Set C Pre-Processor Symbols
DefineIdn
name: Environment Module
deftbl: How to create and use definition table keys
lib: Contour-Model Environment
defining occurrences
name:
definition before application
prop: Set a Property at the First Object Occurrence
definition table
novice: Descriptive Mechanisms Known to Eli
novice: How to Decompose a Text Processing Problem
definition table design
deftbl: Definition Table Design Criteria
Definition table keys (DefTableKey)
mon: Trees and Attribute Values
DefinitionsOf
name: Environment Module
DefPt
oldmod: Migration of Eli Version 3.8 modules
DefTableKey
deftbl: How to create and use definition table keys
DefTableKeyList
clp: Accessing options that appear more than once
deftbl.h
deftbl: The Definition Table Module
DeListElem
adt: Lists in LIDO Specifications
DeListRoot
adt: Lists in LIDO Specifications
`delit'
novice: Descriptive Mechanisms Known to Eli
DepAttr
lidoref: Syntax
DepAttrList
lidoref: Syntax
DepAttrs
lidoref: Syntax
dependence among products
pp: Obtaining Information About the Derivation
dependencies
lidoref: Examples
dependency
comptrees: Dependent Computations
dependent domputations
comptrees: Dependent Computations
Dependent Expressions
lidoref: Dependent Expressions
DEPENDS_ON
news4.0: DEPENDS_ON
DependsClause
lidoref: Syntax
derivation
syntax: Context-Free Grammars and Parsing
derivation, structural unparser
idem: Deriving structural unparsers
derivation, structure definition
idem: Obtaining the structure definition
derivation, textual unparser
idem: Deriving textual unparsers
derivation, unparser
idem: Deriving an Unparser
derived file object, output
novice: How to Request Product Manufacture
derived list object, output
novice: How to Request Product Manufacture
derived object
ui: Referring to Objects
novice: Common Derived Objects
derived object cache
novice: Customizing Eli's Behavior
DescribeCoord command
mon: Input Text Display
descriptions of subproblems
novice: Descriptive Mechanisms Known to Eli
development process
novice: Example of Eli Use
dfltrepar.c
syntax: Improving Error Recovery in the Generated Parser
diagnostic products
pp: Diagnosing Specification Inconsistencies
Dir
ui: Variables
DirectInherits
name: Environment Module
directives
pp: ignore -- Do Not Verify include Files
directories
input: Accessing the Current Token
DISPLAY
gorto: Using GORTO within ELI
fw: Introduction
DIV
lidoref: Predefined Entities
documentation
clp: Documentation options and parameters
dofold
lib: Unique Identifier Management
domain-specific modules
pp: inst -- Instantiate a Generic Module
dot
lex: Character classes
double
ptg: Typed Insertion Points
oil: A more complex example
double quote
lex: Matching operator characters
DTD file
idem: Languages describing tree structure
idem: Obtaining the structure definition
dumpidn
lib: Unique Identifier Management
dumpstr
lib: Character String Storage
dvi
fw: Introduction
pp: dvi -- Device-independent TeX typesetter file
dyadic operator
syntax: Mapping expressions for overload resolution
Dynamic Storage Allocation
adt: Mapping Integral Values To Other Types
DynSpace
oldmod: Migration of Eli Version 3.8 modules

E

e
info: Some Advanced Info Commands
info: Interacting with examples using Info
edit command
pp: help -- Cross-Reference to Documentation
editing
novice: Exercises
editing a file object
novice: How to Request Product Manufacture
editing files
mon: Changing files from within Noosa
Editing files in Noosa
news4.3: File and handlers windows
editing files while monitoring
news4.1: Monitoring
EDITOR
info: Info Options.
faq: Is the file `.odinrc' still read?
novice: Hints on Session Management
Elements
lidoref: Syntax
ElemIn
adt: Linear Lists of Any Type
ElemToBitSet
news4.3: Bit Sets of Arbitrary Length
Eli
comptrees: Interactions within Eli
eli command
novice: Hints on Cache Management
Eli package directory
sysadmin: Installing Eli
Eli session
novice: Hints on Session Management
novice: Hints on Cache Management
Eli, typical use
novice: Example of Eli Use
ELI_DEBUGGER
pp: Monitoring -- Monitor a program at the specification level
ELI_DEBUGGER.
pp: Debugging -- Debug a Program Interactively at the Source Level
ELICACHE
faq: Where to Find Eli Locally
elilink
sysadmin: Installing Eli
Emacs
novice: Hints on Session Management
empty .clp files
news4.1: Command-line processing
empty coercion sequence
oil: Coercion sequences
empty input text, representation of
syntax: Conflict resolution by ignoring possible structures
empty output
news4.0: New specification types in PTG
empty rules
news4.1: CHAIN in Empty Rules
empty specification
clp: The general format of the command line
encodings of non-literals
lex: Building processors
EndOfText
lex: Available processors
enter event
mon: Time Profiles
mon: Supporting Profiling
entity
novice: How to Decompose a Text Processing Problem
novice: Managing source text definitions
novice: Managing source text definitions
Environment
name: Environment Module
Environment Module
name: Environment Module
news4.3: Predefined Identifiers
news4.1: Environment Module Enhancements
deftbl: How to create and use definition table keys
Environments (Environment)
mon: Trees and Attribute Values
envmod
name: Environment Module
news4.1: Environment Module Enhancements
envmod.h
lib: Contour-Model Environment
EnvOf
name: Environment Module
EnvOfInherit
name: Environment Module
EOF
syntax: Conflict resolution by ignoring possible structures
EOL markers, inserting
fw: Inserting End of Line Markers
EOL markers, suppressing
fw: Suppressing End of Line Markers
Eol, Ptg-Pattern.
output: Frequently Used Patterns
EQ
lidoref: Predefined Entities
err
novice: Common Derived Objects
err.h
lib: Source Text Coordinates and Error Reporting
ErrLevel
ui: Variables
ERROR
lib: Source Text Coordinates and Error Reporting
novice: Managing source text definitions
pp: error -- Error Reports
novice: Creating structured output text
`ERROR AUTOMATIC'
cola: Options
error coercion
oil: Coercion sequences
error coercion sequence
oil: Coercion sequences
error format
clp: Options that affect usage messages
error messages
problems:
mon: Messages
comptrees: Specification Errors
error report
pp: error -- Error Reports
pp: warning -- Warning Messages and Error Reports
error reported in a modification
syntax: Conflict resolution by ignoring possible structures
error reports during parsing
syntax: Context-Free Grammars and Parsing
error severity
novice: Managing source text definitions
novice: Creating structured output text
ErrorCount
novice: Creating structured output text
lib: Source Text Coordinates and Error Reporting
ErrorInit
lib: Source Text Coordinates and Error Reporting
Errors, lexical
lex: Making White Space Illegal
`eta'
novice: Descriptive Mechanisms Known to Eli
event
mon: Breakpoints and events
mon: Event Types
event counting
mon: Frequency Profiles
event handlers
mon: Breakpoints and events
event parameters
mon: Breakpoints and events
Event tracing dialog box
news4.3: Main window command changes
event type
mon: Event Types
exact right context
syntax: Conflict resolution by ignoring possible structures
examining attributes
mon: Trees and Attribute Values
example
info: Interacting with examples using Info
ptg: A Complete Example
example application
deftbl: A simple definition table application
example language
ptg: Source Language Structure
example of a reduce-reduce conflict
syntax: How the generated parser determines phrase structure
example of a shift-reduce conflict
syntax: How the generated parser determines phrase structure
example of a type-`con' file
syntax: Mapping expressions for overload resolution
example of a type-`map' file
syntax: Mapping expressions for overload resolution
example of debugging
novice: Exercises
example of editing
novice: Exercises
example of obtaining help
novice: Exercises
example of requesting source code
novice: Exercises
example of user-defined actions
syntax: Carrying Out Actions During Parsing
example operation declaration
deftbl: How to declare operations
`example.fw'
idem: Using an Unparser
examples
type: Basic Type Analysis
type:
name:
modlib:
name: Basic Scope Rules
type: Basic Type Analysis
type:
modlib:
modlib:
name:
name: Basic Scope Rules
modlib:
Examples, FunnelWeb
fw: Introduction
exe
pp: exe -- Executable Version of the Processor
novice: Common Derived Objects
fw: Introduction
executable program
pp: exe -- Executable Version of the Processor
executable target
novice: Hints on Session Management
ui: The Odinfile
execution monitoring
pp: Monitoring -- Monitor a program at the specification level
exiting Noosa
mon: Invoking Noosa
expected argument type
oil: Looking at an operator's type signature
expert system
pp: Obtaining Information About the Derivation
ExpInfo
pp: ExpInfo -- Information about remote attribute access
comptrees: Specification Errors
explanation of reports
pp: help -- Cross-Reference to Documentation
exported identifiers
tp: Predefined Entities
ptg: Predefined Entities
Expression
lidoref: Syntax
Expressions
ptg: Expressions
lidoref: Expressions
lidoref: Expressions
expressions for derived objects
ui: Referring to Objects
external modifications, informing Eli
pp: test -- Check Whether an Object has been Modified

F

f
info: Some advanced Info commands
FAQ
faq:
feedback
pp: Obtaining Information About the Derivation
feedback to the user
novice: Hints on Session Management
Field
oldmod: Migration of Eli Version 3.8 modules
file format
mon: Dapto Grammar
file formats
syntax: Grammars for the Specification Files
file name
ptg: Program Frame
file object, editing
novice: How to Request Product Manufacture
file object, output
novice: How to Request Product Manufacture
file target
novice: Hints on Session Management
ui: The Odinfile
filename
fw: Output Files
files, non-product
news4.1: FunnelWeb Output Specification
fw: Output Files
Filter
adt: Lists in LIDO Specifications
FilterListElem
news4.2: LidoList-Module
adt: Lists in LIDO Specifications
finalisation
mon: Breakpoints and events
finalization
novice: Descriptive Mechanisms Known to Eli
FindFile
input: Command Line Arguments for Included Files
finit
mon: Breakpoints and events
finite-state machine
syntax: How the generated parser determines phrase structure
Finl
adt: Linear Lists of Any Type
`FINL.phi'
novice: Descriptive Mechanisms Known to Eli
finlBuf
lib: Text Input
FirstOcc
prop: Check for Unique Object Occurrences
flat range
name: Basic Scope Rules
float
ptg: Typed Insertion Points
floating point numbers
ptg: Output of Data Items
fold
pp: fold -- Make the Processor Case-Insensitive
fonts
mon: X resources used by Noosa
fonts in Noosa
news4.1: Monitoring
ForEachStackElementDown
adt: Stacks of Any Type
ForEachStackElementUp
adt: Stacks of Any Type
formal parameter lists
fw: Formal Parameter Lists
formatted file
pp: ps -- PostScript file
pp: dvi -- Device-independent TeX typesetter file
formatting strategy
idem: Using an Unparser
frame
lib: The Eli Library
free
lib: Memory Object Management
Freq command
mon: Frequency Profiles
frequency profile
mon: Frequency Profiles
FreqZero command
mon: Frequency Profiles
function
comptrees: Value Dependencies
function AddElemToBitSet
adt: Bit Sets of Arbitrary Length
function AddElIS
adt: Bit Sets of Integer Size
function AddIdn
name: Environment Module
function AddRangeToBitSet
adt: Bit Sets of Arbitrary Length
function AddToOrderedSet
adt: Linear Lists of Any Type
function AddToSet
adt: Linear Lists of Any Type
function App
adt: Linear Lists of Any Type
function AppEl
adt: Linear Lists of Any Type
function application
novice: How to Decompose a Text Processing Problem
function ApplyToBitSet
adt: Bit Sets of Arbitrary Length
function BindIdn
name: Environment Module
function BindingInEnv
name: Environment Module
function BindingInScope
name: Environment Module
function BindInScope
name: Environment Module
function BindKey
name: Environment Module
function BindKeyInScope
name: Environment Module
function C_outchar
output: Output String Conversion
function C_outstr
output: Output String Conversion
function call
type: Function Types
Function Call Insertion
ptg: Function Call Insertion
function calls
lidoref: Simple Expressions
function CardIS
adt: Bit Sets of Integer Size
function CardOfBitSet
adt: Bit Sets of Arbitrary Length
function Comp
adt: Linear Lists of Any Type
function ComplBitSet
adt: Bit Sets of Arbitrary Length
function ComplToBitSet
adt: Bit Sets of Arbitrary Length
function Cons
adt: Linear Lists of Any Type
function ConsIS
adt: Bit Sets of Integer Size
function Copy
adt: Linear Lists of Any Type
function declaration
type: Function Types
function DefineIdn
name: Environment Module
function DisjIS
adt: Bit Sets of Integer Size
function DynAlloc
adt: Dynamic Storage Allocation
function DynClear
adt: Dynamic Storage Allocation
function ElemIn
adt: Linear Lists of Any Type
function ElemInBitSet
adt: Bit Sets of Arbitrary Length
function ElemToBitSet
adt: Bit Sets of Arbitrary Length
function EmptyBitSet
adt: Bit Sets of Arbitrary Length
function EmptyIntersectBitSet
adt: Bit Sets of Arbitrary Length
function EmptyIS
adt: Bit Sets of Integer Size
function EqualBitSet
adt: Bit Sets of Arbitrary Length
function EqualIS
adt: Bit Sets of Integer Size
function Filter
adt: Lists in LIDO Specifications
function FindFile
input: Command Line Arguments for Included Files
function Finl
adt: Linear Lists of Any Type
function FinlMap
adt: Mapping Integral Values To Other Types
function FreeBitSet
adt: Bit Sets of Arbitrary Length
function FreeMemBitSet
adt: Bit Sets of Arbitrary Length
function GetCurrTok
input: Insert a File into the Input Stream
function GetMap
adt: Mapping Integral Values To Other Types
function Head
adt: Linear Lists of Any Type
function InclIS
adt: Bit Sets of Integer Size
function InheritClass
name: Environment Module
function Inheritsfrom
name: Environment Module
function InIS
adt: Bit Sets of Integer Size
function InitDynSpace
adt: Dynamic Storage Allocation
function InitMap
adt: Mapping Integral Values To Other Types
function InitMapValues
adt: Mapping Integral Values To Other Types
function InsertAfter
adt: Linear Lists of Any Type
function InterIS
adt: Bit Sets of Integer Size
function IntersectBitSet
adt: Bit Sets of Arbitrary Length
function IntersectToBitSet
adt: Bit Sets of Arbitrary Length
function IthElem
adt: Linear Lists of Any Type
function KeyInEnv
name: Environment Module
function KeyInScope
name: Environment Module
function Length
adt: Linear Lists of Any Type
function Map
adt: Linear Lists of Any Type
function MapFct
adt: Linear Lists of Any Type
function NewBitSet
adt: Bit Sets of Arbitrary Length
function NewInput
input: Insert a File into the Input Stream
input: Command Line Arguments for Included Files
function NextElemInBitSet
adt: Bit Sets of Arbitrary Length
function NextInhBinding
name: Environment Module
function NextInhKey
name: Environment Module
function NullIS
adt: Bit Sets of Integer Size
function OrderedInsert
adt: Linear Lists of Any Type
function outstr
output: Output String Conversion
function OverridesBinding
name: Environment Module
function P_outstr
output: Output String Conversion
function PreDefine
name: Predefined Identifiers
name: Predefined Identifiers
function PreDefineSym
name: Predefined Identifiers
name: Predefined Identifiers
function PrintBitSet
adt: Bit Sets of Arbitrary Length
function PrintElemsBitSet
adt: Bit Sets of Arbitrary Length
function RefEndApp
adt: Linear Lists of Any Type
function RefEndCons
adt: Linear Lists of Any Type
function SetMap
adt: Mapping Integral Values To Other Types
function signature
ptg: Function Call Insertion
ptg: Typed Insertion Points
ptg: Pattern Specifications
function Single
adt: Linear Lists of Any Type
function SingleIS
adt: Bit Sets of Integer Size
function SubElemFromBitSet
adt: Bit Sets of Arbitrary Length
function SubIS
adt: Bit Sets of Integer Size
function SubtractBitSet
adt: Bit Sets of Arbitrary Length
function SubtractFromBitSet
adt: Bit Sets of Arbitrary Length
function Sum
adt: Linear Lists of Any Type
function SumFct
adt: Linear Lists of Any Type
function Tail
adt: Linear Lists of Any Type
function TransDefer
type: Basic Type Analysis
function type
adt:
function types
type: Pointer Types
function UnionToBitSet
adt: Bit Sets of Arbitrary Length
function UniteBitSet
adt: Bit Sets of Arbitrary Length
function UniteIS
adt: Bit Sets of Integer Size
function, node construction
tp: Node Construction Functions
FunctionName
lidoref: Syntax
functions, printing
novice: How to Decompose a Text Processing Problem
functions, text generation
novice: How to Decompose a Text Processing Problem
FunnelWeb
pp: Producing Formatted Documents
news4.3: FunnelWeb
FunnelWeb Example
fw: Introduction
FunnelWeb files
news4.1: FunnelWeb Output Specification
FunnelWeb typesetters
news4.2: New FunnelWeb Typesetter Support
`fw'
novice: Creating structured output text
novice: Descriptive Mechanisms Known to Eli
Fwd
oldmod: Migration of Eli Version 3.8 modules
fwGen
pp: fwGen -- Obtain the Product Files Generated by FunnelWeb
fwHtml
pp: fwHtml -- HTML file
fwTex
pp: fwTex -- TeX input file
fwTexinfo
fw: Introduction

G

g
info: Some Advanced Info Commands
GChain
oldmod: Migration of Eli Version 3.8 modules
GDB
pp: Debugging -- Debug a Program Interactively at the Source Level
novice: Exercises
pp: Debugging -- Debug a Program Interactively at the Source Level
GE
lidoref: Predefined Entities
gencode
novice: Common Derived Objects
novice: Exercises
pp: gencode -- Code Derived from the Specifications
general format
clp: The general format of the command line
generated files
pp: gencode -- Code Derived from the Specifications
pp: help -- Cross-Reference to Documentation
generated program, characteristics
novice: How Eli Creates a Text Processing Program
generated trees
news4.1: Bottom-up Evaluation
GenerateName
problems: Generating Optional Identifiers
Generating Identifiers
ptg: Generating Identifiers
Generating Output
output:
generation of program text
novice: How to Decompose a Text Processing Problem
generation, parser
pp: parsable -- Verify that the Grammar is Parsable
generic module
novice: Managing source text definitions
novice: Managing source text definitions
novice: Descriptive Mechanisms Known to Eli
novice: Creating structured output text
generic modules, naming instances
pp: instance -- Name an Instance of a Generic Module
generic modules, user-constructed
pp: inst -- Instantiate a Generic Module
GenName
oldmod: Migration of Eli Version 3.8 modules
GENTREE
lidoref: Predefined Entities
lidoref: Examples
Get
deftbl: How to declare operations
Get operations
deftbl: Behavior of the basic query operations
GetClpValue
clp: Accessing options with string values
clp: Accessing options with integer values
GetKind
prop: Associate Kinds to Objects
GetKindSet
prop: Associate Sets of Kinds to Objects
GetScope
name: Scope Properties without Ordering Restrictions
name: Scope Properties C-like
GetScopeProp
name: Scope Properties C-like Bottom-Up
`gla'
novice: Descriptive Mechanisms Known to Eli
comptrees: Tree Construction
glalex
lex: The Generated Lexical Analyzer Module
`gnrc'
novice: Descriptive Mechanisms Known to Eli
GNU debugger
pp: Debugging -- Debug a Program Interactively at the Source Level
GORTO.bak
gorto: Using GORTO within ELI
GORTO.ctl
gorto: Using GORTO within ELI
GotAllInh
name: Inheritance with Algol-like Scope Rules
GotDeferProp
type: Deferred Property Association
GotInh
name: Inheritance of Scopes
GotInhNest
name: Inheritance with Algol-like Scope Rules
GotInhScopes
name: Inheritance with C-like Scope Rules
name: Inheritance with Algol-like Scope Rules
name: Inheritance of Scopes
GotProp
type: Basic Type Analysis
GotScopes
oldmod: Migration of Eli Version 3.8 modules
GotScopesDefs
oldmod: Migration of Eli Version 3.8 modules
GotType
type: Basic Type Analysis
grammar
lex: Specifications
syntax: Context-Free Grammars and Parsing
grammar changes to resolve ambiguity
syntax: Conflict resolution by changing the grammar
grammar development
novice: Specifying the desired phrase structure
grammar listing
clp: Complete Grammar Listing
grammar root
news4.1: Grammar Root Symbol
grammar rule
novice: How to Decompose a Text Processing Problem
growth
lib: Memory Object Management
GT
lidoref: Predefined Entities

H

halt of the parser
syntax: How the generated parser determines phrase structure
Handlers command
mon: Breakpoints and events
HEAD
lidoref: Examples
news4.1: CHAIN in Empty Rules
novice: Creating structured output text
comptrees: Left-to-Right Dependencies
adt: Linear Lists of Any Type
head of coercion sequence
oil: Coercion sequences
`HEAD.phi'
novice: Descriptive Mechanisms Known to Eli
header file
pp: source -- Source Version of the Processor
header files
mon: Header Files
help
pp: help -- Cross-Reference to Documentation
novice: Exercises
novice: How On-line Documentation Supports Debugging
novice: Common Derived Objects
help derivation
comptrees: Specification Errors
help request to Eli
novice: Hints on Session Management
HelpLevel
ui: Variables
Hiding of attributes
gorto: The Main Window
History
ui: Variables
novice: Exercises
hypertext
pp: help -- Cross-Reference to Documentation

I

Id, Ptg Pattern
output: Frequently Used Patterns
IdDef
oldmod: Migration of Eli Version 3.8 modules
IdDefScope
name: Basic Scope Rules
novice: Managing source text definitions
name: C-like Basic Scope Rules
name: Algol-like Basic Scope Rules
IdDefScopeProp
oldmod: Migration of Eli Version 3.8 modules
oldmod: Migration of Eli Version 3.8 modules
IdDefUse
name: C-like Basic Scope Rules
idem
news4.1: Abstract Syntax Tree Unparsing
idem: Deriving textual unparsers
Idem and literal chain rules
syntax: Complete generated concrete and abstract syntaxes
`Idem.fw'
idem: Languages describing tree structure
IdemOrigPtg attribute
idem: Changing IdemPtg computations
IdemPtg
idem: Computations for plain productions
idem: Computations for LISTOF productions
idem: Computations for plain productions
IdemPtg, computation
idem: Changing IdemPtg computations
idem: Changing Structure or Representation
IdemPtg, overriding
idem: Changing IdemPtg computations
IdemReproduce
idem: Computations for plain productions
idem: Computations for plain productions
IdemReproduce_X
idem: Computations for LISTOF productions
idem: Computations for LISTOF productions
IDENTICAL
lidoref: Predefined Entities
identifier
ptg: Generating Identifiers
tp: Summary of the Specification Language
novice: How to Decompose a Text Processing Problem
oil: A review of an example OIL Specification
identifier declarations, scope issues
syntax: Scope rules for declarations
identifier occurrence
prop: Common Aspects of Property Modules
identifier output
pp: fold -- Make the Processor Case-Insensitive
identifier roles
name:
identifier table
novice: Descriptive Mechanisms Known to Eli
identifier, form of
syntax: How to describe a context-free grammar
identifier, in odin-expressions
novice: Common Derived Objects
identifiers
ptg: Output of Data Items
ptg: Syntax of PTG Specifications
ptg: Typed Insertion Points
lidoref: Syntax
lidoref: Examples
IdGetScopeProp
oldmod: Migration of Eli Version 3.8 modules
IdInDeclarator
name: C-like Basic Scope Rules
idn.c
lib: Unique Identifier Management
idn.h
lib: Unique Identifier Management
IdnNumb
problems: Generating Optional Identifiers
IdnOf
name: Environment Module
IdSetScopeProp
name: Scope Properties C-like Bottom-Up
IdUse
oldmod: Migration of Eli Version 3.8 modules
IdUseEnv
name: C-like Basic Scope Rules
name: Algol-like Basic Scope Rules
name: Basic Scope Rules
IdUseScope
name: Algol-like Basic Scope Rules
name: Basic Scope Rules
oldmod: Migration of Eli Version 3.8 modules
name: C-like Basic Scope Rules
IdUseScopeProp
type: Types Having Scope Properties
name: Scope Properties C-like
name: Scope Properties C-like Bottom-Up
name: Scope Properties without Ordering Restrictions
IF
lidoref: Predefined Entities
ignore
pp: ignore -- Do Not Verify include Files
IGNORE macro
idem: Overriding PTG patterns
illegal operator
oil: Validating operator identification
implementation
tp: Implementing Actions
implementation of C entities
comptrees: Implementing Tree Computations
implementing monitoring interfaces
mon: Implementing Monitoring Interfaces
implicit definitions
name: Basic Scope Rules
impossible coercion
oil: Coercion sequence
InclLido
oldmod: Migration of Eli Version 3.8 modules
include
pp: ignore -- Do Not Verify include Files
oldmod: Migration of Eli Version 3.8 modules
tp: Summary of the Specification Language
include directive
novice: Descriptive Mechanisms Known to Eli
novice: Descriptive Mechanisms Known to Eli
novice: Descriptive Mechanisms Known to Eli
include files
mon: Header Files
fw: Include Files
INCLUDING
comptrees: Remote Dependencies in Trees
lidoref: INCLUDING
news4.0: Terminals
comptrees: Basic Symbol Computations
comptrees: Access to a Subtree Root
lidoref: Remote Attribute Access
inconsistencies
pp: Diagnosing Specification Inconsistencies
incremental design
oil: Incremental Design and Implementation
IndCatStrStr
problems: Error Reports
Indent
oldmod: Migration of Eli Version 3.8 modules
indentation
ptg: Function Call Insertion
output: Additional functions
output: Special Situation when Using C String Literals
output: Additional functions
fw: Indentation
indentation, blank
fw: Indentation
indentation, none
fw: Indentation
index
lidoref: Syntax
lidoref: Examples
lidoref: Syntax
Indexed Insertion Points
ptg: Indexed Insertion Points
indexed insertion points, order of
idem: Computations for plain productions
`INFO'
cola: Options
INFORUNDISPLAY
info: Info Options.
INH
comptrees: Value Dependencies
lidoref: Types and Classes of Attributes
lidoref: Attributes
lidoref: Examples
comptrees: Basic Symbol Computations
lidoref: Syntax
lidoref: Examples
Inheritance
lidoref: Syntax
novice: Managing source text definitions
name: Environment Module
comptrees: Supplying Tree Computation Specifications to Eli
name: Inheritance of Scopes
lidoref: Syntax
comptrees: Reuse of Symbol Computations
lidoref: Inheritance of Computations
name: Inheritance with Algol-like Scope Rules
Inheritance of Computations
lidoref: Inheritance of Computations
inheritance of scopes
name: Scope Properties C-like Bottom-Up
inheritance relation
lidoref: Syntax
InheritClass
name: Environment Module
name: Inheritance of Scopes
inherited
comptrees: Value Dependencies
lidoref: Attributes
lidoref: Examples
lidoref: Types and Classes of Attributes
inherited attribute
lidoref: Syntax
InheritOk
name: Inheritance of Scopes
name: Inheritance of Scopes
InheritPtr
name: Environment Module
INHERITS
lidoref: Syntax
comptrees: Reuse of Symbol Computations
novice: Managing source text definitions
InheritScope
name: C-like Inheritance Bottom-Up
name: Inheritance of Scopes
name: Inheritance with C-like Scope Rules
name: Inheritance with Algol-like Scope Rules
name: C-like Inheritance Bottom-Up
InheritScopeProp
oldmod: Migration of Eli Version 3.8 modules
Inheritsfrom
name: Environment Module
InhKey
name: Inheritance of Scopes
InhPrecond
name: C-like Inheritance Bottom-Up
init event type
mon: Breakpoints and events
`INIT.phi'
novice: Descriptive Mechanisms Known to Eli
initBuf
lib: Text Input
initialisation
mon: Breakpoints and events
mon: User Initialisation
initialization
novice: Descriptive Mechanisms Known to Eli
initialization grammar
deftbl: How to specify the initial state
InnerScope
name: Inheritance of Scopes
input
clp: Input parameters
input file
clp: What happens by default?
input file inclusion
input: Accessing the Current Token
input:
input file insertion
input:
input file line length
fw: Maximum Input Line Length
fw: Introduction
input paramater
clp: Accessing positional parameters
input parameter
clp: Input parameters
input parameters
news4.0: New command-line processing features
Input Processing
input:
input text display
mon: Input Text Display
inputs
pp: inputs -- Objects on which a Given Object Depends
InsertAfter
adt: Linear Lists of Any Type
inserting arbitrary characters into text
fw: Inserting Arbitrary Characters into the Text
inserting control characters into text
fw: Inserting Arbitrary Characters into the Text
inserting EOL markers
fw: Inserting End of Line Markers
inserting special character into text
fw: Inserting the Special Character into the Text
insertion point
ptg: Typed Insertion Points
ptg: Pattern Specifications
ptg: Indexed Insertion Points
insertion points
lidoref: Examples
lidoref: Predefined Entities
inst
pp: inst -- Instantiate a Generic Module
inst-derivation
news4.1: Instanciation of Modules with Filenames
installation
sysadmin: Installing Eli
instance
pp: instance -- Name an Instance of a Generic Module
instance names
modlib: Instantiation and Use of Modules
instance parameter
modlib: Instantiation and Use of Modules
instanciating modules from .fw-files
news4.1: Instanciation of Modules with Filenames
instantiation
prop:
modlib: Running Example
novice: Managing source text definitions
pp: inst -- Instantiate a Generic Module
int
lidoref: Predefined Entities
clp: Options that have a value given with them
ptg: Typed Insertion Points
ptg: Output of Data Items
integer values
clp: Options that have a value given with them
interactive
pp: help -- Cross-Reference to Documentation
pp: Debugging -- Debug a Program Interactively at the Source Level
interactive Eli session
novice: Hints on Session Management
interface file
tp: Predefined Entities
ptg: Introduction to PTG
ptg: Predefined Entities
interior node
syntax:
intermediate products
pp: Obtaining Information About the Derivation
internal code
pp: printtokens -- Request Token Printing Code
intrinsic value
pp: printtokens -- Request Token Printing Code
Introduction
ptg: Introduction to PTG
lidoref: Introduction
ints
clp: Options that have a value given with them
IntSet
oldmod: Migration of Eli Version 3.8 modules
prop: Associate Sets of Kinds to Objects
IntToKey
oldmod: Migration of Eli Version 3.8 modules
IntToPtr
oldmod: Migration of Eli Version 3.8 modules
invalid key
deftbl: How to create and use definition table keys
invoking Noosa
mon: Invoking Noosa
invoking type-gnrc scripts
pp: inst -- Instantiate a Generic Module
IPC not available
faq: Eli reports Remote IPC not available on this host
Is
deftbl: Predefined query and update operations
news4.0: Chain Productions
deftbl: How to declare operations
IsClass
name: Environment Module
IsName
deftbl: Predefined query and update operations
IsType
type: Basic Type Analysis
ITERATE
lidoref: Syntax
Iteration
lidoref: Syntax
lidoref: Syntax
Iterations
lidoref: Iterations
IthElem
adt: Linear Lists of Any Type

J

Java
news4.4: New functionality for unparser generation
idem: Languages describing tree structure
`Java.fw'
idem: Languages describing tree structure
Joined Ranges
name: Predefined Identifiers
joined value options
clp: Options that are joined to their values
joinedto
clp: Options that are joined to their values

K

KeepGoing
ui: Variables
key
prop:
name:
novice: How to Decompose a Text Processing Problem
deftbl: How to create and use definition table keys
KeyInEnv
name: Environment Module
lib: Contour-Model Environment
KeyInRange
lib: Contour-Model Environment
KeyInScope
name: Environment Module
KeyOf
name: Environment Module
KeyOfEnv
name: Environment Module
keyword
pp: kwd -- Recognize Specified Literals as Identifiers
Kill command
mon: Controlling Your Program
Kind
prop: Map Objects to Integers
kinds of unparser
idem: Available Kinds of Unparser
KindSet
prop: Associate Kinds to Objects
oldmod: Migration of Eli Version 3.8 modules
known keys
deftbl: How to specify the initial state
KReset
type: Pointer Types
prop: Some Useful PDL Specifications
kwd
pp: kwd -- Recognize Specified Literals as Identifiers

L

l
info: Some advanced Info commands
LALR(1) condition
novice: Exercises
last modification
pp: test -- Check Whether an Object has been Modified
latex
news4.2: New FunnelWeb Typesetter Support
latex2html
news4.2: New FunnelWeb Typesetter Support
layout
idem: Using an Unparser
idem: Computations for plain productions
LE
lidoref: Predefined Entities
leaf
tp: Tree Structure
leaf node
syntax:
Leaf Pattern
ptg: Outdated Constructs
LeafPtg
novice: Creating structured output text
novice: Creating structured output text
oldmod: Migration of Eli Version 3.8 modules
leave event
mon: Supporting Profiling
mon: Time Profiles
left-associative
syntax: Operator associativity
Length
adt: Linear Lists of Any Type
length of a line
lib: Text Input
letters, case of
pp: fold -- Make the Processor Case-Insensitive
lexerr
lex: Available processors
news4.2: New token processor lexerr
news4.3: Detecting lexical errors explicitly
lexical analysis
novice: How to Decompose a Text Processing Problem
mon: Lexical Structure
lexical analyzer
syntax: How to describe a context-free grammar
Lexical errors
lex: Making White Space Illegal
lexical structure
mon: Lexical Structure
Library
faq: Eli doesn't find module include files any more
modlib:
pp: inst -- Instantiate a Generic Module
Library Adt
adt:
library functions
oil: OIL's Support Library
Library Input
input:
Library Name
name:
Library Output
output:
Library Prop
prop:
library routine
pp: source -- Source Version of the Processor
Library Tech
problems:
Library Type
type:
LIDO
ptg: Using LIDO CHAINs
ptg: Using LIDO CONSTITUENTS
lidoref: Introduction
novice: Descriptive Mechanisms Known to Eli
ptg: Expressions
ptg: A Complete Example
LidoList
news4.3: Lists in LIDO Specifications
type: Function Types
LidoList-Module
news4.2: LidoList-Module
LIGA
lidoref: Introduction
LIGAPragma
lidoref: Pragmas
news4.0: Bottom-Up Evaluation
LINE
news4.0: LINE, COL, COORDREF
name: Name Analysis Test
lidoref: Predefined Entities
line comments
lidoref: Syntax
line width
output: Additional functions
output: Additional functions
linear lists
adt:
adt: Lists in LIDO Specifications
LineNum
lib: Source Text Coordinates and Error Reporting
lex: Maintaining the Source Text Coordinates
LineOf
lib: Source Text Coordinates and Error Reporting
Lines in a FunnelWeb file
news4.3: FunnelWeb
linked list
clp: Accessing options that appear more than once
lint
novice: Exercises
lisedit
lib: Source Text Coordinates and Error Reporting
List
oldmod: Migration of Eli Version 3.8 modules
ptg: Output of Sequences
adt: Linear Lists of Any Type
news4.3: Linear Lists of Any Type
list functions
adt: Lists in LIDO Specifications
list object, output
novice: How to Request Product Manufacture
list separators
syntax: Improving Error Recovery in the Generated Parser
List-Module
news4.2: List-Module
LISTEDTO
news4.0: Type Definitions
ListElem
adt: Lists in LIDO Specifications
news4.2: LidoList-Module
LISTOF
news4.0: Terminals in LISTOF productions
lidoref: Syntax
lidoref: Terminals
LISTOF production
comptrees: Tree Structure
LISTOF productions
lidoref: Tree Construction Functions
idem: Textual unparser
LISTOF productions, computations
idem: Computations for LISTOF productions
idem: Computations for LISTOF productions
ListPtr
adt: Linear Lists of Any Type
ListRoot
adt: Lists in LIDO Specifications
literal
novice: Nonliteral character sequences and comments
novice: Descriptive Mechanisms Known to Eli
novice: How to Decompose a Text Processing Problem
literal chain rules
syntax: Chain rule definitions
literal chain rules and Idem
syntax: Complete generated concrete and abstract syntaxes
literal chain rules, preserving
syntax: Preserving literal chain rules
syntax: Complete generated concrete and abstract syntaxes
literal terminal
comptrees: Tree Structure
literal terminals
lidoref: Examples
literal terminals, reconstruction
idem: Textual unparser
idem: Textual unparser
idem: Computations for plain productions
literal, form of
syntax: How to describe a context-free grammar
literals
lidoref: Simple Expressions
literals, abstraction from
syntax: Abstracting information from literals
literate programming
fw:
LogLevel
pp: Obtaining Information About the Derivation
novice: Exercises
novice: Hints on Session Management
ui: Variables
long
ptg: Typed Insertion Points
longest match
lex: What happens if the specification is ambiguous?
lower case
pp: fold -- Make the Processor Case-Insensitive
lower computation
lidoref: Examples
lower computations
lidoref: Syntax
lower context
lidoref: Attributes
comptrees: Tree Structure
novice: Managing source text definitions
LT
lidoref: Predefined Entities
LTType
type: Operator Identification
LType
type: Operator Identification

M

m
info: Menus and the M command
`M3.specs'
idem: Deriving structural unparsers
idem: Languages describing tree structure
macro attributes
fw: Macros
macro definition
novice: Descriptive Mechanisms Known to Eli
macro names
fw: Names
macro parameter delimiting
fw: Macro Calls
mail
info: Complaining about things
Main Menu
gorto: The Main Window
main program, omitting
pp: nomain -- Omitting the main program
Main Window
gorto: The Main Window
maintainer
info: Complaining about things
makefile
pp: source -- Source Version of the Processor
MakeName
problems: Generating Optional Identifiers
malloc
lib: Memory Object Management
Map
adt: Linear Lists of Any Type
novice: Descriptive Mechanisms Known to Eli
`map' file, example
syntax: Mapping expressions for overload resolution
`map' file, format
syntax: Grammars for the Specification Files
MAPCHAINS keyword
syntax: Complete generated concrete and abstract syntaxes
syntax: Preserving literal chain rules
MapFct
adt: Linear Lists of Any Type
mapping
comptrees: Tree Construction
Maptool
syntax:
comptrees: Tree Construction
MaxBuilds
ui: Variables
maximum input line length
fw: Introduction
fw: Maximum Input Line Length
maximum output line length
fw: Introduction
fw: Output Length
maximum product file line length
fw: Output Length
meaning of a construct
syntax: Using structure to convey meaning
member selection
type: Function Types
memory exhaustion
lib: Memory Object Management
menu
info: Menus and the M command
message
novice: Managing source text definitions
problems: Error Reports
oldmod: Migration of Eli Version 3.8 modules
lib: Source Text Coordinates and Error Reporting
messages
mon: Messages
problems:
minus
lex: Character classes
missing definition
name: Basic Scope Rules
Mk functions
news4.4: Eli-generated code as a component
Mk-Functions
lidoref: Tree Construction Functions
mkidn
lex: Definitions of Canned Descriptions
idem: Overriding PTG patterns
pp: fold -- Make the Processor Case-Insensitive
lex: A Case-Insensitive Token Processor
novice: Nonliteral character sequences and comments
lex: Available processors
lib: Unique Identifier Management
lex: Canned Symbol Descriptions
mkint
idem: Overriding PTG patterns
lex: Available processors
lex: Token Processors
mkstr
lex: Definitions of Canned Descriptions
lex: Definitions of Canned Descriptions
lex: Definitions of Canned Descriptions
lex: Definitions of Canned Descriptions
lex: Available processors
novice: How to Decompose a Text Processing Problem
faq: Why does C_STRING_LIT not use c_mkstr?
MOD
lidoref: Predefined Entities
Modification of Partitions
gorto: Symbols
modification specification
syntax: Conflict resolution by ignoring possible structures
Modification visit-sequences
gorto: Visit-sequences
modification, checking for
pp: test -- Check Whether an Object has been Modified
modifications to resolve ambiguity
syntax: Conflict resolution by ignoring possible structures
MODULA2_CHARINT
lex: Available Descriptions
lex: Definitions of Canned Descriptions
MODULA2_COMMENT
lex: Definitions of Canned Descriptions
lex: Available Descriptions
MODULA2_INTEGER
lex: Definitions of Canned Descriptions
lex: Available Descriptions
MODULA2_LITERALDQ
lex: Definitions of Canned Descriptions
lex: Available Descriptions
MODULA2_LITERALSQ
lex: Definitions of Canned Descriptions
lex: Available Descriptions
MODULA3_COMMENT
lex: Available Descriptions
lex: Definitions of Canned Descriptions
MODULA_INTEGER
lex: Definitions of Canned Descriptions
modula_mkint
lex: Definitions of Canned Descriptions
lex: Available processors
Module
faq: Eli doesn't find module include files any more
Module AlgInh
name: Inheritance of Scopes
Module AlgRangeSeq
name: Joined Ranges
Module AlgScope
name: Basic Scope Rules
Module AlgScopeProp
name: Scope Properties without Ordering Restrictions
Module BitSet
adt: Bit Sets of Arbitrary Length
oldmod: Migration of Eli Version 3.8 modules
Module BuInh
name: Inheritance with C-like Scope Rules
Module BuRangeSeq
name: Joined Ranges C-like
Module BuScope
name: C-like Basic Scope Rules
Module BuScopeProp
name: Scope Properties C-like
Module BuType
oldmod: Migration of Eli Version 3.8 modules
Module CInh
name: Inheritance with Algol-like Scope Rules
Module CmdLineIncl
input: Accessing the Current Token
Module CoordMap
input:
Module Counter
problems: String Concatenation
Module CRangeSeq
name: Joined Ranges Algol-like
Module CScope
name: Algol-like Basic Scope Rules
Module CScopeProp
name: Scope Properties Algol-like
Module CType
oldmod: Migration of Eli Version 3.8 modules
Module CurrTok
input: Insert a File into the Input Stream
Module Defer
type: Basic Type Analysis
type: Operator Identification
Module DynSpace
oldmod: Migration of Eli Version 3.8 modules
adt: Mapping Integral Values To Other Types
Module envmod
name: Environment Module
Module FirstOcc
prop: Check for Unique Object Occurrences
Module GlaCorr
input:
Module Include
input:
Module Indent
output: Special Situation when Using C String Literals
Module IntSet
adt: Bit Sets of Integer Size
prop: Associate Sets of Kinds to Objects
Module Kind
prop: Map Objects to Integers
Module KindSet
prop: Associate Kinds to Objects
Module LeafPtg
output:
oldmod: Migration of Eli Version 3.8 modules
module library
comptrees: Supplying Tree Computation Specifications to Eli
Module LidoList
adt:
news4.2: LidoList-Module
type: Pointer Types
Module List
news4.2: List-Module
oldmod: Migration of Eli Version 3.8 modules
adt: Lists in LIDO Specifications
Module MakeName
problems: Counting Symbol Occurrences
Module Map
adt: Stacks of Any Type
Module Message
problems:
Module ObjCnt
prop: Determine First Object Occurrence
Module OccCnt
prop: Count Occurrences of Objects
Module Operator
type: Types Having Scope Properties
Module OutStr
output: Indentation
Module PreDefId
name: C-like Basic Scope Rules Computed Bottom-Up
Module PreDefine
name: C-like Basic Scope Rules Computed Bottom-Up
Module PreDefMod
name: Predefined Identifiers
Module PropLib
prop: Reflexive Relations Between Objects
type: Deferred Property Association
oldmod: Migration of Eli Version 3.8 modules
Module PtgCommon
output: PTG Output for Leaf Nodes
Module PtrList
adt: Linear Lists of Any Type
Module Reflex
prop: Associate Sets of Kinds to Objects
Module ScopeProp
name: Scopes Being Properties of Objects
Module SetFirst
prop: Set a Property at the First Object Occurrence
Module ShowBinding
name: C-like Inheritance Bottom-Up
Module Sort
problems: Generating Optional Identifiers
Module Stack
adt: Stacks of Any Type
Module Type
oldmod: Migration of Eli Version 3.8 modules
Module Unique
prop: Set a Property at the First Object Occurrence
module, block print
idem: Computations for plain productions
module, generic
novice: Managing source text definitions
module, separator
idem: Computations for plain productions
Modules for Name Analysis
oldmod: Migration of Eli Version 3.8 modules
mon
pp: monitor -- Request monitoring support
pp: Monitoring -- Monitor a program at the specification level
mon: Invoking Noosa
pp: Monitoring -- Monitor a program at the specification level
monadic operator
syntax: Mapping expressions for overload resolution
mondbx
news4.0: New interface to monitoring
mondbx is no longer supported
news4.3: Monitoring products
mongdb
news4.0: New interface to monitoring
mon: Invoking Noosa
pp: monitor -- Request monitoring support
pp: Monitoring -- Monitor a program at the specification level
pp: Monitoring -- Monitor a program at the specification level
mongdb is now working
news4.3: Monitoring products
mongdb and +arg
news4.3: Monitoring products
monitor
pp: monitor -- Request monitoring support
lex: Returning a classification
monitoring
news4.0: New interface to monitoring
novice: Common Derived Objects
news4.1: Monitoring
pp: Monitoring -- Monitor a program at the specification level
pp: monitor -- Request monitoring support
news4.3: Monitoring
monitoring database
mon: Implementing Monitoring Interfaces
mon: Monitoring Database
monitoring interface
mon: Monitoring Interfaces
monitoring interface implementation
mon: Implementing Monitoring Interfaces
monitoring non-standard types
mon: Non-standard types
monitoring support
mon: Adding Monitoring Support To A Component
mouse buttons
mon: Invoking Noosa
move by the parser
syntax: How the generated parser determines phrase structure
move determined by input symbol
syntax: How the generated parser determines phrase structure
MUL
lidoref: Predefined Entities
Multiple +arg parameters
news4.3: Monitoring products
multiple caches
novice: Hints on Cache Management
multiple inheritance
lidoref: Inheritance of Computations
multiple operator definition
oil: Operator definition
multiple option strings
news4.1: Command-line processing
clp: Multiple option strings for the same option
multiple property definitions
deftbl: How to declare properties

N

n
info: Help
n(aspects)
mon: Monitoring Database
n(events)
mon: Monitoring Database
n_dectohex
mon: Browsing non-standard types
n_hextodec
mon: Browsing non-standard types
n_say in browsing support
mon: Browsing non-standard types
n_say in handlers
mon: Breakpoints and events
n_say_val
mon: Browsing non-standard types
n_send in browsing support
mon: Browsing non-standard types
n_send to invoke operations
mon: Breakpoints and events
name analysis
name:
pp: inst -- Instantiate a Generic Module
name analysis test
news4.1: Module for Testing Name Analysis
name of a derived object
novice: Common Derived Objects
name spaces
name: Environment Module
name, of an object
ui: Referring to Objects
named terminal
lidoref: Tree Construction Functions
comptrees: Tree Structure
named terminals
lidoref: Terminal Access
lidoref: Outdated Constructs
lidoref: Examples
names
oil: Using Names
name:
oil: Name Functions
lidoref: Examples
fw: Names
oil: Names for operators, types and classes
names, quick
fw: Quick Names
naming instances of generic modules
pp: instance -- Name an Instance of a Generic Module
NE
lidoref: Predefined Entities
NEG
lidoref: Predefined Entities
Nest
oldmod: Migration of Eli Version 3.8 modules
nested ranges
name: Tree Grammar Preconditions
nested regions
novice: Managing source text definitions
NEW_LINE
lex: Available Descriptions
lex: Definitions of Canned Descriptions
NewEnv
lib: Contour-Model Environment
name: Environment Module
NewInput
input: Insert a File into the Input Stream
input: Insert a File into the Input Stream
input: Accessing the Current Token
NewKey
deftbl: The Definition Table Interface
deftbl: How to create and use definition table keys
newline
ptg: Output Functions
ptg: Syntax of PTG Specifications
newline character
novice: Nonliteral character sequences and comments
newline defaults
lex: Spaces, Tabs and Newlines
newlines
lib: Text Input
NewScope
name: Environment Module
lib: Contour-Model Environment
name: C-like Inheritance Bottom-Up
NewStorage
lib: Storage Layout
next
info: Help
NextDefinition
name: Environment Module
NextInhBinding
name: Environment Module
NextInherit
name: Environment Module
NextInhKey
name: Environment Module
NoBinding
name: Environment Module
NoCoord
lib: Source Text Coordinates and Error Reporting
node
novice: How to Decompose a Text Processing Problem
info: Help
tp: Rules
syntax:
Node command
news4.3: Trees
node construction function
tp: Node Construction Functions
NODEPTR
lidoref: Examples
lidoref: Tree Construction Functions
lidoref: Predefined Entities
NoEnv
name: Environment Module
NoIdn
lib: Unique Identifier Management
NoInherit
name: Environment Module
NoKey
deftbl: Behavior of the basic update operations
type: Basic Type Analysis
novice: How to Decompose a Text Processing Problem
deftbl: Behavior of the basic query operations
deftbl: The Definition Table Interface
clp: Accessing options with integer values
deftbl: How to create and use definition table keys
NoKeyMsg
oldmod: Migration of Eli Version 3.8 modules
nomain
pp: nomain -- Omitting the main program
non-associative
syntax: Operator associativity
non-interactive Eli session
novice: Hints on Session Management
non-literal terminal symbols
idem: Overriding PTG patterns
non-product files
fw: Output Files
non-product output files
news4.1: FunnelWeb Output Specification
non-standard types, browsing support
mon: Browsing non-standard types
non-standard types, monitoring
mon: Non-standard types
nonliteral symbol
novice: Nonliteral character sequences and comments
nonterminal
lidoref: Examples
tp: The Tree Patterns
comptrees: Tree Structure
nonterminal symbol
novice: How to Decompose a Text Processing Problem
nonterminal symbols in a grammar
syntax: How to describe a context-free grammar
nonterminal types
tp: Actions and Values
Noosa
news4.1: Monitoring
news4.0: New interface to monitoring
pp: monitor -- Request monitoring support
news4.3: Monitoring
mon:
pp: Monitoring -- Monitor a program at the specification level
Noosa handlers
news4.3: File and handlers windows
Noosa keyboard accelerators
news4.3: Main window command changes
Noosa searching and saving
news4.3: Main window command changes
Noosa tearoff menus
news4.3: Main window command changes
Noosa tree displays
news4.3: Trees
Noosa X resources
news4.3: Configuring Noosa
Noosa.fileHeight
mon: X resources used by Noosa
Noosa.fileWidth
mon: X resources used by Noosa
Noosa.handHeight
mon: X resources used by Noosa
Noosa.inputHeight
mon: X resources used by Noosa
Noosa.nodeColour
mon: X resources used by Noosa
Noosa.transHeight
mon: X resources used by Noosa
Noosa.treeCompHeight
mon: X resources used by Noosa
Noosa.treeCompWidth
mon: X resources used by Noosa
Noosa.treeFullHeight
mon: X resources used by Noosa
Noosa.treeFullWidth
mon: X resources used by Noosa
Noosa.treeHeight
mon: X resources used by Noosa
Noosa.treeIncrHeight
mon: X resources used by Noosa
Noosa.treeIncrWidth
mon: X resources used by Noosa
Noosa.treeSrcHeight
mon: X resources used by Noosa
Noosa.treeSrcWidth
mon: X resources used by Noosa
Noosa.treeWidth
mon: X resources used by Noosa
Noosa.valueColour
mon: X resources used by Noosa
Noosa.width
mon: X resources used by Noosa
NoPosition
lib: Source Text Coordinates and Error Reporting
NORETURN
lex: The Generated Lexical Analyzer Module
lex: Building processors
NoScope
name: Environment Module
NoStorage
lib: Storage Layout
NoStr
lib: Character String Storage
lib: Character String Storage
NoStrIndex
lib: Character String Storage
lib: Character String Storage
NOT
lidoref: Predefined Entities
NOTE
lib: Source Text Coordinates and Error Reporting
NUL
lib: Text Input
NullBitSet
adt: Bit Sets of Arbitrary Length
NullFctName
lidoref: Syntax
NULLIS
adt: Bit Sets of Integer Size
NULLNODEPTR
lidoref: Predefined Entities
lidoref: Tree Construction Functions
NullTYPEList
adt: Linear Lists of Any Type
adt: Linear Lists of Any Type
Numb, Ptg-Pattern
output: Frequently Used Patterns
Number
lidoref: Syntax
numbers
ptg: Output of Data Items
numstr
lib: Character String Storage

O

ObjCnt
news4.3: Map Objects to Integers
prop: Map Objects to Integers
object kind
prop: Map Objects to Integers
prop: Associate Kinds to Objects
object name
ui: Referring to Objects
object, derived
novice: Common Derived Objects
object, source
novice: Common Derived Objects
object-oriented
news4.1: Environment Module Enhancements
obstack
adt: Mapping Integral Values To Other Types
lib: Memory Object Management
obstack_1grow
lib: Memory Object Management
lib: Memory Object Management
obstack_1grow_fast
lib: Memory Object Management
lib: Memory Object Management
obstack_alignment_mask
lib: Memory Object Management
lib: Memory Object Management
obstack_alloc
lib: Memory Object Management
lib: Memory Object Management
obstack_base
lib: Memory Object Management
lib: Memory Object Management
obstack_begin
lib: Memory Object Management
lib: Memory Object Management
obstack_blank
lib: Memory Object Management
lib: Memory Object Management
obstack_blank_fast
lib: Memory Object Management
lib: Memory Object Management
obstack_chunk_alloc
lib: Memory Object Management
lib: Memory Object Management
obstack_chunk_free
lib: Memory Object Management
obstack_chunk_realloc
lib: Memory Object Management
lib: Memory Object Management
obstack_chunk_size
lib: Memory Object Management
lib: Memory Object Management
obstack_copy
lib: Memory Object Management
lib: Memory Object Management
obstack_copy0
lib: Memory Object Management
lib: Memory Object Management
obstack_finish
lib: Memory Object Management
lib: Memory Object Management
obstack_free
lib: Memory Object Management
lib: Memory Object Management
obstack_grow
lib: Memory Object Management
lib: Memory Object Management
obstack_grow0
lib: Memory Object Management
lib: Memory Object Management
obstack_init
lib: Memory Object Management
lib: Memory Object Management
obstack_int_grow
lib: Memory Object Management
obstack_int_grow_fast
lib: Memory Object Management
obstack_next_free
lib: Memory Object Management
lib: Memory Object Management
obstack_object_size
lib: Memory Object Management
lib: Memory Object Management
obstack_ptr_grow
lib: Memory Object Management
obstack_ptr_grow_fast
lib: Memory Object Management
obstack_room
lib: Memory Object Management
lib: Memory Object Management
obstack_strcpy
lib: Memory Object Management
lib: Memory Object Management
obstack_strgrow
lib: Memory Object Management
lib: Memory Object Management
OccCnt
oldmod: Migration of Eli Version 3.8 modules
Odin
sysadmin: Installing Eli
Odin package directory
sysadmin: Installing Eli
Odin variables
faq: Is the file `.odinrc' still read?
odin-expression
novice: Common Derived Objects
odin-expressions
ui: Referring to Objects
ODIN_LOCALIPC
faq: Eli reports Remote IPC not available on this host
`Odinfile'
novice: Hints on Session Management
ui: The Odinfile
ODINPKGS environment variable
sysadmin: Installing Eli
ODINVERIFYLEVEL
faq: Eli didn't notice that I changed my input file!
`oil'
novice: Descriptive Mechanisms Known to Eli
OIL comments
oil: Comments
OIL identifiers
oil: Identifiers
OIL library
oil: OIL's Support Library
OIL specification
oil: OIL's Specification Language
OIL statements
oil: Statement types
oil: OIL's Specification Language
Oil Tool
type: Types Having Scope Properties
OIL types and typesets (tOilType, tOilTypeSet)
mon: Trees and Attribute Values
OilAddArgSig
oil: Argument Signatures
OilAddClassCoercion
oil: Classes
OilAddClassOp
oil: Classes
OilAddClassOpId
oil: Classes
OilAddClassSigArg
oil: Classes
OilAddCoercion
oil: Coercions
OilAddIdentification
oil: Identifications
OilBalance
oil: Set of Possible Types
OilClassInst0
oil: Instantiate Classes
OilClassInst1
oil: Instantiate Classes
OilClassInst2
oil: Instantiate Classes
OilClassName
oil: Name Functions
OilCoerce
oil: Coercion sequences
OilEmptyCS
oil: Coercion sequences
OilGetArg
oil: Operator Signatures
OilGetArgType
oil: Looking at an operator's type signature
OilHeadCS
oil: Coercion sequences
OilIdOp1
oil: Simpler operator identification
OilIdOp2
oil: Simpler operator identification
OilIdOp3
oil: Simpler operator identification
OilIdOpTS1
oil: Set of Possible Types
OilIdOpTS2
oil: Set of Possible Types
OilIdOpTS3
oil: Set of Possible Types
OilIdResultTS1
oil: Set of Possible Types
OilIdResultTS2
oil: Set of Possible Types
OilIdResultTS3
oil: Set of Possible Types
OilIsValidCS
oil: Coercion sequences
OilIsValidOp
oil: Validating operator identification
OilNewArgSig
oil: Argument Signatures
OilNewClass
oil: Classes
OilNewClassSigArg
oil: Classes
OilNewOp
oil: Operators
OilNewType
oil: Types
OilOpName
oil: Name Functions
OilSelectTypeFromTS
oil: Set of Possible Types
OilSetIncludes
oil: Set of Possible Types
OilTailCS
oil: Coercion sequences
OilTypeName
oil: Name Functions
OilTypeToSet
oil: Set of Possible Types
omitted chain rule
idem: Changing IdemPtg computations
omitted child
idem: Overriding PTG patterns
omitting the main program
pp: nomain -- Omitting the main program
omitting the parser
pp: parser -- Choose the parser generator
Once
oldmod: Migration of Eli Version 3.8 modules
ONE
lidoref: Predefined Entities
one or more
lex: Building complex regular expressions
online help
mon:
open error format
clp: Options that affect usage messages
open error usage
clp: Options that affect usage messages
OpenElemScope
name: Joined Ranges C-like Bottom-up
OpenNewScope
name: C-like Basic Scope Rules Computed Bottom-Up
name: Scope Properties C-like Bottom-Up
OpenPrecond
name: Scope Properties C-like Bottom-Up
OpenSeqScope
name: Joined Ranges C-like Bottom-up
operation
mon: Operations
operation macros
deftbl: How to declare operations
operation names
deftbl: How to declare properties
operator association
syntax: Operator associativity
operator character
lex: Matching operator characters
lex: Matching operator characters
operator definition
oil: Operator definition
oil: Statement types
operator denotation
oil: A review of an example OIL Specification
oil: A more complex example
operator identification
oil: Operator Identification
oil: Operator identification
oil: Statement types
type: Types Having Scope Properties
operator indication
oil: A review of an example OIL Specification
oil: Set of Possible Types
oil: A more complex example
operator precedence
syntax: Operator precedence
operator precedence, overriding
idem: Textual unparser
operator signature
oil: Operator Signatures
operator, in odin-expressions
novice: Common Derived Objects
Operator-Module
news4.1: Instanciation of Modules with Filenames
operators
oil: OIL's Specification Language
`OPT INFO'
cola: Options
OptimInfo
pp: OptimInfo -- Information about attribute storage optimization
optional
lex: Building complex regular expressions
optional output patterns
ptg: Optional Parts in Patterns
Optional Patterns
news4.0: New specification types in PTG
options
mon: Controlling Your Program
OR
lidoref: Predefined Entities
ORDER
lidoref: Predefined Entities
order of indexed insertion points
idem: Computations for plain productions
order of option specification lines
clp: The order of option specification lines
order of specification lines
clp: Parameters given by their command line position
OrderedInsert
adt: Linear Lists of Any Type
ordering of specifications
lex: What happens if the specification is ambiguous?
OrdInfo
pp: OrdInfo -- Information about attribute dependence
Outdated Constructs
lidoref: Outdated Constructs
ptg: Outdated Constructs
OuterScope
name: Inheritance of Scopes
output
pp: output -- Files Resulting from Processor Execution
novice: How to Decompose a Text Processing Problem
output file line length
fw: Output Length
fw: Introduction
output files
fw: Output Files
output function
ptg: Program Frame
output functions
output: Additional functions
ptg: Output Functions
output: Additional functions
Output of Data Items
ptg: Output of Data Items
output of identifiers
pp: fold -- Make the Processor Case-Insensitive
Output of Sequences
ptg: Output of Sequences
output text structure
novice: How to Decompose a Text Processing Problem
novice: Descriptive Mechanisms Known to Eli
output to a file
novice: How to Request Product Manufacture
outputs
pp: outputs -- Objects Depending on a Given Object
OutStr
oldmod: Migration of Eli Version 3.8 modules
Overall Structure
lidoref: Overall Structure
Overlay
lib: Storage Layout
overload resolution
novice: How to Decompose a Text Processing Problem
novice: Descriptive Mechanisms Known to Eli
syntax: Mapping expressions for overload resolution
overloaded operators
oil: A review of an example OIL Specification
type: Types Having Scope Properties
OverridesBinding
name: Environment Module
overriding
lidoref: Inheritance of Computations
overriding computations
comptrees: Basic Symbol Computations
overriding operator precedence
idem: Textual unparser
overriding PTG patterns
idem: Changing Structure or Representation

P

p
info: P
package
sysadmin: Installing Eli
package definition
idem: Languages describing tree structure
pairwise related keys
prop: Associate Sets of Kinds to Objects
parameter
pp:
parameter type
adt:
ui: Parameterization Expressions
type: Pointer Types
parameter value
ui: Parameterization Expressions
ParameterListElem
news4.3: Oil
ParameterListRoot
news4.3: Oil
parameters
mon: Breakpoints and events
parameters of the eli command 'c'
faq: Where to Find Eli Locally
parameters of the eli command 'r'
faq: Why is my cache so big?
faq: How do I get new or improved components?
parameters, command line
pp: arg -- Supply Command Line Parameters
ParentOf
name: Environment Module
parsable
pp: parsable -- Verify that the Grammar is Parsable
novice: Exercises
cola: Options
parser
pp: parser -- Choose the parser generator
novice: Specifying the desired phrase structure
parser actions
syntax: Carrying Out Actions During Parsing
parser construction
syntax: Conflict resolution by ignoring possible structures
parser error reports
syntax: Context-Free Grammars and Parsing
parser generation
pp: parsable -- Verify that the Grammar is Parsable
parser generator selection
pp: parser -- Choose the parser generator
parser generators
mon: Phrase Structure
parser move determined by input symbol
syntax: How the generated parser determines phrase structure
parser operation
syntax: How the generated parser determines phrase structure
parser, omitting
pp: parser -- Choose the parser generator
parsing
mon: Phrase Structure
parsing routine
syntax: Context-Free Grammars and Parsing
PASCAL
oil: A review of an example OIL Specification
oil: A simple example
prop: Set a Property at the First Object Occurrence
PASCAL_COMMENT
lex: Available Descriptions
lex: Definitions of Canned Descriptions
PASCAL_IDENTIFIER
lex: Available Descriptions
lex: Definitions of Canned Descriptions
PASCAL_INTEGER
lex: Available Descriptions
lex: Definitions of Canned Descriptions
lex: Canned Symbol Descriptions
PASCAL_REAL
lex: Definitions of Canned Descriptions
lex: Available Descriptions
PASCAL_STRING
lex: Definitions of Canned Descriptions
lex: Canned Symbol Descriptions
lex: Available Descriptions
passed through arguments
ptg: Function Call Insertion
path
faq: Where to Find Eli Locally
pattern
ptg: Pattern Specifications
pattern function
ptg: Pattern Specifications
Pattern Specifications
ptg: Pattern Specifications
Pattern-Based Text Generator
ptg:
PDL
prop:
deftbl: The property definition language
novice: Descriptive Mechanisms Known to Eli
PDL pattern
prop: Reflexive Relations Between Objects
pdl_gen.h
deftbl: The Definition Table Interface
period
lex: Character classes
`perr' file, format
syntax: Grammars for the Specification Files
pgram
pp: pgram -- Parsing Grammar
PGS
pp: parser -- Choose the parser generator
PGS parser generating system
mon: Phrase Structure
`phi'
novice: Descriptive Mechanisms Known to Eli
phrase
novice: How to Decompose a Text Processing Problem
syntax:
Phrase command
mon: Phrase Structure
phrase structure
novice: How to Decompose a Text Processing Problem
novice: Descriptive Mechanisms Known to Eli
mon: Phrase Structure
novice: Descriptive Mechanisms Known to Eli
tp: Summary of the Specification Language
novice: Specifying the desired phrase structure
syntax: Context-Free Grammars and Parsing
plain computation
lidoref: Syntax
plain computations
lidoref: Syntax
lidoref: Examples
plain productions, computations
idem: Computations for plain productions
idem: Computations for plain productions
pointer
ptg: Function Call Insertion
Pointer Types
type: Array Types
positional
clp: Parameters given by their command line position
positional parameters
clp: What is a command line interface?
clp: Parameters given by their command line position
news4.1: Command-line processing
positionals
clp: Parameters given by their command line position
possible result types
oil: Set of Possible Types
postcondition
comptrees: State Dependencies
lidoref: Examples
lidoref: Examples
lidoref: Syntax
PostDeListElem
adt: Lists in LIDO Specifications
PostListElem
adt: Lists in LIDO Specifications
Postprocessing
news4.0: New specification types in PTG
Postscript output from tree displays
news4.3: Trees
PP_BreakLine
output: Pretty Printing
PP_Exdent
output: Pretty Printing
PP_Indent
output: Pretty Printing
PP_Newline
output: Pretty Printing
PP_Out(PTGNode n)
output: Additional functions
PP_OutFile(char *filename, PTGNode n)
output: Additional functions
PP_OutFPtr(FILE *f, PTGNode n)
output: Additional functions
PP_SetEndline(char *endline)
output: Additional functions
PP_SetIndentationWidth(int width)
output: Additional functions
PP_SetLineWidth(int width)
output: Additional functions
PP_SetSoftBreakShortcut(char)
output: Additional functions
PPtgOutstr
output: Useful Embedded Functions
Pragma
lidoref: Pragmas
pre-processor directives
deftbl: The property definition language
precedence levels
idem: Using an Unparser
precedence rules
syntax: Operator precedence
precondition
lidoref: Examples
comptrees: State Dependencies
lidoref: Examples
lidoref: Dependent Expressions
PreDef
oldmod: Migration of Eli Version 3.8 modules
PreDefBind
news4.3: Predefined Identifiers
name: Predefined Identifiers
PreDefId
news4.3: Predefined Identifiers
PreDefId-Module
news4.1: Instanciation of Modules with Filenames
PreDefine
news4.3: Predefined Identifiers
name: Predefined Identifiers
name: Predefined Identifiers
news4.3: Predefined Identifiers
Predefined Entities
tp: Predefined Entities
lidoref: Predefined Entities
comptrees: Implementing Tree Computations
ptg: Predefined Entities
predefined identifiers
name: C-like Basic Scope Rules Computed Bottom-Up
predefined macro
comptrees: Value Dependencies
predefined symbols
lex: Canned Symbol Descriptions
predefined types
type: Example for Basic Type Analysis
PreDefineSym
name: Predefined Identifiers
news4.3: Predefined Identifiers
name: Predefined Identifiers
PreDefKey
name: Predefined Identifiers
PreDefKeyBind
name: Predefined Identifiers
news4.3: Predefined Identifiers
PreDefMod
news4.3: Predefined Identifiers
name: Predefined Identifiers
PreDefSym
name: Predefined Identifiers
PreDefSymKey
name: Predefined Identifiers
PreDefSymKeyBind
news4.3: Predefined Identifiers
name: Predefined Identifiers
PreDeListElem
adt: Lists in LIDO Specifications
prefixes
clp: The order of option specification lines
PreIdnPost
problems: Generating Optional Identifiers
PreListElem
adt: Lists in LIDO Specifications
PRESENT
deftbl: How to declare operations
preserving literal chain rules
syntax: Preserving literal chain rules
syntax: Complete generated concrete and abstract syntaxes
pretty printing
output: Output String Conversion
pretty-printer
idem: Using an Unparser
previous
info: Help
PRINTER
info: Info Options.
printf
ptg: Introduction to PTG
printing
info: Info Options.
printing functions
novice: How to Decompose a Text Processing Problem
printtokens
pp: printtokens -- Request Token Printing Code
problem reporting
sysadmin: Procedure for reporting a problem with Eli
procedure declaration, scope issues
syntax: Scope rules for declarations
processor, token
novice: How to Decompose a Text Processing Problem
product
pp:
product file line length
fw: Output Length
Production
lidoref: Restrictions
lidoref: Syntax
comptrees: Tree Structure
lidoref: Restrictions
syntax: Context-Free Grammars and Parsing
Production Menu
gorto: Productions
productions
lidoref: Examples
lidoref: Productions
productions, LISTOF
idem: Textual unparser
products, relationships among
pp: Obtaining Information About the Derivation
program arguments
mon: Controlling Your Program
Program Frame
ptg: Program Frame
program options
mon: Controlling Your Program
program text generation
novice: Descriptive Mechanisms Known to Eli
novice: How to Decompose a Text Processing Problem
progress in recognizing a phrase
syntax: How the generated parser determines phrase structure
Prop
prop:
Properties of Types
type: Example for Basic Type Analysis
property
prop:
property declaration
deftbl: How to declare properties
property Defer
type: Deferred Property Association
type: Basic Type Analysis
property definition
novice: Descriptive Mechanisms Known to Eli
property definition language
deftbl: The property definition language
property From
prop: Associate Sets of Kinds to Objects
property IsType
type: Basic Type Analysis
property Kind
prop: Associate Kinds to Objects
property KindSet
prop: Associate Sets of Kinds to Objects
property Line
name: Name Analysis Test
property name
deftbl: How to declare properties
property ObjNo
prop: Determine First Object Occurrence
property Scope
name: Scope Properties without Ordering Restrictions
name: Inheritance of Scopes
property specification
deftbl: How to declare properties
property To
prop: Associate Sets of Kinds to Objects
property type
deftbl: How to declare properties
property TypeOf
type: Basic Type Analysis
PropLib
type: Deferred Property Association
type: Pointer Types
prop: Set a Property at the First Object Occurrence
prtidnv
lib: Unique Identifier Management
prtstcon
lib: Character String Storage
ps
pp: ps -- PostScript file
PString, Ptg-Pattern
output: Frequently Used Patterns
`ptg'
novice: Descriptive Mechanisms Known to Eli
ptg:
PTG nodes (PTGNode)
mon: Trees and Attribute Values
PTG Output
output: Restrictions
PTG patterns, overriding
idem: Changing Structure or Representation
PTG specification
novice: Creating structured output text
Ptg-Pattern AsIs
output: Frequently Used Patterns
Ptg-Pattern CChar
output: Frequently Used Patterns
Ptg-Pattern CommaSeq
output: Frequently Used Patterns
Ptg-Pattern CString
output: Frequently Used Patterns
Ptg-Pattern Eol
output: Frequently Used Patterns
Ptg-Pattern Id
output: Frequently Used Patterns
Ptg-Pattern Numb
output: Frequently Used Patterns
Ptg-Pattern PString
output: Frequently Used Patterns
Ptg-Pattern Seq
output: Frequently Used Patterns
ptg_gen.c
ptg: Introduction to PTG
ptg_gen.h
ptg: Introduction to PTG
ptg: Predefined Entities
PTGAsIs()
output: Frequently Used Patterns
PTGCChar()
output: Frequently Used Patterns
PTGCString()
output: Frequently Used Patterns
PTGCStringId
output: Frequently Used Patterns
PTGFree
ptg: Predefined Entities
PTGId()
output: Frequently Used Patterns
PTGName
novice: Creating structured output text
PTGNode
ptg: Predefined Entities
ptg: Pattern Specifications
ptg: Typed Insertion Points
ptg: Output Functions
novice: Creating structured output text
PTGNull
ptg: Predefined Entities
ptg: Predefined Entities
novice: How to Decompose a Text Processing Problem
PTGNumb
novice: Creating structured output text
PTGNumb()
output: Frequently Used Patterns
PTGOut
ptg: Predefined Entities
ptg: Output Functions
PTGOutFile
ptg: Output Functions
ptg: Predefined Entities
PTGOutFPtr
ptg: Predefined Entities
ptg: Output Functions
PtgOutId
idem: Overriding PTG patterns
output: Useful Embedded Functions
PTGProcess
ptg: Predefined Entities
PTGPString()
output: Frequently Used Patterns
PTGPStringId
output: Frequently Used Patterns
PtrList
news4.3: Linear Lists of Any Type
oldmod: Migration of Eli Version 3.8 modules
adt: Linear Lists of Any Type

Q

q
info: Q
query
novice: How to Decompose a Text Processing Problem
query and update operations
deftbl: The Definition Table Interface
query operation
deftbl: Behavior of the basic query operations
quick names
fw: Quick Names
quitting Noosa
mon: Invoking Noosa
quote
lex: Matching operator characters

R

r
info: Interacting with examples using Info
r parameter of the eli command
faq: Why is my cache so big?
faq: How do I get new or improved components?
range
lex: Character classes
prop: Common Aspects of Property Modules
RangeCnt
prop: Count Occurrences of Objects
RangeElement
name: Joined Ranges
RangeFirstOcc
prop: Determine First Object Occurrence
RangeKind
prop: Associate Kinds to Objects
RangeKindSet
prop: Associate Sets of Kinds to Objects
RangeMulInh
name: Inheritance with C-like Scope Rules
name: Inheritance of Scopes
name: Inheritance with Algol-like Scope Rules
RangeObjCnt
prop: Map Objects to Integers
RangeQualInhScope
name: Inheritance with Algol-like Scope Rules
RangeScope
novice: Managing source text definitions
name: C-like Basic Scope Rules
name: Basic Scope Rules
type: Function Types
name: C-like Inheritance Bottom-Up
name: Algol-like Basic Scope Rules
RangeScopeProp
name: Scope Properties without Ordering Restrictions
oldmod: Migration of Eli Version 3.8 modules
name: Scope Properties C-like
oldmod: Migration of Eli Version 3.8 modules
RangeSequence
name: Joined Ranges C-like Bottom-up
name: Joined Ranges
RangeSetFirst
prop: Set a Property at the First Object Occurrence
RangeSnglInh
name: Inheritance of Scopes
name: Inheritance with C-like Scope Rules
name: Inheritance with Algol-like Scope Rules
RangeUnique
prop: Check for Unique Object Occurrences
novice: Managing source text definitions
ranked alphabet
tp: The Tree Patterns
tp: Tree Structure
tp: Rules
rc file
mon: User Initialisation
realloc
lib: Memory Object Management
RecentNewScope
name: C-like Basic Scope Rules Computed Bottom-Up
name: C-like Inheritance Bottom-Up
reconstruction of literal terminals
idem: Computations for plain productions
idem: Textual unparser
idem: Textual unparser
redo
pp: redo -- Ask Eli to Carry Out a Derivation
reduce move by the parser
syntax: How the generated parser determines phrase structure
reduce-reduce conflict
syntax: How the generated parser determines phrase structure
reduce-reduce solved by @ modification
syntax: Conflict resolution by ignoring possible structures
RefEndApp
adt: Linear Lists of Any Type
RefEndCons
adt: Linear Lists of Any Type
referred set
lidoref: Examples
lidoref: Examples
referto
pp: referto -- Relate Instances of Generic Modules
referto parameter
modlib: Instantiation and Use of Modules
refillBuf
lib: Text Input
ReflexFrom
prop: Associate Sets of Kinds to Objects
ReflexTo
prop: Associate Sets of Kinds to Objects
region
novice: Managing source text definitions
regions, nested
novice: Managing source text definitions
regular expression
lex: Regular Expressions
relationship
novice: How to Decompose a Text Processing Problem
RemAttrList
lidoref: Syntax
RemAttrs
lidoref: Syntax
Remote Attribute Access
lidoref: Remote Attribute Access
remote dependencies
comptrees: Specification Errors
comptrees: Access to a Subtree Root
remote rependencies
comptrees: Remote Dependencies in Trees
RemoteAccess
lidoref: Syntax
lidoref: Syntax
repairing syntactic errors
syntax: Context-Free Grammars and Parsing
Reparatur
syntax: Improving Error Recovery in the Generated Parser
repeated boolean options
clp: Accessing options that appear more than once
news4.1: Command-line processing
repeated options
clp: Accessing options that appear more than once
clp: Options that are joined to their values
clp: Options that have a value given with them
clp: Options that are either there or not
repetition
lex: Building complex regular expressions
reported error in a modification
syntax: Conflict resolution by ignoring possible structures
Reporting a lexical error
lex: Making White Space Illegal
reports of syntactic errors
syntax: Context-Free Grammars and Parsing
requesting source code, example
novice: Exercises
Reset
deftbl: How to declare operations
Reset operation
deftbl: Behavior of the basic update operations
reset times
mon: Time Profiles
ResetScan
lex: The Generated Lexical Analyzer Module
resolving ambiguity by grammar changes
syntax: Conflict resolution by changing the grammar
resolving ambiguity by modifications
syntax: Conflict resolution by ignoring possible structures
resolving ambiguity, general methods
syntax: How to Resolve Parsing Conflicts
resolving overloading
syntax: Mapping expressions for overload resolution
restart point
syntax: Improving Error Recovery in the Generated Parser
ResType
type: Operator Identification
result type
oil: Coercion sequences
oil: Set of Possible Types
type: Pointer Types
return
mon: Operations
lex: Returning a classification
return statements
mon: Operations
reuse of computations
syntax: Abstracting information from literals
RHS
lidoref: Syntax
RhsAttrs
lidoref: Syntax
lidoref: Examples
lidoref: Pragmas
RhsFct
lidoref: Predefined Entities
news4.1: Right-Hand Side Access
right-associative
syntax: Operator associativity
right-hand side
news4.1: Right-Hand Side Access
root
novice: How to Decompose a Text Processing Problem
syntax:
root environment
name: Algol-like Basic Scope Rules
name: C-like Basic Scope Rules
name: Predefined Identifiers
root roles
news4.1: Specification Module Library
root symbol
lidoref: Syntax
name: Tree Grammar Preconditions
lidoref: Restrictions
ROOTCLASS
lidoref: Syntax
lidoref: Predefined Entities
news4.1: Grammar Root Symbol
news4.1: Specification Module Library
RootCount
problems: Counting Symbol Occurrences
RootDefer
type: Deferred Property Association
RootEnv
name: Algol-like Basic Scope Rules
name: Predefined Identifiers
name: C-like Basic Scope Rules
RootScope
name: C-like Basic Scope Rules
name: Basic Scope Rules
novice: Managing source text definitions
name: Algol-like Basic Scope Rules
RootType
type: Example for Basic Type Analysis
type: Basic Type Analysis
RTType
type: Operator Identification
RType
type: Operator Identification
rubout
info: C-l
RULE
lidoref: Rule Specifications
tp: Rules
comptrees: Value Dependencies
rule attribute type
lidoref: Examples
rule attributes
lidoref: Examples
rule computation
idem: Changing IdemPtg computations
idem: Changing IdemPtg computations
rule context
comptrees: Tree Structure
rule name
news4.1: Right-Hand Side Access
rule specification
lidoref: Rule Specifications
Rule Specifications
lidoref: Rule Specifications
rule, grammar
novice: How to Decompose a Text Processing Problem
rule, scope
novice: How to Decompose a Text Processing Problem
RuleAttr
lidoref: Syntax
RuleFct
lidoref: Pragmas
lidoref: Predefined Entities
lidoref: Examples
RULENAME
lidoref: Predefined Entities
news4.1: Right-Hand Side Access
lidoref: Syntax
rules, association
syntax: Operator associativity
rules, precedence
syntax: Operator precedence
run
novice: Common Derived Objects
pp: run -- Execute the Processor in the Current Directory
Run command
mon: Controlling Your Program
run with typical input data
pp: Testing a Generated Processor
running example
type:
modlib:
name: Basic Scope Rules
type: Basic Type Analysis
name:
modlib:
running program
mon: Controlling Your Program

S

s
info: Some Advanced Info Commands
saveidn
lib: Unique Identifier Management
savestr
lib: Character String Storage
saving handlers
mon: Breakpoints and events
saving typing
info: Completing Input
scanner
lex: Auxiliary Scanners
pp: kwd -- Recognize Specified Literals as Identifiers
comptrees: Tree Construction
SCANPTR
lex: Resetting the Scan Pointer
Scope
name: Inheritance of Scopes
syntax: Scope rules for declarations
name: Environment Module
name: Environment Module
scope properties
type: Function Types
name: Joined Ranges C-like Bottom-up
scope rules
name: Tree Grammar Preconditions
name:
novice: How to Decompose a Text Processing Problem
ScopeKey
name: Scope Properties C-like Bottom-Up
ScopeProp
name: Joined Ranges C-like Bottom-up
news4.4: Scope Properties without Ordering Restrictions
screen
info: Small Screen
scripts, invocation via inst
pp: inst -- Instantiate a Generic Module
Searching and saving Noosa text
news4.3: Main window command changes
section names
fw: Structure
fw: Names
selected type
oil: Set of Possible Types
selecting entities
deftbl: Criteria for selecting entities
semantic brackets
syntax: Improving Error Recovery in the Generated Parser
semantic delimiters
syntax: Improving Error Recovery in the Generated Parser
semantic disambiguation
syntax: Matching remaining rules
sentence
novice: How to Decompose a Text Processing Problem
syntax:
sentence symbol
syntax: Context-Free Grammars and Parsing
Sep_Out
idem: Deriving multiple unparsers
idem: Using an Unparser
idem: Computations for plain productions
output: Introducing Separators in PTG Output
Sep_Print
idem: Computations for plain productions
idem: Computations for plain productions
separate caches
novice: Hints on Cache Management
separate name space
name: Algol-like Basic Scope Rules
name: C-like Basic Scope Rules
name: Basic Scope Rules
separator
ptg: Using LIDO CONSTITUENTS
output: Restrictions
news4.1: Module Separator added
idem: Overriding PTG patterns
ptg: Output of Sequences
Separator function call
idem: Using an Unparser
idem: Computations for plain productions
separator module, constructing
idem: Computations for plain productions
separator, argument
idem: Overriding PTG patterns
idem: Using an Unparser
idem: Changing IdemPtg computations
Seq, Ptg-Pattern
output: Frequently Used Patterns
sequence
syntax: Context-Free Grammars and Parsing
ptg: Output of Sequences
sequence of coercions
oil: Coercion sequences
oil: Coercion sequence
sequences
ptg: Using LIDO CONSTITUENTS
ptg: Using LIDO CHAINs
Set
deftbl: How to declare operations
set of types
oil: Set of Possible Types
oil: A more complex example
oil: Library Types
Set operations
deftbl: Behavior of the basic update operations
SETCOORD
lex: Setting coordinate values
SetDeferId
type: Deferred Property Association
SetDeferProp
type: Deferred Property Association
SetDiff
prop: Some Useful PDL Specifications
SETENDCOORD
lex: Setting coordinate values
SetGet
prop: Some Useful PDL Specifications
SetKeyOfEnv
name: Environment Module
SetKind
prop: Associate Kinds to Objects
SetOnce
prop: Some Useful PDL Specifications
setting special character
fw: Setting the Special Character
severity of errors
novice: Creating structured output text
novice: Managing source text definitions
SHIELD
lidoref: Syntax
SHIELD clause
comptrees: Access to Contexts within a Subtree
ShieldClause
lidoref: Syntax
shielding
lidoref: Examples
shift move by the parser
syntax: How the generated parser determines phrase structure
shift-reduce conflict
syntax: How the generated parser determines phrase structure
novice: Exercises
shift-reduce solved by $ modification
syntax: Conflict resolution by ignoring possible structures
short
ptg: Typed Insertion Points
ShowBinding
news4.1: Module for Testing Name Analysis
showFe
pp: show -- LIDO Table Viewers showFe and showMe
comptrees: Specification Errors
showMe
pp: show -- LIDO Table Viewers showFe and showMe
side-effects
lidoref: Computations
signature
oil: Operator definition
oil: Looking at an operator's type signature
oil: Operator identification
oil: Operator Signatures
signature, action
tp: Actions and Values
tp: Implementing Actions
significant character sequence
novice: How to Decompose a Text Processing Problem
novice: Nonliteral character sequences and comments
SimpExpr
lidoref: Syntax
lidoref: Syntax
Simple Expressions
lidoref: Simple Expressions
simple sequence
fw: Special Sequences
Single
adt: Linear Lists of Any Type
oil: A more complex example
single assignment rule
comptrees: Value Dependencies
single cache
novice: Hints on Cache Management
SingleFctName
lidoref: Syntax
SingleList
news4.3: Linear Lists of Any Type
SingleTYPEList
news4.2: List-Module
Size
ui: Variables
Solutions of Common Problems
problems:
Sort
news4.1: Module Sort added
SortTYPE
problems: Sorting Elements of an Array
source
pp: source -- Source Version of the Processor
novice: Common Derived Objects
novice: Exercises
source coordinates
prop: Set a Property at the First Object Occurrence
source language file
pp: source -- Source Version of the Processor
Source Language Structure
ptg: Source Language Structure
source object
ui: Referring to Objects
novice: Common Derived Objects
source text coordinates
pp: printtokens -- Request Token Printing Code
source text display
mon: Input Text Display
source type
oil: Coercion sequences
source.h
lib: Text Input
`Sp_Separator.fw'
idem: Computations for plain productions
space
info: C-l
space defaults
lex: Spaces, Tabs and Newlines
SPACES
lex: Restoring the Default Behavior for White Space
lex: Available Descriptions
special character
fw: Special Sequences
special character, inserting
fw: Inserting the Special Character into the Text
special character, setting
fw: Setting the Special Character
special sequence
fw: Special Sequences
Specification
lidoref: Overall Structure
specification grammar
deftbl: How to declare operations
deftbl: How to declare properties
specification ordering
lex: What happens if the specification is ambiguous?
specification types
novice: Descriptive Mechanisms Known to Eli
Specifications
lex: Specifications
deftbl: The property definition language
`specs'
novice: Descriptive Mechanisms Known to Eli
SrcBuffer
lib: Text Input
SrcBufPtr
lib: Text Input
SRCFILE
ptg: Program Frame
lib: Text Input
SrcOpr
type: Operator Identification
Stack
oldmod: Migration of Eli Version 3.8 modules
stack of parser states
syntax: How the generated parser determines phrase structure
StackArray
adt: Stacks of Any Type
StackElement
adt: Stacks of Any Type
StackEmpty
adt: Stacks of Any Type
StackPop
adt: Stacks of Any Type
StackPush
adt: Stacks of Any Type
StackSize
adt: Stacks of Any Type
StackTop
adt: Stacks of Any Type
standard input
clp: What happens by default?
mon: Input Text Display
clp: The general format of the command line
clp: Input parameters
standard output
novice: How to Request Product Manufacture
StartLine
lex: Maintaining the Source Text Coordinates
lex: The Generated Lexical Analyzer Module
startup file
mon: User Initialisation
mon: Browsing non-standard types
state attribute
comptrees: State Dependencies
state dependencies
comptrees: State Dependencies
state of the parser
syntax: How the generated parser determines phrase structure
statements
ptg: Using LIDO CHAINs
STATIC
news4.0: LIDO Tokens
status
pp: Diagnosing Specification Inconsistencies
Status Display
gorto: The Main Window
stdout
pp: stdout -- Standard Output from Processor Execution
stopping execution
mon: Breakpoints and events
stopping option recognition
clp: Terminating the option list
Storage.h
lib: Storage Layout
StorageAlignment
lib: Storage Layout
StorageRequired
lib: Storage Layout
StorageSize
lib: Storage Layout
stostr
lib: Character String Storage
`str'
novice: Descriptive Mechanisms Known to Eli
stradd
lib: Character String Arithmetic
Strategy Menus
gorto: The Main Window
strdivf
lib: Character String Arithmetic
strdivi
lib: Character String Arithmetic
string
ptg: Typed Insertion Points
ptg: Syntax of PTG Specifications
clp: Options that have a value given with them
ptg: Output of Data Items
String Buffer
output: Restrictions
String command
mon: String Table
String Literals
output: Examples
string table
mon: String Table
clp: Accessing options with string values
string table index
idem: Overriding PTG patterns
string values
clp: Options that have a value given with them
Strings
problems: Error Reports
clp: Options that have a value given with them
Strings command
mon: String Table
StringTable
clp: Accessing options with string values
lib: Character String Storage
ptg: Expressions
strmath
lib: Character String Arithmetic
strmult
lib: Character String Arithmetic
strnorm
lib: Character String Arithmetic
strnumb
lib: Character String Arithmetic
strpow
lib: Character String Arithmetic
strrem
lib: Character String Arithmetic
strsqrt
lib: Character String Arithmetic
strsub
lib: Character String Arithmetic
structural unparser
idem: Structural unparser
structural unparser, deriving
idem: Deriving structural unparsers
structural unparser, structure definition
idem: Obtaining the structure definition
structured output text
novice: Descriptive Mechanisms Known to Eli
novice: How to Decompose a Text Processing Problem
SUB
lidoref: Predefined Entities
sub-tree, computed
idem: Deriving multiple unparsers
subproblem
novice: How to Decompose a Text Processing Problem
subproblem descriptions
novice: Descriptive Mechanisms Known to Eli
Sum
adt: Linear Lists of Any Type
SumFct
adt: Linear Lists of Any Type
support library
oil: OIL's Support Library
suppressing EOL markers
fw: Suppressing End of Line Markers
`sym'
novice: Descriptive Mechanisms Known to Eli
SymbKind
lidoref: Syntax
SymbName
lidoref: Syntax
lidoref: Syntax
SymbNameList
lidoref: Syntax
SYMBOL
lidoref: Syntax
novice: Managing source text definitions
comptrees: Basic Symbol Computations
novice: How to Decompose a Text Processing Problem
comptrees: Tree Structure
comptrees: Value Dependencies
symbol attribution
novice: Managing source text definitions
symbol computation
comptrees: Symbol Computations
Symbol Menu
gorto: Symbols
symbol specification
lidoref: Symbol Specifications
Symbol Specifications
lidoref: Symbol Specifications
symbol, nonterminal
novice: How to Decompose a Text Processing Problem
symbol, terminal
novice: How to Decompose a Text Processing Problem
SymbolRef
lidoref: Syntax
Symbols
lidoref: Syntax
lidoref: Syntax
SYNT
comptrees: Basic Symbol Computations
lidoref: Syntax
lidoref: Examples
lidoref: Attributes
lidoref: Examples
lidoref: Types and Classes of Attributes
comptrees: Value Dependencies
syntactic analysis
novice: How to Decompose a Text Processing Problem
syntactic error reports during parsing
syntax: Context-Free Grammars and Parsing
Syntax
lidoref: Syntax
Syntax Errors
cola: Options
Syntax of PTG Specifications
ptg: Syntax of PTG Specifications
synthesized
lidoref: Attributes
comptrees: Value Dependencies
lidoref: Types and Classes of Attributes
lidoref: Examples
synthesized attribute
lidoref: Syntax
system documentation
novice: System Documentation

T

TAB
lex: Available Descriptions
tab character
novice: Nonliteral character sequences and comments
tab defaults
lex: Spaces, Tabs and Newlines
TAIL
comptrees: Left-to-Right Dependencies
lidoref: Examples
news4.1: CHAIN in Empty Rules
adt: Linear Lists of Any Type
lidoref: Examples
tail of coercion sequence
oil: Coercion sequences
target
ui: The Odinfile
novice: Hints on Session Management
TCL
mon: Breakpoints and events
tcl files
mon: Browsing non-standard types
mon: User Initialisation
Tcl specifications
news4.3: Monitoring user-defined types
template
novice: How to Decompose a Text Processing Problem
novice: Creating structured output text
TERM
lidoref: Syntax
comptrees: Tree Construction
comptrees: Value Dependencies
lidoref: Terminals
lidoref: Syntax
novice: Managing source text definitions
news4.0: Terminals
termcode.h
lex: Building processors
TermFct
lidoref: Predefined Entities
news4.1: Right-Hand Side Access
terminal
comptrees: Tree Structure
news4.0: Terminals
lidoref: Examples
comptrees: Tree Construction
lidoref: Tree Construction Functions
comptrees: Value Dependencies
news4.0: Terminals in LISTOF productions
tp: Rules
terminal access
news4.1: Right-Hand Side Access
lidoref: Terminal Access
terminal EOF to terminate text
syntax: Conflict resolution by ignoring possible structures
terminal symbol
novice: Nonliteral character sequences and comments
novice: How to Decompose a Text Processing Problem
terminal symbol, non-literal
idem: Overriding PTG patterns
terminal symbol, overriding
idem: Overriding PTG patterns
terminal symbols in a grammar
syntax: How to describe a context-free grammar
terminal, use in a modification
syntax: Conflict resolution by ignoring possible structures
terminals
lidoref: Outdated Constructs
name:
termination string
clp: Terminating the option list
terminator
clp: Terminating the option list
lidoref: Syntax
test
pp: test -- Check Whether an Object has been Modified
test output
name: C-like Inheritance Bottom-Up
test-utility
faq: Eli didn't notice that I changed my input file!
texinfo
fw: Introduction
pp: Producing Formatted Documents
text character
lex: Matching operator characters
text fragment
novice: How to Decompose a Text Processing Problem
text generation function
novice: Creating structured output text
novice: How to Decompose a Text Processing Problem
TEXTSTART
lib: Text Input
textual unparser
idem: Textual unparser
textual unparser, deriving
idem: Deriving textual unparsers
TgtKey
type: Operator Identification
TgtOpr
type: Operator Identification
THIS
lidoref: Syntax
lidoref: Examples
comptrees: Basic Symbol Computations
lidoref: Examples
time profile
mon: Time Profiles
timing
mon: Time Profiles
tOilArgSig
oil: Argument Signatures
Token command
mon: Lexical Structure
Token names in Noosa
news4.3: Main window command changes
token processor
novice: How to Decompose a Text Processing Problem
token processor compatibility
idem: Overriding PTG patterns
TokenEnd
lex: The Generated Lexical Analyzer Module
tokens
ptg: Syntax of PTG Specifications
TokenStart
lex: The Generated Lexical Analyzer Module
tool command language
mon: Breakpoints and events
TotalCnt
prop: Count Occurrences of Objects
TP_0_DefTableKey
tp: TP_0_DefTableKey
TP_0_int
tp: TP_0_int
TP_1
tp: TP_1
TP_2
tp: TP_2
TP_FltReg
tp: TP_FltReg
tp_gen.h
tp: Predefined Entities
TP_IntReg
tp: TP_IntReg
TPNode
tp: Predefined Entities
TPNULL
tp: Predefined Entities
tp: Predefined Entities
Trace of Dependencies
gorto: Symbols
Tracing Dependencies
gorto: Productions
tracing events
mon: Tracing Events
Trans
prop: Some Useful PDL Specifications
TransDefer
type: Basic Type Analysis
type: Deferred Property Association
TRANSFER
news4.0: TRANSFER
tree
news4.1: Abstract Syntax Tree Unparsing
lidoref: Syntax
idem: Deriving structural unparsers
tree computations
syntax: The Relationship Between Phrases and Tree Nodes
Tree Construction Functions
lidoref: Tree Construction Functions
tree fragment
tp: Rules Describing Tree Fragments
tree grammar
lidoref: Restrictions
comptrees: Tree Structure
lidoref: Syntax
comptrees: Tree Construction
lidoref: Examples
lidoref: Restrictions
lidoref: Restrictions
lidoref: Productions
name:
lidoref: Syntax
tree grammar, partial
idem: Deriving unparsers from sub-grammars
tree node
tp: Rules Describing Tree Nodes
Tree nodes (Node, NODEPTR)
mon: Trees and Attribute Values
Tree parser nodes (TPNode)
mon: Trees and Attribute Values
tree structure
fw: Structure
novice: Descriptive Mechanisms Known to Eli
comptrees: Tree Structure
tree structure, meaning of
novice: Specifying the desired phrase structure
TREE SYMBOL
news4.0: CLASS and TREE SYMBOLS
tree symbol computation
idem: Changing IdemPtg computations
idem: Changing IdemPtg computations
TREE symbols
lidoref: Symbol Specifications
lidoref: Examples
`Tree.fw'
idem: Languages describing tree structure
TREE_COMPLETE
news4.1: Bottom-up Evaluation
Trees menu
mon: Trees and Attribute Values
trivial chain rules
syntax: Chain rule definitions
type
lidoref: Examples
type: Basic Type Analysis
oldmod: Migration of Eli Version 3.8 modules
news4.0: Type Definitions
type:
lidoref: Restrictions
lidoref: Types and Classes of Attributes
lidoref: Examples
Type Analysis
type:
type balancing
oil: Set of Possible Types
type Binding
name: Environment Module
name: Algol-like Basic Scope Rules
name: Basic Scope Rules
name: C-like Basic Scope Rules
type BitSet
adt: Bit Sets of Arbitrary Length
type definition
type: Example for Basic Type Analysis
type denotation
oil: Set of Possible Types
oil: A review of an example OIL Specification
type Environment
name: Environment Module
type InheritPtr
name: Environment Module
type IntSet
adt: Bit Sets of Integer Size
type NODEPTR
lidoref: Examples
type Scope
name: Environment Module
type set
oil: Using type sets
oil: Library Types
oil: OIL's Specification Language
oil: Statement types
type set definition
oil: Type set definition
type signature
oil: Looking at an operator's type signature
type VOID
lidoref: Examples
type, of a parameter in an odin-expression
ui: Parameterization Expressions
type-`clp' file
novice: Descriptive Mechanisms Known to Eli
type-`con' file
novice: Descriptive Mechanisms Known to Eli
type-`con' file format
syntax: Grammars for the Specification Files
type-`con' file, example
syntax: Mapping expressions for overload resolution
type-`con' file, purpose
syntax: How to describe a context-free grammar
type-`ctl' file
novice: Descriptive Mechanisms Known to Eli
type-`dapto' file format
mon: Dapto Grammar
type-`delit' file
novice: Descriptive Mechanisms Known to Eli
type-`eta' file
novice: Descriptive Mechanisms Known to Eli
type-`FINL.phi' file
novice: Descriptive Mechanisms Known to Eli
type-fw
pp: fwTex -- TeX input file
type-`fw' file
novice: Creating structured output text
novice: Descriptive Mechanisms Known to Eli
type-`gla' file
novice: Descriptive Mechanisms Known to Eli
type-`gnrc' file
novice: Descriptive Mechanisms Known to Eli
type-gnrc files
pp: inst -- Instantiate a Generic Module
type-`HEAD.phi' file
novice: Descriptive Mechanisms Known to Eli
novice: Creating structured output text
type-`INIT.phi' file
novice: Descriptive Mechanisms Known to Eli
type-`lido' file
novice: Descriptive Mechanisms Known to Eli
type-`map' file, example
syntax: Mapping expressions for overload resolution
type-`map' file, format
syntax: Grammars for the Specification Files
type-`oil' file
novice: Descriptive Mechanisms Known to Eli
type-`pdl' file
novice: Descriptive Mechanisms Known to Eli
type-`perr' file, format
syntax: Grammars for the Specification Files
type-`phi' file
novice: Descriptive Mechanisms Known to Eli
type-`ptg' file
novice: Descriptive Mechanisms Known to Eli
type-`specs' file
novice: Descriptive Mechanisms Known to Eli
type-`str' file
novice: Descriptive Mechanisms Known to Eli
type-`sym' file
novice: Descriptive Mechanisms Known to Eli
Typed Insertion Points
ptg: Typed Insertion Points
TypedDefId
type: Basic Type Analysis
type: Example for Basic Type Analysis
TypedDefinition
type: Example for Basic Type Analysis
type: Basic Type Analysis
type: Function Types
typedef
tp: Declarations
TypeDefDefId
type: Example for Basic Type Analysis
type: Basic Type Analysis
TypeDefUseId
type: Basic Type Analysis
type: Example for Basic Type Analysis
TypeDenotation
type: Function Types
type: Pointer Types
type: Types Having Scope Properties
type: Array Types
type: Basic Type Analysis
TypedUseId
type: Basic Type Analysis
type: Types Having Scope Properties
type: Example for Basic Type Analysis
TypeIsSet
type: Basic Type Analysis
TypeName
lidoref: Syntax
lidoref: Syntax
TypeOf
type: Basic Type Analysis
types
oil: OIL's Specification Language
Types and Classes of Attributes
lidoref: Types and Classes of Attributes
types, attribute
tp: Actions and Values
types, nonterminal
tp: Actions and Values
types, of input specification
novice: Descriptive Mechanisms Known to Eli
typesetter
fw: Introduction
fw: Specifying the Typesetter
typesetter directives
fw: Specifying the Typesetter
typical use of Eli
novice: Example of Eli Use
typing less
info: Completing Input

U

u
info: The U command
Unique
prop: Set a Property at the First Object Occurrence
novice: Managing source text definitions
deftbl: How to declare operations
deftbl: Predefined query and update operations
oldmod: Migration of Eli Version 3.8 modules
Unique module
novice: Managing source text definitions
unique pattern names
ptg: Restrictions:
UniqueName
deftbl: Predefined query and update operations
uniqueness of property names
deftbl: How to declare properties
Unix newline
fw: Inserting Arbitrary Characters into the Text
unknown value
mon: Non-standard types
unparser derivation
idem: Deriving an Unparser
unparser generation
news4.1: Abstract Syntax Tree Unparsing
unparser generator, available specifications
idem: Languages describing tree structure
unparser generator, specifying
idem: Deriving structural unparsers
unparser, kinds
idem: Available Kinds of Unparser
unparser, structural
idem: Structural unparser
unparser, textual
idem: Textual unparser
unparsers, combining
idem: Deriving multiple unparsers
UnTgtOpr
type: Operator Identification
UNTIL
lidoref: Syntax
up
info: Help
update
novice: How to Decompose a Text Processing Problem
update operation
deftbl: Behavior of the basic update operations
upgrading
faq: How do I get new or improved components?
upper case
pp: fold -- Make the Processor Case-Insensitive
upper computations
lidoref: Syntax
upper context
lidoref: Attributes
comptrees: Tree Structure
usage message
clp: Documentation options and parameters
clp: Options that affect usage messages
clp: Accessing positional parameters
user initialisation
mon: User Initialisation
user modules
modlib: Instantiation and Use of Modules
user supplied function
ptg: Function Call Insertion
user-defined actions during parsing
syntax: Carrying Out Actions During Parsing
Using LIDO CHAINs
ptg: Using LIDO CHAINs
Using LIDO CONSTITUENTS
ptg: Using LIDO CONSTITUENTS

V

v
info: Interacting with examples using Info
valid operator
oil: Validating operator identification
validating a coercion sequence
oil: Coercion sequences
validating operator identification
oil: Validating operator identification
VALUE
deftbl: How to declare operations
comptrees: Value Dependencies
value context
lidoref: Examples
lidoref: Restrictions
lidoref: Examples
value dependencies
comptrees: Value Dependencies
value options
clp: Options that have a value given with them
value options with or without spacing
news4.1: Command-line processing
value, of a parameter in an odin-expression
ui: Parameterization Expressions
variable entities
deftbl: Criteria for selecting entities
variables
faq: Is the file `.odinrc' still read?
VerifyLevel
ui: Variables
faq: Eli didn't notice that I changed my input file!
mon: Changing files from within Noosa
viewlist
novice: Common Derived Objects
virtual target
novice: Hints on Session Management
ui: The Odinfile
visit-sequence
gorto: Visit-sequences
Visit-sequence Menu
gorto: Visit-sequences
visitprocs messages
comptrees: Specification Errors
VOID
lidoref: Predefined Entities
lidoref: Syntax
lidoref: Examples
lidoref: Examples
comptrees: State Dependencies
VOID attribute not allowed here
comptrees: Specification Errors
VOID context
lidoref: Examples
lidoref: Examples
lidoref: Examples
lidoref: Examples
lidoref: Restrictions
lidoref: Examples
VOIDEN
lidoref: Predefined Entities
VoidPtr
adt: Linear Lists of Any Type
VReset
prop: Some Useful PDL Specifications
vskip
fw: Inserting blank vertical space

W

warn
novice: Common Derived Objects
WARNING
lib: Source Text Coordinates and Error Reporting
pp: Diagnosing Specification Inconsistencies
pp: warning -- Warning Messages and Error Reports
warning message
pp: warning -- Warning Messages and Error Reports
warning messages
comptrees: Specification Errors
WarnLevel
ui: Variables
weave
pp: fwTex -- TeX input file
Web pages
sysadmin:
white space
novice: Nonliteral character sequences and comments
ptg: Generating Identifiers
ptg: Restrictions:
white space defaults
lex: Spaces, Tabs and Newlines
white space, in odin-expressions
novice: Common Derived Objects
whitespace
clp: Options that have a value given with them
window sizes
mon: X resources used by Noosa
Windows
news4.4: Eli can now run under Windows
WINEDITOR
info: Info Options.
WITH
lidoref: Syntax
clp: Options that are joined to their values
WITH clause
comptrees: Access to Contexts within a Subtree
WITH functions
ptg: Using LIDO CONSTITUENTS
WithClause
lidoref: Syntax
WRAPUP
lex: Deciding on a continuation after a classification
WRAPUPMONITOR
lex: Deciding on a continuation after a classification

X

X resources
mon: X resources used by Noosa
X resources for Noosa
news4.3: Configuring Noosa
X-Windows (X11)
gorto: Using GORTO within ELI
xdvi
fw: Introduction
XML
news4.4: New functionality for unparser generation
idem: Languages describing tree structure
`Xml.fw'
idem: Languages describing tree structure

Z

ZERO
lidoref: Predefined Entities
zero or more
lex: Building complex regular expressions
zero or one
lex: Building complex regular expressions

{

{ }
lex: Building complex regular expressions

|

|
lex: Building complex regular expressions

Table of Contents