Source code for lib.CodeDOM

# EMACS settings: -*-	tab-width: 2; indent-tabs-mode: t; python-indent-offset: 2 -*-
# vim: tabstop=2:shiftwidth=2:noexpandtab
# kate: tab-width 2; replace-tabs off; indent-width 2;
#
# ==============================================================================
# Authors:          Patrick Lehmann
#                   Martin Zabel
#
# Python Module:    TODO
#
# License:
# ==============================================================================
# Copyright 2007-2016 Patrick Lehmann - Dresden, Germany
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
#
# load dependencies
from lib.Functions import Init
from lib.Parser    import MismatchingParserResult, MatchingParserResult, EmptyChoiseParserResult, GreedyMatchingParserResult
from lib.Parser    import SpaceToken, CharacterToken, StringToken, NumberToken, Tokenizer


__api__ = [
	'CodeDOMMeta',
	'CodeDOMObject',
	'Expression',
	'UnaryExpression',
	'NotExpression',
	'BinaryExpression',
	'LogicalExpression',
	'CompareExpression',
	'EqualExpression',
	'UnequalExpression',
	'LessThanExpression',
	'LessThanEqualExpression',
	'GreaterThanExpression',
	'GreaterThanEqualExpression',
	'AndExpression',
	'OrExpression',
	'XorExpression',
	'InExpression',
	'NotInExpression',
	'Function',
	'ListElement',
	'Literal',
	'StringLiteral',
	'IntegerLiteral',
	'Identifier',
	'Statement',
	'BlockStatement',
	'ConditionalBlockStatement',
	'EmptyLine',
	'CommentLine',
	'BlockedStatement',
	'ExpressionChoice'
]
__all__ = __api__


DEBUG =   False#True

# ==============================================================================
# Base classes
# ==============================================================================
[docs]class CodeDOMMeta(type):
[docs] def parse(mcls): result = mcls() return result
@staticmethod
[docs] def GetChoiceParser(choices): if DEBUG: print("init ChoiceParser") parsers = [] for choice in choices: parser = choice.GetParser() parser.send(None) tup = (choice, parser) parsers.append(tup) removeList = [] while True: token = yield for parser in parsers: try: parser[1].send(token) except MismatchingParserResult: removeList.append(parser) except MatchingParserResult as ex: if DEBUG: print("ChoiceParser: found a matching choice") raise ex for parser in removeList: if DEBUG: print("deactivating parser for {0}".format(parser[0].__name__)) parsers.remove(parser) removeList.clear() if (len(parsers) == 0): break if DEBUG: print("ChoiceParser: list of choices is empty -> no match found") raise EmptyChoiseParserResult("ChoiceParser: ")
@staticmethod
[docs] def GetRepeatParser(callback, generator): if DEBUG: print("init RepeatParser") parser = generator() parser.send(None) while True: token = yield try: parser.send(token) except EmptyChoiseParserResult: break except MismatchingParserResult: break except MatchingParserResult as ex: if DEBUG: print("RepeatParser: found a statement") callback(ex.value) parser = generator() parser.send(None) if DEBUG: print("RepeatParser: repeat end") raise MatchingParserResult()
[docs]class CodeDOMObject(metaclass=CodeDOMMeta): def __init__(self): super().__init__() @classmethod
[docs] def Parse(cls, string, printChar): parser = cls.GetParser() parser.send(None) try: for token in Tokenizer.GetWordTokenizer(string): if printChar: print("{BLUE}{token!s}{NOCOLOR}".format(token=token, **Init.Foreground)) parser.send(token) # FIXME: print("send empty token") parser.send(None) except MatchingParserResult as ex: return ex.value except MismatchingParserResult as ex: print("ERROR: {0}".format(ex.value))
# print("close root parser") # parser.close() # ============================================================================== # Expressions # ==============================================================================
[docs]class Expression(CodeDOMObject): pass
[docs]class UnaryExpression(Expression): def __init__(self, child): super().__init__() self._child = child @property def Child(self): return self._child
[docs]class NotExpression(UnaryExpression): def __init__(self, child): super().__init__(child) __PARSER_EXPRESSIONS__ = None @classmethod
[docs] def GetParser(cls): if DEBUG: print("init NotExpressionParser") child = None # match for "!" token = yield # if (not isinstance(token, StringToken)): raise MismatchingParserResult() # if (token.Value != "not"): raise MismatchingParserResult() if (not isinstance(token, CharacterToken)): raise MismatchingParserResult() if (token.Value != "!"): raise MismatchingParserResult() # match for optional whitespace token = yield if isinstance(token, SpaceToken): token = yield # match for sub expression # ========================================================================== parser = cls.__PARSER_EXPRESSIONS__.GetParser() parser.send(None) try: while True: parser.send(token) token = yield except MatchingParserResult as ex: child = ex.value # construct result result = cls(child) if DEBUG: print("NotExpressionParser: matched {0}".format(result)) raise MatchingParserResult(result)
def __str__(self): return "not {0}".format(self._child.__str__())
[docs]class BinaryExpression(Expression): def __init__(self, leftChild, rightChild): super().__init__() self._leftChild = leftChild self._rightChild = rightChild @property def LeftChild(self): return self._leftChild @property def RightChild(self): return self._rightChild __PARSER_NAME__ = None __PARSER_LHS_EXPRESSIONS__ = None __PARSER_RHS_EXPRESSIONS__ = None __PARSER_OPERATOR__ = None @classmethod
[docs] def GetParser(cls): if DEBUG: print("init " + cls.__PARSER_NAME__) leftChild = None rightChild = None # match for opening ( token = yield if (not isinstance(token, CharacterToken)): raise MismatchingParserResult() if (token.Value != "("): raise MismatchingParserResult() # match for optional whitespace token = yield if isinstance(token, SpaceToken): token = yield # match for sub expression # ========================================================================== parser = cls.__PARSER_LHS_EXPRESSIONS__.GetParser() parser.send(None) try: while True: parser.send(token) token = yield except GreedyMatchingParserResult as ex: leftChild = ex.value except MatchingParserResult as ex: leftChild = ex.value token = yield # match for optional whitespace if isinstance(token, SpaceToken): token = yield # match for operator keyword or sign(s) if isinstance(cls.__PARSER_OPERATOR__, str): if (not isinstance(token, StringToken)): raise MismatchingParserResult() if (token.Value != cls.__PARSER_OPERATOR__): raise MismatchingParserResult() token = yield if (not isinstance(token, SpaceToken)): raise MismatchingParserResult() token = yield elif isinstance(cls.__PARSER_OPERATOR__, tuple): for sign in cls.__PARSER_OPERATOR__: if (not isinstance(token, CharacterToken)): raise MismatchingParserResult() if (token.Value != sign): raise MismatchingParserResult() token = yield # match for optional whitespace if isinstance(token, SpaceToken): token = yield elif isinstance(cls.__PARSER_OPERATOR__, list): for kw in cls.__PARSER_OPERATOR__[:-1]: if (not isinstance(token, StringToken)): raise MismatchingParserResult() if (token.Value != kw): raise MismatchingParserResult() token = yield if (not isinstance(token, SpaceToken)): raise MismatchingParserResult() token = yield kw = cls.__PARSER_OPERATOR__[-1] if (not isinstance(token, StringToken)): raise MismatchingParserResult() if (token.Value != kw): raise MismatchingParserResult() token = yield if (not isinstance(token, SpaceToken)): raise MismatchingParserResult() token = yield # match for sub expression # ========================================================================== parser = cls.__PARSER_RHS_EXPRESSIONS__.GetParser() parser.send(None) try: while True: parser.send(token) token = yield except GreedyMatchingParserResult as ex: rightChild = ex.value except MatchingParserResult as ex: rightChild = ex.value token = yield # match for optional whitespace if isinstance(token, SpaceToken): token = yield # match for closing ) if (not isinstance(token, CharacterToken)): raise MismatchingParserResult() if (token.Value != ")"): raise MismatchingParserResult() # construct result result = cls(leftChild, rightChild) if DEBUG: print(cls.__PARSER_NAME__ + ": matched {0}".format(result)) raise MatchingParserResult(result)
def __str__(self): if isinstance(self.__PARSER_OPERATOR__, tuple): op = "".join(self.__PARSER_OPERATOR__) elif isinstance(self.__PARSER_OPERATOR__, list): op = " ".join(self.__PARSER_OPERATOR__) else: op = self.__PARSER_OPERATOR__ return "({left!s} {op} {right!s})".format(left=self._leftChild, op=op, right=self._rightChild)
[docs]class LogicalExpression(BinaryExpression): pass
[docs]class CompareExpression(LogicalExpression): pass
[docs]class EqualExpression(CompareExpression): __PARSER_NAME__ = "EqualExpressionParser" __PARSER_OPERATOR__ = ("=",)
[docs]class UnequalExpression(CompareExpression): __PARSER_NAME__ = "UnequalExpressionParser" __PARSER_OPERATOR__ = ("!", "=")
[docs]class LessThanExpression(CompareExpression): __PARSER_NAME__ = "LessThanExpressionParser" __PARSER_OPERATOR__ = ("<",)
[docs]class LessThanEqualExpression(CompareExpression): __PARSER_NAME__ = "LessThanEqualExpressionParser" __PARSER_OPERATOR__ = ("<", "=")
[docs]class GreaterThanExpression(CompareExpression): __PARSER_NAME__ = "GreaterThanExpressionParser" __PARSER_OPERATOR__ = (">",)
[docs]class GreaterThanEqualExpression(CompareExpression): __PARSER_NAME__ = "GreaterThanEqualExpressionParser" __PARSER_OPERATOR__ = (">", "=")
[docs]class AndExpression(LogicalExpression): __PARSER_NAME__ = "AndExpressionParser" __PARSER_OPERATOR__ = "and"
[docs]class OrExpression(LogicalExpression): __PARSER_NAME__ = "OrExpressionParser" __PARSER_OPERATOR__ = "or"
[docs]class XorExpression(LogicalExpression): __PARSER_NAME__ = "XorExpressionParser" __PARSER_OPERATOR__ = "xor"
[docs]class InExpression(LogicalExpression): __PARSER_NAME__ = "InExpressionParser" __PARSER_OPERATOR__ = "in"
[docs]class NotInExpression(LogicalExpression): __PARSER_NAME__ = "NotInExpressionParser" __PARSER_OPERATOR__ = ["not", "in"]
[docs]class Function(Expression): pass
[docs]class ListElement(Expression): def __init__(self): super().__init__() __PARSER_LIST_ELEMENT_EXPRESSIONS__ = None @classmethod
[docs] def GetParser(cls): if DEBUG: print("init ListElementParser") # match for EXISTS keyword token = yield if (not isinstance(token, CharacterToken)): raise MismatchingParserResult() if (token.Value != ","): raise MismatchingParserResult() # match for optional whitespace token = yield if isinstance(token, SpaceToken): token = yield parser = cls.__PARSER_LIST_ELEMENT_EXPRESSIONS__.GetParser() parser.send(None) while True: parser.send(token) token = yield
# ============================================================================== # Literals # ==============================================================================
[docs]class Literal(Expression): pass
[docs]class StringLiteral(Literal): def __init__(self, value): super().__init__() self._value = value @property def Value(self): return self._value @classmethod
[docs] def GetParser(cls): if DEBUG: print("init StringLiteralParser") # match for opening " token = yield if (not isinstance(token, CharacterToken)): raise MismatchingParserResult() if (token.Value != "\""): raise MismatchingParserResult() # match for string: value value = "" wasEscapeSign = False while True: token = yield if isinstance(token, CharacterToken): if (token.Value == "\""): if (wasEscapeSign is True): wasEscapeSign = False value += "\"" continue else: break elif (token.Value == "\\"): if (wasEscapeSign is True): wasEscapeSign = False value += "\\" continue else: wasEscapeSign = True continue value += token.Value # construct result result = cls(value) if DEBUG: print("StringLiteralParser: matched {0}".format(result)) raise MatchingParserResult(result)
def __str__(self): return "\"{0}\"".format(self._value)
[docs]class IntegerLiteral(Literal): def __init__(self, value): super().__init__() self._value = value @property def Value(self): return self._value @classmethod
[docs] def GetParser(cls): if DEBUG: print("init IntegerLiteralParser") # match for opening " token = yield if (not isinstance(token, NumberToken)): raise MismatchingParserResult() value = int(token.Value) # construct result result = cls(value) if DEBUG: print("IntegerLiteralParser: matched {0}".format(result)) raise MatchingParserResult(result)
def __str__(self): return str(self._value)
[docs]class Identifier(Expression): def __init__(self, name): super().__init__() self._name = name @property def Name(self): return self._name @classmethod
[docs] def GetParser(cls): if DEBUG: print("init IdentifierParser") name = "" while True: token = yield if isinstance(token, StringToken): name += token.Value elif isinstance(token, NumberToken): if (name != ""): name += token.Value else: raise MismatchingParserResult("IdentifierParser: Expected identifier name. Got a number.") elif (isinstance(token, CharacterToken) and (token.Value == "_")): name += token.Value elif (name == ""): raise MismatchingParserResult("IdentifierParser: Expected identifier name.") else: break # construct result result = cls(name) if DEBUG: print("IdentifierParser: matched {0}".format(result)) raise GreedyMatchingParserResult(result)
def __str__(self): return self._name
# ============================================================================== # Statements # ==============================================================================
[docs]class Statement(CodeDOMObject): def __init__(self, commentText=""): super().__init__() self._commentText = commentText @property def CommentText(self): return self._commentText @CommentText.setter def CommentText(self, value): self._commentText = value
[docs]class BlockStatement(Statement): def __init__(self, commentText=""): super().__init__(commentText) self._statements = []
[docs] def AddStatement(self, stmt): self._statements.append(stmt)
@property def Statements(self): return self._statements def __str__(self, indent=0): _indent = " " * indent buffer = _indent + "BlockStatement" for stmt in self._statements: buffer += "\n{0}".format(stmt.__str__(indent + 1)) return buffer
[docs]class ConditionalBlockStatement(BlockStatement): def __init__(self, expression, commentText=""): super().__init__(commentText) self._expression = expression @property def Expression(self): return self._expression def __str__(self, indent=0): _indent = " " * indent buffer = _indent + "ConditionalBlockStatement " + self._expression.__str__() for stmt in self._statements: buffer += "\n{0}".format(stmt.__str__(indent + 1)) return buffer
# ============================================================================== # Empty and comment lines # ==============================================================================
[docs]class EmptyLine(CodeDOMObject): def __init__(self): super().__init__() @classmethod
[docs] def GetParser(cls): # match for optional whitespace token = yield if isinstance(token, SpaceToken): token = yield # match for delimiter sign: \n if (not isinstance(token, CharacterToken)): raise MismatchingParserResult() if (token.Value.lower() != "\n"): raise MismatchingParserResult() # construct result result = cls() raise MatchingParserResult(result)
def __str__(self, indent=0): return " " * indent + "<empty>"
[docs]class CommentLine(CodeDOMObject): def __init__(self, commentText): super().__init__() self._commentText = commentText @property def Text(self): return self._commentText @classmethod
[docs] def GetParser(cls): # match for optional whitespace token = yield if isinstance(token, SpaceToken): token = yield # match for sign: # if (not isinstance(token, CharacterToken)): raise MismatchingParserResult() if (token.Value.lower() != "#"): raise MismatchingParserResult() # match for any until line end commentText = "" while True: token = yield if isinstance(token, CharacterToken): if (token.Value == "\n"): break commentText += token.Value # construct result result = cls(commentText) raise MatchingParserResult(result)
def __str__(self, indent=0): return "{0}#{1}".format(" " * indent, self._commentText)
# ============================================================================== # Forward declarations # ==============================================================================
[docs]class BlockedStatement(CodeDOMObject): _allowedStatements = [] @classmethod
[docs] def AddChoice(cls, value): cls._allowedStatements.append(value)
@classmethod
[docs] def GetParser(cls): return cls.GetChoiceParser(cls._allowedStatements)
[docs]class ExpressionChoice(CodeDOMObject): _allowedExpressions = [] @classmethod
[docs] def AddChoice(cls, value): cls._allowedExpressions.append(value)
@classmethod
[docs] def GetParser(cls): return cls.GetChoiceParser(cls._allowedExpressions)