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
