def _interpret(interpreter: Interpreter, actual_params: tp.List[ast.AST]) -> d.Boolean: evaluated_params = [] for idx, param in enumerate(actual_params): param_value = interpreter.visit(param) param_type = type(param_value) if not issubclass(param_type, d.RealNum): raise err.ArgumentTypeError( idx=idx, expected=d.RealNum, given=param_value ) evaluated_params.append(param_value) result = d.Boolean(True) prev_value = evaluated_params[0] for param_value in evaluated_params[1:]: current_value = param_value if not prev_value >= current_value: result = d.Boolean(False) break prev_value = current_value return result
def _interpret(interpreter: Interpreter, actual_params: tp.List[ast.AST]) -> d.Boolean: evaluated_params = [] for idx, param in enumerate(actual_params): param_value = interpreter.visit(param) param_type = type(param_value) if not issubclass(param_type, d.Number): raise err.ArgumentTypeError( idx=idx, expected=d.Number, given=param_value ) evaluated_params.append(param_value) first_param_value = evaluated_params[0] result = d.Boolean(True) for param_value in evaluated_params: if param_value != first_param_value: result = d.Boolean(False) break return result
def _interpret(interpreter: Interpreter, actual_params: tp.List[ast.AST]) -> d.Boolean: param_value = interpreter.visit(actual_params[0]) param_type = type(param_value) result = d.Boolean( issubclass(param_type, d.Boolean) and param_value == d.Boolean(False)) return result
def _interpret(interpreter: Interpreter, actual_params: tp.List[ast.AST]) -> d.Boolean: param_value = interpreter.visit(actual_params[0]) param_type = type(param_value) if not issubclass(param_type, d.String): raise err.ArgumentTypeError(expected=d.String, given=param_value) for char in param_value: if not char.isalpha(): return d.Boolean(False) else: return d.Boolean(True)
def _interpret(interpreter: Interpreter, actual_params: tp.List[ast.AST]) -> d.Boolean: param_value = interpreter.visit(actual_params[0]) param_type = type(param_value) is_list = issubclass(param_type, d.List) result = d.Boolean(is_list and len(param_value) == 0) return result
def _interpret(interpreter: Interpreter, actual_params: tp.List[ast.AST]) -> d.Boolean: param_value = interpreter.visit(actual_params[0]) param_type = type(param_value) if not issubclass(param_type, d.String): raise err.ArgumentTypeError(expected=d.String, given=param_value) return d.Boolean(len(param_value) == 0) or param_value.isspace()
def _interpret(interpreter: Interpreter, actual_params: tp.List[ast.AST]) -> d.Boolean: result = d.Boolean(True) for idx, param in enumerate(actual_params): param_value = interpreter.visit(param) param_type = type(param_value) if not issubclass(param_type, d.Boolean): raise err.ArgumentTypeError(idx=idx, expected=d.Boolean, given=param_value) if param_value == d.Boolean(False): result = param_value break return result
def _interpret(interpreter: Interpreter, actual_params: tp.List[ast.AST]) -> d.Boolean: param_value = interpreter.visit(actual_params[0]) param_type = type(param_value) if not issubclass(param_type, d.Boolean): raise err.ArgumentTypeError(expected=d.Boolean, given=param_value) result = d.Boolean(not param_value.value) return result
def _interpret(interpreter: Interpreter, actual_params: tp.List[ast.AST]) -> d.Boolean: evaluated_params = [] for idx, param in enumerate(actual_params): param_value = interpreter.visit(param) param_type = type(param_value) if not issubclass(param_type, d.String): raise err.ArgumentTypeError(idx=idx, expected=d.String, given=param_value) evaluated_params.append(param_value) substring = evaluated_params[0] containing_string = evaluated_params[1] result = substring in containing_string return d.Boolean(result)
def visit_Bool(self, node: ast.Bool) -> d.Boolean: return d.Boolean(node.value)
def visit_ProcCall(self, node: ast.ProcCall) -> d.Data: self.semantic_analyzer.visit(node) proc_symbol, actual_params = self.semantic_analyzer.get_proc_symbol_and_actual_params( node) proc_name = proc_symbol.name if proc_symbol.type == 'STRUCTURE_TYPE': raise err.InterpreterError( error_code=err.ErrorCode.USING_STRUCTURE_TYPE, token=node.token, name=proc_name) expr = proc_symbol.expr formal_params = proc_symbol.formal_params formal_params_len = len(formal_params) actual_params_len = len(actual_params) self.semantic_analyzer.assert_actual_param_len( node_token=node.token, proc_name=proc_name, formal_params_len=formal_params_len, actual_params_len=actual_params_len) expr_type = type(expr) if proc_name in BUILT_IN_PROCS.keys(): token = node.token line_no = token.line_no column = token.column node.proc_token = t.Token.create_proc(proc_name, line_no, column) result = self._visit_builtin_ProcCall(node) node.proc_token = node.original_proc_token return result elif issubclass(expr_type, ast.StructProc): evaluated_params = list( map(lambda param: self.visit(param), actual_params)) if expr_type is ast.StructMake: data = expr.data_type() data.fields = evaluated_params return data elif expr_type is ast.StructHuh: result = d.Boolean(type(evaluated_params[0]) == expr.data_type) return result elif expr_type is ast.StructGet: if type(evaluated_params[0]) != expr.data_type: raise err.InterpreterError( error_code=err.ErrorCode.INCORRECT_ARGUMENT_TYPE, token=node.token, name=proc_name, expected=expr.data_type, given=evaluated_params[0]) data_type_name = expr.data_type.__name__ field = proc_name[len(data_type_name) + 1:] result = evaluated_params[0].fields[ evaluated_params[0].field_names.index(field)] return result else: raise err.IllegalStateError else: result = self._visit_user_defined_ProcCall(proc_name, expr, formal_params, actual_params) return result