def __init__(self, module):
Checker.__init__(self)
self._matchFun = module["matchFun"]
auxdic = module.get('auxdic', {})
self.auxgrammar = {}
for key, value in auxdic.items():
self.auxgrammar[key] = load_checker(value)
def __auxcheck(self, specdict, data):
for key, spec in specdict.items():
value = data.get(key)
if key == "$or" and len(specdict) == 1:
return any([self.__auxcheck(x, data) for x in spec])
elif isinstance(spec, dict) and len(spec) == 1:
operator = list(spec.keys())[0]
operand = list(spec.values())[0]
if operator == "$type":
if not load_checker(operand).check(str(value)):
return False
elif operator == "$or":
if not any([self.__auxcheck({key:x}, data) for x in operand]):
return False
else: #unknown operator
return spec == value
elif isinstance(spec, dict):
if not self.__auxcheck(spec, value):
return False
else:
if spec != value:
return False
return True
def check(self, word):
if not self._matchFun:
from pydsl.Memory.Storage.Loader import load_checker
self._matchFun = load_checker(self.dictionary)
return self._matchFun.check(word)
def check(self, word):
if not self.__checker:
from pydsl.Memory.Storage.Loader import load_checker
self.__checker = load_checker(self.__bnf)
return self.__checker.check(word)
def __init__(self, name, definitionrequirementsdic, boundariesrules):
TerminalSymbol.__init__(self, name, 49, boundariesrules)
self.grammarname = definitionrequirementsdic["grammarname"]
from pydsl.Memory.Storage.Loader import load_grammar, load_checker
grammar = load_grammar(self.grammarname)
self.checker = load_checker(grammar)
def testloadgrammar(self):
#Load a grammar that uses a package (integerOPGrammar), call check
from pydsl.Memory.Storage.Loader import load_checker
grammar = load_checker("integerop")
self.assertTrue(grammar.check("123+3"))
