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#[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
74pub 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, ¶ms, 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
139pub(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
421pub(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
469pub(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}