Constructor.

Destructor.

Adds an additional attribute to an existing rule node.

For example, this is used with range rules, which specify the range boundaries using start and end attributes.

Adds a callback to a rule.

Processes an EAnd rule node.

It is called by PerformRuleL() .

Gets the attribute look-up table used by this parser.

Notifies the parser that all the data has been passed in.

It causes the parser to parse any of the input stream not already parsed.

Gets a pointer to the rule node currently being processed.

Removes the latest mark. All the marks are stored in a stack and this removes the topmost mark.

Processes an EExact rule node.

It is called by PerformRuleL() .

Executes a post-rule callback function.

Executes a pre-rule callback function.

Set a mark to the current position of the input stream.

The mark acts as a tag in the stream currently being processed. As we process further along the stream after adding the mark, we can perform a rollback to the most previously set mark and start processing again (e.g. OR rule works this way). The string fragments won't be consumed (deleted) until all the marks on a fragment (and fragments before that) are deleted.

Inserts a mark to the current position of the stream being processed.

Adding a mark is a very common callback operation before starting to process a rule, so the method is provided by the parser.

Get string between the "cursor position" and the latest mark on the stream.

Gets the marked string with a string added before the mached string. MarkedL()

Processes an ENMore rule node.

It is called by PerformRuleL() .

Creates a new rule tree root node.

It creates a new single instance of CBNFNode as the root node of the rule tree. All the top-level rules are attached as attributes to this node. The root node should have single child node, which should be a reference to the logical root of the rule tree. This can be done be attaching the logical root rule as a component to the root rule.

Creates a new rule node, but does not add it to the tree.

This overload sets no rule callbacks.

Creates a new rule node, but does not add it to the tree.

This overload allows rule callbacks to be set.

Creates a new reference rule node.

Creates a new sub-rule, and makes it a child of a specified parent rule.

This overload sets no rule callbacks.

Creates a new sub-rule, and makes it a child of a specified parent rule.

This overload sets rule callbacks.

Creates a new reference rule node, and adds it as a child of the specified parent.

Note that the function succeeds even if the target rule aRuleName does not yet exist.

Allocates and constructs a new BNF parser.

Creates a new rule node and adds it to the root of the rule tree.

This overload takes ownership of the node data.

Creates a new rule node and adds it to the root of the rule tree.

This overload takes a reference to the node data instead of owning it.

Tests if an Optional node sub-rule matched.

Processes an EOr rule node.

It is called by PerformRuleL() .

Handles a node in the rule tree.

It calls the appropriate handler method for the rule type.

Called by the data provider to add data for the parser to process.

This implements MDataProviderObserver::ProcessDataL() .

Processes an ERange rule node.

It is called by PerformRuleL() .

Processes a reference rule node.

It is called by PerformRuleL() .

Reset the parser to a state where it can accept and parse new input.

If no BNF tree yet exists the virtual method TreeL() is called to obtain the BNF tree for this parser. Any existing state of parsing and input data is destroyed.

Tests if the used rule matched.

This is typically used in post-rule callbacks.

Processes an ESelect rule node.

It is called by PerformRuleL() .

Sets the parser state.

Called by the data provider to report its status to its observer.

This implements MDataProviderObserver::SetStatus() .

Get the current state of the parser.

Concatenates the rest of the input stream (which hasn't yet been processed) into a single string. The ownership of the string is given to the caller.

Checks if the input stream was completely processed

Processes an EWithout rule node.

It is called by PerformRuleL() .

Defines a type to handle a stack of rules.

Type definition for a callback function pointer Callback functions need to get a reference to the parser as parameter and they need to be static.

The BNF rule that is currently being processed.

Storage object for all the attributes and identifiers in a tree

Input stream matched rule flag.

Stores attribute identifier for nmore count attributes.

Stores attribute identifier for nmore maximum attributes.

Stores attribute identifier for nmore minimum attributes.

Flag that indicates when returning to a rule in the rulestack if an optional rule matched correctly.

Parser state.

Stores attribute identifier for post-rule callback attributes.

Stores attribute identifier for pre-rule callback attributes.

Stores attribute identifier for range end attributes.

Stores attribute identifier for range start attributes.

Stores attribute identifier for reference string attributes.

A stack of rules from iTree which are waiting to be completed. The stack basically holds the path along the rule tree.

An utility object which stores all the buffers passed into the parser and represents them as if they would form a single, continuous string. This class also performs the actual physical matching/selection of the strings and holds the marks set onto the string.

Flag indicating if the input stream has been completely processed.

The child rule we are returning from (if any). If this is NULL we are new to this BNF rule.

Flag that indicates when returning to a rule in the rulestack if the child rule matched correctly.

The BNF tree the parser is using to parse the input stream.