mirror of
https://github.com/marcin-szczepanski/jFuzzyLogic.git
synced 2024-12-19 00:35:29 +01:00
289 lines
9.0 KiB
Plaintext
289 lines
9.0 KiB
Plaintext
/*
|
|
[The "BSD licence"]
|
|
Copyright (c) 2007-2008 Johannes Luber
|
|
Copyright (c) 2005-2007 Kunle Odutola
|
|
Copyright (c) 2005 Terence Parr
|
|
All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions
|
|
are met:
|
|
1. Redistributions of source code must retain the above copyright
|
|
notice, this list of conditions and the following disclaimer.
|
|
2. Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in the
|
|
documentation and/or other materials provided with the distribution.
|
|
3. The name of the author may not be used to endorse or promote products
|
|
derived from this software without specific prior written permission.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
/** Template overrides to add debugging to normal Java output;
|
|
* If ASTs are built, then you'll also get ASTDbg.stg loaded.
|
|
*/
|
|
group Dbg;
|
|
|
|
@outputFile.imports() ::= <<
|
|
<@super.imports()>
|
|
using Antlr.Runtime.Debug;
|
|
using IOException = System.IO.IOException;
|
|
>>
|
|
|
|
@genericParser.members() ::= <<
|
|
<if(grammar.grammarIsRoot)>
|
|
public static readonly string[] ruleNames = new string[] {
|
|
"invalidRule", <grammar.allImportedRules:{rST | "<rST.name>"}; wrap="\n ", separator=", ">
|
|
};<\n>
|
|
<endif>
|
|
<if(grammar.grammarIsRoot)> <! grammar imports other grammar(s) !>
|
|
private int ruleLevel = 0;
|
|
public int RuleLevel {
|
|
get { return ruleLevel; }
|
|
}
|
|
public void IncRuleLevel() { ruleLevel++; }
|
|
public void DecRuleLevel() { ruleLevel--; }
|
|
<if(profile)>
|
|
<ctorForProfilingRootGrammar()>
|
|
<else>
|
|
<ctorForRootGrammar()>
|
|
<endif>
|
|
<ctorForPredefinedListener()>
|
|
<else> <! imported grammar !>
|
|
public int RuleLevel {
|
|
get { return <grammar.delegators:{g| <g:delegateName()>}>.RuleLevel; }
|
|
}
|
|
public void IncRuleLevel() { <grammar.delegators:{g| <g:delegateName()>}>.IncRuleLevel(); }
|
|
public void DecRuleLevel() { <grammar.delegators:{g| <g:delegateName()>}>.DecRuleLevel(); }
|
|
<ctorForDelegateGrammar()>
|
|
<endif>
|
|
<if(profile)>
|
|
override public bool AlreadyParsedRule(IIntStream input, int ruleIndex)
|
|
{
|
|
((Profiler)dbg).ExamineRuleMemoization(input, ruleIndex, <grammar.composite.rootGrammar.recognizerName>.ruleNames[ruleIndex]);
|
|
return base.AlreadyParsedRule(input, ruleIndex);
|
|
}<\n>
|
|
override public void Memoize(IIntStream input,
|
|
int ruleIndex,
|
|
int ruleStartIndex)
|
|
{
|
|
((Profiler)dbg).Memoize(input, ruleIndex, ruleStartIndex, <grammar.composite.rootGrammar.recognizerName>.ruleNames[ruleIndex]);
|
|
base.Memoize(input, ruleIndex, ruleStartIndex);
|
|
}<\n>
|
|
<endif>
|
|
protected bool EvalPredicate(bool result, string predicate)
|
|
{
|
|
dbg.SemanticPredicate(result, predicate);
|
|
return result;
|
|
}<\n>
|
|
>>
|
|
|
|
ctorForRootGrammar() ::= <<
|
|
<! bug: can't use <@super.members()> cut-n-paste instead !>
|
|
<! Same except we add port number and profile stuff if root grammar !>
|
|
public <name>(<inputStreamType> input)
|
|
: this(input, DebugEventSocketProxy.DEFAULT_DEBUGGER_PORT, new RecognizerSharedState()) {
|
|
}
|
|
|
|
public <name>(<inputStreamType> input, int port, RecognizerSharedState state)
|
|
: base(input, state) {
|
|
<parserCtorBody()>
|
|
<createListenerAndHandshake()>
|
|
<grammar.directDelegates:{g|<g:delegateName()> = new <g.recognizerName>(input, dbg, this.state, this<grammar.delegators:{g|, <g:delegateName()>}>);}; separator="\n">
|
|
<@finally()>
|
|
}<\n>
|
|
>>
|
|
|
|
ctorForProfilingRootGrammar() ::= <<
|
|
<! bug: can't use <@super.members()> cut-n-paste instead !>
|
|
public <name>(<inputStreamType> input) {
|
|
this(input, new Profiler(null), new RecognizerSharedState());
|
|
}
|
|
|
|
public <name>(<inputStreamType> input, IDebugEventListener dbg, RecognizerSharedState state)
|
|
: base(input, dbg, state) {
|
|
Profiler p = (Profiler)dbg;
|
|
p.setParser(this);
|
|
<parserCtorBody()>
|
|
<grammar.directDelegates:
|
|
{g|<g:delegateName()> = new <g.recognizerName>(input, dbg, this.state, this<grammar.delegators:{g|, <g:delegateName()>}>);}; separator="\n">
|
|
<@finally()>
|
|
}
|
|
<\n>
|
|
>>
|
|
|
|
|
|
/** Basically we don't want to set any dbg listeners are root will have it. */
|
|
ctorForDelegateGrammar() ::= <<
|
|
public <name>(<inputStreamType> input, IDebugEventListener dbg, RecognizerSharedState state<grammar.delegators:{g|, <g.recognizerName> <g:delegateName()>}>)
|
|
: base(input, dbg, state) {
|
|
<parserCtorBody()>
|
|
<grammar.directDelegates:
|
|
{g|<g:delegateName()> = new <g.recognizerName>(input, this, this.state<grammar.delegators:{g|, <g:delegateName()>}>);}; separator="\n">
|
|
}<\n>
|
|
>>
|
|
|
|
ctorForPredefinedListener() ::= <<
|
|
public <name>(<inputStreamType> input, IDebugEventListener dbg)
|
|
: <@superClassRef>base(input, dbg, new RecognizerSharedState())<@end> {
|
|
<if(profile)>
|
|
Profiler p = (Profiler)dbg;
|
|
p.setParser(this);
|
|
<endif>
|
|
<parserCtorBody()>
|
|
<grammar.directDelegates:{g|<g:delegateName()> = new <g.recognizerName>(input, dbg, this.state, this<grammar.delegators:{g|, <g:delegateName()>}>);}; separator="\n">
|
|
<@finally()>
|
|
}<\n>
|
|
>>
|
|
|
|
createListenerAndHandshake() ::= <<
|
|
<if(TREE_PARSER)>
|
|
DebugEventSocketProxy proxy = new DebugEventSocketProxy(this, port, input.TreeAdaptor);
|
|
<else>
|
|
DebugEventSocketProxy proxy = new DebugEventSocketProxy(this, port, null);
|
|
<endif>
|
|
DebugListener = proxy;
|
|
try
|
|
{
|
|
proxy.Handshake();
|
|
}
|
|
catch (IOException ioe)
|
|
{
|
|
ReportError(ioe);
|
|
}
|
|
>>
|
|
|
|
@genericParser.superClassName() ::= "Debug<@super.superClassName()>"
|
|
|
|
@rule.preamble() ::= <<
|
|
try {
|
|
dbg.EnterRule(GrammarFileName, "<ruleName>");
|
|
if ( RuleLevel==0 ) {dbg.Commence();}
|
|
IncRuleLevel();
|
|
dbg.Location(<ruleDescriptor.tree.line>, <ruleDescriptor.tree.column>);<\n>
|
|
>>
|
|
|
|
@lexer.debugAddition() ::= ", dbg"
|
|
|
|
@rule.postamble() ::= <<
|
|
dbg.Location(<ruleDescriptor.EORNode.line>, <ruleDescriptor.EORNode.column>);<\n>
|
|
}
|
|
finally {
|
|
dbg.ExitRule(GrammarFileName, "<ruleName>");
|
|
DecRuleLevel();
|
|
if ( RuleLevel==0 ) {dbg.Terminate();}
|
|
}<\n>
|
|
>>
|
|
|
|
@synpred.start() ::= "dbg.BeginBacktrack(state.backtracking);"
|
|
|
|
@synpred.stop() ::= "dbg.EndBacktrack(state.backtracking, success);"
|
|
|
|
// Common debug event triggers used by region overrides below
|
|
|
|
enterSubRule() ::=
|
|
"try { dbg.EnterSubRule(<decisionNumber>);<\n>"
|
|
|
|
exitSubRule() ::=
|
|
"} finally { dbg.ExitSubRule(<decisionNumber>); }<\n>"
|
|
|
|
enterDecision() ::=
|
|
"try { dbg.EnterDecision(<decisionNumber>);<\n>"
|
|
|
|
exitDecision() ::=
|
|
"} finally { dbg.ExitDecision(<decisionNumber>); }<\n>"
|
|
|
|
enterAlt(n) ::= "dbg.EnterAlt(<n>);<\n>"
|
|
|
|
// Region overrides that tell various constructs to add debugging triggers
|
|
|
|
@block.predecision() ::= "<enterSubRule()><enterDecision()>"
|
|
|
|
@block.postdecision() ::= "<exitDecision()>"
|
|
|
|
@block.postbranch() ::= "<exitSubRule()>"
|
|
|
|
@ruleBlock.predecision() ::= "<enterDecision()>"
|
|
|
|
@ruleBlock.postdecision() ::= "<exitDecision()>"
|
|
|
|
@ruleBlockSingleAlt.prealt() ::= "<enterAlt(n=\"1\")>"
|
|
|
|
@blockSingleAlt.prealt() ::= "<enterAlt(n=\"1\")>"
|
|
|
|
@positiveClosureBlock.preloop() ::= "<enterSubRule()>"
|
|
|
|
@positiveClosureBlock.postloop() ::= "<exitSubRule()>"
|
|
|
|
@positiveClosureBlock.predecision() ::= "<enterDecision()>"
|
|
|
|
@positiveClosureBlock.postdecision() ::= "<exitDecision()>"
|
|
|
|
@positiveClosureBlock.earlyExitException() ::=
|
|
"dbg.RecognitionException(eee);<\n>"
|
|
|
|
@closureBlock.preloop() ::= "<enterSubRule()>"
|
|
|
|
@closureBlock.postloop() ::= "<exitSubRule()>"
|
|
|
|
@closureBlock.predecision() ::= "<enterDecision()>"
|
|
|
|
@closureBlock.postdecision() ::= "<exitDecision()>"
|
|
|
|
@altSwitchCase.prealt() ::= "<enterAlt(n=i)>"
|
|
|
|
@element.prematch() ::=
|
|
"dbg.Location(<it.line>,<it.pos>);"
|
|
|
|
@matchSet.mismatchedSetException() ::=
|
|
"dbg.RecognitionException(mse);"
|
|
|
|
@dfaState.noViableAltException() ::= "dbg.RecognitionException(nvae_d<decisionNumber>s<stateNumber>);"
|
|
|
|
@dfaStateSwitch.noViableAltException() ::= "dbg.RecognitionException(nvae_d<decisionNumber>s<stateNumber>);"
|
|
|
|
dfaDecision(decisionNumber,description) ::= <<
|
|
try
|
|
{
|
|
isCyclicDecision = true;
|
|
<super.dfaDecision(...)>
|
|
}
|
|
catch (NoViableAltException nvae)
|
|
{
|
|
dbg.RecognitionException(nvae);
|
|
throw nvae;
|
|
}
|
|
>>
|
|
|
|
@cyclicDFA.dbgCtor() ::= <<
|
|
public DFA<dfa.decisionNumber>(BaseRecognizer recognizer, IDebugEventListener dbg) : this(recognizer)
|
|
{
|
|
this.dbg = dbg;
|
|
}
|
|
>>
|
|
|
|
@cyclicDFA.debugMember() ::= <<
|
|
IDebugEventListener dbg;
|
|
|
|
>>
|
|
|
|
@cyclicDFA.errorMethod() ::= <<
|
|
public override void Error(NoViableAltException nvae)
|
|
{
|
|
dbg.RecognitionException(nvae);
|
|
}
|
|
>>
|
|
|
|
/** Force predicate validation to trigger an event */
|
|
evalPredicate(pred,description) ::= <<
|
|
EvalPredicate(<pred>,"<description>")
|
|
>>
|