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)