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 evaluator(cls, node, environment):
map = {}
keyEvaluator = Evaluator.oneOf(
Evaluator.forNodes(lambda node, environment: EvaluationResult.OK(Type.string(node.value)), Identifier),
expressionEvaluator(doAssert=True)
)
for entry in node.children:
key = keyEvaluator(entry.key, environment).value
if key in map:
raise RuntimeException(f"Duplicated key '{key.stringify()}' found in map", entry.pos)
map[key] = expressionEvaluator(doAssert=True)(entry.value, environment).value
return Type.map(map)
def _function2(env, list):
map = {}
for entry in list.value:
key, value = entry.value
map[key] = value
return Type.map(map)
def _invokeCustomMethod(self, object, name, args):
for method in self.customMethods:
if method.typeSignature.check([
object
])[0] and method.name == name: #Todo sprawdzic sygnature typu
signatureCheckresult = method.signature.check(args)
if signatureCheckresult[0]:
self.scopes.append(method.defaultArgs)
self.scopes[-1].update({
argName: argValue
for argName, argValue in zip(
method.arguments, list(signatureCheckresult[1:]))
})
self.scopes[-1][method.alias] = object
self.callStack.append(CallStackItem(name))
result = Type.void()
try:
BodyEvaluator.evaluate(
method.body, self
).value # TODO check if it isn't necessary to verify 'result' attr of EvaluatioNResult
except Return as r:
result = r.value
self.callStack.pop(-1)
self.scopes.pop(-1)
return (True, result)
raise IllegalFunctionInvocationException(
f"{method.name}{method.signature.string}",
f"{name}{argsTypesToString(args)}")
return (False, None)
def _invokeCustomFunction(self, name, args):
for function in self.customFunctions:
if function.name == name:
signatureCheckresult = function.signature.check(args)
if signatureCheckresult[0]:
self.appendScope(function.defaultArgs)
appendedScopeIndex = len(self.scopes) - 1
self.scopes[-1].update({
argName: argValue
for argName, argValue in zip(
function.arguments, list(signatureCheckresult[1:]))
})
self.callStack.append(CallStackItem(name))
result = Type.void()
try:
BodyEvaluator.evaluate(
function.body, self
).value #TODO check if it isn't necessary to verify 'result' attr of EvaluatioNResult
except Return as r:
result = r.value
self.callStack.pop(-1)
self.popScope(mergeVariables=False)
self.removeScopesAfter(appendedScopeIndex)
return (True, result)
raise IllegalFunctionInvocationException(
f"{function.name}{function.signature.string}",
f"{name}{argsTypesToString(args)}")
return (False, None)
def evaluator(cls, node, environment):
value = expressionEvaluator(doAssert=True)(node.value, environment).value
if value.type != Type.BOOL:
raise RuntimeException(f"Operator '{node.operator.value}' is supported only by {Type.BOOL.name.lower()} type", node.value.pos)
return Type.bool(not value.value)
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 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 _function1(env, vararg):
map = {}
for entry in vararg:
key, value = entry.value
map[key] = value
return Type.map(map)
def otherRelationOperatorsEvaluator(cls, left, operator, right):
if left.type in [Type.INTEGER, Type.FLOAT
] and right.type in [Type.INTEGER, Type.FLOAT]:
if operator.value == ">":
return Type.bool(left.value > right.value)
if operator.value == ">=":
return Type.bool(left.value >= right.value)
if operator.value == "<":
return Type.bool(left.value < right.value)
if operator.value == "<=":
return Type.bool(left.value <= right.value)
raise RuntimeException(
f"Operator {operator.value} is not supported by {left.type.name.lower()} and {right.type.name.lower()} types",
operator.pos)
def getDecay(config):
key = Type.string("decay")
if key in config.value:
decay = config.value[key]
if not decay.type in [Type.INTEGER, Type.FLOAT] or decay.value < 0:
raise RuntimeException("The 'decay' property must be non-negative integer or float", None)
return decay.value
return DEFAULT_DECAY
def getBpm(config):
key = Type.string("bpm")
if key in config.value:
bpm = config.value[key]
if bpm.type != Type.INTEGER or bpm.value <= 0:
raise RuntimeException("The 'bpm' property must be positive integer", None)
return bpm.value
return DEFAULT_BPM
def getAttack(config):
key = Type.string("attack")
if key in config.value:
attack = config.value[key]
if not attack.type in [Type.INTEGER, Type.FLOAT] or attack.value < 0:
raise RuntimeException("The 'attack' property must be non-negative integer or float", None)
return attack.value
return DEFAULT_ATTACK
def getTuning(config):
key = Type.string("tuning")
if key in config.value:
tuning = config.value[key]
if not tuning.type in [Type.INTEGER, Type.FLOAT] or tuning.value < 0:
raise RuntimeException("The 'tuning' property must be non-negative integer or float", None)
return tuning.value
return DEFAULT_TUNING
def listEvaluator(cls, left, operator, right):
if operator.value == "+":
return Type.list(left.value + right.value)
if operator.value == "-":
raise RuntimeException(
f"Operator {operator.value} is not supported by list types",
operator.pos)
raise RuntimeError("This line should never be reached")
def mapEvaluator(cls, left, operator, right):
if operator.value == "+":
return Type.map({**left.value, **right.value})
if operator.value == "-":
raise RuntimeException(
f"Operator {operator.value} is not supported by map types",
operator.pos)
raise RuntimeError("This line should never be reached")
def call(self, env, args):
from smnp.environment.environment import CallStackItem
for function in self.functions:
result = function.signature.check(args)
if result[0]:
env.callStack.append(CallStackItem(self.name))
ret = function.function(env, *result[1:])
env.callStack.pop(-1)
if ret is None:
return Type.void()
return ret
raise IllegalFunctionInvocationException(
self.stringSignature(), f"{self.name}{argsTypesToString(args)}")
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 getOvertones(config):
key = Type.string("overtones")
if key in config.value:
overtones = config.value[key]
rawOvertones = [overtone.value for overtone in overtones.value]
if overtones.type != Type.LIST or not all(overtone.type in [Type.FLOAT, Type.INTEGER] for overtone in overtones.value):
raise RuntimeException("The 'overtones' property must be list of floats", None)
if len(rawOvertones) < 1:
raise RuntimeException("The 'overtones' property must contain one overtone at least", None)
if any(overtone < 0 for overtone in rawOvertones):
raise RuntimeException("The 'overtones' property mustn't contain negative values", None)
if sum(rawOvertones) > 1.0:
raise RuntimeException("The 'overtones' property must contain overtones which sum is not greater than 1.0", None)
return rawOvertones
return DEFAULT_OVERTONES
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 check(args):
if any(
[matcher.optional
for matcher in [varargMatcher, *basicSignature]]):
raise RuntimeError(
"Vararg signature can't have optional arguments")
if len(basicSignature) > len(args):
return doesNotMatchVararg(basicSignature)
for i in range(len(basicSignature)):
if not basicSignature[i].match(args[i]):
return doesNotMatchVararg(basicSignature)
for i in range(len(basicSignature), len(args)):
if not varargMatcher.match(args[i]):
return doesNotMatchVararg(basicSignature)
if wrapVarargInValue:
return True, (*args[:len(basicSignature)]), Type.list(
args[len(basicSignature):])
else:
return True, (
*args[:len(basicSignature)]), args[len(basicSignature):]
def evaluator(cls, node, environment):
iterator = expressionEvaluator(doAssert=True)(node.left,
environment).value
parameters = [identifier.value for identifier in node.parameters
] if type(node.parameters) != NoneNode() else []
try:
environment.appendScope()
output = {
Type.INTEGER: cls.numberEvaluator,
Type.BOOL: cls.boolEvaluator,
Type.LIST: cls.listEvaluator,
Type.MAP: cls.mapEvaluator
}[iterator.type](node, environment, iterator, parameters,
node.filter)
environment.popScope()
except KeyError:
raise RuntimeException(
f"The {iterator.type.name.lower()} type cannot stand as an iterator for loop statement",
node.left.pos)
return Type.list(output)
def evaluator(cls, node, environment):
left = expressionEvaluator(doAssert=True)(node.left, environment).value
right = expressionEvaluator(doAssert=True)(node.right, environment).value
return Type.bool(left.value and right.value)
def evaluator(cls, node, environment):
list = abstractIterableEvaluator(expressionEvaluator(doAssert=True))(node, environment)
return Type.list(list)
def evaluator(cls, node, environment):
return Type.type(node.value)
def evaluator(cls, node, environment):
return Type.string(node.value)
def evaluator(cls, node, environment):
return Type.integer(node.value)
def _function1(env, value):
return Type.integer(int(value.value))
def notEqualOperatorEvaluator(cls, left, operator, right):
if left.type in [Type.INTEGER, Type.FLOAT
] and right.type in [Type.INTEGER, Type.FLOAT]:
return Type.bool(left.value != right.value)
return Type.bool(left.type != right.type or left.value != right.value)
def getProperTypeProvider(value):
return {
int: lambda v: Type.integer(v),
float: lambda v: Type.float(v)
}[type(value)](value)
