Mercury library 1.0 Translation of CFG grammars into an object model (Bachelor's thesis).

- Main Page
- Packages
- Classes
- Files

- Class List
- Class Index
- Class Hierarchy
- Class Members

All Classes Namespaces Files Functions Variables Enumerations Enumerator Properties
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 1 2 3 4]

▼N Mercury |
▼N Exceptions |
C ErrorActionException | Exception thrown by basic actions when a problem was encountered.
C InterpretingException | An exception thrown because of problems in the Interpreting namespace.
C InvalidActionArgumentException | An exception representing a problem while type checking the Mercury.Interpreting.RewriteRule{T}.
C InvalidActionCallException | An exception representing a problem with Mercury.Interpreting.ActionCall{T}
C InvalidActionException | An exception representing a problem with Mercury.Interpreting.InterpreterAction{T} class.
C InvalidEdgeException | An exception thrown when attempting to create an invalid Mercury.Parser.Edge instance.
C InvalidElementException | An exception representing a problem with Mercury.Interpreting.IElement descendants.
C InvalidRewriteRuleException | An exception representing a problem with Mercury.Interpreting.RewriteRule{T}.
C InvalidRuleException | An exception thrown when attempting to create an invalid Mercury.Syntax.Rule instance.
C InvalidSymbolException | An exception thrown when attempting to create an invalid Mercury.Syntax.Symbol instance.
C MercuryException | An exception thrown by the Mercury library.
C SyntaxException | An exception thrown when something wrong happens in the Mercury.Syntax
▼N Interpreting |
C ActionCall< T > | This class represents the application of Mercury.Interpreting.InterpreterAction{T} on the Mercury.Interpreting.IFormalParameter list.
C Alternative | Represents an alternative of elements. It may match specified symbols or symboltypes (Nonterminals, ...).
C Argument | Represents an argument passed to the Mercury.Interpreting.InterpreterAction{T}, the actual parameter given to the Mercury.Interpreting.Evaluator{T} in place of a formal parameter.
C ArithmeticAction< T > | Represents the arithmetic action. It is similar to the Mercury.Interpreting.FoldingAction{T,U,V} but does not require initial value. The minimal number of arguments is therefore 2. For instance, "1 2 3" would be evaluated as `f(f(1, 2), 3)`
C BasicActions< T > | Contains basic actions for interpretation. Type specifiers of actions are defined as follows:
C Constant | Constant element. Basically equivalent of Mercury.Interpreting.Alternative.
C ConstantAction< T, U > | Wraps a value as an action with no parameters
C ConstantParameter | Constant parameter.
C ConvertAction< T, U, V > | Applies the lambda function on a single value.
C DataEntry | Entry base (dummy) interface.
C EmptyContextFactory | Produces contexts with no custom data
C EntryWriter< T > | An auxiliary class that formats the DataEntry structure and writes it into a stream.
C FoldingAction< T, U, V > | "Folds" all its arguments into one value. For instance, for "x y z" arguments this action computes `f(f(f(s,x), y), z)` where `f` is the lamda function and `s` is the `seed` parameter of the constructor
C GenericAction< T > | Represents an action that infers its return type only after it is provided with types of its arguments.
C IElement | Element interface
C IFormalParameter | Represents formal parameters.
C IInterpreter< T > | Interface for interpreters that create objects from derivation trees according to RewriteRules.
C IInterpreterContextFactory | Factory of context.
C Instance | Represents a binding between a Mercury.Interpreting.Variable and its value
C InstanceList | Represents the list of instances
C Interpreter< T > | Interprets derivation trees using rewrite rules. The type parameter T represents the target language.
C InterpreterAction< T > | Function that wraps constant values in the RHS
C InterpreterAction< T, U > | Interpreter action with a safer return type.
C InterpreterContext< T > | Interpreter Context class. Some languages may use it to override it and remember data when parse trees are being interpreted.
C InterpreterResult< T > | Result of the interpretation.
C MemoEntry< T > | Represents memoized value
C OperationAction< T, U, V > | Represents an operation on two values.
C RewriteRule< T > | Interpreter rewrite rule
C RewriteRuleCollection< T > | A read-only collection of rewrite rules
C RewriteRuleCollectionBuilder< T > | Can be used to construct Mercury.Interpreting.RewriteRuleCollection{T}
C RuleEntry< T > | Describes a rule that has been used to interpret a tree.
C SemanticInterpreter< T > | Represent the semantic analysis with interpretation. Consists of two interpreters, the first one rewrites parse trees, the second one interprets them. This class serves as a wrapper so it could be used in the Mercury.Analyser{T,TResult} class.
C Structure | Represents a tree of Mercury.Interpreting.IElement instances. Must match precisely to the parse tree.
C TextEntry | Stores informations logged by actions or internal Evaluator.
C TreeEntry< T > | Represents an entry for tree interpretation.
C Variable | Represents a variable element that captures value and can be used on the RHS of the RewriteRule as an argument
C VariableParameter | Represents a named parameter that will be replaced by an actual value of a variable captured by interpreter.
C Wildcard | An element that matches zero or more values. Can be used as a variable, but the actioncall must be of arity (0, `int.MAX_VALUE`) and must accept `Tree` or `Symbol` as the argument.
▼N Nucleus |
▼N Collections |
C IMultiDictionary< TKey, TValue > | Represents a multi-valued dictionary, in other words a map between a key and a collection of values.
C IReadOnlyMultiDictionary< TKey, TValue > | Represents a multi-valued read-only dictionary, a map between a key and a collection of values.
C ListMultiDictionary< TKey, TValue > | An implementation of IMultiDictionary{TKey,TValue} using T:System.Collections.Generic.List{T} as an underlying collection of values.
C SetMultiDictionary< TKey, TValue > | An implementation of IMultiDictionary{TKey,TValue} using T:System.Collections.Generic.HashSet{T} as an underlying collection of values.
C UniqueListMultiDictionary< TKey, TValue > | An implementation of IMultiDictionary{TKey,TValue} using T:System.Collections.Generic.List{T} as underlying collection, but opposed to ListMultiDictionary{TKey,TValue} does not allow duplicate values associated with the same key
▼N Trees |
C BFSTreeEnumerator< T > | Breadth-First Search tree enumerator
C DFSTreeEnumerator< T > | Depth-First Search tree enumerator
C Tree< T > | A non-balanced tree implementation that can be referenced from many other trees. Because of that, there is no way to get back to the parent node
▼N Scanning |
C ITokenizer | The tokenizer interface.
C Token | Token, a part of an input text recognized by tokenizer
C Tokenizer | A default implementation of ITokenizer interface using Microsoft Regular Expressions. Splits tokens in the following fashion:
▼N Syntax |
C BasicScanner | Generates four Nonterminals `@Symbol`, `@Keyword`, `@Number` and `@String` based on the given map and types of input tokens.
C BasicScannerMap | Contains mapping between TokenType and Mercury.Syntax.Mapping of Mercury.Syntax.BasicScanner.
C ChartParser | Thread-safe wrapper for ChartParserInternal class.
C CompositeScanner | Mercury.Syntax.IScanner implementation that behaves like container of scanners using the Composite Design Pattern
C Edge | Represents an edge in the chart created by the ChartParser. This is an immutable class. The Edge contains four values:
C Grammar | Represents a Context-Free Grammar. This is an immutable class, to create a grammar use Mercury.Syntax.GrammarBuilder.
C GrammarBuilder | Class that creates grammars.
C IParser | Creates a derivation tree from the list of input tokens
C IScanner | Scanner scans input tokens and creates additional rules for parsing
C ParserResult | Represents the result returned by the parser.
C Rule | Represents a Context-Free Grammar rule. This is an immutable class
C Symbol | Represents a single symbol of the grammar. This is an immutable class. For a symbol name to be valid it must NOT contain control or separator characters, must not be empty and must meet these conditions:
C Analyser< T > | Wrapper class for each step of analysis
C Analyser< T, TResult > | Wrapper class for each step of analysis.
C AnalyserResult< T, TResult > | Holds the result of analysis. The fields hold information according to the following table:
C Defaults | Global class containing cool static / convenience stuff.
C Extensions | Provides extension methods for the Mercury library.
C LanguageInfo< T > | Represents a collection of information required to analyze a language with Mercury Mercury.Analyser{T,TValue}.