ZbnfParser

java.lang.Object
- org.vishia.zbnf.ZbnfParser

```
public class ZbnfParser
extends java.lang.Object
```
An instance of ZbnfParser contains a syntax prescript inside and is able to parse a text, test the syntax and output a tree of information given in the input text.
The invocation is in followed manner:
```
 ZbnfParser parser = new ZbnfParser(reportConsole);
 try{ parser.setSyntax(syntaxString);}
 catch(ParseException exception)
 { writeError("parser reading syntax error: " + exception.getMessage();
   return;
 }
 if(!parser.parse(inputString))
 { writeError(parser.getSyntaxErrorReport());
 }
 else
 { ParseResultItem resultItem = parser.getFirstParseResult();
   while( resultItem != null)
   { evaluateResult(resultItem);
     resultItem = resultItem.next(null))
   }
 }
```
The syntax
The Syntax given as argument of setSyntax(StringPart) is to be defined in the Semantic Backus Naur-Form (ZBNF, Z is a reverse S for Semantic). It is given as a String or StringPartScan. The method setSyntax, reads the string and convert it in internal data. The input string (mostly readed from a file) may be consist of a sequence of variables beginning with $ and syntax terms. A syntax term is described on the class ZbnfSyntaxPrescript, because this class converts a syntax term in an internal tree of syntax nodes. Downside it is shown an example of a syntax file or string with all variables.
```
 <?ZBNF-www.vishia.org version="1.0" encoding="iso-8859-1" ?>  ##this first line is not prescribed but possible.
 $setLinemode.                                 ##if set, than the newline char \n is not overwritten as whitespace
 $endlineComment=##.                           ##defines the string introducing a comment to eol, default is //
 $comment=[*...*].                             ##... between [* ... *] all chars are ignored, default is /*...* /
 $keywords=if|else.                            ##that identifiers are not accepted as identifiers parsing by <$?...>
 $inputEncodingKeyword="encoding".             ##it helps to define the encoding of the input file via a keyword input-file
 $inputEncoding="UTF-8".                       ##it helps to define the encoding of the input file (useable outside parser core)
 $xmlns:nskey="value".                         ##defines a namespace key for XML output (useable outside parser core)
 
 component::=<$?name>=<#?number> { <value> , }. ##The first syntax term is the toplevel syntax.
 value::= val = [ a | b | c].         ##another syntax term
 
```
White space and comment handling when parsing
The whitespaces and/or comments may be skipped over while parsing or not. The following rules ar valid:
- The comment start/end characters defined in the syntax prescript are valid, if a calling of setSkippingComment(String, String, boolean), setSkippingEndlineComment(String, boolean), setWhiteSpaces(String), setLinemode(boolean) is not occured after setSyntax(String).
- Whitespaces and comments are skipped before any matching test occurs, but only if the syntax term in the syntax prescript has at least one whitespace at this position.
- The consideration of whitespaces in syntax terms are switchable off by using the <$NoWhiteSpaces>-construct, see ZbnfSyntaxPrescript.
- But if constant symbols are tested, first a comment is not skipped but tested. If the comment start with this constants, it is recognized as content. So it is possible to include comments in the parsing process . If the constant are not matched to a start of comment, the comment is skipped over and the test is repeated.
Evaluate the parsers result
By calling Parser.parse() a new result buffer is created. The result buffer contains entries with the parsed informations appropriate to the semantic semantic named in the syntax prescript. The evaluation of result starts with getFirstParseResult() to get the toplevel item.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`ZbnfParser.Args`
`(package private) static class`	`ZbnfParser.ForkPoint` Position where an option should be parsed.
`(package private) static class`	`ZbnfParser.LogParsing` This class contains some information to create a log output which logs the parsing process.
`(package private) class`	`ZbnfParser.LogZbnfParser` Class for logging.
`(package private) static class`	`ZbnfParser.ParseResultlet` Element of a Parse result for a part of the syntax.
`(package private) class`	`ZbnfParser.PrescriptParser` Class to organize parsing of a component with a own prescript.

Field Summary

Fields
Modifier and Type	Field and Description
`(package private) java.util.TreeMap<java.lang.String,ZbnfParser.ParseResultlet>`	`alreadyParsedCmpn` Already parsed components with the same input text which should be requested in another context.
`ZbnfParser.Args`	`args`
`protected boolean`	`bConstantSyntaxAsParseResult` Set if constant syntax (terminate morphems) also should stored.
`(package private) boolean`	`bStoreComment` If it is true, the comment is stored in the ParserStore and is supplied by calling getFirstParseResult() and from there calling next().
`(package private) boolean`	`bStoreEndlineComment` If it is true, the end-line-comment is stored in the ParserStore and is supplied by calling getFirstParseResult() and from there calling next().
`(package private) boolean`	`bStoreNewline` If it is true, a newline is stored in the ParserStore and is supplied by calling getFirstParseResult() and from there calling next().
`(package private) boolean`	`bStoreOneSpaceOnWhitespaces` If it is true, one space is stored on whitespaces in the ParserStore and is supplied by calling getFirstParseResult() and from there calling next().
`(package private) boolean`	`bStoreWhiteSpaces` If it is true, the complete white spaces are stored in the ParserStore and is supplied by calling getFirstParseResult() and from there calling next().
`private ZbnfParserStore.BuilderTreeNodeXml`	`builderTreeNodeXml`
`private java.nio.charset.Charset`	`charsetInput`
`protected int`	`columnError` The lineError and columnError will be set if the input supports it, see `StringPart.getLineAndColumn(int[])`.
`(package private) int`	`dbgLineSyntax`
`(package private) int`	`dbgPosFrom`
`(package private) int`	`dbgPosTo`
`protected int`	`idReportBranchParsing`
`protected int`	`idReportComponentParsing`
`protected int`	`idReportError`
`protected int`	`idReportInfo`
`protected int`	`idReportParsing` The ident to report the progress of parsing.
`protected java.util.Map<java.lang.String,java.lang.String>`	`idxMissingPrescripts`
`protected int`	`lineError` The lineError and columnError will be set if the input supports it, see `StringPart.getLineAndColumn(int[])`.
`(package private) java.util.TreeMap<java.lang.String,java.lang.String>`	`listKeywords` Keywords
`(package private) java.util.ArrayList<ZbnfParseResultItem>`	`listParseResultOnError` founded content on rightest parsing error position.
`protected java.util.TreeMap<java.lang.String,ZbnfSyntaxPrescript>`	`listSubPrescript` The list of some all syntax definitons (syntax components).
`private ZbnfParser.LogParsing`	`log`
`(package private) ZbnfParser.LogZbnfParser`	`log1`
`private ZbnfSyntaxPrescript`	`mainScript` The main syntax prescript set from `setSyntax(StringPart)`.
`private int`	`maxParseResultEntriesOnError` Maximum number of shown parsing results on error.
`(package private) static int`	`mXmlSrcline_xmlWrmode`
`(package private) static int`	`mXmlSrctext_xmlWrmode`
`protected int`	`nLevelReportBranchParsing`
`protected int`	`nLevelReportComponentParsing`
`protected int`	`nLevelReportError`
`protected int`	`nLevelReportInfo`
`protected int`	`nLevelReportParsing`
`protected int`	`nReportLevel` The current report level.
`private ZbnfParserStore`	`parserStoreTopLevel` The actual parse result buffer.
`protected long`	`posRightestError` The position of the most right parse fault.
`protected ZbnfParser.PrescriptParser`	`prescriptParserTopLevel`
`protected LogMessage`	`report` To LogMessage something.
`(package private) java.lang.String`	`sCommentStringEnd` The end of a comment string, it shoult be set if sCommentStringStart is not null.
`(package private) java.lang.String`	`sCommentStringStart` The start of a comment string, if null than no comment is known.
`private static java.lang.String`	`sEmpty` Helpfull empty string to build some spaces in strings.
`(package private) java.lang.String`	`sEndlineCommentStringStart` The start of a comment string, if null than no comment is known.
`protected java.lang.String`	`sExpectedSyntax` Required syntax on rightest parsing error position
`protected java.lang.String`	`sFileError` The file or name of the `StringPart.getInputfile()` which was parsed on the rightest error position.
`protected java.lang.String`	`sInputEncoding` If the syntax prescript contains `$inputEncoding="...".`
`protected java.lang.String`	`sInputEncodingKeyword` If the syntax prescript contains `$inputEncodingKeyword="...".`
`(package private) java.lang.String`	`sInputMostRightError`
`protected java.lang.CharSequence`	`sRightestError` The string and position found on the rightest position of an parse fault.
`static java.lang.String`	`sVersion` Version, history and license.
`(package private) java.lang.String`	`sWhiteSpaces` Chars there are detect as white spaces:
`(package private) java.util.TreeMap<java.lang.String,java.lang.String>`	`xmlnsList` xmlns
`protected java.lang.String`	`xxxsFoundedSyntax` founded syntax on rightest parsing error position

Constructor Summary

Constructors
Constructor and Description
`ZbnfParser(LogMessage report)` Creates a empty parser instance.
`ZbnfParser(LogMessage report, int maxParseResultEntriesOnError)` Creates a empty parser instance.
`ZbnfParser(LogMessage report, ZbnfParser.Args args)` Creates a empty parser instance.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`java.lang.StringBuilder`	`buildFoundedInputOnError()` Returns about 50 chars of the input string founded at the parsing error position.
`void`	`clean()` Cleans used memory after evaluation of the parse result.
`java.lang.String`	`getExpectedSyntaxOnError()` Returns the expected syntax on error position.
`ZbnfParseResultItem`	`getFirstParseResult()` Returns the first parse result item to start stepping to the results.
`java.lang.String`	`getFoundedInputOnError()` Invokes `buildFoundedInputOnError()` with String as return value.
`int`	`getInputColumnOnError()`
`java.nio.charset.Charset`	`getInputEncoding()` Returns the setting of `$inputEncoding="...".`
`java.lang.String`	`getInputEncodingKeyword()` Returns the setting of `$inputEncodingKeyword="...".`
`java.lang.String`	`getInputFileOnError()`
`int`	`getInputLineOnError()`
`long`	`getInputPositionOnError()` Returns the position of error in input string.
`java.lang.String`	`getLastFoundedResultOnError()` Returns the up to now founded result on error position.
`TreeNode_ifc<XmlNodeSimple<ZbnfParseResultItem>,ZbnfParseResultItem>`	`getResultNode()`
`XmlNode`	`getResultTree()` Returns the XML-like result tree.
`java.lang.String`	`getRightestInputOnError()`
`java.lang.String`	`getSyntaxErrorReport()` assembles a string with a user readable syntax error message.
`java.util.TreeMap<java.lang.String,java.lang.String>`	`getXmlnsFromSyntaxPrescript()` Returns a TreeMap of all xmlns keys and strings.
`private void`	`importScript(java.lang.String sFile, java.lang.String sDirParent)`
`(package private) static java.lang.CharSequence`	`inputCurrent(StringPartScan input)`
`ZbnfSyntaxPrescript`	`mainScript()`
`boolean`	`parse(java.lang.String input)` Parses a given Input and produces a parse result.
`boolean`	`parse(StringPartScan input)` parses a given Input and produces a parse result.
`boolean`	`parse(StringPartScan input, java.util.List<java.lang.String> additionalInfo)` parses a given Input, see [`parse(StringPart)`, but write additional semantic informations into the first parse result (into the top level component).
`boolean`	`parseFile(java.io.File fInput)` Parses a given file with standard encoding, produces a parse result.
`boolean`	`parseFile(java.io.File fInput, int maxBuffer, java.lang.String sEncodingDetect, java.nio.charset.Charset charset)` Parses a given file with standard encoding, produces a parse result.
`boolean`	`parseFileFromJar(java.lang.Class<?> clazz, java.lang.String pathInJarFromClazz, int maxSize)` Parsed a content which is stored as resource in a jar file.
`void`	`reportStore(LogMessage report)` Reports the whole content of the parse result in the LogMessage.fineInfo-level.
`void`	`reportStore(LogMessage report, int reportLevel)`
`void`	`reportStore(LogMessage report, int reportLevel, java.lang.String sTitle)` Reports the whole content of the parse result.
`private int`	`reportStoreComponent(ZbnfParseResultItem parseResultItem, LogMessage report, int level, ZbnfParseResultItem parent, int reportLevel)` Inner method to report the content of the parse result
`void`	`reportSyntax(LogMessage report, int reportLevel)` Reports the syntax.
`protected ZbnfSyntaxPrescript`	`searchSyntaxPrescript(java.lang.String sSyntax)`
`void`	`setDebugPosition(int from, int to, int lineSyntax)` Sets info for debug break, see using of `dbgPosFrom` etc.
`void`	`setLinemode(boolean bTrue)` Sets the line mode or not.
`void`	`setLogComponents(java.lang.Appendable out)` Optional setting to log which syntax components are entered on which input position.
`void`	`setMainSyntax(java.lang.String ident)` Sets another syntax rule as the first entry in the given syntax.
`void`	`setReportIdents(int identError, int identInfo, int identComponent, int identFine)` sets the ident number for report of the progress of parsing.
`void`	`setSkippingComment(java.lang.String sCommentStringStart, java.lang.String sCommentStringEnd, boolean bStoreComment)` Set the mode of skipping comments.
`void`	`setSkippingEndlineComment(java.lang.String sCommentStringStart, boolean bStoreComment)` Set the mode of skipping comments to end of line.
`boolean`	`setStoringConstantSyntax(boolean bStore)` Determines wether or not constant syntax (teminal syntax items or terminal morphes) should also strored in the result buffer.
`void`	`setSyntax(java.lang.CharSequence syntax)` Sets the syntax from given string.
`void`	`setSyntax(java.io.File fileSyntax)`
`void`	`setSyntax(StringPartScan syntax)` Sets the syntax from given String.
`void`	`setSyntax(StringPartScan syntax, java.lang.String sDirImport)` Sets the syntax
`void`	`setSyntaxFile(java.io.File fileSyntax)` Sets the syntax from a file.
`void`	`setSyntaxFromJar(java.lang.Class<?> clazz, java.lang.String pathInJarFromClazz)` Read syntax from a resource (file inside jar archive).
`void`	`setSyntaxString(java.lang.CharSequence syntax)` Sets the syntax from given string.
`void`	`setWhiteSpaces(java.lang.String sWhiteSpaces)` Sets the chars which are recognized as white spaces.
`void`	`setXmlSrcline(boolean bValue)` Sets the mode of output source line and column in XML.
`void`	`setXmlSrctext(boolean bValue)` Sets the mode of output source line and column in XML.
`private void`	`stop()` It's a debug helper.
`java.util.TreeMap<java.lang.String,ZbnfSyntaxPrescript>`	`subPrescripts()` Returns the index of all sub prescripts for checking.
`protected void`	`throwSyntaxErrorException(java.lang.String text)` throws a ParseException with the infos of syntax error from last parsing.
`void`	`writeResultAsTextList(java.lang.Appendable out)`
`void`	`writeSyntaxStruct(java.lang.Appendable out)` Writes the syntax (`setSyntax(StringPartScan, String)` in a simple text file using `ZbnfSyntaxPrescript.toString()` via `ZbnfSyntaxPrescript.writeSyntaxStruct(Appendable, int)` in a recursively iteration.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - sVersion
```
public static final java.lang.String sVersion
```
    Version, history and license.
    - 2022-06-01: clean() to remove temporary stuff.
    - 2022-04-29: Hartmut using ZbnfSyntaxPrescript.EType.kStoreSrc: This seems a good opportunity to store the source to an element or component.
      new ZbnfParser.PrescriptParser.SubParser.posStoreSrc and ZbnfParser.PrescriptParser.SubParser.semanticStoreSrc to save the start position for the source
      In SubParser#parsePrescript(ZbnfSyntaxPrescript, ParseResultItemImplement, boolean, boolean, int): create the element with the given semantic if bOk.
    - 2022-04-29: For syntax components: If written with <component?""semantic ( ZbnfSyntaxPrescript.bStoreAsString is set), then writes the parse result of this component in ZbnfParserStore.ParseResultItemImplement.sInput, now also inside the component. There it is useful to evaluate, used for parsed hex numbers, " 0x000e" is the source, and 14 is the parse result, to less information without knowledge of the source. Used first time for Java2Vhdl translator.
    - 2022-04-28: for parsing numbers: calls StringPartScan.scanDigits(int, int, String, String[]) with destination of source and stores this source string in ZbnfParserStore.ParseResultItemImplement.sInput. It is offered, what to do with it depends on evaluation of the parse result. See change in ZbnfJavaOutput.
    - 2022-02-22: writeSyntaxStruct(Appendable) as a new feature, should be existing from beginning...
    - 2022-02-22: In parse(StringPartScan, List): set nReportLevel to 0, switch off the old report strategy, because the new one with setLogComponents(Appendable) seems to be better. In comparison to =3 30% lesser calculation time.
    - 2022-02-15: bugfix: Calling with ctor ZbnfParser(LogMessage, Args) has not reported "found before:". The size of the ZbnfParser.Args.maxParseResultEntriesOnError was not gotten correctly.
    - 2022-02-12: new setLogComponents(Appendable) new feature tested
    - 2022-02-10: new sInputMostRightError set on any parser non matching as most right. The problem was, the input file was not seen, only its line and column, but this is not reliable at all times.
    - 2022-02-10: SubParser#parseRepetition(ZbnfSyntaxPrescript, ZbnfSyntaxPrescript, ParseResultItemImplement, boolean, int): regard { as type designation of the created parse result, stores in ZbnfSyntaxPrescript.componentSyntax for usage in ZbnfJavaOutput. Not for the parsing process itself used.
    - 2022-02-10: SubParser#parseItem(ZbnfSyntaxPrescript, ParseResultItemImplement, boolean, int) If a component is necessary, search only one time and store in ZbnfSyntaxPrescript.componentSyntax for further usage. It saves time. The reference is also used for ZbnfJavaOutput.
    - 2022-02-10: SubParser#addResultOrSubsyntax(CharSequence, long, int, int, String, String, ParseResultItemImplement, ZbnfSyntaxPrescript)
      now uses the whole syntaxElement as reference. Used for storing in ZbnfParserStore.ParseResultItemImplement.
      searches a sub syntax only one time and stores it.
    - 2022-02-08: SubParser#parseRepetition(ZbnfSyntaxPrescript, ZbnfSyntaxPrescript, ParseResultItemImplement, boolean, int) now can create a result item for the whole repetition inclusively backward items. This is necessary for a proper evaluation. It is written in form { (supertype is optional). The * means, 'more' or 'all' in the curly braces, also the backward path.
    - % writeResultAsTextList(Appendable) calls feature in ZbnfParserStore.writeContentAsList(Appendable)
    - 2022-02-07: regard ZbnfSyntaxPrescript.EType.kOnlyMarker, ignore this item.
    - 2020-02-02: new setSyntaxFromJar(Class, String) and parseFileFromJar(Class, String, int)
    - 2020-01-16: <?%> is possible as marker in syntax to force debug stop on ZbnfSyntaxPrescript.bDebugParsing, hence it is more simple to test a Zbnf script.
    - 2019-12-09: new: The Usage of already parsed content was prepared in about 2013 but not used till now. Now it is completed, tested and used. But the test overall is owing. Therefore this feature is activted only if ZbnfParser.Args.bUseResultlet is set, default is false.
    - 2019-12-09: new possible ZbnfParser(LogMessage, Args) new ZbnfParser.Args.bUseResultlet
    - 2019-12-09: chg: The XML tree is only built if getResultNode() is called, not unnecessarily in any case. The algorithm for reusing already parsed results does not use the XML tree.
    - 2019-10-10: new setSyntax(CharSequence) formally with CharSequence instead String, more common useable, especially from new FileFunctions.readInJar(Class, String, String)
    - 2019-10-10: new setMainSyntax(String) not only the first entry can be the the main rule. Used to parse inner Syntax in XML (for IEC 61499).
    - 2019-07-07: Some debug possibilities moved or commented.
    - 2019-07-06 Hartmut bugfix: conspicuously on JTtxtcmd-Script some indents where missing (Reflection Generation). The cause was the missing .indent=-3-attribute. The primary error was using the faulty ZbnfSyntaxPrescript instance to store the parse result in parseSub(...). Because of change in 2019-05 accidentally or experimentally the current used prescript are used for the parse result instead the calling prescript item. It is now tested with GenZbnfJavaData and FBCL, that it is not comprehensible for necessity. The parentSyntaxItem (calling level) contains the correct semantic (often same as current syntax prescript but not in any case) and especially for JZtxtcmd indent on texts the attribute for indent, or some more information.
    - 2019-06-29 Hartmut bugfix: If <syntax?"!"textSemantic> is used, the stored text has contained skipped comment and spaces. Often only spaces were contained in the parse result, so trim() was a workarround. But comments are contained too, that is not proper. Yet the order of checking white spaces inclusively parse ZbnfSyntaxPrescript.EType.kTerminalSymbolInComment is moved before checking some nested syntax to set the posInput (local variable).
    - 2019-05-29 Hartmut changes for correctly processing <...?"!"@>, The semantic=="@" should be used to get the semantic from the syntaxComponent. To do it it is explicitly programmed before calling of PrescriptParser.SubParser#parseSub(ZbnfSyntaxPrescript, String, int, ZbnfSyntaxPrescript, String, ParseResultItemImplement, boolean, ZbnfParserStore) Some gardening in arguments.
    - 2019-05-25 Hartmut new possibilities of parsing number: <#8 for any radix, separatorChars in number.
    - 2019-05-22 Hartmut new syntaxItem.bStoreAsString first test success, not ready.
    - 2019-05-22 Hartmut improved: Storing parse result with [<?result>... It was faulty in some cases in comparison with ZBNF/testAllConcepts - test. The result should be stored as ZbnfParserStore.ParseResultItemImplement.parsedString and not as sInput. See changes in ZbnfParserStore.ParseResultItemImplement.getText(). It should not be stored if a result string is set already with {<?semantic=> ... for an empty element per repetition, for example.
      Storing parsed Input on Component: It was done in any case but selten used. It needs memory space. Now the parsed input is only stored if new instance args ZbnfParser.Args.bStoreInputForComponent is true. it can be set either immediately in a JZtxtcmd Script or with public access, or ZbnfParser.Args should be used in a command line environment and set via ctor (TODO)
    - 2019-03-20 Hartmut new: #dbgPosFrom etc setDebugPosition(int, int, int) for low level source debugging (Eclipse) on special problems.
    - 2018-09-09 Hartmut only formalistic: instead int kSyntaxDefinition etc. now ZbnfSyntaxPrescript.EType as enum. It is not a functional change
    - 2017-08-27 Hartmut new: getResultNode(). To evaluate the result with JZtxtcmd immediately without interim store.
    - 2017-03-25 Hartmut new: The ZbnfSyntaxPrescript syntax item is stored in the ZbnfParserStore.ParseResultItemImplement.
    - 2017-03-25 Hartmut chg: The line and column of a component parse result is stored immediately. See parseSub(...). The change from 2015-06-07: ZbnfParser.PrescriptParser.srcLineOption is never used now. The idea in 2015 was: supply position for text indentation though the < subtext> item was written after a <:> (JZcmd, jzTc), the position of the options may be usefully. But that is a non-simple coherence. Now the position of a syntax item in the parsed text is written immediately in the parse result. The correction of the indentation is defined by an attribute in the syntax. See JZtxtcmdSyntax element \\<:\\>< textExpr?.indent=-3>
    - 2017-01-07 Hartmut bugfix: missing StringPartScan.scanStart() in ZbnfParser.PrescriptParser.SubParser.parseTerminalSymbol(ZbnfSyntaxPrescript, org.vishia.zbnf.ZbnfParserStore.ParseResultItemImplement). In follow of that an error in the terminal text shows an faulty position (the position from any scanStart() before). An syntax error in the parsed text was not shown with the exact position.
    - 2016-12-02 Hartmut new: The syntax element \W in the syntax script is considered via the StringFunction capability already: check whether a terminal string ends with a non-identifier character. Check in StringPartScan.scan(text)
    - 2015-12-29 Hartmut new: Possibility for debug: Write <...?%...> in Syntax, then ZbnfSyntaxPrescript.bDebugParsing is set for this item. It can be tested here to set a specific debug breakpoint for parsing this element. Only for special debugging problems.
    - 2015-07-04 Hartmut bugfix of change on 2015-06-14: It should check kTerminalSymbolInComment if such an symbol is parsed inside a part with <$NoWhiteSpaces>
    - 2015-06-14 Hartmut chg: Writes the start of option parsing in log, "Opti" on level 5. Writes the recursion depths in log. Note: The level nLevelReportParsing respectively all source parts "report.report..." outside of ZbnfParser.LogParsing should be removed. They are not reviewed, the usage of ZbnfParser.LogParsing is better.
    - 2015-06-14 Hartmut new: distinguishs between ZbnfSyntaxPrescript#kTerminalSymbolInComment and ZbnfSyntaxPrescript#kTerminalSymbol.
    - 2015-06-07 Hartmut chg: ZbnfParser.PrescriptParser.srcLineOption etc. created and filled. If given it is the src position for a component.
    - 2015-06-07 Hartmut chg: Improved setting line, column and position in parse result items.
    - 2015-06-06 Hartmut chg: Showing components in logfile now from left to right root to special, may be better to read.
    - 2015-06-06 Hartmut chg: showing position in String on error additional to line and column, need for error analyzing.
    - 2015-06-06 Hartmut chg: SubParser#parseSub(ZbnfSyntaxPrescript, String, int, String, boolean, ZbnfParserStore) gets the syntaxPrescript as argument, not a instance variable. Therewith it is not necessary to have an own instance for parsing some alternative options. Because that is the most frequently parse task, it should save calculation time to do so. Furthermore ZbnfSyntaxPrescript#kAlternativeOptionCheckEmptyFirst is handled in the core parser routine in SubParser#parseSub(ZbnfSyntaxPrescript, String, int, String, boolean, ZbnfParserStore) respectively in the new sub routine in parseSub(...) SubParser#parsePrescript(List, boolean). SubParser#idxPrescript not as instance variable but as stack local variable.
    - 2015-06-04 Hartmut chg: Sets line and column of a component from the first read item insert the component, after whiltespaces. That is important for JZcmd to detect the indent position of texts.
    - 2014-12-14 Hartmut chg: Now returns the line and column and the name of the input file on error if that information are available. There are available for a StringPartFromFileLines which is used usual as input for the parser. Changed routines: getSyntaxErrorReport(), getFoundedInputOnError(), new: buildFoundedInputOnError().
    - 2014-06-17 Hartmut new: setXmlSrcline(boolean) and setXmlSrctext(boolean) to control whether srcline="xx" and srctext="text" will be written to a XML output
    - 2014-05-23 Hartmut chg: use StringPart.getLineAndColumn(int[]) instead getLineCt() and StringPart.getCurrentColumn() because it is faster.
    - 2014-05-22 Hartmut new: Save srcFile in ZbnfParserStore.ParseResultItemImplement.sFile, for information in written results, especially with ZbnfJavaOutput.
    - 2014-03-21 Hartmut new: setSyntaxFile(File) and #setSyntaxString(String) for ambiguous names called from a JZcmd script.
    - 2014-03-21 Hartmut bugfix: Parsing kStringUntilEndStringWithIndent and regular expression: There was a check 'if(sSemanticForStoring != null)' before calling addResultOrSubsyntax(...), therefore <*{ * }|* /?!test_description> has not write the result of the sub syntax. It is not correct. Originally there was set sSrc and addResultOrSubsyntax(...) was invoked if(sSrc !=null). That code is reconstructed again.
    - 2014-01-23 Hartmut chg: SubParser#parseSub(StringPartScan, String, int, String, boolean, ZbnfParserStore): Whitespaces skipped before parserStoreInPrescript.addAlternative(...) is called because the position in input should be stored in the alternative ParseResultItem after the whitespaces. Especially the correct line should be noted.
    - 2014-01-23 Hartmut chg: SubParser#parseWhiteSpaceAndCommentOrTerminalSymbol(String, ZbnfParserStore): the parseResult argument is used only if sConstantSyntax is not null. Changed consequently. Now it is possible to invoke this routine with parseWhiteSpaceAndCommentOrTerminalSymbol(null, null) to only skip white spaces and comments. Therefore ZbnfParser.PrescriptParser.SubParser.parseWhiteSpaceAndComment() is possible without the 'parseResult' argument.
    - 2014-01-23 Hartmut bugfix: The <*{ }> for indented lines does not work. Testing and fixing.
    - 2014-01-01 Hartmut new: Line number transfer to parse result items. Idea TODO: transfer the line numbers only on finish of parsing, store position in input file while parsing: There are some more items stored in the parse process than remain on finish. Getting line numbers form org.vishia.util.StringPartFromFileLines#getLineAndColumn(column) is a binary search process of association position to line numbers. It should only be done on end only for the remaining parse result items. Time measurement: Parsing of about 30 Headerfiles with line numbers: 15 seconds, without line numbers: 14 second.
    - 2013-12-06 Hartmut nice fix: trim spaces in $comment and $endlineComment. A user may write white spaces, it didn't recognize comments. Now white spaces are admissable.
    - 2013-09-02 Hartmut TODO forex "[{ = }] cmd " saves the ZbnfParser.PrescriptParser.parseResultToOtherComponent of "assign" because that SubParser#parse_Component(StringPartScan, int, String, String, boolean, boolean, boolean) is ok. But the outer level "{ ... = }" fails because the "=" is not present. In this case the ZbnfParser.PrescriptParser.parseResultToOtherComponent should be removed if it comes from an inner SubParser which is not used. The solution should be: The parseResultToOtherComponent should be an attribute of ZbnfParser.PrescriptParser.SubParser instead the ZbnfParser.PrescriptParser, the ZbnfParser.PrescriptParser should know it via a List and all levels of SubParser should have a List for its own or inner Result items for other component. If a SubParser's syntax does not match, all ParserStores, inclusive the inner ones, can and should be removed.
    - 2013-02-26 Hartmut bugfix: PrescriptParser#parsePrescript1(String, ZbnfParseResultItem, ZbnfParserStore, ZbnfParserStore, boolean, int) while storing ParseResultlet#xmlResult in alreadyParsedCmpn: If the result is empty, the resultlet should be stored with an xmlResult=null (nothing was created), but the syntax is ok. There are some syntax checks without result possible.
    - 2013-02-12 Hartmut chg: getResultTree() returns now the interface reference XmlNode instead the implementation instance reference XmlNodeSimple. The implementation is the same. All references are adapted, especially ParseResultlet#xmlResult
    - 2013-01-18 Hartmut chg, new: Log-output improved. New inner class ZbnfParser.LogParsing.
    - 2013-01-04 Hartmut new alreadyParsedCmpn. It may be speed up the parsing process but only if the same component is requested at the same position inside another component. It is not used yet. Todo: position of text for 2012-11-02 Hartmut new local class ZbnfParser.ParseResultlet, the ZbnfParser.PrescriptParser contains a reference to it. The resultlet is the first action to save gotten parse results though the result is not convenient in the current context. This result may be re-used later in another context (not programmed yet, only prepared). In that context any component's result is converted to an XML tree presentation. This may be the new strategy for parse result storing.
    - 2012-10-23 Hartmut Supports <* |endstring: The parse result is trimmed without leading and trailing white spaces.
    - 2011-10-10 Hartmut bugfix: scanFloatNumber(true). The parser had an exception because more as 5 floats are parsed and not gotten calling StringPartScan.getLastScannedFloatNumber().
    - 2011-01-09 Hartmut corr: Improvement of report of parsing: Not the report level nLevelReportBranchParsing (set with LogMessage.debug usualy) writes any branch of parsing with ok or error. In that way the working of the parser in respect to the syntax prescript is able to view. It is if some uncertainty about the correctness of the given syntax is in question.
    - 2011-01-09 Creation of this variable to show the changes in the javadoc.
    - 2010-05-04 Hartmut: corr: sEndlineCommentStringStart: The \n is not included, it will be skipped either as whitespace or it is necessary for the linemode.
    - 2009-12-30 Hartmut: corr: Output info: subParserTopLevel == null, no syntax is now removed.
    - 2009-08-02 Hartmut: new: parsing with subSyntax now also available in options writing [ ...].
    - 2009-08-02 Hartmut: new: parseExpectedVariant writing [!...] now available. It tests but doesn't processed the content.
    - 2009-08-02 Hartmut: new: $Whitespaces= now accepted (it was declared in documentation but not implement).
    - 2009-05-31 Hartmut: corr: some changes of report and error output: In both cases the syntax path is written from inner to root, separated with a +. In reportlevel 5 (nLevelReportComponentParsing) also the success of parsing terminal symbols are reported, in the same line after 'ok/error Component'. The reporting of parsing process should be improved furthermore.
    - 2009-01-16 Hartmut: new: ZbnfSyntaxPrescript.kFloatWithFactor: Writing <#f*Factor?...> is working now.. corr: Some non-active code parts deleted. corr: Processing of parse(... additionalInfo) corrected. It was the only one position, where setparseResultsFromOuterLevels() was used. But more simple is: chg: pass of ParseResult to components is simplified, in the kind like programmed in 2007. The pass of parse-Results through some components in deeper levels ins't able now, but that feature causes falsity by using.
    - 2008-03-28 JcHartmut: The ParserStore is not cleared, only the reference is assigned new. So outside the ParserStore can be used from an older parsing.
    - 2006-12-15 JcHartmut: regular expressions should be handled after white spaces trimming, error correction.
    - 2006-06-00 JcHartmut: a lot of simple problems in developemnt.
    - 2006-05-00 JcHartmut: creation
    See Also: Constant Field Values
  sEmpty private static final java.lang.String sEmpty Helpfull empty string to build some spaces in strings. See Also: Constant Field Values args public final ZbnfParser.Args args mXmlSrcline_xmlWrmode static final int mXmlSrcline_xmlWrmode See Also: Constant Field Values mXmlSrctext_xmlWrmode static final int mXmlSrctext_xmlWrmode See Also: Constant Field Values dbgPosFrom int dbgPosFrom dbgPosTo int dbgPosTo dbgLineSyntax int dbgLineSyntax report protected final LogMessage report To LogMessage something. nReportLevel protected int nReportLevel The current report level. This value is used to compare wether the report arguments are prepared or not. The test of the level before calling report(...) saves calculation time. It is set on starting of parse(). nLevelReportParsing protected int nLevelReportParsing nLevelReportComponentParsing protected int nLevelReportComponentParsing nLevelReportInfo protected int nLevelReportInfo nLevelReportError protected int nLevelReportError nLevelReportBranchParsing protected int nLevelReportBranchParsing idReportParsing protected int idReportParsing The ident to report the progress of parsing. idReportComponentParsing protected int idReportComponentParsing idReportBranchParsing protected int idReportBranchParsing idReportInfo protected int idReportInfo idReportError protected int idReportError listSubPrescript protected final java.util.TreeMap<java.lang.String,ZbnfSyntaxPrescript> listSubPrescript The list of some all syntax definitons (syntax components). listKeywords java.util.TreeMap<java.lang.String,java.lang.String> listKeywords Keywords xmlnsList java.util.TreeMap<java.lang.String,java.lang.String> xmlnsList xmlns bConstantSyntaxAsParseResult protected boolean bConstantSyntaxAsParseResult Set if constant syntax (terminate morphems) also should stored. See setStoringConstantSyntax() mainScript private ZbnfSyntaxPrescript mainScript The main syntax prescript set from setSyntax(StringPart). prescriptParserTopLevel protected ZbnfParser.PrescriptParser prescriptParserTopLevel sRightestError protected java.lang.CharSequence sRightestError The string and position found on the rightest position of an parse fault. It is necessary to report a parsing error. sExpectedSyntax protected java.lang.String sExpectedSyntax Required syntax on rightest parsing error position xxxsFoundedSyntax protected java.lang.String xxxsFoundedSyntax founded syntax on rightest parsing error position maxParseResultEntriesOnError private int maxParseResultEntriesOnError Maximum number of shown parsing results on error. log private final ZbnfParser.LogParsing log listParseResultOnError java.util.ArrayList<ZbnfParseResultItem> listParseResultOnError founded content on rightest parsing error position. This list will be filled with current parse result if it is the rightest position. posRightestError protected long posRightestError The position of the most right parse fault. The information will be set newly any time if the parser founds a non matching position more right than the last one. lineError protected int lineError The lineError and columnError will be set if the input supports it, see StringPart.getLineAndColumn(int[]). It is necessary to report a parsing error. columnError protected int columnError The lineError and columnError will be set if the input supports it, see StringPart.getLineAndColumn(int[]). It is necessary to report a parsing error. sInputMostRightError java.lang.String sInputMostRightError sFileError protected java.lang.String sFileError The file or name of the StringPart.getInputfile() which was parsed on the rightest error position. sCommentStringStart java.lang.String sCommentStringStart The start of a comment string, if null than no comment is known. The default value is "/ *" like Java or C. sCommentStringEnd java.lang.String sCommentStringEnd The end of a comment string, it shoult be set if sCommentStringStart is not null. The default value is "* /" like Java or C. bStoreComment boolean bStoreComment If it is true, the comment is stored in the ParserStore and is supplied by calling getFirstParseResult() and from there calling next(). sEndlineCommentStringStart java.lang.String sEndlineCommentStringStart The start of a comment string, if null than no comment is known. sInputEncodingKeyword protected java.lang.String sInputEncodingKeyword If the syntax prescript contains $inputEncodingKeyword="...". this variable is set. The content are not used inside the parser itself, but may be requested outside. sInputEncoding protected java.lang.String sInputEncoding If the syntax prescript contains $inputEncoding="...". this variable is set. The content are not used inside the parser itself, but may be requested outside. bStoreEndlineComment boolean bStoreEndlineComment If it is true, the end-line-comment is stored in the ParserStore and is supplied by calling getFirstParseResult() and from there calling next(). sWhiteSpaces java.lang.String sWhiteSpaces Chars there are detect as white spaces: bStoreNewline boolean bStoreNewline If it is true, a newline is stored in the ParserStore and is supplied by calling getFirstParseResult() and from there calling next(). bStoreOneSpaceOnWhitespaces boolean bStoreOneSpaceOnWhitespaces If it is true, one space is stored on whitespaces in the ParserStore and is supplied by calling getFirstParseResult() and from there calling next(). bStoreWhiteSpaces boolean bStoreWhiteSpaces If it is true, the complete white spaces are stored in the ParserStore and is supplied by calling getFirstParseResult() and from there calling next(). charsetInput private java.nio.charset.Charset charsetInput idxMissingPrescripts protected java.util.Map<java.lang.String,java.lang.String> idxMissingPrescripts parserStoreTopLevel private ZbnfParserStore parserStoreTopLevel The actual parse result buffer. builderTreeNodeXml private final ZbnfParserStore.BuilderTreeNodeXml builderTreeNodeXml alreadyParsedCmpn final java.util.TreeMap<java.lang.String,ZbnfParser.ParseResultlet> alreadyParsedCmpn Already parsed components with the same input text which should be requested in another context. The usage of the already detected parse result speeds up the parsing process. The syntax may be designed with such reused parts especially. The key contains the component syntax name and the position in the input. log1 final ZbnfParser.LogZbnfParser log1
Constructor Detail ZbnfParser public ZbnfParser(LogMessage report) Creates a empty parser instance. Parameters: report - A report output ZbnfParser public ZbnfParser(LogMessage report, int maxParseResultEntriesOnError) Creates a empty parser instance. Parameters: report - A report output maxParseResultEntriesOnError - if 0 than no parse result is stored. If >0, than the last founded parse result is stored to support better analysis of syntax errors, but the parser is slower. ZbnfParser public ZbnfParser(LogMessage report, ZbnfParser.Args args) Creates a empty parser instance. Parameters: report - A report output maxParseResultEntriesOnError - if 0 than no parse result is stored. If >0, than the last founded parse result is stored to support better analysis of syntax errors, but the parser is slower. Method Detail setLogComponents public void setLogComponents(java.lang.Appendable out) Optional setting to log which syntax components are entered on which input position. It is interesting or important if a new syntax definition is created and this have some problems. Timing: additional ~ 10% of the parsing time. TODO the older logging capabilities should be removed. This seems to be sufficient. Parameters: out - Since: 2022-02 setSyntax public void setSyntax(java.lang.CharSequence syntax) throws java.text.ParseException Sets the syntax from given string. Parameters: syntax - The ZBNF-Syntax. Throws: java.text.ParseException setSyntaxString public void setSyntaxString(java.lang.CharSequence syntax) throws java.text.ParseException Sets the syntax from given string. This method should be used in an JZcmd script to distinguish between setSyntax(File) and #setSyntax(String). Parameters: syntax - The ZBNF-Syntax. Throws: java.text.ParseException setSyntaxFile public void setSyntaxFile(java.io.File fileSyntax) throws java.nio.charset.IllegalCharsetNameException, java.nio.charset.UnsupportedCharsetException, java.io.FileNotFoundException, java.io.IOException, java.text.ParseException Sets the syntax from a file. This method should be used in an JZcmd script to distinguish between setSyntax(File) and #setSyntax(String). Parameters: fileSyntax - The file which contains the syntax prescription. Throws: java.nio.charset.IllegalCharsetNameException java.nio.charset.UnsupportedCharsetException java.io.FileNotFoundException java.io.IOException java.text.ParseException setSyntax public void setSyntax(java.io.File fileSyntax) throws java.nio.charset.IllegalCharsetNameException, java.nio.charset.UnsupportedCharsetException, java.io.FileNotFoundException, java.io.IOException, java.text.ParseException Throws: java.nio.charset.IllegalCharsetNameException java.nio.charset.UnsupportedCharsetException java.io.FileNotFoundException java.io.IOException java.text.ParseException setSyntaxFromJar public void setSyntaxFromJar(java.lang.Class<?> clazz, java.lang.String pathInJarFromClazz) throws java.io.IOException, java.nio.charset.IllegalCharsetNameException, java.nio.charset.UnsupportedCharsetException, java.text.ParseException Read syntax from a resource (file inside jar archive). Parameters: clazz - A class in any jar, from there the relative path to the pathInJar is built. Usually the clazz should be the output data clazz. But it is a user decision. pathInJar - relative Path from clazz. Usually the syntax should be in the same directory as the output data class. Then this is only the file name. If the file is stored in a p Throws: java.io.IOException java.text.ParseException java.nio.charset.UnsupportedCharsetException java.nio.charset.IllegalCharsetNameException setSyntax public void setSyntax(StringPartScan syntax) throws java.text.ParseException Sets the syntax from given String. The String should contain the syntax in ZBNF-Format. The string is parsed and converted into a tree of objects of class SyntaxPrescript. The class SyntaxPrescript is private inside the Parser, but its matter of principle may be explained here. The class SyntaxPrescript contains a list of elements (listSyntaxElements) or a list of such listSyntaxElements. The list of listSyntaxElements is used if there are some alternatives. The listSyntaxElements contains objects of type String, SyntaxPrescript, Component or Repetition. It is the sequence of syntax elements of one syntax-path in ZBNF. An object of type String represents a terminal symbol (constant string). An element of SyntaxPrescript is an option construction [...|..|..] or also a simple option [...]. The Repetition represents the {...?...}-construction. A Repetition contains one or two objects of type SyntaxPrescript for the forward and optional backward syntax. This syntax-prescripts may be build complexly in the same way. An object of type Component in the listSyntaxElements represents a construction <...?...>. It may contained the semantic information, it may containded a reference to another SyntaxPrescript if there is required in the wise <syntax.... It is also built if a construction of kind <!regex..., <$..., <#... or such else is given. The tree of SyntaxPrescript is passed by syntax test, the right way is searched, see method parse() Parameters: syntax - The syntax in ZBNF-Format. Throws: java.text.ParseException - If any wrong syntax is containing in the ZBNF-string. A string-wise information of the error location is given. setSyntax public void setSyntax(StringPartScan syntax, java.lang.String sDirImport) throws java.text.ParseException, java.nio.charset.IllegalCharsetNameException, java.nio.charset.UnsupportedCharsetException, java.io.FileNotFoundException, java.io.IOException Sets the syntax Parameters: syntax - The syntax, may be read from any file or from a String, use new StringPart(...) sDirImport - If the syntax contains a $import statement, use this directory as current dir to search the file. Throws: java.text.ParseException java.nio.charset.IllegalCharsetNameException java.nio.charset.UnsupportedCharsetException java.io.FileNotFoundException java.io.IOException setMainSyntax public void setMainSyntax(java.lang.String ident) throws java.text.ParseException Sets another syntax rule as the first entry in the given syntax. This routine should be invoked only with a given syntax, one of the setSyntax(File) routines should be called before. Parameters: ident - syntax rule, ::= Throws: java.text.ParseException writeSyntaxStruct public void writeSyntaxStruct(java.lang.Appendable out) throws java.io.IOException Writes the syntax (setSyntax(StringPartScan, String) in a simple text file using ZbnfSyntaxPrescript.toString() via ZbnfSyntaxPrescript.writeSyntaxStruct(Appendable, int) in a recursively iteration. It is interesting to see. Can be improved for details. This routine organizes the main and all sub syntax components known on parser level. This feature may be proper from beginning. Parameters: out - to a Writer, StringBuilder or what ever. Throws: java.io.IOException - from Appendable.append(char) mainScript public ZbnfSyntaxPrescript mainScript() subPrescripts public java.util.TreeMap<java.lang.String,ZbnfSyntaxPrescript> subPrescripts() Returns the index of all sub prescripts for checking. importScript private void importScript(java.lang.String sFile, java.lang.String sDirParent) throws java.nio.charset.IllegalCharsetNameException, java.nio.charset.UnsupportedCharsetException, java.io.FileNotFoundException, java.io.IOException, java.text.ParseException Throws: java.nio.charset.IllegalCharsetNameException java.nio.charset.UnsupportedCharsetException java.io.FileNotFoundException java.io.IOException java.text.ParseException setDebugPosition public void setDebugPosition(int from, int to, int lineSyntax) Sets info for debug break, see using of dbgPosFrom etc. Parameters: from - The absolute char positon, not the line, it is outputted on error reports to - if the current position is between from and to, the break condition met. lineSyntax - Additional condition: Only if the semantic item on this line is used. It is the definition::= line in the zbnf script. Use 0 if it should be inactive. setSkippingComment public void setSkippingComment(java.lang.String sCommentStringStart, java.lang.String sCommentStringEnd, boolean bStoreComment) Set the mode of skipping comments. It it is set, comments are always skipped on every parse operation. This mode may or should be combinded with setIgnoreWhitespace. Parameters: sCommentStringStart - The start chars of comment string, at example '/ *' sCommentStringEnd - The end chars of comment string, at example '* /' bStoreComment - If it is true, the comment string will be stored in the ParserStrore and can be evaluated from the user. setSkippingEndlineComment public void setSkippingEndlineComment(java.lang.String sCommentStringStart, boolean bStoreComment) Set the mode of skipping comments to end of line. It it is set, comments to end of line are always skipped on every parse operation. This mode may or should be combinded with setIgnoreWhitespace. Parameters: sCommentStringStart - The start chars of comment string to end of line, at example '/ /' bStoreComment - If it is true, the comment string will be stored in the ParserStrore and can be evaluated from the user. setWhiteSpaces public void setWhiteSpaces(java.lang.String sWhiteSpaces) Sets the chars which are recognized as white spaces. The default without calling this method is " \t\r\n\f", that is: space, tab, carrige return, new line, form feed. This mehtod is equal to the using of the syntaxprescript variable $Whitespaces, Parameters: sWhiteSpaces - Chars there are recognize as white space. See Also: setSyntax(String). setLinemode public void setLinemode(boolean bTrue) Sets the line mode or not. The line mode means, a new line character is not recognize as whitespace, it must considered in syntax prescript as a signifying element. This mehtod is equal to the using of the syntaxprescript variable $setLinemode, See Also: setSyntax(String). setXmlSrcline public void setXmlSrcline(boolean bValue) Sets the mode of output source line and column in XML. This method is equal to the using of the syntax-prescript variable $setSrclineInXml, but after invocation of setSyntax(...) the mode can be changed. See Also: setSyntax(String). setXmlSrctext public void setXmlSrctext(boolean bValue) Sets the mode of output source line and column in XML. This method is equal to the using of the syntax-prescript variable $setSrctextInXml, but after invocation of setSyntax(...) the mode can be changed. See Also: setSyntax(String). setReportIdents public void setReportIdents(int identError, int identInfo, int identComponent, int identFine) sets the ident number for report of the progress of parsing. If the idents are >0 and < LogMessage.fineDebug, theay are used directly as report level. Parameters: identError - ident for error and warning outputs. identInfo - ident for progress information output. identComponent - ident for output if a component is parsing identFine - ident for fine parsing outputs. parseFile public boolean parseFile(java.io.File fInput, int maxBuffer, java.lang.String sEncodingDetect, java.nio.charset.Charset charset) throws java.nio.charset.IllegalCharsetNameException, java.nio.charset.UnsupportedCharsetException, java.io.FileNotFoundException, java.io.IOException Parses a given file with standard encoding, produces a parse result. Parameters: fInput - The file to read maxBuffer - The maximum of length of the associated StringBuffer. sEncodingDetect - If not null, this string is searched in the first line, read in US-ASCII or UTF-16-Format. If this string is found, the followed string in quotation marks or as identifier with addition '-' char is read and used as charset name. If the charset name is failed, a CharsetException is thrown. It means, a failed content of file may cause a charset exception. charset - If not null, this charset is used as default, if no other charset is found in the files first line, see param sEncodingDetect. If null and not charset is found in file, the systems default charset is used. Returns: true if successfully parsed, false then use getSyntaxErrorReport() Throws: java.io.FileNotFoundException - If the file is not found java.io.IOException - If any other exception is thrown java.io.IOException java.io.FileNotFoundException java.nio.charset.UnsupportedCharsetException java.nio.charset.IllegalCharsetNameException parseFile public boolean parseFile(java.io.File fInput) throws java.nio.charset.IllegalCharsetNameException, java.nio.charset.UnsupportedCharsetException, java.io.FileNotFoundException, java.io.IOException Parses a given file with standard encoding, produces a parse result. Parameters: fInput - Returns: true if successfully parsed, false then use getSyntaxErrorReport() Throws: java.io.IOException java.io.FileNotFoundException java.nio.charset.UnsupportedCharsetException java.nio.charset.IllegalCharsetNameException parseFileFromJar public boolean parseFileFromJar(java.lang.Class<?> clazz, java.lang.String pathInJarFromClazz, int maxSize) throws java.io.IOException Parsed a content which is stored as resource in a jar file. Parameters: clazz - A class in any jar, from there the relative path to the pathInJar is built. Usually the clazz should be the output data clazz. But it is a user decision. pathInJar - relative Path from clazz. Usually the syntax should be in the same directory as the output data class. Then this is only the file name. If the file is stored in a p Returns: false, then see getExpectedSyntaxOnError() etc. Throws: java.io.IOException parse public boolean parse(java.lang.String input) Parses a given Input and produces a parse result. See parse(StringPartScan). Parameters: input - Returns: parse public boolean parse(StringPartScan input) parses a given Input and produces a parse result. The method setSyntax(vishia.StringScan.StringPart) should be called before. While parsing the pathes in the tree of SyntaxPrescript are tested. If a matching path is found, the method returns true, otherwise false. The result of parsing is stored inside the parser (private internal class ParserStore). To evaluate the parse result see getFirstParseResult(). Parameters: input - The source to be parsed. Returns: true if the input is matched to the syntax, otherwise false. parse public boolean parse(StringPartScan input, java.util.List<java.lang.String> additionalInfo) parses a given Input, see [parse(StringPart), but write additional semantic informations into the first parse result (into the top level component). Parameters: input - The text to parse additionalInfo - Pairs of semantic idents and approriate information content. The elements [0], [2] etc. contains the semantic identifier whereas the elements [1], [3] etc. contains the information content. Returns: true if the input is matched to the syntax, otherwise false. Throws: java.io.IOException searchSyntaxPrescript protected ZbnfSyntaxPrescript searchSyntaxPrescript(java.lang.String sSyntax) reportSyntax public void reportSyntax(LogMessage report, int reportLevel) Reports the syntax. reportStore public void reportStore(LogMessage report, int reportLevel, java.lang.String sTitle) Reports the whole content of the parse result. The report is grouped into components. A component is represented by an own syntax presript, written in the current syntax prescript via <ident...>. A new nested component forces a deeper level. The output is written in the form: parseResult: <?semanticIdent> Component parseResult: <?semanticIdent> ident="foundedString" parseResult: <?semanticIdent> number=foundedNumber parseResult: </?semanticIdent> Component Every line is exactly one entry in the parsers store. Parameters: report - The report output instance reportLevel - level of report. This level is shown in output. If the current valid reportLevel of report is less than this parameter, no action is done. reportStore public void reportStore(LogMessage report, int reportLevel) reportStore public void reportStore(LogMessage report) Reports the whole content of the parse result in the LogMessage.fineInfo-level. Parameters: report - The report output instance. See Also: reportStore(LogMessage report, int reportLevel)}. reportStoreComponent private int reportStoreComponent(ZbnfParseResultItem parseResultItem, LogMessage report, int level, ZbnfParseResultItem parent, int reportLevel) Inner method to report the content of the parse result Parameters: parseResultItem - The first item to report, it is the next item behind componentes first (head-) item, if it is a component. report - The report system. level - Level of nested componentes parent - If not null, the inner items of parent component are reported. Returns: The number of written lines. getInputEncodingKeyword public java.lang.String getInputEncodingKeyword() Returns the setting of $inputEncodingKeyword="...". in the syntax prescript or null it no such entry is given. Returns: getInputEncoding public java.nio.charset.Charset getInputEncoding() Returns the setting of $inputEncoding="...". in the syntax prescript or null it no such entry is given. Returns: getExpectedSyntaxOnError public java.lang.String getExpectedSyntaxOnError() Returns the expected syntax on error position. This position is matched to the report of getFoundenInputOnError(). Because the syntax may be differently, much more as a deterministic string is possible, the returned syntax are only one possibility and don't may be non-ambiguous. It may be only a help to detect the error. It is the same problem as error messages by compilers. Returns: A possible expected syntax. getLastFoundedResultOnError public java.lang.String getLastFoundedResultOnError() Returns the up to now founded result on error position. This position is matched to the report of getFoundenInputOnError() and getExpectedSyntaxOnError(). Returns: A possible founded result or null if this feature is not switched on. buildFoundedInputOnError public java.lang.StringBuilder buildFoundedInputOnError() Returns about 50 chars of the input string founded at the parsing error position. If the error position is the end of file or near them, this string ends with the chars "<< Returns: The part of input on error position. getFoundedInputOnError public java.lang.String getFoundedInputOnError() Invokes buildFoundedInputOnError() with String as return value. If possible use only buildFoundedInputOnError() if a CharSequence is sufficient, which are processed in this time. getInputPositionOnError public long getInputPositionOnError() Returns the position of error in input string. It is the same number as in report. getRightestInputOnError public java.lang.String getRightestInputOnError() getInputLineOnError public int getInputLineOnError() getInputColumnOnError public int getInputColumnOnError() getInputFileOnError public java.lang.String getInputFileOnError() throwSyntaxErrorException protected void throwSyntaxErrorException(java.lang.String text) throws java.text.ParseException throws a ParseException with the infos of syntax error from last parsing. This method is simple callable if a routine should be aborted on syntax error. Inside a string via @see getSyntaxErrorReport() is build. Parameters: text - leading text Throws: java.text.ParseException - immediate. getSyntaxErrorReport public java.lang.String getSyntaxErrorReport() assembles a string with a user readable syntax error message. This method is useable if the user should be inform about the error and the application should be controlled by the users directives. Returns: String with syntax error message. getFirstParseResult public ZbnfParseResultItem getFirstParseResult() Returns the first parse result item to start stepping to the results. See samples at interface ParseResultItem. Returns: The first parse result item. writeResultAsTextList public void writeResultAsTextList(java.lang.Appendable out) throws java.io.IOException Throws: java.io.IOException getResultTree public XmlNode getResultTree() Returns the XML-like result tree. Note that the XmlNodeSimple can be written as XML textfile or converted to a Java-XML-format (TODO) using @org.vishia.xmlSimple.SimpleXmlOutputter getResultNode public TreeNode_ifc<XmlNodeSimple<ZbnfParseResultItem>,ZbnfParseResultItem> getResultNode() getXmlnsFromSyntaxPrescript public java.util.TreeMap<java.lang.String,java.lang.String> getXmlnsFromSyntaxPrescript() Returns a TreeMap of all xmlns keys and strings. This is the result of detecting $xmlns:ns="string". -expressions in the syntax prescript. setStoringConstantSyntax public boolean setStoringConstantSyntax(boolean bStore) Determines wether or not constant syntax (teminal syntax items or terminal morphes) should also strored in the result buffer. Parameters: bStore - true if they should strored, false if not. Returns: The old value of this setting. clean public void clean() Cleans used memory after evaluation of the parse result. stop private void stop() It's a debug helper. The method is empty, but it is a mark to set a breakpoint. inputCurrent static java.lang.CharSequence inputCurrent(StringPartScan input)

Class ZbnfParser

The syntax

White space and comment handling when parsing

Evaluate the parsers result

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

sVersion

sEmpty

args

mXmlSrcline_xmlWrmode

mXmlSrctext_xmlWrmode

dbgPosFrom

dbgPosTo

dbgLineSyntax

report

nReportLevel

nLevelReportParsing

nLevelReportComponentParsing

nLevelReportInfo

nLevelReportError

nLevelReportBranchParsing

idReportParsing

idReportComponentParsing

idReportBranchParsing

idReportInfo

idReportError

listSubPrescript

listKeywords

xmlnsList

bConstantSyntaxAsParseResult

mainScript

prescriptParserTopLevel

sRightestError

sExpectedSyntax

xxxsFoundedSyntax

maxParseResultEntriesOnError

log

listParseResultOnError

posRightestError

lineError

columnError

sInputMostRightError

sFileError

sCommentStringStart

sCommentStringEnd

bStoreComment

sEndlineCommentStringStart

sInputEncodingKeyword

sInputEncoding

bStoreEndlineComment

sWhiteSpaces

bStoreNewline

bStoreOneSpaceOnWhitespaces

bStoreWhiteSpaces

charsetInput

idxMissingPrescripts

parserStoreTopLevel

builderTreeNodeXml

alreadyParsedCmpn

log1

Constructor Detail

ZbnfParser

ZbnfParser

ZbnfParser

Method Detail

setLogComponents

setSyntax

setSyntaxString

setSyntaxFile

setSyntax

setSyntaxFromJar

setSyntax

setSyntax

setMainSyntax

writeSyntaxStruct

mainScript