def evaluator(cls, node, environment): left = expressionEvaluator(doAssert=True)(node.left, environment).value right = expressionEvaluator(doAssert=True)(node.right, environment).value supportedTypes = [Type.INTEGER, Type.FLOAT] if not left.type in supportedTypes: raise RuntimeException( f"Operator '{node.operator.value}' is supported only by {[t.name.lower() for t in supportedTypes]} type", node.left.pos) if not right.type in supportedTypes: raise RuntimeException( f"Operator '{node.operator.value}' is supported only by {[t.name.lower() for t in supportedTypes]} type", node.right.pos) if node.operator.value == "*": return getProperTypeProvider(left.value * right.value) if node.operator.value == "/": if right.value == 0: raise RuntimeException("Attempt to divide by 0", node.right.pos) value = left.value / right.value if left.type == right.type == Type.INTEGER and int(value) == value: return Type.integer(int(value)) return getProperTypeProvider(value) raise RuntimeError("This line should never be reached")
def mapEvaluator(cls, node, environment, evaluatedIterator, parameters, filter): output = [] if len(parameters) > 3: raise RuntimeException( f"Loop with map iterator can handle only three parameters", node.parameters.pos) i = 0 for key, value in evaluatedIterator.value.items(): if len(parameters) == 1: environment.scopes[-1][parameters[0]] = value if len(parameters) == 2: environment.scopes[-1][parameters[0]] = key environment.scopes[-1][parameters[1]] = value if len(parameters) == 3: environment.scopes[-1][parameters[0]] = Type.integer(i) environment.scopes[-1][parameters[1]] = key environment.scopes[-1][parameters[2]] = value i += 1 if cls.doFilter(filter, environment): output.append(evaluate(node.right, environment).value) return output
def getValueAccordingToType(value, type): try: if type.value == Type.STRING: return Type.string(value) if type.value == Type.INTEGER: return Type.integer(int(value)) if type.value == Type.BOOL: consumedChars, token = boolTokenizer(value, 0, 0) if consumedChars > 0: return Type.bool(token.value) return ValueError() if type.value == Type.NOTE: consumedChars, token = noteTokenizer(value, 0, 0) if consumedChars > 0: return Type.note(token.value) raise ValueError() raise RuntimeException( f"Type {type.value.name.lower()} is not supported", None) except ValueError: raise RuntimeException( f"Invalid value '{value}' for type {type.value.name.lower()}", None)
def numberEvaluator(cls, node, environment, evaluatedIterator, parameters, filter): output = [] if len(parameters) > 1: raise RuntimeException( f"Loop with numeric iterator can handle only one parameter", node.parameters.pos) for i in range(evaluatedIterator.value): if len(parameters) > 0: environment.scopes[-1][parameters[0]] = Type.integer(i) if cls.doFilter(filter, environment): output.append(evaluate(node.right, environment).value) return output
def listEvaluator(cls, node, environment, evaluatedIterator, parameters, filter): output = [] if len(parameters) > 2: raise RuntimeException( f"Loop with list iterator can handle only two parameters", node.parameters.pos) for i, value in enumerate(evaluatedIterator.value): if len(parameters) == 1: environment.scopes[-1][parameters[0]] = value if len(parameters) == 2: environment.scopes[-1][parameters[0]] = Type.integer(i) environment.scopes[-1][parameters[1]] = value if cls.doFilter(filter, environment): output.append(evaluate(node.right, environment).value) return output
def evaluator(cls, node, environment): return Type.integer(node.value)
def _function1(env, value): return Type.integer(int(value.value))
def getProperTypeProvider(value): return { int: lambda v: Type.integer(v), float: lambda v: Type.float(v) }[type(value)](value)
def evaluateForInteger(cls, value): return Type.integer(-value)
def _function(env, min, max): return Type.integer(random.randint(min.value, max.value))