def take_index(stack): num, l = popn(stack, 2) if type(num) == list: stack.append(l[num[0]:num[1]]) else: stack.append(l[num]) return stack
def filter_(stack): cond, l = popn(stack, 2) L = [] for x in l: if cond([x])[0]: L.append(x) stack.append(L) return stack
def map_(stack): f, l = popn(stack, 2) L = [] for x in l: y = f([x]) L.append(y[0]) stack.append(L) return stack
def bi(stack): f, g, arg = popn(stack, 3) # f is a function of a stack and return stack # in this way I access the real result res1 = g([arg])[0] res2 = f([arg])[0] stack.append(res1) stack.append(res2) return stack
def bif(stack): # for function which return one output stmt, cond = popn(stack, 2) stack_ = stack.copy() stack = cond(stack) if stack[-1]: stack = stmt(stack_) return stack # print ('stack_', stack_) else: return stack
def bii(stack): # for function which return one output f, g = popn(stack, 2) # aggiornare con deepcopy ovunque stack_ = deepcopy(stack) stack = f(stack) stack_ = g(stack_) # print ('ss', stack_) stack.append(stack_[-1]) return stack
def reduce_(stack): f, l = popn(stack, 2) if len(l) == 1: stack.append(l[0]) return stack while l: l = f(l) if len(l) == 1: break stack.append(l[0]) return stack
def dountil(stack): f, l = popn(stack, 2) L = [] for x in l: y = f([x]) # y è uno stack (una lista), il cui ultimo elemento deve essere un bool boolean = y.pop() L.append(boolean) if boolean: break stack.append(L) return stack
def all(stack): # for function which take n input and return one output funcList = popn(stack, 1) # la prima funzione la faccio fuori dal ciclo f = funcList[0] stack_ = deepcopy(stack) # copy of the original stack stack = f(stack) results = [] for f in funcList[1:]: stack__ = deepcopy(stack_) stack__ = f(stack__) results.append(stack__[-1]) stack.extend(results) return stack
def execute(tokens, stack=None, currentEnv=env, path=None, parser=None): if stack is None: stack = [] # if currentEnv is None: currentEnv = env for token in tokens: if token.head == 'import_stmt': name = "".join(token.tail[0].tail) loadModule(name, path, parser=parser) if token.head == 'assign_stmt': type_ = token.tail[0].head names = [x.tail[0] for x in token.tail[0].tail] # print (names, type_, token.tail[0].tail) if type_ == 'assign_normal': values = stack[-len(names):] # print (values) for name, value in zip(names, values): env[name] = value if type_ == 'assign_drop': for name in reversed(names): value = stack.pop() env[name] = value if type_ == 'assign_acc': # per il momento gli acc non possono avere liste come target value = stack[-1] try: env[names[0]].append(value) except: env[names[0]] = [value] if type_ == 'assign_acc_drop': # per il momento gli acc non possono avere liste come target value = stack.pop() try: env[names[0]].append(value) except: env[names[0]] = [value] if token.head == 'definition': name = token.tail[0].tail[0] def _(stack_, token=token): if type(token.tail[1]) != list: params = token.tail[1] for par in reversed([par.tail[0] for par in params.tail]): value = stack_.pop() env[par] = value return execute(token.tail[2], stack_) else: return execute(token.tail[1], stack_) _.__name__ = name env[name] = _ if token.head == 'int': stack.append(int(token.tail[0])) if token.head == 'float': stack.append(float(token.tail[0])) if token.head == 'bool': if token.tail[0] == 'True': stack.append(True) else: stack.append(False) if token.head == 'name': try: value = env[token.tail[0]] except KeyError as error: print('Error:', token.tail[0], 'is undefined') sys.exit(1) try: # va sistemato un po sto punto stack = value(stack) except TypeError as error: stack.append(value) except UnboundLocalError as error: pass if token.head == 'string': stack.append(token.tail[0][1:-1]) if token.head == 'list': # def _(stack_, token=token): # return execute(token.tail, stack_) stack.append(parse_list(token)) if token.head == 'array': stack.append(execute(token.tail, [])) if token.head == 'concat': res = [] for func in token.tail: l_old = len(stack) stack = parse_list(func)(stack) l_new = len(stack) # non posso poppare un solo elemento, devo poppare tutti quelli nuovo calcolati # può capitare anche che lo stack sia più corto di prima! # devo trovare un modo per far capire quanti sono i valori tornati da func arity = ... if arity == 1: res.append(stack.pop()) else: res.extend(popn(stack, arity)) stack.extend(res) return stack
def interval(stack): x, y = popn(stack, 2) x = int(math.ceil(x)) y = int(math.ceil(y)) stack.append(list(range(y, x + 1))) return stack
def pair(stack): a, b = popn(stack, 2) stack.append([b, a]) return stack
def remove(stack): n, l = popn(stack, 2) value = l.pop(n) stack.append(l) stack.append(value) return stack
def z(stack): l1, l2 = popn(stack, 2) stack.append(list(zip(l2, l1))) return stack
def group(stack): n = stack.pop() values = popn(stack, n) stack.append(list(reversed(values))) return stack
def in_(stack): l, num = popn(stack, 2) stack.append(num in l) return stack
def append(stack): num, l = popn(stack, 2) l.append(num) stack.append(l) return stack
def switch(stack): a, b = popn(stack, 2) stack.append(a) stack.append(b) return stack