mirror of
https://github.com/marcin-szczepanski/jFuzzyLogic.git
synced 2024-12-21 09:10:28 +01:00
296 lines
7.7 KiB
Plaintext
296 lines
7.7 KiB
Plaintext
|
/*
|
||
|
|
[The "BSD licence"]
|
||
|
|
Copyright (c) 2005-2006 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.
|
||
|
|
*/
|
||
|
|
|
||
|
|
/** Templates for building ASTs during tree parsing.
|
||
|
|
*
|
||
|
|
* Deal with many combinations. Dimensions are:
|
||
|
|
* Auto build or rewrite
|
||
|
|
* no label, label, list label (label/no-label handled together)
|
||
|
|
* child, root
|
||
|
|
* token, set, rule, wildcard
|
||
|
|
*
|
||
|
|
* Each combination has its own template except that label/no label
|
||
|
|
* is combined into tokenRef, ruleRef, ...
|
||
|
|
*/
|
||
|
|
group ASTTreeParser;
|
||
|
|
|
||
|
|
finishedBacktracking(block) ::= <<
|
||
|
|
<if(backtracking)>
|
||
|
|
if self._state.backtracking == 0:
|
||
|
|
<block>
|
||
|
|
<else>
|
||
|
|
<block>
|
||
|
|
<endif>
|
||
|
|
>>
|
||
|
|
|
||
|
|
/** Add a variable to track last element matched */
|
||
|
|
ruleDeclarations() ::= <<
|
||
|
|
<super.ruleDeclarations()>
|
||
|
|
_first_0 = None
|
||
|
|
_last = None<\n>
|
||
|
|
>>
|
||
|
|
|
||
|
|
/** What to emit when there is no rewrite rule. For auto build
|
||
|
|
* mode, does nothing.
|
||
|
|
*/
|
||
|
|
noRewrite(rewriteBlockLevel, treeLevel) ::= <<
|
||
|
|
<finishedBacktracking({
|
||
|
|
<if(rewriteMode)>
|
||
|
|
retval.tree = _first_0
|
||
|
|
if self._adaptor.getParent(retval.tree) is not None and self._adaptor.isNil(self._adaptor.getParent(retval.tree)):
|
||
|
|
retval.tree = self._adaptor.getParent(retval.tree)
|
||
|
|
<endif>
|
||
|
|
})>
|
||
|
|
>>
|
||
|
|
|
||
|
|
/** match ^(root children) in tree parser; override here to
|
||
|
|
* add tree construction actions.
|
||
|
|
*/
|
||
|
|
tree(root, actionsAfterRoot, children, nullableChildList,
|
||
|
|
enclosingTreeLevel, treeLevel) ::= <<
|
||
|
|
_last = self.input.LT(1)
|
||
|
|
_save_last_<treeLevel> = _last
|
||
|
|
_first_<treeLevel> = None
|
||
|
|
<if(!rewriteMode)>
|
||
|
|
root_<treeLevel> = self._adaptor.nil()<\n>
|
||
|
|
<endif>
|
||
|
|
<root:element()>
|
||
|
|
<if(rewriteMode)>
|
||
|
|
<finishedBacktracking({
|
||
|
|
<if(root.el.rule)>
|
||
|
|
if _first_<enclosingTreeLevel> is None:
|
||
|
|
_first_<enclosingTreeLevel> = <root.el.label>.tree<\n>
|
||
|
|
<else>
|
||
|
|
if _first_<enclosingTreeLevel> is None:
|
||
|
|
_first_<enclosingTreeLevel> = <root.el.label><\n>
|
||
|
|
<endif>
|
||
|
|
})>
|
||
|
|
<endif>
|
||
|
|
<actionsAfterRoot:element()>
|
||
|
|
<if(nullableChildList)>
|
||
|
|
if self.input.LA(1) == DOWN:
|
||
|
|
self.match(self.input, DOWN, None)
|
||
|
|
<children:element()>
|
||
|
|
self.match(self.input, UP, None)
|
||
|
|
|
||
|
|
<else>
|
||
|
|
self.match(self.input, DOWN, None)
|
||
|
|
<children:element()>
|
||
|
|
self.match(self.input, UP, None)<\n>
|
||
|
|
<endif>
|
||
|
|
<if(!rewriteMode)>
|
||
|
|
self._adaptor.addChild(root_<enclosingTreeLevel>, root_<treeLevel>)<\n>
|
||
|
|
<endif>
|
||
|
|
_last = _save_last_<treeLevel>
|
||
|
|
|
||
|
|
>>
|
||
|
|
|
||
|
|
// TOKEN AST STUFF
|
||
|
|
|
||
|
|
/** ID! and output=AST (same as plain tokenRef) 'cept add
|
||
|
|
* setting of _last
|
||
|
|
*/
|
||
|
|
tokenRefBang(token,label,elementIndex) ::= <<
|
||
|
|
_last = self.input.LT(1)
|
||
|
|
<super.tokenRef(...)>
|
||
|
|
>>
|
||
|
|
|
||
|
|
/** ID auto construct */
|
||
|
|
tokenRef(token,label,elementIndex,hetero) ::= <<
|
||
|
|
_last = self.input.LT(1)
|
||
|
|
<super.tokenRef(...)>
|
||
|
|
<if(!rewriteMode)>
|
||
|
|
<finishedBacktracking({
|
||
|
|
<if(hetero)>
|
||
|
|
<label>_tree = <hetero>(<label>)
|
||
|
|
<else>
|
||
|
|
<label>_tree = self._adaptor.dupNode(<label>)
|
||
|
|
<endif><\n>
|
||
|
|
self._adaptor.addChild(root_<treeLevel>, <label>_tree)
|
||
|
|
})>
|
||
|
|
<else> <! rewrite mode !>
|
||
|
|
<finishedBacktracking({
|
||
|
|
if _first_<treeLevel> is None:
|
||
|
|
_first_<treeLevel> = <label><\n>
|
||
|
|
})>
|
||
|
|
<endif>
|
||
|
|
>>
|
||
|
|
|
||
|
|
/** label+=TOKEN auto construct */
|
||
|
|
tokenRefAndListLabel(token,label,elementIndex,hetero) ::= <<
|
||
|
|
<tokenRef(...)>
|
||
|
|
<listLabel(elem=label,...)>
|
||
|
|
>>
|
||
|
|
|
||
|
|
/** ^(ID ...) auto construct */
|
||
|
|
tokenRefRuleRoot(token,label,elementIndex,hetero) ::= <<
|
||
|
|
_last = self.input.LT(1)
|
||
|
|
<super.tokenRef(...)>
|
||
|
|
<if(!rewriteMode)>
|
||
|
|
<finishedBacktracking({
|
||
|
|
<if(hetero)>
|
||
|
|
<label>_tree = <hetero>(<label>)
|
||
|
|
<else>
|
||
|
|
<label>_tree = self._adaptor.dupNode(<label>)
|
||
|
|
<endif><\n>
|
||
|
|
root_<treeLevel> = self._adaptor.becomeRoot(<label>_tree, root_<treeLevel>)
|
||
|
|
})>
|
||
|
|
<endif>
|
||
|
|
>>
|
||
|
|
|
||
|
|
/** Match ^(label+=TOKEN ...) auto construct */
|
||
|
|
tokenRefRuleRootAndListLabel(token,label,elementIndex,hetero) ::= <<
|
||
|
|
<tokenRefRuleRoot(...)>
|
||
|
|
<listLabel(elem=label,...)>
|
||
|
|
>>
|
||
|
|
|
||
|
|
// SET AST
|
||
|
|
matchSet(s,label,hetero,elementIndex,postmatchCode) ::= <<
|
||
|
|
_last = self.input.LT(1)
|
||
|
|
<super.matchSet(..., postmatchCode={
|
||
|
|
<if(!rewriteMode)>
|
||
|
|
<finishedBacktracking({
|
||
|
|
<if(hetero)>
|
||
|
|
<label>_tree = <hetero>(<label>)
|
||
|
|
<else>
|
||
|
|
<label>_tree = self._adaptor.dupNode(<label>)
|
||
|
|
<endif><\n>
|
||
|
|
self._adaptor.addChild(root_<treeLevel>, <label>_tree)
|
||
|
|
})>
|
||
|
|
<endif>
|
||
|
|
})>
|
||
|
|
>>
|
||
|
|
|
||
|
|
matchRuleBlockSet(s,label,hetero,elementIndex,postmatchCode,treeLevel="0") ::= <<
|
||
|
|
<matchSet(...)>
|
||
|
|
<noRewrite()> <! set return tree !>
|
||
|
|
>>
|
||
|
|
|
||
|
|
matchSetBang(s,label,elementIndex,postmatchCode) ::= <<
|
||
|
|
_last = self.input.LT(1)
|
||
|
|
<super.matchSet(...)>
|
||
|
|
>>
|
||
|
|
|
||
|
|
matchSetRuleRoot(s,label,hetero,elementIndex,debug) ::= <<
|
||
|
|
<super.matchSet(..., postmatchCode={
|
||
|
|
<if(!rewriteMode)>
|
||
|
|
<finishedBacktracking({
|
||
|
|
<if(hetero)>
|
||
|
|
<label>_tree = <hetero>(<label>)
|
||
|
|
<else>
|
||
|
|
<label>_tree = self._adaptor.dupNode(<label>)
|
||
|
|
<endif><\n>
|
||
|
|
root_<treeLevel> = self._adaptor.becomeRoot(<label>_tree, root_<treeLevel>)
|
||
|
|
})>
|
||
|
|
<endif>
|
||
|
|
})>
|
||
|
|
>>
|
||
|
|
|
||
|
|
// RULE REF AST
|
||
|
|
|
||
|
|
/** rule auto construct */
|
||
|
|
ruleRef(rule,label,elementIndex,args,scope) ::= <<
|
||
|
|
_last = self.input.LT(1)
|
||
|
|
<super.ruleRef(...)>
|
||
|
|
<finishedBacktracking({
|
||
|
|
<if(!rewriteMode)>
|
||
|
|
self._adaptor.addChild(root_<treeLevel>, <label>.tree)
|
||
|
|
<else> <! rewrite mode !>
|
||
|
|
if _first_<treeLevel> is None:
|
||
|
|
_first_<treeLevel> = <label>.tree<\n>
|
||
|
|
<endif>
|
||
|
|
})>
|
||
|
|
>>
|
||
|
|
|
||
|
|
/** x+=rule auto construct */
|
||
|
|
ruleRefAndListLabel(rule,label,elementIndex,args,scope) ::= <<
|
||
|
|
<ruleRef(...)>
|
||
|
|
<listLabel(elem=label+".tree",...)>
|
||
|
|
>>
|
||
|
|
|
||
|
|
/** ^(rule ...) auto construct */
|
||
|
|
ruleRefRuleRoot(rule,label,elementIndex,args,scope) ::= <<
|
||
|
|
_last = self.input.LT(1)
|
||
|
|
<super.ruleRef(...)>
|
||
|
|
<if(!rewriteMode)>
|
||
|
|
<finishedBacktracking({
|
||
|
|
root_<treeLevel> = self._adaptor.becomeRoot(<label>.tree, root_<treeLevel>)
|
||
|
|
})>
|
||
|
|
<endif>
|
||
|
|
>>
|
||
|
|
|
||
|
|
/** ^(x+=rule ...) auto construct */
|
||
|
|
ruleRefRuleRootAndListLabel(rule,label,elementIndex,args,scope) ::= <<
|
||
|
|
<ruleRefRuleRoot(...)>
|
||
|
|
<listLabel(elem=label+".tree",...)>
|
||
|
|
>>
|
||
|
|
|
||
|
|
/** rule when output=AST and tracking for rewrite */
|
||
|
|
ruleRefTrack(rule,label,elementIndex,args,scope) ::= <<
|
||
|
|
_last = self.input.LT(1)
|
||
|
|
<super.ruleRefTrack(...)>
|
||
|
|
>>
|
||
|
|
|
||
|
|
/** x+=rule when output=AST and tracking for rewrite */
|
||
|
|
ruleRefTrackAndListLabel(rule,label,elementIndex,args,scope) ::= <<
|
||
|
|
_last = self.input.LT(1)
|
||
|
|
<super.ruleRefTrackAndListLabel(...)>
|
||
|
|
>>
|
||
|
|
|
||
|
|
/** ^(rule ...) rewrite */
|
||
|
|
ruleRefRuleRootTrack(rule,label,elementIndex,args,scope) ::= <<
|
||
|
|
_last = self.input.LT(1)
|
||
|
|
<super.ruleRefRootTrack(...)>
|
||
|
|
>>
|
||
|
|
|
||
|
|
/** ^(x+=rule ...) rewrite */
|
||
|
|
ruleRefRuleRootTrackAndListLabel(rule,label,elementIndex,args,scope) ::= <<
|
||
|
|
_last = self.input.LT(1)
|
||
|
|
<super.ruleRefRuleRootTrackAndListLabel(...)>
|
||
|
|
>>
|
||
|
|
|
||
|
|
/** Streams for token refs are tree nodes now; override to
|
||
|
|
* change nextToken to nextNode.
|
||
|
|
*/
|
||
|
|
createRewriteNodeFromElement(token,hetero,scope) ::= <<
|
||
|
|
<if(hetero)>
|
||
|
|
<hetero>(stream_<token>.nextNode())
|
||
|
|
<else>
|
||
|
|
stream_<token>.nextNode()
|
||
|
|
<endif>
|
||
|
|
>>
|
||
|
|
|
||
|
|
ruleCleanUp() ::= <<
|
||
|
|
<super.ruleCleanUp()>
|
||
|
|
<if(!rewriteMode)>
|
||
|
|
<finishedBacktracking({
|
||
|
|
retval.tree = self._adaptor.rulePostProcessing(root_0)
|
||
|
|
})>
|
||
|
|
<endif>
|
||
|
|
>>
|