Skip to main content

runec/clientscript/
hooks.rs

1use crate::arguments::{expression_types, stack_hints};
2use crate::lexer::Lexer;
3use crate::parser::{Expr, Parser, ScriptDeclaration, StringPart};
4use crate::symbol::{SymbolKind, SymbolRegistry, SymbolTable};
5use crate::types::{BaseVarType, Type};
6use std::path::PathBuf;
7
8/// A value a component's hook hands its script.
9#[derive(Clone, Debug, PartialEq, Eq)]
10pub enum HookValue {
11    Int(i32),
12    String(String),
13}
14
15fn hook_value(
16    arg: &Expr,
17    hint: Option<Type>,
18    registry: &SymbolRegistry,
19) -> Result<HookValue, String> {
20    let string = hint.is_some_and(|ty| ty.base_type() == BaseVarType::String);
21    Ok(match arg {
22        Expr::IntLiteral(value) | Expr::CoordLiteral(value) => HookValue::Int(*value),
23        Expr::CharLiteral(value) => HookValue::Int(*value as i32),
24        Expr::BoolLiteral(value) => HookValue::Int(i32::from(*value)),
25        Expr::NullLiteral if string => HookValue::String("null".to_owned()),
26        Expr::NullLiteral => HookValue::Int(-1),
27        Expr::StringLiteral(name) => match hint
28            .filter(|_| !string)
29            .and_then(|ty| registry.lookup_reference(name, ty))
30        {
31            Some(id) => HookValue::Int(id),
32            None => HookValue::String(name.clone()),
33        },
34        Expr::JoinedString { parts } => {
35            let mut text = String::new();
36            for part in parts {
37                let StringPart::Literal(part) = part else {
38                    return Err("A hook argument must be a constant value".to_owned());
39                };
40                text.push_str(part);
41            }
42            HookValue::String(text)
43        }
44        Expr::Identifier(name) | Expr::ConstantVar(name, _) => {
45            let component = name
46                .split_once(':')
47                .and_then(|(interface, component)| registry.lookup_component(interface, component));
48            let reference = hint.and_then(|ty| registry.lookup_reference(name, ty));
49            if let Some(id) = component.or(reference) {
50                return Ok(HookValue::Int(id));
51            }
52            if let Some(SymbolKind::Constant {
53                int_value,
54                string_value,
55                ..
56            }) = registry.lookup_constant(name).map(|symbol| &symbol.kind)
57            {
58                if let Some(value) = int_value {
59                    return Ok(HookValue::Int(*value));
60                }
61                if let Some(value) = string_value {
62                    return Ok(HookValue::String(value.clone()));
63                }
64            }
65            match registry.lookup_entity_id(name) {
66                Some(entity) => HookValue::Int(entity.id),
67                None => return Err(format!("Unknown hook argument '{name}'")),
68            }
69        }
70        _ => return Err("A hook argument must be a constant value".to_owned()),
71    })
72}
73
74/// A component's hook as an interface writes it: `script(args){transmits}`.
75/// Gives the values the hook holds, its script first, and its transmit list.
76pub fn component_hook(
77    text: &str,
78    kind: Option<&str>,
79    registry: &SymbolRegistry,
80) -> Result<(Vec<HookValue>, Vec<i32>), String> {
81    let values = parse(text)?;
82    let Expr::Tuple(args) = &values[1] else {
83        unreachable!()
84    };
85    let (script, params) = match &values[0] {
86        Expr::IntLiteral(id) => (*id, Vec::new()),
87        Expr::Identifier(name) => {
88            let id = registry
89                .lookup_reference(name, Type::ClientScript)
90                .or_else(|| name.strip_prefix("script")?.parse().ok())
91                .ok_or_else(|| format!("Unknown clientscript '{name}'"))?;
92            let params = match registry
93                .lookup_script_by_trigger("clientscript", name)
94                .or_else(|| registry.lookup_script_by_trigger("proc", name))
95                .map(|symbol| &symbol.kind)
96            {
97                Some(SymbolKind::Script { param_types, .. }) => param_types.clone(),
98                _ => Vec::new(),
99            };
100            (id, params)
101        }
102        _ => unreachable!(),
103    };
104    let hints = stack_hints(registry, &params, args, &SymbolTable::new());
105    let mut hook = vec![HookValue::Int(script)];
106    for (arg, hint) in args.iter().zip(hints) {
107        hook.push(hook_value(arg, hint, registry)?);
108    }
109    let mut transmits = Vec::new();
110    if let Some(Expr::Tuple(list)) = values.get(2) {
111        let kind = kind.ok_or("This hook has no transmit list")?;
112        for value in list {
113            transmits.push(match value {
114                Expr::IntLiteral(id) => *id,
115                Expr::Identifier(name) => transmit_id(registry, kind, name)
116                    .ok_or_else(|| format!("Unknown {kind} transmit trigger '{name}'"))?,
117                _ => return Err("A transmit trigger must be a name".to_owned()),
118            });
119        }
120    }
121    Ok((hook, transmits))
122}
123
124pub(crate) fn transmit_kind(command: &str) -> Option<&'static str> {
125    let command = command.trim_start_matches('.');
126    match command
127        .strip_prefix("cc_")
128        .or_else(|| command.strip_prefix("if_"))?
129    {
130        "setonvartransmit" => Some("varp"),
131        "setonvarctransmit" => Some("varc"),
132        "setonvarcstrtransmit" => Some("varcs"),
133        "setoninvtransmit" => Some("inv"),
134        "setonstattransmit" => Some("stat"),
135        _ => None,
136    }
137}
138
139/// What a variable of a table goes by without a name of its own.
140pub(crate) fn var_placeholder(kind: &str) -> &str {
141    match kind {
142        "varp" => "varplayer",
143        "varbit" => "varplayerbit",
144        "varc" | "varcs" => "varclient",
145        other => other,
146    }
147}
148
149pub(crate) fn transmit_id(registry: &SymbolRegistry, kind: &str, name: &str) -> Option<i32> {
150    if kind.starts_with("var") {
151        match registry.lookup_game_var(name).map(|symbol| &symbol.kind) {
152            Some(SymbolKind::GameVar {
153                var_id, category, ..
154            }) if category == kind => Some(*var_id),
155            None => name
156                .strip_prefix(var_placeholder(kind))?
157                .strip_prefix('_')?
158                .parse::<u16>()
159                .ok()
160                .map(i32::from),
161            _ => None,
162        }
163    } else {
164        registry.lookup_reference(name, Type::from_name(kind)?)
165    }
166}
167
168pub(crate) fn transmit_name(registry: &SymbolRegistry, kind: &str, id: i32) -> Option<String> {
169    if kind.starts_with("var") {
170        registry
171            .game_variables()
172            .filter_map(|(name, symbol)| {
173                matches!(&symbol.kind, SymbolKind::GameVar { var_id, category, .. }
174                if *var_id == id && category == kind && !name.starts_with('.'))
175                .then_some(name)
176            })
177            .min()
178            .map(str::to_owned)
179            .or_else(|| {
180                u16::try_from(id)
181                    .ok()
182                    .map(|_| format!("{}_{id}", var_placeholder(kind)))
183            })
184    } else {
185        let ty = Type::from_name(kind)?;
186        registry
187            .entity_ids
188            .iter()
189            .filter_map(|(name, entity)| {
190                entity.variants.contains(&(ty, id)).then_some(name.as_str())
191            })
192            .min()
193            .map(str::to_owned)
194    }
195}
196
197fn resolve_transmits(
198    values: &mut [Expr],
199    command: &str,
200    registry: &SymbolRegistry,
201) -> Result<(), String> {
202    if let Some(kind) = transmit_kind(command)
203        && let Some(Expr::Tuple(transmits)) = values.get_mut(2)
204    {
205        for value in transmits {
206            if let Expr::Identifier(name) = value {
207                let id = transmit_id(registry, kind, name)
208                    .ok_or_else(|| format!("Unknown {kind} transmit trigger '{name}'"))?;
209                *value = Expr::IntLiteral(id);
210            }
211        }
212    }
213    Ok(())
214}
215
216pub(crate) fn lower(
217    registry: &SymbolRegistry,
218    name: &str,
219    args: &[Expr],
220    locals: &SymbolTable,
221    line: usize,
222) -> Result<Option<Vec<Expr>>, String> {
223    let Some(&explicit) = registry.hook_commands.get(name.trim_start_matches('.')) else {
224        return Ok(None);
225    };
226    if args.len() != 1 + usize::from(explicit) {
227        return Ok(None);
228    }
229    let mut lowered = match &args[0] {
230        Expr::NullLiteral => vec![Expr::NullLiteral, Expr::StringLiteral(String::new())],
231        Expr::StringLiteral(text) => {
232            let mut values = parse_at(text, line)?;
233            resolve_transmits(&mut values, name, registry)?;
234            if let (Expr::Identifier(target), Expr::Tuple(args)) = (&values[0], &values[1])
235                && let Some(SymbolKind::Script { param_types, .. }) = registry
236                    .lookup_script_by_trigger("clientscript", target)
237                    .or_else(|| registry.lookup_script_by_trigger("proc", target))
238                    .map(|symbol| &symbol.kind)
239            {
240                let expanded = expand(&values, registry, locals);
241                let Expr::StringLiteral(signature) = expanded.last().unwrap() else {
242                    unreachable!()
243                };
244                let mut expected = [0usize; 3];
245                let mut actual = [0usize; 3];
246                let stack = |ty: Type| match ty.base_type() {
247                    BaseVarType::Integer => 0,
248                    BaseVarType::String => 1,
249                    BaseVarType::Long => 2,
250                };
251                for ty in param_types {
252                    expected[stack(*ty)] += 1;
253                }
254                for ch in signature.trim_end_matches('Y').chars() {
255                    actual[stack(Type::from_char(ch).unwrap_or(Type::Int))] += 1;
256                }
257                if expected != actual {
258                    return Err(format!(
259                        "Hook '{target}' expects {expected:?} int/string/long arguments, got {actual:?} ({} expressions)",
260                        args.len()
261                    ));
262                }
263            }
264            expand(&values, registry, locals)
265        }
266        Expr::CommandCall {
267            name: marker, args, ..
268        } if marker == "__hook" => {
269            let mut values = args.clone();
270            resolve_transmits(&mut values, name, registry)?;
271            expand(&values, registry, locals)
272        }
273        _ => return Ok(None),
274    };
275    if explicit {
276        lowered.push(args[1].clone());
277    }
278    Ok(Some(lowered))
279}
280
281pub(crate) fn parse(text: &str) -> Result<Vec<Expr>, String> {
282    parse_at(text, 1)
283}
284
285fn parse_at(text: &str, line: usize) -> Result<Vec<Expr>, String> {
286    let path = PathBuf::from("hook");
287    let mut tokens = Lexer::new(text, &path)
288        .tokenize()
289        .map_err(|e| e.to_string())?;
290    for token in &mut tokens {
291        token.line += line.saturating_sub(1);
292    }
293    Parser::new(tokens, &path)
294        .parse_hook()
295        .map_err(|e| e.to_string())
296}
297
298pub(crate) fn register_callbacks<'a>(
299    registry: &mut SymbolRegistry,
300    scripts: impl Iterator<Item = &'a ScriptDeclaration>,
301) {
302    let mut scripts: Vec<_> = scripts
303        .filter(|script| matches!(script.trigger.as_str(), "proc" | "clientscript"))
304        .collect();
305    scripts.sort_by_key(|script| script.trigger == "clientscript");
306    for script in scripts {
307        let id = registry
308            .script_id_for_trigger("clientscript", &script.name)
309            .or_else(|| {
310                script
311                    .name
312                    .strip_prefix("clientscript_")
313                    .and_then(|id| id.parse::<i32>().ok())
314                    .filter(|id| *id >= 0)
315            });
316        if let Some(id) = id {
317            registry.register_clientscript(
318                script.name.clone(),
319                id,
320                script.params.iter().map(|param| param.param_type).collect(),
321            );
322        }
323    }
324}
325
326pub(crate) fn server_call(
327    registry: &SymbolRegistry,
328    name: &str,
329    args: &[Expr],
330    locals: &SymbolTable,
331    line: usize,
332) -> Result<Option<Expr>, String> {
333    let command = name.trim_start_matches('.');
334    if !matches!(
335        command,
336        "runclientscript" | "runclientscript*" | "runclientscriptvararg"
337    ) {
338        return Ok(None);
339    }
340    let prefix = if name.starts_with('.') { "." } else { "" };
341    let syntax_error = || {
342        format!(
343            "Use {prefix}runclientscript(\"script(args)\"); the callback must be one quoted expression"
344        )
345    };
346    if command != "runclientscript" {
347        return Err(syntax_error());
348    }
349    let [Expr::StringLiteral(text)] = args else {
350        return Err(syntax_error());
351    };
352    let values = parse_at(text, line)?;
353    if values.len() > 2 {
354        return Err("runclientscript does not accept a transmit list".into());
355    }
356    let Expr::Identifier(target) = &values[0] else {
357        return Err("Expected clientscript name".into());
358    };
359    let id = registry
360        .script_id_for_trigger("clientscript", target)
361        .ok_or_else(|| format!("Unknown clientscript '{target}'"))?;
362    let params = registry
363        .client_script_params
364        .get(target)
365        .or_else(|| {
366            match registry
367                .lookup_script_by_trigger("clientscript", target)
368                .map(|symbol| &symbol.kind)
369            {
370                Some(SymbolKind::Script { param_types, .. }) => Some(param_types),
371                _ => None,
372            }
373        })
374        .ok_or_else(|| format!("Missing clientscript declaration for '{target}'"))?;
375    let Expr::Tuple(args) = &values[1] else {
376        unreachable!()
377    };
378    let hints = stack_hints(registry, params, args, locals);
379    let mut actual = [0usize; 3];
380    let mut expected = [0usize; 3];
381    let stack = |ty: Type| match ty.base_type() {
382        BaseVarType::Integer => 0,
383        BaseVarType::String => 1,
384        BaseVarType::Long => 2,
385    };
386    for ty in params {
387        expected[stack(*ty)] += 1;
388    }
389    let mut lowered = vec![Expr::IntLiteral(id)];
390    for (arg, hint) in args.iter().zip(hints) {
391        let mut arg = arg.clone();
392        if let (Expr::Identifier(value) | Expr::StringLiteral(value), Some(ty)) = (&arg, hint)
393            && let Some(id) = registry.lookup_reference(value, ty)
394        {
395            arg = Expr::IntLiteral(id);
396        }
397        for ty in expression_types(&arg, registry, locals) {
398            actual[stack(ty)] += 1;
399        }
400        lowered.push(arg);
401    }
402    if actual != expected {
403        return Err(format!(
404            "Clientscript '{target}' expects {expected:?} int/string/long arguments, got {actual:?}"
405        ));
406    }
407    if actual[2] != 0 {
408        return Err("runclientscript does not support long arguments".into());
409    }
410    let prefix = if name.starts_with('.') { "." } else { "" };
411    let suffix = if args.is_empty() { "" } else { "*" };
412    let count = lowered.len();
413    Ok(Some(Expr::CommandCall {
414        name: format!("{prefix}runclientscript{suffix}"),
415        args: lowered,
416        arg_lines: vec![line; count],
417        call_line: line,
418    }))
419}
420
421/// What the script a hook runs takes: a hook is a clientscript before it's a proc.
422pub(crate) fn argument_hints(
423    registry: &SymbolRegistry,
424    script: &str,
425    args: &[Expr],
426    locals: &SymbolTable,
427) -> Vec<Option<Type>> {
428    match registry
429        .lookup_script_by_trigger("clientscript", script)
430        .or_else(|| registry.lookup_script_by_trigger("proc", script))
431        .map(|symbol| &symbol.kind)
432    {
433        Some(SymbolKind::Script { param_types, .. }) => {
434            stack_hints(registry, param_types, args, locals)
435        }
436        _ => vec![None; args.len()],
437    }
438}
439
440fn expand(values: &[Expr], registry: &SymbolRegistry, locals: &SymbolTable) -> Vec<Expr> {
441    let Expr::Tuple(args) = &values[1] else {
442        unreachable!()
443    };
444    let hints = if let Expr::Identifier(name) = &values[0] {
445        argument_hints(registry, name, args, locals)
446    } else {
447        vec![None; args.len()]
448    };
449    let mut signature = String::new();
450    for (arg, hint) in args.iter().zip(hints) {
451        let types = expression_types(arg, registry, locals);
452        if types.len() == 1 {
453            signature.push(hint.unwrap_or(types[0]).to_char());
454        } else {
455            signature.extend(types.iter().map(|ty| ty.to_char()));
456        }
457    }
458    let mut lowered = vec![values[0].clone()];
459    lowered.extend_from_slice(args);
460    if let Some(Expr::Tuple(transmits)) = values.get(2) {
461        lowered.extend_from_slice(transmits);
462        lowered.push(Expr::IntLiteral(transmits.len() as i32));
463        signature.push('Y');
464    }
465    lowered.push(Expr::StringLiteral(signature));
466    lowered
467}
468
469/// Where the arguments of a hook's script end among a call's stack arguments.
470pub(crate) fn arguments_end(registry: &SymbolRegistry, name: &str, args: &[Expr]) -> Option<usize> {
471    let explicit = *registry.hook_commands.get(name.trim_start_matches('.'))?;
472    let signature_index = args.len().checked_sub(1 + usize::from(explicit))?;
473    let Expr::StringLiteral(signature) = &args[signature_index] else {
474        return None;
475    };
476    if !signature.ends_with('Y') {
477        return Some(signature_index);
478    }
479    let Expr::IntLiteral(count) = args.get(signature_index.checked_sub(1)?)? else {
480        return None;
481    };
482    signature_index.checked_sub(usize::try_from(*count).ok()? + 1)
483}
484
485pub(crate) fn compact(
486    registry: &SymbolRegistry,
487    name: &str,
488    args: &mut Vec<Expr>,
489    locals: &SymbolTable,
490) {
491    let Some(&explicit) = registry.hook_commands.get(name.trim_start_matches('.')) else {
492        return;
493    };
494    let Some(signature_index) = args.len().checked_sub(1 + usize::from(explicit)) else {
495        return;
496    };
497    let Expr::StringLiteral(signature) = &args[signature_index] else {
498        return;
499    };
500    let mut end = signature_index;
501    let transmits = if signature.ends_with('Y') {
502        let Some(Expr::IntLiteral(count)) = end.checked_sub(1).and_then(|i| args.get(i)) else {
503            return;
504        };
505        let Ok(count) = usize::try_from(*count) else {
506            return;
507        };
508        let Some(start) = end.checked_sub(count + 1) else {
509            return;
510        };
511        let mut values = args[start..end - 1].to_vec();
512        if let Some(kind) = transmit_kind(name) {
513            for value in &mut values {
514                if let Expr::IntLiteral(id) = value
515                    && let Some(name) = transmit_name(registry, kind, *id)
516                {
517                    *value = Expr::Identifier(name);
518                }
519            }
520        }
521        end = start;
522        Some(Expr::Tuple(values))
523    } else {
524        None
525    };
526    if end == 0
527        || !matches!(
528            args[0],
529            Expr::Identifier(_) | Expr::IntLiteral(_) | Expr::NullLiteral
530        )
531    {
532        return;
533    }
534    let hook = if matches!(args[0], Expr::NullLiteral) && signature.is_empty() && end == 1 {
535        Expr::NullLiteral
536    } else {
537        let mut values = vec![args[0].clone(), Expr::Tuple(args[1..end].to_vec())];
538        values.extend(transmits);
539        let expanded = expand(&values, registry, locals);
540        if !matches!(expanded.last(), Some(Expr::StringLiteral(value)) if value == signature) {
541            return;
542        }
543        Expr::CommandCall {
544            name: "__hook".into(),
545            args: values,
546            arg_lines: Vec::new(),
547            call_line: 0,
548        }
549    };
550    let mut compact = vec![hook];
551    if explicit {
552        compact.push(args[signature_index + 1].clone());
553    }
554    *args = compact;
555}