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))
