org.vishia.zbnf

Class ZbnfParser.PrescriptParser.SubParser

java.lang.Object

org.vishia.zbnf.ZbnfParser.PrescriptParser.SubParser

Enclosing class:

ZbnfParser.PrescriptParser

class ZbnfParser.PrescriptParser.SubParser
extends java.lang.Object

To parse nested syntax, for every level a subparser is created.

Field Summary

Fields

Modifier and Type	Field and Description
(package private) boolean	bDoNotStoreData
private int	nRecursion Recursionscounter
(package private) ZbnfParserStore.ParseResultItemImplement	parentOfParentResultItem Reference to the parent parse result item of the parent, given on constructor.
(package private) ZbnfParser.PrescriptParser.SubParser	parentParser Pointer to parent, used for build expected syntax on error:
(package private) long	posStoreSrc If not 0 then <@?
(package private) java.lang.String	semanticStoreSrc Associated semantic to store the source. null: nothing to store.
private int[]	srcColumn last parsed column in an item.
private int	srcLine last parsed line in an item.
(package private) java.lang.String	sSemanticForError The semantic for getExpectedSyntaxOnError.
(package private) int	xxxidxAlternative Counter of tested alternatives.

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	SubParser(ZbnfParser.PrescriptParser.SubParser parent, ZbnfParserStore.ParseResultItemImplement parentResultItem, boolean bDoNotStoreData, int nRecursion) Constructs a new Parser with a given parsed syntaxPrescript and a given input and output buffer.

Method Summary

Modifier and Type	Method and Description
private boolean	addResultOrSubsyntax(java.lang.CharSequence sResult, long srcBegin, int srcLine, int srcColumn, java.lang.String srcFile, java.lang.String sSemanticForStoring, ZbnfParserStore.ParseResultItemImplement parentResultItem, ZbnfSyntaxPrescript syntaxItem)
private java.lang.String	getSemanticTreeForErrorMsg() gets the tree of semantic while parsing
private void	init() call if reused.
private boolean	parse_Component(StringPartScan sInputP, int posInputbase, ZbnfSyntaxPrescript syntaxCmpn, java.lang.String sSemanticForStoring, ZbnfParserStore.ParseResultItemImplement parentResultItem, boolean bSkipSpaceAndComment, boolean bDoNotStoreData, ZbnfSyntaxPrescript parentSyntaxItem, boolean bResultToAssignIntoNextComponent, boolean bAddParseResultFromPrevious) parses a component.
private boolean	parseExpectedVariant(ZbnfSyntaxPrescript syntaxPrescript, boolean bSkipSpaceAndComment, int recursion)
private boolean	parseFloatNumber(ZbnfSyntaxPrescript syntaxItem, int maxNrofChars, ZbnfParserStore.ParseResultItemImplement parentResultItem)
private boolean	parseHexNumber(ZbnfSyntaxPrescript syntaxItem, ZbnfParserStore.ParseResultItemImplement parentResultItem, int maxNrofChars)
private boolean	parseIdentifier(java.lang.String addChars, java.lang.String sSemanticForStoring, ZbnfParserStore.ParseResultItemImplement parentResultItem)
private boolean	parseInteger(ZbnfSyntaxPrescript syntaxItem, ZbnfParserStore.ParseResultItemImplement parentResultItem, int maxNrofChars)
private boolean	parseItem(ZbnfSyntaxPrescript syntaxItem, ZbnfParserStore.ParseResultItemImplement parentResultItem, boolean bSkipSpaceAndComment, int recursion) parses one item.
private boolean	parseNegativVariant(ZbnfSyntaxPrescript syntaxNegativ, boolean bSkipSpaceAndComment, int recursion)
private boolean	parseNoOrSomeCharsOutsideQuotion(java.lang.String sSyntax, int maxNrofChars, java.lang.String sSemanticForStoring, ZbnfParserStore.ParseResultItemImplement parentResultItem, ZbnfSyntaxPrescript syntaxItem)
private boolean	parseNumberRadix(ZbnfSyntaxPrescript syntaxItem, ZbnfParserStore.ParseResultItemImplement parentResultItem, int maxNrofChars) Any desired radix, 2, 8, 16, 24 etc.
private boolean	parseOptions(ZbnfSyntaxPrescript optionPrescript, ZbnfParserStore.ParseResultItemImplement parentResultItem, boolean bSkipSpaceAndComment, int recursion) Parses at start of an option.
private boolean	parsePositiveInteger(ZbnfSyntaxPrescript syntaxItem, ZbnfParserStore.ParseResultItemImplement parentResultItem, int maxNrofChars)
(package private) boolean	parsePrescript(ZbnfSyntaxPrescript prescriptItem, ZbnfParserStore.ParseResultItemImplement parentResultItem, boolean bSkipSpaceAndCommentForward, boolean bDoNotStoreData, int recursion) Parse one linear prescript maybe with options to test first after.
private boolean	parseRegularExpression(ZbnfSyntaxPrescript syntaxItem, java.lang.String sSemanticForStoring, ZbnfParserStore.ParseResultItemImplement parentResultItem, boolean bSkipSpaceAndComment)
private boolean	parseRepetition(ZbnfSyntaxPrescript forwardSyntax, ZbnfSyntaxPrescript backwardSyntax, ZbnfParserStore.ParseResultItemImplement parentResultItem, boolean bSkipSpaceAndComment, int recursion)
private boolean	parseSimpleStringLiteral(java.lang.String sQuotionMarks, int maxNrofChars, java.lang.String sSemanticForStoring, ZbnfParserStore.ParseResultItemImplement parentResultItem, ZbnfSyntaxPrescript syntaxItem)
private boolean	parseStringUntilRightEndchar(java.lang.String sConstantSyntax, boolean bInclusive, int maxNrofChars, java.lang.String sSemanticForStoring, ZbnfParserStore.ParseResultItemImplement parentResultItem, ZbnfSyntaxPrescript syntaxItem) parses until one of some endchars from right.
private boolean	parseStringUntilTerminateString(java.lang.String sConstantSyntax, boolean bInclusive, boolean bTrim, int maxNrofChars, java.lang.String sSemanticForStoring, ZbnfParserStore.ParseResultItemImplement parentResultItem, ZbnfSyntaxPrescript syntaxItem) parses until one of some one of the end strings.
boolean	parseSub(ZbnfSyntaxPrescript syntaxPrescript, java.lang.String sSemanticForErrorDefault, int resultType, ZbnfSyntaxPrescript parentSyntaxItem, java.lang.String sSemanticForStoring, ZbnfParserStore.ParseResultItemImplement parentResultItem, boolean bSkipSpaceAndComment, ZbnfParserStore parseResultsFromOtherComponents, int recursion) Parses a syntax-prescript assigned with this class.
private boolean	parseTerminalSymbol(ZbnfSyntaxPrescript syntaxItem, ZbnfParserStore.ParseResultItemImplement parentResultItem) checks a terminal symbol.
private boolean	parseUnconditionalVariant(ZbnfSyntaxPrescript syntaxPrescript, ZbnfParserStore.ParseResultItemImplement parentResultItem, boolean bSkipSpaceAndComment, int recursion)
private boolean	parseWhiteSpaceAndComment()
private boolean	parseWhiteSpaceAndCommentOrTerminalSymbol(java.lang.String sConstantSyntax, ZbnfParserStore.ParseResultItemImplement parentResultItem) Skips white spaces and parses a given constant syntax before checking and skipping comments.
private void	saveError(java.lang.String sSyntax) Sets the rightest position of matched input.
java.lang.String	XXXgetDefinitionIdent()
ZbnfParserStore	xxxgetParserStore() Gets the parser Store

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

nRecursion

private final int nRecursion

Recursionscounter

xxxidxAlternative

int xxxidxAlternative

Counter of tested alternatives. On succesfull parsing it is the number of matched alternative.

sSemanticForError

java.lang.String sSemanticForError

The semantic for getExpectedSyntaxOnError.

See Also:

ZbnfParser.getExpectedSyntaxOnError()

posStoreSrc

long posStoreSrc

If not 0 then <@?semantic> was detected, to store the source to this path till end of sub syntax.

semanticStoreSrc

java.lang.String semanticStoreSrc

Associated semantic to store the source. null: nothing to store.

bDoNotStoreData

final boolean bDoNotStoreData

parentParser

final ZbnfParser.PrescriptParser.SubParser parentParser

Pointer to parent, used for build expected syntax on error:

parentOfParentResultItem

final ZbnfParserStore.ParseResultItemImplement parentOfParentResultItem

Reference to the parent parse result item of the parent, given on constructor.

srcColumn

private final int[] srcColumn

last parsed column in an item.

srcLine

private int srcLine

last parsed line in an item.

Constructor Detail

SubParser

protected SubParser(ZbnfParser.PrescriptParser.SubParser parent,
                    ZbnfParserStore.ParseResultItemImplement parentResultItem,
                    boolean bDoNotStoreData,
                    int nRecursion)

Constructs a new Parser with a given parsed syntaxPrescript and a given input and output buffer. This constructor is used by recursively calling.

Parameters:

syntax - The prescript is a child of the parents' prescript.

parent - Parent level of parsing, for debug and transform parseResultToOtherComponent.

parserStoreInPrescript - typically the same result buffer as parent, but an other buffer, typically identically with parent.parssResultToOtherComponent, if the result shouldn't be stored in main stream, used to transform semantic results to a followed item (<..?->-Syntax). It may be null, than create a new temporary parser result buffer.

Method Detail

init

private void init()

call if reused.

parseSub

public boolean parseSub(ZbnfSyntaxPrescript syntaxPrescript,
                        java.lang.String sSemanticForErrorDefault,
                        int resultType,
                        ZbnfSyntaxPrescript parentSyntaxItem,
                        java.lang.String sSemanticForStoring,
                        ZbnfParserStore.ParseResultItemImplement parentResultItem,
                        boolean bSkipSpaceAndComment,
                        ZbnfParserStore parseResultsFromOtherComponents,
                        int recursion)
                 throws java.text.ParseException

Parses a syntax-prescript assigned with this class. The prescript may be a syntax component, but also an option or repetition. This routine should be called only one time with a new instance of SubParser. Some instances of SubParser may be created in nested levels.

The input is used from the outer class Parser, aggregation 'input'. It is running in a while()-loop. The loop breaks at end of syntax-prescript or if no path in syntax prescript matches to the input. Inside the method 'parseComplexSyntax()' this method may be called recursively, if the syntax prescript contains <syntax...>.


If a semantic for storing is given as input argument sSemanticForStoring, or the syntax prescript have a semantic itself, a parse result is stored as a component for this sub parsing. A semantic as input argument is given if this call results of <syntax...>. A semantic itself is given if the prescript starts with <?syntax> at example in option brackets [<?syntax>... or repeat brackets {<?syntax>... or also possible at start of an nested prescript ::=<?syntax>...

Every time at first the whitespaces and comments are skipped over before the matching of the input to the syntax prescript is tested. The mode of skipping whitespace and comments may be setted by calling setSkippingComment(), setSkippingWhitespace() and setSkippingEndlineComment(), see there.


If the syntax prescript contains a semantic, this is at example by [<?semantic>...], a parse result is written, containing the semantic and the nr of choice if there are some alternatives. Also an empty option is considered.

Parameters:

input - The input to parse,it is a reference to the same instance as in parent.

sSemanticForErrorP - The semantic superior semantic. This semantic is used for error report.

resultType - type of the result item of this component. It may one of ParserStore.kOption etc or a less positiv or negativ number used for repetition and backward repetition.

sSemanticForStoring1 - The semantic given at the calling item. It may be

• null: No parse result item is created for this level of syntax component. In ZBNF this behavior is forced with noting <component?> by using the component.
• an identifier: A parse result item is created in the parsers result with this given semantic.
• an identifier started with an @: The same as a normal identifier, but in XML output a attribute is created instead an element.
• The string "@": The own semantic of the component is used. The semantic of the component is either identical with the name of the component, or it is defined in ZBNF with the construct component::=<?semantic>. This is the regulary case for mostly calls of syntax component, especially in ZBNF via the simple <syntax>.
  It is possible that the components semantic is null, in this case no parse result item is created for this level. A null-semantic of the component is given in ZBNF via construct component::=<?>. For transforming ZBNF a SyntaxPrescript see @see SyntaxPrescript.convertSyntaxDefinition(StringPart spInput) If not own semantic of the component is defined,

input - The input String.

sSemanticForErrorDefault - It is used only if the component has not a semantic.

resultType - The type of Parser Store result, see ZbnfParserStore.kTerminalSymbol etc. A positiv number 1... is the count of repetition.

sSemanticForStoring -

parentResultItem - the parent parse result item for a new child.

bSkipSpaceAndComment - if true, than white spaces or comments are possible at actual input positions and should be skipped before test a non-terminate syntax and should be skipped after test a terminate syntax if its failed.

Returns:

true if successfully, false on error.

Throws:

java.text.ParseException

parsePrescript

boolean parsePrescript(ZbnfSyntaxPrescript prescriptItem,
                       ZbnfParserStore.ParseResultItemImplement parentResultItem,
                       boolean bSkipSpaceAndCommentForward,
                       boolean bDoNotStoreData,
                       int recursion)
                throws java.text.ParseException

Parse one linear prescript maybe with options to test first after.

Parameters:

listPrescripts - list of the syntax sub prescripts

bSkipSpaceAndCommentForward - true then outside a space skip is set

Returns:

true on success.

Throws:

java.text.ParseException

parseItem

private boolean parseItem(ZbnfSyntaxPrescript syntaxItem,
                          ZbnfParserStore.ParseResultItemImplement parentResultItem,
                          boolean bSkipSpaceAndComment,
                          int recursion)
                   throws java.text.ParseException

parses one item. In this method a switch-case to the type of syntaxitem is done. Because a terminal symbol or regular expression may be test with including comment parts, the input is provided with leading white spaces and comments.

Parameters:

parentResultItem - the parent parse result item for a new child.

bSkipSpaceAndComment - true if the calling level determines that white spaces and comments are to skip.

Returns:

Throws:

java.text.ParseException

parseWhiteSpaceAndComment

private boolean parseWhiteSpaceAndComment()

parseWhiteSpaceAndCommentOrTerminalSymbol

private boolean parseWhiteSpaceAndCommentOrTerminalSymbol(java.lang.String sConstantSyntax,
                                                          ZbnfParserStore.ParseResultItemImplement parentResultItem)

Skips white spaces and parses a given constant syntax before checking and skipping comments. Other comment parts are skipped. If the sConstantSyntax is given, it have to be found. Otherwise the current position of input is rewind to the start before this method is calling (no whitespaces and comments are skipped!). If the constant syntax is not given, all comments and white spaces are skipped.

Parameters:

sConstantSyntax - The string to test as terminal symbol or null.

parentResultItem - the parent parse result item for a new child, can be null if sConstantSyntax is null.

Returns:

true if the constant syntax given by syntaxItem is found. false if it is not found or syntaxItem == null.

parseTerminalSymbol

private boolean parseTerminalSymbol(ZbnfSyntaxPrescript syntaxItem,
                                    ZbnfParserStore.ParseResultItemImplement parentResultItem)

checks a terminal symbol.

Parameters:

syntaxItem - The syntaxitem of a terminal symbol, containing the constant syntax.

parentResultItem - the parent parse result item for a new child.

Returns:

##s

parseRegularExpression

private boolean parseRegularExpression(ZbnfSyntaxPrescript syntaxItem,
                                       java.lang.String sSemanticForStoring,
                                       ZbnfParserStore.ParseResultItemImplement parentResultItem,
                                       boolean bSkipSpaceAndComment)
                                throws java.text.ParseException

Parameters:

syntaxItem -

sSemanticForStoring -

parentResultItem - the parent parse result item for a new child.

bSkipSpaceAndComment -

Returns:

Throws:

java.text.ParseException

parseIdentifier

private boolean parseIdentifier(java.lang.String addChars,
                                java.lang.String sSemanticForStoring,
                                ZbnfParserStore.ParseResultItemImplement parentResultItem)

parsePositiveInteger

private boolean parsePositiveInteger(ZbnfSyntaxPrescript syntaxItem,
                                     ZbnfParserStore.ParseResultItemImplement parentResultItem,
                                     int maxNrofChars)
                              throws java.text.ParseException

Throws:

java.text.ParseException

parseHexNumber

private boolean parseHexNumber(ZbnfSyntaxPrescript syntaxItem,
                               ZbnfParserStore.ParseResultItemImplement parentResultItem,
                               int maxNrofChars)
                        throws java.text.ParseException

Throws:

java.text.ParseException

parseNumberRadix

private boolean parseNumberRadix(ZbnfSyntaxPrescript syntaxItem,
                                 ZbnfParserStore.ParseResultItemImplement parentResultItem,
                                 int maxNrofChars)
                          throws java.text.ParseException

Any desired radix, 2, 8, 16, 24 etc.

Parameters:

syntaxItem -

parentResultItem -

maxNrofChars -

Returns:

Throws:

java.text.ParseException

parseInteger

private boolean parseInteger(ZbnfSyntaxPrescript syntaxItem,
                             ZbnfParserStore.ParseResultItemImplement parentResultItem,
                             int maxNrofChars)
                      throws java.text.ParseException

Throws:

java.text.ParseException

parseFloatNumber

private boolean parseFloatNumber(ZbnfSyntaxPrescript syntaxItem,
                                 int maxNrofChars,
                                 ZbnfParserStore.ParseResultItemImplement parentResultItem)
                          throws java.text.ParseException

Throws:

java.text.ParseException

parseNoOrSomeCharsOutsideQuotion

private boolean parseNoOrSomeCharsOutsideQuotion(java.lang.String sSyntax,
                                                 int maxNrofChars,
                                                 java.lang.String sSemanticForStoring,
                                                 ZbnfParserStore.ParseResultItemImplement parentResultItem,
                                                 ZbnfSyntaxPrescript syntaxItem)
                                          throws java.text.ParseException

Throws:

java.text.ParseException

parseStringUntilRightEndchar

private boolean parseStringUntilRightEndchar(java.lang.String sConstantSyntax,
                                             boolean bInclusive,
                                             int maxNrofChars,
                                             java.lang.String sSemanticForStoring,
                                             ZbnfParserStore.ParseResultItemImplement parentResultItem,
                                             ZbnfSyntaxPrescript syntaxItem)
                                      throws java.text.ParseException

parses until one of some endchars from right.

Parameters:

sConstantSyntax - contains the possible end chars

bInclusive - If true, the end char is parsed inclusive, if false, than exclusive.

maxNrofChars - possible given at left position <123....> or Integer.MAX_VALUE

sSemanticForStoring - The semantic, null if no result should be stored.

sSubSyntax - not null, the name of the inner syntax prescript if there is one.

parseResult - Buffer to store the result. It may be a special buffer or the main buffer.

Returns:

Throws:

java.text.ParseException

parseStringUntilTerminateString

private boolean parseStringUntilTerminateString(java.lang.String sConstantSyntax,
                                                boolean bInclusive,
                                                boolean bTrim,
                                                int maxNrofChars,
                                                java.lang.String sSemanticForStoring,
                                                ZbnfParserStore.ParseResultItemImplement parentResultItem,
                                                ZbnfSyntaxPrescript syntaxItem)
                                         throws java.text.ParseException

parses until one of some one of the end strings.

Parameters:

sConstantSyntax - now unused.

bInclusive - If true, the end char is parsed inclusive, if false, than exclusive.

maxNrofChars - possible given at left position <123....> or Integer.MAX_VALUE

sSemanticForStoring - The semantic, null if no result should be stored.

syntaxItem - The syntax item, contains info for substrings, see ZbnfSyntaxPrescript.getListStrings().

parseResult - Buffer to store the result. It may be a special buffer or the main buffer.

Returns:

Throws:

java.text.ParseException

parse_Component

private boolean parse_Component(StringPartScan sInputP,
                                int posInputbase,
                                ZbnfSyntaxPrescript syntaxCmpn,
                                java.lang.String sSemanticForStoring,
                                ZbnfParserStore.ParseResultItemImplement parentResultItem,
                                boolean bSkipSpaceAndComment,
                                boolean bDoNotStoreData,
                                ZbnfSyntaxPrescript parentSyntaxItem,
                                boolean bResultToAssignIntoNextComponent,
                                boolean bAddParseResultFromPrevious)
                         throws java.text.ParseException

parses a component. This method creates a new SubParser instances and works with an own syntax definition, in ZBNF written as "sDefinitionIdent::=.... .". It is possible to parse in mainstream input, in this case this.input should be given as parameter sInputP, or it is possible to parse a detected part of input, escpecially after parsing "<*...?!sDefinitionIdent>".
It is also possible to write the result in the main parse result buffer, or in a extra buffer.

Parameters:

sInputP - input to parse. This may be the main input from this.

posInputbase - The position of the given sInputP in the originally input. Note that this parse routine does not use the ZbnfParser.PrescriptParser.input but parses the sInputP. This is the offset information.

sDefinitionIdent - Identifier of the Syntax prescript, written in ZBNF at "sDefinitionIdent::=..."

sSemanticForStoring - If the semantic is specified outside, it is its identifier. Otherwise it is null

bSkipSpaceAndComment - True if there are spaces in the prescript before this component.

bResultToAssignIntoNextComponent - If true, than the second Buffer ZbnfParser.PrescriptParser.parseResultToOtherComponent is used to store the parse result. That is, if the calling syntax/semantic syntax contains <...?-...>>.

parentSyntaxItem - That syntax element which invokes parsing this component. It contains for example the ZbnfSyntaxPrescript.bDebugParsing for a manual break while debugging.

bAddParseResultFromPrevious - If true, than this Parseresult containing in ZbnfParser.PrescriptParser.parseResultToOtherComponent should be added at start of this components result associated to this component. It is a result of previous parsing with <...?-...>>, stored now because the components prescript has the form <...?+...>>.

Returns:

true if succesfull, false if the input not matches to the prescript.

Throws:

java.text.ParseException

addResultOrSubsyntax

private boolean addResultOrSubsyntax(java.lang.CharSequence sResult,
                                     long srcBegin,
                                     int srcLine,
                                     int srcColumn,
                                     java.lang.String srcFile,
                                     java.lang.String sSemanticForStoring,
                                     ZbnfParserStore.ParseResultItemImplement parentResultItem,
                                     ZbnfSyntaxPrescript syntaxItem)
                              throws java.text.ParseException

Throws:

java.text.ParseException

parseSimpleStringLiteral

private boolean parseSimpleStringLiteral(java.lang.String sQuotionMarks,
                                         int maxNrofChars,
                                         java.lang.String sSemanticForStoring,
                                         ZbnfParserStore.ParseResultItemImplement parentResultItem,
                                         ZbnfSyntaxPrescript syntaxItem)
                                  throws java.text.ParseException

Parameters:

sQuotionMarks - left and right quotion mark char, typical "" or '', also possible <> or ><

maxNrofChars -

sSemantic -

Returns:

Throws:

java.text.ParseException

parseOptions

private boolean parseOptions(ZbnfSyntaxPrescript optionPrescript,
                             ZbnfParserStore.ParseResultItemImplement parentResultItem,
                             boolean bSkipSpaceAndComment,
                             int recursion)
                      throws java.text.ParseException

Parses at start of an option.

Parameters:

options - The current syntaxprescript item, a option item.

Returns:

Throws:

java.text.ParseException

parseNegativVariant

private boolean parseNegativVariant(ZbnfSyntaxPrescript syntaxNegativ,
                                    boolean bSkipSpaceAndComment,
                                    int recursion)
                             throws java.text.ParseException

Throws:

java.text.ParseException

parseExpectedVariant

private boolean parseExpectedVariant(ZbnfSyntaxPrescript syntaxPrescript,
                                     boolean bSkipSpaceAndComment,
                                     int recursion)
                              throws java.text.ParseException

Throws:

java.text.ParseException

parseUnconditionalVariant

private boolean parseUnconditionalVariant(ZbnfSyntaxPrescript syntaxPrescript,
                                          ZbnfParserStore.ParseResultItemImplement parentResultItem,
                                          boolean bSkipSpaceAndComment,
                                          int recursion)
                                   throws java.text.ParseException

Throws:

java.text.ParseException

parseRepetition

private boolean parseRepetition(ZbnfSyntaxPrescript forwardSyntax,
                                ZbnfSyntaxPrescript backwardSyntax,
                                ZbnfParserStore.ParseResultItemImplement parentResultItem,
                                boolean bSkipSpaceAndComment,
                                int recursion)
                         throws java.text.ParseException

Throws:

java.text.ParseException

saveError

private void saveError(java.lang.String sSyntax)

Sets the rightest position of matched input. Usefull to support the methods getFoundedInputOnError() and getExpectedSyntaxOnError().
This method should be called always in inner routine if a test failed. The expected syntax will be added in a string if the same position is tested more as one time. So the user gets a synopsis of expected syntax at the rightest error position.

Parameters:

sSyntax - The expected syntax.

getSemanticTreeForErrorMsg

private java.lang.String getSemanticTreeForErrorMsg()

gets the tree of semantic while parsing

Returns:

Tree of semantic, every sSemanticForError is divide by a dot.

xxxgetParserStore

public ZbnfParserStore xxxgetParserStore()

Gets the parser Store

Returns:

The parser Store

XXXgetDefinitionIdent

public java.lang.String XXXgetDefinitionIdent()