use alloc::format;
use alloc::string::{String, ToString};
use alloc::vec;
use alloc::vec::Vec;
pub(crate) use crate::date::{date_add, date_diff, format_time};
pub(crate) use crate::dialogs::{dir_select, file_select, input_box, tray_tip};
use crate::dll::{Convention, NativeArg, NativeCall, NativeFailureKind, NativeType, NativeValue};
pub(crate) use crate::files::{
dir_copy, dir_move, download, file_append, file_copy, file_encoding, file_get_attrib,
file_get_size, file_get_time, file_install, file_move, file_open, file_read, file_set_attrib,
file_set_time, ini_delete, ini_read, ini_write,
};
pub(crate) use crate::hotkeys::{
get_key_state, hotif, hotif_window, hotkey, hotstring, install_hook, key_history, list_hotkeys,
};
pub(crate) use crate::pictures::{image_search, load_picture};
use crate::runtime::{
Runtime, RuntimeError, RuntimeFailure, TypeName, Value, WindowAnswer, expected_type,
};
pub(crate) use crate::settings::{
coord_mode, get_key_name, get_key_sc, get_key_vk, send_event, send_input, send_level,
send_play, send_text, set_control_delay, set_default_mouse_speed, set_detect_hidden_text,
set_detect_hidden_windows, set_key_delay, set_mouse_delay, set_reg_view,
set_store_caps_lock_mode, set_title_match_mode, set_win_delay,
};
use core::cmp::Ordering;
use core::sync::atomic::{AtomicU32, Ordering as AtomicOrder};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum BuiltinKind {
Function,
Command,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Parameter {
Value,
Reference,
VarRef,
Variable,
Output,
Name,
}
pub type BuiltinHandler =
for<'a> fn(&mut Runtime<'a>, &[Value], u32, u8) -> Result<Value, RuntimeError>;
pub struct Builtin {
pub name: &'static str,
pub kind: BuiltinKind,
pub min: u8,
pub max: u8,
pub variant: u8,
pub parameters: &'static [Parameter],
pub handler: BuiltinHandler,
}
pub const THE_NAMES_THAT_ARE_BOTH: &[&str] = &[
"DetectHiddenText",
"DetectHiddenWindows",
"FileEncoding",
"ListLines",
"Persistent",
"SendLevel",
"SendMode",
"SetControlDelay",
"SetDefaultMouseSpeed",
"SetMouseDelay",
"SetRegView",
"SetStoreCapsLockMode",
"SetTitleMatchMode",
];
pub fn is_both(name: &str) -> bool {
THE_NAMES_THAT_ARE_BOTH
.iter()
.any(|both| both.eq_ignore_ascii_case(name))
}
impl Builtin {
pub fn writes_back(&self, index: usize) -> bool {
matches!(
self.parameters.get(index),
Some(Parameter::Reference) | Some(Parameter::Output)
)
}
}
pub const BUILTINS: &[Builtin] = &[
Builtin {
name: "Abs",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: abs,
},
Builtin {
name: "ACos",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 1,
parameters: &[Parameter::Value],
handler: inverse_trigonometry,
},
Builtin {
name: "ASin",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: inverse_trigonometry,
},
Builtin {
name: "ATan",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 2,
parameters: &[Parameter::Value],
handler: inverse_trigonometry,
},
Builtin {
name: "Ceil",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 1,
parameters: &[Parameter::Value],
handler: round_to,
},
Builtin {
name: "Cos",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 1,
parameters: &[Parameter::Value],
handler: trigonometry,
},
Builtin {
name: "Exp",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: exponential,
},
Builtin {
name: "Floor",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: round_to,
},
Builtin {
name: "Ln",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: logarithm,
},
Builtin {
name: "Log",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 1,
parameters: &[Parameter::Value],
handler: logarithm,
},
Builtin {
name: "Max",
kind: BuiltinKind::Function,
min: 1,
max: 255,
variant: 1,
parameters: &[Parameter::Value],
handler: extreme,
},
Builtin {
name: "Min",
kind: BuiltinKind::Function,
min: 1,
max: 255,
variant: 0,
parameters: &[Parameter::Value],
handler: extreme,
},
Builtin {
name: "Mod",
kind: BuiltinKind::Function,
min: 2,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: modulo,
},
Builtin {
name: "NumGet",
kind: BuiltinKind::Function,
min: 2,
max: 3,
variant: 0,
parameters: &[Parameter::Value],
handler: num_get,
},
Builtin {
name: "NumPut",
kind: BuiltinKind::Function,
min: 3,
max: 255,
variant: 0,
parameters: &[Parameter::Value],
handler: num_put,
},
Builtin {
name: "Random",
kind: BuiltinKind::Function,
min: 0,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: random,
},
Builtin {
name: "Round",
kind: BuiltinKind::Function,
min: 1,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: round_to_digits,
},
Builtin {
name: "Sin",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: trigonometry,
},
Builtin {
name: "Sqrt",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: square_root,
},
Builtin {
name: "Tan",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 2,
parameters: &[Parameter::Value],
handler: trigonometry,
},
Builtin {
name: "Chr",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: chr,
},
Builtin {
name: "Format",
kind: BuiltinKind::Function,
min: 1,
max: 255,
variant: 0,
parameters: &[Parameter::Value],
handler: format,
},
Builtin {
name: "InStr",
kind: BuiltinKind::Function,
min: 2,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: in_str,
},
Builtin {
name: "LTrim",
kind: BuiltinKind::Function,
min: 1,
max: 2,
variant: 1,
parameters: &[Parameter::Value],
handler: trim,
},
Builtin {
name: "Ord",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: ord,
},
Builtin {
name: "RTrim",
kind: BuiltinKind::Function,
min: 1,
max: 2,
variant: 2,
parameters: &[Parameter::Value],
handler: trim,
},
Builtin {
name: "Sort",
kind: BuiltinKind::Function,
min: 1,
max: 3,
variant: 0,
parameters: &[Parameter::Value],
handler: sort,
},
Builtin {
name: "StrCompare",
kind: BuiltinKind::Function,
min: 2,
max: 3,
variant: 0,
parameters: &[Parameter::Value],
handler: str_compare,
},
Builtin {
name: "StrLen",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: str_len,
},
Builtin {
name: "StrLower",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: change_case,
},
Builtin {
name: "StrReplace",
kind: BuiltinKind::Function,
min: 2,
max: 6,
variant: 0,
parameters: &[
Parameter::Value,
Parameter::Value,
Parameter::Value,
Parameter::Value,
Parameter::Reference,
Parameter::Value,
],
handler: str_replace,
},
Builtin {
name: "StrUpper",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 1,
parameters: &[Parameter::Value],
handler: change_case,
},
Builtin {
name: "SubStr",
kind: BuiltinKind::Function,
min: 2,
max: 3,
variant: 0,
parameters: &[Parameter::Value],
handler: sub_str,
},
Builtin {
name: "Trim",
kind: BuiltinKind::Function,
min: 1,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: trim,
},
Builtin {
name: "IsAlnum",
kind: BuiltinKind::Function,
min: 1,
max: 2,
variant: 7,
parameters: &[Parameter::Value],
handler: is_value,
},
Builtin {
name: "IsAlpha",
kind: BuiltinKind::Function,
min: 1,
max: 2,
variant: 8,
parameters: &[Parameter::Value],
handler: is_value,
},
Builtin {
name: "IsDigit",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 5,
parameters: &[Parameter::Value],
handler: is_value,
},
Builtin {
name: "IsFloat",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 3,
parameters: &[Parameter::Value],
handler: is_value,
},
Builtin {
name: "IsInteger",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 2,
parameters: &[Parameter::Value],
handler: is_value,
},
Builtin {
name: "IsLower",
kind: BuiltinKind::Function,
min: 1,
max: 2,
variant: 10,
parameters: &[Parameter::Value],
handler: is_value,
},
Builtin {
name: "IsNumber",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 1,
parameters: &[Parameter::Value],
handler: is_value,
},
Builtin {
name: "IsObject",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: is_object,
},
Builtin {
name: "IsSpace",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 11,
parameters: &[Parameter::Value],
handler: is_value,
},
Builtin {
name: "IsTime",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 4,
parameters: &[Parameter::Value],
handler: is_value,
},
Builtin {
name: "IsUpper",
kind: BuiltinKind::Function,
min: 1,
max: 2,
variant: 9,
parameters: &[Parameter::Value],
handler: is_value,
},
Builtin {
name: "IsXDigit",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 6,
parameters: &[Parameter::Value],
handler: is_value,
},
Builtin {
name: "Type",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: type_of,
},
Builtin {
name: "RegExMatch",
kind: BuiltinKind::Function,
min: 2,
max: 4,
variant: 0,
parameters: &[
Parameter::Value,
Parameter::Value,
Parameter::Reference,
Parameter::Value,
],
handler: regex_match,
},
Builtin {
name: "RegExReplace",
kind: BuiltinKind::Function,
min: 2,
max: 6,
variant: 0,
parameters: &[
Parameter::Value,
Parameter::Value,
Parameter::Value,
Parameter::Reference,
Parameter::Value,
Parameter::Value,
],
handler: regex_replace,
},
Builtin {
name: "Click",
kind: BuiltinKind::Function,
min: 0,
max: 6,
variant: 0,
parameters: &[Parameter::Value],
handler: click,
},
Builtin {
name: "MouseGetPos",
kind: BuiltinKind::Command,
min: 0,
max: 5,
variant: 0,
parameters: &[
Parameter::Reference,
Parameter::Reference,
Parameter::Reference,
Parameter::Reference,
Parameter::Value,
],
handler: mouse_get_pos,
},
Builtin {
name: "MouseMove",
kind: BuiltinKind::Command,
min: 2,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: mouse_move,
},
Builtin {
name: "PixelGetColor",
kind: BuiltinKind::Command,
min: 2,
max: 3,
variant: 0,
parameters: &[Parameter::Value],
handler: pixel_get_color,
},
Builtin {
name: "PixelSearch",
kind: BuiltinKind::Command,
min: 7,
max: 8,
variant: 0,
parameters: &[
Parameter::Reference,
Parameter::Reference,
Parameter::Value,
Parameter::Value,
Parameter::Value,
Parameter::Value,
Parameter::Value,
Parameter::Value,
],
handler: pixel_search,
},
Builtin {
name: "Screenshot",
kind: BuiltinKind::Command,
min: 5,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: screenshot,
},
Builtin {
name: "WinActive",
kind: BuiltinKind::Function,
min: 0,
max: 4,
variant: 1,
parameters: &[Parameter::Value],
handler: window_active,
},
Builtin {
name: "WinExist",
kind: BuiltinKind::Function,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: window_exist,
},
Builtin {
name: "WinGetTitle",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: win_get_title,
},
Builtin {
name: "MsgBox",
kind: BuiltinKind::Command,
min: 0,
max: 3,
variant: 0,
parameters: &[Parameter::Value],
handler: msg_box,
},
Builtin {
name: "Run",
kind: BuiltinKind::Command,
min: 1,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: run,
},
Builtin {
name: "Send",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: send,
},
Builtin {
name: "Sleep",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: sleep,
},
Builtin {
name: "ClipWait",
kind: BuiltinKind::Command,
min: 0,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: clip_wait,
},
Builtin {
name: "DirCreate",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: dir_create,
},
Builtin {
name: "DirDelete",
kind: BuiltinKind::Command,
min: 1,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: dir_delete,
},
Builtin {
name: "DirExist",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: dir_exist,
},
Builtin {
name: "EnvGet",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: env_get,
},
Builtin {
name: "EnvSet",
kind: BuiltinKind::Command,
min: 1,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: env_set,
},
Builtin {
name: "Exit",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: exit_script,
},
Builtin {
name: "ExitApp",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: exit_script,
},
Builtin {
name: "FileAppend",
kind: BuiltinKind::Command,
min: 1,
max: 3,
variant: 0,
parameters: &[Parameter::Value],
handler: file_append,
},
Builtin {
name: "FileDelete",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: file_delete,
},
Builtin {
name: "FileExist",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: file_exist,
},
Builtin {
name: "FileRead",
kind: BuiltinKind::Command,
min: 1,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: file_read,
},
Builtin {
name: "GetMethod",
kind: BuiltinKind::Function,
min: 1,
max: 3,
variant: 0,
parameters: &[Parameter::Value],
handler: get_method,
},
Builtin {
name: "HasBase",
kind: BuiltinKind::Function,
min: 2,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: has_base,
},
Builtin {
name: "HasMethod",
kind: BuiltinKind::Function,
min: 1,
max: 3,
variant: 0,
parameters: &[Parameter::Value],
handler: has_method,
},
Builtin {
name: "HasProp",
kind: BuiltinKind::Function,
min: 2,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: has_prop,
},
Builtin {
name: "IsSet",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Reference],
handler: is_set,
},
Builtin {
name: "IsSetRef",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Reference],
handler: is_set_ref,
},
Builtin {
name: "KeyWait",
kind: BuiltinKind::Command,
min: 1,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: key_wait,
},
Builtin {
name: "RunWait",
kind: BuiltinKind::Function,
min: 1,
max: 4,
variant: 0,
parameters: &[
Parameter::Value,
Parameter::Value,
Parameter::Value,
Parameter::Reference,
],
handler: run,
},
Builtin {
name: "SendMode",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: send_mode,
},
Builtin {
name: "SetKeyDelay",
kind: BuiltinKind::Command,
min: 0,
max: 3,
variant: 0,
parameters: &[Parameter::Value],
handler: set_key_delay,
},
Builtin {
name: "SetTimer",
kind: BuiltinKind::Command,
min: 0,
max: 3,
variant: 0,
parameters: &[Parameter::Value],
handler: set_timer,
},
Builtin {
name: "SplitPath",
kind: BuiltinKind::Function,
min: 1,
max: 6,
variant: 0,
parameters: &[
Parameter::Value,
Parameter::Reference,
Parameter::Reference,
Parameter::Reference,
Parameter::Reference,
Parameter::Reference,
],
handler: split_path,
},
Builtin {
name: "StrSplit",
kind: BuiltinKind::Command,
min: 1,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: str_split,
},
Builtin {
name: "VarSetStrCapacity",
kind: BuiltinKind::Function,
min: 1,
max: 2,
variant: 0,
parameters: &[Parameter::Reference, Parameter::Value],
handler: var_set_str_capacity,
},
Builtin {
name: "BlockInput",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: block_input,
},
Builtin {
name: "CallbackCreate",
kind: BuiltinKind::Command,
min: 1,
max: 3,
variant: 0,
parameters: &[Parameter::Value],
handler: callback_create,
},
Builtin {
name: "CallbackFree",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: callback_free,
},
Builtin {
name: "CaretGetPos",
kind: BuiltinKind::Function,
min: 0,
max: 2,
variant: 0,
parameters: &[Parameter::Reference, Parameter::Reference],
handler: caret_get_pos,
},
Builtin {
name: "ComCall",
kind: BuiltinKind::Function,
min: 2,
max: 255,
variant: 0,
parameters: &[Parameter::Value],
handler: com_call,
},
Builtin {
name: "ComObjActive",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: com_obj_active,
},
Builtin {
name: "ComObjConnect",
kind: BuiltinKind::Function,
min: 1,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: com_obj_connect,
},
Builtin {
name: "ComObjFlags",
kind: BuiltinKind::Function,
min: 1,
max: 3,
variant: 0,
parameters: &[Parameter::Value],
handler: com_obj_flags,
},
Builtin {
name: "ComObjFromPtr",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: com_obj_from_ptr,
},
Builtin {
name: "ComObjGet",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: com_obj_get,
},
Builtin {
name: "ComObjQuery",
kind: BuiltinKind::Function,
min: 2,
max: 3,
variant: 0,
parameters: &[Parameter::Value],
handler: com_obj_query,
},
Builtin {
name: "ComObjType",
kind: BuiltinKind::Function,
min: 1,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: com_obj_type,
},
Builtin {
name: "ComObjValue",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: com_obj_value,
},
Builtin {
name: "ControlAddItem",
kind: BuiltinKind::Command,
min: 2,
max: 6,
variant: 0,
parameters: &[Parameter::Value],
handler: control_add_item,
},
Builtin {
name: "ControlChooseIndex",
kind: BuiltinKind::Command,
min: 2,
max: 6,
variant: 0,
parameters: &[Parameter::Value],
handler: control_choose_index,
},
Builtin {
name: "ControlChooseString",
kind: BuiltinKind::Command,
min: 2,
max: 6,
variant: 0,
parameters: &[Parameter::Value],
handler: control_choose_string,
},
Builtin {
name: "ControlClick",
kind: BuiltinKind::Command,
min: 0,
max: 8,
variant: 0,
parameters: &[Parameter::Value],
handler: control_act,
},
Builtin {
name: "ControlDeleteItem",
kind: BuiltinKind::Command,
min: 2,
max: 6,
variant: 0,
parameters: &[Parameter::Value],
handler: control_delete_item,
},
Builtin {
name: "ControlFindItem",
kind: BuiltinKind::Command,
min: 2,
max: 6,
variant: 0,
parameters: &[Parameter::Value],
handler: control_find_item,
},
Builtin {
name: "ControlFocus",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 1,
parameters: &[Parameter::Value],
handler: control_act,
},
Builtin {
name: "ControlGetChecked",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: control_get_checked,
},
Builtin {
name: "ControlGetChoice",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: control_get_choice,
},
Builtin {
name: "ControlGetClassNN",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: control_get_classnn,
},
Builtin {
name: "ControlGetEnabled",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 1,
parameters: &[Parameter::Value],
handler: control_flag,
},
Builtin {
name: "ControlGetExStyle",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 1,
parameters: &[Parameter::Value],
handler: control_style,
},
Builtin {
name: "ControlGetFocus",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: control_get_focus,
},
Builtin {
name: "ControlGetHwnd",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: control_get_hwnd,
},
Builtin {
name: "ControlGetIndex",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: control_get_index,
},
Builtin {
name: "ControlGetItems",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: control_get_items,
},
Builtin {
name: "ControlGetPos",
kind: BuiltinKind::Command,
min: 0,
max: 9,
variant: 0,
parameters: &[Parameter::Value],
handler: control_get_pos,
},
Builtin {
name: "ControlGetStyle",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: control_style,
},
Builtin {
name: "ControlGetText",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: control_get_text,
},
Builtin {
name: "ControlGetVisible",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: control_flag,
},
Builtin {
name: "ControlHide",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: control_visibility,
},
Builtin {
name: "ControlHideDropDown",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: control_hide_drop_down,
},
Builtin {
name: "ControlMove",
kind: BuiltinKind::Command,
min: 0,
max: 9,
variant: 0,
parameters: &[Parameter::Value],
handler: control_move,
},
Builtin {
name: "ControlSend",
kind: BuiltinKind::Command,
min: 1,
max: 6,
variant: 0,
parameters: &[Parameter::Value],
handler: control_send,
},
Builtin {
name: "ControlSendText",
kind: BuiltinKind::Command,
min: 1,
max: 6,
variant: 0,
parameters: &[Parameter::Value],
handler: control_send_text,
},
Builtin {
name: "ControlSetChecked",
kind: BuiltinKind::Command,
min: 2,
max: 6,
variant: 0,
parameters: &[Parameter::Value],
handler: control_set_checked,
},
Builtin {
name: "ControlSetEnabled",
kind: BuiltinKind::Command,
min: 2,
max: 6,
variant: 0,
parameters: &[Parameter::Value],
handler: control_set_enabled,
},
Builtin {
name: "ControlSetExStyle",
kind: BuiltinKind::Command,
min: 2,
max: 6,
variant: 1,
parameters: &[Parameter::Value],
handler: control_set_style,
},
Builtin {
name: "ControlSetStyle",
kind: BuiltinKind::Command,
min: 2,
max: 6,
variant: 0,
parameters: &[Parameter::Value],
handler: control_set_style,
},
Builtin {
name: "ControlSetText",
kind: BuiltinKind::Command,
min: 2,
max: 6,
variant: 0,
parameters: &[Parameter::Value],
handler: control_set_text,
},
Builtin {
name: "ControlShow",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: control_show,
},
Builtin {
name: "ControlShowDropDown",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: control_show_drop_down,
},
Builtin {
name: "DetectHiddenText",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: set_detect_hidden_text,
},
Builtin {
name: "DetectHiddenWindows",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: set_detect_hidden_windows,
},
Builtin {
name: "DllCall",
kind: BuiltinKind::Function,
min: 1,
max: 255,
variant: 0,
parameters: &[Parameter::Value],
handler: dll_call,
},
Builtin {
name: "DriveEject",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: drive_eject,
},
Builtin {
name: "DriveGetCapacity",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: drive_get_capacity,
},
Builtin {
name: "DriveGetFilesystem",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: drive_get_filesystem,
},
Builtin {
name: "DriveGetLabel",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: drive_get_label,
},
Builtin {
name: "DriveGetList",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: drive_get_list,
},
Builtin {
name: "DriveGetSerial",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: drive_get_serial,
},
Builtin {
name: "DriveGetSpaceFree",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: drive_get_space_free,
},
Builtin {
name: "DriveGetStatus",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: drive_get_status,
},
Builtin {
name: "DriveGetStatusCD",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: drive_get_status_cd,
},
Builtin {
name: "DriveGetType",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: drive_get_type,
},
Builtin {
name: "DriveLock",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: drive_lock,
},
Builtin {
name: "DriveRetract",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: drive_retract,
},
Builtin {
name: "DriveSetLabel",
kind: BuiltinKind::Command,
min: 1,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: drive_set_label,
},
Builtin {
name: "DriveUnlock",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: drive_unlock,
},
Builtin {
name: "Edit",
kind: BuiltinKind::Command,
min: 0,
max: 0,
variant: 0,
parameters: &[Parameter::Value],
handler: edit,
},
Builtin {
name: "EditGetCurrentCol",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: edit_get_current_col,
},
Builtin {
name: "EditGetCurrentLine",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: edit_get_current_line,
},
Builtin {
name: "EditGetLine",
kind: BuiltinKind::Command,
min: 2,
max: 6,
variant: 0,
parameters: &[Parameter::Value],
handler: edit_get_line,
},
Builtin {
name: "EditGetLineCount",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: edit_get_line_count,
},
Builtin {
name: "EditGetSelectedText",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: edit_get_selected_text,
},
Builtin {
name: "EditPaste",
kind: BuiltinKind::Command,
min: 2,
max: 6,
variant: 0,
parameters: &[Parameter::Value],
handler: edit_paste,
},
Builtin {
name: "FileCreateShortcut",
kind: BuiltinKind::Command,
min: 2,
max: 9,
variant: 0,
parameters: &[Parameter::Value],
handler: file_create_shortcut,
},
Builtin {
name: "FileGetShortcut",
kind: BuiltinKind::Command,
min: 1,
max: 8,
variant: 0,
parameters: &[Parameter::Value],
handler: file_get_shortcut,
},
Builtin {
name: "FileGetVersion",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: file_get_version,
},
Builtin {
name: "FileRecycle",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: file_recycle,
},
Builtin {
name: "FileRecycleEmpty",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: file_recycle_empty,
},
Builtin {
name: "GroupActivate",
kind: BuiltinKind::Command,
min: 1,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: group_activate,
},
Builtin {
name: "GroupAdd",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: group_add,
},
Builtin {
name: "GroupClose",
kind: BuiltinKind::Command,
min: 1,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: group_close,
},
Builtin {
name: "GroupDeactivate",
kind: BuiltinKind::Command,
min: 1,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: group_close,
},
Builtin {
name: "GuiCtrlFromHwnd",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: gui_ctrl_from_hwnd,
},
Builtin {
name: "GuiFromHwnd",
kind: BuiltinKind::Command,
min: 1,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: gui_from_hwnd,
},
Builtin {
name: "IL_Add",
kind: BuiltinKind::Command,
min: 2,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: il_add,
},
Builtin {
name: "IL_Create",
kind: BuiltinKind::Command,
min: 0,
max: 3,
variant: 0,
parameters: &[Parameter::Value],
handler: il_create,
},
Builtin {
name: "IL_Destroy",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: il_destroy,
},
Builtin {
name: "ListViewGetContent",
kind: BuiltinKind::Command,
min: 0,
max: 6,
variant: 0,
parameters: &[Parameter::Value],
handler: list_view_get_content,
},
Builtin {
name: "MenuFromHandle",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: menu_from_handle,
},
Builtin {
name: "MenuSelect",
kind: BuiltinKind::Command,
min: 0,
max: 11,
variant: 0,
parameters: &[Parameter::Value],
handler: menu_select,
},
Builtin {
name: "MonitorGet",
kind: BuiltinKind::Command,
min: 0,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: monitor_get,
},
Builtin {
name: "MonitorGetCount",
kind: BuiltinKind::Command,
min: 0,
max: 0,
variant: 0,
parameters: &[Parameter::Value],
handler: monitor_get_count,
},
Builtin {
name: "MonitorGetName",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: monitor_get_name,
},
Builtin {
name: "MonitorGetPrimary",
kind: BuiltinKind::Command,
min: 0,
max: 0,
variant: 0,
parameters: &[Parameter::Value],
handler: monitor_get_primary,
},
Builtin {
name: "MonitorGetWorkArea",
kind: BuiltinKind::Command,
min: 0,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: monitor_get_work_area,
},
Builtin {
name: "ObjAddRef",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: obj_add_ref,
},
Builtin {
name: "ObjBindMethod",
kind: BuiltinKind::Function,
min: 1,
max: 255,
variant: 0,
parameters: &[Parameter::Value],
handler: obj_bind_method,
},
Builtin {
name: "ObjFromPtr",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: obj_from_ptr,
},
Builtin {
name: "ObjFromPtrAddRef",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: obj_from_ptr_add_ref,
},
Builtin {
name: "ObjGetBase",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: obj_get_base,
},
Builtin {
name: "ObjGetCapacity",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: obj_get_capacity,
},
Builtin {
name: "ObjHasOwnProp",
kind: BuiltinKind::Function,
min: 2,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: obj_has_own_prop,
},
Builtin {
name: "ObjOwnPropCount",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: obj_own_prop_count,
},
Builtin {
name: "ObjOwnProps",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: obj_own_props,
},
Builtin {
name: "ObjPtr",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: obj_ptr,
},
Builtin {
name: "ObjPtrAddRef",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: obj_ptr_add_ref,
},
Builtin {
name: "ObjRelease",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 1,
parameters: &[Parameter::Value],
handler: obj_add_ref,
},
Builtin {
name: "ObjSetBase",
kind: BuiltinKind::Function,
min: 2,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: obj_set_base,
},
Builtin {
name: "ObjSetCapacity",
kind: BuiltinKind::Function,
min: 2,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: obj_set_capacity,
},
Builtin {
name: "OnClipboardChange",
kind: BuiltinKind::Command,
min: 1,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: on_clipboard_change,
},
Builtin {
name: "OnMessage",
kind: BuiltinKind::Command,
min: 2,
max: 3,
variant: 0,
parameters: &[Parameter::Value],
handler: on_message,
},
Builtin {
name: "OutputDebug",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: output_debug,
},
Builtin {
name: "PostMessage",
kind: BuiltinKind::Command,
min: 1,
max: 8,
variant: 0,
parameters: &[Parameter::Value],
handler: post_message,
},
Builtin {
name: "ProcessClose",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: process_close,
},
Builtin {
name: "ProcessExist",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: process_exist,
},
Builtin {
name: "ProcessGetName",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: process_get_name,
},
Builtin {
name: "ProcessGetParent",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: process_get_parent,
},
Builtin {
name: "ProcessGetPath",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: process_get_path,
},
Builtin {
name: "ProcessSetPriority",
kind: BuiltinKind::Command,
min: 1,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: process_set_priority,
},
Builtin {
name: "ProcessWait",
kind: BuiltinKind::Command,
min: 1,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: process_wait,
},
Builtin {
name: "ProcessWaitClose",
kind: BuiltinKind::Command,
min: 1,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: process_wait_close,
},
Builtin {
name: "RegCreateKey",
kind: BuiltinKind::Function,
min: 0,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: reg_create_key,
},
Builtin {
name: "RegDelete",
kind: BuiltinKind::Function,
min: 0,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: reg_delete,
},
Builtin {
name: "RegDeleteKey",
kind: BuiltinKind::Function,
min: 0,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: reg_delete_key,
},
Builtin {
name: "RegRead",
kind: BuiltinKind::Function,
min: 0,
max: 3,
variant: 0,
parameters: &[Parameter::Value],
handler: reg_read,
},
Builtin {
name: "RegWrite",
kind: BuiltinKind::Function,
min: 1,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: reg_write,
},
Builtin {
name: "RunAs",
kind: BuiltinKind::Command,
min: 0,
max: 3,
variant: 0,
parameters: &[Parameter::Value],
handler: run_as,
},
Builtin {
name: "SendMessage",
kind: BuiltinKind::Command,
min: 1,
max: 9,
variant: 0,
parameters: &[Parameter::Value],
handler: send_message,
},
Builtin {
name: "SetCapsLockState",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: set_caps_lock_state,
},
Builtin {
name: "SetControlDelay",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: set_control_delay,
},
Builtin {
name: "SetNumLockState",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: set_num_lock_state,
},
Builtin {
name: "SetRegView",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: set_reg_view,
},
Builtin {
name: "SetScrollLockState",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: set_scroll_lock_state,
},
Builtin {
name: "SetTitleMatchMode",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: set_title_match_mode,
},
Builtin {
name: "SetWinDelay",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: set_win_delay,
},
Builtin {
name: "Shutdown",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: shutdown,
},
Builtin {
name: "SoundBeep",
kind: BuiltinKind::Command,
min: 0,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: sound_beep,
},
Builtin {
name: "SoundGetInterface",
kind: BuiltinKind::Function,
min: 1,
max: 3,
variant: 0,
parameters: &[Parameter::Value],
handler: sound_get_interface,
},
Builtin {
name: "SoundGetMute",
kind: BuiltinKind::Function,
min: 0,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: sound_get_mute,
},
Builtin {
name: "SoundGetName",
kind: BuiltinKind::Function,
min: 0,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: sound_get_name,
},
Builtin {
name: "SoundGetVolume",
kind: BuiltinKind::Function,
min: 0,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: sound_get_volume,
},
Builtin {
name: "SoundPlay",
kind: BuiltinKind::Command,
min: 1,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: sound_play,
},
Builtin {
name: "SoundSetMute",
kind: BuiltinKind::Function,
min: 1,
max: 3,
variant: 0,
parameters: &[Parameter::Value],
handler: sound_set_mute,
},
Builtin {
name: "SoundSetVolume",
kind: BuiltinKind::Function,
min: 1,
max: 3,
variant: 0,
parameters: &[Parameter::Value],
handler: sound_set_volume,
},
Builtin {
name: "StatusBarGetText",
kind: BuiltinKind::Command,
min: 0,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: status_bar_get_text,
},
Builtin {
name: "StatusBarWait",
kind: BuiltinKind::Command,
min: 0,
max: 8,
variant: 0,
parameters: &[Parameter::Value],
handler: status_bar_wait,
},
Builtin {
name: "StrGet",
kind: BuiltinKind::Function,
min: 1,
max: 3,
variant: 0,
parameters: &[Parameter::Value],
handler: str_get,
},
Builtin {
name: "StrPtr",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: str_ptr,
},
Builtin {
name: "StrPut",
kind: BuiltinKind::Function,
min: 1,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: str_put,
},
Builtin {
name: "SysGet",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: sys_get,
},
Builtin {
name: "SysGetIPAddresses",
kind: BuiltinKind::Command,
min: 0,
max: 0,
variant: 0,
parameters: &[Parameter::Value],
handler: sys_get_ip_addresses,
},
Builtin {
name: "ToolTip",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: tooltip,
},
Builtin {
name: "TraySetIcon",
kind: BuiltinKind::Command,
min: 0,
max: 3,
variant: 0,
parameters: &[Parameter::Value],
handler: tray_set_icon,
},
Builtin {
name: "TrayTip",
kind: BuiltinKind::Command,
min: 0,
max: 3,
variant: 0,
parameters: &[Parameter::Value],
handler: tray_tip,
},
Builtin {
name: "WinActivate",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: win_activate,
},
Builtin {
name: "WinActivateBottom",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: win_activate_bottom,
},
Builtin {
name: "WinClose",
kind: BuiltinKind::Command,
min: 0,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: win_close,
},
Builtin {
name: "WinGetClass",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: win_get_class,
},
Builtin {
name: "WinGetControls",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: win_get_controls,
},
Builtin {
name: "WinGetControlsHwnd",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: win_get_controls_hwnd,
},
Builtin {
name: "WinGetCount",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: win_get_count,
},
Builtin {
name: "WinGetExStyle",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 1,
parameters: &[Parameter::Value],
handler: win_style,
},
Builtin {
name: "WinGetID",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: win_get_id,
},
Builtin {
name: "WinGetIDLast",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: win_get_id_last,
},
Builtin {
name: "WinGetList",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: win_get_list,
},
Builtin {
name: "WinGetMinMax",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: win_get_min_max,
},
Builtin {
name: "WinGetPID",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: win_get_pid,
},
Builtin {
name: "WinGetPos",
kind: BuiltinKind::Command,
min: 0,
max: 8,
variant: 0,
parameters: &[
Parameter::Reference,
Parameter::Reference,
Parameter::Reference,
Parameter::Reference,
Parameter::Value,
Parameter::Value,
Parameter::Value,
Parameter::Value,
],
handler: win_get_pos,
},
Builtin {
name: "WinGetClientPos",
kind: BuiltinKind::Command,
min: 0,
max: 8,
variant: 0,
parameters: &[
Parameter::Reference,
Parameter::Reference,
Parameter::Reference,
Parameter::Reference,
Parameter::Value,
Parameter::Value,
Parameter::Value,
Parameter::Value,
],
handler: win_get_client_pos,
},
Builtin {
name: "WinGetProcessName",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: win_get_process,
},
Builtin {
name: "WinGetProcessPath",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 1,
parameters: &[Parameter::Value],
handler: win_get_process,
},
Builtin {
name: "WinGetStyle",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: win_style,
},
Builtin {
name: "WinGetText",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: win_get_text,
},
Builtin {
name: "WinGetTransColor",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: win_trans_color,
},
Builtin {
name: "WinGetTransparent",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: win_get_transparent,
},
Builtin {
name: "WinHide",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: win_hide,
},
Builtin {
name: "WinKill",
kind: BuiltinKind::Command,
min: 0,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: win_kill,
},
Builtin {
name: "WinMaximize",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: win_maximize,
},
Builtin {
name: "WinMinimize",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: win_minimize,
},
Builtin {
name: "WinMinimizeAll",
kind: BuiltinKind::Command,
min: 0,
max: 0,
variant: 0,
parameters: &[Parameter::Value],
handler: win_minimize_all,
},
Builtin {
name: "WinMinimizeAllUndo",
kind: BuiltinKind::Command,
min: 0,
max: 0,
variant: 0,
parameters: &[Parameter::Value],
handler: win_minimize_all_undo,
},
Builtin {
name: "WinMove",
kind: BuiltinKind::Command,
min: 0,
max: 8,
variant: 0,
parameters: &[Parameter::Value],
handler: win_move,
},
Builtin {
name: "WinMoveBottom",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: win_move_bottom,
},
Builtin {
name: "WinMoveTop",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: win_move_top,
},
Builtin {
name: "WinRedraw",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: win_redraw,
},
Builtin {
name: "WinRestore",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: win_restore,
},
Builtin {
name: "WinSetAlwaysOnTop",
kind: BuiltinKind::Command,
min: 0,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: win_set_always_on_top,
},
Builtin {
name: "WinSetEnabled",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: win_set_enabled,
},
Builtin {
name: "WinSetExStyle",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 1,
parameters: &[Parameter::Value],
handler: win_set_style,
},
Builtin {
name: "WinSetRegion",
kind: BuiltinKind::Command,
min: 0,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: win_set_region,
},
Builtin {
name: "WinSetStyle",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: win_set_style,
},
Builtin {
name: "WinSetTitle",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: win_set_title,
},
Builtin {
name: "WinSetTransColor",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: win_set_trans_color,
},
Builtin {
name: "WinSetTransparent",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: win_set_transparent,
},
Builtin {
name: "WinShow",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: win_show,
},
Builtin {
name: "WinWait",
kind: BuiltinKind::Command,
min: 0,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: win_wait,
},
Builtin {
name: "WinWaitActive",
kind: BuiltinKind::Command,
min: 0,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: win_wait_active,
},
Builtin {
name: "WinWaitClose",
kind: BuiltinKind::Command,
min: 0,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: win_wait_close,
},
Builtin {
name: "WinWaitNotActive",
kind: BuiltinKind::Command,
min: 0,
max: 5,
variant: 0,
parameters: &[Parameter::Value],
handler: win_wait_not_active,
},
Builtin {
name: "GetKeyState",
kind: BuiltinKind::Command,
min: 1,
max: 2,
variant: 1,
parameters: &[Parameter::Value],
handler: get_key_state,
},
Builtin {
name: "HotIf",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 1,
parameters: &[Parameter::Value],
handler: hotif,
},
Builtin {
name: "HotIfWinActive",
kind: BuiltinKind::Command,
min: 0,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: hotif_window,
},
Builtin {
name: "HotIfWinExist",
kind: BuiltinKind::Command,
min: 0,
max: 2,
variant: 1,
parameters: &[Parameter::Value],
handler: hotif_window,
},
Builtin {
name: "HotIfWinNotActive",
kind: BuiltinKind::Command,
min: 0,
max: 2,
variant: 2,
parameters: &[Parameter::Value],
handler: hotif_window,
},
Builtin {
name: "HotIfWinNotExist",
kind: BuiltinKind::Command,
min: 0,
max: 2,
variant: 3,
parameters: &[Parameter::Value],
handler: hotif_window,
},
Builtin {
name: "Hotkey",
kind: BuiltinKind::Command,
min: 1,
max: 3,
variant: 1,
parameters: &[Parameter::Value],
handler: hotkey,
},
Builtin {
name: "Hotstring",
kind: BuiltinKind::Command,
min: 1,
max: 3,
variant: 1,
parameters: &[Parameter::Value],
handler: hotstring,
},
Builtin {
name: "InstallKeybdHook",
kind: BuiltinKind::Command,
min: 0,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: install_hook,
},
Builtin {
name: "InstallMouseHook",
kind: BuiltinKind::Command,
min: 0,
max: 2,
variant: 1,
parameters: &[Parameter::Value],
handler: install_hook,
},
Builtin {
name: "KeyHistory",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 1,
parameters: &[Parameter::Value],
handler: key_history,
},
Builtin {
name: "ListHotkeys",
kind: BuiltinKind::Command,
min: 0,
max: 0,
variant: 1,
parameters: &[Parameter::Value],
handler: list_hotkeys,
},
Builtin {
name: "CoordMode",
kind: BuiltinKind::Command,
min: 1,
max: 2,
variant: 5,
parameters: &[Parameter::Value],
handler: coord_mode,
},
Builtin {
name: "Critical",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: critical,
},
Builtin {
name: "DateAdd",
kind: BuiltinKind::Command,
min: 3,
max: 3,
variant: 2,
parameters: &[Parameter::Value],
handler: date_add,
},
Builtin {
name: "DateDiff",
kind: BuiltinKind::Command,
min: 3,
max: 3,
variant: 2,
parameters: &[Parameter::Value],
handler: date_diff,
},
Builtin {
name: "DirCopy",
kind: BuiltinKind::Command,
min: 2,
max: 3,
variant: 4,
parameters: &[Parameter::Value],
handler: dir_copy,
},
Builtin {
name: "DirMove",
kind: BuiltinKind::Command,
min: 2,
max: 3,
variant: 4,
parameters: &[Parameter::Value],
handler: dir_move,
},
Builtin {
name: "DirSelect",
kind: BuiltinKind::Command,
min: 0,
max: 3,
variant: 0,
parameters: &[Parameter::Value],
handler: dir_select,
},
Builtin {
name: "Download",
kind: BuiltinKind::Command,
min: 2,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: download,
},
Builtin {
name: "FileCopy",
kind: BuiltinKind::Command,
min: 2,
max: 3,
variant: 6,
parameters: &[Parameter::Value],
handler: file_copy,
},
Builtin {
name: "FileEncoding",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 4,
parameters: &[Parameter::Value],
handler: file_encoding,
},
Builtin {
name: "FileGetAttrib",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 4,
parameters: &[Parameter::Value],
handler: file_get_attrib,
},
Builtin {
name: "FileGetSize",
kind: BuiltinKind::Command,
min: 0,
max: 2,
variant: 4,
parameters: &[Parameter::Value],
handler: file_get_size,
},
Builtin {
name: "FileGetTime",
kind: BuiltinKind::Command,
min: 0,
max: 2,
variant: 4,
parameters: &[Parameter::Value],
handler: file_get_time,
},
Builtin {
name: "FileInstall",
kind: BuiltinKind::Command,
min: 2,
max: 3,
variant: 4,
parameters: &[Parameter::Value],
handler: file_install,
},
Builtin {
name: "FileMove",
kind: BuiltinKind::Command,
min: 2,
max: 3,
variant: 6,
parameters: &[Parameter::Value],
handler: file_move,
},
Builtin {
name: "FileOpen",
kind: BuiltinKind::Function,
min: 2,
max: 3,
variant: 4,
parameters: &[Parameter::Value],
handler: file_open,
},
Builtin {
name: "FileSelect",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: file_select,
},
Builtin {
name: "FileSetAttrib",
kind: BuiltinKind::Command,
min: 1,
max: 3,
variant: 4,
parameters: &[Parameter::Value],
handler: file_set_attrib,
},
Builtin {
name: "FileSetTime",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 4,
parameters: &[Parameter::Value],
handler: file_set_time,
},
Builtin {
name: "FormatTime",
kind: BuiltinKind::Function,
min: 0,
max: 2,
variant: 2,
parameters: &[Parameter::Value],
handler: format_time,
},
Builtin {
name: "GetKeyName",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 5,
parameters: &[Parameter::Value],
handler: get_key_name,
},
Builtin {
name: "GetKeySC",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 5,
parameters: &[Parameter::Value],
handler: get_key_sc,
},
Builtin {
name: "GetKeyVK",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 5,
parameters: &[Parameter::Value],
handler: get_key_vk,
},
Builtin {
name: "ImageSearch",
kind: BuiltinKind::Command,
min: 7,
max: 7,
variant: 0,
parameters: &[
Parameter::Reference,
Parameter::Reference,
Parameter::Value,
Parameter::Value,
Parameter::Value,
Parameter::Value,
Parameter::Value,
],
handler: image_search,
},
Builtin {
name: "IniDelete",
kind: BuiltinKind::Command,
min: 2,
max: 3,
variant: 6,
parameters: &[Parameter::Value],
handler: ini_delete,
},
Builtin {
name: "IniRead",
kind: BuiltinKind::Command,
min: 1,
max: 4,
variant: 4,
parameters: &[Parameter::Value],
handler: ini_read,
},
Builtin {
name: "IniWrite",
kind: BuiltinKind::Command,
min: 3,
max: 4,
variant: 4,
parameters: &[Parameter::Value],
handler: ini_write,
},
Builtin {
name: "InputBox",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 0,
parameters: &[Parameter::Value],
handler: input_box,
},
Builtin {
name: "IsLabel",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: is_label,
},
Builtin {
name: "ListLines",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: list_lines,
},
Builtin {
name: "ListVars",
kind: BuiltinKind::Command,
min: 0,
max: 0,
variant: 0,
parameters: &[Parameter::Value],
handler: list_vars,
},
Builtin {
name: "LoadPicture",
kind: BuiltinKind::Command,
min: 1,
max: 3,
variant: 0,
parameters: &[Parameter::Value, Parameter::Value, Parameter::Reference],
handler: load_picture,
},
Builtin {
name: "MouseClick",
kind: BuiltinKind::Command,
min: 0,
max: 7,
variant: 0,
parameters: &[Parameter::Value],
handler: mouse_click,
},
Builtin {
name: "MouseClickDrag",
kind: BuiltinKind::Command,
min: 0,
max: 7,
variant: 0,
parameters: &[Parameter::Value],
handler: mouse_click_drag,
},
Builtin {
name: "OnError",
kind: BuiltinKind::Command,
min: 1,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: on_error,
},
Builtin {
name: "OnExit",
kind: BuiltinKind::Command,
min: 1,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: on_exit,
},
Builtin {
name: "Pause",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: pause,
},
Builtin {
name: "Persistent",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: persistent,
},
Builtin {
name: "Reload",
kind: BuiltinKind::Command,
min: 0,
max: 0,
variant: 0,
parameters: &[Parameter::Value],
handler: reload,
},
Builtin {
name: "SendEvent",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 5,
parameters: &[Parameter::Value],
handler: send_event,
},
Builtin {
name: "SendInput",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 5,
parameters: &[Parameter::Value],
handler: send_input,
},
Builtin {
name: "SendLevel",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 5,
parameters: &[Parameter::Value],
handler: send_level,
},
Builtin {
name: "SendPlay",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 5,
parameters: &[Parameter::Value],
handler: send_play,
},
Builtin {
name: "SendText",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 5,
parameters: &[Parameter::Value],
handler: send_text,
},
Builtin {
name: "SetDefaultMouseSpeed",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 5,
parameters: &[Parameter::Value],
handler: set_default_mouse_speed,
},
Builtin {
name: "SetMouseDelay",
kind: BuiltinKind::Command,
min: 1,
max: 2,
variant: 5,
parameters: &[Parameter::Value],
handler: set_mouse_delay,
},
Builtin {
name: "SetStoreCapsLockMode",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 5,
parameters: &[Parameter::Value],
handler: set_store_caps_lock_mode,
},
Builtin {
name: "SetWorkingDir",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: set_working_dir,
},
Builtin {
name: "StrTitle",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: str_title,
},
Builtin {
name: "Suspend",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 0,
parameters: &[Parameter::Value],
handler: suspend,
},
Builtin {
name: "Thread",
kind: BuiltinKind::Command,
min: 1,
max: 3,
variant: 0,
parameters: &[Parameter::Value],
handler: thread_command,
},
Builtin {
name: "VerCompare",
kind: BuiltinKind::Function,
min: 2,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: ver_compare,
},
];
pub(crate) fn com_obj_flags(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let first = values.first().cloned().unwrap_or(Value::Int(0));
if crate::classes::comvalue::the_flags_of_the_value(&first).is_none() {
return Err(RuntimeError {
message: crate::runtime::requires(1, "ComObjFlags", TypeName::ComValue, &first),
line,
});
}
if let Some(flags) = values.get(1) {
let flags = flags.to_number().unwrap_or(0.0) as i64;
crate::classes::comvalue::the_flags_are_written(&first, flags);
}
Ok(Value::Int(
crate::classes::comvalue::the_flags_of_the_value(&first).unwrap_or(0),
))
}
pub(crate) fn com_obj_value(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let first = values.first().cloned().unwrap_or(Value::Int(0));
match crate::classes::comvalue::the_number_of(&first) {
Some(number) => Ok(Value::Int(number)),
None => Err(RuntimeError {
message: crate::runtime::requires(1, "ComObjValue", TypeName::ComValue, &first),
line,
}),
}
}
pub(crate) fn com_obj_connect(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let first = values.first().cloned().unwrap_or(Value::Int(0));
let Some(pointer) = crate::classes::comvalue::the_number_of(&first) else {
return Err(RuntimeError {
message: crate::runtime::requires(1, "ComObjConnect", TypeName::ComValue, &first),
line,
});
};
let kind = crate::classes::comvalue::the_kind_of_the_value(&first).unwrap_or(0);
let prefix = values
.get(1)
.map(|prefix| prefix.to_text())
.unwrap_or_default();
if prefix.is_empty() && values.len() > 1 {
return Err(RuntimeError {
message: "Parameter #2 of ComObjConnect is invalid.".to_string(),
line,
});
}
let object = crate::desktop::ComObject {
pointer: pointer as u64,
kind,
};
rt.desktop()
.com_object_is_connected(&object, &prefix)
.map_err(|reason| desktop_failure(reason, line))?;
Ok(Value::Int(1))
}
const THE_REQUIRED: &[(&str, &[u8])] = &[
("ControlGetPos", &[5]),
("FileGetAttrib", &[1]),
("FileGetSize", &[1]),
("FileGetTime", &[1]),
("FileGetVersion", &[1]),
("FileSetTime", &[2]),
("ListViewGetContent", &[2]),
("MenuSelect", &[3]),
("MouseClickDrag", &[4, 5]),
];
pub fn required_parameters(name: &str) -> &'static [u8] {
THE_REQUIRED
.iter()
.find(|(command, _)| *command == name)
.map(|(_, numbers)| *numbers)
.unwrap_or(&[])
}
pub fn reference_parameters(name: &str) -> Vec<usize> {
find(name)
.map(|builtin| {
builtin
.parameters
.iter()
.enumerate()
.filter(|(_, shape)| **shape == Parameter::Reference)
.map(|(index, _)| index)
.collect()
})
.unwrap_or_default()
}
pub fn parameters_of(name: &str) -> &'static [Parameter] {
find(name).map(|builtin| builtin.parameters).unwrap_or(&[])
}
pub fn decides_references(name: &str) -> bool {
matches!(name, "DllCall")
}
pub fn find(name: &str) -> Option<&'static Builtin> {
let wanted = name.to_lowercase();
BUILTINS
.iter()
.find(|builtin| builtin.name.to_lowercase() == wanted)
}
pub fn the_extra_of(name: &str, message: &str, values: &[Value]) -> Option<String> {
if name == "SetTitleMatchMode" && message == "Parameter #1 of SetTitleMatchMode is invalid." {
return values.first().map(|value| value.to_text());
}
if matches!(
name,
"WinGetID" | "WinGetIDLast" | "WinGetClass" | "WinGetTitle"
) && message == "Target window not found."
{
return match values.first() {
Some(Value::Int(_)) | None => None,
Some(value) => Some(value.to_text()),
};
}
if message == "Target window not found." {
let index = match name {
"WinGetStyle" | "WinGetExStyle" | "WinGetTransColor" => 0,
"WinSetStyle" | "WinSetExStyle" | "WinSetTransColor" => 1,
"ControlGetStyle" | "ControlGetExStyle" => 1,
"ControlSetStyle" | "ControlSetExStyle" => 2,
_ => return None,
};
return match values.get(index) {
Some(Value::Int(_)) | None => None,
Some(value) => Some(value.to_text()),
};
}
if name == "ObjSetBase" && message.starts_with("Expected an Object but got") {
return values.get(1).map(crate::runtime::the_extra_of_the_value);
}
if name == "MouseClick" && message == "Parameter #1 of MouseClick is invalid." {
return values
.first()
.map(|value| value.to_text().trim_end().to_string());
}
if matches!(name, "FileCopy" | "FileMove") && message == "Failed" {
return Some("1".to_string());
}
if name == "StrPut"
&& message == "Parameter #2 of StrPut is invalid."
&& matches!(values.get(1), Some(Value::Object(_)))
{
return Some("Buffer".to_string());
}
if message != "Invalid option." {
return None;
}
match name {
"InputBox" => {
let options = values
.get(2)
.map(|value| value.to_text())
.unwrap_or_default();
crate::dialogs::the_option_that_failed(&options)
}
"FileRead" => {
let options = values
.get(1)
.map(|value| value.to_text())
.unwrap_or_default();
crate::files::the_option_that_failed(&options, true)
}
"FileAppend" => {
let options = values
.get(2)
.map(|value| value.to_text())
.unwrap_or_default();
crate::files::the_option_that_failed(&options, false)
}
_ => None,
}
}
pub fn find_command(name: &str) -> Option<&'static Builtin> {
find(name).filter(|builtin| builtin.kind == BuiltinKind::Command)
}
pub fn names() -> impl Iterator<Item = &'static str> {
BUILTINS.iter().map(|builtin| builtin.name)
}
#[cfg(feature = "std")]
fn the_native_call_with_the_callbacks<'a>(
rt: &mut Runtime<'a>,
call: &mut NativeCall,
at: Option<u64>,
) -> Result<crate::dll::NativeResult, crate::dll::NativeFailure> {
let desktop_ptr: *mut (dyn crate::desktop::Desktop + 'a) = rt.desktop();
let previous = crate::callback::set_current(rt);
let answer = unsafe {
match at {
Some(address) => (*desktop_ptr).call_native_at(address, call),
None => (*desktop_ptr).call_native(call),
}
};
crate::callback::clear_current(previous);
answer
}
pub(crate) fn dll_call(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
dll_call_with_the_kind(rt, values, line).map_err(|(_, error)| error)
}
pub(crate) fn dll_call_with_the_kind(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
) -> Result<Value, (NativeFailureKind, RuntimeError)> {
let Some(first) = values.first() else {
return Err((
NativeFailureKind::Invalid,
RuntimeError {
message: "DllCall wants the library and the function.".into(),
line,
},
));
};
let (library, function, at) = match first {
Value::Text(target) => {
let (library, function) = crate::dll::split_target(target);
(library, function, None)
}
Value::Int(number) if *number >= 65536 => {
(String::new(), String::new(), Some(*number as u64))
}
Value::Float(number) if *number >= 65536.0 => {
(String::new(), String::new(), Some(*number as u64))
}
_ => {
return Err((
NativeFailureKind::Invalid,
RuntimeError {
message: expected_type(TypeName::String, first.type_name()),
line,
},
));
}
};
let rest = &values[1..];
let (returns, convention, rest) = if rest.len() % 2 == 1 {
let last = rest.last().expect("there is one");
let Value::Text(text) = last else {
return Err((
NativeFailureKind::Invalid,
RuntimeError {
message: expected_type(TypeName::String, last.type_name()),
line,
},
));
};
let (convention, name) = split_convention(text);
let Some((kind, _)) = crate::dll::parse_type(name) else {
return Err((
NativeFailureKind::Invalid,
RuntimeError {
message: "Invalid return type.".into(),
line,
},
));
};
(kind, convention, &rest[..rest.len() - 1])
} else {
(NativeType::Int, Convention::Standard, rest)
};
let mut arguments = Vec::new();
let mut references = Vec::new();
let mut index = 0;
while index < rest.len() {
let Value::Text(text) = &rest[index] else {
return Err((
NativeFailureKind::Invalid,
RuntimeError {
message: expected_type(TypeName::String, rest[index].type_name()),
line,
},
));
};
let Some((kind, address)) = crate::dll::parse_type(text) else {
return Err((
NativeFailureKind::Invalid,
RuntimeError {
message: "Invalid arg type.".into(),
line,
},
));
};
let (argument, reference) = marshal(rt, kind, address, &rest[index + 1], line)
.map_err(|error| (NativeFailureKind::Invalid, error))?;
arguments.push(argument);
references.push(reference);
index += 2;
}
let mut call = NativeCall {
library,
function,
convention,
returns,
arguments,
};
#[cfg(feature = "std")]
let answer = the_native_call_with_the_callbacks(rt, &mut call, at);
#[cfg(not(feature = "std"))]
let answer = match at {
Some(address) => rt.desktop().call_native_at(address, &mut call),
None => rt.desktop().call_native(&mut call),
};
let answer = answer.map_err(|failure| {
(
failure.kind,
RuntimeError {
message: failure.reason,
line,
},
)
})?;
#[cfg(feature = "std")]
crate::classes::buffer::the_buffers_are_read_back();
for (argument, reference) in call.arguments.iter().zip(references) {
if !argument.address {
continue;
}
let Some(reference) = reference else { continue };
let NativeValue::Bytes(bytes) = &argument.value else {
continue;
};
let written = if argument.kind.is_text() {
Value::Text(crate::dll::decode(bytes, argument.kind))
} else if argument.kind.is_float() {
Value::Float(crate::dll::decode_number(bytes, argument.kind))
} else {
Value::Int(crate::dll::decode_number(bytes, argument.kind) as i64)
};
rt.write_reference(&reference, written);
}
Ok(match answer.value {
NativeValue::Integer(number) => Value::Int(number),
NativeValue::Float(number) => Value::Float(number),
NativeValue::Bytes(bytes) => Value::Text(crate::dll::decode(&bytes, answer.kind)),
})
}
fn marshal(
rt: &mut Runtime<'_>,
kind: NativeType,
address: bool,
value: &Value,
line: u32,
) -> Result<(NativeArg, Option<Value>), RuntimeError> {
let (value, reference) = match value {
Value::Reference(reference) => {
let Some(current) = rt.read_reference(reference) else {
return Err(RuntimeError {
message: rt.the_unassigned(&reference.name),
line,
});
};
(current, Some(value.clone()))
}
other => (other.clone(), None),
};
if kind.is_text() {
let Value::Text(text) = &value else {
return Err(RuntimeError {
message: expected_type(TypeName::String, value.type_name()),
line,
});
};
let bytes = crate::dll::encode(text, kind);
return Ok((
NativeArg {
kind,
address,
value: NativeValue::Bytes(bytes),
},
reference,
));
}
if matches!(kind, NativeType::Ptr | NativeType::UPtr) {
if let Value::Object(_) = &value {
if let Some(place) = rt.property_of(&value, "ptr", line) {
let place = place.to_number_strict().map_err(|got| RuntimeError {
message: expected_type(TypeName::Integer, got),
line,
})?;
return Ok((
NativeArg {
kind,
address,
value: NativeValue::Integer(place as i64),
},
reference,
));
}
}
}
let number = native_number(rt, &value, line)?;
let value = if kind.is_float() {
NativeValue::Float(number)
} else {
NativeValue::Integer(number as i64)
};
Ok((
NativeArg {
kind,
address,
value,
},
reference,
))
}
fn native_number(rt: &Runtime<'_>, value: &Value, line: u32) -> Result<f64, RuntimeError> {
match rt.number(value, line) {
Ok(number) => Ok(number),
Err(RuntimeFailure::Error(error)) => Err(error),
Err(RuntimeFailure::Detailed(error, _)) => Err(error),
Err(RuntimeFailure::Fatal(error)) => Err(error),
Err(RuntimeFailure::Timeout(_)) => Err(RuntimeError {
message: "the script ran out of time.".into(),
line,
}),
Err(RuntimeFailure::Flow(_)) => Err(RuntimeError {
message: "a number was expected.".into(),
line,
}),
Err(RuntimeFailure::Thrown(_)) => Err(RuntimeError {
message: "a number was expected.".into(),
line,
}),
}
}
fn split_convention(text: &str) -> (Convention, &str) {
let trimmed = text.trim();
let (head, tail) = match trimmed.split_once(char::is_whitespace) {
Some((head, tail)) => (head, tail.trim()),
None => (trimmed, ""),
};
if head.eq_ignore_ascii_case("cdecl") {
return (Convention::Cdecl, tail);
}
if head.eq_ignore_ascii_case("stdcall") {
return (Convention::Standard, tail);
}
(Convention::Standard, trimmed)
}
pub const REFUSAL: u8 = 100;
pub fn refusal_of(name: &str) -> Option<&'static str> {
find(name).and_then(refusal_of_the)
}
pub fn refusal_of_the(builtin: &Builtin) -> Option<&'static str> {
if builtin.variant < REFUSAL {
return None;
}
Some(refusal_message(builtin.variant - REFUSAL))
}
fn refusal_message(variant: u8) -> &'static str {
match variant {
0 => "this is a name of Windows, and this desktop is not Windows.",
1 => "this runtime has no hotkeys yet.",
2 => {
"the clock of this runtime counts from an arbitrary origin, and it does not know the date."
}
3 => "this runtime is one script that ends when it ends, and it cannot do that.",
4 => "this desktop cannot serve that with the files it has.",
5 => {
"the pointer and the keyboard of this runtime are the ones of the box, and they have no setting of that kind."
}
6 => "a method of this runtime is not bound to an object.",
8 => "this runtime runs one script in one thread, and it cannot make it critical.",
9 => "this runtime runs one script in one thread, and it cannot start another.",
10 => "this runtime cannot wait for a key to continue: the script ends when it ends.",
11 => "this runtime is a script that ends when it ends, and it cannot be kept alive.",
12 => "this runtime runs one script once, and it cannot run itself again.",
13 => "this runtime cannot stop itself: it would never end.",
14 => {
"the lines are listed in a window of v2, and this runtime has no window to show them in."
}
15 => {
"the variables are listed in a window of v2, and this runtime has no window to show them in."
}
16 => {
"the question of the user is asked in a window of v2, and this runtime has no window to ask in."
}
17 => "the download is made by the desktop, and this desktop does not reach the network.",
18 => {
"the picture is read by the desktop, and this desktop does not read the images of the machine."
}
19 => {
"the search of a picture is made by the desktop, and this desktop does not read the images of the machine."
}
21 => crate::settings::NO_TEXT_OF_A_WINDOW,
23 => "the registry is a thing of Windows, and this runtime does not carry it.",
_ => crate::dialect::NOT_CARRIED_YET,
}
}
#[allow(dead_code)]
pub(crate) fn not_carried(
_rt: &mut Runtime<'_>,
_values: &[Value],
line: u32,
variant: u8,
) -> Result<Value, RuntimeError> {
let message = refusal_message(variant.saturating_sub(REFUSAL));
Err(RuntimeError {
message: message.to_string(),
line,
})
}
pub(crate) fn env_get(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let name = text_of(values, 0);
let value = rt
.desktop()
.env_get(&name)
.map_err(|reason| RuntimeError {
message: reason,
line,
})?
.unwrap_or_default();
Ok(Value::Text(value))
}
pub(crate) fn env_set(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let name = text_of(values, 0);
let value = text_of(values, 1);
rt.desktop()
.env_set(&name, &value)
.map_err(|reason| RuntimeError {
message: reason,
line,
})?;
Ok(Value::Text(value))
}
pub(crate) fn file_exist(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let pattern = text_of(values, 0);
let attributes = rt
.desktop()
.attributes_of_the_pattern(&pattern, "")
.map_err(|reason| RuntimeError {
message: reason,
line,
})?;
Ok(Value::Text(attributes.concat()))
}
pub(crate) fn dir_exist(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let pattern = text_of(values, 0);
let attributes = rt
.desktop()
.attributes_of_the_pattern(&pattern, "D")
.map_err(|reason| RuntimeError {
message: reason,
line,
})?;
Ok(Value::Text(attributes.concat()))
}
pub(crate) fn file_delete(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let path = crate::files::the_name_of_a_file(values, 0, 1, "FileDelete", line)?;
let files = if crate::files::is_a_pattern(&path) {
crate::files::the_files_of_the_pattern(rt, &path, line)?
} else {
vec![path]
};
for file in files {
rt.desktop()
.delete_file(&file)
.map_err(|reason| RuntimeError {
message: reason,
line,
})?;
}
Ok(Value::Text(String::new()))
}
pub(crate) fn dir_create(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let path = text_of(values, 0);
rt.desktop()
.create_dir(&path)
.map_err(|reason| RuntimeError {
message: reason,
line,
})?;
Ok(Value::Text(String::new()))
}
pub(crate) fn dir_delete(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let path = text_of(values, 0);
let recurse = crate::files::flag_of(values, 1, "DirDelete", line)?;
rt.desktop()
.dir_delete(&path, recurse)
.map_err(|reason| RuntimeError {
message: if rt.dialect().is_the_v1() {
reason
} else {
"Failed".to_string()
},
line,
})?;
Ok(Value::Text(String::new()))
}
pub(crate) fn file_create_shortcut(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let target = text_of(values, 0);
let shortcut = text_of(values, 1);
let working_directory = text_of(values, 2);
let arguments = text_of(values, 3);
let description = text_of(values, 4);
let icon = text_of(values, 5);
rt.desktop()
.create_shortcut(
&target,
&shortcut,
&working_directory,
&arguments,
&description,
&icon,
)
.map_err(|reason| desktop_failure(reason, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn file_get_shortcut(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let shortcut = text_of(values, 0);
let (target, dir, args, desc, icon) = rt
.desktop()
.read_shortcut(&shortcut)
.map_err(|reason| desktop_failure(reason, line))?;
let places: [(&str, Value); 7] = [
("target", Value::Text(target)),
("dir", Value::Text(dir)),
("args", Value::Text(args)),
("desc", Value::Text(desc)),
("icon", Value::Text(icon)),
("iconnum", Value::Text(String::new())),
("run", Value::Text(String::new())),
];
for (index, (name, value)) in places.iter().enumerate() {
let at = index + 1;
let Some(slot) = values.get(at) else {
continue;
};
if !matches!(slot, Value::Reference(_)) {
return Err(RuntimeError {
message: format!(
"the {} of FileGetShortcut is written back, so parameter #{} wants a variable",
name,
at + 1
),
line,
});
}
rt.write_reference(slot, value.clone());
}
Ok(Value::Text(String::new()))
}
pub(crate) fn str_split(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let text = text_of(values, 0);
let delimiters = the_delimiters(rt, values.get(1), line)?;
let omit = text_of(values, 2);
let max = match values.get(3) {
None => -1.0,
Some(value) => value.to_number().unwrap_or(-1.0),
};
let pieces = the_pieces(&text, &delimiters, &omit, max);
let values: Vec<Value> = pieces.into_iter().map(Value::Text).collect();
match crate::classes::construct("array", &values, rt, line) {
Some(result) => result.map_err(|failure| crate::runtime::as_error(failure, line)),
None => Ok(Value::List(values)),
}
}
fn the_delimiters(
rt: &Runtime<'_>,
value: Option<&Value>,
line: u32,
) -> Result<Vec<String>, RuntimeError> {
let invalid = || RuntimeError {
message: "Parameter #2 of StrSplit is invalid.".into(),
line,
};
match value {
None => Ok(Vec::new()),
Some(Value::List(items)) => {
if items.is_empty() {
return Err(invalid());
}
Ok(items.iter().map(|item| item.to_text()).collect())
}
Some(value) => {
if rt.class_of(value).as_deref() == Some("Array") {
let items = crate::classes::array::the_items(value);
if items.is_empty() {
return Err(invalid());
}
return items
.iter()
.map(|item| match item {
Value::Text(text) => Ok(text.clone()),
other => Err(RuntimeError {
message: crate::runtime::requires(
2,
"StrSplit",
TypeName::String,
other,
),
line,
}),
})
.collect::<Result<Vec<String>, RuntimeError>>();
}
if matches!(value, Value::Object(_)) {
return Err(invalid());
}
let text = value.to_text();
if text.is_empty() {
return Ok(Vec::new());
}
Ok(vec![text])
}
}
}
fn the_pieces(text: &str, delimiters: &[String], omit: &str, max: f64) -> Vec<String> {
if delimiters.is_empty() {
return text
.chars()
.filter(|character| !omit.contains(*character))
.map(|character| character.to_string())
.collect();
}
if max == 0.0 {
return Vec::new();
}
if text.is_empty() {
return Vec::new();
}
let cuts = if max > 0.0 { max as usize - 1 } else { 0 };
let mut pieces: Vec<String> = Vec::new();
let mut rest = text;
let mut made = 0;
while let Some((at, length)) = the_first_delimiter(rest, delimiters) {
if max > 0.0 && made >= cuts {
pieces.push(trim_the_omit(rest, omit));
return pieces;
}
pieces.push(trim_the_omit(&rest[..at], omit));
rest = &rest[at + length..];
made += 1;
}
pieces.push(trim_the_omit(rest, omit));
pieces
}
fn the_first_delimiter(text: &str, delimiters: &[String]) -> Option<(usize, usize)> {
let mut found: Option<(usize, usize)> = None;
for delimiter in delimiters {
if delimiter.is_empty() {
continue;
}
let Some(at) = text.find(delimiter.as_str()) else {
continue;
};
match found {
Some((first, _)) if first <= at => continue,
_ => found = Some((at, delimiter.len())),
}
}
found
}
fn trim_the_omit(text: &str, omit: &str) -> String {
if omit.is_empty() {
return text.to_string();
}
let mut start = 0;
while start < text.len() {
let Some(character) = text[start..].chars().next() else {
break;
};
if !omit.contains(character) {
break;
}
start += character.len_utf8();
}
let mut end = text.len();
while end > start {
let Some(character) = text[..end].chars().next_back() else {
break;
};
if !omit.contains(character) {
break;
}
end -= character.len_utf8();
}
text[start..end].to_string()
}
pub(crate) fn split_path(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let path = text_argument("SplitPath", values, 0, line)?;
let pieces = split_the_path(&path);
for (index, piece) in pieces.into_iter().enumerate() {
let Some(value) = values.get(index + 1) else {
continue;
};
if !matches!(value, Value::Reference(_)) {
return Err(RuntimeError {
message: crate::runtime::wants_a_reference(
index + 2,
"SplitPath",
"a variable reference",
value,
),
line,
});
}
rt.write_reference(value, Value::Text(piece));
}
Ok(Value::Text(String::new()))
}
pub(crate) fn split_the_path(path: &str) -> [String; 5] {
if let Some(at) = path.find("://") {
let scheme = &path[..at];
let rest = &path[at + 3..];
let host_end = rest.find('/').unwrap_or(rest.len());
let drive = format!("{scheme}://{}", &rest[..host_end]);
let tail = &rest[host_end..];
let separator = tail.rfind('/');
let name = match separator {
Some(at) => tail[at + 1..].to_string(),
None => tail.to_string(),
};
let directory = match separator {
Some(at) => format!("{drive}{}", &tail[..at]),
None => drive.clone(),
};
let (stem, extension) = the_extension(&name);
return [name, directory, extension, stem, drive];
}
let (drive, rest) = if let Some(rest) = path.strip_prefix("\\\\") {
let end = rest.find('\\').unwrap_or(rest.len());
(format!("\\\\{}", &rest[..end]), &rest[end..])
} else if path.len() >= 2 && path.as_bytes()[1] == b':' {
(path[..2].to_string(), &path[2..])
} else {
(String::new(), path)
};
let separator = rest.rfind('\\');
let name = match separator {
Some(at) => rest[at + 1..].to_string(),
None => rest.to_string(),
};
let directory = match separator {
Some(at) => format!("{drive}{}", &rest[..at]),
None => drive.clone(),
};
let (stem, extension) = the_extension(&name);
[name, directory, extension, stem, drive]
}
fn the_extension(name: &str) -> (String, String) {
match name.rfind('.') {
Some(at) if at > 0 => (name[..at].to_string(), name[at + 1..].to_string()),
_ => (name.to_string(), String::new()),
}
}
fn text_argument(
name: &str,
values: &[Value],
index: usize,
line: u32,
) -> Result<String, RuntimeError> {
match values.get(index) {
None => Ok(String::new()),
Some(Value::Unset) => Ok(String::new()),
Some(Value::Reference(_)) => Err(RuntimeError {
message: format!(
"Parameter #{} of {} requires a String, but received a VarRef.",
index + 1,
name
),
line,
}),
Some(value) => Ok(value.to_text()),
}
}
pub(crate) fn obj_bind_method(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let object = values
.first()
.cloned()
.unwrap_or(Value::Text(String::new()));
if !matches!(object, Value::Object(_)) {
return Err(RuntimeError {
message: crate::runtime::requires(1, "ObjBindMethod", TypeName::Object, &object),
line,
});
}
let method = text_of(values, 1);
Ok(rt.bound_function(object, Value::Text(method)))
}
pub(crate) fn has_prop(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let target = values
.first()
.cloned()
.unwrap_or(Value::Text(String::new()));
let name = text_of(values, 1);
if !matches!(target, Value::Object(_)) {
return Ok(Value::Int(if name.eq_ignore_ascii_case("__class") {
1
} else {
0
}));
}
if rt.class_name_of(&target).is_some() {
return rt.base_object(&target, "hasprop", &[Value::Text(name)], line);
}
rt.own_method(&target, "hasprop", &[Value::Text(name)], line)
}
pub(crate) fn has_method(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let target = values
.first()
.cloned()
.unwrap_or(Value::Text(String::new()));
let name = text_of(values, 1);
let count = values.get(2).map(|value| value.to_number().unwrap_or(0.0));
let mut arguments = Vec::new();
if values.len() > 1 {
arguments.push(Value::Text(name));
}
if let Some(count) = count {
arguments.push(Value::Int(count as i64));
}
if !matches!(target, Value::Object(_)) {
return Ok(Value::Int(0));
}
if rt.class_name_of(&target).is_some() {
return rt.base_object(&target, "hasmethod", &arguments, line);
}
rt.own_method(&target, "hasmethod", &arguments, line)
}
pub(crate) fn get_method(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let target = values
.first()
.cloned()
.unwrap_or(Value::Text(String::new()));
let name = text_of(values, 1);
let count = values.get(2).map(|value| value.to_number().unwrap_or(0.0));
let mut arguments = vec![Value::Text(name)];
if let Some(count) = count {
arguments.push(Value::Int(count as i64));
}
rt.own_method(&target, "getmethod", &arguments, line)
}
pub(crate) fn has_base(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let target = values
.first()
.cloned()
.unwrap_or(Value::Text(String::new()));
let base = values.get(1).cloned().unwrap_or(Value::Text(String::new()));
if !matches!(base, Value::Object(_)) {
return Err(RuntimeError {
message: format!(
"Expected an object but got {}.",
crate::runtime::the_kind_of(&base)
),
line,
});
}
if !matches!(target, Value::Object(_)) {
return Ok(Value::Int(0));
}
rt.own_method(&target, "hasbase", &[base], line)
}
pub(crate) fn is_set_ref(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let Some(value) = values.first() else {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, "IsSetRef"),
line,
});
};
let Value::Reference(reference) = value else {
return Err(RuntimeError {
message: crate::runtime::wants_a_reference(
1,
"IsSetRef",
"a variable reference",
value,
),
line,
});
};
Ok(Value::Int(rt.read_reference(reference).is_some() as i64))
}
pub(crate) fn send_mode(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let mode = text_of(values, 0).to_lowercase();
match mode.as_str() {
"input" | "event" | "play" => {
rt.note("the keys go through the keyboard of the box, one at a time");
Ok(Value::Text("Input".to_string()))
}
_ => Err(RuntimeError {
message: "Parameter #1 of SendMode is invalid.".into(),
line,
}),
}
}
pub(crate) fn key_wait(
_rt: &mut Runtime<'_>,
_values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
Err(RuntimeError {
message: "this runtime does not keep the keys that are down, so it cannot wait for one."
.into(),
line,
})
}
pub(crate) fn set_timer(
rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let priority = number_of(values, 2) as i64;
let name = the_name_of_the_timer(&values[0]);
let period = number_of(values, 1);
let period = if period > 0.0 { period as u64 } else { 250 };
rt.add_timer(&name, period, priority);
Ok(Value::Int(1))
}
fn the_name_of_the_timer(value: &Value) -> String {
if let Value::Object(object) = value {
let object = object.borrow();
if object.class == "func" {
let name = object
.value_of("name")
.map(|name| name.to_text())
.unwrap_or_default();
if !name.is_empty() {
return name;
}
}
}
value.to_text()
}
pub(crate) fn sound_beep(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let frequency = match values.first() {
Some(value) => value.to_number().unwrap_or(523.0),
None => 523.0,
};
if !(37.0..=32767.0).contains(&frequency) {
return Err(RuntimeError {
message: "the frequency of a tone is between 37 and 32767.".into(),
line,
});
}
let duration = match values.get(1) {
Some(value) => value.to_number().unwrap_or(150.0),
None => 150.0,
};
let duration = if duration > 0.0 { duration as u64 } else { 150 };
rt.desktop()
.sound_beep(frequency, duration)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Int(1))
}
pub(crate) fn sound_play(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let path = text_of(values, 0);
if path.is_empty() {
return Err(RuntimeError {
message: "the sound file is missing.".into(),
line,
});
}
rt.desktop()
.sound_play(&path)
.map_err(|_| RuntimeError {
message: "Failed".into(),
line,
})?;
Ok(Value::Int(1))
}
pub(crate) fn sound_get_volume(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let component = component_of(values, 0).map_err(|message| RuntimeError { message, line })?;
let device = device_of(values, 1);
let volume = rt
.desktop()
.sound_volume(&device, &component)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Float(volume))
}
pub(crate) fn sound_set_volume(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let setting = text_of(values, 0);
let (adjust, number) = match setting.strip_prefix('+') {
Some(rest) => (true, rest.to_string()),
None => match setting.strip_prefix('-') {
Some(rest) => (true, format!("-{rest}")),
None => (false, setting.clone()),
},
};
let number: f64 = number.trim().parse().map_err(|_| RuntimeError {
message: format!(
"the volume of a device is a percentage between -100 and 100, and {setting:?} is not one."
),
line,
})?;
if !(-100.0..=100.0).contains(&number) {
return Err(RuntimeError {
message: "the volume of a device is a percentage between -100 and 100.".into(),
line,
});
}
let component = component_of(values, 1).map_err(|message| RuntimeError { message, line })?;
let device = device_of(values, 2);
if adjust {
let current = rt
.desktop()
.sound_volume(&device, &component)
.map_err(|e| desktop_failure(e, line))?;
let wanted = (current + number).clamp(0.0, 100.0);
rt.desktop()
.sound_set_volume(&device, &component, wanted)
.map_err(|e| desktop_failure(e, line))?;
} else {
rt.desktop()
.sound_set_volume(&device, &component, number)
.map_err(|e| desktop_failure(e, line))?;
}
Ok(Value::Int(1))
}
pub(crate) fn sound_get_mute(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let component = component_of(values, 0).map_err(|message| RuntimeError { message, line })?;
let device = device_of(values, 1);
let muted = rt
.desktop()
.sound_muted(&device, &component)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Int(muted as i64))
}
pub(crate) fn sound_set_mute(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let setting = number_of(values, 0);
if !(-1.0..=1.0).contains(&setting) {
return Err(RuntimeError {
message: "the mute of a device is 1, 0 or -1.".into(),
line,
});
}
let component = component_of(values, 1).map_err(|message| RuntimeError { message, line })?;
let device = device_of(values, 2);
let muted = if setting < 0.0 {
let current = rt
.desktop()
.sound_muted(&device, &component)
.map_err(|e| desktop_failure(e, line))?;
!current
} else {
setting != 0.0
};
rt.desktop()
.sound_set_muted(&device, &component, muted)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Int(1))
}
fn component_of(values: &[Value], index: usize) -> Result<String, String> {
let component = match values.get(index) {
Some(value) => value.to_text(),
None => return Ok(String::new()),
};
if component.is_empty() {
return Ok(String::new());
}
Ok(component)
}
fn device_of(values: &[Value], index: usize) -> String {
match values.get(index) {
Some(Value::Int(number)) => number.to_string(),
Some(value) => value.to_text(),
None => String::new(),
}
}
fn the_on_or_off_of_a_command(
values: &[Value],
name: &str,
line: u32,
) -> Result<Option<bool>, RuntimeError> {
let Some(value) = values.first() else {
return Ok(None);
};
match token_to_int64(value) {
1 => Ok(Some(true)),
0 => Ok(Some(false)),
-1 => Ok(None),
_ => Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, name),
line,
}),
}
}
pub(crate) fn suspend(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
match the_on_or_off_of_a_command(values, "Suspend", line)? {
Some(suspended) => rt.set_suspended(suspended),
None => {
let now = rt.is_suspended();
rt.set_suspended(!now);
}
}
Ok(Value::Text(String::new()))
}
pub(crate) fn pause(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
match the_on_or_off_of_a_command(values, "Pause", line)? {
Some(paused) => rt.set_paused(paused),
None => {
let now = rt.is_paused();
rt.set_paused(!now);
}
}
Ok(Value::Text(String::new()))
}
pub(crate) fn exit_script(
rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let code = number_of(values, 0) as i32;
rt.exit_with(code);
Ok(Value::Int(code as i64))
}
pub(crate) fn on_exit(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let callback = rt.the_callback(values.first(), "OnExit", line)?;
match the_order(values.get(1), "OnExit", line)? {
1 => rt.set_exit_callback(&callback.name, line),
-1 => {
rt.set_exit_callback(&callback.name, line);
rt.order_exit_callback(&callback.name, true);
}
0 => rt.remove_exit_callback(&callback.name),
_ => {
return Err(RuntimeError {
message: format!(
"{}\n Specifically: {}",
crate::runtime::invalid_parameter(2, "OnExit"),
values
.get(1)
.map(|value| value.to_text())
.unwrap_or_default()
),
line,
});
}
}
Ok(Value::Int(1))
}
pub(crate) fn on_error(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let callback = rt.the_callback(values.first(), "OnError", line)?;
match the_order(values.get(1), "OnError", line)? {
1 => rt.set_error_callback(&callback.name, line),
-1 => {
rt.set_error_callback(&callback.name, line);
rt.order_error_callback(&callback.name, true);
}
0 => rt.remove_error_callback(&callback.name),
_ => {
return Err(RuntimeError {
message: format!(
"{}\n Specifically: {}",
crate::runtime::invalid_parameter(2, "OnError"),
values
.get(1)
.map(|value| value.to_text())
.unwrap_or_default()
),
line,
});
}
}
Ok(Value::Int(1))
}
fn the_order(value: Option<&Value>, name: &str, line: u32) -> Result<i32, RuntimeError> {
let Some(value) = value else { return Ok(1) };
let number = value.to_number_strict().map_err(|_| RuntimeError {
message: crate::runtime::wants_a_reference(2, name, "a Number", value),
line,
})?;
Ok(number as i32)
}
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum Wants {
Declared(TypeName),
Checked(TypeName),
Reference(&'static str),
Value,
}
const THE_TEXTS: &[(&str, &[u8])] = &[
("CoordMode", &[0, 1]),
("DateAdd", &[0, 2]),
("DateDiff", &[0, 1, 2]),
("DirCopy", &[0, 1]),
("DirCreate", &[0]),
("DirDelete", &[0]),
("DirExist", &[0]),
("DirMove", &[0, 1]),
("DirSelect", &[0, 2]),
("Download", &[0, 1]),
("EnvGet", &[0]),
("EnvSet", &[0, 1]),
("FileAppend", &[1, 2]),
("FileCopy", &[0, 1]),
("FileDelete", &[0]),
("FileEncoding", &[0]),
("FileExist", &[0]),
("FileGetAttrib", &[0]),
("FileGetSize", &[0, 1]),
("FileGetTime", &[0, 1]),
("FileInstall", &[0, 1]),
("FileMove", &[0, 1]),
("FileRead", &[0, 1]),
("FileSelect", &[0, 1, 2, 3]),
("FileSetAttrib", &[0, 1]),
("FileSetTime", &[0, 1, 2]),
("Format", &[0]),
("FormatTime", &[0, 1]),
("GetKeyName", &[0]),
("GetKeySC", &[0]),
("GetKeyState", &[0, 1]),
("GetKeyVK", &[0]),
("HotIfWinActive", &[0]),
("HotIfWinExist", &[0]),
("HotIfWinNotActive", &[0]),
("HotIfWinNotExist", &[0]),
("Hotkey", &[0, 2]),
("Hotstring", &[0, 2]),
("InStr", &[0, 1]),
("IniDelete", &[0, 1, 2]),
("IniRead", &[0, 1, 2, 3]),
("IniWrite", &[0, 1, 2, 3]),
("InputBox", &[0, 1, 2, 3]),
("IsAlnum", &[0, 1]),
("IsAlpha", &[0, 1]),
("IsDigit", &[0]),
("IsLabel", &[0]),
("IsLower", &[0, 1]),
("IsSpace", &[0]),
("IsTime", &[0]),
("IsUpper", &[0, 1]),
("IsXDigit", &[0]),
("KeyWait", &[0, 1]),
("LTrim", &[0, 1]),
("LoadPicture", &[0, 1]),
("MouseClick", &[0]),
("MouseClickDrag", &[0]),
("MouseMove", &[3]),
("MsgBox", &[0, 1, 2]),
("Ord", &[0]),
("RTrim", &[0, 1]),
("RegExMatch", &[0, 1]),
("RegExReplace", &[0, 1]),
("Run", &[0, 1, 2]),
("RunWait", &[0, 1, 2]),
("Send", &[0]),
("SendEvent", &[0]),
("SendInput", &[0]),
("SendMode", &[0]),
("SendPlay", &[0]),
("SendText", &[0]),
("SetKeyDelay", &[2]),
("SetMouseDelay", &[1]),
("SetWorkingDir", &[0]),
("Sort", &[0, 1]),
("SoundGetMute", &[0, 1]),
("SoundGetVolume", &[0, 1]),
("SoundPlay", &[0]),
("SoundSetMute", &[1, 2]),
("SoundSetVolume", &[1, 2]),
("SplitPath", &[0]),
("StrCompare", &[0, 1]),
("StrLen", &[0]),
("StrLower", &[0]),
("StrReplace", &[0, 1]),
("StrSplit", &[0, 2]),
("StrTitle", &[0]),
("StrUpper", &[0]),
("SubStr", &[0]),
("Trim", &[0, 1]),
("VerCompare", &[0, 1]),
("WinGetTitle", &[1, 2, 3]),
];
const THE_NUMBERS: &[(&str, &[u8])] = &[
("ACos", &[0]),
("ASin", &[0]),
("ATan", &[0]),
("Abs", &[0]),
("Ceil", &[0]),
("Chr", &[0]),
("ClipWait", &[0, 1]),
("Cos", &[0]),
("DateAdd", &[1]),
("DirSelect", &[1]),
("Exit", &[0]),
("ExitApp", &[0]),
("Exp", &[0]),
("FileCopy", &[2]),
("FileInstall", &[2]),
("FileMove", &[2]),
("Floor", &[0]),
("InStr", &[3, 4]),
("KeyHistory", &[0]),
("Ln", &[0]),
("Log", &[0]),
("MouseClick", &[1, 2, 3, 4]),
("MouseClickDrag", &[1, 2, 3, 4]),
("MouseMove", &[0, 1, 2]),
("PixelGetColor", &[0, 1]),
("Random", &[0, 1]),
("Round", &[0, 1]),
("SendLevel", &[0]),
("SetDefaultMouseSpeed", &[0]),
("SetKeyDelay", &[0, 1]),
("SetMouseDelay", &[0]),
("Sin", &[0]),
("Sleep", &[0]),
("SoundBeep", &[0, 1]),
("Sqrt", &[0]),
("StrSplit", &[3]),
("SubStr", &[1, 2]),
("Tan", &[0]),
];
const THE_REFUSED: &[(&str, usize, Wants)] = &[
("BlockInput", 0, Wants::Declared(TypeName::String)),
("CallbackFree", 0, Wants::Declared(TypeName::Number)),
("CaretGetPos", 0, Wants::Reference("a variable reference")),
("CaretGetPos", 1, Wants::Reference("a variable reference")),
("ComCall", 0, Wants::Declared(TypeName::Integer)),
("ComObjFlags", 0, Wants::Declared(TypeName::ComValue)),
("ComObjFromPtr", 0, Wants::Declared(TypeName::Number)),
("ComObjValue", 0, Wants::Declared(TypeName::ComValue)),
("ControlAddItem", 0, Wants::Declared(TypeName::String)),
("ControlAddItem", 3, Wants::Declared(TypeName::String)),
("ControlAddItem", 4, Wants::Declared(TypeName::String)),
("ControlAddItem", 5, Wants::Declared(TypeName::String)),
("ControlChooseIndex", 0, Wants::Declared(TypeName::Number)),
("ControlChooseIndex", 3, Wants::Declared(TypeName::String)),
("ControlChooseIndex", 4, Wants::Declared(TypeName::String)),
("ControlChooseIndex", 5, Wants::Declared(TypeName::String)),
("ControlChooseString", 0, Wants::Declared(TypeName::String)),
("ControlChooseString", 3, Wants::Declared(TypeName::String)),
("ControlChooseString", 4, Wants::Declared(TypeName::String)),
("ControlChooseString", 5, Wants::Declared(TypeName::String)),
("ControlClick", 2, Wants::Declared(TypeName::String)),
("ControlClick", 3, Wants::Declared(TypeName::String)),
("ControlClick", 4, Wants::Declared(TypeName::Number)),
("ControlClick", 5, Wants::Declared(TypeName::String)),
("ControlClick", 6, Wants::Declared(TypeName::String)),
("ControlClick", 7, Wants::Declared(TypeName::String)),
("ControlDeleteItem", 0, Wants::Declared(TypeName::Number)),
("ControlDeleteItem", 3, Wants::Declared(TypeName::String)),
("ControlDeleteItem", 4, Wants::Declared(TypeName::String)),
("ControlDeleteItem", 5, Wants::Declared(TypeName::String)),
("ControlFindItem", 0, Wants::Declared(TypeName::String)),
("ControlFindItem", 3, Wants::Declared(TypeName::String)),
("ControlFindItem", 4, Wants::Declared(TypeName::String)),
("ControlFindItem", 5, Wants::Declared(TypeName::String)),
("ControlFocus", 2, Wants::Declared(TypeName::String)),
("ControlFocus", 3, Wants::Declared(TypeName::String)),
("ControlFocus", 4, Wants::Declared(TypeName::String)),
("ControlGetChecked", 2, Wants::Declared(TypeName::String)),
("ControlGetChecked", 3, Wants::Declared(TypeName::String)),
("ControlGetChecked", 4, Wants::Declared(TypeName::String)),
("ControlGetChoice", 2, Wants::Declared(TypeName::String)),
("ControlGetChoice", 3, Wants::Declared(TypeName::String)),
("ControlGetChoice", 4, Wants::Declared(TypeName::String)),
("ControlGetClassNN", 2, Wants::Declared(TypeName::String)),
("ControlGetClassNN", 3, Wants::Declared(TypeName::String)),
("ControlGetClassNN", 4, Wants::Declared(TypeName::String)),
("ControlGetEnabled", 2, Wants::Declared(TypeName::String)),
("ControlGetEnabled", 3, Wants::Declared(TypeName::String)),
("ControlGetEnabled", 4, Wants::Declared(TypeName::String)),
("ControlGetExStyle", 2, Wants::Declared(TypeName::String)),
("ControlGetExStyle", 3, Wants::Declared(TypeName::String)),
("ControlGetExStyle", 4, Wants::Declared(TypeName::String)),
("ControlGetFocus", 1, Wants::Declared(TypeName::String)),
("ControlGetFocus", 2, Wants::Declared(TypeName::String)),
("ControlGetFocus", 3, Wants::Declared(TypeName::String)),
("ControlGetHwnd", 2, Wants::Declared(TypeName::String)),
("ControlGetHwnd", 3, Wants::Declared(TypeName::String)),
("ControlGetHwnd", 4, Wants::Declared(TypeName::String)),
("ControlGetIndex", 2, Wants::Declared(TypeName::String)),
("ControlGetIndex", 3, Wants::Declared(TypeName::String)),
("ControlGetIndex", 4, Wants::Declared(TypeName::String)),
("ControlGetItems", 2, Wants::Declared(TypeName::String)),
("ControlGetItems", 3, Wants::Declared(TypeName::String)),
("ControlGetItems", 4, Wants::Declared(TypeName::String)),
("ControlGetPos", 0, Wants::Reference("a VarRef")),
("ControlGetPos", 1, Wants::Reference("a VarRef")),
("ControlGetPos", 2, Wants::Reference("a VarRef")),
("ControlGetPos", 3, Wants::Reference("a VarRef")),
("ControlGetPos", 6, Wants::Declared(TypeName::String)),
("ControlGetPos", 7, Wants::Declared(TypeName::String)),
("ControlGetPos", 8, Wants::Declared(TypeName::String)),
("ControlGetStyle", 2, Wants::Declared(TypeName::String)),
("ControlGetStyle", 3, Wants::Declared(TypeName::String)),
("ControlGetStyle", 4, Wants::Declared(TypeName::String)),
("ControlGetText", 2, Wants::Declared(TypeName::String)),
("ControlGetText", 3, Wants::Declared(TypeName::String)),
("ControlGetText", 4, Wants::Declared(TypeName::String)),
("ControlGetVisible", 2, Wants::Declared(TypeName::String)),
("ControlGetVisible", 3, Wants::Declared(TypeName::String)),
("ControlGetVisible", 4, Wants::Declared(TypeName::String)),
("ControlHide", 2, Wants::Declared(TypeName::String)),
("ControlHide", 3, Wants::Declared(TypeName::String)),
("ControlHide", 4, Wants::Declared(TypeName::String)),
("ControlHideDropDown", 2, Wants::Declared(TypeName::String)),
("ControlHideDropDown", 3, Wants::Declared(TypeName::String)),
("ControlHideDropDown", 4, Wants::Declared(TypeName::String)),
("ControlMove", 0, Wants::Declared(TypeName::Number)),
("ControlMove", 1, Wants::Declared(TypeName::Number)),
("ControlMove", 2, Wants::Declared(TypeName::Number)),
("ControlMove", 3, Wants::Declared(TypeName::Number)),
("ControlMove", 6, Wants::Declared(TypeName::String)),
("ControlMove", 7, Wants::Declared(TypeName::String)),
("ControlMove", 8, Wants::Declared(TypeName::String)),
("ControlSend", 0, Wants::Declared(TypeName::String)),
("ControlSend", 3, Wants::Declared(TypeName::String)),
("ControlSend", 4, Wants::Declared(TypeName::String)),
("ControlSend", 5, Wants::Declared(TypeName::String)),
("ControlSendText", 0, Wants::Declared(TypeName::String)),
("ControlSendText", 3, Wants::Declared(TypeName::String)),
("ControlSendText", 4, Wants::Declared(TypeName::String)),
("ControlSendText", 5, Wants::Declared(TypeName::String)),
("ControlSetChecked", 0, Wants::Declared(TypeName::Number)),
("ControlSetChecked", 3, Wants::Declared(TypeName::String)),
("ControlSetChecked", 4, Wants::Declared(TypeName::String)),
("ControlSetChecked", 5, Wants::Declared(TypeName::String)),
("ControlSetEnabled", 0, Wants::Declared(TypeName::Number)),
("ControlSetEnabled", 3, Wants::Declared(TypeName::String)),
("ControlSetEnabled", 4, Wants::Declared(TypeName::String)),
("ControlSetEnabled", 5, Wants::Declared(TypeName::String)),
("ControlSetExStyle", 0, Wants::Declared(TypeName::String)),
("ControlSetExStyle", 3, Wants::Declared(TypeName::String)),
("ControlSetExStyle", 4, Wants::Declared(TypeName::String)),
("ControlSetExStyle", 5, Wants::Declared(TypeName::String)),
("ControlSetStyle", 0, Wants::Declared(TypeName::String)),
("ControlSetStyle", 3, Wants::Declared(TypeName::String)),
("ControlSetStyle", 4, Wants::Declared(TypeName::String)),
("ControlSetStyle", 5, Wants::Declared(TypeName::String)),
("ControlSetText", 0, Wants::Declared(TypeName::String)),
("ControlSetText", 3, Wants::Declared(TypeName::String)),
("ControlSetText", 4, Wants::Declared(TypeName::String)),
("ControlSetText", 5, Wants::Declared(TypeName::String)),
("ControlShow", 2, Wants::Declared(TypeName::String)),
("ControlShow", 3, Wants::Declared(TypeName::String)),
("ControlShow", 4, Wants::Declared(TypeName::String)),
("ControlShowDropDown", 2, Wants::Declared(TypeName::String)),
("ControlShowDropDown", 3, Wants::Declared(TypeName::String)),
("ControlShowDropDown", 4, Wants::Declared(TypeName::String)),
("Critical", 0, Wants::Declared(TypeName::String)),
("DriveEject", 0, Wants::Declared(TypeName::String)),
("DriveGetCapacity", 0, Wants::Declared(TypeName::String)),
("DriveGetFilesystem", 0, Wants::Declared(TypeName::String)),
("DriveGetLabel", 0, Wants::Declared(TypeName::String)),
("DriveGetList", 0, Wants::Declared(TypeName::String)),
("DriveGetSerial", 0, Wants::Declared(TypeName::String)),
("DriveGetSpaceFree", 0, Wants::Declared(TypeName::String)),
("DriveGetStatus", 0, Wants::Declared(TypeName::String)),
("DriveGetStatusCD", 0, Wants::Declared(TypeName::String)),
("DriveGetType", 0, Wants::Declared(TypeName::String)),
("DriveLock", 0, Wants::Declared(TypeName::String)),
("DriveRetract", 0, Wants::Declared(TypeName::String)),
("DriveSetLabel", 0, Wants::Declared(TypeName::String)),
("DriveSetLabel", 1, Wants::Declared(TypeName::String)),
("DriveUnlock", 0, Wants::Declared(TypeName::String)),
("EditGetCurrentCol", 2, Wants::Declared(TypeName::String)),
("EditGetCurrentCol", 3, Wants::Declared(TypeName::String)),
("EditGetCurrentCol", 4, Wants::Declared(TypeName::String)),
("EditGetCurrentLine", 2, Wants::Declared(TypeName::String)),
("EditGetCurrentLine", 3, Wants::Declared(TypeName::String)),
("EditGetCurrentLine", 4, Wants::Declared(TypeName::String)),
("EditGetLine", 0, Wants::Declared(TypeName::Number)),
("EditGetLine", 3, Wants::Declared(TypeName::String)),
("EditGetLine", 4, Wants::Declared(TypeName::String)),
("EditGetLine", 5, Wants::Declared(TypeName::String)),
("EditGetLineCount", 2, Wants::Declared(TypeName::String)),
("EditGetLineCount", 3, Wants::Declared(TypeName::String)),
("EditGetLineCount", 4, Wants::Declared(TypeName::String)),
("EditGetSelectedText", 2, Wants::Declared(TypeName::String)),
("EditGetSelectedText", 3, Wants::Declared(TypeName::String)),
("EditGetSelectedText", 4, Wants::Declared(TypeName::String)),
("EditPaste", 0, Wants::Declared(TypeName::String)),
("EditPaste", 3, Wants::Declared(TypeName::String)),
("EditPaste", 4, Wants::Declared(TypeName::String)),
("EditPaste", 5, Wants::Declared(TypeName::String)),
("FileCreateShortcut", 0, Wants::Declared(TypeName::String)),
("FileCreateShortcut", 1, Wants::Declared(TypeName::String)),
("FileCreateShortcut", 2, Wants::Declared(TypeName::String)),
("FileCreateShortcut", 3, Wants::Declared(TypeName::String)),
("FileCreateShortcut", 4, Wants::Declared(TypeName::String)),
("FileCreateShortcut", 5, Wants::Declared(TypeName::String)),
("FileCreateShortcut", 6, Wants::Declared(TypeName::String)),
("FileCreateShortcut", 7, Wants::Declared(TypeName::Number)),
("FileCreateShortcut", 8, Wants::Declared(TypeName::Number)),
("FileGetShortcut", 0, Wants::Declared(TypeName::String)),
("FileGetShortcut", 1, Wants::Reference("a VarRef")),
("FileGetShortcut", 2, Wants::Reference("a VarRef")),
("FileGetShortcut", 3, Wants::Reference("a VarRef")),
("FileGetShortcut", 4, Wants::Reference("a VarRef")),
("FileGetShortcut", 5, Wants::Reference("a VarRef")),
("FileGetShortcut", 6, Wants::Reference("a VarRef")),
("FileGetShortcut", 7, Wants::Reference("a VarRef")),
("FileGetVersion", 0, Wants::Declared(TypeName::String)),
("FileRecycle", 0, Wants::Declared(TypeName::String)),
("FileRecycleEmpty", 0, Wants::Declared(TypeName::String)),
("GroupActivate", 0, Wants::Declared(TypeName::String)),
("GroupActivate", 1, Wants::Declared(TypeName::String)),
("GroupAdd", 0, Wants::Declared(TypeName::String)),
("GroupAdd", 1, Wants::Declared(TypeName::String)),
("GroupAdd", 2, Wants::Declared(TypeName::String)),
("GroupAdd", 3, Wants::Declared(TypeName::String)),
("GroupAdd", 4, Wants::Declared(TypeName::String)),
("GroupClose", 0, Wants::Declared(TypeName::String)),
("GroupClose", 1, Wants::Declared(TypeName::String)),
("GroupDeactivate", 0, Wants::Declared(TypeName::String)),
("GroupDeactivate", 1, Wants::Declared(TypeName::String)),
("GuiCtrlFromHwnd", 0, Wants::Declared(TypeName::Number)),
("GuiFromHwnd", 0, Wants::Declared(TypeName::Number)),
("IL_Add", 0, Wants::Declared(TypeName::Number)),
("IL_Add", 1, Wants::Declared(TypeName::String)),
("IL_Add", 2, Wants::Declared(TypeName::Number)),
("IL_Create", 0, Wants::Declared(TypeName::Number)),
("IL_Create", 1, Wants::Declared(TypeName::Number)),
("IL_Destroy", 0, Wants::Declared(TypeName::Number)),
("ListLines", 0, Wants::Declared(TypeName::Number)),
("ListViewGetContent", 0, Wants::Declared(TypeName::String)),
("ListViewGetContent", 3, Wants::Declared(TypeName::String)),
("ListViewGetContent", 4, Wants::Declared(TypeName::String)),
("ListViewGetContent", 5, Wants::Declared(TypeName::String)),
("MenuFromHandle", 0, Wants::Declared(TypeName::Number)),
("MenuSelect", 1, Wants::Declared(TypeName::String)),
("MenuSelect", 2, Wants::Declared(TypeName::String)),
("MenuSelect", 3, Wants::Declared(TypeName::String)),
("MenuSelect", 4, Wants::Declared(TypeName::String)),
("MenuSelect", 5, Wants::Declared(TypeName::String)),
("MenuSelect", 6, Wants::Declared(TypeName::String)),
("MenuSelect", 7, Wants::Declared(TypeName::String)),
("MenuSelect", 8, Wants::Declared(TypeName::String)),
("MenuSelect", 9, Wants::Declared(TypeName::String)),
("MenuSelect", 10, Wants::Declared(TypeName::String)),
("MonitorGet", 0, Wants::Declared(TypeName::Number)),
("MonitorGetName", 0, Wants::Declared(TypeName::Number)),
("MonitorGetWorkArea", 0, Wants::Declared(TypeName::Number)),
("OnMessage", 0, Wants::Declared(TypeName::Number)),
("OutputDebug", 0, Wants::Declared(TypeName::String)),
("Pause", 0, Wants::Declared(TypeName::Number)),
("PostMessage", 0, Wants::Declared(TypeName::Number)),
("PostMessage", 5, Wants::Declared(TypeName::String)),
("PostMessage", 6, Wants::Declared(TypeName::String)),
("PostMessage", 7, Wants::Declared(TypeName::String)),
("ProcessClose", 0, Wants::Declared(TypeName::String)),
("ProcessExist", 0, Wants::Declared(TypeName::String)),
("ProcessGetName", 0, Wants::Declared(TypeName::String)),
("ProcessGetParent", 0, Wants::Declared(TypeName::String)),
("ProcessGetPath", 0, Wants::Declared(TypeName::String)),
("ProcessSetPriority", 0, Wants::Declared(TypeName::String)),
("ProcessSetPriority", 1, Wants::Declared(TypeName::String)),
("ProcessWait", 0, Wants::Declared(TypeName::String)),
("ProcessWait", 1, Wants::Declared(TypeName::Number)),
("ProcessWaitClose", 0, Wants::Declared(TypeName::String)),
("ProcessWaitClose", 1, Wants::Declared(TypeName::Number)),
("RunAs", 0, Wants::Declared(TypeName::String)),
("RunAs", 1, Wants::Declared(TypeName::String)),
("RunAs", 2, Wants::Declared(TypeName::String)),
("SendMessage", 0, Wants::Declared(TypeName::Number)),
("SendMessage", 5, Wants::Declared(TypeName::String)),
("SendMessage", 6, Wants::Declared(TypeName::String)),
("SendMessage", 7, Wants::Declared(TypeName::String)),
("SendMessage", 8, Wants::Declared(TypeName::Number)),
("SetCapsLockState", 0, Wants::Declared(TypeName::String)),
("SetNumLockState", 0, Wants::Declared(TypeName::String)),
("SetScrollLockState", 0, Wants::Declared(TypeName::String)),
("Shutdown", 0, Wants::Declared(TypeName::Number)),
("SoundGetName", 0, Wants::Declared(TypeName::String)),
("SoundGetName", 1, Wants::Declared(TypeName::String)),
("StatusBarGetText", 0, Wants::Declared(TypeName::Number)),
("StatusBarGetText", 2, Wants::Declared(TypeName::String)),
("StatusBarGetText", 3, Wants::Declared(TypeName::String)),
("StatusBarGetText", 4, Wants::Declared(TypeName::String)),
("StatusBarWait", 0, Wants::Declared(TypeName::String)),
("StatusBarWait", 1, Wants::Declared(TypeName::Number)),
("StatusBarWait", 2, Wants::Declared(TypeName::Number)),
("StatusBarWait", 4, Wants::Declared(TypeName::String)),
("StatusBarWait", 5, Wants::Declared(TypeName::Number)),
("StatusBarWait", 6, Wants::Declared(TypeName::String)),
("StatusBarWait", 7, Wants::Declared(TypeName::String)),
("StrPtr", 0, Wants::Checked(TypeName::String)),
("StrPut", 0, Wants::Declared(TypeName::String)),
("Suspend", 0, Wants::Declared(TypeName::Number)),
("SysGet", 0, Wants::Declared(TypeName::Number)),
("Thread", 0, Wants::Declared(TypeName::String)),
("Thread", 1, Wants::Declared(TypeName::Number)),
("Thread", 2, Wants::Declared(TypeName::Number)),
("ToolTip", 0, Wants::Declared(TypeName::String)),
("ToolTip", 1, Wants::Declared(TypeName::Number)),
("ToolTip", 2, Wants::Declared(TypeName::Number)),
("ToolTip", 3, Wants::Declared(TypeName::Number)),
("TraySetIcon", 0, Wants::Declared(TypeName::String)),
("TraySetIcon", 1, Wants::Declared(TypeName::Number)),
("TrayTip", 0, Wants::Declared(TypeName::String)),
("TrayTip", 1, Wants::Declared(TypeName::String)),
("TrayTip", 2, Wants::Declared(TypeName::String)),
("WinActivate", 1, Wants::Declared(TypeName::String)),
("WinActivate", 2, Wants::Declared(TypeName::String)),
("WinActivate", 3, Wants::Declared(TypeName::String)),
("WinActivateBottom", 1, Wants::Declared(TypeName::String)),
("WinActivateBottom", 2, Wants::Declared(TypeName::String)),
("WinActivateBottom", 3, Wants::Declared(TypeName::String)),
("WinClose", 1, Wants::Declared(TypeName::String)),
("WinClose", 2, Wants::Declared(TypeName::Number)),
("WinClose", 3, Wants::Declared(TypeName::String)),
("WinClose", 4, Wants::Declared(TypeName::String)),
("WinGetClass", 1, Wants::Declared(TypeName::String)),
("WinGetClass", 2, Wants::Declared(TypeName::String)),
("WinGetClass", 3, Wants::Declared(TypeName::String)),
("WinGetClientPos", 0, Wants::Reference("a VarRef")),
("WinGetClientPos", 1, Wants::Reference("a VarRef")),
("WinGetClientPos", 2, Wants::Reference("a VarRef")),
("WinGetClientPos", 3, Wants::Reference("a VarRef")),
("WinGetClientPos", 5, Wants::Declared(TypeName::String)),
("WinGetClientPos", 6, Wants::Declared(TypeName::String)),
("WinGetClientPos", 7, Wants::Declared(TypeName::String)),
("WinGetControls", 1, Wants::Declared(TypeName::String)),
("WinGetControls", 2, Wants::Declared(TypeName::String)),
("WinGetControls", 3, Wants::Declared(TypeName::String)),
("WinGetControlsHwnd", 1, Wants::Declared(TypeName::String)),
("WinGetControlsHwnd", 2, Wants::Declared(TypeName::String)),
("WinGetControlsHwnd", 3, Wants::Declared(TypeName::String)),
("WinGetCount", 1, Wants::Declared(TypeName::String)),
("WinGetCount", 2, Wants::Declared(TypeName::String)),
("WinGetCount", 3, Wants::Declared(TypeName::String)),
("WinGetExStyle", 1, Wants::Declared(TypeName::String)),
("WinGetExStyle", 2, Wants::Declared(TypeName::String)),
("WinGetExStyle", 3, Wants::Declared(TypeName::String)),
("WinGetID", 1, Wants::Declared(TypeName::String)),
("WinGetID", 2, Wants::Declared(TypeName::String)),
("WinGetID", 3, Wants::Declared(TypeName::String)),
("WinGetIDLast", 1, Wants::Declared(TypeName::String)),
("WinGetIDLast", 2, Wants::Declared(TypeName::String)),
("WinGetIDLast", 3, Wants::Declared(TypeName::String)),
("WinGetList", 1, Wants::Declared(TypeName::String)),
("WinGetList", 2, Wants::Declared(TypeName::String)),
("WinGetList", 3, Wants::Declared(TypeName::String)),
("WinGetMinMax", 1, Wants::Declared(TypeName::String)),
("WinGetMinMax", 2, Wants::Declared(TypeName::String)),
("WinGetMinMax", 3, Wants::Declared(TypeName::String)),
("WinGetPID", 1, Wants::Declared(TypeName::String)),
("WinGetPID", 2, Wants::Declared(TypeName::String)),
("WinGetPID", 3, Wants::Declared(TypeName::String)),
("WinGetPos", 0, Wants::Reference("a VarRef")),
("WinGetPos", 1, Wants::Reference("a VarRef")),
("WinGetPos", 2, Wants::Reference("a VarRef")),
("WinGetPos", 3, Wants::Reference("a VarRef")),
("WinGetPos", 5, Wants::Declared(TypeName::String)),
("WinGetPos", 6, Wants::Declared(TypeName::String)),
("WinGetPos", 7, Wants::Declared(TypeName::String)),
("WinGetProcessName", 1, Wants::Declared(TypeName::String)),
("WinGetProcessName", 2, Wants::Declared(TypeName::String)),
("WinGetProcessName", 3, Wants::Declared(TypeName::String)),
("WinGetProcessPath", 1, Wants::Declared(TypeName::String)),
("WinGetProcessPath", 2, Wants::Declared(TypeName::String)),
("WinGetProcessPath", 3, Wants::Declared(TypeName::String)),
("WinGetStyle", 1, Wants::Declared(TypeName::String)),
("WinGetStyle", 2, Wants::Declared(TypeName::String)),
("WinGetStyle", 3, Wants::Declared(TypeName::String)),
("WinGetText", 1, Wants::Declared(TypeName::String)),
("WinGetText", 2, Wants::Declared(TypeName::String)),
("WinGetText", 3, Wants::Declared(TypeName::String)),
("WinGetTransColor", 1, Wants::Declared(TypeName::String)),
("WinGetTransColor", 2, Wants::Declared(TypeName::String)),
("WinGetTransColor", 3, Wants::Declared(TypeName::String)),
("WinGetTransparent", 1, Wants::Declared(TypeName::String)),
("WinGetTransparent", 2, Wants::Declared(TypeName::String)),
("WinGetTransparent", 3, Wants::Declared(TypeName::String)),
("WinHide", 1, Wants::Declared(TypeName::String)),
("WinHide", 2, Wants::Declared(TypeName::String)),
("WinHide", 3, Wants::Declared(TypeName::String)),
("WinKill", 1, Wants::Declared(TypeName::String)),
("WinKill", 2, Wants::Declared(TypeName::Number)),
("WinKill", 3, Wants::Declared(TypeName::String)),
("WinKill", 4, Wants::Declared(TypeName::String)),
("WinMaximize", 1, Wants::Declared(TypeName::String)),
("WinMaximize", 2, Wants::Declared(TypeName::String)),
("WinMaximize", 3, Wants::Declared(TypeName::String)),
("WinMinimize", 1, Wants::Declared(TypeName::String)),
("WinMinimize", 2, Wants::Declared(TypeName::String)),
("WinMinimize", 3, Wants::Declared(TypeName::String)),
("WinMove", 0, Wants::Declared(TypeName::Number)),
("WinMove", 1, Wants::Declared(TypeName::Number)),
("WinMove", 2, Wants::Declared(TypeName::Number)),
("WinMove", 3, Wants::Declared(TypeName::Number)),
("WinMove", 5, Wants::Declared(TypeName::String)),
("WinMove", 6, Wants::Declared(TypeName::String)),
("WinMove", 7, Wants::Declared(TypeName::String)),
("WinMoveBottom", 1, Wants::Declared(TypeName::String)),
("WinMoveBottom", 2, Wants::Declared(TypeName::String)),
("WinMoveBottom", 3, Wants::Declared(TypeName::String)),
("WinMoveTop", 1, Wants::Declared(TypeName::String)),
("WinMoveTop", 2, Wants::Declared(TypeName::String)),
("WinMoveTop", 3, Wants::Declared(TypeName::String)),
("WinRedraw", 1, Wants::Declared(TypeName::String)),
("WinRedraw", 2, Wants::Declared(TypeName::String)),
("WinRedraw", 3, Wants::Declared(TypeName::String)),
("WinRestore", 1, Wants::Declared(TypeName::String)),
("WinRestore", 2, Wants::Declared(TypeName::String)),
("WinRestore", 3, Wants::Declared(TypeName::String)),
("WinSetAlwaysOnTop", 0, Wants::Declared(TypeName::Number)),
("WinSetAlwaysOnTop", 2, Wants::Declared(TypeName::String)),
("WinSetAlwaysOnTop", 3, Wants::Declared(TypeName::String)),
("WinSetAlwaysOnTop", 4, Wants::Declared(TypeName::String)),
("WinSetEnabled", 0, Wants::Declared(TypeName::Number)),
("WinSetEnabled", 2, Wants::Declared(TypeName::String)),
("WinSetEnabled", 3, Wants::Declared(TypeName::String)),
("WinSetEnabled", 4, Wants::Declared(TypeName::String)),
("WinSetExStyle", 0, Wants::Declared(TypeName::String)),
("WinSetExStyle", 2, Wants::Declared(TypeName::String)),
("WinSetExStyle", 3, Wants::Declared(TypeName::String)),
("WinSetExStyle", 4, Wants::Declared(TypeName::String)),
("WinSetRegion", 0, Wants::Declared(TypeName::String)),
("WinSetRegion", 2, Wants::Declared(TypeName::String)),
("WinSetRegion", 3, Wants::Declared(TypeName::String)),
("WinSetRegion", 4, Wants::Declared(TypeName::String)),
("WinSetStyle", 0, Wants::Declared(TypeName::String)),
("WinSetStyle", 2, Wants::Declared(TypeName::String)),
("WinSetStyle", 3, Wants::Declared(TypeName::String)),
("WinSetStyle", 4, Wants::Declared(TypeName::String)),
("WinSetTitle", 0, Wants::Declared(TypeName::String)),
("WinSetTitle", 2, Wants::Declared(TypeName::String)),
("WinSetTitle", 3, Wants::Declared(TypeName::String)),
("WinSetTitle", 4, Wants::Declared(TypeName::String)),
("WinSetTransColor", 2, Wants::Declared(TypeName::String)),
("WinSetTransColor", 3, Wants::Declared(TypeName::String)),
("WinSetTransColor", 4, Wants::Declared(TypeName::String)),
("WinSetTransparent", 0, Wants::Declared(TypeName::String)),
("WinSetTransparent", 2, Wants::Declared(TypeName::String)),
("WinSetTransparent", 3, Wants::Declared(TypeName::String)),
("WinSetTransparent", 4, Wants::Declared(TypeName::String)),
("WinShow", 1, Wants::Declared(TypeName::String)),
("WinShow", 2, Wants::Declared(TypeName::String)),
("WinShow", 3, Wants::Declared(TypeName::String)),
("WinWait", 1, Wants::Declared(TypeName::String)),
("WinWait", 2, Wants::Declared(TypeName::Number)),
("WinWait", 3, Wants::Declared(TypeName::String)),
("WinWait", 4, Wants::Declared(TypeName::String)),
("WinWaitActive", 1, Wants::Declared(TypeName::String)),
("WinWaitActive", 2, Wants::Declared(TypeName::Number)),
("WinWaitActive", 3, Wants::Declared(TypeName::String)),
("WinWaitActive", 4, Wants::Declared(TypeName::String)),
("WinWaitClose", 1, Wants::Declared(TypeName::String)),
("WinWaitClose", 2, Wants::Declared(TypeName::Number)),
("WinWaitClose", 3, Wants::Declared(TypeName::String)),
("WinWaitClose", 4, Wants::Declared(TypeName::String)),
("WinWaitNotActive", 1, Wants::Declared(TypeName::String)),
("WinWaitNotActive", 2, Wants::Declared(TypeName::Number)),
("WinWaitNotActive", 3, Wants::Declared(TypeName::String)),
("WinWaitNotActive", 4, Wants::Declared(TypeName::String)),
("RegExMatch", 2, Wants::Reference("a variable reference")),
("RegExReplace", 3, Wants::Reference("a variable reference")),
("StrReplace", 4, Wants::Reference("a variable reference")),
(
"VarSetStrCapacity",
0,
Wants::Reference("a variable reference"),
),
];
pub fn wants(name: &str, index: usize) -> Wants {
let place = index as u8;
if THE_TEXTS
.iter()
.any(|(built_in, indexes)| *built_in == name && indexes.contains(&place))
{
return Wants::Declared(TypeName::String);
}
if THE_NUMBERS
.iter()
.any(|(built_in, indexes)| *built_in == name && indexes.contains(&place))
{
return Wants::Declared(TypeName::Number);
}
if let Some((_, _, kind)) = THE_REFUSED
.iter()
.find(|(built_in, place, _)| *built_in == name && *place == index)
{
return *kind;
}
match (name, place) {
("Min" | "Max", _) => Wants::Declared(TypeName::Number),
("ObjOwnProps" | "ObjOwnPropCount" | "ObjHasOwnProp" | "ObjSetBase", 0) => {
Wants::Checked(TypeName::Object)
}
("MonitorGet" | "MonitorGetWorkArea", 1..=4) => Wants::Declared(TypeName::VarRef),
_ => Wants::Value,
}
}
pub fn refuses_itself(name: &str) -> bool {
matches!(name, "Mod")
}
pub(crate) fn obj_get_base(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let mut target = values
.first()
.cloned()
.unwrap_or(Value::Text(String::new()));
if let Value::Reference(reference) = &target {
target = rt
.read_reference(reference)
.unwrap_or_else(|| crate::classes::object_with("object", vec![]));
if !matches!(target, Value::Object(_)) {
target = crate::classes::object_with("object", vec![]);
}
}
rt.the_base_of_the_value(&target).ok_or_else(|| RuntimeError {
message: crate::runtime::expected_type(TypeName::Object, target.type_name()),
line,
})
}
pub(crate) fn obj_set_base(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let target = values
.first()
.cloned()
.unwrap_or(Value::Text(String::new()));
let base = values.get(1).cloned().unwrap_or(Value::Text(String::new()));
if !matches!(base, Value::Object(_)) {
return Err(RuntimeError {
message: crate::runtime::expected_type(TypeName::Object, base.type_name()),
line,
});
}
let old = rt
.stored_base_of(&target)
.unwrap_or(Value::Text(String::new()));
rt.set_base_of(&target, base, line)?;
Ok(old)
}
pub(crate) fn obj_own_props(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let target = values
.first()
.cloned()
.unwrap_or(Value::Text(String::new()));
rt.own_method(&target, "ownprops", &[], line)
}
pub(crate) fn obj_own_prop_count(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let target = values
.first()
.cloned()
.unwrap_or(Value::Text(String::new()));
let names = rt.own_method(&target, "ownprops", &[], line)?;
Ok(Value::Int(crate::classes::enumerator::the_count(&names)))
}
pub(crate) fn obj_has_own_prop(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let target = values
.first()
.cloned()
.unwrap_or(Value::Text(String::new()));
let name = values.get(1).cloned().unwrap_or(Value::Text(String::new()));
rt.own_method(&target, "hasownprop", &[name], line)
}
pub(crate) fn obj_get_capacity(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let target = values
.first()
.cloned()
.unwrap_or(Value::Text(String::new()));
if !matches!(target, Value::Object(_)) {
return Err(RuntimeError {
message: crate::runtime::expected_type(TypeName::Object, target.type_name()),
line,
});
}
Ok(rt
.property_of(&target, "capacity", line)
.unwrap_or(Value::Int(0)))
}
pub(crate) fn obj_set_capacity(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let target = values
.first()
.cloned()
.unwrap_or(Value::Text(String::new()));
let capacity = values.get(1).cloned().unwrap_or(Value::Int(0));
if !matches!(target, Value::Object(_)) {
return Err(RuntimeError {
message: crate::runtime::expected_type(TypeName::Object, target.type_name()),
line,
});
}
rt.write_property_of(&target, "capacity", capacity, line)?;
Ok(Value::Int(1))
}
pub(crate) fn obj_add_ref(
_rt: &mut Runtime<'_>,
_values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, "ObjAddRef"),
line,
})
}
fn text_of(values: &[Value], index: usize) -> String {
values
.get(index)
.map(|value| value.to_text())
.unwrap_or_default()
}
fn number_of(values: &[Value], index: usize) -> f64 {
values
.get(index)
.and_then(|value| value.to_number())
.unwrap_or(0.0)
}
fn number_value(value: &Value) -> Option<Value> {
match value {
Value::Int(_) | Value::Float(_) => Some(value.clone()),
Value::Text(text) => {
let trimmed = text.trim();
if trimmed.is_empty() {
return None;
}
let number: f64 = trimmed.parse().ok()?;
if trimmed.contains('.') || trimmed.contains('e') || trimmed.contains('E') {
Some(Value::Float(number))
} else {
Some(Value::Int(number as i64))
}
}
_ => None,
}
}
pub(crate) fn is_numeric_value(value: &Value) -> bool {
match value {
Value::Int(_) | Value::Float(_) => true,
Value::Text(text) => is_numeric_text(text),
_ => false,
}
}
fn is_numeric_text(text: &str) -> bool {
let bytes = text.as_bytes();
let mut at = 0;
while at < bytes.len() && (bytes[at] == b' ' || bytes[at] == b'\t') {
at += 1;
}
if at >= bytes.len() {
return false;
}
if bytes[at] == b'-' || bytes[at] == b'+' {
at += 1;
}
let hex = is_hex_at(bytes, at);
if hex {
at += 2;
}
let mut point = false;
let mut exponent = false;
let mut digit = false;
while at < bytes.len() {
let character = bytes[at];
if character == b' ' || character == b'\t' {
let mut next = at;
while next < bytes.len() && (bytes[next] == b' ' || bytes[next] == b'\t') {
next += 1;
}
if next < bytes.len() {
return false;
}
break;
}
if character == b'.' {
if point || hex {
return false;
}
point = true;
at += 1;
continue;
}
let is_digit = if hex {
character.is_ascii_hexdigit()
} else {
character.is_ascii_digit()
};
if !is_digit {
if hex || (character != b'e' && character != b'E') || !digit || exponent {
return false;
}
let mut next = at + 1;
if next < bytes.len() && (bytes[next] == b'+' || bytes[next] == b'-') {
next += 1;
}
if next >= bytes.len() || !bytes[next].is_ascii_digit() {
return false;
}
exponent = true;
point = true;
at = next + 1;
continue;
}
digit = true;
at += 1;
}
digit
}
fn is_hex_at(bytes: &[u8], at: usize) -> bool {
at + 2 < bytes.len()
&& bytes[at] == b'0'
&& (bytes[at + 1] == b'x' || bytes[at + 1] == b'X')
&& bytes[at + 2].is_ascii_hexdigit()
}
fn hex_digit(character: u8) -> u64 {
match character {
b'0'..=b'9' => (character - b'0') as u64,
b'a'..=b'f' => (character - b'a') as u64 + 10,
_ => (character - b'A') as u64 + 10,
}
}
pub(crate) fn token_to_int64(value: &Value) -> i64 {
match value {
Value::Int(number) => *number,
Value::Float(number) => double_to_int64(*number),
Value::Text(text) => text_to_int64(text),
_ => 0,
}
}
fn double_to_int64(number: f64) -> i64 {
if !(-9223372036854775808.0..9223372036854775808.0).contains(&number) {
return i64::MIN;
}
number as i64
}
pub(crate) fn token_to_double(value: &Value) -> f64 {
match value {
Value::Int(number) => *number as f64,
Value::Float(number) => *number,
Value::Text(text) => text_to_double(text),
_ => 0.0,
}
}
pub(crate) fn text_to_int64(text: &str) -> i64 {
let bytes = text.as_bytes();
let mut at = 0;
while at < bytes.len() && (bytes[at] == b' ' || bytes[at] == b'\t') {
at += 1;
}
let negative = at < bytes.len() && bytes[at] == b'-';
if negative || (at < bytes.len() && bytes[at] == b'+') {
at += 1;
}
let mut value: u64;
if is_hex_at(bytes, at) {
at += 2;
value = 0;
while at < bytes.len() && bytes[at].is_ascii_hexdigit() {
value = value.wrapping_mul(16).wrapping_add(hex_digit(bytes[at]));
at += 1;
}
} else {
value = 0;
while at < bytes.len() && bytes[at].is_ascii_digit() {
value = value
.wrapping_mul(10)
.wrapping_add((bytes[at] - b'0') as u64);
at += 1;
}
let end_integer = at;
if at < bytes.len() && bytes[at] == b'.' {
at += 1;
while at < bytes.len() && bytes[at].is_ascii_digit() {
at += 1;
}
}
let end_fraction = at;
if at < bytes.len() && (bytes[at] == b'e' || bytes[at] == b'E') {
at += 1;
let exponent_negative = at < bytes.len() && bytes[at] == b'-';
if exponent_negative || (at < bytes.len() && bytes[at] == b'+') {
at += 1;
}
let digits_start = at;
let mut exponent: u64 = 0;
while at < bytes.len() && bytes[at].is_ascii_digit() {
exponent = exponent
.wrapping_mul(10)
.wrapping_add((bytes[at] - b'0') as u64);
at += 1;
}
if at > digits_start {
if !exponent_negative && end_integer < end_fraction && bytes[end_integer] == b'.' {
let mut next = end_integer + 1;
while next < end_fraction && exponent > 0 {
value = value
.wrapping_mul(10)
.wrapping_add((bytes[next] - b'0') as u64);
next += 1;
exponent -= 1;
}
}
if exponent >= if exponent_negative { 20 } else { 64 } {
value = 0;
} else if exponent != 0 {
let mut multiplier: u64 = 1;
let mut base: u64 = 10;
let mut left = exponent;
while left > 1 {
if left & 1 == 1 {
multiplier = multiplier.wrapping_mul(base);
}
left >>= 1;
base = base.wrapping_mul(base);
}
multiplier = multiplier.wrapping_mul(base);
if exponent_negative {
value /= multiplier;
} else {
value = value.wrapping_mul(multiplier);
}
}
}
}
}
if negative {
-(value as i64)
} else {
value as i64
}
}
pub(crate) fn text_to_double(text: &str) -> f64 {
let bytes = text.as_bytes();
let mut at = 0;
while at < bytes.len() && (bytes[at] == b' ' || bytes[at] == b'\t') {
at += 1;
}
let mut probe = at;
if probe < bytes.len() && (bytes[probe] == b'-' || bytes[probe] == b'+') {
probe += 1;
}
if is_hex_at(bytes, probe) {
return text_to_int64(text) as f64;
}
let start = at;
if at < bytes.len() && (bytes[at] == b'-' || bytes[at] == b'+') {
at += 1;
}
let mut digit = false;
while at < bytes.len() && bytes[at].is_ascii_digit() {
at += 1;
digit = true;
}
if at < bytes.len() && bytes[at] == b'.' {
at += 1;
while at < bytes.len() && bytes[at].is_ascii_digit() {
at += 1;
digit = true;
}
}
if digit && at < bytes.len() && (bytes[at] == b'e' || bytes[at] == b'E') {
let mut next = at + 1;
if next < bytes.len() && (bytes[next] == b'+' || bytes[next] == b'-') {
next += 1;
}
if next < bytes.len() && bytes[next].is_ascii_digit() {
while next < bytes.len() && bytes[next].is_ascii_digit() {
next += 1;
}
at = next;
}
}
if !digit {
return 0.0;
}
text[start..at].parse::<f64>().unwrap_or(0.0)
}
pub(crate) fn text_holds_an_integer(text: &str) -> bool {
let bytes = text.as_bytes();
let mut at = 0;
while at < bytes.len() && (bytes[at] == b' ' || bytes[at] == b'\t') {
at += 1;
}
if at < bytes.len() && (bytes[at] == b'-' || bytes[at] == b'+') {
at += 1;
}
if is_hex_at(bytes, at) {
return true;
}
!bytes[at..]
.iter()
.any(|character| *character == b'.' || *character == b'e' || *character == b'E')
}
fn number_argument(
values: &[Value],
index: usize,
line: u32,
name: &str,
) -> Result<f64, RuntimeError> {
let value = values.get(index).cloned().unwrap_or(Value::Int(0));
value.to_number_strict().map_err(|_| RuntimeError {
message: crate::runtime::requires(index + 1, name, TypeName::Number, &value),
line,
})
}
fn numbers_argument(values: &[Value], line: u32, name: &str) -> Result<Vec<f64>, RuntimeError> {
let mut numbers = Vec::with_capacity(values.len());
for (index, value) in values.iter().enumerate() {
numbers.push(value.to_number_strict().map_err(|_| RuntimeError {
message: crate::runtime::requires(index + 1, name, TypeName::Number, value),
line,
})?);
}
Ok(numbers)
}
fn integer_argument(values: &[Value], index: usize, line: u32) -> Result<i64, RuntimeError> {
match values.get(index) {
Some(Value::Int(number)) => Ok(*number),
Some(other) => Err(RuntimeError {
message: crate::runtime::expected_type(TypeName::Integer, other.type_name()),
line,
}),
None => Err(RuntimeError {
message: crate::runtime::expected_type(TypeName::Integer, TypeName::String),
line,
}),
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum CaseSense {
Sensitive,
Insensitive,
Locale,
Logical,
}
fn case_sense(
values: &[Value],
index: usize,
name: &str,
line: u32,
) -> Result<CaseSense, RuntimeError> {
let invalid = || RuntimeError {
message: crate::runtime::invalid_parameter(index + 1, name),
line,
};
match values.get(index) {
None => Ok(CaseSense::Insensitive),
Some(Value::Unset) => Ok(CaseSense::Insensitive),
Some(Value::Int(1)) => Ok(CaseSense::Sensitive),
Some(Value::Int(0)) => Ok(CaseSense::Insensitive),
Some(Value::Text(text)) => case_sense_of_a_text(text).ok_or_else(invalid),
Some(_) => Err(invalid()),
}
}
fn case_sense_of_a_text(text: &str) -> Option<CaseSense> {
if text.eq_ignore_ascii_case("On") || text == "1" {
Some(CaseSense::Sensitive)
} else if text.eq_ignore_ascii_case("Off") || text == "0" {
Some(CaseSense::Insensitive)
} else if text.eq_ignore_ascii_case("Locale") {
Some(CaseSense::Locale)
} else if text.eq_ignore_ascii_case("Logical") {
Some(CaseSense::Logical)
} else {
None
}
}
fn compare_texts(left: &str, right: &str, sense: CaseSense) -> Ordering {
match sense {
CaseSense::Sensitive => left.cmp(right),
CaseSense::Logical => compare_logically(left, right),
CaseSense::Insensitive | CaseSense::Locale => {
left.to_lowercase().cmp(&right.to_lowercase())
}
}
}
fn compare_logically(left: &str, right: &str) -> Ordering {
let left: Vec<char> = left.chars().collect();
let right: Vec<char> = right.chars().collect();
let mut at = 0usize;
while at < left.len() && at < right.len() {
let a = left[at];
let b = right[at];
if a.is_ascii_digit() && b.is_ascii_digit() {
let mut end_a = at;
while end_a < left.len() && left[end_a].is_ascii_digit() {
end_a += 1;
}
let mut end_b = at;
while end_b < right.len() && right[end_b].is_ascii_digit() {
end_b += 1;
}
let number_a: &str = &left[at..end_a].iter().collect::<String>();
let number_b: &str = &right[at..end_b].iter().collect::<String>();
let trimmed_a = number_a.trim_start_matches('0');
let trimmed_b = number_b.trim_start_matches('0');
let order = trimmed_a
.len()
.cmp(&trimmed_b.len())
.then_with(|| trimmed_a.cmp(trimmed_b))
.then_with(|| number_a.len().cmp(&number_b.len()));
if order != Ordering::Equal {
return order;
}
at = end_a.min(end_b);
continue;
}
let folded_a = a.to_lowercase().next().unwrap_or(a);
let folded_b = b.to_lowercase().next().unwrap_or(b);
if folded_a != folded_b {
return folded_a.cmp(&folded_b);
}
at += 1;
}
left.len().cmp(&right.len())
}
fn same_letter(left: char, right: char, sense: CaseSense) -> bool {
match sense {
CaseSense::Sensitive => left == right,
CaseSense::Insensitive | CaseSense::Locale | CaseSense::Logical => {
left.to_lowercase().eq(right.to_lowercase())
}
}
}
fn find_ignoring_case(haystack: &str, needle: &str) -> Option<usize> {
let hay: Vec<char> = haystack.chars().collect();
let pin: Vec<char> = needle.chars().collect();
if pin.is_empty() || pin.len() > hay.len() {
return None;
}
for at in 0..=(hay.len() - pin.len()) {
let same = hay[at..at + pin.len()]
.iter()
.zip(pin.iter())
.all(|(left, right)| same_letter(*left, *right, CaseSense::Insensitive));
if same {
return haystack.char_indices().nth(at).map(|(byte, _)| byte);
}
}
None
}
fn find_in_sense(text: &str, needle: &str, sense: CaseSense) -> Option<usize> {
match sense {
CaseSense::Sensitive => text.find(needle),
CaseSense::Insensitive | CaseSense::Locale | CaseSense::Logical => {
find_ignoring_case(text, needle)
}
}
}
pub(crate) fn desktop_failure(message: String, line: u32) -> RuntimeError {
RuntimeError { message, line }
}
pub(crate) fn abs(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let value = values.first().cloned().unwrap_or(Value::Int(0));
number_argument(values, 0, line, "Abs")?;
Ok(match number_value(&value) {
Some(Value::Int(number)) => Value::Int(number.abs()),
Some(Value::Float(number)) => Value::Float(number.abs()),
_ => Value::Int(0),
})
}
pub(crate) fn round_to(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
variant: u8,
) -> Result<Value, RuntimeError> {
let name = if variant == 1 { "Ceil" } else { "Floor" };
let number = number_argument(values, 0, line, name)?;
let rounded = if variant == 1 {
crate::runtime::ceil(number)
} else {
crate::runtime::floor(number)
};
Ok(Value::from_number(rounded))
}
pub(crate) fn extreme(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
variant: u8,
) -> Result<Value, RuntimeError> {
let name = if variant == 1 { "Max" } else { "Min" };
let numbers = numbers_argument(values, line, name)?;
let mut result = numbers.first().copied().unwrap_or(0.0);
for number in numbers.iter().skip(1) {
if (variant == 1 && *number > result) || (variant == 0 && *number < result) {
result = *number;
}
}
Ok(Value::from_number(result))
}
pub(crate) fn modulo(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let dividend = values.first().cloned().unwrap_or(Value::Int(0));
let divisor = values.get(1).cloned().unwrap_or(Value::Int(0));
let invalid = || RuntimeError {
message: "Invalid parameter(s).".into(),
line,
};
let left = number_value(÷nd).ok_or_else(invalid)?;
let right = number_value(&divisor).ok_or_else(invalid)?;
if right.to_number() == Some(0.0) {
return Err(RuntimeError {
message: "Divide by zero.".into(),
line,
});
}
Ok(match (left, right) {
(Value::Int(left), Value::Int(right)) => Value::Int(left.wrapping_rem(right)),
(left, right) => {
let left = left.to_number().unwrap_or(0.0);
let right = right.to_number().unwrap_or(0.0);
Value::Float(left % right)
}
})
}
pub(crate) fn round_to_digits(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let decimals = match values.get(1) {
None => 0i32,
Some(value) => {
if !is_numeric_value(value) {
return Err(RuntimeError {
message: crate::runtime::requires(2, "Round", TypeName::Number, value),
line,
});
}
token_to_int64(value) as i32
}
};
let number = match values.first() {
None => 0.0,
Some(value) => {
if !is_numeric_value(value) {
return Err(RuntimeError {
message: crate::runtime::requires(1, "Round", TypeName::Number, value),
line,
});
}
token_to_double(value)
}
};
let multiplier = crate::runtime::powi(10.0, decimals);
let rounded = if number >= 0.0 {
crate::runtime::floor(number * multiplier + 0.5)
} else {
crate::runtime::ceil(number * multiplier - 0.5)
} / multiplier;
if decimals > 0 {
if decimals as usize > 100_000 {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(2, "Round"),
line,
});
}
let body = if rounded.is_nan() {
if rounded.is_sign_negative() {
"-nan(ind)".to_string()
} else {
"nan(ind)".to_string()
}
} else if rounded.is_infinite() {
if rounded < 0.0 {
"-inf".to_string()
} else {
"inf".to_string()
}
} else {
format!("{:.*}", decimals as usize, rounded)
};
return Ok(Value::Text(body));
}
let nudged = rounded + if rounded > 0.0 { 0.2 } else { -0.2 };
Ok(Value::Int(double_to_int64(nudged)))
}
pub(crate) fn square_root(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = number_argument(values, 0, line, "Sqrt")?;
if number < 0.0 {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, "Sqrt"),
line,
});
}
Ok(Value::Float(crate::runtime::sqrt(number)))
}
pub(crate) fn trigonometry(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
variant: u8,
) -> Result<Value, RuntimeError> {
let name = match variant {
0 => "Sin",
1 => "Cos",
_ => "Tan",
};
let number = number_argument(values, 0, line, name)?;
let result = match variant {
0 => crate::runtime::sin(number),
1 => crate::runtime::cos(number),
_ => crate::runtime::tan(number),
};
Ok(Value::Float(result))
}
pub(crate) fn inverse_trigonometry(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
variant: u8,
) -> Result<Value, RuntimeError> {
let name = match variant {
0 => "ASin",
1 => "ACos",
_ => "ATan",
};
let number = number_argument(values, 0, line, name)?;
if variant != 2 && !(-1.0..=1.0).contains(&number) {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, name),
line,
});
}
let result = match variant {
0 => crate::runtime::asin(number),
1 => crate::runtime::acos(number),
_ => crate::runtime::atan(number),
};
Ok(Value::Float(result))
}
pub(crate) fn exponential(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
Ok(Value::Float(crate::runtime::exp(number_argument(
values, 0, line, "Exp",
)?)))
}
pub(crate) fn logarithm(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
variant: u8,
) -> Result<Value, RuntimeError> {
let name = if variant == 1 { "Log" } else { "Ln" };
let number = number_argument(values, 0, line, name)?;
if number < 0.0 {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, name),
line,
});
}
let result = if variant == 0 {
crate::runtime::ln(number)
} else {
crate::runtime::log10(number)
};
Ok(Value::Float(result))
}
static RANDOM_STATE: AtomicU32 = AtomicU32::new(0);
fn next_random(now_ms: u64) -> u32 {
let mut state = RANDOM_STATE.load(AtomicOrder::Relaxed);
if state == 0 {
state = (now_ms as u32) ^ 0x9E37_79B9 | 1;
}
state ^= state << 13;
state ^= state >> 17;
state ^= state << 5;
RANDOM_STATE.store(state, AtomicOrder::Relaxed);
state
}
fn unit_random(now_ms: u64) -> f64 {
next_random(now_ms) as f64 / (u32::MAX as f64 + 1.0)
}
pub(crate) fn random(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let now = rt.now_ms() ^ rt.the_seed_of_the_random();
match values.len() {
0 => Ok(Value::Float(unit_random(now))),
1 => {
let bound = number_argument(values, 0, line, "Random")?;
if bound <= 0.0 {
return Ok(Value::Int(0));
}
if values[0].type_name() == TypeName::Float {
return Ok(Value::Float(unit_random(now) * bound));
}
Ok(Value::Int(next_random(now) as i64 % bound as i64))
}
_ => {
let mut low = number_argument(values, 0, line, "Random")?;
let mut high = number_argument(values, 1, line, "Random")?;
if low > high {
core::mem::swap(&mut low, &mut high);
}
let whole = values[0].type_name() != TypeName::Float
&& values[1].type_name() != TypeName::Float;
if whole {
let span = (high - low) as u64;
let offset = if span == 0 {
0
} else {
next_random(now) as u64 % (span + 1)
};
Ok(Value::Int((low as i64).saturating_add(offset as i64)))
} else {
Ok(Value::Float(low + unit_random(now) * (high - low)))
}
}
}
}
pub(crate) fn num_get(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let source = values.first().cloned().unwrap_or(Value::Int(0));
if !matches!(source, Value::Object(_)) {
let message = match source {
Value::Int(_) => "this runtime does not read the memory of an address: the source of a number is a buffer.".to_string(),
other => expected_type(TypeName::Object, other.type_name()),
};
return Err(RuntimeError { message, line });
}
let (offset, type_name) = if values.len() > 2 {
(integer_argument(values, 1, line)?, text_of(values, 2))
} else {
(0, text_of(values, 1))
};
let kind = crate::classes::buffer::number_type(&type_name).ok_or_else(|| RuntimeError {
message: "the type of a number is one of UInt, Int, Int64, Short, UShort, Char, UChar, Double, Float, Ptr or UPtr.".into(),
line,
})?;
match crate::classes::buffer::read_number(&source, offset, kind, line) {
Ok(number) => Ok(number),
Err(RuntimeFailure::Error(error)) => Err(error),
Err(RuntimeFailure::Detailed(error, _)) => Err(error),
Err(_) => Err(RuntimeError {
message: "the buffer did not answer.".into(),
line,
}),
}
}
pub(crate) fn num_put(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let Some(index) = values
.iter()
.rposition(|value| matches!(value, Value::Object(_)))
else {
let message = match values.last() {
Some(Value::Int(_)) => "this runtime does not write to the memory of an address: the target of a number is a buffer.".to_string(),
Some(other) => expected_type(TypeName::Object, other.type_name()),
None => expected_type(TypeName::Object, TypeName::String),
};
return Err(RuntimeError { message, line });
};
let pairs = &values[..index];
if pairs.len() % 2 != 0 {
return Err(RuntimeError {
message: "the types and the numbers of a write come in pairs.".into(),
line,
});
}
if index + 2 < values.len() {
return Err(RuntimeError {
message: "a write takes the target and the offset after the pairs.".into(),
line,
});
}
let offset = match values.get(index + 1) {
Some(_) => integer_argument(values, index + 1, line)?,
None => 0,
};
let mut numbers = Vec::with_capacity(pairs.len() / 2);
let mut at = 0;
while at < pairs.len() {
let kind = crate::classes::buffer::number_type(&text_of(pairs, at)).ok_or_else(|| RuntimeError {
message: "the type of a number is one of UInt, Int, Int64, Short, UShort, Char, UChar, Double, Float, Ptr or UPtr.".into(),
line,
})?;
let number = pairs[at + 1].clone();
let number = number_value(&number).ok_or_else(|| RuntimeError {
message: crate::runtime::requires(at + 2, "NumPut", TypeName::Number, &number),
line,
})?;
numbers.push((kind, number));
at += 2;
}
let target = &values[index];
match crate::classes::buffer::write_numbers(target, offset, &numbers, line) {
Ok(address) => Ok(Value::Int(address)),
Err(RuntimeFailure::Error(error)) => Err(error),
Err(RuntimeFailure::Detailed(error, _)) => Err(error),
Err(_) => Err(RuntimeError {
message: "the buffer did not answer.".into(),
line,
}),
}
}
pub(crate) fn chr(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let code = number_argument(values, 0, line, "Chr")? as i64;
if !(0..=0x10FFFF).contains(&code) {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, "Chr"),
line,
});
}
let text = if (0xD800..=0xDFFF).contains(&code) {
crate::text16::the_text_of(&[code as u16])
} else {
let Some(character) = char::from_u32(code as u32) else {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, "Chr"),
line,
});
};
character.to_string()
};
Ok(Value::Text(text))
}
pub(crate) fn format(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let Some(first) = values.first() else {
return Ok(Value::Text(String::new()));
};
if matches!(first, Value::Object(_) | Value::List(_)) {
return Err(RuntimeError {
message: crate::runtime::requires(1, "Format", TypeName::String, first),
line,
});
}
let mut arguments = Vec::with_capacity(values.len());
for value in values {
arguments.push(match value {
Value::Reference(reference) => rt
.read_reference(reference)
.unwrap_or_else(|| Value::Text(String::new())),
other => other.clone(),
});
}
let pattern = match arguments.first() {
Some(value @ (Value::Object(_) | Value::List(_))) => {
return Err(RuntimeError {
message: crate::runtime::requires(1, "Format", TypeName::String, value),
line,
});
}
Some(value) => value.to_text(),
None => String::new(),
};
Ok(Value::Text(format_pattern(&pattern, &arguments, line)?))
}
pub(crate) fn in_str(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let haystack: Vec<char> = text_of(values, 0).chars().collect();
let needle: Vec<char> = text_of(values, 1).chars().collect();
if needle.is_empty() {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(2, "InStr"),
line,
});
}
let sense = case_sense(values, 2, "InStr", line)?;
if sense == CaseSense::Logical {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(3, "InStr"),
line,
});
}
let start_given = values.get(3).is_some();
let mut offset: i64 = 1;
if let Some(value) = values.get(3) {
if !is_numeric_value(value) {
return Err(RuntimeError {
message: crate::runtime::requires(4, "InStr", TypeName::Number, value),
line,
});
}
offset = token_to_int64(value);
if offset == 0 {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(4, "InStr"),
line,
});
}
}
let mut occurrence: i64 = 1;
if let Some(value) = values.get(4) {
if !is_numeric_value(value) {
return Err(RuntimeError {
message: crate::runtime::requires(5, "InStr", TypeName::Number, value),
line,
});
}
occurrence = token_to_int64(value) as i32 as i64;
if occurrence == 0 {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(5, "InStr"),
line,
});
}
}
let length = haystack.len() as i64;
if offset < 0 {
if values.get(4).is_none() {
occurrence = -1;
}
offset = offset.saturating_add(length + 1);
}
if occurrence > 0 {
offset = offset.saturating_sub(1);
}
if offset < 0 {
offset = 0;
} else if offset > length {
offset = length;
}
if occurrence < 0 {
let end = if start_given {
offset as usize
} else {
haystack.len()
};
let wanted = (-occurrence) as u64;
let mut found = 0u64;
if needle.len() <= end {
for at in (0..=(end - needle.len())).rev() {
if haystack[at..at + needle.len()]
.iter()
.zip(needle.iter())
.all(|(left, right)| same_letter(*left, *right, sense))
{
found += 1;
if found == wanted {
return Ok(Value::Int(at as i64 + 1));
}
}
}
}
return Ok(Value::Int(0));
}
let mut at = offset as usize;
let mut count: i64 = 1;
while at + needle.len() <= haystack.len() {
if haystack[at..at + needle.len()]
.iter()
.zip(needle.iter())
.all(|(left, right)| same_letter(*left, *right, sense))
{
if count == occurrence {
return Ok(Value::Int(at as i64 + 1));
}
count += 1;
at += needle.len();
} else {
at += 1;
}
}
Ok(Value::Int(0))
}
pub(crate) fn ord(
_rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let text = text_of(values, 0);
let code = match text.chars().next() {
None => 0,
Some(character) => match crate::text16::the_surrogate_of_a_character(character) {
Some(unit) => unit as i64,
None => character as u32 as i64,
},
};
Ok(Value::Int(code))
}
struct SortOptions {
delimiter: char,
sense: CaseSense,
numeric: bool,
reverse: bool,
column: usize,
blank_trailing: bool,
naked_filename: bool,
random: bool,
unique: bool,
}
fn sort_options(text: &str) -> SortOptions {
let chars: Vec<char> = text.chars().collect();
let mut options = SortOptions {
delimiter: '\n',
sense: CaseSense::Insensitive,
numeric: false,
reverse: false,
column: 0,
blank_trailing: false,
naked_filename: false,
random: false,
unique: false,
};
let mut at = 0usize;
while at < chars.len() {
match chars[at].to_ascii_uppercase() {
'C' => {
if chars.get(at + 1).map(|c| c.to_ascii_uppercase()) == Some('L') {
let rest: String = chars[at + 2..].iter().take(6).collect();
if rest.eq_ignore_ascii_case("ogical") {
options.sense = CaseSense::Logical;
at += 8;
} else {
let rest: String = chars[at + 2..].iter().take(5).collect();
if rest.eq_ignore_ascii_case("ocale") {
at += 7;
} else {
at += 2;
}
options.sense = CaseSense::Locale;
}
} else {
let rest: String = chars[at + 1..].iter().take(3).collect();
if rest.eq_ignore_ascii_case("Off") {
options.sense = CaseSense::Insensitive;
at += 4;
} else if chars.get(at + 1) == Some(&'0') {
options.sense = CaseSense::Insensitive;
at += 1;
} else {
let rest: String = chars[at + 1..].iter().take(2).collect();
if rest.eq_ignore_ascii_case("On") {
at += 3;
} else {
at += 1;
}
options.sense = CaseSense::Sensitive;
}
}
}
'D' => {
if at + 1 < chars.len() {
options.delimiter = chars[at + 1];
at += 2;
} else {
at += 1;
}
}
'N' => {
options.numeric = true;
at += 1;
}
'P' => {
let mut next = at + 1;
while next < chars.len() && chars[next].is_ascii_whitespace() {
next += 1;
}
let negative = next < chars.len() && chars[next] == '-';
if negative || (next < chars.len() && chars[next] == '+') {
next += 1;
}
let mut value: i64 = 0;
while next < chars.len() && chars[next].is_ascii_digit() {
value = value
.saturating_mul(10)
.saturating_add((chars[next] as u8 - b'0') as i64);
next += 1;
}
if negative {
value = -value;
}
options.column = if value < 1 { 1 } else { value as usize } - 1;
at += 1;
}
'R' => {
let rest: String = chars[at..].iter().take(6).collect();
if rest.eq_ignore_ascii_case("Random") {
options.random = true;
at += 6;
} else {
options.reverse = true;
at += 1;
}
}
'U' => {
options.unique = true;
at += 1;
}
'Z' => {
options.blank_trailing = true;
at += 1;
}
'\\' => {
options.naked_filename = true;
at += 1;
}
_ => at += 1,
}
}
options
}
fn sort_key(item: &str, options: &SortOptions) -> String {
if options.column == 0 {
return item.to_string();
}
item.chars().skip(options.column).collect()
}
fn naked_filename(item: &str) -> &str {
match item.rfind('\\') {
Some(at) => &item[at + 1..],
None => item,
}
}
pub(crate) fn sort(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let contents = sort_text(values, 0, line)?;
let options = sort_options(&sort_text(values, 1, line)?);
let callback = match values.get(2) {
None => None,
Some(value @ (Value::Object(_) | Value::List(_) | Value::Reference(_))) => {
Some(value.clone())
}
Some(_) => {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(3, "Sort"),
line,
});
}
};
if contents.is_empty() {
return Ok(Value::Text(String::new()));
}
let mut working = contents.clone();
let mut terminate_last = false;
let mut trailing_crlf = false;
if !options.blank_trailing && working.ends_with(options.delimiter) {
terminate_last = true;
} else if options.delimiter == '\n' {
let chars: Vec<char> = working.chars().collect();
if let Some(at) = chars.iter().position(|c| *c == '\n') {
if at > 0 && chars[at - 1] == '\r' {
trailing_crlf = true;
terminate_last = true;
working.push_str("\r\n");
}
}
}
let mut items: Vec<String> = working
.split(options.delimiter)
.map(|item| item.to_string())
.collect();
if terminate_last {
items.pop();
}
if items.len() == 1 {
return Ok(Value::Text(contents));
}
let mut positions: Vec<usize> = Vec::with_capacity(items.len());
let mut position = 0usize;
for item in &items {
positions.push(position);
position += item.chars().count() + 1;
}
let keys: Vec<String> = items.iter().map(|item| sort_key(item, &options)).collect();
let mut order: Vec<usize> = (0..items.len()).collect();
let mut failure: Option<RuntimeError> = None;
if let Some(callback) = &callback {
let is_a_function = match callback {
Value::Object(object) => {
let class = object.borrow().class.to_lowercase();
class == "func" || class == "boundfunc" || class == "closure"
}
_ => false,
};
let no_method = |value: &Value| RuntimeError {
message: format!(
"This value of type \"{}\" has no method named \"Call\".",
value.the_kind()
),
line,
};
order.sort_by(|&left, &right| {
if failure.is_some() {
return Ordering::Equal;
}
let offset = positions[right] as i64 - positions[left] as i64;
let arguments = [
Value::Text(items[left].clone()),
Value::Text(items[right].clone()),
Value::Int(offset),
];
let called = if is_a_function {
match crate::classes::func::call_the_value(callback, &arguments, rt, line) {
Some(Ok(value)) => Ok(value),
Some(Err(error)) => Err(the_failure_in_one(error, line)),
None => Err(no_method(callback)),
}
} else {
match rt.call_a_method_of_an_object(callback, "Call", &arguments, line) {
Ok(value) => Ok(value),
Err(error) => Err(the_failure_in_one(error, line)),
}
};
match called {
Ok(value) => match token_to_int64(&value) {
number if number < 0 => Ordering::Less,
number if number > 0 => Ordering::Greater,
_ => Ordering::Equal,
},
Err(error) => {
failure = Some(error);
Ordering::Equal
}
}
});
} else if options.random {
let now = rt.now_ms() ^ rt.the_seed_of_the_random();
for at in (1..order.len()).rev() {
let pick = (unit_random(now) * (at as f64 + 1.0)) as usize;
order.swap(at, pick.min(at));
}
} else {
order.sort_by(|&left, &right| {
let order = if options.naked_filename {
compare_texts(
naked_filename(&items[left]),
naked_filename(&items[right]),
options.sense,
)
} else if options.numeric {
let a = text_to_double(&keys[left]);
let b = text_to_double(&keys[right]);
a.partial_cmp(&b).unwrap_or(Ordering::Equal)
} else {
compare_texts(&keys[left], &keys[right], options.sense)
};
let order = if order == Ordering::Equal {
left.cmp(&right)
} else {
order
};
if options.reverse {
order.reverse()
} else {
order
}
});
}
if let Some(failure) = failure {
return Err(failure);
}
let mut kept: Vec<usize> = Vec::with_capacity(order.len());
for &index in &order {
if options.unique {
if let Some(&previous) = kept.last() {
if sort_duplicates(&items[previous], &items[index], &options) {
continue;
}
}
}
kept.push(index);
}
let mut out = String::with_capacity(contents.len());
for (at, &index) in kept.iter().enumerate() {
out.push_str(&items[index]);
if at + 1 < kept.len() || terminate_last {
out.push(options.delimiter);
}
}
if trailing_crlf && out.ends_with("\r\n") {
out.truncate(out.len() - 2);
}
Ok(Value::Text(out))
}
fn sort_text(values: &[Value], index: usize, line: u32) -> Result<String, RuntimeError> {
match values.get(index) {
None => Ok(String::new()),
Some(Value::Unset) => Ok(String::new()),
Some(value @ (Value::Object(_) | Value::List(_) | Value::Reference(_))) => {
Err(RuntimeError {
message: crate::runtime::requires(index + 1, "Sort", TypeName::String, value),
line,
})
}
Some(value) => Ok(value.to_text()),
}
}
fn sort_duplicates(left: &str, right: &str, options: &SortOptions) -> bool {
if options.numeric && options.column == 0 {
text_to_double(left) == text_to_double(right)
} else if options.sense == CaseSense::Logical {
compare_logically(left, right) == Ordering::Equal
} else {
compare_texts(left, right, options.sense) == Ordering::Equal
}
}
fn the_failure_in_one(error: RuntimeFailure, line: u32) -> RuntimeError {
match error {
RuntimeFailure::Error(error)
| RuntimeFailure::Detailed(error, _)
| RuntimeFailure::Fatal(error) => error,
RuntimeFailure::Thrown(value) => RuntimeError {
message: value.to_text(),
line,
},
_ => RuntimeError {
message: "the sort stopped the run.".to_string(),
line,
},
}
}
pub(crate) fn str_compare(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let left = text_of(values, 0);
let right = text_of(values, 1);
let order = compare_texts(&left, &right, case_sense(values, 2, "StrCompare", line)?);
Ok(Value::Int(match order {
Ordering::Less => -1,
Ordering::Equal => 0,
Ordering::Greater => 1,
}))
}
pub(crate) fn str_len(
_rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
Ok(Value::Int(
crate::text16::the_number_of_the_code_units(&text_of(values, 0)) as i64,
))
}
pub(crate) fn change_case(
_rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
variant: u8,
) -> Result<Value, RuntimeError> {
let text = text_of(values, 0);
Ok(Value::Text(if variant == 1 {
text.to_uppercase()
} else {
text.to_lowercase()
}))
}
pub(crate) fn str_replace(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let haystack = text_argument("StrReplace", values, 0, line)?;
let needle = text_argument("StrReplace", values, 1, line)?;
let replacement = text_argument("StrReplace", values, 2, line)?;
let sense = match values.get(3) {
Some(Value::Unset) | None => CaseSense::Insensitive,
Some(_) => case_sense(values, 3, "StrReplace", line)?,
};
if sense == CaseSense::Logical {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(4, "StrReplace"),
line,
});
}
let limit = match values.get(5) {
Some(Value::Unset) | None => 0,
Some(_) => number_of(values, 5) as i64,
};
let mut out = String::with_capacity(haystack.len());
let mut rest = haystack.as_str();
let mut replaced = 0i64;
while !needle.is_empty() {
let found = find_in_sense(rest, &needle, sense);
let Some(at) = found else {
break;
};
out.push_str(&rest[..at]);
out.push_str(&replacement);
rest = &rest[at + needle.len()..];
replaced += 1;
if limit > 0 && replaced >= limit {
break;
}
}
out.push_str(rest);
if let Some(value) = values.get(4) {
if matches!(value, Value::Unset) {
return Ok(Value::Text(out));
}
if !matches!(value, Value::Reference(_)) {
return Err(RuntimeError {
message: crate::runtime::wants_a_reference(
5,
"StrReplace",
"a variable reference",
value,
),
line,
});
}
rt.write_reference(value, Value::Int(replaced));
}
Ok(Value::Text(out))
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum TextEncoding {
Utf8,
Utf16,
Cp0,
}
fn the_encoding_of(name: Option<&Value>) -> Result<TextEncoding, String> {
match name {
None => Ok(TextEncoding::Utf16),
Some(Value::Text(text)) => match text.to_ascii_lowercase().as_str() {
"utf-8" => Ok(TextEncoding::Utf8),
"utf-16" => Ok(TextEncoding::Utf16),
"cp0" => Ok(TextEncoding::Cp0),
_ => Err("Invalid Encoding.".to_string()),
},
Some(_) => Err("Invalid Encoding.".to_string()),
}
}
fn the_bytes_of(text: &str, encoding: TextEncoding) -> Vec<u8> {
match encoding {
TextEncoding::Utf8 | TextEncoding::Cp0 => text.as_bytes().to_vec(),
TextEncoding::Utf16 => {
let mut bytes: Vec<u8> = Vec::with_capacity(text.len() * 2);
for unit in text.encode_utf16() {
bytes.extend_from_slice(&unit.to_le_bytes());
}
bytes
}
}
}
fn the_terminator_of(encoding: TextEncoding) -> Vec<u8> {
match encoding {
TextEncoding::Utf8 | TextEncoding::Cp0 => vec![0],
TextEncoding::Utf16 => vec![0, 0],
}
}
fn the_text_of(bytes: &[u8], encoding: TextEncoding, length: Option<usize>) -> String {
match encoding {
TextEncoding::Utf8 | TextEncoding::Cp0 => {
let end = bytes
.iter()
.position(|byte| *byte == 0)
.unwrap_or(bytes.len());
let end = length.map(|length| end.min(length)).unwrap_or(end);
String::from_utf8_lossy(&bytes[..end]).into_owned()
}
TextEncoding::Utf16 => {
let mut units: Vec<u16> = Vec::new();
let mut at = 0;
while at + 1 < bytes.len() {
let unit = u16::from_le_bytes([bytes[at], bytes[at + 1]]);
if unit == 0 {
break;
}
units.push(unit);
at += 2;
if let Some(length) = length {
if units.len() >= length {
break;
}
}
}
String::from_utf16_lossy(&units)
}
}
}
pub(crate) fn str_ptr(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let text = match values.first() {
Some(Value::Text(text)) => text.clone(),
Some(value) => {
return Err(RuntimeError {
message: crate::runtime::expected_type(TypeName::String, value.type_name()),
line,
});
}
None => String::new(),
};
Ok(Value::Int(rt.the_address_of_a_text(&text)))
}
pub(crate) fn str_get(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let Some(source) = values.first() else {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, "StrGet"),
line,
});
};
let bytes: Vec<u8> = match source {
Value::Object(object) => {
if object.borrow().class.eq_ignore_ascii_case("buffer") {
crate::classes::buffer::raw_bytes(source, line).map_err(|failure| RuntimeError {
message: the_message_of(failure),
line,
})?
} else {
let ptr = rt.read_property(source, "Ptr", line).map_err(|failure| {
RuntimeError {
message: the_message_of(failure),
line,
}
})?;
match ptr {
Value::Int(address) => match rt.the_text_at_an_address(address) {
Some(text) => the_bytes_of(&text, TextEncoding::Utf16),
None => match rt.the_buffer_at(address) {
Some(buffer) => crate::classes::buffer::raw_bytes(&buffer, line)
.map_err(|failure| RuntimeError {
message: the_message_of(failure),
line,
})?,
None => return Ok(Value::Text(String::new())),
},
},
_ => {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, "StrGet"),
line,
});
}
}
}
}
Value::Int(address) => match rt.the_text_at_an_address(*address) {
Some(text) => the_bytes_of(&text, TextEncoding::Utf16),
None => match rt.the_buffer_at(*address) {
Some(buffer) => {
crate::classes::buffer::raw_bytes(&buffer, line).map_err(|failure| {
RuntimeError {
message: the_message_of(failure),
line,
}
})?
}
None => {
if (0..0x10000).contains(address) {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, "StrGet"),
line,
});
}
return Ok(Value::Text(String::new()));
}
},
},
Value::Text(_) => {
return Err(RuntimeError {
message: "Parameter #1 invalid.".to_string(),
line,
});
}
_ => {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, "StrGet"),
line,
});
}
};
let (length, encoding_name) = match values.get(1) {
Some(value) if is_numeric_value(value) => {
(Some(token_to_int64(value).max(0) as usize), values.get(2))
}
Some(value) => (None, Some(value)),
None => (None, None),
};
let encoding =
the_encoding_of(encoding_name).map_err(|message| RuntimeError { message, line })?;
Ok(Value::Text(the_text_of(&bytes, encoding, length)))
}
pub(crate) fn str_put(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let _ = &rt;
let text = match values.first() {
Some(Value::Text(text)) => text.clone(),
Some(value @ (Value::Object(_) | Value::List(_) | Value::Reference(_))) => {
return Err(RuntimeError {
message: crate::runtime::requires(1, "StrPut", TypeName::String, value),
line,
});
}
Some(value) => value.to_text(),
None => String::new(),
};
let (target, encoding_name, length_name) = match values.get(1) {
None => (None, values.get(2), values.get(3)),
Some(value @ Value::Object(_)) => {
let empty = values
.get(2)
.map(|value| value.to_text().is_empty())
.unwrap_or(true);
if empty {
(Some(value), values.get(3), None)
} else {
(Some(value), values.get(2), values.get(3))
}
}
Some(value @ Value::Text(_)) => (None, Some(value), values.get(2)),
Some(_) => {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(2, "StrPut"),
line,
});
}
};
if target.is_none() && length_name.is_some() {
return Err(RuntimeError {
message: "Invalid parameter(s).".to_string(),
line,
});
}
let mut capacity: Option<i64> = None;
let encoding = match encoding_name {
Some(value) if is_numeric_value(value) => {
capacity = Some(token_to_int64(value));
TextEncoding::Utf16
}
other => the_encoding_of(other).map_err(|message| RuntimeError { message, line })?,
};
let characters = text.chars().count() as i64;
let mut bytes = the_bytes_of(&text, encoding);
let mut terminator = true;
if let Some(capacity) = capacity {
if capacity < 0 || capacity < characters {
return Err(RuntimeError {
message: "Invalid Length.".to_string(),
line,
});
}
if capacity == characters {
terminator = false;
}
}
if terminator {
bytes.extend_from_slice(&the_terminator_of(encoding));
}
let Some(target) = target else {
return Ok(Value::Int(bytes.len() as i64));
};
let size = match crate::classes::buffer::size_of(target, line) {
Ok(size) => size,
Err(_) => {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(2, "StrPut"),
line,
});
}
};
if bytes.len() as i64 > size {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(2, "StrPut"),
line,
});
}
match crate::classes::buffer::fill(target, &bytes, line) {
Ok(_) => Ok(Value::Int(bytes.len() as i64)),
Err(_) => Err(RuntimeError {
message: crate::runtime::invalid_parameter(2, "StrPut"),
line,
}),
}
}
pub(crate) fn the_message_of(failure: crate::runtime::RuntimeFailure) -> String {
match failure {
crate::runtime::RuntimeFailure::Error(error) => error.message,
crate::runtime::RuntimeFailure::Detailed(error, _) => error.message,
_ => "the runtime cannot answer that.".to_string(),
}
}
pub(crate) fn var_set_str_capacity(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let Some(value) = values.first() else {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, "VarSetStrCapacity"),
line,
});
};
let Value::Reference(reference) = value else {
return Err(RuntimeError {
message: crate::runtime::wants_a_reference(
1,
"VarSetStrCapacity",
"a variable reference",
value,
),
line,
});
};
let Some(capacity) = values.get(1) else {
return match rt.read_reference(reference) {
Some(Value::Text(_)) | None => Ok(Value::Int(rt.string_capacity(reference))),
Some(other) => Err(RuntimeError {
message: crate::runtime::expected_type(TypeName::String, other.type_name()),
line,
}),
};
};
let requested = token_to_int64(capacity);
if requested == -1 {
let length = rt
.read_reference(reference)
.map(|value| value.to_text().chars().count() as i64)
.unwrap_or(0);
return Ok(Value::Int(length));
}
if !(0..=i64::MAX / 2).contains(&requested) {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(2, "VarSetStrCapacity"),
line,
});
}
let current = rt.string_capacity(reference);
let asked_for = rt.keeps_a_string_capacity(reference);
rt.write_reference(value, Value::Text(String::new()));
let capacity = if requested > 0 {
rt.set_string_capacity(reference, requested.max(current));
requested.max(current)
} else if asked_for {
rt.forget_a_string_capacity(reference);
0
} else {
current
};
Ok(Value::Int(capacity))
}
pub(crate) fn sub_str(
_rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let text = crate::text16::the_code_units_of(&text_of(values, 0));
let start = number_of(values, 1) as i64;
let from = start_index(start, text.len()).min(text.len());
let sliced: Vec<u16> = match values.get(2).and_then(|value| value.to_number()) {
Some(length) => {
let length = length as i64;
if length < 0 {
let to = text.len().saturating_sub((-length) as usize).max(from);
text[from..to].to_vec()
} else {
let to = (from + length as usize).min(text.len());
text[from..to].to_vec()
}
}
None => text[from..].to_vec(),
};
Ok(Value::Text(crate::text16::the_text_of(&sliced)))
}
fn start_index(start: i64, length: usize) -> usize {
if start < 0 {
(length as i64 + start).max(0) as usize
} else if start == 0 {
length
} else {
(start - 1) as usize
}
}
pub(crate) fn trim(
_rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
variant: u8,
) -> Result<Value, RuntimeError> {
let characters: Vec<char> = text_of(values, 0).chars().collect();
let set: Vec<char> = values
.get(1)
.map(|value| value.to_text())
.unwrap_or_else(|| " \t".to_string())
.chars()
.collect();
let mut start = 0usize;
let mut end = characters.len();
if variant != 2 {
while start < end && set.contains(&characters[start]) {
start += 1;
}
}
if variant != 1 {
while end > start && set.contains(&characters[end - 1]) {
end -= 1;
}
}
Ok(Value::Text(characters[start..end].iter().collect()))
}
pub(crate) fn is_value(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
variant: u8,
) -> Result<Value, RuntimeError> {
let name = the_name_of_the_variant_of_is_value(variant);
if values.len() > 1 {
return Err(RuntimeError {
message: format!("Parameter #2 of {name} is invalid."),
line,
});
}
let value = values
.first()
.cloned()
.unwrap_or(Value::Text(String::new()));
let answer = match variant {
1 => is_number(&value),
2 => is_integer(&value),
3 => is_float(&value),
4 => is_time(&value),
5 => is_digits(&text_of_value(&value, line)?),
6 => is_hex_digits(&text_of_value(&value, line)?),
7 => is_alnum(&text_of_value(&value, line)?),
8 => is_alpha(&text_of_value(&value, line)?),
9 => is_upper(&text_of_value(&value, line)?),
10 => is_lower(&text_of_value(&value, line)?),
_ => is_space(&text_of_value(&value, line)?),
};
Ok(Value::Int(if answer { 1 } else { 0 }))
}
fn the_name_of_the_variant_of_is_value(variant: u8) -> &'static str {
match variant {
1 => "IsNumber",
2 => "IsInteger",
3 => "IsFloat",
4 => "IsTime",
5 => "IsDigit",
6 => "IsXDigit",
7 => "IsAlnum",
8 => "IsAlpha",
9 => "IsUpper",
10 => "IsLower",
_ => "IsSpace",
}
}
pub(crate) fn is_object(
_rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let value = values.first().cloned().unwrap_or(Value::Int(0));
let answer = !matches!(value, Value::Int(_) | Value::Float(_) | Value::Text(_));
Ok(Value::Int(if answer { 1 } else { 0 }))
}
pub(crate) fn type_of(
rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let value = values.first().cloned().unwrap_or(Value::Int(0));
let name = match value.type_name() {
TypeName::Integer => "Integer",
TypeName::Float => "Float",
TypeName::String => "String",
TypeName::Object => "Object",
TypeName::VarRef => "VarRef",
TypeName::Number => "Number",
TypeName::Class => "Class",
TypeName::ComValue => "ComValue",
};
if rt.class_name_of(&value).is_some() {
return Ok(Value::Text("Class".into()));
}
if let Value::Object(_) = &value {
if let Some(class) = rt.class_of(&value) {
return Ok(Value::Text(class));
}
}
Ok(Value::Text(name.into()))
}
pub(crate) fn is_set(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
match values.first() {
Some(Value::Reference(reference)) if reference.alias => {
let set = match rt.read_reference(reference) {
Some(Value::Unset) | Some(Value::Skipped) => false,
Some(_) => true,
None => false,
};
Ok(Value::Int(if set { 1 } else { 0 }))
}
_ => Err(RuntimeError {
message: "IsSet requires a variable.".to_string(),
line,
}),
}
}
fn text_of_value(value: &Value, line: u32) -> Result<String, RuntimeError> {
match value {
Value::Text(text) => Ok(text.clone()),
other => Err(RuntimeError {
message: crate::runtime::expected_type(TypeName::String, other.type_name()),
line,
}),
}
}
fn is_number(value: &Value) -> bool {
is_integer(value) || is_float(value)
}
fn is_integer(value: &Value) -> bool {
match value {
Value::Int(_) => true,
Value::Float(_) => false,
Value::Text(text) => is_integer_text(text),
_ => false,
}
}
fn is_float(value: &Value) -> bool {
match value {
Value::Float(_) => true,
Value::Int(_) => false,
Value::Text(text) => is_float_text(text),
_ => false,
}
}
fn is_integer_text(text: &str) -> bool {
let text = text.trim_matches(&[' ', '\t'][..]);
let rest = text.strip_prefix(&['+', '-'][..]).unwrap_or(text);
if rest.is_empty() {
return false;
}
if let Some(digits) = rest.strip_prefix("0x").or_else(|| rest.strip_prefix("0X")) {
return !digits.is_empty()
&& digits
.chars()
.all(|character| character.is_ascii_hexdigit());
}
rest.chars().all(|character| character.is_ascii_digit())
}
fn is_float_text(text: &str) -> bool {
let text = text.trim_matches(&[' ', '\t'][..]);
let rest = text.strip_prefix(&['+', '-'][..]).unwrap_or(text);
let (mantissa, exponent) = match rest.find(['e', 'E']) {
Some(at) => (&rest[..at], Some(&rest[at + 1..])),
None => (rest, None),
};
if let Some(exponent) = exponent {
let exponent = exponent.strip_prefix(&['+', '-'][..]).unwrap_or(exponent);
if exponent.is_empty() || !exponent.chars().all(|character| character.is_ascii_digit()) {
return false;
}
}
let Some(point) = mantissa.find('.') else {
return false;
};
let (whole, fraction) = mantissa.split_at(point);
let fraction = &fraction[1..];
if whole.is_empty() && fraction.is_empty() {
return false;
}
whole.chars().all(|character| character.is_ascii_digit())
&& fraction.chars().all(|character| character.is_ascii_digit())
}
fn is_digits(text: &str) -> bool {
text.chars().all(|character| character.is_ascii_digit())
}
fn is_hex_digits(text: &str) -> bool {
let rest = text
.strip_prefix("0x")
.or_else(|| text.strip_prefix("0X"))
.unwrap_or(text);
rest.chars().all(|character| character.is_ascii_hexdigit())
}
fn is_alpha(text: &str) -> bool {
text.chars()
.all(|character| character.is_ascii_alphabetic())
}
fn is_alnum(text: &str) -> bool {
text.chars()
.all(|character| character.is_ascii_alphanumeric())
}
fn is_upper(text: &str) -> bool {
text.chars().all(|character| character.is_ascii_uppercase())
}
fn is_lower(text: &str) -> bool {
text.chars().all(|character| character.is_ascii_lowercase())
}
fn is_space(text: &str) -> bool {
text.chars()
.all(|character| matches!(character, ' ' | '\t' | '\n' | '\r' | '\u{b}' | '\u{c}'))
}
fn is_time(value: &Value) -> bool {
let text = value.to_text();
if !text.chars().all(|character| character.is_ascii_digit()) {
return false;
}
let digits = text.len();
if !(4..=14).contains(&digits) || digits % 2 != 0 {
return false;
}
let year: u32 = text[..4].parse().unwrap_or(0);
(1601..=9999).contains(&year)
}
pub(crate) fn regex_match(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let output = match values.get(2) {
None => None,
Some(value @ Value::Reference(_)) => Some(value.clone()),
Some(value) => {
return Err(RuntimeError {
message: crate::runtime::wants_a_reference(
3,
"RegExMatch",
"a variable reference",
value,
),
line,
});
}
};
let text = regex_text(values, 0, "RegExMatch", line)?;
let pattern = regex_text(values, 1, "RegExMatch", line)?;
let mut starting = 0usize;
if let Some(value) = values.get(3) {
if !is_numeric_value(value) {
return Err(RuntimeError {
message: crate::runtime::requires(4, "RegExMatch", TypeName::Number, value),
line,
});
}
let length = text.chars().count() as i64;
let mut place = token_to_int64(value) as i32 as i64;
if place <= 0 {
place += length;
if place < 0 {
place = 0;
}
} else if place > length {
place = length;
} else {
place -= 1;
}
starting = place as usize;
}
let regex = crate::regex::Regex::new(&pattern).map_err(|reason| RuntimeError {
message: reason,
line,
})?;
let found = regex
.find_at(&text, starting)
.map_err(|reason| RuntimeError {
message: reason,
line,
})?;
let Some(found) = found else {
if let Some(output) = &output {
rt.write_reference(output, Value::Text(String::new()));
}
return Ok(Value::Int(0));
};
let place = found.span().0 as i64 + 1;
if let Some(output) = &output {
rt.write_reference(
output,
crate::classes::regexmatchinfo::of(&text, ®ex, &found),
);
}
Ok(Value::Int(place))
}
fn regex_text(
values: &[Value],
index: usize,
name: &str,
line: u32,
) -> Result<String, RuntimeError> {
match values.get(index) {
None => Ok(String::new()),
Some(Value::Unset) => Ok(String::new()),
Some(value @ (Value::Object(_) | Value::List(_) | Value::Reference(_))) => {
Err(RuntimeError {
message: crate::runtime::requires(index + 1, name, TypeName::String, value),
line,
})
}
Some(value) => Ok(value.to_text()),
}
}
pub(crate) fn regex_replace(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let text = regex_text(values, 0, "RegExReplace", line)?;
let pattern = regex_text(values, 1, "RegExReplace", line)?;
let replacement = text_argument("RegExReplace", values, 2, line)?;
let limit = number_of(values, 4) as i64;
let starting = (number_of(values, 5) as i64).max(1) as usize - 1;
let regex = crate::regex::Regex::new(&pattern).map_err(|reason| RuntimeError {
message: reason,
line,
})?;
let characters: Vec<char> = text.chars().collect();
let mut out = String::with_capacity(text.len());
let mut at = starting.min(characters.len());
out.extend(characters[..at].iter());
let mut replaced = 0i64;
while at <= characters.len() {
let found = regex.find_at(&text, at).map_err(|reason| RuntimeError {
message: reason,
line,
})?;
let Some(found) = found else {
break;
};
let (start, end) = found.span();
out.extend(characters[at..start].iter());
out.push_str(&expand_replacement(
&replacement,
®ex,
&found,
&characters,
));
replaced += 1;
if end == start {
if end < characters.len() {
out.push(characters[end]);
}
at = end + 1;
} else {
at = end;
}
if limit > 0 && replaced >= limit {
break;
}
}
if at <= characters.len() {
out.extend(characters[at..].iter());
}
if let Some(value) = values.get(3) {
if !matches!(value, Value::Reference(_)) {
return Err(RuntimeError {
message: crate::runtime::wants_a_reference(
4,
"RegExReplace",
"a variable reference",
value,
),
line,
});
}
rt.write_reference(value, Value::Int(replaced));
}
Ok(Value::Text(out))
}
fn expand_replacement(
replacement: &str,
regex: &crate::regex::Regex,
found: &crate::regex::Match,
characters: &[char],
) -> String {
let mut out = String::new();
let mut rest = replacement;
while let Some(at) = rest.find(['$', '\\']) {
out.push_str(&rest[..at]);
let marker = rest[at..].chars().next().unwrap_or('$');
let tail = &rest[at + marker.len_utf8()..];
if marker == '$' && tail.starts_with('$') {
out.push('$');
rest = &tail[1..];
continue;
}
let (name, after) = match tail.strip_prefix('{') {
Some(braced) => match braced.find('}') {
Some(close) => (&braced[..close], &braced[close + 1..]),
None => ("", tail),
},
None => {
let count = tail
.chars()
.take_while(|character| character.is_ascii_digit())
.count();
(&tail[..count], &tail[count..])
}
};
match name.parse::<usize>() {
Ok(group) => {
out.push_str(&found.group(group, characters).unwrap_or_default());
rest = after;
}
Err(_) => match regex.group_number(name) {
Some(group) => {
out.push_str(&found.group(group, characters).unwrap_or_default());
rest = after;
}
None => {
out.push(marker);
rest = tail;
}
},
}
}
out.push_str(rest);
out
}
pub(crate) fn click(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let mut words: Vec<String> = Vec::new();
for value in values {
for word in value.to_text().split_whitespace() {
words.push(word.to_string());
}
}
let mut place: Option<(i64, i64)> = None;
let mut button = "left".to_string();
let mut count = 1u32;
let mut relative = false;
let mut pressing: Option<bool> = None;
let mut wheel: Option<String> = None;
let mut at = 0usize;
while at < words.len() {
let word = words[at].clone();
if let Ok(number) = word.parse::<f64>() {
let next_is_a_number = words
.get(at + 1)
.map(|next| next.parse::<f64>().is_ok())
.unwrap_or(false);
if place.is_none() && next_is_a_number {
let y = words[at + 1].parse::<f64>().unwrap_or(0.0);
place = Some((number as i64, y as i64));
at += 2;
continue;
}
count = number.max(1.0) as u32;
at += 1;
continue;
}
match word.to_lowercase().as_str() {
"left" | "l" => button = "left".to_string(),
"right" | "r" => button = "right".to_string(),
"middle" | "m" => button = "middle".to_string(),
"x1" => button = "x1".to_string(),
"x2" => button = "x2".to_string(),
"rel" | "relative" => relative = true,
"down" | "d" => pressing = Some(true),
"up" | "u" => pressing = Some(false),
other
if other.starts_with("wheel")
|| other == "wu"
|| other == "wd"
|| other == "wl"
|| other == "wr" =>
{
wheel = Some(the_wheel_of(other).unwrap_or("wheelup").to_string());
}
other => {
return Err(RuntimeError {
message: format!("{other} is not a part of a click."),
line,
});
}
}
at += 1;
}
let (x, y) = match place {
Some(place) => place,
None => {
let (pointer_x, pointer_y) = rt
.desktop()
.mouse_position()
.map_err(|e| desktop_failure(e, line))?;
(pointer_x, pointer_y)
}
};
let (x, y) = if relative {
let (pointer_x, pointer_y) = rt
.desktop()
.mouse_position()
.map_err(|e| desktop_failure(e, line))?;
(x + pointer_x, y + pointer_y)
} else {
(x, y)
};
if let Some(wheel) = wheel {
let detail = rt
.desktop()
.mouse_wheel(Some(x), Some(y), &wheel, count)
.map_err(|e| desktop_failure(e, line))?;
return Ok(Value::Text(detail));
}
if let Some(down) = pressing {
let detail = if down {
rt.desktop()
.mouse_down(Some(x), Some(y), &button)
.map_err(|e| desktop_failure(e, line))?
} else {
rt.desktop()
.mouse_up(Some(x), Some(y), &button)
.map_err(|e| desktop_failure(e, line))?
};
return Ok(Value::Text(detail));
}
let detail = rt
.desktop()
.click(x, y, &button, count)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Text(detail))
}
pub(crate) fn mouse_click(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let spelled = values
.first()
.map(|value| value.to_text())
.unwrap_or_default();
let button = if spelled.is_empty() {
"left".to_string()
} else {
spelled
};
let wheel = the_wheel_of(&button);
let name = match button.to_lowercase().as_str() {
"left" | "l" => "left",
"right" | "r" => "right",
"middle" | "m" => "middle",
"x1" => "x1",
"x2" => "x2",
_ if wheel.is_some() => "left",
_ => {
return Err(RuntimeError {
message: "Parameter #1 of MouseClick is invalid.".into(),
line,
});
}
};
let x = values
.get(1)
.and_then(|value| value.to_number())
.map(|number| number as i64);
let y = values
.get(2)
.and_then(|value| value.to_number())
.map(|number| number as i64);
let count = values
.get(3)
.and_then(|value| value.to_number())
.unwrap_or(1.0)
.max(1.0) as u32;
let options = values
.get(5)
.map(|value| value.to_text().trim().to_lowercase())
.unwrap_or_default();
if let Some(wheel) = wheel {
let detail = rt
.desktop()
.mouse_wheel(x, y, wheel, count)
.map_err(|e| desktop_failure(e, line))?;
return Ok(Value::Text(detail));
}
match options.as_str() {
"" => {}
"down" => {
let detail = rt
.desktop()
.mouse_down(x, y, name)
.map_err(|e| desktop_failure(e, line))?;
return Ok(Value::Text(detail));
}
"up" => {
let detail = rt
.desktop()
.mouse_up(x, y, name)
.map_err(|e| desktop_failure(e, line))?;
return Ok(Value::Text(detail));
}
_ => {
return Err(RuntimeError {
message: "Parameter #6 of MouseClick is invalid.".into(),
line,
});
}
}
let (x, y) = match (x, y) {
(Some(x), Some(y)) => (x, y),
_ => {
let (pointer_x, pointer_y) = rt
.desktop()
.mouse_position()
.map_err(|e| desktop_failure(e, line))?;
(pointer_x, pointer_y)
}
};
let detail = rt
.desktop()
.click(x, y, name, count)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Text(detail))
}
fn the_wheel_of(button: &str) -> Option<&'static str> {
match button.trim().to_lowercase().as_str() {
"wheelup" | "wu" => Some("wheelup"),
"wheeldown" | "wd" => Some("wheeldown"),
"wheelleft" | "wl" => Some("wheelleft"),
"wheelright" | "wr" => Some("wheelright"),
_ => None,
}
}
pub(crate) fn mouse_click_drag(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let words = words_of(values);
let mut at = 0usize;
let mut button = "left".to_string();
if let Some(word) = words.first() {
if let Some(name) = button_of(word) {
button = name.to_string();
at = 1;
} else if word.parse::<f64>().is_err() {
return Err(RuntimeError {
message: format!(
"{word} is not a button of a mouse: the tree carries the left, the right and the middle one."
),
line,
});
}
}
let mut numbers: Vec<i64> = Vec::new();
for word in &words[at..] {
match word.parse::<f64>() {
Ok(number) => numbers.push(number as i64),
Err(_) => {
return Err(RuntimeError {
message: format!(
"{word} is not a part of a drag: the tree carries the two places and not the speed or the relative mode."
),
line,
});
}
}
}
if numbers.len() < 4 {
return Err(RuntimeError {
message: "a drag wants the two places: the one where the button goes down and the one where it comes up."
.into(),
line,
});
}
let (x1, y1, x2, y2) = (numbers[0], numbers[1], numbers[2], numbers[3]);
rt.desktop()
.mouse_down(Some(x1), Some(y1), &button)
.map_err(|e| desktop_failure(e, line))?;
rt.desktop()
.move_pointer(x2, y2)
.map_err(|e| desktop_failure(e, line))?;
rt.desktop()
.mouse_up(None, None, &button)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Int(1))
}
pub(crate) fn set_working_dir(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let directory = text_of(values, 0);
if directory.is_empty() {
return Err(RuntimeError {
message: "the name of the directory is missing.".into(),
line,
});
}
rt.desktop()
.set_working_directory(&directory)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Int(1))
}
pub(crate) fn str_title(
_rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
Ok(Value::Text(title_case(&text_of(values, 0))))
}
fn title_case(text: &str) -> String {
let mut out = String::with_capacity(text.len());
let mut at_a_word = true;
for character in text.chars() {
if character.is_alphabetic() {
if at_a_word {
out.extend(character.to_uppercase());
at_a_word = false;
} else {
out.extend(character.to_lowercase());
}
} else {
out.push(character);
if character.is_whitespace() {
at_a_word = true;
}
}
}
out
}
pub(crate) fn ver_compare(
_rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let first = text_of(values, 0);
let second = text_of(values, 1);
if let Some((operator, wanted)) = split_operator(&second) {
let order = compare_versions(&first, wanted.trim());
let answer = match operator {
"<" => order < 0,
"<=" => order <= 0,
">" => order > 0,
">=" => order >= 0,
_ => order == 0,
};
return Ok(Value::Int(answer as i64));
}
Ok(Value::Int(compare_versions(&first, second.trim()) as i64))
}
pub(crate) fn is_label(
rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let name = text_of(values, 0);
Ok(Value::Int(if rt.has_label(&name) { 1 } else { 0 }))
}
fn words_of(values: &[Value]) -> Vec<String> {
let mut words = Vec::new();
for value in values {
for word in value.to_text().split_whitespace() {
words.push(word.to_string());
}
}
words
}
fn button_of(word: &str) -> Option<&'static str> {
match word.to_lowercase().as_str() {
"left" | "l" => Some("left"),
"right" | "r" => Some("right"),
"middle" | "m" => Some("middle"),
_ => None,
}
}
fn split_operator(version: &str) -> Option<(&'static str, &str)> {
let trimmed = version.trim_start();
for operator in ["<=", ">=", "<", ">", "="] {
if let Some(rest) = trimmed.strip_prefix(operator) {
return Some((operator, rest));
}
}
None
}
fn compare_versions(first: &str, second: &str) -> i32 {
let (first_numbers, first_pre) = split_version(first);
let (second_numbers, second_pre) = split_version(second);
let order = compare_numbers(&first_numbers, &second_numbers);
if order != 0 {
return order;
}
match (first_pre, second_pre) {
(None, None) => 0,
(Some(_), None) => -1,
(None, Some(_)) => 1,
(Some(first_pre), Some(second_pre)) => compare_pre(first_pre, second_pre),
}
}
fn split_version(version: &str) -> (Vec<u64>, Option<&str>) {
let trimmed = version.trim();
let (numbers, pre) = match trimmed.split_once('-') {
Some((numbers, pre)) => (numbers, Some(pre)),
None => (trimmed, None),
};
let numbers = numbers
.split('.')
.map(|part| part.trim().parse::<u64>().unwrap_or(0).min(2147483647))
.collect();
(numbers, pre)
}
fn compare_numbers(first: &[u64], second: &[u64]) -> i32 {
let count = first.len().max(second.len());
for index in 0..count {
let left = first.get(index).copied().unwrap_or(0);
let right = second.get(index).copied().unwrap_or(0);
if left != right {
return if left < right { -1 } else { 1 };
}
}
0
}
fn compare_pre(first: &str, second: &str) -> i32 {
match (first.parse::<u64>(), second.parse::<u64>()) {
(Ok(left), Ok(right)) => {
if left == right {
0
} else if left < right {
-1
} else {
1
}
}
(Ok(_), Err(_)) => -1,
(Err(_), Ok(_)) => 1,
(Err(_), Err(_)) => match first.cmp(second) {
core::cmp::Ordering::Less => -1,
core::cmp::Ordering::Equal => 0,
core::cmp::Ordering::Greater => 1,
},
}
}
pub(crate) fn mouse_get_pos(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let (x, y) = rt
.desktop()
.mouse_position()
.map_err(|e| desktop_failure(e, line))?;
let places = [
Value::Int(x),
Value::Int(y),
Value::Text(String::new()),
Value::Text(String::new()),
];
for (index, place) in places.into_iter().enumerate() {
let Some(value) = values.get(index) else {
continue;
};
if !matches!(value, Value::Reference(_)) {
return Err(RuntimeError {
message: crate::runtime::wants_a_reference(
index + 1,
"MouseGetPos",
"a VarRef",
value,
),
line,
});
}
rt.write_reference(value, place);
}
Ok(Value::Text(String::new()))
}
pub(crate) fn mouse_move(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let _ = values.get(2);
let relative = match values.get(3) {
None => false,
Some(value) => {
let text = value.to_text();
if text.trim().eq_ignore_ascii_case("R") {
true
} else {
return Err(RuntimeError {
message: "Parameter #4 of MouseMove is invalid.".into(),
line,
});
}
}
};
let mut x = number_of(values, 0) as i64;
let mut y = number_of(values, 1) as i64;
if relative {
let (here_x, here_y) = rt
.desktop()
.mouse_position()
.map_err(|reason| RuntimeError {
message: reason,
line,
})?;
x += here_x;
y += here_y;
}
let detail = rt
.desktop()
.move_pointer(x, y)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Text(detail))
}
pub(crate) fn pixel_get_color(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let (x, y) = if values.len() >= 2 {
(number_of(values, 0) as i64, number_of(values, 1) as i64)
} else {
let (pointer_x, pointer_y) = rt
.desktop()
.mouse_position()
.map_err(|e| desktop_failure(e, line))?;
(pointer_x, pointer_y)
};
let colour = rt
.desktop()
.pixel(x, y)
.map_err(|e| desktop_failure(e, line))?;
rt.set_global("pixel", Value::Text(colour.clone()));
Ok(Value::Text(colour))
}
pub(crate) fn pixel_search(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
for index in 0..2 {
let Some(value) = values.get(index) else {
continue;
};
if !matches!(value, Value::Reference(_)) {
return Err(RuntimeError {
message: crate::runtime::wants_a_reference(
index + 1,
"PixelSearch",
"a VarRef",
value,
),
line,
});
}
}
let x1 = number_of(values, 2) as i64;
let y1 = number_of(values, 3) as i64;
let x2 = number_of(values, 4) as i64;
let y2 = number_of(values, 5) as i64;
let colour = text_of(values, 6);
let found = rt
.desktop()
.pixel_search(x1, y1, x2, y2, &colour)
.map_err(|e| desktop_failure(e, line))?;
match found {
Some((x, y)) => {
rt.write_reference(&values[0], Value::Int(x));
rt.write_reference(&values[1], Value::Int(y));
Ok(Value::Int(1))
}
None => {
rt.write_reference(&values[0], Value::Text(String::new()));
rt.write_reference(&values[1], Value::Text(String::new()));
Ok(Value::Int(0))
}
}
}
pub(crate) fn screenshot(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let x = number_of(values, 0) as i64;
let y = number_of(values, 1) as i64;
let width = number_of(values, 2) as i64;
let height = number_of(values, 3) as i64;
let name = text_of(values, 4);
let path = rt
.desktop()
.capture(x, y, width, height, &name)
.map_err(|e| desktop_failure(e, line))?;
rt.set_global("screenshot", Value::Text(path.clone()));
Ok(Value::Text(path))
}
fn a_window_answers(
mode: crate::desktop::TitleMatch,
window: &crate::desktop::WindowInfo,
wanted: &str,
) -> bool {
let criteria = crate::desktop::criteria::WindowCriteria::parse(wanted);
a_window_answers_the_criteria(mode, window, &criteria, &window.exe)
}
fn a_window_answers_the_criteria(
mode: crate::desktop::TitleMatch,
window: &crate::desktop::WindowInfo,
criteria: &crate::desktop::criteria::WindowCriteria,
exe: &str,
) -> bool {
criteria
.matches(
&window.title,
&window.class,
exe,
window.id,
window.pid,
mode,
)
.unwrap_or(false)
}
pub(crate) fn a_window_answers_the_target(
mode: crate::desktop::TitleMatch,
window: &crate::desktop::WindowInfo,
wanted: &crate::desktop::TheWindowWanted,
exe: &str,
) -> bool {
if wanted.asked && wanted.title.is_empty() {
return false;
}
let criteria = crate::desktop::criteria::WindowCriteria::parse(&wanted.title);
if !a_window_answers_the_criteria(mode, window, &criteria, exe) {
return false;
}
if !window.has_the_text(&wanted.text) {
return false;
}
for excluded in &wanted.exclude_titles {
if mode.matches(&window.title, excluded).unwrap_or(false) {
return false;
}
}
for excluded in &wanted.exclude_texts {
if window.has_the_text(excluded) {
return false;
}
}
true
}
fn the_windows_that_answer(
rt: &mut Runtime<'_>,
wanted: &crate::desktop::TheWindowWanted,
line: u32,
) -> Result<Vec<crate::desktop::WindowInfo>, RuntimeError> {
let windows = rt
.desktop()
.windows()
.map_err(|reason| desktop_failure(reason, line))?;
Ok(the_windows_of_the_listing(rt, &windows, wanted))
}
pub(crate) fn the_windows_of_the_listing(
rt: &mut Runtime<'_>,
windows: &[crate::desktop::WindowInfo],
wanted: &crate::desktop::TheWindowWanted,
) -> Vec<crate::desktop::WindowInfo> {
let mode = crate::settings::title_match_mode();
let criteria = crate::desktop::criteria::WindowCriteria::parse(&wanted.title);
let wants_the_exe = criteria.exe.is_some();
let mut answer = Vec::new();
for window in windows {
let exe = if wants_the_exe {
rt.desktop().window_exe(window.id)
} else {
String::new()
};
if a_window_answers_the_target(mode, window, wanted, &exe) {
answer.push(window.clone());
}
}
answer
}
fn the_window_in(
windows: &[crate::desktop::WindowInfo],
value: Option<&Value>,
) -> Result<Option<crate::desktop::WindowInfo>, RuntimeError> {
match value {
Some(Value::Int(id)) => Ok(windows.iter().find(|window| window.id == *id).cloned()),
Some(value) if !value.to_text().is_empty() => {
let wanted = value.to_text();
let mode = crate::settings::title_match_mode();
for window in windows {
if a_window_answers(mode, window, &wanted) {
return Ok(Some(window.clone()));
}
}
Ok(None)
}
_ => Ok(windows.iter().find(|window| window.active).cloned()),
}
}
fn no_window(line: u32) -> RuntimeError {
RuntimeError {
message: "Target window not found.".to_string(),
line,
}
}
pub(crate) fn window_active(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let wanted = window_target(values)?;
match rt.desktop().windows() {
Ok(windows) => {
let windows = the_windows_of_the_listing(rt, &windows, &wanted);
let window = the_window_in(&windows, values.first())?;
return Ok(Value::Int(match window {
Some(window) if window.active => window.id,
_ => 0,
}));
}
Err(reason) => {
if matches!(values.first(), Some(Value::Int(_))) {
return Err(RuntimeError {
message: format!("WinActive cannot look a window up by its id: {reason}"),
line,
});
}
}
}
let title = text_of(values, 0);
let mode = crate::settings::title_match_mode();
match rt
.desktop()
.window_active(&title, mode)
.map_err(|e| desktop_failure(e, line))?
{
WindowAnswer::Active => Ok(Value::Int(1)),
WindowAnswer::NotActive | WindowAnswer::Absent => Ok(Value::Int(0)),
WindowAnswer::Unknown(reason) => Err(RuntimeError {
message: format!("WinActive cannot answer: {reason}"),
line,
}),
}
}
pub(crate) fn window_exist(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let wanted = window_target(values)?;
match rt.desktop().windows() {
Ok(windows) => {
let windows = the_windows_of_the_listing(rt, &windows, &wanted);
let window = the_window_in(&windows, values.first())?;
if let Some(window) = &window {
rt.remember_the_last_window(&window.id.to_string());
}
return Ok(Value::Int(window.map(|window| window.id).unwrap_or(0)));
}
Err(reason) => {
if matches!(values.first(), Some(Value::Int(_))) {
return Err(RuntimeError {
message: format!("WinExist cannot look a window up by its id: {reason}"),
line,
});
}
}
}
let title = text_of(values, 0);
let mode = crate::settings::title_match_mode();
match rt
.desktop()
.window_exists(&title, mode)
.map_err(|e| desktop_failure(e, line))?
{
WindowAnswer::Active | WindowAnswer::NotActive => Ok(Value::Int(1)),
WindowAnswer::Absent => Ok(Value::Int(0)),
WindowAnswer::Unknown(reason) => Err(RuntimeError {
message: format!("WinExist cannot answer: {reason}"),
line,
}),
}
}
pub(crate) fn win_get_title(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let wanted = window_target(values)?;
let asked = !values.is_empty();
if wanted.asked && wanted.title.is_empty() {
return Err(no_window(line));
}
if let Ok(windows) = rt.desktop().windows() {
let windows = the_windows_of_the_listing(rt, &windows, &wanted);
let window = the_window_in(&windows, values.first())?;
let title = match window {
Some(window) => window.title,
None if asked => return Err(no_window(line)),
None => String::new(),
};
let delay = crate::settings::the_win_delay();
if delay > 0 {
rt.sleep_ms(delay as u64);
}
return Ok(Value::Text(title));
}
if asked && matches!(values.first(), Some(Value::Int(_))) {
let reason = rt.desktop().windows().err().unwrap_or_default();
return Err(RuntimeError {
message: format!("WinGetTitle cannot look a window up by its id: {reason}"),
line,
});
}
let title = rt
.desktop()
.active_window_title()
.map_err(|e| desktop_failure(e, line))?;
let delay = crate::settings::the_win_delay();
if delay > 0 {
rt.sleep_ms(delay as u64);
}
Ok(Value::Text(title.unwrap_or_default()))
}
fn the_process_of(values: &[Value], index: usize) -> Option<String> {
values.get(index).map(|value| value.to_text())
}
fn the_timeout_of(
values: &[Value],
index: usize,
name: &str,
line: u32,
) -> Result<Option<f64>, RuntimeError> {
if values.get(index).is_none() {
return Ok(None);
}
Ok(Some(number_argument(values, index, line, name)?))
}
fn no_process(line: u32) -> RuntimeError {
RuntimeError {
message: "Target process not found.".to_string(),
line,
}
}
pub(crate) fn process_exist(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let which = the_process_of(values, 0);
let pid = rt
.desktop()
.process_exist(which.as_deref())
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Int(pid as i64))
}
pub(crate) fn process_get_name(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let which = the_process_of(values, 0);
let answer = rt
.desktop()
.process_name(which.as_deref())
.map_err(|e| desktop_failure(e, line))?;
match answer {
Some(name) => Ok(Value::Text(name)),
None => Err(no_process(line)),
}
}
pub(crate) fn process_get_path(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let which = the_process_of(values, 0);
let answer = rt
.desktop()
.process_path(which.as_deref())
.map_err(|e| desktop_failure(e, line))?;
match answer {
Some(path) => Ok(Value::Text(path)),
None => Err(no_process(line)),
}
}
pub(crate) fn process_get_parent(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let which = the_process_of(values, 0);
let pid = rt
.desktop()
.process_parent(which.as_deref())
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Int(pid as i64))
}
pub(crate) fn process_close(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let Some(which) = the_process_of(values, 0) else {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, "ProcessClose"),
line,
});
};
let pid = rt
.desktop()
.process_close(&which)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Int(pid as i64))
}
pub(crate) fn process_wait(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let Some(which) = the_process_of(values, 0) else {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, "ProcessWait"),
line,
});
};
let timeout = the_timeout_of(values, 1, "ProcessWait", line)?;
let pid = rt
.desktop()
.process_wait(&which, timeout)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Int(pid as i64))
}
pub(crate) fn process_wait_close(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let Some(which) = the_process_of(values, 0) else {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, "ProcessWaitClose"),
line,
});
};
let timeout = the_timeout_of(values, 1, "ProcessWaitClose", line)?;
let pid = rt
.desktop()
.process_wait_close(&which, timeout)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Int(pid as i64))
}
pub(crate) fn process_set_priority(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let priority = values
.first()
.map(|value| value.to_text())
.unwrap_or_default();
let letter = priority
.chars()
.next()
.map(|letter| letter.to_ascii_uppercase());
if !matches!(letter, Some('L' | 'B' | 'N' | 'A' | 'H' | 'R')) {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, "ProcessSetPriority"),
line,
});
}
let which = the_process_of(values, 1);
let answer = rt
.desktop()
.process_set_priority(&priority, which.as_deref())
.map_err(|e| desktop_failure(e, line))?;
match answer {
Some(pid) => Ok(Value::Int(pid as i64)),
None => Err(no_process(line)),
}
}
fn the_monitor_of(
rt: &mut Runtime<'_>,
values: &[Value],
name: &str,
line: u32,
) -> Result<(usize, Vec<crate::desktop::Monitor>), RuntimeError> {
let wanted = match values.first() {
None => 0,
Some(value) => token_to_int64(value) as i32 as i64,
};
let monitors = rt
.desktop()
.monitors()
.map_err(|e| desktop_failure(e, line))?;
if wanted == 0 {
let primary = rt
.desktop()
.primary_monitor()
.map_err(|e| desktop_failure(e, line))?;
if primary == 0 || primary > monitors.len() {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, name),
line,
});
}
return Ok((primary, monitors));
}
if wanted < 0 || wanted as usize > monitors.len() {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, name),
line,
});
}
Ok((wanted as usize, monitors))
}
fn the_monitor_at(
monitors: &[crate::desktop::Monitor],
index: usize,
) -> Option<crate::desktop::Monitor> {
monitors.get(index.checked_sub(1)?).cloned()
}
pub(crate) fn monitor_get(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
the_monitor_bounds_into(rt, values, line, "MonitorGet")
}
pub(crate) fn monitor_get_count(
rt: &mut Runtime<'_>,
_values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let monitors = rt
.desktop()
.monitors()
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Int(monitors.len() as i64))
}
pub(crate) fn monitor_get_name(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let (index, monitors) = the_monitor_of(rt, values, "MonitorGetName", line)?;
let Some(monitor) = the_monitor_at(&monitors, index) else {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, "MonitorGetName"),
line,
});
};
if monitor.name.is_empty() {
return Err(RuntimeError {
message: "this desktop does not say the name of its monitors.".to_string(),
line,
});
}
Ok(Value::Text(monitor.name))
}
pub(crate) fn monitor_get_primary(
rt: &mut Runtime<'_>,
_values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let index = rt
.desktop()
.primary_monitor()
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Int(index as i64))
}
pub(crate) fn monitor_get_work_area(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let (index, monitors) = the_monitor_of(rt, values, "MonitorGetWorkArea", line)?;
if the_monitor_at(&monitors, index).is_none() {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, "MonitorGetWorkArea"),
line,
});
}
let Some((left, top, right, bottom)) = rt
.desktop()
.monitor_work_area(index)
.map_err(|e| desktop_failure(e, line))?
else {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, "MonitorGetWorkArea"),
line,
});
};
for (place, number) in [(1, left), (2, top), (3, right), (4, bottom)] {
if let Some(value) = values.get(place) {
rt.write_reference(value, Value::Int(number));
}
}
Ok(Value::Int(1))
}
pub(crate) fn sys_get(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let Some(value) = values.first() else {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, "SysGet"),
line,
});
};
let metric = token_to_int64(value) as i32 as i64;
let monitors = rt
.desktop()
.monitors()
.map_err(|e| desktop_failure(e, line))?;
if monitors.is_empty() && (0..=102).contains(&metric) && metric != 81 {
return Err(RuntimeError {
message: format!(
"the compositor published no monitor, so the metric {metric} of SysGet is not \
known."
),
line,
});
}
let answer = match metric {
0 | 16 => {
let index = rt
.desktop()
.primary_monitor()
.map_err(|e| desktop_failure(e, line))?;
match the_monitor_at(&monitors, index) {
Some(monitor) => monitor.width(),
None => 0,
}
}
1 => {
let index = rt
.desktop()
.primary_monitor()
.map_err(|e| desktop_failure(e, line))?;
match the_monitor_at(&monitors, index) {
Some(monitor) => monitor.height(),
None => 0,
}
}
76 => monitors
.iter()
.map(|monitor| monitor.left)
.min()
.unwrap_or(0),
77 => monitors
.iter()
.map(|monitor| monitor.top)
.min()
.unwrap_or(0),
78 => {
let left = monitors.iter().map(|m| m.left).min().unwrap_or(0);
let right = monitors.iter().map(|m| m.right).max().unwrap_or(0);
right - left
}
79 => {
let top = monitors.iter().map(|m| m.top).min().unwrap_or(0);
let bottom = monitors.iter().map(|m| m.bottom).max().unwrap_or(0);
bottom - top
}
80 => monitors.len() as i64,
81 => 1,
other if (0..=102).contains(&other) => {
match rt.desktop().system_metric(other as i32) {
Some(value) => value,
None => {
return Err(RuntimeError {
message: format!(
"SysGet({other}) is a metric of the window manager of Windows, and this \
desktop does not have one."
),
line,
});
}
}
}
_ => 0,
};
Ok(Value::Int(answer))
}
pub(crate) fn sys_get_ip_addresses(
rt: &mut Runtime<'_>,
_values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let addresses = rt
.desktop()
.ip_addresses()
.map_err(|e| desktop_failure(e, line))?;
let items: Vec<Value> = addresses.into_iter().map(Value::Text).collect();
crate::classes::array::construct(&items, rt, line).map_err(|failure| RuntimeError {
message: the_message_of(failure),
line,
})
}
fn set_lock_state(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
lock: &str,
) -> Result<Value, RuntimeError> {
let word = text_of(values, 0).trim().to_lowercase();
let wanted = match word.as_str() {
"on" => Some(true),
"off" => Some(false),
_ => None,
};
if let Some(on) = wanted {
rt.desktop()
.set_lock_light(lock, on)
.map_err(|reason| desktop_failure(reason, line))?;
}
Ok(Value::Text(String::new()))
}
pub(crate) fn output_debug(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let text = values
.first()
.map(|value| value.to_text())
.unwrap_or_default();
rt.desktop()
.output_debug(&text)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn file_recycle(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let Some(value) = values.first() else {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, "FileRecycle"),
line,
});
};
let pattern = value.to_text();
if pattern.is_empty() {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, "FileRecycle"),
line,
});
}
rt.desktop()
.recycle(&pattern)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn file_recycle_empty(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let drive = values
.first()
.map(|value| value.to_text())
.filter(|text| !text.is_empty());
rt.desktop()
.empty_trash(drive.as_deref())
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn msg_box(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let text = rt.interpolate(&text_of(values, 0), line)?;
let title = if values.len() > 1 {
rt.interpolate(&text_of(values, 1), line)?
} else {
String::new()
};
let options = match values.get(2) {
Some(Value::Int(n)) => *n,
Some(Value::Float(f)) => *f as i64,
_ => 0,
};
#[cfg(feature = "std")]
let button = {
let desktop_ptr: *mut (dyn crate::desktop::Desktop + '_) = rt.desktop();
let previous = crate::callback::set_current(rt);
let answer = unsafe { (*desktop_ptr).msg_box(&text, &title, options) };
crate::callback::clear_current(previous);
answer.map_err(|e| desktop_failure(e, line))?
};
#[cfg(not(feature = "std"))]
let button = rt
.desktop()
.msg_box(&text, &title, options)
.map_err(|e| desktop_failure(e, line))?;
rt.push_output(text);
Ok(Value::Text(button))
}
pub(crate) fn run(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let command = text_of(values, 0);
let working_dir = text_of(values, 1);
let (code, stdout, stderr, pid) = if values.len() > 3 {
rt.desktop()
.run_with_pid(&command, &working_dir)
.map_err(|e| desktop_failure(e, line))?
} else {
let (code, stdout, stderr) = rt
.desktop()
.run(&command, &working_dir)
.map_err(|e| desktop_failure(e, line))?;
(code, stdout, stderr, 0)
};
if values.len() > 3 {
if let Some(variable) = values.get(3) {
if matches!(variable, Value::Reference(_)) {
rt.write_reference(variable, Value::Int(pid as i64));
}
}
}
if !stdout.trim().is_empty() {
rt.push_output(stdout.trim_end().to_string());
}
if !stderr.trim().is_empty() {
rt.push_output(stderr.trim_end().to_string());
}
Ok(Value::Int(code as i64))
}
pub(crate) fn send(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let text = rt.interpolate(&text_of(values, 0), line)?;
let mut parts = Vec::new();
for part in split_send(&text) {
let said = match part {
SendPart::Text(text) => rt.desktop().type_text(&text),
SendPart::Key { name, modifiers } => rt.desktop().press_key(&name, &modifiers),
SendPart::Down(name) => match mouse_button(&name) {
Some(button) => rt.desktop().mouse_down(None, None, button),
None => rt.desktop().key_down(&name),
},
SendPart::Up(name) => match mouse_button(&name) {
Some(button) => rt.desktop().mouse_up(None, None, button),
None => rt.desktop().key_up(&name),
},
};
parts.push(said.map_err(|e| desktop_failure(e, line))?);
}
Ok(Value::Text(parts.concat()))
}
pub(crate) fn sleep(
rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let millis = number_of(values, 0).clamp(0.0, 60_000.0) as u64;
rt.sleep_ms(millis);
Ok(Value::Int(millis as i64))
}
const CLIP_POLL_MS: u64 = 50;
pub(crate) fn clip_wait(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
if number_of(values, 1) != 0.0 {
return Err(RuntimeError {
message: "the clipboard of this runtime carries text only, and it cannot wait for data of any kind.".to_string(),
line,
});
}
let limit = if values.is_empty() {
None
} else {
Some(number_of(values, 0) * 1000.0)
};
let started = rt.now_ms();
loop {
let text = rt
.desktop()
.clipboard_read()
.map_err(|message| desktop_failure(message, line))?;
if !text.is_empty() {
return Ok(Value::Int(1));
}
let waited = rt.now_ms().saturating_sub(started) as f64;
let left = match limit {
Some(limit) => {
if waited >= limit {
return Ok(Value::Int(0));
}
limit - waited
}
None => {
let left = rt.remaining_ms();
if left == 0 {
return Ok(Value::Int(0));
}
left as f64
}
};
rt.sleep_ms((left as u64).clamp(1, CLIP_POLL_MS));
}
}
const FORMAT_LIMIT: usize = 100_000;
#[derive(Clone, Copy, Default)]
struct FormatFlags {
minus: bool,
plus: bool,
space: bool,
hash: bool,
zero: bool,
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum FormatKind {
Int,
Float,
Char,
Pointer,
Str(Option<char>),
}
struct FormatSpec {
flags: FormatFlags,
width: usize,
precision: Option<usize>,
kind: FormatKind,
letter: char,
}
enum FormatValue {
Int(i64),
Float(f64),
Text(String),
}
fn parse_spec_number(chars: &[char]) -> Option<usize> {
let mut value = 0usize;
for character in chars {
if !character.is_ascii_digit() {
return None;
}
value = value
.checked_mul(10)?
.checked_add(character.to_digit(10)? as usize)?;
if value > FORMAT_LIMIT {
return None;
}
}
Some(value)
}
fn parse_format_spec(chars: &[char], mut at: usize) -> Option<(FormatSpec, usize)> {
let start = at;
let mut spec = FormatSpec {
flags: FormatFlags::default(),
width: 0,
precision: None,
kind: FormatKind::Str(None),
letter: 's',
};
while at < chars.len() {
match chars[at] {
'-' => spec.flags.minus = true,
'+' => spec.flags.plus = true,
' ' => spec.flags.space = true,
'#' => spec.flags.hash = true,
'0' => spec.flags.zero = true,
_ => break,
}
at += 1;
}
let width_start = at;
while at < chars.len() && chars[at].is_ascii_digit() {
at += 1;
}
if at > width_start {
spec.width = parse_spec_number(&chars[width_start..at])?;
}
if at < chars.len() && chars[at] == '.' {
at += 1;
let precision_start = at;
while at < chars.len() && chars[at].is_ascii_digit() {
at += 1;
}
spec.precision = Some(parse_spec_number(&chars[precision_start..at])?);
}
if at - start + 4 >= 52 {
return None;
}
let letter = *chars.get(at)?;
match letter {
'd' | 'i' | 'o' | 'u' | 'x' | 'X' => {
spec.kind = FormatKind::Int;
spec.letter = letter;
at += 1;
}
'e' | 'E' | 'f' | 'g' | 'G' | 'a' | 'A' => {
spec.kind = FormatKind::Float;
spec.letter = letter;
at += 1;
}
'c' | 'C' => {
spec.kind = FormatKind::Char;
spec.letter = letter;
at += 1;
}
'p' => {
spec.kind = FormatKind::Pointer;
spec.letter = letter;
at += 1;
}
_ => {
if "ULlTt".contains(letter) {
spec.kind = FormatKind::Str(Some(letter.to_ascii_uppercase()));
at += 1;
}
if chars.get(at) == Some(&'s') {
at += 1;
}
spec.letter = 's';
}
}
Some((spec, at))
}
fn format_argument(
spec: &FormatSpec,
value: &Value,
parameter: usize,
line: u32,
) -> Result<FormatValue, RuntimeError> {
if matches!(value, Value::Unset) {
return Ok(FormatValue::Text(String::new()));
}
match spec.kind {
FormatKind::Str(_) => match value {
Value::Int(number) => Ok(FormatValue::Text(number.to_string())),
Value::Float(number) => Ok(FormatValue::Text(crate::float_text::the_text_of(*number))),
Value::Text(text) => Ok(FormatValue::Text(text.clone())),
other => Err(RuntimeError {
message: crate::runtime::requires(parameter, "Format", TypeName::String, other),
line,
}),
},
FormatKind::Float => {
if !is_numeric_value(value) {
return Err(RuntimeError {
message: crate::runtime::requires(parameter, "Format", TypeName::Number, value),
line,
});
}
Ok(FormatValue::Float(token_to_double(value)))
}
_ => {
if !is_numeric_value(value) {
return Err(RuntimeError {
message: crate::runtime::requires(parameter, "Format", TypeName::Number, value),
line,
});
}
Ok(FormatValue::Int(token_to_int64(value)))
}
}
}
fn format_pattern(pattern: &str, values: &[Value], line: u32) -> Result<String, RuntimeError> {
let chars: Vec<char> = pattern.chars().collect();
let mut out = String::with_capacity(pattern.len() + 8);
let mut lit = 0usize;
let mut position = 0usize;
let mut last_parameter = 0usize;
loop {
let mut at = position;
while at < chars.len() && chars[at] != '{' {
at += 1;
}
if lit < at {
out.extend(chars[lit..at].iter());
}
lit = at;
if at >= chars.len() {
break;
}
let mut cursor = at + 1;
if cursor + 1 < chars.len()
&& (chars[cursor] == '{' || chars[cursor] == '}')
&& chars[cursor + 1] == '}'
{
out.push(chars[cursor]);
cursor += 2;
lit = cursor;
position = cursor;
continue;
}
let digits_start = cursor;
while cursor < chars.len() && chars[cursor].is_ascii_digit() {
cursor += 1;
}
let parameter = if cursor > digits_start {
match parse_spec_number(&chars[digits_start..cursor]) {
Some(number) => number,
None => usize::MAX,
}
} else {
last_parameter + 1
};
if parameter >= values.len() || parameter < 1 {
position = cursor;
continue;
}
let parsed = if cursor < chars.len() && chars[cursor] == ':' {
parse_format_spec(&chars, cursor + 1)
} else {
Some((
FormatSpec {
flags: FormatFlags::default(),
width: 0,
precision: None,
kind: FormatKind::Str(None),
letter: 's',
},
cursor,
))
};
let Some((spec, next)) = parsed else {
position = cursor;
continue;
};
let argument = format_argument(&spec, &values[parameter], parameter + 1, line)?;
if next >= chars.len() || chars[next] != '}' {
position = next;
continue;
}
out.push_str(&format_spec(&spec, &argument));
last_parameter = parameter;
lit = next + 1;
position = next + 1;
}
Ok(out)
}
fn format_spec(spec: &FormatSpec, value: &FormatValue) -> String {
match spec.kind {
FormatKind::Str(custom) => {
let mut text = match value {
FormatValue::Text(text) => text.clone(),
_ => String::new(),
};
if let Some(precision) = spec.precision {
text = text.chars().take(precision).collect();
}
let fill = if spec.flags.zero && !spec.flags.minus {
'0'
} else {
' '
};
let text = pad_text(&text, spec.width, fill, spec.flags.minus);
match custom {
Some('U') => text.to_uppercase(),
Some('L') => text.to_lowercase(),
Some('T') => title_case(&text),
_ => text,
}
}
FormatKind::Int => format_integer(
spec,
match value {
FormatValue::Int(number) => *number,
_ => 0,
},
),
FormatKind::Char => {
let number = match value {
FormatValue::Int(number) => *number,
_ => 0,
};
let text = character_text(spec.letter, number);
pad_text(&text, spec.width, ' ', spec.flags.minus)
}
FormatKind::Pointer => {
let number = match value {
FormatValue::Int(number) => *number,
_ => 0,
};
let text = format!("{:016X}", number as u64);
pad_text(&text, spec.width, ' ', spec.flags.minus)
}
FormatKind::Float => format_float(
spec,
match value {
FormatValue::Float(number) => *number,
_ => 0.0,
},
),
}
}
fn pad_text(text: &str, width: usize, fill: char, on_the_right: bool) -> String {
let length = text.chars().count();
if length >= width {
return text.to_string();
}
let mut out = String::with_capacity(width);
if on_the_right {
out.push_str(text);
for _ in length..width {
out.push(fill);
}
} else {
for _ in length..width {
out.push(fill);
}
out.push_str(text);
}
out
}
fn format_integer(spec: &FormatSpec, number: i64) -> String {
let unsigned = number as u64;
let mut sign = String::new();
let mut prefix = String::new();
let mut digits: String;
match spec.letter {
'd' | 'i' => {
if number < 0 {
sign.push('-');
} else if spec.flags.plus {
sign.push('+');
} else if spec.flags.space {
sign.push(' ');
}
digits = number.unsigned_abs().to_string();
}
'u' => digits = unsigned.to_string(),
'o' => {
digits = format!("{unsigned:o}");
if spec.flags.hash && !digits.starts_with('0') {
prefix.push('0');
}
}
'x' | 'X' => {
digits = if spec.letter == 'X' {
format!("{unsigned:X}")
} else {
format!("{unsigned:x}")
};
if spec.flags.hash && number != 0 {
prefix.push_str(if spec.letter == 'X' { "0X" } else { "0x" });
}
}
_ => digits = number.to_string(),
}
if let Some(precision) = spec.precision {
if precision == 0 && number == 0 {
digits.clear();
} else if digits.chars().count() < precision {
digits = format!("{}{digits}", "0".repeat(precision - digits.chars().count()));
}
}
let body = format!("{sign}{prefix}{digits}");
let length = body.chars().count();
if length >= spec.width {
return body;
}
let count = spec.width - length;
if spec.flags.minus {
format!("{body}{}", " ".repeat(count))
} else if spec.flags.zero && spec.precision.is_none() {
format!("{sign}{prefix}{}{digits}", "0".repeat(count))
} else {
format!("{}{body}", " ".repeat(count))
}
}
fn character_text(letter: char, number: i64) -> String {
let code = if letter == 'C' {
(number as u64 & 0xff) as u32
} else {
(number as u64 & 0xffff) as u32
};
match char::from_u32(code) {
Some(character) => character.to_string(),
None => "\u{fffd}".to_string(),
}
}
fn format_float(spec: &FormatSpec, number: f64) -> String {
if number.is_nan() {
let text = if number.is_sign_negative() {
"-nan(ind)"
} else {
"nan(ind)"
};
return pad_text(text, spec.width, ' ', spec.flags.minus);
}
if number.is_infinite() {
let text = if number < 0.0 { "-inf" } else { "inf" };
return pad_text(text, spec.width, ' ', spec.flags.minus);
}
let negative = number.is_sign_negative();
let magnitude = number.abs();
let mut sign = String::new();
if negative {
sign.push('-');
} else if spec.flags.plus {
sign.push('+');
} else if spec.flags.space {
sign.push(' ');
}
let letter = spec.letter.to_ascii_lowercase();
let uppercase = spec.letter.is_ascii_uppercase();
let body = match letter {
'e' => exponent_text(magnitude, spec, uppercase),
'g' => general_text(magnitude, spec, uppercase),
'a' => hex_float_text(magnitude, spec, uppercase),
_ => fixed_text(magnitude, spec),
};
let text = format!("{sign}{body}");
let length = text.chars().count();
if length >= spec.width {
return text;
}
let count = spec.width - length;
if spec.flags.minus {
format!("{text}{}", " ".repeat(count))
} else if spec.flags.zero {
format!("{sign}{}{body}", "0".repeat(count))
} else {
format!("{}{text}", " ".repeat(count))
}
}
fn fixed_text(magnitude: f64, spec: &FormatSpec) -> String {
let precision = spec.precision.unwrap_or(6);
let mut text = format!("{magnitude:.precision$}");
if spec.flags.hash && precision == 0 {
text.push('.');
}
text
}
fn exponent_text(magnitude: f64, spec: &FormatSpec, uppercase: bool) -> String {
let precision = spec.precision.unwrap_or(6);
let text = format!("{magnitude:.precision$e}");
let (mantissa, exponent) = text
.split_once('e')
.expect("the exponential form of a number has an exponent");
let exponent: i32 = exponent.parse().expect("the exponent is a number");
let mut mantissa = mantissa.to_string();
if spec.flags.hash && precision == 0 {
mantissa.push('.');
}
format!(
"{mantissa}{}{}{:02}",
if uppercase { 'E' } else { 'e' },
if exponent < 0 { '-' } else { '+' },
exponent.abs()
)
}
fn general_text(magnitude: f64, spec: &FormatSpec, uppercase: bool) -> String {
let precision = spec.precision.unwrap_or(6);
let precision = if precision == 0 { 1 } else { precision };
if magnitude == 0.0 {
return if spec.flags.hash {
format!("{:.*}", precision - 1, 0.0)
} else {
"0".to_string()
};
}
let scientific = format!("{:.*e}", precision - 1, magnitude);
let (mantissa, exponent) = scientific
.split_once('e')
.expect("the exponential form of a number has an exponent");
let exponent: i32 = exponent.parse().expect("the exponent is a number");
if exponent < -4 || exponent >= precision as i32 {
let mut mantissa = mantissa.to_string();
if !spec.flags.hash {
strip_trailing_zeros(&mut mantissa);
}
return format!(
"{mantissa}{}{}{:02}",
if uppercase { 'E' } else { 'e' },
if exponent < 0 { '-' } else { '+' },
exponent.abs()
);
}
let decimals = (precision as i32 - 1 - exponent).max(0) as usize;
let mut text = format!("{magnitude:.decimals$}");
if !spec.flags.hash {
strip_trailing_zeros(&mut text);
}
text
}
fn strip_trailing_zeros(text: &mut String) {
if !text.contains('.') {
return;
}
while text.ends_with('0') {
text.pop();
}
if text.ends_with('.') {
text.pop();
}
}
fn hex_float_text(magnitude: f64, spec: &FormatSpec, uppercase: bool) -> String {
let bits = magnitude.to_bits();
let exponent_field = ((bits >> 52) & 0x7ff) as i64;
let fraction = bits & 0x000f_ffff_ffff_ffff;
let (mut leading, exponent) = if magnitude == 0.0 {
(0u64, 0i64)
} else if exponent_field == 0 {
(0u64, -1022i64)
} else {
(1u64, exponent_field - 1023)
};
let asked = spec.precision.unwrap_or(13);
let precision = asked.min(13);
let shift = 52 - 4 * precision;
let mut kept = if shift > 0 {
(fraction + (1u64 << (shift - 1))) >> shift
} else {
fraction
};
if precision < 13 && kept == (1u64 << (4 * precision)) {
leading += 1;
kept = 0;
}
let mut digits = if precision == 0 {
String::new()
} else {
format!("{kept:0width$x}", width = precision)
};
if asked > 13 {
digits.push_str(&"0".repeat(asked - 13));
}
let mut text = format!("0x{leading}");
if !digits.is_empty() {
text.push('.');
text.push_str(&digits);
}
text.push(if uppercase { 'P' } else { 'p' });
text.push(if exponent < 0 { '-' } else { '+' });
text.push_str(&format!("{}", exponent.abs()));
if uppercase {
text = text.to_uppercase();
}
text
}
enum SendPart {
Text(String),
Key {
name: String,
modifiers: Vec<String>,
},
Down(String),
Up(String),
}
fn mouse_button(name: &str) -> Option<&'static str> {
match name.to_lowercase().as_str() {
"lbutton" | "left" => Some("left"),
"rbutton" | "right" => Some("right"),
"mbutton" | "middle" => Some("middle"),
_ => None,
}
}
fn split_send(text: &str) -> Vec<SendPart> {
let mut parts = Vec::new();
let mut buffer = String::new();
let mut modifiers: Vec<String> = Vec::new();
let chars: Vec<char> = text.chars().collect();
let mut index = 0usize;
let mut raw = false;
let modifier_name = |character: char| match character {
'^' => Some("ctrl"),
'+' => Some("shift"),
'!' => Some("alt"),
'#' => Some("super"),
_ => None,
};
while index < chars.len() {
if raw {
buffer.push(chars[index]);
index += 1;
continue;
}
if let Some(name) = modifier_name(chars[index]) {
let next = chars.get(index + 1);
let is_literal = match next {
None => true,
Some(next) => next.is_whitespace(),
};
if !is_literal {
modifiers.push(name.to_string());
index += 1;
continue;
}
}
if !modifiers.is_empty() {
parts.push(SendPart::Key {
name: chars[index].to_string(),
modifiers: core::mem::take(&mut modifiers),
});
index += 1;
continue;
}
if chars[index] == '{' {
if let Some(offset) = chars[index + 1..].iter().position(|c| *c == '}') {
let close = index + 1 + offset;
let name: String = chars[index + 1..close].iter().collect();
if !buffer.is_empty() {
parts.push(SendPart::Text(core::mem::take(&mut buffer)));
}
if name.chars().count() == 1
&& modifier_name(name.chars().next().unwrap()).is_some()
{
parts.push(SendPart::Text(name));
} else if name.eq_ignore_ascii_case("raw") {
raw = true;
} else {
let (key, state, times) = match name.rsplit_once(' ') {
Some((key, "down")) => (key.to_string(), Some(true), 1),
Some((key, "up")) => (key.to_string(), Some(false), 1),
Some((key, times))
if !times.is_empty() && times.chars().all(|c| c.is_ascii_digit()) =>
{
(key.to_string(), None, times.parse::<usize>().unwrap_or(1))
}
_ => (name.clone(), None, 1),
};
match state {
Some(true) => parts.push(SendPart::Down(key)),
Some(false) => parts.push(SendPart::Up(key)),
None => {
let modifiers = core::mem::take(&mut modifiers);
for _ in 0..times {
parts.push(SendPart::Key {
name: key.clone(),
modifiers: modifiers.clone(),
});
}
}
}
}
index = close + 1;
continue;
}
}
buffer.push(chars[index]);
index += 1;
}
if !buffer.is_empty() {
parts.push(SendPart::Text(buffer));
}
parts
}
pub(crate) fn ks_atan2(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let y = number_argument(values, 0, line, "ATan2")?;
let x = number_argument(values, 1, line, "ATan2")?;
Ok(Value::Float(crate::runtime::atan2(y, x)))
}
pub(crate) fn ks_hyperbolic(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
variant: u8,
) -> Result<Value, RuntimeError> {
let name = match variant {
0 => "Sinh",
1 => "Cosh",
_ => "Tanh",
};
let number = number_argument(values, 0, line, name)?;
let result = match variant {
0 => crate::runtime::sinh(number),
1 => crate::runtime::cosh(number),
_ => crate::runtime::tanh(number),
};
Ok(Value::Float(result))
}
pub(crate) fn ks_random_seed(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let seed = number_argument(values, 0, line, "RandomSeed")?;
rt.seed_the_random(seed as i64);
Ok(Value::Text(String::new()))
}
pub(crate) fn ks_replace_line_endings(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let _ = line;
let text = text_of(values, 0);
let ending = if values.len() > 1 {
text_of(values, 1)
} else {
"\n".to_string()
};
let mut out = String::new();
let mut characters = text.chars().peekable();
while let Some(character) = characters.next() {
let is_ending = match character {
'\r' => {
if characters.peek() == Some(&'\n') {
characters.next();
}
true
}
'\n' | '\u{000C}' | '\u{0085}' | '\u{2028}' | '\u{2029}' => true,
_ => false,
};
if is_ending {
out.push_str(&ending);
} else {
out.push(character);
}
}
Ok(Value::Text(out))
}
pub(crate) fn ks_file_full_path(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let path = text_of(values, 0);
rt.desktop()
.full_path(&path)
.map(Value::Text)
.map_err(|reason| desktop_failure(reason, line))
}
pub(crate) fn ks_file_create_temp(
rt: &mut Runtime<'_>,
_values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
rt.desktop()
.create_temp_file()
.map(Value::Text)
.map_err(|reason| desktop_failure(reason, line))
}
pub(crate) fn ks_output_debug_line(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let text = values
.first()
.map(|value| value.to_text())
.unwrap_or_default();
rt.desktop()
.output_debug(&(text + "\n"))
.map_err(|reason| desktop_failure(reason, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn ks_collect(
_rt: &mut Runtime<'_>,
_values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
Ok(Value::Text(String::new()))
}
pub(crate) fn the_builtin_in_the_dialect(
dialect: &'static dyn crate::dialect::Dialect,
wanted: &str,
) -> Option<&'static Builtin> {
dialect
.builtins()
.iter()
.find(|builtin| builtin.name.to_lowercase() == wanted)
.or_else(|| dialect.the_builtin_of_the_extension(wanted))
}
pub(crate) fn ks_throw(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let value = values.first().cloned().unwrap_or(Value::Unset);
rt.throw_the_value(value);
Err(RuntimeError {
message: "the value was thrown".to_string(),
line,
})
}
pub(crate) fn ks_props(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let value = values.first().cloned().unwrap_or(Value::Unset);
let Some(pairs) = rt.the_properties_of_a_value(&value) else {
let kind = rt.the_type_of(&value);
return Err(RuntimeError {
message: format!("Parameter #1 of Props requires an Object, but received a {kind}."),
line,
});
};
Ok(crate::classes::enumerator::make(
pairs,
crate::classes::enumerator::Alone::TheKey,
))
}
pub(crate) fn ks_is_component_available(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let name = text_of(values, 0).to_lowercase();
let answer = match name.as_str() {
"parser" | "parsing" => 1,
"compiler" | "compilation" => 0,
_ => {
return Err(RuntimeError {
message: format!("Unknown capability \"{name}\"."),
line,
});
}
};
Ok(Value::Int(answer))
}
pub(crate) fn ks_validate_script(
rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let code = text_of(values, 0);
let (source, file) = match rt.desktop().read_file(&code) {
Ok(lines) => (lines.join("\n"), Some(code.clone())),
Err(_) => (code.clone(), None),
};
let parsed = crate::parser::parse_with(&source, rt.dialect());
let mut errors: Vec<Value> = Vec::new();
let valid = match parsed {
Ok(_) => 1,
Err(failure) => {
let place = match &file {
Some(file) => format!("{file}:{}:{}", failure.line, failure.column),
None => format!("{}:{}", failure.line, failure.column),
};
errors.push(Value::Text(format!("{place}: {}", failure.message)));
0
}
};
let object = crate::classes::object("object");
let Value::Object(object) = object else {
return Err(RuntimeError {
message: "this runtime cannot make an object".to_string(),
line: _line,
});
};
object.borrow_mut().put("IsValid", Value::Int(valid));
object.borrow_mut().put(
"Errors",
crate::classes::array::construct(&errors, rt, _line).map_err(|failure| RuntimeError {
message: crate::runtime::the_message_of(&failure),
line: _line,
})?,
);
object.borrow_mut().put(
"Warnings",
crate::classes::array::construct(&[], rt, _line).map_err(|failure| RuntimeError {
message: crate::runtime::the_message_of(&failure),
line: _line,
})?,
);
Ok(Value::Object(object))
}
pub(crate) fn ks_get_key_info(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let text = match values.first() {
Some(value) => value.to_text(),
None => String::new(),
};
let (prefix, modifiers, rest) = crate::keys::the_modifier_prefix_of(&text);
let mut vk = crate::settings::key_code(rest);
let mut sc = crate::settings::key_event(rest) as u32;
let name = crate::settings::key_name(rest);
if (vk == 0 && sc == 0) || name.is_empty() {
return Ok(Value::Int(0));
}
if let Some(layout_value) = values.get(1) {
if !matches!(layout_value, Value::Unset) {
let layout = layout_value.to_text();
let (the_vk, the_sc) = rt
.desktop()
.key_in_layout(vk, rest, &layout)
.map_err(|reason| RuntimeError {
message: reason,
line,
})?;
vk = the_vk;
sc = the_sc;
}
}
Ok(crate::classes::keyinfo::the_key_info(
vk, sc, &name, modifiers, &prefix,
))
}
pub(crate) fn ks_obj_get_data_ptr(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let value = match values.first() {
Some(value) => value,
None => {
return Err(RuntimeError {
message: "Too few parameters passed to function.".to_string(),
line,
});
}
};
let Value::Object(object) = value else {
return Err(RuntimeError {
message: crate::runtime::requires(1, "ObjGetDataPtr", TypeName::Object, value),
line,
});
};
match object
.borrow()
.value_of(crate::classes::typed::THE_DATA_POINTER)
{
Some(address) => Ok(address),
None => Err(RuntimeError {
message: "Operation failed.".to_string(),
line,
}),
}
}
pub(crate) fn ks_obj_get_data_size(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let value = match values.first() {
Some(value) => value,
None => {
return Err(RuntimeError {
message: "Too few parameters passed to function.".to_string(),
line,
});
}
};
let Value::Object(object) = value else {
return Err(RuntimeError {
message: crate::runtime::requires(1, "ObjGetDataSize", TypeName::Object, value),
line,
});
};
let class = object.borrow().class.clone();
let size = match crate::classes::typed::the_class_of(&class) {
Some((_, size, _)) => size,
None => 0,
};
Ok(Value::Int(size))
}
pub(crate) fn ks_obj_set_data_ptr(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let value = match values.first() {
Some(value) => value,
None => {
return Err(RuntimeError {
message: "Too few parameters passed to function.".to_string(),
line,
});
}
};
let Value::Object(object) = value else {
return Err(RuntimeError {
message: crate::runtime::requires(1, "ObjSetDataPtr", TypeName::Object, value),
line,
});
};
let address = match values.get(1).and_then(|value| value.to_number()) {
Some(number) => number as i64,
None => {
let second = values.get(1).unwrap_or(&Value::Unset);
return Err(RuntimeError {
message: crate::runtime::requires(2, "ObjSetDataPtr", TypeName::Number, second),
line,
});
}
};
let borrows = object
.borrow()
.value_of(crate::classes::typed::THE_DATA_POINTER)
.is_some();
if !borrows {
return Err(RuntimeError {
message: "Operation failed.".to_string(),
line,
});
}
object
.borrow_mut()
.put(crate::classes::typed::THE_DATA_POINTER, Value::Int(address));
Ok(Value::Text(String::new()))
}
pub(crate) fn ks_obj_create_with_data_ptr(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let invalid = || RuntimeError {
message: "Invalid class.".to_string(),
line,
};
let name = match values.first() {
Some(Value::Object(object)) => match object.borrow().value_of(crate::runtime::CLASS_NAME) {
Some(Value::Text(name)) => name,
_ => return Err(invalid()),
},
_ => return Err(invalid()),
};
let class = match crate::classes::typed::the_class_of(&name) {
Some((_, _, _)) => name.to_lowercase(),
None => return Err(invalid()),
};
let address = match values.get(1).and_then(|value| value.to_number()) {
Some(number) => number as i64,
None => {
let second = values.get(1).unwrap_or(&Value::Unset);
return Err(RuntimeError {
message: crate::runtime::requires(
2,
"ObjCreateWithDataPtr",
TypeName::Number,
second,
),
line,
});
}
};
match crate::classes::typed::the_view_at(&class, address, "ObjCreateWithDataPtr", 2, line) {
Some(Ok(value)) => {
let _ = rt;
Ok(value)
}
Some(Err(error)) => Err(error),
None => Err(invalid()),
}
}
pub(crate) fn ks_show_debug(
_rt: &mut Runtime<'_>,
_values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
Ok(Value::Text(String::new()))
}
fn the_pieces_of_a_command_line(text: &str) -> Vec<String> {
let mut pieces: Vec<String> = Vec::new();
let mut current = String::new();
let mut quoted = false;
let mut has = false;
for character in text.chars() {
match character {
'"' => {
quoted = !quoted;
has = true;
}
other => {
if other.is_whitespace() && !quoted {
if has {
pieces.push(current.clone());
current.clear();
has = false;
}
continue;
}
current.push(other);
has = true;
}
}
}
if has {
pieces.push(current);
}
pieces
}
pub(crate) fn ks_mail(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let failure = |message: String| RuntimeError { message, line };
let mut to: Vec<String> = Vec::new();
let first = values.first().unwrap_or(&Value::Unset);
match first {
Value::Text(text) => {
if !text.is_empty() {
to.push(text.clone());
}
}
Value::Object(object) if object.borrow().class == "array" => {
for (index, item) in crate::classes::array::the_items(first).iter().enumerate() {
match item {
Value::Text(text) if !text.is_empty() => to.push(text.clone()),
Value::Text(_) => {
return Err(failure(format!("Recipient {} is empty.", index + 1)));
}
other => {
return Err(failure(format!(
"Recipient {} is {}; every recipient must be a String.",
index + 1,
other.the_kind()
)));
}
}
}
}
other => return Err(failure(expected_type(TypeName::String, other.type_name()))),
}
if to.is_empty() {
return Err(failure("At least one recipient is required.".to_string()));
}
let subject = text_of(values, 1);
let body = text_of(values, 2);
let mut host: Option<String> = None;
let mut port: u16 = 25;
let mut from: Option<String> = None;
let mut reply_to: Option<String> = None;
let mut cc: Vec<String> = Vec::new();
let mut bcc: Vec<String> = Vec::new();
let mut attachments: Vec<String> = Vec::new();
let mut headers: Vec<(String, String)> = Vec::new();
if let Some(value) = values.get(3) {
if !matches!(value, Value::Unset) {
let pairs = match crate::classes::map::the_pairs(value) {
Some(pairs) => pairs,
None => return Err(failure("The options of Mail must be a Map.".to_string())),
};
for (key, val) in pairs {
let item = key.to_text();
if item.is_empty() {
continue;
}
match item.to_lowercase().as_str() {
"host" => {
let Value::Text(text) = val else {
return Err(failure(format!(
"The \"{item}\" option must be a String."
)));
};
let mut named = text.clone();
if let Some(colon) = text.rfind(':') {
if text.rfind(']').is_none_or(|bracket| bracket < colon) {
let (left, right) = text.split_at(colon + 1);
let number = right.trim().parse::<i64>();
match number {
Ok(number) if (1..=65535).contains(&number) => {
port = number as u16;
named = left[..left.len() - 1].to_string();
}
_ => {
return Err(failure(format!(
"\"{right}\" is not a port between 1 and 65535."
)));
}
}
}
}
if named.is_empty() {
return Err(failure(format!("The \"{item}\" option names no server.")));
}
host = Some(named);
}
"from" | "replyto" => {
let Value::Text(text) = val else {
return Err(failure(format!(
"The \"{item}\" option must be a String."
)));
};
if item.eq_ignore_ascii_case("from") {
from = Some(text.clone());
} else {
reply_to = Some(text.clone());
}
}
"cc" | "bcc" | "attachments" => {
let wanted = item.to_lowercase();
let list = match &val {
Value::Text(text) => vec![text.clone()],
Value::Object(inner) if inner.borrow().class == "array" => {
let mut out: Vec<String> = Vec::new();
for entry in crate::classes::array::the_items(&val) {
let Value::Text(text) = entry else {
return Err(failure(format!(
"The \"{item}\" option must be a String or an Array of them."
)));
};
out.push(text.clone());
}
out
}
_ => {
return Err(failure(format!(
"The \"{item}\" option must be a String or an Array of them."
)));
}
};
match wanted.as_str() {
"cc" => cc = list,
"bcc" => bcc = list,
_ => attachments = list,
}
}
"headers" => {
let pairs = match crate::classes::map::the_pairs(&val) {
Some(pairs) => pairs,
None => return Err(failure(
"The \"headers\" option must be a Map of header names and values."
.to_string(),
)),
};
for (name, value) in pairs {
let name = name.to_text();
if name.is_empty() {
continue;
}
headers.push((name, value.to_text()));
}
}
_ => {
return Err(failure(format!(
"Unknown option \"{item}\". Accepted keys are host, from, cc, bcc, replyto, attachments and headers."
)));
}
}
}
}
}
let Some(host) = host else {
return Err(failure(
"The \"host\" option is required: there is no default SMTP server.".to_string(),
));
};
let Some(from) = from else {
return Err(failure(
"The \"from\" option is required: SMTP has no sender to fall back on.".to_string(),
));
};
let message = crate::desktop::MailMessage {
to,
cc,
bcc,
subject,
body,
from,
reply_to,
attachments,
headers,
host,
port,
};
rt.desktop()
.send_mail(&message)
.map_err(|reason| desktop_failure(reason, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn ks_run_script(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let failure = |message: String| RuntimeError { message, line };
let code = text_of(values, 0);
let source = match rt.desktop().read_file(&code) {
Ok(lines) => lines.join("\n"),
Err(_) => code.clone(),
};
if let Err(failure_of_the_parse) = crate::parser::parse_with(&source, rt.dialect()) {
return Err(failure(format!(
"the script does not compile: {}:{}: {}",
failure_of_the_parse.line, failure_of_the_parse.column, failure_of_the_parse.message
)));
}
let asynchronous = values.get(1).map(|value| value.truthy()).unwrap_or(false);
let callback_name: Option<String> = match values.get(2) {
None => None,
Some(Value::Unset) => None,
Some(value) => match value {
Value::Object(object) if object.borrow().class == "func" => {
match object.borrow().value_of("name") {
Some(Value::Text(text)) if !text.is_empty() => Some(text.clone()),
_ => return Err(failure("Invalid callback function.".to_string())),
}
}
_ => {
return Err(failure(format!(
"This value of type \"{}\" has no method named \"Call\".",
value.type_name().name()
)));
}
},
};
if let Some(value) = values.get(3) {
if !matches!(value, Value::Unset) && !value.to_text().is_empty() {
return Err(failure(
"this tree generates no program of its own: the name parameter of RunScript has nothing to name".to_string(),
));
}
}
let executable = match values.get(4) {
Some(value) if !matches!(value, Value::Unset) && !value.to_text().is_empty() => {
value.to_text()
}
_ => rt
.desktop()
.executable()
.map_err(|reason| desktop_failure(reason, line))?,
};
let mut arguments: Vec<String> = Vec::new();
if let Some(value) = values.get(5) {
if !matches!(value, Value::Unset) {
let pieces = match value {
Value::Object(object) if object.borrow().class == "array" => {
crate::classes::array::the_items(value)
.iter()
.map(|item| item.to_text())
.collect()
}
other => the_pieces_of_a_command_line(&other.to_text()),
};
for piece in pieces {
let lowered = piece.to_lowercase();
if lowered.starts_with("--define") || lowered.starts_with("--include") {
return Err(failure(
"this tree compiles with its parser alone: --define and --include have no compilation to be applied to".to_string(),
));
}
arguments.push(piece);
}
}
}
if asynchronous && callback_name.is_some() {
return Err(failure(
"this tree does not watch a process it does not wait for: the callback of an asynchronous RunScript cannot be called".to_string(),
));
}
let pid = if asynchronous {
rt.desktop()
.launch_with_stdin(&executable, &arguments, &source, "")
.map_err(|reason| desktop_failure(reason, line))? as i64
} else {
let (pid, _, _, _) = rt
.desktop()
.run_with_stdin(&executable, &arguments, &source, "")
.map_err(|reason| desktop_failure(reason, line))?;
pid as i64
};
let process = match crate::classes::scriptprocess::construct(
"scriptprocess",
&[Value::Int(pid)],
rt,
line,
) {
Some(Ok(value)) => value,
Some(Err(failure_of_the_object)) => {
return Err(RuntimeError {
message: crate::runtime::the_message_of(&failure_of_the_object),
line,
});
}
None => {
return Err(failure(
"the object of the process could not be made".to_string(),
));
}
};
if let Some(name) = &callback_name {
rt.call_named(
name,
core::slice::from_ref(&process),
line,
crate::runtime::Route::Written,
)
.map_err(|failure_of_the_call| RuntimeError {
message: crate::runtime::the_message_of(&failure_of_the_call),
line,
})?;
}
Ok(process)
}
pub(crate) fn ks_get_keyboard_layout(
rt: &mut Runtime<'_>,
_values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let name = rt
.desktop()
.keyboard_layout_name()
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Text(name))
}
pub(crate) fn ks_clip_cursor(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let rect = if values.is_empty() {
None
} else if values.len() == 4 && !values.iter().any(|value| matches!(value, Value::Unset)) {
let mut numbers = [0i64; 4];
for (index, slot) in numbers.iter_mut().enumerate() {
match values[index].to_number() {
Some(number) => *slot = number as i64,
None => {
return Err(RuntimeError {
message: crate::runtime::requires(
index + 1,
"ClipCursor",
TypeName::Number,
&values[index],
),
line,
});
}
}
}
let [x1, y1, x2, y2] = numbers;
Some((x1.min(x2), y1.min(y2), x1.max(x2), y1.max(y2)))
} else {
return Err(RuntimeError {
message: "ClipCursor requires either zero or four coordinates.".to_string(),
line,
});
};
rt.desktop()
.clip_cursor(rect)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn ks_win_from_point(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let mut given: [Option<i64>; 2] = [None, None];
for index in 0..values.len().min(2) {
if matches!(values[index], Value::Unset) {
continue;
}
match values[index].to_number() {
Some(number) => given[index] = Some(number as i64),
None => {
return Err(RuntimeError {
message: crate::runtime::requires(
index + 1,
"WinFromPoint",
TypeName::Number,
&values[index],
),
line,
});
}
}
}
let (x, y) = match (given[0], given[1]) {
(Some(x), Some(y)) => (x, y),
_ => {
let (px, py) = rt
.desktop()
.mouse_position()
.map_err(|e| desktop_failure(e, line))?;
(given[0].unwrap_or(px), given[1].unwrap_or(py))
}
};
let answer = rt
.desktop()
.the_window_at(x, y)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Int(answer.unwrap_or(0)))
}
pub(crate) const THE_WINDOW_CAPABILITIES: [&str; 8] = [
"AlwaysOnTopGet",
"AlwaysOnTopSet",
"WindowEnabledGet",
"ControlEnabledGet",
"WindowList",
"WindowActivate",
"WindowMinimize",
"WindowClose",
];
fn ks_the_window_of(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
) -> Result<crate::desktop::WindowInfo, RuntimeError> {
let windows = rt
.desktop()
.windows()
.map_err(|e| desktop_failure(e, line))?;
match the_window_in(&windows, values.first())? {
Some(window) => Ok(window),
None => Err(no_window(line)),
}
}
pub(crate) fn ks_win_get_always_on_top(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let window = ks_the_window_of(rt, values, line)?;
let answer = rt
.desktop()
.always_on_top(&window)
.map_err(|e| desktop_failure(e, line))?;
match answer {
Some(true) => Ok(Value::Int(1)),
Some(false) => Ok(Value::Int(0)),
None => Err(RuntimeError {
message: "the desktop of this run cannot say whether the window is above the others."
.into(),
line,
}),
}
}
pub(crate) fn ks_win_get_enabled(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let window = ks_the_window_of(rt, values, line)?;
let answer = rt
.desktop()
.window_enabled(&window)
.map_err(|e| desktop_failure(e, line))?;
match answer {
Some(true) => Ok(Value::Int(1)),
Some(false) => Ok(Value::Int(0)),
None => Err(RuntimeError {
message: "the desktop of this run cannot say whether the window is enabled.".into(),
line,
}),
}
}
pub(crate) fn win_set_always_on_top(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let asked = match values.first() {
Some(value) => value.to_text(),
None => String::new(),
};
let wanted = match asked.trim().to_lowercase().as_str() {
"1" | "on" | "true" => Some(true),
"0" | "off" | "false" => Some(false),
"-1" | "toggle" | "" => None,
other => {
return Err(RuntimeError {
message: format!(
"the first parameter of WinSetAlwaysOnTop is not one of 1, 0, -1, Toggle, On or Off: {other}"
),
line,
});
}
};
let target = crate::desktop::TheWindowWanted::of(values, 1);
if target.title.is_empty() {
return Err(RuntimeError {
message: TARGET_WINDOW.into(),
line,
});
}
let windows = rt
.desktop()
.windows()
.map_err(|e| desktop_failure(e, line))?;
let found = the_windows_of_the_listing(rt, &windows, &target);
let Some(window) = found.into_iter().next() else {
return Err(no_window(line));
};
let on = match wanted {
Some(on) => on,
None => match rt
.desktop()
.always_on_top(&window)
.map_err(|e| desktop_failure(e, line))?
{
Some(current) => !current,
None => {
return Err(RuntimeError {
message:
"the desktop of this run cannot say whether the window is above the others, so it cannot toggle it."
.into(),
line,
})
}
},
};
rt.desktop()
.set_always_on_top(&window, on)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn ks_win_get_capability(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let asked = match values.first() {
Some(value) => value.to_text(),
None => String::new(),
};
if !THE_WINDOW_CAPABILITIES
.iter()
.any(|name| name.eq_ignore_ascii_case(asked.trim()))
{
return Err(RuntimeError {
message: format!(
"WinGetCapability: {asked} is not one of the capabilities of the tree."
),
line,
});
}
let capabilities = rt.desktop().window_capabilities();
let answer = capabilities
.iter()
.any(|name| name.eq_ignore_ascii_case(asked.trim()));
Ok(Value::Int(if answer { 1 } else { 0 }))
}
pub(crate) fn ks_request_capabilities(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let mut asked: Vec<String> = Vec::new();
for value in values {
for part in value
.to_text()
.split(|character: char| character == ',' || character.is_whitespace())
{
if !part.is_empty() {
asked.push(part.to_lowercase());
}
}
}
if asked.is_empty() {
asked.push("inputmonitoring".to_string());
asked.push("screencapture".to_string());
}
let mut granted = true;
let object = crate::classes::object("object");
let Value::Object(object) = object else {
return Err(RuntimeError {
message: "this runtime cannot make an object".to_string(),
line,
});
};
for name in asked {
let answer = match name.as_str() {
"inputmonitoring" | "screencapture" => "Granted",
_ => "Unsupported",
};
if answer != "Granted" {
granted = false;
}
object
.borrow_mut()
.put(&name, Value::Text(answer.to_string()));
}
object
.borrow_mut()
.put("IsGranted", Value::Int(if granted { 1 } else { 0 }));
let _ = rt;
Ok(Value::Object(object))
}
pub(crate) fn com_obj_get(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let name = values
.first()
.map(|value| value.to_text())
.unwrap_or_default();
let object = rt
.desktop()
.com_object_of_the_name(&name)
.map_err(|reason| desktop_failure(reason, line))?;
Ok(crate::classes::comvalue::the_value(
object.pointer,
object.kind,
0,
))
}
pub(crate) fn com_obj_active(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let class = values
.first()
.map(|value| value.to_text())
.unwrap_or_default();
let object = rt
.desktop()
.com_object_of_the_running(&class)
.map_err(|reason| desktop_failure(reason, line))?;
Ok(crate::classes::comvalue::the_value(
object.pointer,
object.kind,
0,
))
}
pub(crate) fn com_obj_type(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let first = values.first().cloned().unwrap_or(Value::Int(0));
match crate::classes::comvalue::the_kind_of_the_value(&first) {
Some(kind) => {
if let Some(what) = values.get(1) {
let what = what.to_text();
let pointer = crate::classes::comvalue::the_number_of(&first).unwrap_or(0);
let object = crate::desktop::ComObject {
pointer: pointer as u64,
kind,
};
let answer = rt
.desktop()
.com_type_of_the_object(&object, what.trim())
.map_err(|reason| desktop_failure(reason, line))?;
return Ok(Value::Text(answer));
}
Ok(Value::Int(kind))
}
None => Ok(Value::Text(String::new())),
}
}
pub(crate) fn com_obj_query(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let first = values.first().cloned().unwrap_or(Value::Int(0));
let pointer = match crate::classes::comvalue::the_number_of(&first) {
Some(pointer) if pointer >= 65536 => pointer,
_ => {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, "ComObjQuery"),
line,
});
}
};
let interface = values
.get(1)
.map(|value| value.to_text())
.unwrap_or_default();
let object = rt
.desktop()
.com_object_is_queried(
&crate::desktop::ComObject {
pointer: pointer as u64,
kind: crate::classes::comvalue::the_kind_of_the_value(&first).unwrap_or(0),
},
&interface,
)
.map_err(|reason| desktop_failure(reason, line))?;
Ok(crate::classes::comvalue::the_value(
object.pointer,
object.kind,
0,
))
}
pub(crate) fn list_lines(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let before = match crate::settings::value_of("listlines") {
Some(Ok(Value::Int(on))) => Value::Int(on),
_ => Value::Int(1),
};
let Some(setting) = values.first() else {
return Ok(before);
};
if !matches!(setting, Value::Int(_) | Value::Float(_)) {
return Err(RuntimeError {
message: crate::runtime::requires(1, "ListLines", TypeName::Number, setting),
line,
});
}
let on = setting.to_number_lenient() != 0.0;
match crate::settings::write_of("listlines", &Value::Int(on as i64)) {
Some(Ok(_)) => Ok(before),
Some(Err(why)) => Err(RuntimeError { message: why, line }),
None => Err(RuntimeError {
message: "the log of the lines is not carried.".to_string(),
line,
}),
}
}
const REGISTRY_KINDS: [&str; 5] = [
"REG_SZ",
"REG_EXPAND_SZ",
"REG_MULTI_SZ",
"REG_DWORD",
"REG_BINARY",
];
const NO_VALUE_NAME: &str = "(161) The specified path is invalid.";
const NOTHING_THERE: &str = "(2) The system cannot find the file specified.";
fn the_key_of(
values: &[Value],
index: usize,
name: &str,
line: u32,
) -> Result<String, RuntimeError> {
let key = values
.get(index)
.map(|value| value.to_text())
.unwrap_or_default()
.trim()
.to_string();
let hive = key.split('\\').next().unwrap_or("").trim().to_uppercase();
let known = matches!(
hive.as_str(),
"HKCU"
| "HKEY_CURRENT_USER"
| "HKLM"
| "HKEY_LOCAL_MACHINE"
| "HKU"
| "HKEY_USERS"
| "HKCR"
| "HKEY_CLASSES_ROOT"
| "HKCC"
| "HKEY_CURRENT_CONFIG"
);
if !known {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(index + 1, name),
line,
});
}
Ok(key)
}
fn the_value_name_of(values: &[Value], index: usize, line: u32) -> Result<String, RuntimeError> {
let name = values
.get(index)
.map(|value| value.to_text())
.unwrap_or_default()
.trim()
.to_string();
if name.is_empty() {
return Err(RuntimeError {
message: NO_VALUE_NAME.to_string(),
line,
});
}
Ok(name)
}
pub(crate) fn reg_create_key(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
if values.is_empty() {
return Err(RuntimeError {
message: "Parameter #1 of RegCreateKey must not be omitted in this case.".to_string(),
line,
});
}
let key = the_key_of(values, 0, "RegCreateKey", line)?;
rt.desktop()
.registry_create_key(&key)
.map_err(|reason| desktop_failure(reason, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn reg_write(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
if values.len() < 3 {
return Err(RuntimeError {
message: "Parameter #3 of RegWrite must not be omitted in this case.".to_string(),
line,
});
}
let kind = text_of(values, 1).trim().to_uppercase();
if !REGISTRY_KINDS.contains(&kind.as_str()) {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(2, "RegWrite"),
line,
});
}
let key = the_key_of(values, 2, "RegWrite", line)?;
let name = the_value_name_of(values, 3, line)?;
let value = if kind == "REG_DWORD" {
format!("{}", number_argument(values, 0, line, "RegWrite")? as i64)
} else {
text_of(values, 0)
};
rt.desktop()
.registry_write(&key, &name, &kind, &value)
.map_err(|reason| desktop_failure(reason, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn reg_read(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
if values.is_empty() {
return Err(RuntimeError {
message: "Parameter #1 of RegRead must not be omitted in this case.".to_string(),
line,
});
}
let key = the_key_of(values, 0, "RegRead", line)?;
let name = the_value_name_of(values, 1, line)?;
match rt
.desktop()
.registry_value(&key, &name)
.map_err(|reason| desktop_failure(reason, line))?
{
Some((kind, value)) => {
if kind == "REG_DWORD" {
Ok(match value.parse::<i64>() {
Ok(number) => Value::Int(number),
Err(_) => Value::Text(value),
})
} else {
Ok(Value::Text(value))
}
}
None => match values.get(2) {
Some(default) => Ok(default.clone()),
None => Err(RuntimeError {
message: NOTHING_THERE.to_string(),
line,
}),
},
}
}
pub(crate) fn reg_delete(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
if values.is_empty() {
return Err(RuntimeError {
message: "Parameter #1 of RegDelete must not be omitted in this case.".to_string(),
line,
});
}
let key = the_key_of(values, 0, "RegDelete", line)?;
let name = the_value_name_of(values, 1, line)?;
rt.desktop()
.registry_delete(&key, &name)
.map_err(|reason| desktop_failure(reason, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn reg_delete_key(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
if values.is_empty() {
return Err(RuntimeError {
message: "Parameter #1 of RegDeleteKey must not be omitted in this case.".to_string(),
line,
});
}
let key = the_key_of(values, 0, "RegDeleteKey", line)?;
rt.desktop()
.registry_delete_key(&key)
.map_err(|reason| desktop_failure(reason, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn tray_set_icon(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let Some(file) = values.first() else {
return Ok(Value::Text(String::new()));
};
let file = file.to_text();
let number = values
.get(1)
.map(|value| value.to_number().unwrap_or(1.0) as i64);
let options = crate::desktop::PictureOptions {
width: None,
height: None,
icon: number,
};
let image = rt.desktop().load_picture(&file, &options).ok().flatten();
if image.is_none() {
return Err(RuntimeError {
message: "Can't load icon.".to_string(),
line,
});
}
let canonical = rt
.desktop()
.canonical_path(&file)
.unwrap_or_else(|_| file.clone());
rt.set_the_icon_of_the_script(canonical.clone(), number.unwrap_or(1));
let refused = rt.desktop().tray_set_icon(&canonical).err();
if let Some(reason) = refused {
rt.note(format!(
"the tray of the session did not take the icon: {reason}"
));
}
Ok(Value::Text(String::new()))
}
pub(crate) fn callback_free(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let first = values.first().cloned().unwrap_or(Value::Int(0));
let address = match first {
Value::Int(n) if n >= 65536 => n as u64,
Value::Int(_) | Value::Float(_) => {
return Err(RuntimeError {
message: "Parameter #1 of CallbackFree is invalid.".to_string(),
line,
});
}
_ => {
return Err(RuntimeError {
message: crate::runtime::requires(1, "CallbackFree", TypeName::Number, &first),
line,
});
}
};
rt.desktop().free_callback(address);
Ok(Value::Text(String::new()))
}
pub(crate) fn com_call(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let rest = if values.len() > 2 {
&values[2..]
} else {
&[][..]
};
let (returns, rest) = if rest.len() % 2 == 1 {
let last = rest.last().expect("there is one");
let Value::Text(text) = last else {
return Err(RuntimeError {
message: "Invalid return type.".to_string(),
line,
});
};
let (_convention, name) = split_convention(text);
let Some((kind, _)) = crate::dll::parse_type(name) else {
return Err(RuntimeError {
message: "Invalid return type.".to_string(),
line,
});
};
(kind, &rest[..rest.len() - 1])
} else {
(NativeType::Int, rest)
};
let second = values.get(1).cloned().unwrap_or(Value::Int(0));
let pointer = match crate::classes::comvalue::the_number_of(&second) {
Some(pointer) if pointer >= 65536 => pointer,
_ => match second {
Value::Int(pointer) if pointer >= 65536 => pointer,
Value::Float(pointer) if pointer as i64 >= 65536 => pointer as i64,
_ => {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(2, "ComCall"),
line,
});
}
},
};
let index = values
.first()
.map(|value| value.to_number().unwrap_or(0.0) as i64);
let Some(index) = index else {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, "ComCall"),
line,
});
};
if index < 0 {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, "ComCall"),
line,
});
}
let mut arguments = Vec::new();
let mut references = Vec::new();
let mut place = 0;
while place < rest.len() {
let Value::Text(text) = &rest[place] else {
return Err(RuntimeError {
message: "Invalid arg type.".to_string(),
line,
});
};
let Some((kind, address)) = crate::dll::parse_type(text) else {
return Err(RuntimeError {
message: "Invalid arg type.".to_string(),
line,
});
};
let (argument, reference) = marshal(rt, kind, address, &rest[place + 1], line)?;
arguments.push(argument);
references.push(reference);
place += 2;
}
let mut all = vec![NativeArg {
kind: NativeType::Ptr,
address: false,
value: NativeValue::Integer(pointer),
}];
all.extend(arguments);
let object = crate::desktop::ComObject {
pointer: pointer as u64,
kind: crate::classes::comvalue::the_kind_of_the_value(&second).unwrap_or(0),
};
let failure_is_an_error = rest.len() % 2 == 0;
let answer = rt
.desktop()
.com_method_is_called(
&object,
index as usize,
&mut all,
returns,
failure_is_an_error,
)
.map_err(|reason| desktop_failure(reason, line))?;
for (argument, reference) in all[1..].iter().zip(references) {
if !argument.address {
continue;
}
let Some(reference) = reference else { continue };
let NativeValue::Bytes(bytes) = &argument.value else {
continue;
};
let written = if argument.kind.is_text() {
Value::Text(crate::dll::decode(bytes, argument.kind))
} else if argument.kind.is_float() {
Value::Float(crate::dll::decode_number(bytes, argument.kind))
} else {
Value::Int(crate::dll::decode_number(bytes, argument.kind) as i64)
};
rt.write_reference(&reference, written);
}
Ok(match answer.value {
NativeValue::Integer(number) => Value::Int(number),
NativeValue::Float(number) => Value::Float(number),
NativeValue::Bytes(bytes) => Value::Text(crate::dll::decode(&bytes, answer.kind)),
})
}
pub(crate) fn com_obj_from_ptr(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let first = values.first().cloned().unwrap_or(Value::Int(0));
if !matches!(first, Value::Int(_) | Value::Float(_)) {
return Err(RuntimeError {
message: crate::runtime::requires(1, "ComObjFromPtr", TypeName::Number, &first),
line,
});
}
let pointer = first.to_number_lenient() as i64;
if pointer == 0 {
return Err(RuntimeError {
message: "Parameter #1 of ComObjFromPtr is invalid.".to_string(),
line,
});
}
Ok(crate::classes::comvalue::the_value(
pointer as u64,
crate::classes::comvalue::THE_DISPATCH,
0,
))
}
pub(crate) fn il_create(
rt: &mut Runtime<'_>,
_values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
Ok(Value::Int(rt.make_an_image_list()))
}
pub(crate) fn il_add(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let first = values.first().cloned().unwrap_or(Value::Int(0));
if !matches!(first, Value::Int(_) | Value::Float(_)) {
return Err(RuntimeError {
message: crate::runtime::requires(1, "IL_Add", TypeName::Number, &first),
line,
});
}
let list = number_of(values, 0) as i64;
if list == 0 {
return Err(RuntimeError {
message: "Parameter #1 of IL_Add is invalid.".to_string(),
line,
});
}
let file = text_of(values, 1);
let icon = values
.get(2)
.map(|value| value.to_number().unwrap_or(1.0) as i64);
let options = crate::desktop::PictureOptions {
width: None,
height: None,
icon,
};
let image = rt.desktop().load_picture(&file, &options).ok().flatten();
let Some(image) = image else {
return Ok(Value::Int(0));
};
Ok(Value::Int(
rt.put_an_image_in_a_list(list, image as i64).unwrap_or(0),
))
}
pub(crate) fn il_destroy(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let first = values.first().cloned().unwrap_or(Value::Int(0));
if !matches!(first, Value::Int(_) | Value::Float(_)) {
return Err(RuntimeError {
message: crate::runtime::requires(1, "IL_Destroy", TypeName::Number, &first),
line,
});
}
let list = number_of(values, 0) as i64;
Ok(Value::Int(rt.take_an_image_list(list) as i64))
}
pub(crate) fn set_caps_lock_state(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
set_lock_state(rt, values, line, "CapsLock")
}
pub(crate) fn set_num_lock_state(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
set_lock_state(rt, values, line, "NumLock")
}
pub(crate) fn set_scroll_lock_state(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
set_lock_state(rt, values, line, "ScrollLock")
}
pub const TARGET_WINDOW: &str = "Target window not found.";
pub const TARGET_CONTROL: &str = "Target control not found.";
fn window_target(
values: &[Value],
) -> Result<crate::desktop::TheWindowWanted, RuntimeError> {
Ok(crate::desktop::TheWindowWanted::of(values, 0))
}
pub(crate) fn caret_get_pos(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let caret = rt
.desktop()
.gui_caret()
.map_err(|e| desktop_failure(e, line))?;
match caret {
Some((x, y)) => {
if let Some(value) = values.first() {
rt.write_reference(value, Value::Int(x));
}
if let Some(value) = values.get(1) {
rt.write_reference(value, Value::Int(y));
}
Ok(Value::Int(1))
}
None => Ok(Value::Int(0)),
}
}
const DRIVE_PATH: &str = "(3) The system cannot find the path specified.";
const DRIVE_FILE: &str = "(2) The system cannot find the file specified.";
pub(crate) fn drive_get_label(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let path = text_of(values, 0);
match rt
.desktop()
.drive_label(&path)
.map_err(|e| desktop_failure(e, line))?
{
Some(label) => Ok(Value::Text(label)),
None => Err(RuntimeError {
message: DRIVE_PATH.to_string(),
line,
}),
}
}
pub(crate) fn drive_get_serial(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let path = text_of(values, 0);
match rt
.desktop()
.drive_serial(&path)
.map_err(|e| desktop_failure(e, line))?
{
Some(serial) => match serial.parse::<i64>() {
Ok(number) => Ok(Value::Int(number)),
Err(_) => Ok(Value::Text(serial)),
},
None => Err(RuntimeError {
message: DRIVE_PATH.to_string(),
line,
}),
}
}
pub(crate) fn drive_get_list(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
if !values.is_empty() {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, "DriveGetList"),
line,
});
}
let drives = rt
.desktop()
.drive_list()
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Text(drives.join("\n")))
}
pub(crate) fn drive_get_status_cd(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let path = text_of(values, 0);
match rt
.desktop()
.drive_status_cd(&path)
.map_err(|e| desktop_failure(e, line))?
{
Some(status) => Ok(Value::Text(status)),
None => Err(RuntimeError {
message: "Failed".to_string(),
line,
}),
}
}
fn the_drive_for_the_operation(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
) -> Result<String, RuntimeError> {
let path = text_of(values, 0);
match rt
.desktop()
.drive_label(&path)
.map_err(|e| desktop_failure(e, line))?
{
Some(_) => Ok(path),
None => Err(RuntimeError {
message: DRIVE_FILE.to_string(),
line,
}),
}
}
pub(crate) fn drive_eject(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let path = the_drive_for_the_operation(rt, values, line)?;
rt.desktop()
.drive_eject(&path)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn drive_lock(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let path = the_drive_for_the_operation(rt, values, line)?;
rt.desktop()
.drive_lock(&path)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn drive_unlock(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let path = the_drive_for_the_operation(rt, values, line)?;
rt.desktop()
.drive_unlock(&path)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn drive_retract(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let path = the_drive_for_the_operation(rt, values, line)?;
rt.desktop()
.drive_retract(&path)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn drive_set_label(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let path = text_of(values, 0);
match rt
.desktop()
.drive_label(&path)
.map_err(|e| desktop_failure(e, line))?
{
Some(_) => {}
None => {
return Err(RuntimeError {
message: DRIVE_PATH.to_string(),
line,
});
}
}
let label = text_of(values, 1);
rt.desktop()
.drive_set_label(&path, &label)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn win_get_id(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let wanted = window_target(values)?;
let windows = the_windows_that_answer(rt, &wanted, line)?;
match the_window_named_by(&windows, values.first()) {
Some(window) => {
rt.remember_the_last_window(&window.id.to_string());
Ok(Value::Text(window.id.to_string()))
}
None => Err(RuntimeError {
message: TARGET_WINDOW.to_string(),
line,
}),
}
}
fn the_window_named_by(
windows: &[crate::desktop::WindowInfo],
value: Option<&Value>,
) -> Option<crate::desktop::WindowInfo> {
match value {
Some(Value::Int(id)) => windows.iter().find(|window| window.id == *id).cloned(),
Some(value) if !value.to_text().is_empty() => {
let wanted = value.to_text();
let mode = crate::settings::title_match_mode();
windows
.iter()
.find(|window| a_window_answers(mode, window, &wanted))
.cloned()
}
_ => windows.first().cloned(),
}
}
pub(crate) fn win_get_id_last(
rt: &mut Runtime<'_>,
_values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
match rt.the_last_window() {
Some(id) => Ok(Value::Text(id.to_string())),
None => Err(RuntimeError {
message: TARGET_WINDOW.to_string(),
line,
}),
}
}
pub(crate) fn win_get_class(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let wanted = window_target(values)?;
let windows = the_windows_that_answer(rt, &wanted, line)?;
match the_window_named_by(&windows, values.first()) {
Some(window) => Ok(Value::Text(window.class.clone())),
None => Err(RuntimeError {
message: TARGET_WINDOW.to_string(),
line,
}),
}
}
pub(crate) fn win_get_list(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let wanted = window_target(values)?;
let windows = the_windows_that_answer(rt, &wanted, line)?;
let ids: Vec<Value> = windows
.iter()
.map(|window| Value::Text(window.id.to_string()))
.collect();
match crate::classes::construct("array", &ids, rt, line) {
Some(result) => result.map_err(|failure| crate::runtime::as_error(failure, line)),
None => Ok(Value::List(ids)),
}
}
pub(crate) fn win_get_count(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let wanted = window_target(values)?;
let windows = the_windows_that_answer(rt, &wanted, line)?;
Ok(Value::Int(windows.len() as i64))
}
pub(crate) fn win_get_pos(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
window_geometry_into(rt, values, line, "WinGetPos")
}
pub(crate) fn win_get_client_pos(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
window_geometry_into(rt, values, line, "WinGetClientPos")
}
pub(crate) fn control_get_text(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let control = text_of(values, 0);
let wanted = crate::desktop::TheWindowWanted::of(values, 1);
if wanted.title.is_empty() {
return Err(RuntimeError {
message: TARGET_WINDOW.into(),
line,
});
}
let title = the_title_of_the_window(rt, &wanted, line)?;
match rt
.desktop()
.control_text(&control, &title)
.map_err(|e| desktop_failure(e, line))?
{
crate::desktop::ControlAnswer::Found(text) => Ok(Value::Text(text)),
crate::desktop::ControlAnswer::NoSuchWindow => Err(RuntimeError {
message: TARGET_WINDOW.into(),
line,
}),
crate::desktop::ControlAnswer::NoSuchControl => Err(RuntimeError {
message: TARGET_CONTROL.into(),
line,
}),
}
}
pub(crate) fn control_flag(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
variant: u8,
) -> Result<Value, RuntimeError> {
let control = text_of(values, 0);
let wanted = crate::desktop::TheWindowWanted::of(values, 1);
if wanted.title.is_empty() {
return Err(RuntimeError {
message: TARGET_WINDOW.into(),
line,
});
}
let title = the_title_of_the_window(rt, &wanted, line)?;
let answer = if variant == 0 {
rt.desktop().control_visible(&control, &title)
} else {
rt.desktop().control_enabled(&control, &title)
}
.map_err(|e| desktop_failure(e, line))?;
match answer {
crate::desktop::ControlFlag::Yes => Ok(Value::Int(1)),
crate::desktop::ControlFlag::No => Ok(Value::Int(0)),
crate::desktop::ControlFlag::NoSuchWindow => Err(RuntimeError {
message: TARGET_WINDOW.into(),
line,
}),
crate::desktop::ControlFlag::NoSuchControl => Err(RuntimeError {
message: TARGET_CONTROL.into(),
line,
}),
}
}
pub(crate) fn control_set_text(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let text = text_of(values, 0);
let control = text_of(values, 1);
let wanted = crate::desktop::TheWindowWanted::of(values, 2);
if wanted.title.is_empty() {
return Err(RuntimeError {
message: TARGET_WINDOW.into(),
line,
});
}
let title = the_title_of_the_window(rt, &wanted, line)?;
match rt
.desktop()
.control_set_text(&control, &title, &text)
.map_err(|e| desktop_failure(e, line))?
{
crate::desktop::ControlEdit::Done => Ok(Value::Text(String::new())),
crate::desktop::ControlEdit::NoSuchWindow => Err(RuntimeError {
message: TARGET_WINDOW.into(),
line,
}),
crate::desktop::ControlEdit::NoSuchControl => Err(RuntimeError {
message: TARGET_CONTROL.into(),
line,
}),
}
}
pub(crate) fn control_act(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
variant: u8,
) -> Result<Value, RuntimeError> {
let control = text_of(values, 0);
let wanted = crate::desktop::TheWindowWanted::of(values, 1);
if wanted.title.is_empty() {
return Err(RuntimeError {
message: TARGET_WINDOW.into(),
line,
});
}
let title = the_title_of_the_window(rt, &wanted, line)?;
let answer = if variant == 0 {
rt.desktop().control_click(&control, &title)
} else {
rt.desktop().control_focus(&control, &title)
}
.map_err(|e| desktop_failure(e, line))?;
match answer {
crate::desktop::ControlEdit::Done => Ok(Value::Text(String::new())),
crate::desktop::ControlEdit::NoSuchWindow => Err(RuntimeError {
message: TARGET_WINDOW.into(),
line,
}),
crate::desktop::ControlEdit::NoSuchControl => Err(RuntimeError {
message: TARGET_CONTROL.into(),
line,
}),
}
}
pub(crate) fn control_send_text(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let text = text_of(values, 0);
let control = text_of(values, 1);
let wanted = crate::desktop::TheWindowWanted::of(values, 2);
if wanted.title.is_empty() {
return Err(RuntimeError {
message: TARGET_WINDOW.into(),
line,
});
}
let title = the_title_of_the_window(rt, &wanted, line)?;
match rt
.desktop()
.control_send_text(&control, &title, &text)
.map_err(|e| desktop_failure(e, line))?
{
crate::desktop::ControlEdit::Done => Ok(Value::Text(String::new())),
crate::desktop::ControlEdit::NoSuchWindow => Err(RuntimeError {
message: TARGET_WINDOW.into(),
line,
}),
crate::desktop::ControlEdit::NoSuchControl => Err(RuntimeError {
message: TARGET_CONTROL.into(),
line,
}),
}
}
pub(crate) fn win_get_pid(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let wanted = crate::desktop::TheWindowWanted::of(values, 0);
if wanted.asked && wanted.title.is_empty() {
return Err(RuntimeError {
message: TARGET_WINDOW.into(),
line,
});
}
let title = the_title_of_the_window(rt, &wanted, line)?;
match rt
.desktop()
.window_pid(&title)
.map_err(|e| desktop_failure(e, line))?
{
Some(pid) => Ok(Value::Int(pid)),
None => Err(RuntimeError {
message: TARGET_WINDOW.into(),
line,
}),
}
}
pub(crate) fn win_get_process(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
variant: u8,
) -> Result<Value, RuntimeError> {
let wanted = crate::desktop::TheWindowWanted::of(values, 0);
if wanted.title.is_empty() {
return Err(RuntimeError {
message: TARGET_WINDOW.into(),
line,
});
}
let title = the_title_of_the_window(rt, &wanted, line)?;
let pid = match rt
.desktop()
.window_pid(&title)
.map_err(|e| desktop_failure(e, line))?
{
Some(pid) => pid,
None => {
return Err(RuntimeError {
message: TARGET_WINDOW.into(),
line,
});
}
};
let number = pid.to_string();
let answer = if variant == 0 {
rt.desktop().process_name(Some(&number))
} else {
rt.desktop().process_path(Some(&number))
}
.map_err(|e| desktop_failure(e, line))?;
match answer {
Some(text) => Ok(Value::Text(text)),
None => Err(RuntimeError {
message: "Target process not found.".into(),
line,
}),
}
}
pub(crate) fn persistent(
rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let asked = match values.first() {
None => true,
Some(value) => token_to_int64(value) != 0,
};
let was = rt.the_script_is_persistent();
rt.the_script_asked_to_stay(asked);
Ok(Value::Int(was as i64))
}
pub(crate) fn critical(
_rt: &mut Runtime<'_>,
_values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
Ok(Value::Int(0))
}
pub(crate) fn list_vars(
rt: &mut Runtime<'_>,
_values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
for (name, value) in rt.variable_names() {
rt.push_output(format!("{name}[{value}]"));
}
Ok(Value::Text(String::new()))
}
fn the_monitor_bounds_into(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
name: &str,
) -> Result<Value, RuntimeError> {
for index in 0..4 {
let Some(value) = values.get(index + 1) else {
continue;
};
if !matches!(value, Value::Reference(_)) {
return Err(RuntimeError {
message: crate::runtime::wants_a_reference(index + 2, name, "a VarRef", value),
line,
});
}
}
let (index, monitors) = the_monitor_of(rt, values, name, line)?;
let Some(monitor) = the_monitor_at(&monitors, index) else {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, name),
line,
});
};
let places = [monitor.left, monitor.top, monitor.right, monitor.bottom];
for (index, place) in places.iter().enumerate() {
if values.get(index + 1).is_some() {
rt.write_reference(&values[index + 1], Value::Int(*place));
}
}
Ok(Value::Int(1))
}
fn the_drive_of(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
name: &str,
) -> Result<crate::desktop::DriveSpace, RuntimeError> {
let path = text_of(values, 0);
match rt
.desktop()
.drive_space(&path)
.map_err(|e| desktop_failure(e, line))?
{
Some(space) => Ok(space),
None => Err(RuntimeError {
message: format!("{name}: the drive of {path} is not there."),
line,
}),
}
}
pub(crate) fn drive_get_space_free(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
Ok(Value::Int(
the_drive_of(rt, values, line, "DriveGetSpaceFree")?.free,
))
}
pub(crate) fn drive_get_capacity(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
Ok(Value::Int(
the_drive_of(rt, values, line, "DriveGetCapacity")?.capacity,
))
}
pub(crate) fn drive_get_status(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let path = text_of(values, 0);
match rt
.desktop()
.drive_space(&path)
.map_err(|e| desktop_failure(e, line))?
{
Some(_) => Ok(Value::Text("Ready".to_string())),
None => Ok(Value::Text(String::new())),
}
}
pub(crate) fn drive_get_filesystem(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let path = text_of(values, 0);
match rt
.desktop()
.drive_space(&path)
.map_err(|e| desktop_failure(e, line))?
{
Some(space) => Ok(Value::Text(space.filesystem)),
None => Ok(Value::Text(String::new())),
}
}
pub(crate) fn drive_get_type(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let path = text_of(values, 0);
match rt
.desktop()
.drive_space(&path)
.map_err(|e| desktop_failure(e, line))?
{
Some(space) => Ok(Value::Text(space.kind)),
None => Ok(Value::Text(String::new())),
}
}
const MAX_WINDOW_WAIT_MS: u64 = 60_000;
fn window_wait_timeout(rt: &Runtime<'_>, values: &[Value]) -> u64 {
let seconds = match values.get(2) {
Some(value) => match value.to_number() {
Some(seconds) => seconds,
None => return MAX_WINDOW_WAIT_MS,
},
None => return MAX_WINDOW_WAIT_MS,
};
if seconds < 0.0 {
return MAX_WINDOW_WAIT_MS;
}
if seconds == 0.0 {
return if rt.dialect().is_the_v1() { 500 } else { 0 };
}
(seconds * 1000.0).min(MAX_WINDOW_WAIT_MS as f64) as u64
}
fn window_wait_into(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
what: crate::desktop::WaitFor,
) -> Result<Option<String>, RuntimeError> {
let title = text_of(values, 0);
let mode = crate::settings::title_match_mode();
let timeout = window_wait_timeout(rt, values);
let excludes: Vec<String> = values
.iter()
.skip(3)
.take(1)
.map(|value| value.to_text())
.filter(|text| !text.is_empty())
.collect();
rt.desktop()
.window_wait(&title, mode, what, timeout, &excludes)
.map_err(|e| desktop_failure(e, line))
}
pub(crate) fn win_wait(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
match window_wait_into(rt, values, line, crate::desktop::WaitFor::Present)? {
Some(id) => Ok(Value::Text(id)),
None => Ok(Value::Int(0)),
}
}
pub(crate) fn win_wait_active(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
match window_wait_into(rt, values, line, crate::desktop::WaitFor::Active)? {
Some(id) => Ok(Value::Text(id)),
None => Ok(Value::Int(0)),
}
}
pub(crate) fn win_wait_not_active(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let met = window_wait_into(rt, values, line, crate::desktop::WaitFor::NotActive)?.is_some();
Ok(Value::Int(if met { 1 } else { 0 }))
}
pub(crate) fn win_wait_close(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let met = window_wait_into(rt, values, line, crate::desktop::WaitFor::Close)?.is_some();
Ok(Value::Int(if met { 1 } else { 0 }))
}
pub(crate) fn win_get_min_max(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let wanted = window_target(values)?;
let title = wanted.title.clone();
let mode = crate::settings::title_match_mode();
if title.is_empty() {
return Err(RuntimeError {
message: TARGET_WINDOW.to_string(),
line,
});
}
match rt
.desktop()
.window_min_max(&title, mode)
.map_err(|e| desktop_failure(e, line))?
{
Some(answer) => Ok(Value::Int(answer)),
None => Err(RuntimeError {
message: TARGET_WINDOW.to_string(),
line,
}),
}
}
fn window_geometry_into(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
name: &str,
) -> Result<Value, RuntimeError> {
for index in 0..4 {
let Some(value) = values.get(index) else {
continue;
};
if !matches!(value, Value::Reference(_)) {
return Err(RuntimeError {
message: crate::runtime::wants_a_reference(index + 1, name, "a VarRef", value),
line,
});
}
}
let title = text_of(values, 4);
if title.is_empty() {
return Err(RuntimeError {
message: TARGET_WINDOW.to_string(),
line,
});
}
let mode = crate::settings::title_match_mode();
let geometry = rt
.desktop()
.window_geometry(&title, mode)
.map_err(|e| desktop_failure(e, line))?;
let Some(geometry) = geometry else {
return Err(RuntimeError {
message: TARGET_WINDOW.to_string(),
line,
});
};
let places = [geometry.x, geometry.y, geometry.width, geometry.height];
for (index, place) in places.iter().enumerate() {
if values.get(index).is_some() {
rt.write_reference(&values[index], Value::Int(*place));
}
}
Ok(Value::Text(String::new()))
}
pub(crate) fn edit_get_line_count(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = number_of(values, 0) as u64;
rt.desktop()
.gui_line_count(number)
.map(Value::Int)
.map_err(|reason| desktop_failure(reason, line))
}
pub(crate) fn edit_get_line(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let wanted = number_of(values, 0).max(1.0) as usize;
let number = number_of(values, 1) as u64;
let text = rt
.desktop()
.gui_value(number, None)
.map_err(|reason| desktop_failure(reason, line))?;
let found = text.split('\n').nth(wanted - 1).unwrap_or("");
Ok(Value::Text(found.to_string()))
}
pub(crate) fn edit_get_current_line(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = number_of(values, 0) as u64;
let cursor = rt
.desktop()
.gui_cursor(number)
.map_err(|reason| desktop_failure(reason, line))?;
let text = rt
.desktop()
.gui_value(number, None)
.map_err(|reason| desktop_failure(reason, line))?;
let before: usize = (cursor.max(0) as usize).min(text.chars().count());
let breaks = text.chars().take(before).filter(|c| *c == '\n').count();
Ok(Value::Int(breaks as i64 + 1))
}
pub(crate) fn edit_get_current_col(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = number_of(values, 0) as u64;
let cursor = rt
.desktop()
.gui_cursor(number)
.map_err(|reason| desktop_failure(reason, line))?;
let text = rt
.desktop()
.gui_value(number, None)
.map_err(|reason| desktop_failure(reason, line))?;
let before: usize = (cursor.max(0) as usize).min(text.chars().count());
let seen: Vec<char> = text.chars().take(before).collect();
let column = match seen.iter().rposition(|held| *held == '\n') {
Some(at) => seen.len() - at,
None => seen.len() + 1,
};
Ok(Value::Int(column as i64))
}
pub(crate) fn edit_get_selected_text(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = number_of(values, 0) as u64;
rt.desktop()
.gui_selection(number)
.map(Value::Text)
.map_err(|reason| desktop_failure(reason, line))
}
pub(crate) fn control_get_focus(
rt: &mut Runtime<'_>,
_values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
if !rt.desktop().gui_is_open() {
return Err(RuntimeError {
message: "the focus of a window of another program is not read by this runtime, and this script has no window of its own".to_string(),
line,
});
}
rt.desktop()
.gui_focused()
.map(Value::Text)
.map_err(|reason| desktop_failure(reason, line))
}
pub(crate) fn control_get_hwnd(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
if !rt.desktop().gui_is_open() {
return Err(RuntimeError {
message: "this name asks about a window of another program, and this script has no window of its own".to_string(),
line,
});
}
let classnn = text_of(values, 0);
rt.desktop()
.gui_number_named(&classnn)
.map(Value::Int)
.map_err(|reason| desktop_failure(reason, line))
}
fn the_visibility_of_a_control(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
on: bool,
) -> Result<Value, RuntimeError> {
if !rt.desktop().gui_is_open() {
return Err(RuntimeError {
message: "this name asks about a window of another program, and this script has no window of its own".to_string(),
line,
});
}
let classnn = text_of(values, 0);
rt.desktop()
.gui_visibility(&classnn, on)
.map_err(|reason| desktop_failure(reason, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn control_visibility(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
the_visibility_of_a_control(rt, values, line, false)
}
pub(crate) fn control_show(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
the_visibility_of_a_control(rt, values, line, true)
}
pub(crate) fn control_get_classnn(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
if let Some(Value::Int(hwnd)) = values.first() {
let classnn = rt
.desktop()
.control_classnn_of(*hwnd)
.map_err(|reason| desktop_failure(reason, line))?;
return Ok(Value::Text(classnn));
}
if !rt.desktop().gui_is_open() {
return Err(RuntimeError {
message: "this name asks about a window of another program, and this script has no window of its own".to_string(),
line,
});
}
let classnn = text_of(values, 0);
rt.desktop()
.gui_number_named(&classnn)
.map_err(|reason| desktop_failure(reason, line))?;
Ok(Value::Text(classnn))
}
fn the_state_of_a_control(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
what: &str,
on: bool,
) -> Result<Value, RuntimeError> {
if !rt.desktop().gui_is_open() {
return Err(RuntimeError {
message: "this name asks about a window of another program, and this script has no window of its own".to_string(),
line,
});
}
let classnn = text_of(values, 1);
rt.desktop()
.gui_control_state(&classnn, what, on)
.map_err(|reason| desktop_failure(reason, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn control_set_enabled(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let on = number_of(values, 0) != 0.0;
the_state_of_a_control(rt, values, line, "enabled", on)
}
fn the_tick_of_a_control(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
at: usize,
setting: Option<bool>,
) -> Result<Value, RuntimeError> {
if !rt.desktop().gui_is_open() {
return Err(RuntimeError {
message: "this name asks about a window of another program, and this script has no window of its own".to_string(),
line,
});
}
let classnn = text_of(values, at);
let number = rt
.desktop()
.gui_number_named(&classnn)
.map_err(|reason| desktop_failure(reason, line))? as u64;
let checked = rt
.desktop()
.gui_checked(number, setting)
.map_err(|reason| desktop_failure(reason, line))?;
match setting {
Some(_) => Ok(Value::Text(String::new())),
None => Ok(Value::Int(checked)),
}
}
pub(crate) fn control_get_checked(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
the_tick_of_a_control(rt, values, line, 0, None)
}
pub(crate) fn control_set_checked(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let on = number_of(values, 0) != 0.0;
the_tick_of_a_control(rt, values, line, 1, Some(on))
}
pub(crate) fn edit_paste(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let text = text_of(values, 0);
let number = number_of(values, 1) as u64;
rt.desktop()
.gui_paste(number, &text)
.map_err(|reason| desktop_failure(reason, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn control_move(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
if values.len() < 5 {
return Err(RuntimeError {
message: "Parameter #5 of ControlMove must not be omitted in this case.".to_string(),
line,
});
}
number_argument(values, 0, line, "ControlMove")?;
let title = text_of(values, 5);
the_window_of_the_script(rt, &title, line)?;
let classnn = text_of(values, 4);
match rt.desktop().gui_number_named(&classnn) {
Ok(_) => Err(RuntimeError {
message: "the binary of v2.0.19 hangs on this call -- measured on 2026-11-11 -- and this runtime does not wait forever: the window of this tree lays its controls out in order, so the place of a control cannot be set.".to_string(),
line,
}),
Err(_) => Err(RuntimeError {
message: "Target window not found.".to_string(),
line,
}),
}
}
pub(crate) fn win_set_title(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let new_title = text_of(values, 0);
let target = text_of(values, 1);
if !rt.desktop().gui_is_open() {
return Err(RuntimeError {
message: "Target window not found.".to_string(),
line,
});
}
let current = rt
.desktop()
.gui_title(0, None)
.map_err(|reason| desktop_failure(reason, line))?;
if !target.is_empty() && !current.contains(&target) {
return Err(RuntimeError {
message: "Target window not found.".to_string(),
line,
});
}
rt.desktop()
.gui_title(0, Some(&new_title))
.map_err(|reason| desktop_failure(reason, line))?;
Ok(Value::Text(String::new()))
}
fn the_window_of_the_script(
rt: &mut Runtime<'_>,
target: &str,
line: u32,
) -> Result<(), RuntimeError> {
if !rt.desktop().gui_is_open() {
return Err(RuntimeError {
message: "Target window not found.".to_string(),
line,
});
}
let current = rt
.desktop()
.gui_title(0, None)
.map_err(|reason| desktop_failure(reason, line))?;
if !target.is_empty() && !current.contains(target) {
return Err(RuntimeError {
message: "Target window not found.".to_string(),
line,
});
}
Ok(())
}
fn the_visibility_of_the_window(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
shown: bool,
) -> Result<Value, RuntimeError> {
let target = text_of(values, 0);
the_window_of_the_script(rt, &target, line)?;
let answer = if shown {
rt.desktop().gui_show(0)
} else {
rt.desktop().gui_hide()
};
answer.map_err(|reason| desktop_failure(reason, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn win_hide(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
the_visibility_of_the_window(rt, values, line, false)
}
pub(crate) fn win_show(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
the_visibility_of_the_window(rt, values, line, true)
}
fn the_state_of_the_window(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
state: &str,
) -> Result<Value, RuntimeError> {
if let Some(value @ Value::Object(_)) = values.first() {
rt.read_property(value, "Hwnd", line)
.map_err(|failure| RuntimeError {
message: the_message_of(failure),
line,
})?;
}
let target = text_of(values, 0);
the_window_of_the_script(rt, &target, line)?;
rt.desktop()
.gui_option(state, true)
.map_err(|reason| desktop_failure(reason, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn win_activate(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
the_state_of_the_window(rt, values, line, "activate")
}
pub(crate) fn win_activate_bottom(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
the_state_of_the_window(rt, values, line, "activate")
}
pub(crate) fn win_minimize(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
the_state_of_the_window(rt, values, line, "minimize")
}
pub(crate) fn win_maximize(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
the_state_of_the_window(rt, values, line, "maximize")
}
pub(crate) fn win_restore(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
the_state_of_the_window(rt, values, line, "restore")
}
pub(crate) fn win_set_enabled(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let on = number_of(values, 0) != 0.0;
let target = text_of(values, 1);
the_window_of_the_script(rt, &target, line)?;
rt.desktop()
.gui_option("disabled", !on)
.map_err(|reason| desktop_failure(reason, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn win_move_top(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
the_state_of_the_window(rt, values, line, "activate")
}
pub(crate) fn win_minimize_all(
rt: &mut Runtime<'_>,
_values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
if !rt.desktop().gui_is_open() {
return Ok(Value::Text(String::new()));
}
rt.desktop()
.gui_option("minimize", true)
.map_err(|reason| desktop_failure(reason, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn win_minimize_all_undo(
rt: &mut Runtime<'_>,
_values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
if !rt.desktop().gui_is_open() {
return Ok(Value::Text(String::new()));
}
rt.desktop()
.gui_option("restore", true)
.map_err(|reason| desktop_failure(reason, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn win_move_bottom(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
the_state_of_the_window(rt, values, line, "movebottom")
}
fn the_close_of_the_window(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
) -> Result<Value, RuntimeError> {
let target = text_of(values, 0);
the_window_of_the_script(rt, &target, line)?;
rt.desktop()
.gui_option("close", true)
.map_err(|reason| desktop_failure(reason, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn win_close(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
the_close_of_the_window(rt, values, line)
}
pub(crate) fn win_kill(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
the_close_of_the_window(rt, values, line)
}
pub(crate) fn win_set_transparent(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let target = text_of(values, 1);
the_window_of_the_script(rt, &target, line)?;
let written = text_of(values, 0);
let setting = if written.eq_ignore_ascii_case("off") {
255
} else {
number_of(values, 0) as i64
};
rt.desktop()
.gui_opacity(Some(setting))
.map_err(|reason| desktop_failure(reason, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn win_get_transparent(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let target = text_of(values, 0);
the_window_of_the_script(rt, &target, line)?;
rt.desktop()
.gui_opacity(None)
.map(Value::Int)
.map_err(|reason| desktop_failure(reason, line))
}
pub(crate) fn win_redraw(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
the_state_of_the_window(rt, values, line, "redraw")
}
pub(crate) fn obj_ptr(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let value = match values.first() {
Some(value) => value.clone(),
None => {
return Err(RuntimeError {
message: "Too few parameters passed to function.".to_string(),
line,
});
}
};
Ok(Value::Int(rt.the_pointer_of(&value)))
}
pub(crate) fn obj_from_ptr(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = number_of(values, 0) as i64;
match rt.the_object_of(number) {
Some(value) => Ok(value),
None => Err(RuntimeError {
message: format!(
"the number {number} does not name an object this script has asked about"
),
line,
}),
}
}
pub(crate) fn obj_ptr_add_ref(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let value = match values.first() {
Some(value) => value.clone(),
None => {
return Err(RuntimeError {
message: "Too few parameters passed to function.".to_string(),
line,
});
}
};
if !matches!(value, Value::Object(_)) {
let kind = the_kind_of(&value);
let article = if kind.starts_with(['A', 'E', 'I', 'O', 'U']) {
"an"
} else {
"a"
};
return Err(RuntimeError {
message: format!("Expected an object but got {article} {kind}."),
line,
});
}
Ok(Value::Int(rt.the_pointer_of(&value)))
}
pub(crate) fn obj_from_ptr_add_ref(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = number_of(values, 0) as i64;
match rt.the_object_of(number) {
Some(value) => Ok(value),
None => Err(RuntimeError {
message: format!(
"the number {number} does not name an object this script has asked about"
),
line,
}),
}
}
fn the_kind_of(value: &Value) -> &'static str {
match value {
Value::Int(_) => "Integer",
Value::Float(_) => "Float",
Value::Text(_) => "String",
Value::Object(_) => "Object",
_ => "value that is not an object",
}
}
pub(crate) fn sound_get_name(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let component = text_of(values, 0).trim().to_string();
let device = text_of(values, 1).trim().to_string();
let (plays, records) = rt
.desktop()
.sound_device_names()
.map_err(|reason| desktop_failure(reason, line))?;
if !device.is_empty() {
return match rt
.desktop()
.sound_device_named(&device)
.map_err(|reason| desktop_failure(reason, line))?
{
Some(name) => Ok(Value::Text(name)),
None => Err(RuntimeError {
message: "Component not found".to_string(),
line,
}),
};
}
match component.as_str() {
"" => Ok(Value::Text(plays)),
"1" => Ok(Value::Text(records)),
"2" => Ok(Value::Text(String::new())),
_ => Err(RuntimeError {
message: "Component not found".to_string(),
line,
}),
}
}
pub(crate) fn sound_get_interface(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let iid = text_of(values, 0).trim().to_string();
if !is_the_identifier_of_an_interface(&iid) {
return Err(RuntimeError {
message: "Parameter #1 of SoundGetInterface is invalid.".to_string(),
line,
});
}
let device = device_of(values, 1);
let pointer = rt
.desktop()
.sound_interface_of_the_device(&device, &iid)
.map_err(|reason| desktop_failure(reason, line))?;
Ok(Value::Int(pointer as i64))
}
fn is_the_identifier_of_an_interface(text: &str) -> bool {
let Some(inner) = text
.strip_prefix('{')
.and_then(|rest| rest.strip_suffix('}'))
else {
return false;
};
let parts: Vec<&str> = inner.split('-').collect();
if parts.len() != 5 {
return false;
}
let widths = [8, 4, 4, 4, 12];
parts
.iter()
.zip(widths)
.all(|(part, width)| part.len() == width && part.chars().all(|c| c.is_ascii_hexdigit()))
}
pub(crate) fn win_trans_color(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let (_wanted, window) = the_target_of_a_window(rt, values, 0, line)?;
let colour = rt
.desktop()
.window_trans_color(&window.title)
.map_err(|reason| desktop_failure(reason, line))?;
Ok(Value::Text(colour))
}
pub(crate) fn win_set_trans_color(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let colour: u32 = match values.first() {
Some(Value::Int(number)) => (number & 0x00FF_FFFF) as u32,
Some(Value::Text(text)) => {
let trimmed = text.trim();
if trimmed.is_empty() || trimmed.eq_ignore_ascii_case("off") {
crate::window_style::COLOUR_NONE
} else {
match crate::window_style::the_colour_of_a_text(trimmed) {
Some(colour) => colour,
None => {
return Err(RuntimeError {
message: "Parameter #1 of WinSetTransColor is invalid.".to_string(),
line,
});
}
}
}
}
_ => {
return Err(RuntimeError {
message: "Parameter #1 of WinSetTransColor is invalid.".to_string(),
line,
});
}
};
let (_wanted, window) = the_target_of_a_window(rt, values, 1, line)?;
let written = if colour == crate::window_style::COLOUR_NONE {
String::new()
} else {
format!("0x{:06X}", colour)
};
rt.desktop()
.window_set_trans_color(&window.title, &written)
.map_err(|reason| desktop_failure(reason, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn win_style(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
variant: u8,
) -> Result<Value, RuntimeError> {
let extended = variant == 1;
let (_wanted, window) = the_target_of_a_window(rt, values, 0, line)?;
let style = rt
.desktop()
.window_style(&window.title, extended)
.map_err(|reason| desktop_failure(reason, line))?;
Ok(Value::Int(style))
}
pub(crate) fn win_set_style(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
variant: u8,
) -> Result<Value, RuntimeError> {
let extended = variant == 1;
let name = if variant == 1 {
"WinSetExStyle"
} else {
"WinSetStyle"
};
let text = text_of(values, 0);
let Some(change) = crate::window_style::the_style_change_of_a_text(&text) else {
return Err(RuntimeError {
message: format!("Parameter #1 of {name} is invalid."),
line,
});
};
let (_wanted, window) = the_target_of_a_window(rt, values, 1, line)?;
let current = rt
.desktop()
.window_style(&window.title, extended)
.map_err(|reason| desktop_failure(reason, line))?;
let wanted = change.the_style_of(current as u32);
rt.desktop()
.window_set_style(&window.title, wanted as i64, extended)
.map_err(|reason| desktop_failure(reason, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn control_style(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
variant: u8,
) -> Result<Value, RuntimeError> {
let extended = variant == 1;
let control = text_of(values, 0);
let wanted = crate::desktop::TheWindowWanted::of(values, 1);
if wanted.title.is_empty() {
return Err(RuntimeError {
message: TARGET_WINDOW.into(),
line,
});
}
let title = the_title_of_the_window(rt, &wanted, line)?;
match rt
.desktop()
.control_text(&control, &title)
.map_err(|reason| desktop_failure(reason, line))?
{
crate::desktop::ControlAnswer::Found(_) => {}
crate::desktop::ControlAnswer::NoSuchWindow => {
return Err(RuntimeError {
message: TARGET_WINDOW.into(),
line,
});
}
crate::desktop::ControlAnswer::NoSuchControl => {
return Err(RuntimeError {
message: TARGET_CONTROL.into(),
line,
});
}
}
let style = rt
.desktop()
.control_style(&control, &title, extended)
.map_err(|reason| desktop_failure(reason, line))?;
Ok(Value::Int(style))
}
pub(crate) fn control_set_style(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
variant: u8,
) -> Result<Value, RuntimeError> {
let extended = variant == 1;
let name = if variant == 1 {
"ControlSetExStyle"
} else {
"ControlSetStyle"
};
let text = text_of(values, 0);
let Some(change) = crate::window_style::the_style_change_of_a_text(&text) else {
return Err(RuntimeError {
message: format!("Parameter #1 of {name} is invalid."),
line,
});
};
if let Some(Value::Int(hwnd)) = values.get(1) {
let current = rt
.desktop()
.control_style_of_hwnd(*hwnd, extended)
.map_err(|reason| desktop_failure(reason, line))?;
let wanted = change.the_style_of(current as u32);
rt.desktop()
.control_set_style_of_hwnd(*hwnd, wanted as i64, extended)
.map_err(|reason| desktop_failure(reason, line))?;
return Ok(Value::Text(String::new()));
}
let control = text_of(values, 1);
let wanted = crate::desktop::TheWindowWanted::of(values, 2);
if wanted.title.is_empty() {
return Err(RuntimeError {
message: TARGET_WINDOW.into(),
line,
});
}
let title = the_title_of_the_window(rt, &wanted, line)?;
match rt
.desktop()
.control_text(&control, &title)
.map_err(|reason| desktop_failure(reason, line))?
{
crate::desktop::ControlAnswer::Found(_) => {}
crate::desktop::ControlAnswer::NoSuchWindow => {
return Err(RuntimeError {
message: TARGET_WINDOW.into(),
line,
});
}
crate::desktop::ControlAnswer::NoSuchControl => {
return Err(RuntimeError {
message: TARGET_CONTROL.into(),
line,
});
}
}
let current = rt
.desktop()
.control_style(&control, &title, extended)
.map_err(|reason| desktop_failure(reason, line))?;
let wanted = change.the_style_of(current as u32);
rt.desktop()
.control_set_style(&control, &title, wanted as i64, extended)
.map_err(|reason| desktop_failure(reason, line))?;
Ok(Value::Text(String::new()))
}
fn the_target_of_a_window(
rt: &mut Runtime<'_>,
values: &[Value],
index: usize,
line: u32,
) -> Result<(crate::desktop::TheWindowWanted, crate::desktop::WindowInfo), RuntimeError> {
let mut wanted = crate::desktop::TheWindowWanted::of(values, index);
if wanted.title.is_empty() {
match rt.the_last_window() {
Some(id) => wanted.title = format!("ahk_id {id}"),
None => {
return Err(RuntimeError {
message: TARGET_WINDOW.to_string(),
line,
});
}
}
}
let windows = rt
.desktop()
.windows()
.map_err(|reason| desktop_failure(reason, line))?;
let found = the_windows_of_the_listing(rt, &windows, &wanted);
match found.into_iter().next() {
Some(window) => Ok((wanted, window)),
None => Err(no_window(line)),
}
}
fn the_title_of_the_window(
rt: &mut Runtime<'_>,
wanted: &crate::desktop::TheWindowWanted,
line: u32,
) -> Result<String, RuntimeError> {
let windows = rt
.desktop()
.windows()
.map_err(|reason| desktop_failure(reason, line))?;
match the_windows_of_the_listing(rt, &windows, wanted)
.into_iter()
.next()
{
Some(window) => Ok(window.title),
None => Err(no_window(line)),
}
}
pub(crate) fn win_get_text(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let target = text_of(values, 0);
the_window_of_the_script(rt, &target, line)?;
rt.desktop()
.gui_all_text()
.map(Value::Text)
.map_err(|reason| desktop_failure(reason, line))
}
pub(crate) fn win_get_controls(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let target = text_of(values, 0);
the_window_of_the_script(rt, &target, line)?;
let joined = rt
.desktop()
.gui_controls()
.map_err(|reason| desktop_failure(reason, line))?;
let answers: Vec<Value> = if joined.is_empty() {
Vec::new()
} else {
joined
.split('\n')
.map(|name| Value::Text(name.to_string()))
.collect()
};
match crate::classes::construct("array", &answers, rt, line) {
Some(result) => result.map_err(|failure| crate::runtime::as_error(failure, line)),
None => Ok(Value::List(answers)),
}
}
pub(crate) fn win_get_controls_hwnd(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
if let Some(Value::Int(hwnd)) = values.first() {
let hwnds = rt
.desktop()
.control_hwnds_of(*hwnd)
.map_err(|reason| desktop_failure(reason, line))?;
let answers: Vec<Value> = hwnds.into_iter().map(Value::Int).collect();
return match crate::classes::construct("array", &answers, rt, line) {
Some(result) => result.map_err(|failure| crate::runtime::as_error(failure, line)),
None => Ok(Value::List(answers)),
};
}
let target = text_of(values, 0);
the_window_of_the_script(rt, &target, line)?;
let joined = rt
.desktop()
.gui_controls()
.map_err(|reason| desktop_failure(reason, line))?;
let mut answers: Vec<Value> = Vec::new();
if !joined.is_empty() {
for name in joined.split('\n') {
let number = rt
.desktop()
.gui_number_named(name)
.map_err(|reason| desktop_failure(reason, line))?;
answers.push(Value::Int(number));
}
}
match crate::classes::construct("array", &answers, rt, line) {
Some(result) => result.map_err(|failure| crate::runtime::as_error(failure, line)),
None => Ok(Value::List(answers)),
}
}
pub(crate) fn edit(
rt: &mut Runtime<'_>,
_values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let Some(path) = rt.script_path().map(str::to_string) else {
return Err(RuntimeError {
message: "the script of this runtime is read from the standard input, so it has no file for an editor to open".to_string(),
line,
});
};
rt.desktop()
.open_with_the_default_program(&path)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn reload(
rt: &mut Runtime<'_>,
_values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
if rt.script_path().is_none() {
return Ok(Value::Text(String::new()));
}
rt.ask_for_the_script_to_run_again();
rt.exit_with(0);
Ok(Value::Text(String::new()))
}
pub(crate) fn thread_command(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let command = text_of(values, 0);
let mut state = rt.the_thread_state();
match command.to_ascii_lowercase().as_str() {
"priority" => {
if let Some(value) = values.get(1).and_then(|value| value.to_number()) {
state.priority = value as i64;
}
}
"interrupt" => {
if let Some(value) = values.get(1).and_then(|value| value.to_number()) {
state.uninterruptible_ms = value as i64;
}
if let Some(value) = values.get(2).and_then(|value| value.to_number()) {
state.uninterruptible_lines = value as i64;
}
}
"notimers" => {
if let Some(value) = values.get(1).and_then(|value| value.to_number()) {
state.allow_timers = value == 0.0;
}
}
_ => {
return Err(RuntimeError {
message: "Parameter #1 of Thread is invalid.".to_string(),
line,
});
}
}
rt.set_the_thread_state(state);
Ok(Value::Text(String::new()))
}
pub(crate) fn tooltip(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let text = text_of(values, 0);
if text.is_empty() {
rt.desktop()
.tooltip_show("", 0, 0)
.map_err(|e| desktop_failure(e, line))?;
return Ok(Value::Text(String::new()));
}
let x = number_of(values, 1) as i64;
let y = number_of(values, 2) as i64;
let number = rt
.desktop()
.tooltip_show(&text, x, y)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Int(number))
}
pub(crate) fn win_move(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let x = number_of(values, 0) as i64;
let y = number_of(values, 1) as i64;
let width = number_of(values, 2) as i64;
let height = number_of(values, 3) as i64;
let title = text_of(values, 4);
the_window_of_the_script(rt, &title, line)?;
rt.desktop()
.window_move(x, y, width, height)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn control_send(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let raw = rt.interpolate(&text_of(values, 0), line)?;
if !raw.contains('{') && !raw.contains('}') {
return control_send_text(rt, values, line, 0);
}
let mut text = String::new();
for part in split_send(&raw) {
match part {
SendPart::Text(t) => text.push_str(&t),
SendPart::Key { name, modifiers } => {
if !modifiers.is_empty() {
return Err(RuntimeError {
message: format!(
"the {name} key with a modifier has no text to put into a control"
),
line,
});
}
match name.to_ascii_lowercase().as_str() {
"enter" => text.push('\n'),
"tab" => text.push('\t'),
"backspace" | "bs" => {
text.pop();
}
other => {
return Err(RuntimeError {
message: format!(
"the {other} key has no text effect on a control, and this tree will not claim it did"
),
line,
});
}
}
}
SendPart::Down(name) | SendPart::Up(name) => {
return Err(RuntimeError {
message: format!("holding the {name} key down has no text effect on a control"),
line,
});
}
}
}
let mut sent = values.to_vec();
if sent.is_empty() {
sent.push(Value::Text(text));
} else {
sent[0] = Value::Text(text);
}
control_send_text(rt, &sent, line, 0)
}
pub(crate) fn run_as(
_rt: &mut Runtime<'_>,
_values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
Ok(Value::Text(String::new()))
}
pub(crate) fn block_input(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let mode = text_of(values, 0).to_ascii_lowercase();
if mode.is_empty() || mode.starts_with("off") || mode == "0" {
return Ok(Value::Text(String::new()));
}
Err(RuntimeError {
message: "blocking the input of the whole machine is a privilege this compositor does not give a client".to_string(),
line,
})
}
pub(crate) fn on_clipboard_change(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let callback = rt.the_callback_with_one_argument(values.first(), "OnClipboardChange", line)?;
let remove = match values.get(1) {
Some(value) => value.to_number().unwrap_or(1.0) <= 0.0,
None => false,
};
rt.set_the_clipboard_watcher(if remove { None } else { Some(callback.name) });
Ok(Value::Text(String::new()))
}
pub(crate) fn callback_create(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let func = match values.first() {
Some(value) => value.clone(),
None => {
return Err(RuntimeError {
message: "Too few parameters passed to function.".to_string(),
line,
});
}
};
let param_count = match values.get(2) {
Some(Value::Int(n)) if *n >= 0 => *n as usize,
_ => 4,
};
let address = rt
.desktop()
.create_callback(&func, param_count)
.map_err(|reason| RuntimeError { message: reason, line })?;
Ok(Value::Int(address as i64))
}
pub(crate) fn shutdown(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
number_argument(values, 0, line, "Shutdown")?;
Ok(Value::Text(String::new()))
}
pub(crate) fn file_get_version(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let Some(path) = values.first() else {
return Err(RuntimeError {
message: "Parameter #1 of FileGetVersion must not be omitted in this case.".to_string(),
line,
});
};
let path = path.to_text();
let bytes = rt
.desktop()
.read_the_bytes_of_a_file(&path)
.map_err(|reason| desktop_failure(reason, line))?;
match crate::version::the_version_of(&bytes) {
Some(version) => Ok(Value::Text(version)),
None => Err(RuntimeError {
message: "(1812) The specified image file did not contain a resource section."
.to_string(),
line,
}),
}
}
pub(crate) fn control_get_pos(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
for index in 0..4 {
let Some(value) = values.get(index) else {
continue;
};
if !matches!(value, Value::Reference(_)) {
return Err(RuntimeError {
message: crate::runtime::wants_a_reference(
index + 1,
"ControlGetPos",
"a VarRef",
value,
),
line,
});
}
}
let number = the_number_of_a_combo(rt, values, 4, line)?;
let (x, y, width, height) = rt
.desktop()
.gui_control_pos(number)
.map_err(|e| desktop_failure(e, line))?;
let places = [x, y, width, height];
for (index, place) in places.iter().enumerate() {
if values.get(index).is_some() {
rt.write_reference(&values[index], Value::Int(*place));
}
}
Ok(Value::Text(String::new()))
}
pub(crate) fn on_message(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = number_argument(values, 0, line, "OnMessage")? as i64;
let Some(callback) = values.get(1) else {
return Err(RuntimeError {
message: "Parameter #2 of OnMessage must not be omitted in this case.".to_string(),
line,
});
};
if !matches!(callback, Value::Object(_)) {
return Err(RuntimeError {
message: crate::runtime::requires(2, "OnMessage", TypeName::Object, callback),
line,
});
}
if values.get(2).and_then(|value| value.to_number()) == Some(0.0) {
rt.forget_a_message_handler(number);
return Ok(Value::Text(String::new()));
}
rt.remember_a_message_handler(number, callback.clone());
let _ = rt.desktop().watch_a_message(number);
Ok(Value::Text(String::new()))
}
pub(crate) fn post_message(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let message = number_argument(values, 0, line, "PostMessage")? as i64;
let wparam = values.get(1).and_then(|v| v.to_number()).unwrap_or(0.0) as i64;
let lparam = values.get(2).and_then(|v| v.to_number()).unwrap_or(0.0) as i64;
let window = the_hwnd_of_the_message_target(rt, values.get(3), line)?;
rt.desktop()
.post_a_message(window, message, wparam, lparam)
.map_err(|reason| RuntimeError {
message: reason,
line,
})?;
Ok(Value::Int(1))
}
fn the_hwnd_of_the_message_target(
rt: &mut Runtime<'_>,
title: Option<&Value>,
line: u32,
) -> Result<i64, RuntimeError> {
match title {
Some(Value::Int(number)) => return Ok(*number),
Some(Value::Float(number)) => return Ok(*number as i64),
_ => {}
}
let text = title.map(|v| v.to_text()).unwrap_or_default();
let trimmed = text.trim();
if let Some(rest) = trimmed.strip_prefix("ahk_id ") {
let rest = rest.trim();
let number = if let Some(hex) = rest.strip_prefix("0x").or_else(|| rest.strip_prefix("0X")) {
i64::from_str_radix(hex, 16).ok()
} else {
rest.parse::<i64>().ok()
};
if let Some(number) = number {
return Ok(number);
}
}
if trimmed.is_empty() {
return rt.desktop().script_window().map_err(|reason| RuntimeError {
message: reason,
line,
});
}
let windows = rt.desktop().windows().map_err(|reason| RuntimeError {
message: reason,
line,
})?;
let mode = crate::settings::title_match_mode();
for window in windows {
if mode.matches(&window.title, trimmed).unwrap_or(false) {
return Ok(window.id);
}
}
Err(RuntimeError {
message: "Target window not found.".to_string(),
line,
})
}
pub(crate) fn send_message(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let message = number_argument(values, 0, line, "SendMessage")? as i64;
let wparam = values.get(1).and_then(|v| v.to_number()).unwrap_or(0.0) as i64;
let lparam = values.get(2).and_then(|v| v.to_number()).unwrap_or(0.0) as i64;
let window = the_hwnd_of_the_message_target(rt, values.get(3), line)?;
let answer = rt
.desktop()
.send_a_message(window, message, wparam, lparam)
.map_err(|reason| RuntimeError {
message: reason,
line,
})?;
Ok(Value::Int(answer))
}
pub(crate) fn win_set_region(
_rt: &mut Runtime<'_>,
_values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
Err(RuntimeError {
message: "Target window not found.".to_string(),
line,
})
}
pub(crate) fn group_add(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let group = text_of(values, 0);
if group.is_empty() {
return Err(RuntimeError {
message: "the name of a window group may not be empty.".to_string(),
line,
});
}
let wanted = crate::desktop::TheWindowWanted::of(values, 1);
let title = if wanted.asked && !wanted.title.is_empty() {
the_title_of_the_window(rt, &wanted, line)?
} else {
wanted.title.clone()
};
rt.add_to_group(&group, &title);
Ok(Value::Text(String::new()))
}
pub(crate) fn group_activate(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let group = text_of(values, 0);
let titles = rt.the_titles_of_a_group(&group);
for title in titles {
let windows = rt
.desktop()
.matching_windows(&title, crate::settings::title_match_mode())
.map_err(|e| desktop_failure(e, line))?;
if let Some(window) = windows.first() {
return Ok(Value::Text(window.id.clone()));
}
}
Ok(Value::Int(0))
}
pub(crate) fn group_close(
rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let group = text_of(values, 0);
rt.close_a_group(&group);
Ok(Value::Text(String::new()))
}
pub(crate) fn menu_select(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let title = text_of(values, 0);
let windows = rt
.desktop()
.matching_windows(&title, crate::settings::title_match_mode())
.map_err(|e| desktop_failure(e, line))?;
if windows.is_empty() {
return Err(RuntimeError {
message: TARGET_WINDOW.to_string(),
line,
});
}
Err(RuntimeError {
message: "Non-existent or unsupported menu.".to_string(),
line,
})
}
fn the_gui_object_of_a_handle(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
name: &str,
) -> Result<Value, RuntimeError> {
let number = number_argument(values, 0, line, name)? as i64;
match rt.the_object_of(number) {
Some(object) => Ok(object),
None => Ok(Value::Text(String::new())),
}
}
pub(crate) fn gui_from_hwnd(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let object = the_gui_object_of_a_handle(rt, values, line, "GuiFromHwnd")?;
let is_gui = match &object {
Value::Object(o) => o.borrow().class.eq_ignore_ascii_case("gui"),
_ => false,
};
if is_gui {
Ok(object)
} else {
Ok(Value::Text(String::new()))
}
}
pub(crate) fn gui_ctrl_from_hwnd(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = number_argument(values, 0, line, "GuiCtrlFromHwnd")? as i64;
if let Some(object) = rt.the_object_of(number) {
let is_control = match &object {
Value::Object(o) => o.borrow().class.to_lowercase().starts_with("gui."),
_ => false,
};
if is_control {
return Ok(object);
}
}
for gui in rt.the_guis() {
let Value::Object(window) = gui else {
continue;
};
for (key, property) in window.borrow().properties.iter() {
if !key.starts_with("control:") {
continue;
}
let Value::Object(control) = &property.value else {
continue;
};
let stored = control
.borrow()
.value_of("hwnd")
.map(|value| value.to_text().parse::<i64>().unwrap_or(-1));
if stored == Some(number) {
return Ok(property.value.clone());
}
}
}
Ok(Value::Text(String::new()))
}
pub(crate) fn menu_from_handle(
_rt: &mut Runtime<'_>,
_values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
Err(RuntimeError {
message: "a menu handle is a Win32 HMENU, and this runtime has no handle of a menu: the menus are objects the script holds and the helper draws".to_string(),
line,
})
}
fn the_number_of_a_combo(
rt: &mut Runtime<'_>,
values: &[Value],
control_index: usize,
line: u32,
) -> Result<u64, RuntimeError> {
if !rt.desktop().gui_is_open() {
return Err(RuntimeError {
message: "this name asks about a window of another program, and this script has no window of its own".to_string(),
line,
});
}
let classnn = text_of(values, control_index);
let number = rt
.desktop()
.gui_number_named(&classnn)
.map_err(|reason| desktop_failure(reason, line))?;
Ok(number as u64)
}
pub(crate) fn control_get_items(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_number_of_a_combo(rt, values, 0, line)?;
let joined = rt
.desktop()
.gui_combo_items(number)
.map_err(|e| desktop_failure(e, line))?;
let answers: Vec<Value> = if joined.is_empty() {
Vec::new()
} else {
joined
.split('\n')
.map(|item| Value::Text(item.to_string()))
.collect()
};
match crate::classes::construct("array", &answers, rt, line) {
Some(result) => result.map_err(|failure| crate::runtime::as_error(failure, line)),
None => Ok(Value::List(answers)),
}
}
pub(crate) fn control_add_item(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_number_of_a_combo(rt, values, 1, line)?;
let text = text_of(values, 0);
rt.desktop()
.gui_combo_add(number, &text)
.map_err(|e| desktop_failure(e, line))?;
let items = rt
.desktop()
.gui_combo_items(number)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Int(items.lines().count() as i64))
}
pub(crate) fn control_choose_index(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_number_of_a_combo(rt, values, 1, line)?;
let index = number_of(values, 0) as i64;
rt.desktop()
.gui_combo_select(number, &index.to_string(), false)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn control_choose_string(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_number_of_a_combo(rt, values, 1, line)?;
let text = text_of(values, 0);
rt.desktop()
.gui_combo_select(number, &text, true)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn control_get_choice(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_number_of_a_combo(rt, values, 0, line)?;
let (_index, text) = rt
.desktop()
.gui_combo_choice(number)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Text(text))
}
pub(crate) fn control_get_index(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_number_of_a_combo(rt, values, 0, line)?;
let (index, _text) = rt
.desktop()
.gui_combo_choice(number)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Int(index))
}
pub(crate) fn control_delete_item(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_number_of_a_combo(rt, values, 1, line)?;
let index = number_of(values, 0) as i64;
rt.desktop()
.gui_combo_delete(number, &index.to_string())
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn control_find_item(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_number_of_a_combo(rt, values, 1, line)?;
let text = text_of(values, 0);
let index = rt
.desktop()
.gui_combo_find(number, &text)
.map_err(|e| desktop_failure(e, line))?;
if index == 0 {
return Err(RuntimeError {
message: "Failed".to_string(),
line,
});
}
Ok(Value::Int(index))
}
fn the_drop_down_of_a_combo(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
show: bool,
) -> Result<Value, RuntimeError> {
let number = the_number_of_a_combo(rt, values, 0, line)?;
rt.desktop()
.gui_combo_dropdown(number, show)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Text(String::new()))
}
pub(crate) fn control_show_drop_down(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
the_drop_down_of_a_combo(rt, values, line, true)
}
pub(crate) fn control_hide_drop_down(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
the_drop_down_of_a_combo(rt, values, line, false)
}
pub(crate) fn status_bar_get_text(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let title = text_of(values, 1);
the_window_of_the_script(rt, &title, line)?;
rt.desktop()
.gui_status_text()
.map(Value::Text)
.map_err(|e| desktop_failure(e, line))
}
pub(crate) fn status_bar_wait(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let wanted = text_of(values, 0);
let seconds = number_of(values, 1);
let part = number_of(values, 2);
let title = text_of(values, 3);
if part != 1.0 && values.len() > 2 {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(3, "StatusBarWait"),
line,
});
}
the_window_of_the_script(rt, &title, line)?;
let limit = if values.len() > 1 && seconds > 0.0 {
Some(seconds * 1000.0)
} else if values.len() > 1 {
Some(0.0)
} else {
None
};
let started = rt.now_ms();
loop {
let text = rt
.desktop()
.gui_status_text()
.map_err(|e| desktop_failure(e, line))?;
if text.contains(&wanted) {
return Ok(Value::Int(1));
}
let waited = rt.now_ms().saturating_sub(started) as f64;
let left = match limit {
Some(limit) => {
if waited >= limit {
return Ok(Value::Int(0));
}
limit - waited
}
None => {
let left = rt.remaining_ms();
if left == 0 {
return Ok(Value::Int(0));
}
left as f64
}
};
rt.sleep_ms((left as u64).clamp(1, CLIP_POLL_MS));
}
}
pub(crate) fn list_view_get_content(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let options = text_of(values, 0);
let classnn = text_of(values, 1);
let title = text_of(values, 2);
the_window_of_the_script(rt, &title, line)?;
if !rt.desktop().gui_is_open() {
return Err(RuntimeError {
message: TARGET_WINDOW.to_string(),
line,
});
}
let number = rt
.desktop()
.gui_number_named(&classnn)
.map_err(|reason| desktop_failure(reason, line))?;
let selected = options.eq_ignore_ascii_case("selected");
rt.desktop()
.gui_list_content(number as u64, selected)
.map(Value::Text)
.map_err(|e| desktop_failure(e, line))
}