def execute(self, operands: List[Expression], frame: Frame, gui_holder: Holder, eval_operands=True): new_frame = Frame(self.name, self.frame if self.lexically_scoped else frame) if eval_operands and self.evaluates_operands: operands = evaluate_all(operands, frame, gui_holder.expression.children[1:]) if self.var_param: verify_min_callable_length(self, len(self.params), len(operands)) else: verify_exact_callable_length(self, len(self.params), len(operands)) if len(self.body) > 1: body = [Pair(Symbol("begin"), make_list(self.body))] else: body = self.body for param, value in zip(self.params, operands): new_frame.assign(param, value) if self.var_param: new_frame.assign(self.var_param, make_list(operands[len(self.params):])) out = None gui_holder.expression.set_entries([ VisualExpression(expr, gui_holder.expression.display_value) for expr in body ]) gui_holder.apply() for i, expression in enumerate(body): out = evaluate(expression, new_frame, gui_holder.expression.children[i], self.evaluates_operands and i == len(body) - 1, log_stack=len(self.body) == 1) new_frame.assign(return_symbol, out) if not self.evaluates_operands: gui_holder.expression.set_entries( [VisualExpression(out, gui_holder.expression.display_value)]) out = evaluate(out, frame, gui_holder.expression.children[i], True) return out
def get_expression(buffer: TokenBuffer) -> Union[(Expression, None)]: token = buffer.pop_next_token() if (token is None): return None elif (token in ('(', '[')): return get_rest_of_list(buffer, (')' if (token == '(') else ']')) elif (token == "'"): return make_list([Symbol('quote'), get_expression(buffer)]) elif (token == ','): if (buffer.get_next_token() == '@'): buffer.pop_next_token() return make_list( [Symbol('unquote-splicing'), get_expression(buffer)]) else: return make_list([Symbol('unquote'), get_expression(buffer)]) elif (token == '`'): return make_list([Symbol('quasiquote'), get_expression(buffer)]) elif (token == '.'): if logger.dotted: raise ParseError(''.join( ["Unexpected token: '", '{}'.format(token), "'"])) else: return make_list([Symbol('variadic'), get_expression(buffer)]) elif (token == '"'): return get_string(buffer) elif (token in SPECIALS): raise ParseError(''.join( ["Unexpected token: '", '{}'.format(token), "'"])) elif is_number(token.value): try: return Number(int(token.value)) except ValueError: return Number(float(token.value)) elif ((token == '#t') or (token.value.lower() == 'true')): return SingletonTrue elif ((token == '#f') or (token.value.lower() == 'false')): return SingletonFalse elif (token == 'nil'): return Nil elif is_str(token.value): return Symbol(token.value.lower()) else: raise ParseError(''.join( ["Unexpected token: '", '{}'.format(token), "'"]))
def quasiquote_evaluate(cls, expr: Expression, frame: Frame, gui_holder: Holder, splicing=False): is_well_formed = False if isinstance(expr, Pair): try: lst = pair_to_list(expr) except OperandDeduceError: pass else: is_well_formed = not any(map( lambda x: isinstance(x, Symbol) and x.value in ["unquote", "quasiquote", "unquote-splicing"], lst)) visual_expression = gui_holder.expression if not is_well_formed: visual_expression.children[2:] = [] if isinstance(expr, Pair): if isinstance(expr.first, Symbol) and expr.first.value in ("unquote", "unquote-splicing"): if expr.first.value == "unquote-splicing" and not splicing: raise OperandDeduceError("Unquote-splicing must be in list template.") gui_holder.evaluate() verify_exact_callable_length(expr.first, 1, len(pair_to_list(expr)) - 1) out = evaluate(expr.rest.first, frame, visual_expression.children[1]) visual_expression.value = out gui_holder.complete() return out elif isinstance(expr.first, Symbol) and expr.first.value == "quasiquote": visual_expression.value = expr gui_holder.complete() return expr else: if is_well_formed: out = [] for sub_expr, holder in zip(pair_to_list(expr), visual_expression.children): splicing = isinstance(sub_expr, Pair) and isinstance(sub_expr.first, Symbol) \ and sub_expr.first.value == "unquote-splicing" evaluated = Quasiquote.quasiquote_evaluate(sub_expr, frame, holder, splicing) if splicing: if not isinstance(evaluated, (Pair, NilType)): raise TypeMismatchError(f"Can only splice lists, not {evaluated}.") out.extend(pair_to_list(evaluated)) else: out.append(evaluated) out = make_list(out) else: if not logger.dotted: raise OperandDeduceError(f"{expr} is an ill-formed quasiquotation.") out = Pair(Quasiquote.quasiquote_evaluate(expr.first, frame, visual_expression.children[0]), Quasiquote.quasiquote_evaluate(expr.rest, frame, visual_expression.children[1])) visual_expression.value = out gui_holder.complete() return out else: visual_expression.value = expr gui_holder.complete() return expr
def get_expression(buffer: TokenBuffer) -> Union[Expression, None]: token = buffer.pop_next_token() if token is None: return None elif token in ("(", "["): return get_rest_of_list(buffer, ")" if token == "(" else "]") elif token == "'": return make_list([Symbol("quote"), get_expression(buffer)]) elif token == ",": if buffer.get_next_token() == "@": buffer.pop_next_token() return make_list( [Symbol("unquote-splicing"), get_expression(buffer)]) else: return make_list([Symbol("unquote"), get_expression(buffer)]) elif token == "`": return make_list([Symbol("quasiquote"), get_expression(buffer)]) elif token == ".": if logger.dotted: raise ParseError(f"Unexpected token: '{token}'") else: return make_list([Symbol("variadic"), get_expression(buffer)]) elif token == "\"": return get_string(buffer) elif token in SPECIALS: raise ParseError(f"Unexpected token: '{token}'") elif is_number(token.value): try: return Number(int(token.value)) except ValueError: return Number(float(token.value)) elif token == "#t" or token.value.lower() == "true": return SingletonTrue elif token == "#f" or token.value.lower() == "false": return SingletonFalse elif token == "nil": return Nil elif is_str(token.value): return Symbol(token.value.lower()) else: raise ParseError(f"Unexpected token: '{token}'")
def side_menu(): db = con() user_id = session.get("user_id") # select all data from users table semesters = db.execute("SELECT * FROM semesters WHERE user_id=?", (user_id, )) sub_sem_list = make_list(semesters) return dict(sub_sem_list=sub_sem_list)
def execute(self, operands: List[Expression], frame: Frame, gui_holder: Holder, eval_operands=True): verify_exact_callable_length(self, 1, len(operands)) if eval_operands: operands = evaluate_all(operands, frame, gui_holder.expression.children[1:]) if not isinstance(operands[0], String): raise OperandDeduceError(f"Load expected a String, received {operands[0]}.") if logger.fragile: raise IrreversibleOperationError() from os import listdir from os.path import join directory = operands[0].value try: targets = sorted(listdir(directory)) targets = [join(directory, target) for target in targets if target.endswith(".scm")] exprs = [make_list([Symbol("load"), make_list([Symbol("quote"), Symbol(x[:-4])])]) for x in targets] equiv = make_list([Symbol("begin-noexcept")] + exprs) gui_holder.expression.set_entries([equiv]) gui_holder.apply() return evaluate(equiv, frame, gui_holder.expression.children[0], True) except Exception as e: raise SchemeError(e)
def execute_evaluated(self, operands: List[Expression], frame: Frame) -> Expression: if (len(operands) == 0): return Nil out = [] for operand in operands[:(-1)]: if ((not isinstance(operand, Pair)) and (operand is not Nil)): raise OperandDeduceError(''.join([ 'Expected operand to be valid list, not ', '{}'.format(operand) ])) out.extend(pair_to_list(operand)) try: last = operands[(-1)] if (not isinstance(last, Pair)): raise OperandDeduceError() last = pair_to_list(last) except OperandDeduceError: return make_list(out, operands[(-1)]) else: out.extend(last) return make_list(out)
def index(): """ gets all the data from database and display""" db = con() user_id = session.get("user_id") #"INSERT INTO users(first_name, last_name, email) VALUES ('Sandipa', 'Rijal', '*****@*****.**')" #table ="CREATE TABLE subjects (id INTEGER PRIMARY KEY AUTOINCREMENT, title TEXT NOT NULL, semester_id INTEGER, user_id INTEGER, FOREIGN KEY (user_id) REFERENCES users(id))" # select all data from users table user = db.execute("SELECT * FROM users WHERE id =?", (user_id, )) semesters = db.execute("SELECT * FROM semesters WHERE user_id=?", (user_id, )) sub_sem_list = make_list(semesters) # return the template index return render_template("index.html")
def get_rest_of_list(buffer: TokenBuffer, end_paren: str) -> Expression: out = [] last = Nil while True: next = buffer.get_next_token() if next == end_paren: buffer.pop_next_token() break elif logger.dotted and next == ".": buffer.pop_next_token() last = get_expression(buffer) if buffer.pop_next_token() != end_paren: raise ParseError( f"Only one expression may follow a dot in a dotted list.") break expr = get_expression(buffer) out.append(expr) out = make_list(out, last) return out
def quasiquote_evaluate(cls, expr: Expression, frame: Frame, gui_holder: Holder, splicing=False): is_well_formed = False if isinstance(expr, Pair): try: lst = pair_to_list(expr) except OperandDeduceError: pass else: is_well_formed = (not any( map((lambda x: (isinstance(x, Symbol) and (x.value in ['unquote', 'quasiquote', 'unquote-splicing']))), lst))) visual_expression = VisualExpression(expr) gui_holder.link_visual(visual_expression) if (not is_well_formed): visual_expression.children[2:] = [] if isinstance(expr, Pair): if (isinstance(expr.first, Symbol) and (expr.first.value in ('unquote', 'unquote-splicing'))): if ((expr.first.value == 'unquote-splicing') and (not splicing)): raise OperandDeduceError( 'Unquote-splicing must be in list template.') gui_holder.evaluate() verify_exact_callable_length(expr.first, 1, (len(pair_to_list(expr)) - 1)) out = evaluate(expr.rest.first, frame, visual_expression.children[1]) visual_expression.value = out gui_holder.complete() return out elif (isinstance(expr.first, Symbol) and (expr.first.value == 'quasiquote')): visual_expression.value = expr gui_holder.complete() return expr else: if is_well_formed: out = [] for (sub_expr, holder) in zip(pair_to_list(expr), visual_expression.children): splicing = (isinstance(sub_expr, Pair) and isinstance(sub_expr.first, Symbol) and (sub_expr.first.value == 'unquote-splicing')) evaluated = Quasiquote.quasiquote_evaluate( sub_expr, frame, holder, splicing) if splicing: if (not isinstance(evaluated, (Pair, NilType))): raise TypeMismatchError(''.join([ 'Can only splice lists, not ', '{}'.format(evaluated), '.' ])) out.extend(pair_to_list(evaluated)) else: out.append(evaluated) out = make_list(out) else: if (not logger.dotted): raise OperandDeduceError(''.join([ '{}'.format(expr), ' is an ill-formed quasiquotation.' ])) out = Pair( Quasiquote.quasiquote_evaluate( expr.first, frame, visual_expression.children[0]), Quasiquote.quasiquote_evaluate( expr.rest, frame, visual_expression.children[1])) visual_expression.value = out gui_holder.complete() return out else: visual_expression.value = expr gui_holder.complete() return expr
def execute_evaluated(self, operands: List[Expression], frame: Frame) -> Expression: return make_list(operands)