├── .gitignore
├── .gitattributes
├── rust-toolchain.toml
├── gm_microoptimisation_war_crime.dll.vdf
├── gm_microoptimisation_war_crime.so.vdf
├── .editorconfig
├── src
    ├── cxx
    │   ├── mod.rs
    │   ├── plugin.cpp
    │   ├── plugin.hpp
    │   └── include
    │   │   ├── iserverplugin.h
    │   │   └── iluainterface.h
    ├── localization.rs
    ├── lib.rs
    ├── strip.rs
    ├── realms.rs
    ├── enums.rs
    ├── hax.rs
    └── tests.rs
├── Cargo.toml
├── README.md
└── Cargo.lock


/.gitignore:
--------------------------------------------------------------------------------
1 | /target
2 | 


--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
1 | *.h linguist-vendored


--------------------------------------------------------------------------------
/rust-toolchain.toml:
--------------------------------------------------------------------------------
1 | [toolchain]
2 | channel = "nightly"


--------------------------------------------------------------------------------
/gm_microoptimisation_war_crime.dll.vdf:
--------------------------------------------------------------------------------
1 | Plugin
2 | {
3 | 	file "lua/bin/gm_microoptimisation_war_crime.dll"
4 | }


--------------------------------------------------------------------------------
/gm_microoptimisation_war_crime.so.vdf:
--------------------------------------------------------------------------------
1 | Plugin
2 | {
3 | 	file "lua/bin/gm_microoptimisation_war_crime.so"
4 | }


--------------------------------------------------------------------------------
/.editorconfig:
--------------------------------------------------------------------------------
1 | root = true
2 | 
3 | [*]
4 | indent_style = tab
5 | indent_size = 4
6 | charset = utf-8
7 | trim_trailing_whitespace = true


--------------------------------------------------------------------------------
/src/cxx/mod.rs:
--------------------------------------------------------------------------------
1 | #[cxx::bridge] pub mod bridge {
2 | 	extern "C++" {
3 | 		include!("plugin.hpp");
4 | 		unsafe fn is_client(lua: usize) -> bool;
5 | 		unsafe fn is_server(lua: usize) -> bool;
6 | 		unsafe fn CreateInterface() -> usize;
7 | 	}
8 | }


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "gm_microoptimisation_war_crime"
 3 | version = "2.0.0"
 4 | edition = "2021"
 5 | 
 6 | [lib]
 7 | crate-type = ["cdylib", "rlib"]
 8 | 
 9 | [profile.release]
10 | panic = "abort"
11 | 
12 | [dependencies]
13 | magic_static = "3.0.1"
14 | pcre2 = "0.2.3"
15 | cxx = "1.0.63"
16 | gmod = "14.0.2"
17 | gmserverplugin = "2.0.1"
18 | 
19 | [build-dependencies]
20 | cxx-build = "1.0.63"
21 | 


--------------------------------------------------------------------------------
/src/cxx/plugin.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <plugin.hpp>
 4 | 
 5 | WarcrimePlugin::WarcrimePlugin() {}
 6 | 
 7 | static WarcrimePlugin* INSTANCE = new WarcrimePlugin();
 8 | uintptr_t CreateInterface() {
 9 | 	return (uintptr_t) INSTANCE;
10 | }
11 | 
12 | bool is_server(uintptr_t lua_ptr) {
13 | 	ILuaInterface* lua = (ILuaInterface*)lua_ptr;
14 | 	return lua->IsServer();
15 | }
16 | 
17 | bool is_client(uintptr_t lua_ptr) {
18 | 	ILuaInterface* lua = (ILuaInterface*)lua_ptr;
19 | 	return lua->IsClient();
20 | }


--------------------------------------------------------------------------------
/src/localization.rs:
--------------------------------------------------------------------------------
 1 | magic_statics_mod! {
 2 | 	static ref RE_LOCAL_WORD_BOUNDARY: crate::Regex = crate::Regex::new(r#"\bl"#).unwrap();
 3 | }
 4 | 
 5 | pub fn is_localization(src: &[u8], start: usize) -> bool {
 6 | 	if start == 0 {
 7 | 		return false;
 8 | 	}
 9 | 	let mut cursor = start - 1;
10 | 	while cursor > 0 && src[cursor] == ' ' as u8 {
11 | 		cursor -= 1;
12 | 	}
13 | 	if cursor < b"local".len() - 1 {
14 | 		return false;
15 | 	}
16 | 	if &src[cursor - (b"local".len() - 1)..=cursor] != b"local" {
17 | 		return false;
18 | 	}
19 | 	if cursor <= 4 {
20 | 		return true;
21 | 	}
22 | 	RE_LOCAL_WORD_BOUNDARY.is_match(&src[cursor - (b"local".len() - 1) - 1..][..2]).unwrap()
23 | }
24 | 


--------------------------------------------------------------------------------
/src/lib.rs:
--------------------------------------------------------------------------------
 1 | #![feature(c_unwind)]
 2 | 
 3 | #[macro_use] extern crate gmod;
 4 | #[macro_use] extern crate magic_static;
 5 | 
 6 | mod localization;
 7 | mod realms;
 8 | mod enums;
 9 | mod strip;
10 | mod hax;
11 | mod cxx;
12 | 
13 | pub(crate) type Regex = pcre2::bytes::Regex;
14 | 
15 | #[magic_static::main(
16 | 	mod strip,
17 | 	mod realms,
18 | 	mod enums,
19 | 	mod localization
20 | )]
21 | pub fn init() {}
22 | 
23 | #[cfg(any(debug_assertions, test))]
24 | mod tests;
25 | 
26 | #[no_mangle]
27 | pub unsafe extern "C" fn CreateInterface() -> *mut std::ffi::c_void {
28 | 	extern "C" fn after_init(lua: *mut std::ffi::c_void, _: *mut std::ffi::c_void) {
29 | 		unsafe {
30 | 			enums::clean_up_global_table(gmod::lua::State(lua));
31 | 		}
32 | 	}
33 | 
34 | 	extern "C" fn before_init(_: *mut std::ffi::c_void, lua: *mut std::ffi::c_void) {
35 | 		unsafe {
36 | 			realms::detect(lua);
37 | 		}
38 | 	}
39 | 
40 | 	extern "C" fn newstate(lua: *mut std::ffi::c_void, _: *mut std::ffi::c_void) {
41 | 		unsafe {
42 | 			gmod::set_lua_state(lua);
43 | 			init();
44 | 			hax::init();
45 | 		}
46 | 	}
47 | 
48 |     gmserverplugin::init();
49 |     gmserverplugin::newstate(newstate);
50 |     gmserverplugin::before_init(before_init);
51 |     gmserverplugin::after_init(after_init);
52 | 
53 | 	cxx::bridge::CreateInterface() as *mut _
54 | }


--------------------------------------------------------------------------------
/src/cxx/plugin.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "rust/cxx.h"
 4 | #include "gm_microoptimisation_war_crime/src/cxx/mod.rs.h"
 5 | 
 6 | #include <include/iserverplugin.h>
 7 | #include <include/iluainterface.h>
 8 | #include <cstdio>
 9 | #include <cstring>
10 | 
11 | class WarcrimePlugin : public IServerPluginCallbacks
12 | {
13 | public:
14 | 	WarcrimePlugin();
15 | 	~WarcrimePlugin();
16 | 
17 | 	virtual bool 			Load(CreateInterfaceFn, CreateInterfaceFn) { return true; };
18 | 	virtual void			Unload(void) {};
19 | 	virtual void			Pause(void) {};
20 | 	virtual void			UnPause(void) {};
21 | 	virtual const char     *GetPluginDescription(void) { return "warcrime"; };
22 | 	virtual void			LevelInit(char const *) {};
23 | 	virtual void			ServerActivate(void *, int, int) {};
24 | 	virtual void			GameFrame(bool) {};
25 | 	virtual void			LevelShutdown(void) {};
26 | 	virtual void			ClientActive(void *) {};
27 | 	virtual void			ClientDisconnect(void *) {};
28 | 	virtual void			ClientPutInServer(void *, char const *) {};
29 | 	virtual void			SetCommandClient(int ) {};
30 | 	virtual void			ClientSettingsChanged(void *) {};
31 | 	virtual PLUGIN_RESULT 	ClientConnect(bool *, void *, const char *, const char *, char *, int ) { return PLUGIN_CONTINUE; };
32 | 	virtual PLUGIN_RESULT	ClientCommand(void *, const CCommand &) { return PLUGIN_CONTINUE; };
33 | 	virtual PLUGIN_RESULT	NetworkIDValidated(const char *, const char *) { return PLUGIN_CONTINUE; };
34 | 	virtual void 			OnQueryCvarValueFinished(QueryCvarCookie_t , void *, EQueryCvarValueStatus , const char *, const char *) {};
35 | 	virtual void			OnEdictAllocated(void *) {};
36 | 	virtual void			OnEdictFreed(const void *) {};
37 | };
38 | 
39 | uintptr_t CreateInterface();
40 | 
41 | bool is_server(uintptr_t lua_ptr);
42 | bool is_client(uintptr_t lua_ptr);


--------------------------------------------------------------------------------
/src/strip.rs:
--------------------------------------------------------------------------------
 1 | //! Generate a data structure containing ranges of comments and strings for ignoring during optimisation passes.
 2 | 
 3 | use std::ops::Range;
 4 | 
 5 | #[derive(Default)]
 6 | pub(crate) struct StripTreeBuilder(Vec<Range<usize>>);
 7 | impl StripTreeBuilder {
 8 | 	#[inline]
 9 | 	pub(crate) fn insert(&mut self, range: Range<usize>) {
10 | 		self.0.push(range);
11 | 	}
12 | 
13 | 	#[inline]
14 | 	pub(crate) fn build(self) -> StripTree {
15 | 		StripTree(self.0)
16 | 	}
17 | }
18 | 
19 | pub(crate) struct StripTree(Vec<Range<usize>>);
20 | impl StripTree {
21 | 	pub(crate) fn contains(&self, other: Range<usize>) -> bool {
22 | 		for range in &self.0 {
23 | 			if other.start >= range.start && other.end <= range.end {
24 | 				return true;
25 | 			}
26 | 		}
27 | 		false
28 | 	}
29 | }
30 | 
31 | macro_rules! strips {
32 | 	{ $($name:ident => $re:literal),* } => {
33 | 		#[doc(hidden)]
34 | 		mod regex {
35 | 			#![allow(non_upper_case_globals)]
36 | 			magic_statics_mod! {
37 | 				$(pub(super) static ref $name: crate::Regex = crate::Regex::new($re).unwrap();)*
38 | 			}
39 | 		}
40 | 
41 | 		$(
42 | 			#[doc(hidden)]
43 | 			fn $name(tree: &mut StripTreeBuilder, src: &[u8]) {
44 | 				for m in self::regex::$name.find_iter(src).map(|m| m.unwrap()) {
45 | 					tree.insert((m.start()..m.end()).into());
46 | 				}
47 | 			}
48 | 		)*
49 | 
50 | 		pub(crate) fn generate(src: &[u8]) -> StripTree {
51 | 			let mut strip_tree = StripTreeBuilder::default();
52 | 			$(
53 | 				$name(&mut strip_tree, src);
54 | 			)*
55 | 			strip_tree.build()
56 | 		}
57 | 
58 | 		#[inline]
59 | 		pub fn magic_static() {
60 | 			regex::magic_static()
61 | 		}
62 | 	};
63 | }
64 | 
65 | strips! {
66 | 	comments => r#"--(?:\[(=*)\[[\S\s]+?\]\1\]|[\S\s]+?(?:\n|(?m:$)))"#,
67 | 	strings => r#"(?:("|')((?:\\\1|\\\\|.)*?)\1)|(?<!--)(?:\[(=*)\[([\s\S]*?)\]\3\])"#
68 | }


--------------------------------------------------------------------------------
/src/realms.rs:
--------------------------------------------------------------------------------
 1 | 
 2 | use crate::{strip::StripTree, cxx, localization};
 3 | 
 4 | magic_statics_mod! {
 5 | 	static ref RE_SERVER: crate::Regex = crate::Regex::new(r#"\bSERVER\b"#).unwrap();
 6 | 	static ref RE_CLIENT: crate::Regex = crate::Regex::new(r#"\bCLIENT\b"#).unwrap();
 7 | }
 8 | 
 9 | static mut REALM: Realm = Realm::Unknown;
10 | 
11 | #[inline]
12 | pub fn realm() -> Realm {
13 | 	unsafe { REALM }
14 | }
15 | 
16 | #[repr(u8)]
17 | #[derive(Clone, Copy, Debug)]
18 | pub enum Realm {
19 | 	Unknown,
20 | 	Server,
21 | 	Client
22 | }
23 | 
24 | #[inline]
25 | fn replace<'r, 't>(
26 | 	iter: pcre2::bytes::Matches<'r, 't>,
27 | 	strip_tree: &StripTree,
28 | 	copy: &[u8],
29 | 	src: &mut [u8],
30 | 	replacement: &'static [u8],
31 | ) {
32 | 	iter.map(|m| m.unwrap())
33 | 		.map(|m| m.start()..m.end())
34 | 		.filter(|m| !strip_tree.contains(m.clone()))
35 | 		.filter(|m| !localization::is_localization(copy, m.start))
36 | 		.for_each(|m| src[m].copy_from_slice(replacement))
37 | }
38 | 
39 | pub(crate) fn optimise_server(src: &mut [u8], strip_tree: &StripTree) {
40 | 	let copy = src.to_vec();
41 | 	replace(RE_SERVER.find_iter(&copy), strip_tree, &copy, src, b"true  ");
42 | 	replace(RE_CLIENT.find_iter(&copy), strip_tree, &copy, src, b"false ");
43 | }
44 | 
45 | pub(crate) fn optimise_client(src: &mut [u8], strip_tree: &StripTree) {
46 | 	let copy = src.to_vec();
47 | 	replace(RE_SERVER.find_iter(&copy), strip_tree, &copy, src, b"false ");
48 | 	replace(RE_CLIENT.find_iter(&copy), strip_tree, &copy, src, b"true  ");
49 | }
50 | 
51 | pub(crate) fn optimise(realm: Realm, src: &mut [u8], strip_tree: &StripTree) {
52 | 	match realm {
53 | 		Realm::Server => optimise_server(src, &strip_tree),
54 | 		Realm::Client => optimise_client(src, &strip_tree),
55 | 		_ => unreachable!()
56 | 	}
57 | }
58 | 
59 | pub(super) unsafe fn detect(lua: *mut std::ffi::c_void) {
60 | 	if cxx::bridge::is_server(lua as usize) {
61 | 		REALM = Realm::Server;
62 | 	} else if cxx::bridge::is_client(lua as usize) {
63 | 		REALM = Realm::Client;
64 | 	} else {
65 | 		panic!("Couldn't detect whether this is a server or a client");
66 | 	}
67 | }


--------------------------------------------------------------------------------
/src/enums.rs:
--------------------------------------------------------------------------------
  1 | use std::{collections::BTreeSet, cell::RefCell, borrow::Cow};
  2 | 
  3 | use crate::{strip::StripTree, localization};
  4 | 
  5 | /// These are enums that have internal usage that means we cannot optimise them.
  6 | static FILTERED_ENUMS: &'static [&'static str] = &[
  7 | 	"NUM_AI_CLASSES"
  8 | ];
  9 | 
 10 | magic_statics_mod! {
 11 | 	static ref RE_POTENTIAL_ENUM: crate::Regex = crate::Regex::new(r#"\b(?:[A-Z0-9]+?_)*?[A-Z]+\b"#).unwrap();
 12 | }
 13 | 
 14 | thread_local! {
 15 | 	static LUA_ENUMS: RefCell<BTreeSet<LuaEnum<'static>>> = RefCell::new(BTreeSet::new());
 16 | }
 17 | 
 18 | #[derive(Debug, Clone)]
 19 | pub struct LuaEnum<'a> {
 20 | 	pub key: Cow<'a, [u8]>,
 21 | 	pub value: isize,
 22 | 	pub value_literal: Vec<u8>
 23 | }
 24 | impl LuaEnum<'_> {
 25 | 	fn new<'a, K: AsRef<[u8]>>(key: K, value: isize) -> Option<LuaEnum<'a>> {
 26 | 		let key = key.as_ref();
 27 | 
 28 | 		let value_literal = {
 29 | 			let mut value_literal = value.to_string().into_bytes();
 30 | 
 31 | 			let value_literal_pad = match key.len().checked_sub(value_literal.len()) {
 32 | 				Some(value_literal_pad @ 1..) => value_literal_pad,
 33 | 				_ => return None
 34 | 			};
 35 | 
 36 | 			value_literal.extend([' ' as u8].into_iter().cycle().take(value_literal_pad)); // pad it
 37 | 			value_literal
 38 | 		};
 39 | 
 40 | 		Some(LuaEnum {
 41 | 			value_literal,
 42 | 			value,
 43 | 			key: key.to_vec().into()
 44 | 		})
 45 | 	}
 46 | }
 47 | impl Eq for LuaEnum<'_> {}
 48 | impl PartialEq for LuaEnum<'_> {
 49 | 	fn eq(&self, other: &Self) -> bool {
 50 | 		self.key == other.key
 51 | 	}
 52 | }
 53 | impl PartialOrd for LuaEnum<'_> {
 54 | 	fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
 55 | 		self.key.partial_cmp(&other.key)
 56 | 	}
 57 | }
 58 | impl Ord for LuaEnum<'_> {
 59 | 	fn cmp(&self, other: &Self) -> std::cmp::Ordering {
 60 | 		self.key.cmp(&other.key)
 61 | 	}
 62 | }
 63 | impl<'a> From<&'a [u8]> for LuaEnum<'a> {
 64 |     fn from(bytes: &'a [u8]) -> Self {
 65 | 		LuaEnum { key: Cow::Borrowed(bytes), value: -1, value_literal: Vec::new() }
 66 |     }
 67 | }
 68 | 
 69 | unsafe fn get_global_keys<'a>(lua: gmod::lua::State) -> BTreeSet<LuaEnum<'a>> {
 70 | 	let mut global_keys = BTreeSet::new();
 71 | 
 72 | 	fn insert_global_key(global_keys: &mut BTreeSet<LuaEnum>, key: &[u8], value: isize) {
 73 | 		if !RE_POTENTIAL_ENUM.is_match(key).unwrap() {
 74 | 			return;
 75 | 		}
 76 | 
 77 | 		#[cfg(debug_assertions)]
 78 | 		let insert_key = key.to_owned();
 79 | 
 80 | 		#[cfg(not(debug_assertions))]
 81 | 		let insert_key = key;
 82 | 
 83 | 		let lua_enum = match LuaEnum::new(insert_key, value) {
 84 | 			Some(lua_enum) => lua_enum,
 85 | 			None => return
 86 | 		};
 87 | 
 88 | 		let _was_empty = global_keys.insert(lua_enum);
 89 | 		debug_assert!(_was_empty, "{} was already in the set", String::from_utf8_lossy(key));
 90 | 	}
 91 | 
 92 | 	lua_stack_guard!(lua => {
 93 | 		lua.push_globals();
 94 | 
 95 | 		lua.push_nil();
 96 | 		while lua.next(-2) != 0 {
 97 | 			if lua.lua_type(-1) == gmod::lua::LUA_TNUMBER {
 98 | 				// we only care about numerical enums
 99 | 				lua.push_value(-1); // push a copy of the value
100 | 				let value = lua.to_integer(-1);
101 | 				lua.pop();
102 | 
103 | 				lua.push_value(-2); // push a copy of the key
104 | 				if let Some(key) = lua.get_binary_string(-1) {
105 | 					insert_global_key(&mut global_keys, key, value);
106 | 				}
107 | 				lua.pop();
108 | 			}
109 | 			lua.pop();
110 | 		}
111 | 
112 | 		lua.pop();
113 | 	});
114 | 
115 | 	for filtered in FILTERED_ENUMS {
116 | 		global_keys.remove(&LuaEnum::from(filtered.as_bytes()));
117 | 	}
118 | 
119 | 	global_keys
120 | }
121 | 
122 | pub unsafe fn collect<F: Fn()>(lua: gmod::lua::State, func: F) {
123 | 	let global_keys = get_global_keys(lua);
124 | 
125 | 	func();
126 | 
127 | 	let new_global_keys = get_global_keys(lua);
128 | 
129 | 	LUA_ENUMS.with(|enums| {
130 | 		enums.borrow_mut().extend(new_global_keys.difference(&global_keys).cloned());
131 | 	});
132 | }
133 | 
134 | pub(crate) fn optimise(src: &mut [u8], strip_tree: &StripTree) {
135 | 	let copy = src.to_vec();
136 | 	LUA_ENUMS.with(|enums| {
137 | 		let enums = enums.borrow();
138 | 
139 | 		RE_POTENTIAL_ENUM.find_iter(&copy)
140 | 			.map(|m| m.unwrap())
141 | 			.filter(|m| !strip_tree.contains(m.start()..m.end()))
142 | 			.filter(|m| !localization::is_localization(&copy, m.start()))
143 | 			.filter_map(|m| enums.get(&LuaEnum::from(&copy[m.start()..m.end()])).map(|lua_enum| (lua_enum, m.start()..m.end())))
144 | 			.for_each(|(lua_enum, range)| {
145 | 				src[range].copy_from_slice(&lua_enum.value_literal)
146 | 			})
147 | 	});
148 | }
149 | 
150 | pub unsafe fn clean_up_global_table(lua: gmod::lua::State) {
151 | 	LUA_ENUMS.with(|enums| {
152 | 		lua.push_globals();
153 | 		for lua_enum in enums.borrow().iter() {
154 | 			lua.push_binary_string(lua_enum.key.as_ref());
155 | 			lua.push_nil();
156 | 			lua.set_table(-3);
157 | 		}
158 | 		lua.pop();
159 | 	});
160 | }
161 | 
162 | #[cfg(test)]
163 | pub fn test_data() {
164 | 	LUA_ENUMS.with(|enums| {
165 | 		enums.borrow_mut().extend([
166 | 			LuaEnum::new(b"ACT_INVALID", -1).unwrap(),
167 | 			LuaEnum::new(b"ACT_RESET", 0).unwrap(),
168 | 			LuaEnum::new(b"ACT_IDLE", 1).unwrap(),
169 | 			LuaEnum::new(b"ACT_TRANSITION", 2).unwrap(),
170 | 			LuaEnum::new(b"ACT_COVER", 3).unwrap(),
171 | 			LuaEnum::new(b"ACT_COVER_MED", 4).unwrap(),
172 | 			LuaEnum::new(b"ACT_COVER_LOW", 5).unwrap(),
173 | 			LuaEnum::new(b"ACT_WALK", 6).unwrap(),
174 | 			LuaEnum::new(b"ACT_WALK_AIM", 7).unwrap(),
175 | 			LuaEnum::new(b"ACT_WALK_CROUCH", 8).unwrap(),
176 | 			LuaEnum::new(b"ACT_WALK_CROUCH_AIM", 9).unwrap(),
177 | 			LuaEnum::new(b"ACT_RUN", 10).unwrap(),
178 | 			LuaEnum::new(b"ACT_RUN_AIM", 11).unwrap(),
179 | 			LuaEnum::new(b"ACT_RUN_CROUCH", 12).unwrap(),
180 | 			LuaEnum::new(b"ACT_RUN_CROUCH_AIM", 13).unwrap(),
181 | 		].into_iter());
182 | 	});
183 | }


--------------------------------------------------------------------------------
/src/cxx/include/iserverplugin.h:
--------------------------------------------------------------------------------
  1 | //========= Copyright Valve Corporation, All rights reserved. ============//
  2 | //
  3 | // Purpose:
  4 | //
  5 | // $NoKeywords: $
  6 | //
  7 | //=============================================================================//
  8 | 
  9 | #ifndef ISERVERPLUGIN_H
 10 | #define ISERVERPLUGIN_H
 11 | 
 12 | #ifdef _WIN32
 13 | #pragma once
 14 | #endif
 15 | 
 16 | class CCommand;
 17 | 
 18 | //
 19 | // you will also want to listen for game events via IGameEventManager::AddListener()
 20 | //
 21 | 
 22 | typedef enum
 23 | {
 24 | 	PLUGIN_CONTINUE = 0, // keep going
 25 | 	PLUGIN_OVERRIDE, // run the game dll function but use our return value instead
 26 | 	PLUGIN_STOP, // don't run the game dll function at all
 27 | } PLUGIN_RESULT;
 28 | 
 29 | 
 30 | typedef enum
 31 | {
 32 | 	eQueryCvarValueStatus_ValueIntact=0,	// It got the value fine.
 33 | 	eQueryCvarValueStatus_CvarNotFound=1,
 34 | 	eQueryCvarValueStatus_NotACvar=2,		// There's a ConCommand, but it's not a ConVar.
 35 | 	eQueryCvarValueStatus_CvarProtected=3	// The cvar was marked with FCVAR_SERVER_CAN_NOT_QUERY, so the server is not allowed to have its value.
 36 | } EQueryCvarValueStatus;
 37 | 
 38 | typedef void* (*CreateInterfaceFn)(const char *pName, int *pReturnCode);
 39 | 
 40 | typedef int QueryCvarCookie_t;
 41 | #define InvalidQueryCvarCookie -1
 42 | 
 43 | 
 44 | #define INTERFACEVERSION_ISERVERPLUGINCALLBACKS_VERSION_1	"ISERVERPLUGINCALLBACKS001"
 45 | #define INTERFACEVERSION_ISERVERPLUGINCALLBACKS_VERSION_2	"ISERVERPLUGINCALLBACKS002"
 46 | #define INTERFACEVERSION_ISERVERPLUGINCALLBACKS				"ISERVERPLUGINCALLBACKS003"
 47 | 
 48 | //-----------------------------------------------------------------------------
 49 | // Purpose: callbacks the engine exposes to the 3rd party plugins (ala MetaMod)
 50 | //-----------------------------------------------------------------------------
 51 | class IServerPluginCallbacks
 52 | {
 53 | public:
 54 | 	// Initialize the plugin to run
 55 | 	// Return false if there is an error during startup.
 56 | 	virtual bool			Load(	CreateInterfaceFn interfaceFactory, CreateInterfaceFn gameServerFactory  ) = 0;
 57 | 
 58 | 	// Called when the plugin should be shutdown
 59 | 	virtual void			Unload( void ) = 0;
 60 | 
 61 | 	// called when a plugins execution is stopped but the plugin is not unloaded
 62 | 	virtual void			Pause( void ) = 0;
 63 | 
 64 | 	// called when a plugin should start executing again (sometime after a Pause() call)
 65 | 	virtual void			UnPause( void ) = 0;
 66 | 
 67 | 	// Returns string describing current plugin.  e.g., Admin-Mod.
 68 | 	virtual const char     *GetPluginDescription( void ) = 0;
 69 | 
 70 | 	// Called any time a new level is started (after GameInit() also on level transitions within a game)
 71 | 	virtual void			LevelInit( char const *pMapName ) = 0;
 72 | 
 73 | 	// The server is about to activate
 74 | 	virtual void			ServerActivate( void *pEdictList, int edictCount, int clientMax ) = 0;
 75 | 
 76 | 	// The server should run physics/think on all edicts
 77 | 	virtual void			GameFrame( bool simulating ) = 0;
 78 | 
 79 | 	// Called when a level is shutdown (including changing levels)
 80 | 	virtual void			LevelShutdown( void ) = 0;
 81 | 
 82 | 	// Client is going active
 83 | 	virtual void			ClientActive( void *pEntity ) = 0;
 84 | 
 85 | 	// Client is disconnecting from server
 86 | 	virtual void			ClientDisconnect( void *pEntity ) = 0;
 87 | 
 88 | 	// Client is connected and should be put in the game
 89 | 	virtual void			ClientPutInServer( void *pEntity, char const *playername ) = 0;
 90 | 
 91 | 	// Sets the client index for the client who typed the command into their console
 92 | 	virtual void			SetCommandClient( int index ) = 0;
 93 | 
 94 | 	// A player changed one/several replicated cvars (name etc)
 95 | 	virtual void			ClientSettingsChanged( void *pEdict ) = 0;
 96 | 
 97 | 	// Client is connecting to server ( set retVal to false to reject the connection )
 98 | 	//	You can specify a rejection message by writing it into reject
 99 | 	virtual PLUGIN_RESULT	ClientConnect( bool *bAllowConnect, void *pEntity, const char *pszName, const char *pszAddress, char *reject, int maxrejectlen ) = 0;
100 | 
101 | 	// The client has typed a command at the console
102 | 	virtual PLUGIN_RESULT	ClientCommand( void *pEntity, const CCommand &args ) = 0;
103 | 
104 | 	// A user has had their network id setup and validated
105 | 	virtual PLUGIN_RESULT	NetworkIDValidated( const char *pszUserName, const char *pszNetworkID ) = 0;
106 | 
107 | 	// This is called when a query from IServerPluginHelpers::StartQueryCvarValue is finished.
108 | 	// iCookie is the value returned by IServerPluginHelpers::StartQueryCvarValue.
109 | 	// Added with version 2 of the interface.
110 | 	virtual void			OnQueryCvarValueFinished( QueryCvarCookie_t iCookie, void *pPlayerEntity, EQueryCvarValueStatus eStatus, const char *pCvarName, const char *pCvarValue ) = 0;
111 | 
112 | 	// added with version 3 of the interface.
113 | 	virtual void			OnEdictAllocated( void *edict ) = 0;
114 | 	virtual void			OnEdictFreed( const void *edict  ) = 0;
115 | };
116 | 
117 | #define INTERFACEVERSION_ISERVERPLUGINHELPERS			"ISERVERPLUGINHELPERS001"
118 | 
119 | typedef enum
120 | {
121 | 	DIALOG_MSG = 0,		// just an on screen message
122 | 	DIALOG_MENU,		// an options menu
123 | 	DIALOG_TEXT,		// a richtext dialog
124 | 	DIALOG_ENTRY,		// an entry box
125 | 	DIALOG_ASKCONNECT	// Ask the client to connect to a specified IP address. Only the "time" and "title" keys are used.
126 | } DIALOG_TYPE;
127 | 
128 | class IServerPluginHelpers
129 | {
130 | public:
131 | 	// creates an onscreen menu with various option buttons
132 | 	//	The keyvalues param can contain these fields:
133 | 	//	"title" - (string) the title to show in the hud and in the title bar
134 | 	//	"msg" - (string) a longer message shown in the GameUI
135 | 	//  "color" - (color) the color to display the message in the hud (white by default)
136 | 	//	"level" - (int) the priority of this message (closer to 0 is higher), only 1 message can be outstanding at a time
137 | 	//	"time" - (int) the time in seconds this message should stay active in the GameUI (min 10 sec, max 200 sec)
138 | 	//
139 | 	// For DIALOG_MENU add sub keys for each option with these fields:
140 | 	//  "command" - (string) client command to run if selected
141 | 	//  "msg" - (string) button text for this option
142 | 	//
143 | 	virtual void CreateMessage( void *pEntity, DIALOG_TYPE type, void *data, IServerPluginCallbacks *plugin ) = 0;
144 | 	virtual void ClientCommand( void *pEntity, const char *cmd ) = 0;
145 | 
146 | 	// Call this to find out the value of a cvar on the client.
147 | 	//
148 | 	// It is an asynchronous query, and it will call IServerPluginCallbacks::OnQueryCvarValueFinished when
149 | 	// the value comes in from the client.
150 | 	//
151 | 	// Store the return value if you want to match this specific query to the OnQueryCvarValueFinished call.
152 | 	// Returns InvalidQueryCvarCookie if the entity is invalid.
153 | 	virtual QueryCvarCookie_t StartQueryCvarValue( void *pEntity, const char *pName ) = 0;
154 | };
155 | 
156 | #endif //ISERVERPLUGIN_H


--------------------------------------------------------------------------------
/src/hax.rs:
--------------------------------------------------------------------------------
  1 | #![allow(non_snake_case)]
  2 | #![allow(non_camel_case_types)]
  3 | #![allow(unused_unsafe)]
  4 | 
  5 | use std::{ffi::{c_void, CStr}, os::raw::c_char, cell::RefCell};
  6 | use crate::*;
  7 | 
  8 | pub struct Detours {
  9 | 	RunStringEx: gmod::detour::GenericDetour<RunStringEx>,
 10 | 	CLuaEnums_InitLibraries: gmod::detour::GenericDetour<CLuaEnums_InitLibraries>,
 11 | 	CGameLuaEnums_InitLibraries: gmod::detour::GenericDetour<CGameLuaEnums_InitLibraries>,
 12 | }
 13 | 
 14 | thread_local! {
 15 | 	static DETOURS: RefCell<Option<Detours>> = RefCell::new(None);
 16 | }
 17 | 
 18 | unsafe fn get_lua_state(iluainterface: *mut c_void) -> gmod::lua::State {
 19 | 	let ptr = *((iluainterface as *mut u8).add(std::mem::size_of::<usize>()) as *mut *mut c_void);
 20 | 	gmod::lua::State(ptr)
 21 | }
 22 | 
 23 | #[cfg_attr(all(target_os = "windows", target_pointer_width = "64"), abi("fastcall"))]
 24 | #[cfg_attr(all(target_os = "windows", target_pointer_width = "32"), abi("stdcall"))]
 25 | #[type_alias(CLuaEnums_InitLibraries)]
 26 | extern "cdecl" fn CLuaEnums_InitLibraries_Detour(this: *mut c_void, lua_interface: *mut c_void) {
 27 | 	unsafe {
 28 | 		crate::enums::collect(
 29 | 			get_lua_state(lua_interface),
 30 | 			|| DETOURS.with(move |detour| unsafe {
 31 | 				detour.borrow().as_ref().unwrap().CLuaEnums_InitLibraries.call(this, lua_interface);
 32 | 			})
 33 | 		);
 34 | 	}
 35 | }
 36 | 
 37 | #[cfg_attr(all(target_os = "windows", target_pointer_width = "64"), abi("fastcall"))]
 38 | #[cfg_attr(all(target_os = "windows", target_pointer_width = "32"), abi("stdcall"))]
 39 | #[type_alias(CGameLuaEnums_InitLibraries)]
 40 | extern "cdecl" fn CGameLuaEnums_InitLibraries_Detour(this: *mut c_void, lua_interface: *mut c_void) {
 41 | 	unsafe {
 42 | 		crate::enums::collect(
 43 | 			get_lua_state(lua_interface),
 44 | 			|| DETOURS.with(move |detour| unsafe {
 45 | 				detour.borrow().as_ref().unwrap().CGameLuaEnums_InitLibraries.call(this, lua_interface);
 46 | 			})
 47 | 		);
 48 | 	}
 49 | }
 50 | 
 51 | #[cfg_attr(all(target_os = "windows", target_pointer_width = "64"), abi("fastcall"))]
 52 | #[cfg_attr(all(target_os = "windows", target_pointer_width = "32"), abi("stdcall"))]
 53 | #[type_alias(RunStringEx)]
 54 | extern "cdecl" fn RunStringEx_Detour(this: *mut c_void, path: *const c_char, unk1: *const c_char, src: *const c_char, unk2: bool, unk3: bool, unk4: bool, unk5: bool) -> usize {
 55 | 	#[cfg(debug_assertions)]
 56 | 	let path_str = unsafe { CStr::from_ptr(path) }.to_bytes();
 57 | 
 58 | 	let src = unsafe { CStr::from_ptr(src) };
 59 | 
 60 | 	let mut src = src.to_bytes().to_vec();
 61 | 	let strip_tree = strip::generate(&src);
 62 | 	realms::optimise(crate::realms::realm(), &mut src, &strip_tree);
 63 | 	enums::optimise(&mut src, &strip_tree);
 64 | 	src.push(0);
 65 | 
 66 | 	#[cfg(debug_assertions)]
 67 | 	if path_str == b"gamemodes/base/gamemode/animations.lua" {
 68 | 		let _ = std::fs::write("gm_microoptimisation_war_crime.lua", &src);
 69 | 	}
 70 | 
 71 | 	let src = src.as_ptr() as *const c_char;
 72 | 
 73 | 	#[allow(unused_unsafe)]
 74 | 	DETOURS.with(move |detour| unsafe {
 75 | 		detour.borrow().as_ref().unwrap().RunStringEx.call(
 76 | 			this, path, unk1, src,
 77 | 			unk2, unk3, unk4, unk5
 78 | 		)
 79 | 	})
 80 | }
 81 | 
 82 | pub(super) unsafe fn init() {
 83 | 	DETOURS.with(|cell| {
 84 | 		let mut cell = cell.borrow_mut();
 85 | 		drop(cell.take());
 86 | 
 87 | 		let (_serverdll, _serverdllpath) = open_library_srv!("server").expect("Failed to find server.dll!");
 88 | 
 89 | 		cell.replace(Detours {
 90 | 			RunStringEx: {
 91 | 				let (_lib, _path) = open_library_srv!("lua_shared").expect("Failed to find lua_shared!");
 92 | 
 93 | 				// It would be cool to do this with CLuaInterface::RunMacros but it's inlined on Windows
 94 | 				// and uses C++ std::string which is probably not worth making a cxx bridge for.
 95 | 
 96 | 				let RunStringEx: RunStringEx = find_gmod_signature!((_lib, _path) -> {
 97 | 
 98 | 					win64_x86_64: [@SIG = "40 55 53 56 57 41 54 41 56 41 57 48 8D AC 24 ? ? ? ? 48 81 EC ? ? ? ? 48 8B 05 ? ? ? ? 48 33 C4 48 89 85 ? ? ? ? 49 8B F1 4D 8B F8 4C 8B F2 48 8B F9 4D 85 C9 0F 84"],
 99 | 					win32_x86_64: [@SIG = "55 8B EC 81 EC ? ? ? ? 56 57 8B 7D 10 8B F1 85 FF 0F 84 ? ? ? ? 57 E8 ? ? ? ? 83 C4 04 83 F8 01 0F 8C ? ? ? ? 80 3F 1B 75 35 8B 06 6A 1B 68 ? ? ? ? 56 FF 90 ? ? ? ?"],
100 | 
101 | 					linux64_x86_64: [@SIG = "55 48 89 E5 41 57 41 56 41 55 49 89 F5 41 54 53 48 89 FB 48 81 EC ? ? ? ? 44 89 85 ? ? ? ? 8B 45 18 44 89 8D ? ? ? ? 44 8B 75 10 89 85"],
102 | 					linux32_x86_64: [@SIG = "55 89 E5 57 56 53 81 EC ? ? ? ? 8B 45 18 8B 55 14 8B 5D 08 8B 7D 0C 89 85 ? ? ? ? 8B 45 1C 8B 75 10 89 85 ? ? ? ? 8B 45 20 89 85 ? ? ? ? 8B 45 24 89 85 ? ? ? ? 65 A1 ? ? ? ? 89 45 E4 31 C0 85 D2 0F 84 ? ? ? ? 89 14 24 89 95"],
103 | 
104 | 					win32: [@SIG = "55 8B EC 8B 55 10 81 EC ? ? ? ? 56 8B F1 57 85 D2 0F 84 ? ? ? ? 8B CA 8D 79 01 8D 49 00 8A 01 41 84 C0 75 F9 2B CF 83 F9 01 0F 8C ? ? ? ? 80 3A 1B 75 35"],
105 | 					linux32: [@SIG = "55 89 E5 57 56 53 81 EC ? ? ? ? 8B 45 18 8B 55 14 8B 5D 08 8B 7D 0C 89 85 ? ? ? ? 8B 45 1C 8B 75 10 89 85 ? ? ? ? 8B 45 20 89 85 ? ? ? ? 8B 45 24 89 85 ? ? ? ? 65 A1 ? ? ? ? 89 45 E4 31 C0 85 D2 0F 84 ? ? ? ? 89 14 24 89 95 ? ? ? ?"],
106 | 
107 | 				}).expect("Failed to find CLuaInterface::RunStringEx");
108 | 
109 | 				let detour = gmod::detour::GenericDetour::new::<RunStringEx>(RunStringEx, RunStringEx_Detour).expect("Failed to detour CLuaInterface::RunStringEx");
110 | 				detour.enable().expect("Failed to enable CLuaInterface::RunStringEx detour");
111 | 				detour
112 | 			},
113 | 
114 | 			// BUTTON_CODE_INVALID
115 | 			CLuaEnums_InitLibraries: {
116 | 				let CLuaEnums_InitLibraries: CLuaEnums_InitLibraries = find_gmod_signature!((_serverdll, _serverdllpath) -> {
117 | 
118 | 					win64_x86_64: [@SIG = "48 8B C4 48 89 58 08 57 48 81 EC ? ? ? ? 0F 29 70 E8 48 8B CA 0F 29 78 D8 48 8B FA 44 0F 29 40 ? 44 0F 29 48 ? 44 0F 29 58 ? 44 0F 29 60 ? 44 0F 29 68 ? 48 8B 02 44 0F 29 74 24 ? 44 0F 29 7C 24 ? FF 90 ? ? ? ? F2 0F 10 35 ? ? ? ? 48 8D 15 ? ? ? ?"],
119 | 					win32_x86_64: [@SIG = "00"],
120 | 
121 | 					linux64_x86_64: [@SIG = "00"],
122 | 					linux32_x86_64: [@SIG = "00"],
123 | 
124 | 					win32: [@SIG = "00"],
125 | 					linux32: [@SIG = "00"],
126 | 
127 | 				}).expect("Failed to find CLuaEnums::InitLibraries");
128 | 
129 | 				let detour = gmod::detour::GenericDetour::new::<CLuaEnums_InitLibraries>(CLuaEnums_InitLibraries, CLuaEnums_InitLibraries_Detour).expect("Failed to detour CLuaEnums::InitLibraries");
130 | 				detour.enable().expect("Failed to enable CLuaEnums::InitLibraries detour");
131 | 				detour
132 | 			},
133 | 
134 | 			// BUTTON_CODE_INVALID
135 | 			CGameLuaEnums_InitLibraries: {
136 | 				let CGameLuaEnums_InitLibraries: CGameLuaEnums_InitLibraries = find_gmod_signature!((_serverdll, _serverdllpath) -> {
137 | 
138 | 					win64_x86_64: [@SIG = "48 8B C4 48 89 58 08 48 89 70 10 57 48 81 EC ? ? ? ? 0F 29 70 E8 48 8B CA 0F 29 78 D8 48 8B FA 44 0F 29 40 ? 44 0F 29 48 ? 44 0F 29 50 ? 44 0F 29 58 ? 44 0F 29 60 ? 48 8B 02 44 0F 29 6C 24 ? 44 0F 29 74 24 ? 44 0F 29 7C 24 ? FF 90 ? ? ? ? F2 0F 10 15 ? ? ? ?"],
139 | 					win32_x86_64: [@SIG = "00"],
140 | 
141 | 					linux64_x86_64: [@SIG = "00"],
142 | 					linux32_x86_64: [@SIG = "00"],
143 | 
144 | 					win32: [@SIG = "00"],
145 | 					linux32: [@SIG = "00"],
146 | 
147 | 				}).expect("Failed to find CGameLuaEnums::InitLibraries");
148 | 
149 | 				let detour = gmod::detour::GenericDetour::new::<CGameLuaEnums_InitLibraries>(CGameLuaEnums_InitLibraries, CGameLuaEnums_InitLibraries_Detour).expect("Failed to detour CGameLuaEnums::InitLibraries");
150 | 				detour.enable().expect("Failed to enable CGameLuaEnums::InitLibraries detour");
151 | 				detour
152 | 			},
153 | 		});
154 | 	});
155 | }


--------------------------------------------------------------------------------
/src/tests.rs:
--------------------------------------------------------------------------------
  1 | macro_rules! generate {
  2 | 	{
  3 | 		Realm::Server => {
  4 | 			$($sv_name:ident: { $sv_from:literal, $sv_to:literal }),*
  5 | 		},
  6 | 		Realm::Client => {
  7 | 			$($cl_name:ident: { $cl_from:literal, $cl_to:literal }),*
  8 | 		}
  9 | 	} => {
 10 | 		mod server {
 11 | 			$(
 12 | 				#[test]
 13 | 				fn $sv_name() {
 14 | 					crate::init();
 15 | 					crate::enums::test_data();
 16 | 
 17 | 					let mut src = $sv_from.trim().as_bytes().to_vec();
 18 | 					let strip_tree = crate::strip::generate(&src);
 19 | 					crate::realms::optimise(crate::realms::Realm::Server, &mut src, &strip_tree);
 20 | 					crate::enums::optimise(&mut src, &strip_tree);
 21 | 
 22 | 					let a = String::from_utf8_lossy(&src);
 23 | 					let b = $sv_to.trim();
 24 | 					if src.as_slice() != b.as_bytes() {
 25 | 						panic!("Mismatch\n\n== Left ==\n{}\n\n== Right ==\n{}", a, b);
 26 | 					}
 27 | 				}
 28 | 			)*
 29 | 		}
 30 | 		mod client {
 31 | 			$(
 32 | 				#[test]
 33 | 				fn $cl_name() {
 34 | 					crate::init();
 35 | 					crate::enums::test_data();
 36 | 
 37 | 					let mut src = $cl_from.trim().as_bytes().to_vec();
 38 | 					let strip_tree = crate::strip::generate(&src);
 39 | 					crate::realms::optimise(crate::realms::Realm::Client, &mut src, &strip_tree);
 40 | 					crate::enums::optimise(&mut src, &strip_tree);
 41 | 
 42 | 					let a = String::from_utf8_lossy(&src);
 43 | 					let b = $cl_to.trim();
 44 | 					if src.as_slice() != b.as_bytes() {
 45 | 						panic!("Mismatch\n\n== Left ==\n{}\n\n== Right ==\n{}", a, b);
 46 | 					}
 47 | 				}
 48 | 			)*
 49 | 		}
 50 | 	};
 51 | }
 52 | 
 53 | generate! {
 54 | 	Realm::Server => {
 55 | 		localizations: {
 56 | 			r#"
 57 | 			(local SERVER = SERVER)
 58 | 			(local CLIENT = CLIENT)
 59 | 			(local ACT_INVALID = ACT_INVALID)
 60 | 			"#,
 61 | 
 62 | 			r#"
 63 | 			(local SERVER = true  )
 64 | 			(local CLIENT = false )
 65 | 			(local ACT_INVALID = -1         )
 66 | 			"#
 67 | 		},
 68 | 
 69 | 		enums: {
 70 | 			r#"
 71 | 			(ACT_INVALID)
 72 | 			(ACT_RESET)
 73 | 			(ACT_IDLE)
 74 | 			(ACT_TRANSITION)
 75 | 			(ACT_COVER)
 76 | 			(ACT_COVER_MED)
 77 | 			(ACT_COVER_LOW)
 78 | 			(ACT_WALK)
 79 | 			(ACT_WALK_AIM)
 80 | 			(ACT_WALK_CROUCH)
 81 | 			(ACT_WALK_CROUCH_AIM)
 82 | 			(ACT_RUN)
 83 | 			(ACT_RUN_AIM)
 84 | 			(ACT_RUN_CROUCH)
 85 | 			(ACT_RUN_CROUCH_AIM)
 86 | 			"#,
 87 | 
 88 | 			r#"
 89 | 			(-1         )
 90 | 			(0        )
 91 | 			(1       )
 92 | 			(2             )
 93 | 			(3        )
 94 | 			(4            )
 95 | 			(5            )
 96 | 			(6       )
 97 | 			(7           )
 98 | 			(8              )
 99 | 			(9                  )
100 | 			(10     )
101 | 			(11         )
102 | 			(12            )
103 | 			(13                )
104 | 			"#
105 | 		},
106 | 
107 | 		server_and_client: {
108 | 			r#"
109 | 			-- SERVER
110 | 			local _ = "SERVER CLIENT"
111 | 			local _ = "SER\"VER"
112 | 			local _ = "SER\\\"VER"
113 | 			local _ = 'SER\'VER'
114 | 			local _ = [[SERVER]]
115 | 			local _ = [[SER]\]VER]]
116 | 			local _ = [[SER\]\]VER]]
117 | 			local _ = [[SERVER CLIENT
118 | 			SERVER]]
119 | 			local _ = "" .. SERVER .. ""
120 | 
121 | 			-- CLIENT
122 | 			local _ = "CLIENT SERVER"
123 | 			local _ = "CLIENT\"CLIENT"
124 | 			local _ = "CLIENT\\\"CLIENT"
125 | 			local _ = 'CLIENT\'CLIENT'
126 | 			local _ = [[CLIENT]]
127 | 			local _ = [[CLIENT]\]CLIENT]]
128 | 			local _ = [[CLIENT\]\]CLIENT]]
129 | 			local _ = [[CLIENT SERVER
130 | 			CLIENT]]
131 | 			local _ = "" .. CLIENT .. ""
132 | 
133 | 			--[[
134 | 				multiline comment
135 | 				SERVER
136 | 				CLIENT
137 | 			]]
138 | 
139 | 			--[=[
140 | 				multiline comment
141 | 				SERVER
142 | 				CLIENT
143 | 			]=]
144 | 
145 | 			--[==========[
146 | 				multiline comment
147 | 				SERVER
148 | 				CLIENT
149 | 			]==========]
150 | 
151 | 			if SERVER and not lol or not hi and SERVER and CLIENT then
152 | 
153 | 			end
154 | 			"#,
155 | 
156 | 			r#"
157 | 			-- SERVER
158 | 			local _ = "SERVER CLIENT"
159 | 			local _ = "SER\"VER"
160 | 			local _ = "SER\\\"VER"
161 | 			local _ = 'SER\'VER'
162 | 			local _ = [[SERVER]]
163 | 			local _ = [[SER]\]VER]]
164 | 			local _ = [[SER\]\]VER]]
165 | 			local _ = [[SERVER CLIENT
166 | 			SERVER]]
167 | 			local _ = "" .. true   .. ""
168 | 
169 | 			-- CLIENT
170 | 			local _ = "CLIENT SERVER"
171 | 			local _ = "CLIENT\"CLIENT"
172 | 			local _ = "CLIENT\\\"CLIENT"
173 | 			local _ = 'CLIENT\'CLIENT'
174 | 			local _ = [[CLIENT]]
175 | 			local _ = [[CLIENT]\]CLIENT]]
176 | 			local _ = [[CLIENT\]\]CLIENT]]
177 | 			local _ = [[CLIENT SERVER
178 | 			CLIENT]]
179 | 			local _ = "" .. false  .. ""
180 | 
181 | 			--[[
182 | 				multiline comment
183 | 				SERVER
184 | 				CLIENT
185 | 			]]
186 | 
187 | 			--[=[
188 | 				multiline comment
189 | 				SERVER
190 | 				CLIENT
191 | 			]=]
192 | 
193 | 			--[==========[
194 | 				multiline comment
195 | 				SERVER
196 | 				CLIENT
197 | 			]==========]
198 | 
199 | 			if true   and not lol or not hi and true   and false  then
200 | 
201 | 			end
202 | 			"#
203 | 		}
204 | 	},
205 | 
206 | 	Realm::Client => {
207 | 		localizations: {
208 | 			r#"
209 | 			(local SERVER = SERVER)
210 | 			(local CLIENT = CLIENT)
211 | 			(local ACT_INVALID = ACT_INVALID)
212 | 			"#,
213 | 
214 | 			r#"
215 | 			(local SERVER = false )
216 | 			(local CLIENT = true  )
217 | 			(local ACT_INVALID = -1         )
218 | 			"#
219 | 		},
220 | 
221 | 		enums: {
222 | 			r#"
223 | 			(ACT_INVALID)
224 | 			(ACT_RESET)
225 | 			(ACT_IDLE)
226 | 			(ACT_TRANSITION)
227 | 			(ACT_COVER)
228 | 			(ACT_COVER_MED)
229 | 			(ACT_COVER_LOW)
230 | 			(ACT_WALK)
231 | 			(ACT_WALK_AIM)
232 | 			(ACT_WALK_CROUCH)
233 | 			(ACT_WALK_CROUCH_AIM)
234 | 			(ACT_RUN)
235 | 			(ACT_RUN_AIM)
236 | 			(ACT_RUN_CROUCH)
237 | 			(ACT_RUN_CROUCH_AIM)
238 | 			"#,
239 | 
240 | 			r#"
241 | 			(-1         )
242 | 			(0        )
243 | 			(1       )
244 | 			(2             )
245 | 			(3        )
246 | 			(4            )
247 | 			(5            )
248 | 			(6       )
249 | 			(7           )
250 | 			(8              )
251 | 			(9                  )
252 | 			(10     )
253 | 			(11         )
254 | 			(12            )
255 | 			(13                )
256 | 			"#
257 | 		},
258 | 
259 | 		server_and_client: {
260 | 			r#"
261 | 			-- SERVER
262 | 			local _ = "SERVER CLIENT"
263 | 			local _ = "SERVER\"SERVER"
264 | 			local _ = "SERVER\\\"SERVER"
265 | 			local _ = 'SERVER\'SERVER'
266 | 			local _ = [[SERVER]]
267 | 			local _ = [[SERVER]\]SERVER]]
268 | 			local _ = [[SERVER\]\]SERVER]]
269 | 			local _ = [[SERVER CLIENT
270 | 			SERVER]]
271 | 			local _ = "" .. SERVER .. ""
272 | 
273 | 			-- CLIENT
274 | 			local _ = "CLIENT SERVER"
275 | 			local _ = "CLIENT\"CLIENT"
276 | 			local _ = "CLIENT\\\"CLIENT"
277 | 			local _ = 'CLIENT\'CLIENT'
278 | 			local _ = [[CLIENT]]
279 | 			local _ = [[CLIENT]\]CLIENT]]
280 | 			local _ = [[CLIENT\]\]CLIENT]]
281 | 			local _ = [[CLIENT SERVER
282 | 			CLIENT]]
283 | 			local _ = "" .. CLIENT .. ""
284 | 
285 | 			--[[
286 | 				multiline comment
287 | 				SERVER
288 | 				CLIENT
289 | 			]]
290 | 
291 | 			--[=[
292 | 				multiline comment
293 | 				SERVER
294 | 				CLIENT
295 | 			]=]
296 | 
297 | 			--[==========[
298 | 				multiline comment
299 | 				SERVER
300 | 				CLIENT
301 | 			]==========]
302 | 
303 | 			if SERVER and not lol or not hi and SERVER and CLIENT then
304 | 
305 | 			end
306 | 			"#,
307 | 
308 | 			r#"
309 | 			-- SERVER
310 | 			local _ = "SERVER CLIENT"
311 | 			local _ = "SERVER\"SERVER"
312 | 			local _ = "SERVER\\\"SERVER"
313 | 			local _ = 'SERVER\'SERVER'
314 | 			local _ = [[SERVER]]
315 | 			local _ = [[SERVER]\]SERVER]]
316 | 			local _ = [[SERVER\]\]SERVER]]
317 | 			local _ = [[SERVER CLIENT
318 | 			SERVER]]
319 | 			local _ = "" .. false  .. ""
320 | 
321 | 			-- CLIENT
322 | 			local _ = "CLIENT SERVER"
323 | 			local _ = "CLIENT\"CLIENT"
324 | 			local _ = "CLIENT\\\"CLIENT"
325 | 			local _ = 'CLIENT\'CLIENT'
326 | 			local _ = [[CLIENT]]
327 | 			local _ = [[CLIENT]\]CLIENT]]
328 | 			local _ = [[CLIENT\]\]CLIENT]]
329 | 			local _ = [[CLIENT SERVER
330 | 			CLIENT]]
331 | 			local _ = "" .. true   .. ""
332 | 
333 | 			--[[
334 | 				multiline comment
335 | 				SERVER
336 | 				CLIENT
337 | 			]]
338 | 
339 | 			--[=[
340 | 				multiline comment
341 | 				SERVER
342 | 				CLIENT
343 | 			]=]
344 | 
345 | 			--[==========[
346 | 				multiline comment
347 | 				SERVER
348 | 				CLIENT
349 | 			]==========]
350 | 
351 | 			if false  and not lol or not hi and false  and true   then
352 | 
353 | 			end
354 | 			"#
355 | 		}
356 | 	}
357 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Wat
  2 | 
  3 | This attractively named repository contains a Garry's Mod module that performs a micro optimisation that makes use of LuaJIT's constant folding on all Lua scripts.
  4 | 
  5 | The module intercepts the loading of Lua scripts and preprocesses the Lua code to replace all instances of `SERVER` and `CLIENT` with `true` and `false` depending on the current realm.
  6 | 
  7 | The module does not replace these in comments or strings and does not change the size of the file or span of the tokens (by inserting extra whitespace.)
  8 | 
  9 | # Explanation
 10 | 
 11 | In Garry's Mod there are two runtime realms, the server realm and the client realm. Because Lua doesn't have conditional compilation, developers have to use an if statement to determine whether the script is running on the server or the client:
 12 | 
 13 | ```lua
 14 | if SERVER then
 15 |     print("Hello, server!")
 16 | end
 17 | if CLIENT then
 18 |     print("Hello, client!")
 19 | end
 20 | ```
 21 | 
 22 | The equivalent C preprocessor code would look like this:
 23 | 
 24 | ```c
 25 | #ifdef SERVER
 26 |     printf("Hello, server!\n")
 27 | #endif
 28 | #ifdef CLIENT
 29 |     printf("Hello, client!\n")
 30 | #endif
 31 | ```
 32 | 
 33 | # Results
 34 | 
 35 | First I should probably note that this is just a dumb experiment and I expected it to not have much performance impact.
 36 | 
 37 | CPU branch predictors are pretty good these days and LuaJIT should hopefully help too to make this not so much of an issue for performance.
 38 | 
 39 | Additionally, it's quite rare that a runtime realm check would find itself in a hot loop or hot function, so the impact of overall server/game performance from such an optimisation is probably completely unnoticable.
 40 | 
 41 | ## Bytecode
 42 | 
 43 | The generated bytecode is only slightly different after this hack. It would seem that LuaJIT does not do dead code elimination in this case. It does however eliminate the branch and replaces it with a direct jump.
 44 | 
 45 | ### Sample Code
 46 | 
 47 | ```lua
 48 | function helloWorld()
 49 |     if SERVER then
 50 |         print("Hello SERVER")
 51 |     end
 52 |     if CLIENT then
 53 |         print("Hello CLIENT")
 54 |     end
 55 | end
 56 | ```
 57 | 
 58 | ### Unoptimised
 59 | 
 60 | ```asm
 61 | 0000	FUNCF    3
 62 | 0001	GGET     0   0      ; "SERVER"
 63 | 0002	ISF          0
 64 | 0003	JMP      1 => 0007
 65 | 0004	GGET     0   1      ; "print"
 66 | 0005	KSTR     2   2      ; "Hello SERVER"
 67 | 0006	CALL     0   1   2
 68 | 0007	GGET     0   3      ; "CLIENT"
 69 | 0008	ISF          0
 70 | 0009	JMP      1 => 0013
 71 | 0010	GGET     0   1      ; "print"
 72 | 0011	KSTR     2   4      ; "Hello CLIENT"
 73 | 0012	CALL     0   1   2
 74 | 0013	RET0     0   1
 75 | ```
 76 | 
 77 | ### Optimised
 78 | 
 79 | ```asm
 80 | 0000	FUNCF    3
 81 | 0001	GGET     0   0      ; "print"
 82 | 0002	KSTR     2   1      ; "Hello SERVER"
 83 | 0003	CALL     0   1   2
 84 | 0004	JMP      0 => 0005
 85 | 0005	JMP      0 => 0009
 86 | 0006	GGET     0   0      ; "print"
 87 | 0007	KSTR     2   2      ; "Hello CLIENT"
 88 | 0008	CALL     0   1   2
 89 | 0009	RET0     0   1
 90 | ```
 91 | 
 92 | ## Benchmarks
 93 | 
 94 | ```lua
 95 | jit.off() jit.on()
 96 | jit.flush()
 97 | print(jit.status()) print()
 98 | 
 99 | local seed = math.random(1, 2)
100 | 
101 | do
102 |     local function globals()
103 |         local low = math.huge
104 |         local high = 0
105 |         local total = 0
106 |         for i = 1, 10 do
107 |             local start = SysTime()
108 |             for i = 1, 100000 do
109 |                 local n = 0
110 |                 if SERVER then
111 |                     n = n + seed
112 |                 end
113 |                 if CLIENT then
114 |                     n = n + seed
115 |                 end
116 |             end
117 |             local delta = SysTime() - start
118 |             low = math.min(low, delta)
119 |             high = math.max(high, delta)
120 |             total = total + delta
121 |         end
122 |         print("(Global) Unoptimised")
123 |         print("Low: " .. low * (10 ^ 6) .. "us")
124 |         print("High: " .. high * (10 ^ 6) .. "us")
125 |         print("Mean: " .. (total / 10) * (10 ^ 6) .. "us\n")
126 |     end
127 |     globals()
128 | end
129 | 
130 | do
131 |     local function localised()
132 |         local SERVER = SERVER
133 |         local CLIENT = CLIENT
134 | 
135 |         local low = math.huge
136 |         local high = 0
137 |         local total = 0
138 |         for i = 1, 10 do
139 |             local start = SysTime()
140 |             for i = 1, 100000 do
141 |                 local n = 0
142 |                 if SERVER then
143 |                     n = n + seed
144 |                 end
145 |                 if CLIENT then
146 |                     n = n + seed
147 |                 end
148 |             end
149 |             local delta = SysTime() - start
150 |             low = math.min(low, delta)
151 |             high = math.max(high, delta)
152 |             total = total + delta
153 |         end
154 |         print("(Local) Unoptimised")
155 |         print("Low: " .. low * (10 ^ 6) .. "us")
156 |         print("High: " .. high * (10 ^ 6) .. "us")
157 |         print("Mean: " .. (total / 10) * (10 ^ 6) .. "us\n")
158 |     end
159 |     localised()
160 | end
161 | 
162 | do
163 |     local function localised_no_const()
164 |         local SERVER = math.random(1, 2) == 1
165 |         local CLIENT = not SERVER
166 | 
167 |         local low = math.huge
168 |         local high = 0
169 |         local total = 0
170 |         for i = 1, 10 do
171 |             local start = SysTime()
172 |             for i = 1, 100000 do
173 |                 local n = 0
174 |                 if SERVER then
175 |                     n = n + seed
176 |                 end
177 |                 if CLIENT then
178 |                     n = n + seed
179 |                 end
180 |             end
181 |             local delta = SysTime() - start
182 |             low = math.min(low, delta)
183 |             high = math.max(high, delta)
184 |             total = total + delta
185 |         end
186 |         print("(Local NoConst) Unoptimised")
187 |         print("Low: " .. low * (10 ^ 6) .. "us")
188 |         print("High: " .. high * (10 ^ 6) .. "us")
189 |         print("Mean: " .. (total / 10) * (10 ^ 6) .. "us\n")
190 |     end
191 |     localised_no_const()
192 | end
193 | 
194 | do
195 |     local function optimised()
196 |         local low = math.huge
197 |         local high = 0
198 |         local total = 0
199 |         for i = 1, 10 do
200 |             local start = SysTime()
201 |             for i = 1, 100000 do
202 |                 local n = 0
203 |                 if true then
204 |                     n = n + seed
205 |                 end
206 |                 if false then
207 |                     n = n + seed
208 |                 end
209 |             end
210 |             local delta = SysTime() - start
211 |             low = math.min(low, delta)
212 |             high = math.max(high, delta)
213 |             total = total + delta
214 |         end
215 |         print("Optimised")
216 |         print("Low: " .. low * (10 ^ 6) .. "us")
217 |         print("High: " .. high * (10 ^ 6) .. "us")
218 |         print("Mean: " .. (total / 10) * (10 ^ 6) .. "us")
219 |     end
220 |     optimised()
221 | end
222 | ```
223 | 
224 | ```
225 | true    SSE2    SSE3    SSE4.1  AMD     BMI2    fold    cse     dce     fwd     dse     narrow  loop    abc     sink   fuse
226 | 
227 | (Global) Unoptimised
228 | Low: 77.999999575695us
229 | High: 115.39999968591us
230 | Mean: 85.85999994466us
231 | 
232 | (Local) Unoptimised
233 | Low: 34.700000014709us
234 | High: 53.599999773724us
235 | Mean: 39.509999987786us
236 | 
237 | (Local NoConst) Unoptimised
238 | Low: 34.700000014709us
239 | High: 70.099999902595us
240 | Mean: 39.699999979348us
241 | 
242 | Optimised
243 | Low: 34.699999559962us
244 | High: 51.699999858101us
245 | Mean: 37.459999975908us
246 | ```
247 | 
248 | ## Conclusion
249 | 
250 | It is clear that most of the overhead from `if SERVER` and `if CLIENT` runtime checks come from global lookups.
251 | 
252 | Unsurprisingly, the branching overhead is extremely small. We can see this because the `(Local) Unoptimised` average is only ~2.24us difference when compared to the `Optimised` average.
253 | 
254 | Because `SERVER` and `CLIENT` are just booleans, they will be copied into the localised variables. This could potentially enable additional optimisations since LuaJIT can see that the local value could be constants. I tested this with the `Local NoConst` benchmark but it seemed to have negligible difference, so in this case I don't think it was relevant.
255 | 
256 | In conclusion from these observations, this module can optimise runtime checking of realm when looking up from the global table but has negligible impact when those globals have been localised.
257 | 
258 | ### Alternative Solution
259 | 
260 | A module that prepends common globals as locals to the top of scripts could be an alternative, and potentially even better method for this, but is definitely more error prone as Lua has a maximum upvalue amount and adding new locals to the top of a script could cause an error for this reason. However, a more advanced module that implements a real GLua lexer + parser could catch this issue and skip optimising that file.
261 | 


--------------------------------------------------------------------------------
/src/cxx/include/iluainterface.h:
--------------------------------------------------------------------------------
  1 | typedef int ( *CFunc )( void* L );
  2 | 
  3 | class Color;
  4 | 
  5 | class ILuaBase
  6 | {
  7 | public:
  8 | 	// Returns the amount of values on the stack
  9 | 	virtual int         Top( void ) = 0;
 10 | 
 11 | 	// Pushes a copy of the value at iStackPos to the top of the stack
 12 | 	virtual void        Push( int iStackPos ) = 0;
 13 | 
 14 | 	// Pops iAmt values from the top of the stack
 15 | 	virtual void        Pop( int iAmt = 1 ) = 0;
 16 | 
 17 | 	// Pushes table[key] on to the stack
 18 | 	// table = value at iStackPos
 19 | 	// key   = value at top of the stack
 20 | 	// Pops the key from the stack
 21 | 	virtual void        GetTable( int iStackPos ) = 0;
 22 | 
 23 | 	// Pushes table[key] on to the stack
 24 | 	// table = value at iStackPos
 25 | 	// key   = strName
 26 | 	virtual void        GetField( int iStackPos, const char* strName ) = 0;
 27 | 
 28 | 	// Sets table[key] to the value at the top of the stack
 29 | 	// table = value at iStackPos
 30 | 	// key   = strName
 31 | 	// Pops the value from the stack
 32 | 	virtual void        SetField( int iStackPos, const char* strName ) = 0;
 33 | 
 34 | 	// Creates a new table and pushes it to the top of the stack
 35 | 	virtual void        CreateTable() = 0;
 36 | 
 37 | 	// Sets table[key] to the value at the top of the stack
 38 | 	// table = value at iStackPos
 39 | 	// key   = value 2nd to the top of the stack
 40 | 	// Pops the key and the value from the stack
 41 | 	virtual void        SetTable( int iStackPos ) = 0;
 42 | 
 43 | 	// Sets the metatable for the value at iStackPos to the value at the top of the stack
 44 | 	// Pops the value off of the top of the stack
 45 | 	virtual void        SetMetaTable( int iStackPos ) = 0;
 46 | 
 47 | 	// Pushes the metatable of the value at iStackPos on to the top of the stack
 48 | 	// Upon failure, returns false and does not push anything
 49 | 	virtual bool        GetMetaTable( int i ) = 0;
 50 | 
 51 | 	// Calls a function
 52 | 	// To use it: Push the function on to the stack followed by each argument
 53 | 	// Pops the function and arguments from the stack, leaves iResults values on the stack
 54 | 	// If this function errors, any local C values will not have their destructors called!
 55 | 	virtual void        Call( int iArgs, int iResults ) = 0;
 56 | 
 57 | 	// Similar to Call
 58 | 	// See: lua_pcall( void*, int, int, int )
 59 | 	virtual int         PCall( int iArgs, int iResults, int iErrorFunc ) = 0;
 60 | 
 61 | 	// Returns true if the values at iA and iB are equal
 62 | 	virtual int         Equal( int iA, int iB ) = 0;
 63 | 
 64 | 	// Returns true if the value at iA and iB are equal
 65 | 	// Does not invoke metamethods
 66 | 	virtual int         RawEqual( int iA, int iB ) = 0;
 67 | 
 68 | 	// Moves the value at the top of the stack in to iStackPos
 69 | 	// Any elements above iStackPos are shifted upwards
 70 | 	virtual void        Insert( int iStackPos ) = 0;
 71 | 
 72 | 	// Removes the value at iStackPos from the stack
 73 | 	// Any elements above iStackPos are shifted downwards
 74 | 	virtual void        Remove( int iStackPos ) = 0;
 75 | 
 76 | 	// Allows you to iterate tables similar to pairs(...)
 77 | 	// See: lua_next( void*, int );
 78 | 	virtual int         Next( int iStackPos ) = 0;
 79 | 
 80 | protected:
 81 | 		// Deprecated: Use the UserType functions instead of this
 82 | 	virtual void*       NewUserdata( unsigned int iSize ) = 0;
 83 | 
 84 | public:
 85 | 	// Throws an error and ceases execution of the function
 86 | 	// If this function is called, any local C values will not have their destructors called!
 87 | 	[[noreturn]]
 88 | 	virtual void        ThrowError( const char* strError ) = 0;
 89 | 
 90 | 	// Checks that the type of the value at iStackPos is iType
 91 | 	// Throws and error and ceases execution of the function otherwise
 92 | 	// If this function errors, any local C values will not have their destructors called!
 93 | 	virtual void        CheckType( int iStackPos, int iType ) = 0;
 94 | 
 95 | 	// Throws a pretty error message about the given argument
 96 | 	// If this function is called, any local C values will not have their destructors called!
 97 | 	[[noreturn]]
 98 | 	virtual void        ArgError( int iArgNum, const char* strMessage ) = 0;
 99 | 
100 | 	// Pushes table[key] on to the stack
101 | 	// table = value at iStackPos
102 | 	// key   = value at top of the stack
103 | 	// Does not invoke metamethods
104 | 	virtual void        RawGet( int iStackPos ) = 0;
105 | 
106 | 	// Sets table[key] to the value at the top of the stack
107 | 	// table = value at iStackPos
108 | 	// key   = value 2nd to the top of the stack
109 | 	// Pops the key and the value from the stack
110 | 	// Does not invoke metamethods
111 | 	virtual void        RawSet( int iStackPos ) = 0;
112 | 
113 | 	// Returns the string at iStackPos. iOutLen is set to the length of the string if it is not NULL
114 | 	// If the value at iStackPos is a number, it will be converted in to a string
115 | 	// Returns NULL upon failure
116 | 	virtual const char* GetString( int iStackPos = -1, unsigned int* iOutLen = nullptr ) = 0;
117 | 
118 | 	// Returns the number at iStackPos
119 | 	// Returns 0 upon failure
120 | 	virtual double      GetNumber( int iStackPos = -1 ) = 0;
121 | 
122 | 	// Returns the boolean at iStackPos
123 | 	// Returns false upon failure
124 | 	virtual bool        GetBool( int iStackPos = -1 ) = 0;
125 | 
126 | 	// Returns the C-Function at iStackPos
127 | 	// returns NULL upon failure
128 | 	virtual CFunc       GetCFunction( int iStackPos = -1 ) = 0;
129 | 
130 | protected:
131 | 		// Deprecated: You should probably be using the UserType functions instead of this
132 | 	virtual void*       GetUserdata( int iStackPos = -1 ) = 0;
133 | 
134 | public:
135 | 	// Pushes a nil value on to the stack
136 | 	virtual void        PushNil() = 0;
137 | 
138 | 	// Pushes the given string on to the stack
139 | 	// If iLen is 0, strlen will be used to determine the string's length
140 | 	virtual void        PushString( const char* val, unsigned int iLen = 0 ) = 0;
141 | 
142 | 	// Pushes the given double on to the stack
143 | 	virtual void        PushNumber( double val ) = 0;
144 | 
145 | 	// Pushes the given bobolean on to the stack
146 | 	virtual void        PushBool( bool val ) = 0;
147 | 
148 | 	// Pushes the given C-Function on to the stack
149 | 	virtual void        PushCFunction( CFunc val ) = 0;
150 | 
151 | 	// Pushes the given C-Function on to the stack with upvalues
152 | 	// See: GetUpvalueIndex()
153 | 	virtual void        PushCClosure( CFunc val, int iVars ) = 0;
154 | 
155 | 
156 | protected:
157 | 		// Deprecated: Don't use light userdata in GMod
158 | 	virtual void        PushUserdata( void* ) = 0;
159 | 
160 | public:
161 | 	// Allows for values to be stored by reference for later use
162 | 	// Make sure you call ReferenceFree when you are done with a reference
163 | 	virtual int         ReferenceCreate() = 0;
164 | 	virtual void        ReferenceFree( int i ) = 0;
165 | 	virtual void        ReferencePush( int i ) = 0;
166 | 
167 | 	// Push a special value onto the top of the stack (see SPECIAL_* enums)
168 | 	virtual void        PushSpecial( int iType ) = 0;
169 | 
170 | 	// Returns true if the value at iStackPos is of type iType
171 | 	// See: Types.h
172 | 	virtual bool        IsType( int iStackPos, int iType ) = 0;
173 | 
174 | 	// Returns the type of the value at iStackPos
175 | 	// See: Types.h
176 | 	virtual int         GetType( int iStackPos ) = 0;
177 | 
178 | 	// Returns the name associated with the given type ID
179 | 	// See: Types.h
180 | 	// Note: GetTypeName does not work with user-created types
181 | 	virtual const char* GetTypeName( int iType ) = 0;
182 | 
183 | protected:
184 | 		// Deprecated: Use CreateMetaTable
185 | 	virtual void        CreateMetaTableType( const char* strName, int iType ) = 0;
186 | 
187 | public:
188 | 	// Like Get* but throws errors and returns if they're not of the expected type
189 | 	// If these functions error, any local C values will not have their destructors called!
190 | 	virtual const char* CheckString( int iStackPos = -1 ) = 0;
191 | 	virtual double      CheckNumber( int iStackPos = -1 ) = 0;
192 | 
193 | 	// Returns the length of the object at iStackPos
194 | 	// Works for: strings, tables, userdata
195 | 	virtual int         ObjLen( int iStackPos = -1 ) = 0;
196 | 
197 | 	// Returns the angle at iStackPos
198 | 	virtual const void * GetAngle( int iStackPos = -1 ) = 0;
199 | 
200 | 	// Returns the vector at iStackPos
201 | 	virtual const void * GetVector( int iStackPos = -1 ) = 0;
202 | 
203 | 	// Pushes the given angle to the top of the stack
204 | 	virtual void        PushAngle( const void * val ) = 0;
205 | 
206 | 	// Pushes the given vector to the top of the stack
207 | 	virtual void        PushVector( const void * val ) = 0;
208 | 
209 | 	// Sets the void to be used by the ILuaBase implementation
210 | 	// You don't need to use this if you use the LUA_FUNCTION macro
211 | 	virtual void        SetState( void* L ) = 0;
212 | 
213 | 	// Pushes the metatable associated with the given type name
214 | 	// Returns the type ID to use for this type
215 | 	// If the type doesn't currently exist, it will be created
216 | 	virtual int         CreateMetaTable( const char* strName ) = 0;
217 | 
218 | 	// Pushes the metatable associated with the given type
219 | 	virtual bool        PushMetaTable( int iType ) = 0;
220 | 
221 | 	// Creates a new UserData of type iType that references the given data
222 | 	virtual void        PushUserType( void* data, int iType ) = 0;
223 | 
224 | 	// Sets the data pointer of the UserType at iStackPos
225 | 	// You can use this to invalidate a UserType by passing NULL
226 | 	virtual void        SetUserType( int iStackPos, void* data ) = 0;
227 | };
228 | 
229 | class ILuaInterface : public ILuaBase
230 | {
231 | public:
232 | 	virtual bool Init( void *, bool ) = 0;
233 | 	virtual void Shutdown( ) = 0;
234 | 	virtual void Cycle( ) = 0;
235 | 	virtual void *Global( ) = 0;
236 | 	virtual void *GetObject( int index ) = 0;
237 | 	virtual void PushLuaObject( void *obj ) = 0;
238 | 	virtual void PushLuaFunction( CFunc func ) = 0;
239 | 	virtual void LuaError( const char *err, int index ) = 0;
240 | 	virtual void TypeError( const char *name, int index ) = 0;
241 | 	virtual void CallInternal( int args, int rets ) = 0;
242 | 	virtual void CallInternalNoReturns( int args ) = 0;
243 | 	virtual bool CallInternalGetBool( int args ) = 0;
244 | 	virtual const char *CallInternalGetString( int args ) = 0;
245 | 	virtual bool CallInternalGet( int args, void *obj ) = 0;
246 | 	virtual void NewGlobalTable( const char *name ) = 0;
247 | 	virtual void *NewTemporaryObject( ) = 0;
248 | 	virtual bool isUserData( int index ) = 0;
249 | 	virtual void *GetMetaTableObject( const char *name, int type ) = 0;
250 | 	virtual void *GetMetaTableObject( int index ) = 0;
251 | 	virtual void *GetReturn( int index ) = 0;
252 | 	virtual bool IsServer( ) = 0;
253 | 	virtual bool IsClient( ) = 0;
254 | 	virtual bool IsMenu( ) = 0;
255 | 	virtual void DestroyObject( void *obj ) = 0;
256 | 	virtual void *CreateObject( ) = 0;
257 | 	virtual void SetMember( void *table, void *key, void *value ) = 0;
258 | 	virtual void GetNewTable( ) = 0;
259 | 	virtual void SetMember( void *table, float key ) = 0;
260 | 	virtual void SetMember( void *table, float key, void *value ) = 0;
261 | 	virtual void SetMember( void *table, const char *key ) = 0;
262 | 	virtual void SetMember( void *table, const char *key, void *value ) = 0;
263 | 	virtual void SetType( unsigned char ) = 0;
264 | 	virtual void PushLong( long num ) = 0;
265 | 	virtual int GetFlags( int index ) = 0;
266 | 	virtual bool FindOnObjectsMetaTable( int objIndex, int keyIndex ) = 0;
267 | 	virtual bool FindObjectOnTable( int tableIndex, int keyIndex ) = 0;
268 | 	virtual void SetMemberFast( void *table, int keyIndex, int valueIndex ) = 0;
269 | 	virtual bool RunString( const char *filename, const char *path, const char *stringToRun, bool run, bool showErrors ) = 0;
270 | 	virtual bool IsEqual( void *objA, void *objB ) = 0;
271 | 	virtual void Error( const char *err ) = 0;
272 | 	virtual const char *GetStringOrError( int index ) = 0;
273 | 	virtual bool RunLuaModule( const char *name ) = 0;
274 | 	virtual bool FindAndRunScript( const char *filename, bool run, bool showErrors, const char *stringToRun, bool noReturns ) = 0;
275 | 	virtual void SetPathID( const char *pathID ) = 0;
276 | 	virtual const char *GetPathID( ) = 0;
277 | 	virtual void ErrorNoHalt( const char *fmt, ... ) = 0;
278 | 	virtual void Msg( const char *fmt, ... ) = 0;
279 | 	virtual void PushPath( const char *path ) = 0;
280 | 	virtual void PopPath( ) = 0;
281 | 	virtual const char *GetPath( ) = 0;
282 | 	virtual int GetColor( int index ) = 0;
283 | 	virtual void PushColor( Color color ) = 0;
284 | 	virtual int GetStack( int level, void *dbg ) = 0;
285 | 	virtual int GetInfo( const char *what, void *dbg ) = 0;
286 | 	virtual const char *GetLocal( void *dbg, int n ) = 0;
287 | 	virtual const char *GetUpvalue( int funcIndex, int n ) = 0;
288 | 	virtual bool RunStringEx( const char *filename, const char *path, const char *stringToRun, bool run, bool printErrors, bool dontPushErrors, bool noReturns ) = 0;
289 | 	virtual size_t GetDataString( int index, const char **str ) = 0;
290 | 	virtual void ErrorFromLua( const char *fmt, ... ) = 0;
291 | 	virtual const char *GetCurrentLocation( ) = 0;
292 | 	virtual void MsgColour( const void *col, const char *fmt, ... ) = 0;
293 | 	virtual void GetCurrentFile( void *outStr ) = 0;
294 | 	virtual void CompileString( void *dumper, const void *stringToCompile ) = 0;
295 | 	virtual bool CallFunctionProtected( int, int, bool ) = 0;
296 | 	virtual void Require( const char *name ) = 0;
297 | 	virtual const char *GetActualTypeName( int type ) = 0;
298 | 	virtual void PreCreateTable( int arrelems, int nonarrelems ) = 0;
299 | 	virtual void PushPooledString( int index ) = 0;
300 | 	virtual const char *GetPooledString( int index ) = 0;
301 | 	virtual void *AddThreadedCall( void * ) = 0;
302 | 	virtual void AppendStackTrace( char *, unsigned long ) = 0;
303 | 	virtual void *CreateConVar( const char *, const char *, const char *, int ) = 0;
304 | 	virtual void *CreateConCommand( const char *, const char *, int, void ( * )( const void * ), int ( * )( const char *, char ( * )[128] ) ) = 0;
305 | };


--------------------------------------------------------------------------------
/Cargo.lock:
--------------------------------------------------------------------------------
  1 | # This file is automatically @generated by Cargo.
  2 | # It is not intended for manual editing.
  3 | version = 3
  4 | 
  5 | [[package]]
  6 | name = "bitflags"
  7 | version = "1.3.2"
  8 | source = "registry+https://github.com/rust-lang/crates.io-index"
  9 | checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 10 | 
 11 | [[package]]
 12 | name = "cc"
 13 | version = "1.0.72"
 14 | source = "registry+https://github.com/rust-lang/crates.io-index"
 15 | checksum = "22a9137b95ea06864e018375b72adfb7db6e6f68cfc8df5a04d00288050485ee"
 16 | dependencies = [
 17 |  "jobserver",
 18 | ]
 19 | 
 20 | [[package]]
 21 | name = "cfg-if"
 22 | version = "1.0.0"
 23 | source = "registry+https://github.com/rust-lang/crates.io-index"
 24 | checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 25 | 
 26 | [[package]]
 27 | name = "cfg_table"
 28 | version = "1.0.0"
 29 | source = "registry+https://github.com/rust-lang/crates.io-index"
 30 | checksum = "78518bef4e5cc70a69a0bd1905594f8033b2f7492c9d7c0f173208c0945c30a2"
 31 | 
 32 | [[package]]
 33 | name = "codespan-reporting"
 34 | version = "0.11.1"
 35 | source = "registry+https://github.com/rust-lang/crates.io-index"
 36 | checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e"
 37 | dependencies = [
 38 |  "termcolor",
 39 |  "unicode-width",
 40 | ]
 41 | 
 42 | [[package]]
 43 | name = "cstr"
 44 | version = "0.2.9"
 45 | source = "registry+https://github.com/rust-lang/crates.io-index"
 46 | checksum = "f2846d3636dcaff720d311ea8983f5fa7a8288632b2f95145dd4b5819c397fd8"
 47 | dependencies = [
 48 |  "proc-macro2",
 49 |  "quote",
 50 | ]
 51 | 
 52 | [[package]]
 53 | name = "ctor"
 54 | version = "0.1.21"
 55 | source = "registry+https://github.com/rust-lang/crates.io-index"
 56 | checksum = "ccc0a48a9b826acdf4028595adc9db92caea352f7af011a3034acd172a52a0aa"
 57 | dependencies = [
 58 |  "quote",
 59 |  "syn",
 60 | ]
 61 | 
 62 | [[package]]
 63 | name = "cxx"
 64 | version = "1.0.63"
 65 | source = "registry+https://github.com/rust-lang/crates.io-index"
 66 | checksum = "c949f4e2576a655698463c56dbc5c5ea4c00964becc9adb0458baa943e862a5b"
 67 | dependencies = [
 68 |  "cc",
 69 |  "cxxbridge-flags",
 70 |  "cxxbridge-macro",
 71 |  "link-cplusplus",
 72 | ]
 73 | 
 74 | [[package]]
 75 | name = "cxx-build"
 76 | version = "1.0.63"
 77 | source = "registry+https://github.com/rust-lang/crates.io-index"
 78 | checksum = "618f85c8f132bd8912aab124e15a38adc762bb7e3cef84524adde1692ef3e8bc"
 79 | dependencies = [
 80 |  "cc",
 81 |  "codespan-reporting",
 82 |  "once_cell",
 83 |  "proc-macro2",
 84 |  "quote",
 85 |  "scratch",
 86 |  "syn",
 87 | ]
 88 | 
 89 | [[package]]
 90 | name = "cxxbridge-flags"
 91 | version = "1.0.63"
 92 | source = "registry+https://github.com/rust-lang/crates.io-index"
 93 | checksum = "1b44dad556b0c83d86676135d6c684bdc2b1b9a1188052dd1cb5998246163536"
 94 | 
 95 | [[package]]
 96 | name = "cxxbridge-macro"
 97 | version = "1.0.63"
 98 | source = "registry+https://github.com/rust-lang/crates.io-index"
 99 | checksum = "2acc9305a8b69bc2308c2e17dbb98debeac984cdc89ac550c01507cc129433c3"
100 | dependencies = [
101 |  "proc-macro2",
102 |  "quote",
103 |  "syn",
104 | ]
105 | 
106 | [[package]]
107 | name = "detour"
108 | version = "0.8.1"
109 | source = "registry+https://github.com/rust-lang/crates.io-index"
110 | checksum = "f3c83fabcc3bc336e19320c13576ea708a15deec201d6b879b7ad1b92734d7b9"
111 | dependencies = [
112 |  "cfg-if",
113 |  "generic-array",
114 |  "lazy_static",
115 |  "libc",
116 |  "libudis86-sys",
117 |  "mmap-fixed",
118 |  "region",
119 |  "slice-pool",
120 | ]
121 | 
122 | [[package]]
123 | name = "fn_abi"
124 | version = "2.0.1"
125 | source = "registry+https://github.com/rust-lang/crates.io-index"
126 | checksum = "451b828bd3c5f19949222834f58b38c3670604dcaa5f2b7aec50c0cd58f34900"
127 | dependencies = [
128 |  "proc-macro2",
129 |  "quote",
130 |  "syn",
131 |  "syn_squash",
132 | ]
133 | 
134 | [[package]]
135 | name = "fn_has_this"
136 | version = "0.1.1"
137 | source = "registry+https://github.com/rust-lang/crates.io-index"
138 | checksum = "eb93938067213676967092012a53515e926de7c813afccd9b075ba0ec78dbba9"
139 | dependencies = [
140 |  "proc-macro2",
141 |  "quote",
142 |  "syn",
143 |  "syn_squash",
144 | ]
145 | 
146 | [[package]]
147 | name = "fn_type_alias"
148 | version = "0.1.0"
149 | source = "registry+https://github.com/rust-lang/crates.io-index"
150 | checksum = "809e807f01217f1f89959fbeebd10c6471b5ef3971fce1b02a70fb7212cc6c1f"
151 | dependencies = [
152 |  "proc-macro2",
153 |  "quote",
154 |  "syn",
155 | ]
156 | 
157 | [[package]]
158 | name = "generic-array"
159 | version = "0.14.4"
160 | source = "registry+https://github.com/rust-lang/crates.io-index"
161 | checksum = "501466ecc8a30d1d3b7fc9229b122b2ce8ed6e9d9223f1138d4babb253e51817"
162 | dependencies = [
163 |  "typenum",
164 |  "version_check",
165 | ]
166 | 
167 | [[package]]
168 | name = "gm_microoptimisation_war_crime"
169 | version = "2.0.0"
170 | dependencies = [
171 |  "cxx",
172 |  "cxx-build",
173 |  "gmod 14.0.0",
174 |  "gmserverplugin",
175 |  "magic_static",
176 |  "pcre2",
177 | ]
178 | 
179 | [[package]]
180 | name = "gmod"
181 | version = "12.0.1"
182 | source = "registry+https://github.com/rust-lang/crates.io-index"
183 | checksum = "a3573d8d390480fc201b868996f348812fda75351ffd12efc140a1df3459a944"
184 | dependencies = [
185 |  "cfg_table",
186 |  "cstr",
187 |  "ctor",
188 |  "detour",
189 |  "fn_abi",
190 |  "fn_has_this",
191 |  "fn_type_alias",
192 |  "gmod-macros 2.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
193 |  "lazy_static",
194 |  "libloading",
195 |  "null_fn",
196 |  "skidscan",
197 | ]
198 | 
199 | [[package]]
200 | name = "gmod"
201 | version = "14.0.0"
202 | dependencies = [
203 |  "cfg_table",
204 |  "cstr",
205 |  "ctor",
206 |  "detour",
207 |  "fn_abi",
208 |  "fn_has_this",
209 |  "fn_type_alias",
210 |  "gmod-macros 2.0.1",
211 |  "lazy_static",
212 |  "libloading",
213 |  "null_fn",
214 |  "skidscan",
215 | ]
216 | 
217 | [[package]]
218 | name = "gmod-macros"
219 | version = "2.0.1"
220 | dependencies = [
221 |  "proc-macro2",
222 |  "quote",
223 |  "syn",
224 | ]
225 | 
226 | [[package]]
227 | name = "gmod-macros"
228 | version = "2.0.1"
229 | source = "registry+https://github.com/rust-lang/crates.io-index"
230 | checksum = "4f379e64e2b37dc89becb8ac4e1a67211a1a8989b866a71d8365dc16459224a8"
231 | dependencies = [
232 |  "proc-macro2",
233 |  "quote",
234 |  "syn",
235 | ]
236 | 
237 | [[package]]
238 | name = "gmserverplugin"
239 | version = "2.0.0"
240 | dependencies = [
241 |  "gmod 12.0.1",
242 | ]
243 | 
244 | [[package]]
245 | name = "jobserver"
246 | version = "0.1.24"
247 | source = "registry+https://github.com/rust-lang/crates.io-index"
248 | checksum = "af25a77299a7f711a01975c35a6a424eb6862092cc2d6c72c4ed6cbc56dfc1fa"
249 | dependencies = [
250 |  "libc",
251 | ]
252 | 
253 | [[package]]
254 | name = "kernel32-sys"
255 | version = "0.2.2"
256 | source = "registry+https://github.com/rust-lang/crates.io-index"
257 | checksum = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
258 | dependencies = [
259 |  "winapi 0.2.8",
260 |  "winapi-build",
261 | ]
262 | 
263 | [[package]]
264 | name = "lazy_static"
265 | version = "1.4.0"
266 | source = "registry+https://github.com/rust-lang/crates.io-index"
267 | checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
268 | 
269 | [[package]]
270 | name = "libc"
271 | version = "0.2.112"
272 | source = "registry+https://github.com/rust-lang/crates.io-index"
273 | checksum = "1b03d17f364a3a042d5e5d46b053bbbf82c92c9430c592dd4c064dc6ee997125"
274 | 
275 | [[package]]
276 | name = "libloading"
277 | version = "0.7.2"
278 | source = "registry+https://github.com/rust-lang/crates.io-index"
279 | checksum = "afe203d669ec979b7128619bae5a63b7b42e9203c1b29146079ee05e2f604b52"
280 | dependencies = [
281 |  "cfg-if",
282 |  "winapi 0.3.9",
283 | ]
284 | 
285 | [[package]]
286 | name = "libudis86-sys"
287 | version = "0.2.1"
288 | source = "registry+https://github.com/rust-lang/crates.io-index"
289 | checksum = "139bbf9ddb1bfc90c1ac64dd2923d9c957cd433cee7315c018125d72ab08a6b0"
290 | dependencies = [
291 |  "cc",
292 |  "libc",
293 | ]
294 | 
295 | [[package]]
296 | name = "link-cplusplus"
297 | version = "1.0.6"
298 | source = "registry+https://github.com/rust-lang/crates.io-index"
299 | checksum = "f8cae2cd7ba2f3f63938b9c724475dfb7b9861b545a90324476324ed21dbc8c8"
300 | dependencies = [
301 |  "cc",
302 | ]
303 | 
304 | [[package]]
305 | name = "log"
306 | version = "0.4.14"
307 | source = "registry+https://github.com/rust-lang/crates.io-index"
308 | checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
309 | dependencies = [
310 |  "cfg-if",
311 | ]
312 | 
313 | [[package]]
314 | name = "mach"
315 | version = "0.3.2"
316 | source = "registry+https://github.com/rust-lang/crates.io-index"
317 | checksum = "b823e83b2affd8f40a9ee8c29dbc56404c1e34cd2710921f2801e2cf29527afa"
318 | dependencies = [
319 |  "libc",
320 | ]
321 | 
322 | [[package]]
323 | name = "magic_static"
324 | version = "3.0.1"
325 | source = "registry+https://github.com/rust-lang/crates.io-index"
326 | checksum = "be35a45e22cf0d68f744113a08723a258ea30ea95ac88c1faaf5199c0b21b305"
327 | dependencies = [
328 |  "magic_static_macro",
329 | ]
330 | 
331 | [[package]]
332 | name = "magic_static_macro"
333 | version = "3.0.0"
334 | source = "registry+https://github.com/rust-lang/crates.io-index"
335 | checksum = "a98ec7012afce91a937be58d850372ca42a62cf56238704da2ee72f2e6745fe7"
336 | dependencies = [
337 |  "quote",
338 |  "syn",
339 | ]
340 | 
341 | [[package]]
342 | name = "mmap-fixed"
343 | version = "0.1.5"
344 | source = "registry+https://github.com/rust-lang/crates.io-index"
345 | checksum = "27c1ae264d6343d3b4079549f6bc9e6d074dc4106cb1324c7753c6ce11d07b21"
346 | dependencies = [
347 |  "kernel32-sys",
348 |  "libc",
349 |  "winapi 0.2.8",
350 | ]
351 | 
352 | [[package]]
353 | name = "null_fn"
354 | version = "0.1.1"
355 | source = "registry+https://github.com/rust-lang/crates.io-index"
356 | checksum = "345919cfb52d0d8da7efc21aea56046ca96d9e3a8adfdbdb27ef1172829976c1"
357 | dependencies = [
358 |  "proc-macro2",
359 |  "quote",
360 |  "syn",
361 | ]
362 | 
363 | [[package]]
364 | name = "once_cell"
365 | version = "1.9.0"
366 | source = "registry+https://github.com/rust-lang/crates.io-index"
367 | checksum = "da32515d9f6e6e489d7bc9d84c71b060db7247dc035bbe44eac88cf87486d8d5"
368 | 
369 | [[package]]
370 | name = "pcre2"
371 | version = "0.2.3"
372 | source = "registry+https://github.com/rust-lang/crates.io-index"
373 | checksum = "85b30f2f69903b439dd9dc9e824119b82a55bf113b29af8d70948a03c1b11ab1"
374 | dependencies = [
375 |  "libc",
376 |  "log",
377 |  "pcre2-sys",
378 |  "thread_local",
379 | ]
380 | 
381 | [[package]]
382 | name = "pcre2-sys"
383 | version = "0.2.5"
384 | source = "registry+https://github.com/rust-lang/crates.io-index"
385 | checksum = "dec30e5e9ec37eb8fbf1dea5989bc957fd3df56fbee5061aa7b7a99dbb37b722"
386 | dependencies = [
387 |  "cc",
388 |  "libc",
389 |  "pkg-config",
390 | ]
391 | 
392 | [[package]]
393 | name = "pkg-config"
394 | version = "0.3.24"
395 | source = "registry+https://github.com/rust-lang/crates.io-index"
396 | checksum = "58893f751c9b0412871a09abd62ecd2a00298c6c83befa223ef98c52aef40cbe"
397 | 
398 | [[package]]
399 | name = "proc-macro-crate"
400 | version = "1.1.0"
401 | source = "registry+https://github.com/rust-lang/crates.io-index"
402 | checksum = "1ebace6889caf889b4d3f76becee12e90353f2b8c7d875534a71e5742f8f6f83"
403 | dependencies = [
404 |  "thiserror",
405 |  "toml",
406 | ]
407 | 
408 | [[package]]
409 | name = "proc-macro2"
410 | version = "1.0.36"
411 | source = "registry+https://github.com/rust-lang/crates.io-index"
412 | checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029"
413 | dependencies = [
414 |  "unicode-xid",
415 | ]
416 | 
417 | [[package]]
418 | name = "quote"
419 | version = "1.0.14"
420 | source = "registry+https://github.com/rust-lang/crates.io-index"
421 | checksum = "47aa80447ce4daf1717500037052af176af5d38cc3e571d9ec1c7353fc10c87d"
422 | dependencies = [
423 |  "proc-macro2",
424 | ]
425 | 
426 | [[package]]
427 | name = "region"
428 | version = "2.2.0"
429 | source = "registry+https://github.com/rust-lang/crates.io-index"
430 | checksum = "877e54ea2adcd70d80e9179344c97f93ef0dffd6b03e1f4529e6e83ab2fa9ae0"
431 | dependencies = [
432 |  "bitflags",
433 |  "libc",
434 |  "mach",
435 |  "winapi 0.3.9",
436 | ]
437 | 
438 | [[package]]
439 | name = "scratch"
440 | version = "1.0.1"
441 | source = "registry+https://github.com/rust-lang/crates.io-index"
442 | checksum = "96311ef4a16462c757bb6a39152c40f58f31cd2602a40fceb937e2bc34e6cbab"
443 | 
444 | [[package]]
445 | name = "serde"
446 | version = "1.0.133"
447 | source = "registry+https://github.com/rust-lang/crates.io-index"
448 | checksum = "97565067517b60e2d1ea8b268e59ce036de907ac523ad83a0475da04e818989a"
449 | 
450 | [[package]]
451 | name = "skidscan"
452 | version = "2.0.0"
453 | source = "registry+https://github.com/rust-lang/crates.io-index"
454 | checksum = "60c2b7c0d9358c69c16b05037d80ffc810655ea7a2625beeb8af8a8b37126768"
455 | dependencies = [
456 |  "libc",
457 |  "skidscan-macros",
458 |  "winapi 0.3.9",
459 | ]
460 | 
461 | [[package]]
462 | name = "skidscan-macros"
463 | version = "0.1.2"
464 | source = "registry+https://github.com/rust-lang/crates.io-index"
465 | checksum = "881ef2150f0e4e2a855bb661a3ecd621ab1b6aa07b34aef941d1bd37b4267e8d"
466 | dependencies = [
467 |  "proc-macro-crate",
468 |  "syn",
469 | ]
470 | 
471 | [[package]]
472 | name = "slice-pool"
473 | version = "0.4.1"
474 | source = "registry+https://github.com/rust-lang/crates.io-index"
475 | checksum = "733fc6e5f1bd3a8136f842c9bdea4e5f17c910c2fcc98c90c3aa7604ef5e2e7a"
476 | 
477 | [[package]]
478 | name = "syn"
479 | version = "1.0.84"
480 | source = "registry+https://github.com/rust-lang/crates.io-index"
481 | checksum = "ecb2e6da8ee5eb9a61068762a32fa9619cc591ceb055b3687f4cd4051ec2e06b"
482 | dependencies = [
483 |  "proc-macro2",
484 |  "quote",
485 |  "unicode-xid",
486 | ]
487 | 
488 | [[package]]
489 | name = "syn_squash"
490 | version = "0.1.0"
491 | source = "registry+https://github.com/rust-lang/crates.io-index"
492 | checksum = "134b985708d02b2569ab2b9e27c8758ca4baaaf725341a572d59bc2d174b9bb5"
493 | 
494 | [[package]]
495 | name = "termcolor"
496 | version = "1.1.2"
497 | source = "registry+https://github.com/rust-lang/crates.io-index"
498 | checksum = "2dfed899f0eb03f32ee8c6a0aabdb8a7949659e3466561fc0adf54e26d88c5f4"
499 | dependencies = [
500 |  "winapi-util",
501 | ]
502 | 
503 | [[package]]
504 | name = "thiserror"
505 | version = "1.0.30"
506 | source = "registry+https://github.com/rust-lang/crates.io-index"
507 | checksum = "854babe52e4df1653706b98fcfc05843010039b406875930a70e4d9644e5c417"
508 | dependencies = [
509 |  "thiserror-impl",
510 | ]
511 | 
512 | [[package]]
513 | name = "thiserror-impl"
514 | version = "1.0.30"
515 | source = "registry+https://github.com/rust-lang/crates.io-index"
516 | checksum = "aa32fd3f627f367fe16f893e2597ae3c05020f8bba2666a4e6ea73d377e5714b"
517 | dependencies = [
518 |  "proc-macro2",
519 |  "quote",
520 |  "syn",
521 | ]
522 | 
523 | [[package]]
524 | name = "thread_local"
525 | version = "1.1.3"
526 | source = "registry+https://github.com/rust-lang/crates.io-index"
527 | checksum = "8018d24e04c95ac8790716a5987d0fec4f8b27249ffa0f7d33f1369bdfb88cbd"
528 | dependencies = [
529 |  "once_cell",
530 | ]
531 | 
532 | [[package]]
533 | name = "toml"
534 | version = "0.5.8"
535 | source = "registry+https://github.com/rust-lang/crates.io-index"
536 | checksum = "a31142970826733df8241ef35dc040ef98c679ab14d7c3e54d827099b3acecaa"
537 | dependencies = [
538 |  "serde",
539 | ]
540 | 
541 | [[package]]
542 | name = "typenum"
543 | version = "1.15.0"
544 | source = "registry+https://github.com/rust-lang/crates.io-index"
545 | checksum = "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987"
546 | 
547 | [[package]]
548 | name = "unicode-width"
549 | version = "0.1.9"
550 | source = "registry+https://github.com/rust-lang/crates.io-index"
551 | checksum = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973"
552 | 
553 | [[package]]
554 | name = "unicode-xid"
555 | version = "0.2.2"
556 | source = "registry+https://github.com/rust-lang/crates.io-index"
557 | checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
558 | 
559 | [[package]]
560 | name = "version_check"
561 | version = "0.9.4"
562 | source = "registry+https://github.com/rust-lang/crates.io-index"
563 | checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
564 | 
565 | [[package]]
566 | name = "winapi"
567 | version = "0.2.8"
568 | source = "registry+https://github.com/rust-lang/crates.io-index"
569 | checksum = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
570 | 
571 | [[package]]
572 | name = "winapi"
573 | version = "0.3.9"
574 | source = "registry+https://github.com/rust-lang/crates.io-index"
575 | checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
576 | dependencies = [
577 |  "winapi-i686-pc-windows-gnu",
578 |  "winapi-x86_64-pc-windows-gnu",
579 | ]
580 | 
581 | [[package]]
582 | name = "winapi-build"
583 | version = "0.1.1"
584 | source = "registry+https://github.com/rust-lang/crates.io-index"
585 | checksum = "2d315eee3b34aca4797b2da6b13ed88266e6d612562a0c46390af8299fc699bc"
586 | 
587 | [[package]]
588 | name = "winapi-i686-pc-windows-gnu"
589 | version = "0.4.0"
590 | source = "registry+https://github.com/rust-lang/crates.io-index"
591 | checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
592 | 
593 | [[package]]
594 | name = "winapi-util"
595 | version = "0.1.5"
596 | source = "registry+https://github.com/rust-lang/crates.io-index"
597 | checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
598 | dependencies = [
599 |  "winapi 0.3.9",
600 | ]
601 | 
602 | [[package]]
603 | name = "winapi-x86_64-pc-windows-gnu"
604 | version = "0.4.0"
605 | source = "registry+https://github.com/rust-lang/crates.io-index"
606 | checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
607 | 


--------------------------------------------------------------------------------