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};
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,
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,
}
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: "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: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "CallbackCreate",
kind: BuiltinKind::Command,
min: 1,
max: 3,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "CallbackFree",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "CaretGetPos",
kind: BuiltinKind::Function,
min: 0,
max: 2,
variant: 100,
parameters: &[Parameter::Reference, Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ComCall",
kind: BuiltinKind::Function,
min: 2,
max: 255,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ComObjActive",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ComObjConnect",
kind: BuiltinKind::Function,
min: 1,
max: 2,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ComObjFlags",
kind: BuiltinKind::Function,
min: 1,
max: 3,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ComObjFromPtr",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ComObjGet",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ComObjQuery",
kind: BuiltinKind::Function,
min: 2,
max: 3,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ComObjType",
kind: BuiltinKind::Function,
min: 1,
max: 2,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ComObjValue",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlAddItem",
kind: BuiltinKind::Command,
min: 2,
max: 6,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlChooseIndex",
kind: BuiltinKind::Command,
min: 2,
max: 6,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlChooseString",
kind: BuiltinKind::Command,
min: 2,
max: 6,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlClick",
kind: BuiltinKind::Command,
min: 0,
max: 8,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlDeleteItem",
kind: BuiltinKind::Command,
min: 2,
max: 6,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlFindItem",
kind: BuiltinKind::Command,
min: 2,
max: 6,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlFocus",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlGetChecked",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlGetChoice",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlGetClassNN",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlGetEnabled",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlGetExStyle",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlGetFocus",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlGetHwnd",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlGetIndex",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlGetItems",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlGetPos",
kind: BuiltinKind::Command,
min: 0,
max: 9,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlGetStyle",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlGetText",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlGetVisible",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlHide",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlHideDropDown",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlMove",
kind: BuiltinKind::Command,
min: 0,
max: 9,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlSend",
kind: BuiltinKind::Command,
min: 1,
max: 6,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlSendText",
kind: BuiltinKind::Command,
min: 1,
max: 6,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlSetChecked",
kind: BuiltinKind::Command,
min: 2,
max: 6,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlSetEnabled",
kind: BuiltinKind::Command,
min: 2,
max: 6,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlSetExStyle",
kind: BuiltinKind::Command,
min: 2,
max: 6,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlSetStyle",
kind: BuiltinKind::Command,
min: 2,
max: 6,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlSetText",
kind: BuiltinKind::Command,
min: 2,
max: 6,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlShow",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ControlShowDropDown",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
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: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "DriveGetCapacity",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "DriveGetFilesystem",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "DriveGetLabel",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "DriveGetList",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "DriveGetSerial",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "DriveGetSpaceFree",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "DriveGetStatus",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "DriveGetStatusCD",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "DriveGetType",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "DriveLock",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "DriveRetract",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "DriveSetLabel",
kind: BuiltinKind::Command,
min: 1,
max: 2,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "DriveUnlock",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "Edit",
kind: BuiltinKind::Command,
min: 0,
max: 0,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "EditGetCurrentCol",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "EditGetCurrentLine",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "EditGetLine",
kind: BuiltinKind::Command,
min: 2,
max: 6,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "EditGetLineCount",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "EditGetSelectedText",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "EditPaste",
kind: BuiltinKind::Command,
min: 2,
max: 6,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "FileCreateShortcut",
kind: BuiltinKind::Command,
min: 2,
max: 9,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "FileGetShortcut",
kind: BuiltinKind::Command,
min: 1,
max: 8,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "FileGetVersion",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "FileRecycle",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "FileRecycleEmpty",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "GroupActivate",
kind: BuiltinKind::Command,
min: 1,
max: 2,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "GroupAdd",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "GroupClose",
kind: BuiltinKind::Command,
min: 1,
max: 2,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "GroupDeactivate",
kind: BuiltinKind::Command,
min: 1,
max: 2,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "GuiCtrlFromHwnd",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "GuiFromHwnd",
kind: BuiltinKind::Command,
min: 1,
max: 2,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "IL_Add",
kind: BuiltinKind::Command,
min: 2,
max: 4,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "IL_Create",
kind: BuiltinKind::Command,
min: 0,
max: 3,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "IL_Destroy",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ListViewGetContent",
kind: BuiltinKind::Command,
min: 0,
max: 6,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "MenuFromHandle",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "MenuSelect",
kind: BuiltinKind::Command,
min: 0,
max: 11,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "MonitorGet",
kind: BuiltinKind::Command,
min: 0,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "MonitorGetCount",
kind: BuiltinKind::Command,
min: 0,
max: 0,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "MonitorGetName",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "MonitorGetPrimary",
kind: BuiltinKind::Command,
min: 0,
max: 0,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "MonitorGetWorkArea",
kind: BuiltinKind::Command,
min: 0,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
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: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ObjFromPtrAddRef",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
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: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ObjPtrAddRef",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ObjRelease",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
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: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "OnMessage",
kind: BuiltinKind::Command,
min: 2,
max: 3,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "OutputDebug",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "PostMessage",
kind: BuiltinKind::Command,
min: 1,
max: 8,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ProcessClose",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ProcessExist",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ProcessGetName",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ProcessGetParent",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ProcessGetPath",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ProcessSetPriority",
kind: BuiltinKind::Command,
min: 1,
max: 2,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ProcessWait",
kind: BuiltinKind::Command,
min: 1,
max: 2,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ProcessWaitClose",
kind: BuiltinKind::Command,
min: 1,
max: 2,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "RegCreateKey",
kind: BuiltinKind::Function,
min: 0,
max: 1,
variant: 123,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "RegDelete",
kind: BuiltinKind::Function,
min: 0,
max: 2,
variant: 123,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "RegDeleteKey",
kind: BuiltinKind::Function,
min: 0,
max: 1,
variant: 123,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "RegRead",
kind: BuiltinKind::Function,
min: 0,
max: 3,
variant: 123,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "RegWrite",
kind: BuiltinKind::Function,
min: 0,
max: 4,
variant: 123,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "RunAs",
kind: BuiltinKind::Command,
min: 0,
max: 3,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "SendMessage",
kind: BuiltinKind::Command,
min: 1,
max: 9,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "SetCapsLockState",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
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: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
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: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
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: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
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: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
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: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
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: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "StatusBarWait",
kind: BuiltinKind::Command,
min: 0,
max: 8,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "StrGet",
kind: BuiltinKind::Function,
min: 1,
max: 3,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "StrPtr",
kind: BuiltinKind::Function,
min: 1,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "StrPut",
kind: BuiltinKind::Function,
min: 1,
max: 4,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "SysGet",
kind: BuiltinKind::Command,
min: 1,
max: 1,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "SysGetIPAddresses",
kind: BuiltinKind::Command,
min: 0,
max: 0,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ToolTip",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "TraySetIcon",
kind: BuiltinKind::Command,
min: 0,
max: 3,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "TrayTip",
kind: BuiltinKind::Command,
min: 0,
max: 3,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinActivate",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinActivateBottom",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinClose",
kind: BuiltinKind::Command,
min: 0,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinGetClass",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinGetClientPos",
kind: BuiltinKind::Command,
min: 0,
max: 8,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinGetControls",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinGetControlsHwnd",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinGetCount",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinGetExStyle",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinGetID",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinGetIDLast",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinGetList",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinGetMinMax",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinGetPID",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinGetPos",
kind: BuiltinKind::Command,
min: 0,
max: 8,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinGetProcessName",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinGetProcessPath",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinGetStyle",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinGetText",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 121,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinGetTransColor",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinGetTransparent",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinHide",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinKill",
kind: BuiltinKind::Command,
min: 0,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinMaximize",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinMinimize",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinMinimizeAll",
kind: BuiltinKind::Command,
min: 0,
max: 0,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinMinimizeAllUndo",
kind: BuiltinKind::Command,
min: 0,
max: 0,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinMove",
kind: BuiltinKind::Command,
min: 0,
max: 8,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinMoveBottom",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinMoveTop",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinRedraw",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinRestore",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinSetAlwaysOnTop",
kind: BuiltinKind::Command,
min: 0,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinSetEnabled",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinSetExStyle",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinSetRegion",
kind: BuiltinKind::Command,
min: 0,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinSetStyle",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinSetTitle",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinSetTransColor",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinSetTransparent",
kind: BuiltinKind::Command,
min: 1,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinShow",
kind: BuiltinKind::Command,
min: 0,
max: 4,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinWait",
kind: BuiltinKind::Command,
min: 0,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinWaitActive",
kind: BuiltinKind::Command,
min: 0,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinWaitClose",
kind: BuiltinKind::Command,
min: 0,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "WinWaitNotActive",
kind: BuiltinKind::Command,
min: 0,
max: 5,
variant: 100,
parameters: &[Parameter::Value],
handler: not_carried,
},
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: 108,
parameters: &[Parameter::Value],
handler: not_carried,
},
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: 114,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "ListVars",
kind: BuiltinKind::Command,
min: 0,
max: 0,
variant: 115,
parameters: &[Parameter::Value],
handler: not_carried,
},
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: 110,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "Persistent",
kind: BuiltinKind::Command,
min: 0,
max: 1,
variant: 111,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "Reload",
kind: BuiltinKind::Command,
min: 0,
max: 0,
variant: 112,
parameters: &[Parameter::Value],
handler: not_carried,
},
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: 113,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "Thread",
kind: BuiltinKind::Command,
min: 1,
max: 3,
variant: 109,
parameters: &[Parameter::Value],
handler: not_carried,
},
Builtin {
name: "VerCompare",
kind: BuiltinKind::Function,
min: 2,
max: 2,
variant: 0,
parameters: &[Parameter::Value],
handler: ver_compare,
},
];
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 == "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 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)
}
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 Value::Text(target) = first else {
return Err((
NativeFailureKind::Invalid,
RuntimeError {
message: expected_type(TypeName::String, first.type_name()),
line,
},
));
};
let (library, function) = crate::dll::split_target(target);
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,
};
let answer = rt.desktop().call_native(&mut call).map_err(|failure| {
(
failure.kind,
RuntimeError {
message: failure.reason,
line,
},
)
})?;
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."
}
20 => "the handler of an error is not carried: this runtime ends the script when it fails.",
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,
}
}
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)?;
crate::files::refuse_the_wildcards(&path, line)?;
rt.desktop()
.delete_file(&path)
.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: reason,
line,
})?;
Ok(Value::Text(path))
}
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()))
}
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::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> {
if values.len() > 1 {
return Err(RuntimeError {
message: "the method of the sending is not carried yet.".into(),
line,
});
}
let mode = text_of(values, 0).to_lowercase();
match mode.as_str() {
"input" => {
rt.note("the keys go through the keyboard of the box, one at a time");
Ok(Value::Int(1))
}
_ => Err(RuntimeError {
message: "the keys of this runtime go through the keyboard of the box, and that is the only mode there is.".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> {
if values.len() > 2 {
return Err(RuntimeError {
message: "the priority of the timer is not carried yet.".into(),
line,
});
}
let name = text_of(values, 0);
let period = number_of(values, 1);
let period = if period > 0.0 { period as u64 } else { 250 };
rt.add_timer(&name, period);
Ok(Value::Int(1))
}
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> {
if values.len() > 1 {
return Err(RuntimeError {
message: "the volume, the speed and the pitch of a sound are not carried yet.".into(),
line,
});
}
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(|e| desktop_failure(e, line))?;
Ok(Value::Int(1))
}
pub(crate) fn sound_get_volume(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
if values.len() > 2 {
return Err(RuntimeError {
message:
"the component of a sound is not carried yet: the box has one volume per device."
.into(),
line,
});
}
component_of(values, 0, line)?;
let device = device_of(values, 1);
let volume = rt
.desktop()
.sound_volume(&device)
.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> {
if values.len() > 3 {
return Err(RuntimeError {
message:
"the component of a sound is not carried yet: the box has one volume per device."
.into(),
line,
});
}
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,
});
}
component_of(values, 1, line)?;
let device = device_of(values, 2);
if adjust {
let current = rt
.desktop()
.sound_volume(&device)
.map_err(|e| desktop_failure(e, line))?;
let wanted = (current + number).clamp(0.0, 100.0);
rt.desktop()
.sound_set_volume(&device, wanted)
.map_err(|e| desktop_failure(e, line))?;
} else {
rt.desktop()
.sound_set_volume(&device, 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> {
if values.len() > 2 {
return Err(RuntimeError {
message:
"the component of a sound is not carried yet: the box has one volume per device."
.into(),
line,
});
}
component_of(values, 0, line)?;
let device = device_of(values, 1);
let muted = rt
.desktop()
.sound_muted(&device)
.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> {
if values.len() > 3 {
return Err(RuntimeError {
message:
"the component of a sound is not carried yet: the box has one volume per device."
.into(),
line,
});
}
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,
});
}
component_of(values, 1, line)?;
let device = device_of(values, 2);
let muted = if setting < 0.0 {
let current = rt
.desktop()
.sound_muted(&device)
.map_err(|e| desktop_failure(e, line))?;
!current
} else {
setting != 0.0
};
rt.desktop()
.sound_set_muted(&device, muted)
.map_err(|e| desktop_failure(e, line))?;
Ok(Value::Int(1))
}
fn component_of(values: &[Value], index: usize, line: u32) -> Result<String, RuntimeError> {
let component = match values.get(index) {
Some(value) => value.to_text(),
None => return Ok(String::new()),
};
if component.is_empty() || component.eq_ignore_ascii_case("master") {
return Ok(String::new());
}
Err(RuntimeError {
message: "the box has one volume per device: the master volume is the only one it has."
.into(),
line,
})
}
fn device_of(values: &[Value], index: usize) -> String {
match values.get(index) {
Some(Value::Int(number)) => format!("#{number}"),
Some(value) => value.to_text(),
None => 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)),
("MonitorGet", 1, Wants::Reference("a VarRef")),
("MonitorGet", 2, Wants::Reference("a VarRef")),
("MonitorGet", 3, Wants::Reference("a VarRef")),
("MonitorGet", 4, Wants::Reference("a VarRef")),
("MonitorGetName", 0, Wants::Declared(TypeName::Number)),
("MonitorGetWorkArea", 0, Wants::Declared(TypeName::Number)),
("MonitorGetWorkArea", 1, Wants::Reference("a VarRef")),
("MonitorGetWorkArea", 2, Wants::Reference("a VarRef")),
("MonitorGetWorkArea", 3, Wants::Reference("a VarRef")),
("MonitorGetWorkArea", 4, Wants::Reference("a VarRef")),
("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)),
];
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)
}
_ => 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 target = values
.first()
.cloned()
.unwrap_or(Value::Text(String::new()));
rt.base_of(&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,
}
}
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,
}),
}
}
fn case_sense(values: &[Value], index: usize, name: &str, line: u32) -> Result<bool, RuntimeError> {
match values.get(index) {
Some(Value::Int(number)) if *number == 0 || *number == 1 => Ok(*number == 1),
None => Ok(false),
Some(_) => Err(RuntimeError {
message: crate::runtime::invalid_parameter(index + 1, name),
line,
}),
}
}
fn compare_texts(left: &str, right: &str, case_sensitive: bool) -> Ordering {
if case_sensitive {
left.cmp(right)
} else {
left.to_lowercase().cmp(&right.to_lowercase())
}
}
fn compare_values(left: &Value, right: &Value) -> Ordering {
match (left, right) {
(Value::Int(left), Value::Int(right)) => left.cmp(right),
(Value::Float(left), Value::Float(right)) => {
left.partial_cmp(right).unwrap_or(Ordering::Equal)
}
(Value::Int(left), Value::Float(right)) => {
(*left as f64).partial_cmp(right).unwrap_or(Ordering::Equal)
}
(Value::Float(left), Value::Int(right)) => left
.partial_cmp(&(*right as f64))
.unwrap_or(Ordering::Equal),
_ => compare_texts(&left.to_text(), &right.to_text(), false),
}
}
fn same_letter(left: char, right: char, case_sensitive: bool) -> bool {
if case_sensitive {
left == right
} else {
left.eq_ignore_ascii_case(&right)
}
}
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, false));
if same {
return haystack.char_indices().nth(at).map(|(byte, _)| byte);
}
}
None
}
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 number = number_argument(values, 0, line, "Round")?;
let digits = number_argument(values, 1, line, "Round")? as i32;
let factor = crate::runtime::powi(10.0, digits);
Ok(Value::from_number(
crate::runtime::round(number * factor) / factor,
))
}
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();
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;
let Some(character) = char::from_u32(code as u32) else {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, "Chr"),
line,
});
};
Ok(Value::Text(character.to_string()))
}
pub(crate) fn format(
_rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
Ok(Value::Text(format_pattern(
&text_of(values, 0),
&values[1.min(values.len())..],
)))
}
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 case_sensitive = case_sense(values, 2, "InStr", line)?;
let start = match values.get(3).and_then(|value| value.to_number()) {
Some(start) => (start.max(1.0) as usize - 1).min(haystack.len()),
None => 0,
};
let occurrence = match values.get(4) {
None => 1usize,
Some(value) => {
let Some(number) = value.to_number() else {
return Err(RuntimeError {
message: crate::runtime::requires(
5,
"InStr",
crate::runtime::TypeName::Number,
value,
),
line,
});
};
if number < 1.0 {
return Err(RuntimeError {
message: crate::runtime::invalid_parameter(5, "InStr"),
line,
});
}
number as usize
}
};
let end = haystack.len();
if end < start || end - start < needle.len() {
return Ok(Value::Int(0));
}
let mut found = 0usize;
for at in start..=(end - needle.len()) {
let same = haystack[at..at + needle.len()]
.iter()
.zip(needle.iter())
.all(|(left, right)| same_letter(*left, *right, case_sensitive));
if same {
found += 1;
if found == occurrence {
return Ok(Value::Int(at as i64 + 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 = text
.chars()
.next()
.map(|character| character as i64)
.unwrap_or(0);
Ok(Value::Int(code))
}
pub(crate) fn sort(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
if values.len() > 1 {
return Err(RuntimeError {
message: "the options of the sort are not carried yet.".into(),
line,
});
}
match values.first() {
Some(Value::List(items)) => {
let mut sorted = items.clone();
sorted.sort_by(compare_values);
Ok(Value::List(sorted))
}
Some(Value::Text(text)) => {
let mut lines: Vec<&str> = text.split('\n').collect();
lines.sort_by(|left, right| compare_texts(left, right, false));
Ok(Value::Text(lines.join("\n")))
}
_ => Err(RuntimeError {
message: crate::runtime::invalid_parameter(1, "Sort"),
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(text_of(values, 0).chars().count() 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 case_sensitive = case_sense(values, 3, "StrReplace", line)?;
let limit = 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 = if case_sensitive {
rest.find(needle.as_str())
} else {
find_ignoring_case(rest, &needle)
};
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::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))
}
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 current = rt
.read_reference(reference)
.unwrap_or(Value::Text(String::new()));
let Some(capacity) = values.get(1) else {
return Ok(Value::Int(current.to_text().chars().count() as i64));
};
let capacity = match capacity.to_number_strict() {
Ok(number) => number as i64,
Err(kind) => {
return Err(RuntimeError {
message: crate::runtime::expected_type(TypeName::Integer, kind),
line,
});
}
};
rt.write_reference(value, Value::Text(String::new()));
Ok(Value::Int(capacity))
}
pub(crate) fn sub_str(
_rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let text: Vec<char> = text_of(values, 0).chars().collect();
let start = number_of(values, 1) as i64;
let from = start_index(start, text.len()).min(text.len());
let sliced: String = 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].iter().collect()
} else {
let to = (from + length as usize).min(text.len());
text[from..to].iter().collect()
}
}
None => text[from..].iter().collect(),
};
Ok(Value::Text(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> {
if values.len() > 1 {
return Err(RuntimeError {
message: "the code page of the text is not carried yet.".into(),
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 }))
}
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()))
}
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> {
if values.len() > 2 {
return Err(RuntimeError {
message: "the matches of the pattern are not carried into a variable yet.".into(),
line,
});
}
let text = text_of(values, 0);
let pattern = text_of(values, 1);
let regex = crate::regex::Regex::new(&pattern).map_err(|reason| RuntimeError {
message: reason,
line,
})?;
let found = regex.find(&text).map_err(|reason| RuntimeError {
message: reason,
line,
})?;
Ok(Value::Int(
found.map(|found| found.span().0 as i64 + 1).unwrap_or(0),
))
}
pub(crate) fn regex_replace(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let text = text_argument("RegExReplace", values, 0, line)?;
let pattern = text_argument("RegExReplace", values, 1, 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, &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,
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(_) => {
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 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" => {
return Err(RuntimeError {
message: "the fourth button is not carried yet.".into(),
line,
});
}
"x2" => {
return Err(RuntimeError {
message: "the fifth button is not carried yet.".into(),
line,
});
}
"down" | "d" | "up" | "u" => {
return Err(RuntimeError {
message: "the pressing of the button is not carried yet.".into(),
line,
});
}
"rel" | "relative" => {
return Err(RuntimeError {
message: "the place relative to the pointer is not carried yet.".into(),
line,
});
}
other
if other.starts_with("wheel")
|| other == "wu"
|| other == "wd"
|| other == "wl"
|| other == "wr" =>
{
return Err(RuntimeError {
message: "the wheel is not carried yet.".into(),
line,
});
}
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 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 name = match button.to_lowercase().as_str() {
"left" | "l" => "left",
"right" | "r" => "right",
"middle" | "m" => "middle",
"x1" => {
return Err(RuntimeError {
message: "the fourth button is not carried yet.".into(),
line,
});
}
"x2" => {
return Err(RuntimeError {
message: "the fifth button is not carried yet.".into(),
line,
});
}
"wheelup" | "wu" | "wheeldown" | "wd" | "wheelleft" | "wl" | "wheelright" | "wr" => {
return Err(RuntimeError {
message: "the wheel is not carried yet.".into(),
line,
});
}
_ => {
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;
if values
.get(5)
.map(|value| !value.to_text().trim().is_empty())
.unwrap_or(false)
{
return Err(RuntimeError {
message: "the pressing of the button is not carried yet.".into(),
line,
});
}
if values
.get(6)
.map(|value| !value.to_text().trim().is_empty())
.unwrap_or(false)
{
return Err(RuntimeError {
message: "the place relative to the pointer is not carried yet.".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))
}
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> {
let text = text_of(values, 0);
let mut out = String::with_capacity(text.len());
let mut first = true;
for character in text.chars() {
if character.is_alphanumeric() {
if first {
out.extend(character.to_uppercase());
} else {
out.extend(character.to_lowercase());
}
first = false;
} else {
out.push(character);
first = true;
}
}
Ok(Value::Text(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> {
if values.len() > 3 {
return Err(RuntimeError {
message: "the relative place of the move is not carried yet.".into(),
line,
});
}
if let Some(speed) = values.get(2) {
if speed.to_number().unwrap_or(0.0) != 0.0 {
return Err(RuntimeError {
message: "the speed of the move is not carried yet.".into(),
line,
});
}
}
let x = number_of(values, 0) as i64;
let y = number_of(values, 1) as i64;
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))
}
pub(crate) fn window_active(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
if values.len() > 1 {
return Err(RuntimeError {
message: "the text of the window and the exclusions are not carried yet.".into(),
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> {
if values.len() > 1 {
return Err(RuntimeError {
message: "the text of the window and the exclusions are not carried yet.".into(),
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> {
if !values.is_empty() {
return Err(RuntimeError {
message: "the window to ask about is not carried yet: only the active one is.".into(),
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()))
}
pub(crate) fn msg_box(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
if values.len() > 1 {
return Err(RuntimeError {
message:
"the options, the title and the variable that takes the answer are not carried yet."
.into(),
line,
});
}
let text = rt.interpolate(&text_of(values, 0), line)?;
rt.push_output(text.clone());
Ok(Value::Text(text))
}
pub(crate) fn run(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
if values.len() > 2 {
return Err(RuntimeError {
message: "the options of the window and the pid of the process are not carried yet."
.into(),
line,
});
}
let command = text_of(values, 0);
let working_dir = text_of(values, 1);
let (code, stdout, stderr) = rt
.desktop()
.run(&command, &working_dir)
.map_err(|e| desktop_failure(e, line))?;
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));
}
}
fn format_pattern(pattern: &str, arguments: &[Value]) -> String {
let mut out = String::with_capacity(pattern.len());
let chars: Vec<char> = pattern.chars().collect();
let mut index = 0usize;
let mut next = 0usize;
while index < chars.len() {
match chars[index] {
'{' if chars.get(index + 1) == Some(&'{') => {
out.push('{');
index += 2;
continue;
}
'}' if chars.get(index + 1) == Some(&'}') => {
out.push('}');
index += 2;
continue;
}
'{' => {}
other => {
out.push(other);
index += 1;
continue;
}
}
let Some(offset) = chars[index + 1..].iter().position(|c| *c == '}') else {
out.push(chars[index]);
index += 1;
continue;
};
let close = index + 1 + offset;
let inside: String = chars[index + 1..close].iter().collect();
let (position, spec) = match inside.split_once(':') {
Some((position, spec)) => (position.trim().to_string(), spec.trim().to_string()),
None => (inside.trim().to_string(), String::new()),
};
let argument = if position.is_empty() {
let argument = arguments.get(next);
next += 1;
argument
} else {
position
.parse::<usize>()
.ok()
.and_then(|number| number.checked_sub(1))
.and_then(|number| arguments.get(number))
};
match argument {
Some(value) => out.push_str(&format_value(value, &spec)),
None => {
out.push('{');
out.push_str(&inside);
out.push('}');
}
}
index = close + 1;
}
out
}
fn format_value(value: &Value, spec: &str) -> String {
let mut decimals: Option<usize> = None;
let mut integer = false;
for character in spec.chars() {
match character {
'.' => decimals = Some(0),
'0'..='9' => {
if let Some(count) = decimals {
decimals = Some(count * 10 + character.to_digit(10).unwrap_or(0) as usize);
}
}
'd' | 'i' | 'u' => integer = true,
_ => {}
}
}
if integer {
let number = crate::runtime::round(value.to_number().unwrap_or(0.0));
return Value::Int(number as i64).to_text();
}
match decimals {
Some(decimals) => {
let number = value.to_number().unwrap_or(0.0);
format!("{number:.decimals$}")
}
None => value.to_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
}