├── External
    └── src
    │   ├── common.cpp
    │   ├── pointers.hpp
    │   ├── pointer.hpp
    │   ├── file_manager
    │       ├── file.hpp
    │       ├── folder.hpp
    │       ├── folder.cpp
    │       └── file.cpp
    │   ├── pointers.cpp
    │   ├── script_loader.hpp
    │   ├── pattern.hpp
    │   ├── common.hpp
    │   ├── ysc_file.hpp
    │   ├── rage
    │       ├── joaat.hpp
    │       ├── natives.hpp
    │       ├── script_program.hpp
    │       └── script_thread.hpp
    │   ├── file_manager.hpp
    │   ├── main.cpp
    │   ├── process.hpp
    │   ├── pattern.cpp
    │   ├── ysc_file.cpp
    │   ├── script_loader.cpp
    │   └── logger.hpp
├── modmenu.ysc
├── helloworld.ysc
├── GenerateProjects.bat
├── .gitmodules
├── README.md
├── premake5.lua
├── .gitignore
└── JITYSC
    └── src
        └── ysc.hpp


/External/src/common.cpp:
--------------------------------------------------------------------------------
1 | #include "common.hpp"
2 | 


--------------------------------------------------------------------------------
/modmenu.ysc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/maybegreat48/External/HEAD/modmenu.ysc


--------------------------------------------------------------------------------
/helloworld.ysc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/maybegreat48/External/HEAD/helloworld.ysc


--------------------------------------------------------------------------------
/GenerateProjects.bat:
--------------------------------------------------------------------------------
1 | @echo off
2 | premake5 vs2019
3 | IF %ERRORLEVEL% NEQ 0 (
4 |   PAUSE
5 | )
6 | 


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "g3log"]
2 | 	path = g3log
3 | 	url = https://github.com/KjellKod/g3log.git
4 | [submodule "json"]
5 | 	path = json
6 | 	url = https://github.com/nlohmann/json
7 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # External
2 | A POC for loading RAGE script files externally
3 | 
4 | Also see my version of [SC-CL](https://github.com/maybegreat48/SC-CL) which can be used to make RAGE script files
5 | 


--------------------------------------------------------------------------------
/External/src/pointers.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "pointer.hpp"
 3 | 
 4 | namespace ext
 5 | {
 6 | 	class pointers
 7 | 	{
 8 | 	public:
 9 | 		explicit pointers();
10 | 		~pointers();
11 | 	public:
12 | 		pointer<bool> m_is_session_started;
13 | 		pointer<uint64_t> m_script_threads;
14 | 		pointer<uint64_t> m_script_program_table;
15 | 		pointer<uint64_t> m_native_registration_table;
16 | 		pointer<PVOID> m_ret_true_function;
17 | 	};
18 | 
19 | 	inline pointers* g_pointers;
20 | }


--------------------------------------------------------------------------------
/External/src/pointer.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "process.hpp"
 3 | 
 4 | namespace ext 
 5 | {
 6 | 	template <typename T>
 7 | 	class pointer
 8 | 	{
 9 | 		std::uint64_t address;
10 | 	public:
11 | 		inline pointer(std::uint64_t address) :
12 | 			address(address)
13 | 		{
14 | 		}
15 | 
16 | 		inline T operator*() const
17 | 		{
18 | 			return g_process->read<T>(address);
19 | 		}
20 | 
21 | 		inline operator uint64_t() const
22 | 		{
23 | 			return address;
24 | 		}
25 | 	};
26 | }


--------------------------------------------------------------------------------
/External/src/file_manager/file.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | namespace ext
 4 | {
 5 | 	class file_manager;
 6 | 
 7 | 	class file
 8 | 	{
 9 | 	public:
10 | 
11 | 		file(std::filesystem::path file_path);
12 | 
13 | 		file copy(std::filesystem::path new_path);
14 | 		bool exists() const;
15 | 		const std::filesystem::path get_path() const;
16 | 		file move(std::filesystem::path new_path);
17 | 
18 | 	protected:
19 | 		file(file_manager* file_manager, std::filesystem::path file_path);
20 | 
21 | 	private:
22 | 		friend class file_manager;
23 | 
24 | 		bool m_is_project_file;
25 | 		std::filesystem::path m_file_path;
26 | 
27 | 	};
28 | }


--------------------------------------------------------------------------------
/External/src/file_manager/folder.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | namespace ext
 4 | {
 5 | 	class file;
 6 | 	class file_manager;
 7 | 
 8 | 	class folder
 9 | 	{
10 | 
11 | 	public:
12 | 		folder(std::filesystem::path folder_path);
13 | 
14 | 		file get_file(std::filesystem::path file_path) const;
15 | 		const std::filesystem::path get_path() const;
16 | 
17 | 	protected:
18 | 		folder(file_manager* file_manager, std::filesystem::path file_path);
19 | 
20 | 	private:
21 | 
22 | 		friend class file_manager;
23 | 		file_manager* m_file_manager;
24 | 
25 | 		bool m_is_project_file;
26 | 
27 | 		std::filesystem::path m_folder_path;
28 | 
29 | 	};
30 | }


--------------------------------------------------------------------------------
/External/src/pointers.cpp:
--------------------------------------------------------------------------------
 1 | #include "pointers.hpp"
 2 | #include "pattern.hpp"
 3 | 
 4 | namespace ext
 5 | {
 6 | 	pointers::pointers() :
 7 | 		m_is_session_started(pattern("ISA", "40 38 35 ? ? ? ? 75 0E 4C 8B C3 49 8B D7 49 8B CE").add(3).rip()),
 8 | 		m_script_threads(pattern("ST", "45 33 F6 8B E9 85 C9 B8").sub(4).rip().sub(8)),
 9 | 		m_script_program_table(pattern("SP", "44 8B 0D ? ? ? ? 4C 8B 1D ? ? ? ? 48 8B 1D ? ? ? ? 41 83 F8 FF 74 3F 49 63 C0 42 0F B6 0C 18 81 E1").add(17).rip()),
10 | 		m_native_registration_table(pattern("NH", "48 8D 0D ? ? ? ? 48 8B 14 FA E8 ? ? ? ? 48 85 C0 75 0A").add(3).rip()),
11 | 		m_ret_true_function(pattern("RT", "B0 01 C3"))
12 | 	{
13 | 		g_pointers = this;
14 | 	}
15 | 
16 | 	pointers::~pointers()
17 | 	{
18 | 		g_pointers = nullptr;
19 | 	}
20 | }


--------------------------------------------------------------------------------
/External/src/script_loader.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "pointers.hpp"
 3 | #include "rage/script_thread.hpp"
 4 | #include "rage/script_program.hpp"
 5 | #include "rage/natives.hpp"
 6 | #include <commdlg.h>
 7 | 
 8 | namespace ext
 9 | {
10 | 	class script_loader
11 | 	{
12 | 		std::map<uint64_t, uint64_t> m_handler_cache{};
13 | 		rage::scrNativeRegistrationTable m_native_registration;
14 | 		rage::joaat_t m_required_script;
15 | 		rage::scrThread m_thread{0};
16 | 		rage::scrProgram m_program{0};
17 | 		std::uint64_t m_fake_vft;
18 | 		OPENFILENAMEA m_ofn;
19 | 		char m_file_name[260]{};
20 | 
21 | 	public:
22 | 		script_loader();
23 | 		~script_loader();
24 | 
25 | 		void find_thread();
26 | 		void pick_script();
27 | 		void initalize_thread();
28 | 	};
29 | 
30 | 	inline script_loader* g_script_loader;
31 | }


--------------------------------------------------------------------------------
/External/src/file_manager/folder.cpp:
--------------------------------------------------------------------------------
 1 | #include "file_manager.hpp"
 2 | #include "folder.hpp"
 3 | 
 4 | namespace ext
 5 | {
 6 | 	folder::folder(file_manager* file_manager, std::filesystem::path file_path)
 7 | 		: folder(file_manager->get_base_dir() / file_path)
 8 | 	{
 9 | 		m_file_manager = file_manager;
10 | 		m_is_project_file = true;
11 | 	}
12 | 
13 | 	folder::folder(std::filesystem::path folder_path)
14 | 		: m_folder_path(file_manager::ensure_folder_exists(folder_path))
15 | 	{
16 | 
17 | 	}
18 | 
19 | 	file folder::get_file(std::filesystem::path file_path) const
20 | 	{
21 | 		if (file_path.is_absolute())
22 | 			throw std::exception("folder#get_file requires a relative path.");
23 | 
24 | 		return file(
25 | 			m_folder_path / file_path
26 | 		);
27 | 	}
28 | 
29 | 	const std::filesystem::path folder::get_path() const
30 | 	{
31 | 		return m_folder_path;
32 | 	}
33 | }


--------------------------------------------------------------------------------
/External/src/pattern.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "process.hpp"
 3 | #define CHUNK_SIZE 0x1000
 4 | 
 5 | namespace ext {
 6 | 
 7 | 	class pattern {
 8 | 		std::vector<std::optional<uint8_t>> compiled;
 9 | 		std::string name;
10 | 		uintptr_t   address = 0;
11 | 
12 | 	public:
13 | 		inline pattern(std::string name, std::string x) :
14 | 			name(name)
15 | 		{
16 | 			compile(x);
17 | 			scan();
18 | 		}
19 | 
20 | 		inline pattern(std::string name_, uintptr_t addr) {
21 | 			name = name_;
22 | 			address = addr;
23 | 		}
24 | 
25 | 		void compile(const std::string& pat);
26 | 
27 | 		pattern& scan();
28 | 
29 | 		inline pattern add(size_t n) {
30 | 			return pattern(name, address + n);
31 | 		}
32 | 
33 | 		inline pattern sub(size_t n) {
34 | 			return pattern(name, address - n);
35 | 		}
36 | 
37 | 		pattern rip();
38 | 
39 | 		inline operator std::uint64_t() const
40 | 		{
41 | 			return address;
42 | 		}
43 | 	};
44 | };


--------------------------------------------------------------------------------
/External/src/common.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #define DISABLE_VECTORED_EXCEPTIONHANDLING
 4 | 
 5 | #include <iostream>
 6 | #include <vector>
 7 | #include <array>
 8 | #include <map>
 9 | #include <chrono>
10 | #include <list>
11 | 
12 | #include <filesystem>
13 | #include <fstream>
14 | #include <iostream>
15 | #include <iomanip>
16 | 
17 | #include <thread>
18 | 
19 | #include <Windows.h>
20 | 
21 | #include <Psapi.h>
22 | 
23 | #pragma comment(lib, "psapi.lib")
24 | 
25 | #include "logger.hpp"
26 | 
27 | namespace std
28 | {
29 | 	template <class T, template <class...> class Template>
30 | 	struct is_specialization : std::false_type {};
31 | 
32 | 	template <template <class...> class Template, class... Args>
33 | 	struct is_specialization<Template<Args...>, Template> : std::true_type {};
34 | }
35 | 
36 | namespace ext 
37 | {
38 | 	using namespace std::chrono_literals;
39 | 
40 | 	inline std::atomic_bool g_running{ true };
41 | }


--------------------------------------------------------------------------------
/External/src/file_manager/file.cpp:
--------------------------------------------------------------------------------
 1 | #include "common.hpp"
 2 | #include "file.hpp"
 3 | #include "file_manager.hpp"
 4 | 
 5 | namespace ext
 6 | {
 7 | 	file::file(file_manager* file_manager, std::filesystem::path file_path)
 8 | 		: file(file_manager->get_base_dir() / file_path)
 9 | 	{
10 | 		m_is_project_file = true;
11 | 	}
12 | 
13 | 	file::file(std::filesystem::path file_path)
14 | 		: m_file_path(file_manager::ensure_file_can_be_created(file_path)), m_is_project_file(false)
15 | 	{
16 | 
17 | 	}
18 | 
19 | 	bool file::exists() const
20 | 	{
21 | 		return std::filesystem::exists(m_file_path);
22 | 	}
23 | 
24 | 	const std::filesystem::path file::get_path() const
25 | 	{
26 | 		return m_file_path;
27 | 	}
28 | 
29 | 	file file::move(std::filesystem::path new_path)
30 | 	{
31 | 		if (new_path.is_relative())
32 | 			new_path = m_file_path.parent_path() / new_path;
33 | 
34 | 		file_manager::ensure_file_can_be_created(new_path);
35 | 
36 | 		if (std::filesystem::exists(m_file_path))
37 | 			std::filesystem::rename(m_file_path, new_path);
38 | 
39 | 		return { new_path };
40 | 	}
41 | }


--------------------------------------------------------------------------------
/External/src/ysc_file.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "rage/joaat.hpp"
 3 | 
 4 | namespace ext
 5 | {
 6 | 	class ysc_file
 7 | 	{
 8 | 		std::ifstream m_file;
 9 | 
10 | 		inline void fix_pointer(std::uint64_t& ptr)
11 | 		{
12 | 			ptr &= 0xFFFFFF;
13 | 		}
14 | 
15 | 		inline void rotl(std::uint64_t& hash, int rotate)
16 | 		{
17 | 			rotate %= 64;
18 | 			hash = (hash << rotate | hash >> (64 - rotate));
19 | 		}
20 | 
21 | 	public:
22 | 		std::vector<uint8_t*> m_code_block_list{};
23 | 		std::vector<uint8_t*> m_string_block_list{};
24 | 		std::vector<uint64_t> m_natives{};
25 | 		rage::joaat_t m_name_hash;
26 | 		char m_name[0x40];
27 | 		uint64_t* m_statics = nullptr;
28 | 		uint64_t m_code_page_list_offset;
29 | 		uint64_t m_strings_list_offset;
30 | 		uint64_t m_statics_offset;
31 | 		uint64_t m_natives_list_offset;
32 | 		uint64_t m_script_name_offset;
33 | 		uint32_t m_code_length;
34 | 		uint32_t m_script_parameter_count;
35 | 		uint32_t m_static_count;
36 | 		uint32_t m_global_count;
37 | 		uint32_t m_natives_count;
38 | 		uint32_t m_string_size;
39 | 
40 | 		uint32_t m_code_blocks;
41 | 		uint32_t m_string_blocks;
42 | 
43 | 		ysc_file(const std::filesystem::path& filename);
44 | 		~ysc_file();
45 | 	};
46 | }


--------------------------------------------------------------------------------
/External/src/rage/joaat.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <cstddef>
 3 | #include <cstdint>
 4 | #include <string_view>
 5 | #include <type_traits>
 6 | #include <span>
 7 | 
 8 | namespace rage
 9 | {
10 | 	using joaat_t = std::uint32_t;
11 | 
12 | 	inline constexpr char joaat_to_lower(char c)
13 | 	{
14 | 		return (c >= 'A' && c <= 'Z') ? c + ('a' - 'A') : c;
15 | 	}
16 | 
17 | 	inline constexpr joaat_t constexpr_joaat(const std::span<const char>& data)
18 | 	{
19 | 		joaat_t hash = 0;
20 | 
21 | 		for (std::size_t i = 0; i < data.size() - 1; ++i)
22 | 		{
23 | 			hash += joaat_to_lower(data[i]);
24 | 			hash += (hash << 10);
25 | 			hash ^= (hash >> 6);
26 | 		}
27 | 
28 | 		hash += (hash << 3);
29 | 		hash ^= (hash >> 11);
30 | 		hash += (hash << 15);
31 | 
32 | 		return hash;
33 | 	}
34 | 	static_assert(constexpr_joaat("test") == 0x3f75ccc1);
35 | 
36 | 	inline joaat_t joaat(std::string_view str)
37 | 	{
38 | 		joaat_t hash = 0;
39 | 
40 | 		for (char c : str)
41 | 		{
42 | 			hash += joaat_to_lower(c);
43 | 			hash += (hash << 10);
44 | 			hash ^= (hash >> 6);
45 | 		}
46 | 
47 | 		hash += (hash << 3);
48 | 		hash ^= (hash >> 11);
49 | 		hash += (hash << 15);
50 | 
51 | 		return hash;
52 | 	}
53 | 
54 | 	inline joaat_t joaat(const char* str)
55 | 	{
56 | 		joaat_t hash = 0;
57 | 
58 | 		while (*str)
59 | 		{
60 | 			hash += joaat_to_lower(*(str++));
61 | 			hash += (hash << 10);
62 | 			hash ^= (hash >> 6);
63 | 		}
64 | 
65 | 		hash += (hash << 3);
66 | 		hash ^= (hash >> 11);
67 | 		hash += (hash << 15);
68 | 
69 | 		return hash;
70 | 	}
71 | }
72 | 
73 | #define RAGE_JOAAT(str) std::integral_constant<std::uint32_t, rage::constexpr_joaat(str)>::value
74 | #define $(x) RAGE_JOAAT(#x)


--------------------------------------------------------------------------------
/External/src/file_manager.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "common.hpp"
 3 | #include "file_manager/file.hpp"
 4 | #include "file_manager/folder.hpp"
 5 | 
 6 | namespace ext
 7 | {
 8 | 	class file_manager;
 9 | 	inline file_manager* g_file_manager{};
10 | 
11 | 	class file_manager final
12 | 	{
13 | 	public:
14 | 
15 | 		file_manager(std::filesystem::path base_dir)
16 | 			: m_base_dir(base_dir)
17 | 		{
18 | 			file_manager::ensure_folder_exists(m_base_dir);
19 | 
20 | 			g_file_manager = this;
21 | 		}
22 | 		~file_manager()
23 | 		{
24 | 			g_file_manager = nullptr;
25 | 		}
26 | 
27 | 		std::filesystem::path get_base_dir()
28 | 		{
29 | 			return m_base_dir;
30 | 		}
31 | 
32 | 		file get_project_file(std::filesystem::path file_path)
33 | 		{
34 | 			if (file_path.is_absolute())
35 | 				throw std::exception("Project files are relative to the BaseDir, don't use absolute paths!");
36 | 
37 | 			return file(this, file_path);
38 | 		}
39 | 		folder get_project_folder(std::filesystem::path folder_path)
40 | 		{
41 | 			if (folder_path.is_absolute())
42 | 				throw std::exception("Project folders are relative to the BaseDir, don't use absolute paths!");
43 | 
44 | 			return folder(this, folder_path);
45 | 		}
46 | 
47 | 		static std::filesystem::path ensure_file_can_be_created(const std::filesystem::path file_path)
48 | 		{
49 | 			file_manager::ensure_folder_exists(file_path.parent_path());
50 | 
51 | 			return file_path;
52 | 		}
53 | 		static std::filesystem::path ensure_folder_exists(const std::filesystem::path folder_path)
54 | 		{
55 | 			bool create_path = !std::filesystem::exists(folder_path);
56 | 
57 | 			if (!create_path && !std::filesystem::is_directory(folder_path))
58 | 			{
59 | 				std::filesystem::remove(folder_path);
60 | 				create_path = true;
61 | 			}
62 | 			if (create_path)
63 | 				std::filesystem::create_directory(folder_path);
64 | 
65 | 			return folder_path;
66 | 		}
67 | 
68 | 	private:
69 | 		std::filesystem::path m_base_dir;
70 | 	};
71 | }


--------------------------------------------------------------------------------
/External/src/rage/natives.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "process.hpp"
 3 | 
 4 | namespace rage
 5 | {
 6 | 	// https://www.unknowncheats.me/forum/grand-theft-auto-v/473487-entry-dumper-gta5.html
 7 | 	// https://www.unknowncheats.me/forum/3036413-post862.html
 8 | 
 9 | 	class scrNativeRegistrationTable
10 | 	{
11 | 		template<typename T>
12 | 		struct Enc {
13 | 		private:
14 | 			uint32_t a{};
15 | 			uint32_t b{};
16 | 			uint32_t c{};
17 | 			uint8_t _pad[4]{};
18 | 
19 | 		public:
20 | 			[[nodiscard]] inline T decrypt(uint64_t _this) const 
21 | 			{
22 | 				auto const nonce = _this ^ c;
23 | 				auto const value = static_cast<uint32_t>(nonce ^ a) | (nonce ^ b) << 32u;
24 | 				if constexpr (std::is_integral_v<T>) {
25 | 					return value;
26 | 				}
27 | 				else {
28 | 					return reinterpret_cast<T>(value);
29 | 				}
30 | 			}
31 | 		};
32 | 
33 | 		struct NativeRegistration
34 | 		{
35 | 			Enc<uint64_t> next;
36 | 			uint64_t handlers[7]{};
37 | 			uint32_t numEntries1 = 0;
38 | 			uint32_t numEntries2 = 0;
39 | 			uint32_t pad = 0;
40 | 			std::array<Enc<uint64_t>, 7> hashes;
41 | 		};
42 | 
43 | 		std::uint64_t address;
44 | 	public:
45 | 		scrNativeRegistrationTable(std::uint64_t addr) :
46 | 			address(addr)
47 | 		{
48 | 
49 | 		}
50 | 
51 | 		inline std::uint64_t get_entrypoint_from_hash(std::uint64_t translated_hash)
52 | 		{
53 | 			for (size_t j = 0; j < 256; ++j) {
54 | 				size_t tableptr = ext::g_process->read<size_t>(address + 8 * j);
55 | 
56 | 				while (tableptr) {
57 | 					struct NativeRegistration entry{};
58 | 					ext::g_process->read<NativeRegistration>(tableptr, entry);
59 | 
60 | 					const uint32_t numEntries = entry.numEntries1 ^ entry.numEntries2 ^ uint32_t(tableptr + offsetof(NativeRegistration, numEntries1));
61 | 
62 | 					for (size_t i = 0; i < numEntries; i++) {
63 | 						const uint64_t entryHash = entry.hashes[i].decrypt(tableptr + 0x54 + (i * 0x10));
64 | 
65 | 						if (entryHash == translated_hash)
66 | 						{
67 | 							return entry.handlers[i];
68 | 						}
69 | 					}
70 | 					tableptr = entry.next.decrypt(tableptr);
71 | 				}
72 | 			}
73 | 
74 | 			LOG(WARNING) << "Cannot find handler for translated hash " << HEX_TO_UPPER(translated_hash);
75 | 		}
76 | 	};
77 | }


--------------------------------------------------------------------------------
/External/src/rage/script_program.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "pointers.hpp"
 3 | #include "joaat.hpp"
 4 | 
 5 | namespace rage
 6 | {
 7 | 	class scrProgram
 8 | 	{
 9 | 		std::uint64_t address;
10 | 	public:
11 | 		inline scrProgram(std::uint64_t addr) :
12 | 			address(addr)
13 | 		{
14 | 		}
15 | 
16 | 		inline bool valid() const
17 | 		{
18 | 			return address != 0;
19 | 		}
20 | 
21 | 		inline joaat_t get_hash() const
22 | 		{
23 | 			return ext::g_process->read<joaat_t>(address + 0x18);
24 | 		}
25 | 
26 | 		inline std::uint32_t get_num_statics() const
27 | 		{
28 | 			return ext::g_process->read<std::uint32_t>(address + 0x24);
29 | 		}
30 | 
31 | 		inline std::uint32_t get_code_size() const
32 | 		{
33 | 			return ext::g_process->read<std::uint32_t>(address + 0x1C);
34 | 		}
35 | 
36 | 		inline std::uint32_t get_string_size() const
37 | 		{
38 | 			return ext::g_process->read<std::uint32_t>(address + 0x70);
39 | 		}
40 | 
41 | 		inline std::uint32_t get_num_natives() const
42 | 		{
43 | 			return ext::g_process->read<std::uint32_t>(address + 0x2C);
44 | 		}
45 | 
46 | 		// for the internal debugger
47 | 		inline void mark_program_as_ours()
48 | 		{
49 | 			ext::g_process->write<std::uint32_t>(address + 0x28, 0x1337);
50 | 		}
51 | 
52 | 		inline std::uint64_t get_code_page(std::uint64_t index) const
53 | 		{
54 | 			return ext::g_process->read<std::uint64_t>(ext::g_process->read<std::uint64_t>(address + 0x10) + index * 8);
55 | 		}
56 | 
57 | 		inline std::uint64_t get_string_page(std::uint64_t index) const
58 | 		{
59 | 			return ext::g_process->read<std::uint64_t>(ext::g_process->read<std::uint64_t>(address + 0x68) + index * 8);
60 | 		}
61 | 
62 | 		inline std::uint64_t get_native_table() const
63 | 		{
64 | 			return ext::g_process->read<std::uint64_t>(address + 0x40);
65 | 		}
66 | 
67 | 		static inline scrProgram get_program_by_hash(joaat_t hash)
68 | 		{
69 | 			std::uint32_t programs = ext::g_process->read<std::uint32_t>(ext::g_pointers->m_script_program_table + 0x18);
70 | 			std::uint64_t program_list = ext::g_process->read<std::uint64_t>(ext::g_pointers->m_script_program_table);
71 | 
72 | 			for (int i = 0; i < programs; i++)
73 | 			{
74 | 				std::uint64_t program = ext::g_process->read<std::uint64_t>(program_list + (i * 0x10));
75 | 				joaat_t phash = ext::g_process->read<joaat_t>(program_list + (i * 0x10) + 0xC);
76 | 
77 | 				if (phash == hash) return scrProgram(program);
78 | 			}
79 | 
80 | 			return scrProgram(0);
81 | 		}
82 | 	};
83 | }


--------------------------------------------------------------------------------
/External/src/main.cpp:
--------------------------------------------------------------------------------
 1 | // main.cpp : This file contains the 'main' function. Program execution begins and ends there.
 2 | //
 3 | 
 4 | #include <iostream>
 5 | #include <natives.hpp>
 6 | #include <ysc.hpp>
 7 | 
 8 | #include "process.hpp"
 9 | #include "pattern.hpp"
10 | #include "pointers.hpp"
11 | #include "rage/natives.hpp"
12 | #include "natives.hpp"
13 | #include "script_loader.hpp"
14 | 
15 | using namespace ext;
16 | 
17 | inline std::uint32_t find_gta_proc_id() 
18 | {
19 | 	auto win = ::FindWindowA("grcWindow", nullptr);
20 | 	if (!win) {
21 | 		LOG(FATAL) << "Cannot find game window";
22 | 	}
23 | 
24 | 	DWORD a;
25 | 	::GetWindowThreadProcessId(win, &a);
26 | 
27 | 	return a;
28 | }
29 | 
30 | int main()
31 | {
32 | 	std::filesystem::path base_dir = std::getenv("appdata");
33 | 	base_dir /= "External";
34 | 
35 | 	auto file_manager_instance = std::make_unique<file_manager>(base_dir);
36 | 
37 | 	auto logger_instance = std::make_unique<logger>(
38 | 		"External",
39 | 		file_manager_instance->get_project_file("./cout.log")
40 | 	);
41 | 
42 | 	LOG(INFO) << "External loaded.";
43 | 
44 | 	auto process_instance = std::make_unique<process>(find_gta_proc_id());
45 | 	LOG(INFO) << "Process initalized.";
46 | 
47 | 	auto pointers_instance = std::make_unique<pointers>();
48 | 	LOG(INFO) << "Pointers initialized.";
49 | 
50 | 	auto script_loader_instance = std::make_unique<script_loader>();
51 | 	LOG(INFO) << "Script loader initialized.";
52 | 
53 | 	__fastfail(0);
54 | 
55 | 	while (g_running && g_process->is_running()) 
56 | 	{
57 | 		::Sleep(100);
58 | 	}
59 | 
60 | 	script_loader_instance.reset();
61 | 	LOG(INFO) << "Script loader uninitialized.";
62 | 
63 | 	pointers_instance.reset();
64 | 	LOG(INFO) << "Pointers uninitialized.";
65 | 
66 | 	process_instance.reset();
67 | 	LOG(INFO) << "Process uninitialized.";
68 | 
69 | 	LOG(INFO) << "Farewell!";
70 | 
71 | 	logger_instance.reset();
72 | 	file_manager_instance.reset();
73 | 
74 | 	return 0;
75 | }
76 | 
77 | // Run program: Ctrl + F5 or Debug > Start Without Debugging menu
78 | // Debug program: F5 or Debug > Start Debugging menu
79 | 
80 | // Tips for Getting Started: 
81 | //   1. Use the Solution Explorer window to add/manage files
82 | //   2. Use the Team Explorer window to connect to source control
83 | //   3. Use the Output window to see build output and other messages
84 | //   4. Use the Error List window to view errors
85 | //   5. Go to Project > Add New Item to create new code files, or Project > Add Existing Item to add existing code files to the project
86 | //   6. In the future, to open this project again, go to File > Open > Project and select the .sln file
87 | 


--------------------------------------------------------------------------------
/External/src/process.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | namespace ext 
  4 | {
  5 | 	class process;
  6 | 	inline process* g_process;
  7 | 
  8 | 	class process 
  9 | 	{
 10 | 		HANDLE m_handle;
 11 | 		uint32_t m_pid;
 12 | 
 13 | 	public:
 14 | 		uintptr_t m_base_address;
 15 | 		size_t m_size;
 16 | 
 17 | 		process(uint32_t pid) :
 18 | 			m_pid(pid)
 19 | 		{
 20 | 			m_handle = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
 21 | 			if (!m_handle) {
 22 | 				throw std::exception("Failed to open handle");
 23 | 			}
 24 | 
 25 | 			HMODULE modules[0xFF];
 26 | 			MODULEINFO module_info;
 27 | 			DWORD _;
 28 | 
 29 | 			if (!::EnumProcessModulesEx(m_handle, modules, sizeof(modules), &_, LIST_MODULES_64BIT))
 30 | 				throw std::exception("Failed to enumerate modules");
 31 | 
 32 | 			m_base_address = (uintptr_t)modules[0];
 33 | 
 34 | 			if (!::GetModuleInformation(m_handle, modules[0], &module_info, sizeof(module_info)))
 35 | 				throw std::exception("Failed to get module info");
 36 | 
 37 | 			m_size = module_info.SizeOfImage;
 38 | 
 39 | 			g_process = this;
 40 | 		}
 41 | 
 42 | 		~process() 
 43 | 		{
 44 | 			::CloseHandle(m_handle);
 45 | 			g_process = nullptr;
 46 | 		}
 47 | 
 48 | 		inline bool is_running() 
 49 | 		{
 50 | 			return ::WaitForSingleObject(m_handle, 0) == WAIT_TIMEOUT;
 51 | 		}
 52 | 
 53 | 		inline void set_paused(bool paused)
 54 | 		{
 55 | 			if (paused)
 56 | 			{
 57 | 				::SuspendThread(m_handle);
 58 | 			}
 59 | 			else
 60 | 			{
 61 | 				::ResumeThread(m_handle);
 62 | 			}
 63 | 		}
 64 | 
 65 | 		inline bool read_raw_ex(uintptr_t base, size_t size, void* out) 
 66 | 		{
 67 | 			return ::ReadProcessMemory(m_handle, (LPCVOID)base, out, size, nullptr);
 68 | 		}
 69 | 
 70 | 		inline void read_raw(uintptr_t base, size_t size, void* out) 
 71 | 		{
 72 | 			if (!::ReadProcessMemory(m_handle, (LPCVOID)base, out, size, nullptr)) 
 73 | 			{
 74 | 				throw std::exception("RPM failed");
 75 | 			}
 76 | 		}
 77 | 
 78 | 		inline void write_raw(uintptr_t base, size_t size, void* buf) 
 79 | 		{
 80 | 			if (!::WriteProcessMemory(m_handle, (LPVOID)base, buf, size, nullptr)) 
 81 | 			{
 82 | 				throw std::exception("RPM failed");
 83 | 			}
 84 | 		}
 85 | 
 86 | 		template <typename T>
 87 | 		inline void read(uintptr_t base, T& ref) 
 88 | 		{
 89 | 			read_raw(base, sizeof(T), &ref);
 90 | 		}
 91 | 
 92 | 		template <typename T>
 93 | 		inline T read(uintptr_t base) 
 94 | 			requires(std::is_scalar_v<T>)
 95 | 		{
 96 | 			T out{};
 97 | 			read_raw(base, sizeof(T), &out);
 98 | 			return out;
 99 | 		}
100 | 
101 | 		template <typename T>
102 | 		inline void write(uintptr_t base, const T& ref) {
103 | 			write_raw(base, sizeof(T), (void*)&ref);
104 | 		}
105 | 
106 | 		inline uint64_t allocate(size_t size)
107 | 		{
108 | 			return (uint64_t)::VirtualAllocEx(m_handle, nullptr, size, MEM_COMMIT, PAGE_READWRITE);
109 | 		}
110 | 	};
111 | }


--------------------------------------------------------------------------------
/External/src/pattern.cpp:
--------------------------------------------------------------------------------
  1 | #include "pattern.hpp"
  2 | 
  3 | namespace ext
  4 | {
  5 | 	void pattern::compile(const std::string& pat) {
  6 | 		int hexchar = 0;
  7 | 		bool first = true;
  8 | 		bool lastwaswc = false;
  9 | 
 10 | 		auto to_hex = [&](char c) -> std::uint8_t
 11 | 		{
 12 | 			switch (std::toupper(c))
 13 | 			{
 14 | 			case '0':
 15 | 				return static_cast<std::uint8_t>(0);
 16 | 			case '1':
 17 | 				return static_cast<std::uint8_t>(1);
 18 | 			case '2':
 19 | 				return static_cast<std::uint8_t>(2);
 20 | 			case '3':
 21 | 				return static_cast<std::uint8_t>(3);
 22 | 			case '4':
 23 | 				return static_cast<std::uint8_t>(4);
 24 | 			case '5':
 25 | 				return static_cast<std::uint8_t>(5);
 26 | 			case '6':
 27 | 				return static_cast<std::uint8_t>(6);
 28 | 			case '7':
 29 | 				return static_cast<std::uint8_t>(7);
 30 | 			case '8':
 31 | 				return static_cast<std::uint8_t>(8);
 32 | 			case '9':
 33 | 				return static_cast<std::uint8_t>(9);
 34 | 			case 'A':
 35 | 				return static_cast<std::uint8_t>(10);
 36 | 			case 'B':
 37 | 				return static_cast<std::uint8_t>(11);
 38 | 			case 'C':
 39 | 				return static_cast<std::uint8_t>(12);
 40 | 			case 'D':
 41 | 				return static_cast<std::uint8_t>(13);
 42 | 			case 'E':
 43 | 				return static_cast<std::uint8_t>(14);
 44 | 			case 'F':
 45 | 				return static_cast<std::uint8_t>(15);
 46 | 			default:
 47 | 				return 0;
 48 | 			}
 49 | 		};
 50 | 
 51 | 		for (char c : pat) {
 52 | 			if (c == '?' && !lastwaswc) {
 53 | 				lastwaswc = true;
 54 | 				compiled.push_back(std::nullopt);
 55 | 			}
 56 | 			else {
 57 | 				lastwaswc = false;
 58 | 				if (c == ' ') continue;
 59 | 				hexchar += first ? to_hex(c) * 0x10 : to_hex(c);
 60 | 
 61 | 				if (!first) {
 62 | 					compiled.push_back(hexchar);
 63 | 					hexchar = 0;
 64 | 				}
 65 | 				first = !first;
 66 | 			}
 67 | 		}
 68 | 	}
 69 | 
 70 | 	pattern& pattern::scan() {
 71 | 		size_t i = g_process->m_base_address;
 72 | 		std::uint8_t* membuf = new std::uint8_t[CHUNK_SIZE];
 73 | 
 74 | 		address = 0;
 75 | 
 76 | 		while (address == 0) {
 77 | 			if (i >= (g_process->m_base_address + g_process->m_size))
 78 | 				break;
 79 | 
 80 | 			if (!g_process->read_raw_ex(i, CHUNK_SIZE, membuf))
 81 | 				goto next;
 82 | 
 83 | 			for (int j = 0; j < CHUNK_SIZE; j++) {
 84 | 				for (int k = 0; k < compiled.size(); k++) {
 85 | 					if (!compiled[k].has_value()) continue;
 86 | 					if (compiled[k].value() != membuf[j + k]) goto incorrect;
 87 | 				}
 88 | 
 89 | 				address = i + j;
 90 | 				break;
 91 | 
 92 | 			incorrect: continue;
 93 | 			}
 94 | 
 95 | 		next:
 96 | 			i += CHUNK_SIZE;
 97 | 		}
 98 | 
 99 | 		delete[] membuf;
100 | 
101 | 		if (address == NULL)
102 | 			throw std::exception(("cannot find pattern " + name).data());
103 | 
104 | 		return *this;
105 | 	}
106 | 
107 | 	pattern pattern::rip() {
108 | 		return add(g_process->read<int>(address)).add(4);
109 | 	}
110 | }


--------------------------------------------------------------------------------
/External/src/rage/script_thread.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | #include "pointers.hpp"
  3 | #include "joaat.hpp"
  4 | 
  5 | namespace rage
  6 | {
  7 | 	enum class eThreadState : std::uint32_t
  8 | 	{
  9 | 		Running,
 10 | 		Sleeping,
 11 | 		Killed,
 12 | 		Paused,
 13 | 		Breakpoint
 14 | 	};
 15 | 
 16 | 	class scrThread 
 17 | 	{
 18 | 		std::uint64_t address;
 19 | 	public:
 20 | 		inline scrThread(std::uint64_t addr) :
 21 | 			address(addr)
 22 | 		{
 23 | 		}
 24 | 
 25 | 		inline bool valid() const
 26 | 		{
 27 | 			return address != 0;
 28 | 		}
 29 | 
 30 | 		inline joaat_t get_hash() const
 31 | 		{
 32 | 			return ext::g_process->read<joaat_t>(address + 0x8 + 0x4);
 33 | 		}
 34 | 
 35 | 		inline void set_hash(joaat_t hash)
 36 | 		{
 37 | 			ext::g_process->write<joaat_t>(address + 0x8 + 0x4, hash);
 38 | 			ext::g_process->write<joaat_t>(address + 0xD0, hash);
 39 | 		}
 40 | 
 41 | 		inline std::uint32_t get_stack_size() const
 42 | 		{
 43 | 			return ext::g_process->read<std::uint32_t>(address + 0x8 + 0x50);
 44 | 		}
 45 | 
 46 | 		inline std::uint64_t get_name() const
 47 | 		{
 48 | 			return address + 0xD4;
 49 | 		}
 50 | 
 51 | 		inline void set_state(eThreadState state)
 52 | 		{
 53 | 			ext::g_process->write<eThreadState>(address + 0x8 + 0x8, state);
 54 | 		}
 55 | 
 56 | 		inline void set_stack_ptr(std::uint32_t ptr)
 57 | 		{
 58 | 			ext::g_process->write<uint32_t>(address + 0x8 + 0x14, ptr);  // IP
 59 | 		}
 60 | 
 61 | 		inline void reset()
 62 | 		{
 63 | 			ext::g_process->write<uint32_t>(address + 0x8 + 0xC, 0);  // IP
 64 | 			ext::g_process->write<uint32_t>(address + 0x8 + 0x10, 0); // FP
 65 | 			ext::g_process->write<uint32_t>(address + 0x8 + 0x54, 0); // CATCH IP
 66 | 			ext::g_process->write<uint32_t>(address + 0x124, 0); // CLEANUP IP
 67 | 		}
 68 | 
 69 | 		inline uint64_t get_stack()
 70 | 		{
 71 | 			return ext::g_process->read<std::uint64_t>(address + 0xB0);
 72 | 		}
 73 | 
 74 | 		template <typename T>
 75 | 		inline T get_static(uint32_t index)
 76 | 		{
 77 | 			return ext::g_process->read<T>(ext::g_process->read<joaat_t>(address + 0xB0) + (index * 8));
 78 | 		}
 79 | 
 80 | 		template <typename T>
 81 | 		inline void set_static(uint32_t index, T value)
 82 | 		{
 83 | 			ext::g_process->write<T>(ext::g_process->read<joaat_t>(address + 0xB0) + (index * 8), value);
 84 | 		}
 85 | 
 86 | 		inline std::uint64_t get_handler_vft()
 87 | 		{
 88 | 			return ext::g_process->read<std::uint64_t>(ext::g_process->read<std::uint64_t>(address + 0x118));
 89 | 		}
 90 | 
 91 | 		inline void set_handler_vft(uint64_t vft)
 92 | 		{
 93 | 			ext::g_process->write<std::uint64_t>(ext::g_process->read<std::uint64_t>(address + 0x118), vft);
 94 | 		}
 95 | 
 96 | 		static inline scrThread get_thread_by_hash(joaat_t hash)
 97 | 		{
 98 | 			std::uint16_t num_threads = ext::g_process->read<std::uint16_t>(ext::g_pointers->m_script_threads + 10);
 99 | 			std::uint64_t threads_base = ext::g_process->read<std::uint64_t>(ext::g_pointers->m_script_threads);
100 | 
101 | 			for (int i = 0; i < num_threads; i++)
102 | 			{
103 | 				scrThread thread(ext::g_process->read<std::uint64_t>(threads_base + i * 8));
104 | 				if (thread.get_hash() == hash) 
105 | 					return thread;
106 | 			}
107 | 
108 | 			return scrThread(0);
109 | 		}
110 | 	};
111 | }


--------------------------------------------------------------------------------
/External/src/ysc_file.cpp:
--------------------------------------------------------------------------------
  1 | #include "ysc_file.hpp"
  2 | #include "crossmap.hpp"
  3 | 
  4 | namespace ext
  5 | {
  6 | 	ysc_file::ysc_file(const std::filesystem::path& filename) :
  7 | 		m_file(filename, std::ios::in | std::ios::binary)
  8 | 	{
  9 | 		m_file.seekg(0, std::ios_base::beg);
 10 | 
 11 | 		m_file.seekg(8, std::ios_base::cur); // page base
 12 | 		m_file.seekg(8, std::ios_base::cur); // unk 1 ptr
 13 | 		m_file.read((char*)&m_code_page_list_offset, 8); fix_pointer(m_code_page_list_offset);
 14 | 		m_file.seekg(4, std::ios_base::cur); // unk 2
 15 | 		m_file.read((char*)&m_code_length, 4);
 16 | 		m_file.read((char*)&m_script_parameter_count, 4);
 17 | 		m_file.read((char*)&m_static_count, 4);
 18 | 		m_file.read((char*)&m_global_count, 4);
 19 | 		m_file.read((char*)&m_natives_count, 4);
 20 | 		m_file.read((char*)&m_statics_offset, 8); fix_pointer(m_statics_offset);
 21 | 		m_file.seekg(8, std::ios_base::cur); // globals offset
 22 | 		m_file.read((char*)&m_natives_list_offset, 8); fix_pointer(m_natives_list_offset);
 23 | 		m_file.seekg(8, std::ios_base::cur); // unk 3 ptr
 24 | 		m_file.seekg(8, std::ios_base::cur); // unk 4 ptr
 25 | 		m_file.read((char*)&m_name_hash, 4);
 26 | 		m_file.seekg(4, std::ios_base::cur); // unk 5
 27 | 		m_file.read((char*)&m_script_name_offset, 8); fix_pointer(m_script_name_offset);
 28 | 		m_file.read((char*)&m_strings_list_offset, 8); fix_pointer(m_strings_list_offset);
 29 | 		m_file.read((char*)&m_string_size, 4);
 30 | 
 31 | 		m_string_blocks = (m_string_size + 0x3FFF) >> 14;
 32 | 		m_code_blocks = (m_code_length + 0x3FFF) >> 14;
 33 | 
 34 | 		m_file.seekg(m_script_name_offset, std::ios_base::beg);
 35 | 
 36 | 		char chr = 0;
 37 | 		int i = 0;
 38 | 		while (i < 0x40)
 39 | 		{
 40 | 			m_file.read((char*)&chr, 1);
 41 | 			m_name[i] = chr;
 42 | 			if (chr == 0x0 || chr == 0xFF)
 43 | 				break;
 44 | 		}
 45 | 
 46 | 		if (m_static_count)
 47 | 		{
 48 | 			m_file.seekg(m_statics_offset, std::ios_base::beg);
 49 | 			m_statics = new uint64_t[m_static_count];
 50 | 			m_file.read((char*)m_statics, m_static_count * 8);
 51 | 		}
 52 | 
 53 | 		for (i = 0; i < m_code_blocks; i++)
 54 | 		{
 55 | 			uint64_t loc;
 56 | 			int tablesize = ((i + 1) * 0x4000 >= m_code_length) ? m_code_length % 0x4000 : 0x4000;
 57 | 			uint8_t* code_block = new uint8_t[tablesize];
 58 | 			m_file.seekg(m_code_page_list_offset + (i * 8), std::ios_base::beg);
 59 | 			m_file.read((char*)&loc, 8); fix_pointer(loc);
 60 | 			m_file.seekg(loc, std::ios_base::beg);
 61 | 			m_file.read((char*)code_block, tablesize);
 62 | 			m_code_block_list.push_back(code_block);
 63 | 		}
 64 | 
 65 | 		for (i = 0; i < m_string_blocks; i++)
 66 | 		{
 67 | 			uint64_t loc;
 68 | 			int tablesize = ((i + 1) * 0x4000 >= m_string_size) ? m_string_size % 0x4000 : 0x4000;
 69 | 			uint8_t* string_block = new uint8_t[tablesize];
 70 | 			m_file.seekg(m_strings_list_offset + (i * 8), std::ios_base::beg);
 71 | 			m_file.read((char*)&loc, 8); fix_pointer(loc);
 72 | 			m_file.seekg(loc, std::ios_base::beg);
 73 | 			m_file.read((char*)string_block, tablesize);
 74 | 			m_string_block_list.push_back(string_block);
 75 | 		}
 76 | 
 77 | 		for (i = 0; i < m_natives_count; i++)
 78 | 		{
 79 | 			m_file.seekg(m_natives_list_offset + (i * 8), std::ios_base::beg);
 80 | 			uint64_t hash;
 81 | 			m_file.read((char*)&hash, 8); rotl(hash, m_code_length + i);
 82 | 			for (auto& mapping : ysc::crossmap)
 83 | 			{
 84 | 				if (mapping.first == hash)
 85 | 				{
 86 | 					hash = mapping.second;
 87 | 					break;
 88 | 				}
 89 | 			}
 90 | 
 91 | 			m_natives.push_back(hash);
 92 | 		}
 93 | 
 94 | 		m_file.close();
 95 | 	}
 96 | 
 97 | 	ysc_file::~ysc_file()
 98 | 	{
 99 | 		for (auto& code : m_code_block_list)
100 | 		{
101 | 			delete[] code;
102 | 		}
103 | 
104 | 		for (auto& string : m_string_block_list)
105 | 		{
106 | 			delete[] string;
107 | 		}
108 | 
109 | 		if (m_statics)
110 | 			delete[] m_statics;
111 | 	}
112 | }


--------------------------------------------------------------------------------
/External/src/script_loader.cpp:
--------------------------------------------------------------------------------
  1 | #include "script_loader.hpp"
  2 | #include "crossmap.hpp"
  3 | #include "rage/natives.hpp"
  4 | #include "natives.hpp"
  5 | #include "ysc_file.hpp"
  6 | 
  7 | namespace ext 
  8 | {
  9 | 	script_loader::script_loader() :
 10 | 		m_native_registration(g_pointers->m_native_registration_table),
 11 | 		m_required_script($(code_controller))
 12 | 	{
 13 | 		find_thread();
 14 | 		pick_script();
 15 | 		initalize_thread();
 16 | 
 17 | 		g_script_loader = this;
 18 | 	}
 19 | 
 20 | 	script_loader::~script_loader()
 21 | 	{
 22 | 		if (m_thread.valid() && g_process->is_running())
 23 | 			m_thread.set_state(rage::eThreadState::Paused);
 24 | 		g_script_loader = nullptr;
 25 | 	}
 26 | 
 27 | 	void script_loader::find_thread()
 28 | 	{
 29 | 		LOG(INFO) << "Waiting for code_controller...";
 30 | 		while ((!m_thread.valid()) || (!m_program.valid()))
 31 | 		{
 32 | 			m_thread = rage::scrThread::get_thread_by_hash(m_required_script);
 33 | 			m_program = rage::scrProgram::get_program_by_hash(m_required_script);
 34 | 			::Sleep(100);
 35 | 		}
 36 | 	}
 37 | 
 38 | 	void script_loader::pick_script()
 39 | 	{
 40 | 		// https://stackoverflow.com/a/49652087
 41 | 
 42 | 		memset(&m_ofn, 0, sizeof(m_ofn));
 43 | 		m_ofn.lStructSize = sizeof(m_ofn);
 44 | 		m_ofn.hwndOwner = NULL;
 45 | 		m_ofn.lpstrFile = m_file_name;
 46 | 		m_ofn.nMaxFile = sizeof(m_file_name);
 47 | 		m_ofn.lpstrFilter = "Rage Script (no RSC7 header)\0*.YSC;*.YSC.FULL\0\0";
 48 | 		m_ofn.nFilterIndex = 1;
 49 | 		m_ofn.lpstrFileTitle = NULL;
 50 | 		m_ofn.nMaxFileTitle = 0;
 51 | 		m_ofn.lpstrInitialDir = NULL;
 52 | 		m_ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
 53 | 
 54 | 		if (::GetOpenFileNameA(&m_ofn) != TRUE)
 55 | 		{
 56 | 			exit(0);
 57 | 		}
 58 | 	}
 59 | 
 60 | 	void script_loader::initalize_thread()
 61 | 	{
 62 | 		LOG(INFO) << "Preparing script...";
 63 | 
 64 | 		std::filesystem::path fpath(m_file_name);
 65 | 		ysc_file file(fpath);
 66 | 
 67 | 		LOG(INFO) << "Caching native handlers...";
 68 | 		for (auto& p : file.m_natives)
 69 | 		{
 70 | 			m_handler_cache[p] = m_native_registration.get_entrypoint_from_hash(p);
 71 | 		}
 72 | 
 73 | 		m_thread.set_state(rage::eThreadState::Paused);
 74 | 		g_process->set_paused(true);
 75 | 
 76 | 		m_thread.reset();
 77 | 
 78 | 		if (m_program.get_code_size() < file.m_code_length)
 79 | 			LOG(FATAL) << "Cannot fit " << file.m_code_length << " bytes into program, maximum is " << m_program.get_code_size();
 80 | 
 81 | 		if (m_program.get_string_size() < file.m_string_size)
 82 | 			LOG(FATAL) << "Cannot fit " << file.m_string_size << " string chars into program, maximum is " << m_program.get_string_size();
 83 | 
 84 | 		if (m_program.get_num_natives() < file.m_natives_count)
 85 | 			LOG(FATAL) << "Cannot fit " << file.m_natives_count << " natives into program, maximum is " << m_program.get_num_natives();
 86 | 
 87 | 		if ((m_thread.get_stack_size() - 200) < file.m_static_count)
 88 | 			LOG(FATAL) << "Cannot fit " << file.m_static_count << " statics into stack, maximum is " << (m_thread.get_stack_size() - 200);
 89 | 
 90 | 		for (int i = 0; i < file.m_code_block_list.size(); i++)
 91 | 		{
 92 | 			int tablesize = ((i + 1) * 0x4000 >= file.m_code_length) ? file.m_code_length % 0x4000 : 0x4000;
 93 | 			uint64_t codepage = m_program.get_code_page(i);
 94 | 			g_process->write_raw(codepage, tablesize, file.m_code_block_list[i]);
 95 | 		}
 96 | 
 97 | 		for (int i = 0; i < file.m_string_block_list.size(); i++)
 98 | 		{
 99 | 			int tablesize = ((i + 1) * 0x4000 >= file.m_string_size) ? file.m_string_size % 0x4000 : 0x4000;
100 | 			uint64_t stringpage = m_program.get_string_page(i);
101 | 			g_process->write_raw(stringpage, tablesize, file.m_string_block_list[i]);
102 | 		}
103 | 
104 | 		uint64_t natives = m_program.get_native_table();
105 | 
106 | 		for (int i = 0; i < file.m_natives.size(); i++)
107 | 		{
108 | 			g_process->write<std::uint64_t>(natives + (uint64_t)(i * 8), m_handler_cache[file.m_natives[i]]);
109 | 		}
110 | 
111 | 		g_process->write_raw(m_thread.get_stack(), file.m_static_count * 8, file.m_statics);
112 | 		m_thread.set_stack_ptr(file.m_static_count + 1);
113 | 
114 | 		//g_process->write_raw(m_thread.get_name(), strlen(file.m_name), file.m_name);
115 | 		//m_thread.set_hash(file.m_name_hash);
116 | 
117 | 		// model spawn bypass
118 | 
119 | 		auto m_original_vft = m_thread.get_handler_vft();
120 | 		m_fake_vft = g_process->allocate(20 * 8);
121 | 
122 | 		for (uint64_t i = 0; i < 20; i++)
123 | 		{
124 | 			g_process->write<uint64_t>(m_fake_vft + (i * 8), g_process->read<uint64_t>(m_original_vft + (i * 8)));
125 | 		}
126 | 
127 | 		g_process->write<uint64_t>(m_fake_vft + (6 * 8), g_pointers->m_ret_true_function);
128 | 
129 | 		m_thread.set_handler_vft(m_fake_vft);
130 | 
131 | 		m_program.mark_program_as_ours();
132 | 
133 | 		g_process->set_paused(false);
134 | 		m_thread.set_state(rage::eThreadState::Running);
135 | 	}
136 | }


--------------------------------------------------------------------------------
/premake5.lua:
--------------------------------------------------------------------------------
  1 | workspace "External"
  2 |   architecture "x64"
  3 |   startproject "External"
  4 | 
  5 |   configurations
  6 |   {
  7 |     "Debug",
  8 |     "Release",
  9 |     "Dist"
 10 |   }
 11 | 
 12 |   outputdir = "%{cfg.buildcfg}"
 13 | 
 14 |   IncludeDir = {}
 15 |   IncludeDir["g3log"] = "g3log/src"
 16 |   IncludeDir["JITYSC"] = "JITYSC/src"
 17 |   IncludeDir["json"] = "json/single_include"
 18 |   
 19 |   CppVersion = "C++20"
 20 |   MsvcToolset = "v143"
 21 |   WindowsSdkVersion = "10.0"
 22 |   
 23 |   function DeclareMSVCOptions()
 24 |     filter "system:windows"
 25 |     staticruntime "Off"
 26 | 	  floatingpoint "Fast"
 27 | 	  vectorextensions "AVX2"
 28 |     systemversion (WindowsSdkVersion)
 29 |     toolset (MsvcToolset)
 30 |     cppdialect (CppVersion)
 31 | 
 32 |     defines
 33 |     {
 34 |       "_CRT_SECURE_NO_WARNINGS",
 35 |       "NOMINMAX",
 36 |       "WIN32_LEAN_AND_MEAN",
 37 |       "_WIN32_WINNT=0x601" -- Support Windows 7
 38 |     }
 39 |     
 40 |     disablewarnings
 41 |     {
 42 |       "4100", -- C4100: unreferenced formal parameter
 43 |       "4201", -- C4201: nameless struct/union
 44 |       "4307",  -- C4307: integral constant overflow
 45 |       "4996"  -- C4996: deprecated in C++17
 46 |     }
 47 |   end
 48 |   
 49 |   function file_exists(name)
 50 |    local f=io.open(name,"r")
 51 |    if f~=nil then io.close(f) return true else return false end
 52 |   end
 53 |    
 54 |   function DeclareDebugOptions()
 55 |     filter "configurations:Debug"
 56 |       defines { "_DEBUG" }
 57 |       symbols "On"
 58 |     filter "not configurations:Debug"
 59 |       defines { "NDEBUG" }
 60 |   end
 61 | 
 62 |   project "JITYSC"
 63 |     location "%{prj.name}"
 64 |     kind "StaticLib"
 65 |     language "C++"
 66 | 
 67 |     targetdir ("bin/lib/" .. outputdir)
 68 |     objdir ("bin/lib/int/" .. outputdir .. "/%{prj.name}")
 69 | 	
 70 | 	  includedirs
 71 |     {
 72 |       "%{prj.name}/src"
 73 |     }
 74 | 
 75 |     files
 76 |     {
 77 |       "%{prj.name}/src/**.hpp",
 78 |       "%{prj.name}/src/**.cpp"
 79 |     }
 80 | 
 81 |     DeclareMSVCOptions()
 82 |     DeclareDebugOptions()
 83 | 	
 84 |   project "g3log"
 85 |     location "%{prj.name}"
 86 |     kind "StaticLib"
 87 |     language "C++"
 88 | 
 89 |     targetdir ("bin/lib/" .. outputdir)
 90 |     objdir ("bin/lib/int/" .. outputdir .. "/%{prj.name}")
 91 | 	
 92 | 	  includedirs
 93 |     {
 94 |       "%{prj.name}/src"
 95 |     }
 96 | 
 97 | 	  if(file_exists("g3log\\src\\g3log\\generated_definitions.hpp") == false) then
 98 | 		  file = io.open("g3log\\src\\g3log\\generated_definitions.hpp", "w")
 99 | 		  if(file == nil) then
100 | 			  premake.error("Failed to locate vendor directories. Try doing git pull --recurse-submodules.")
101 | 		  end
102 | 		  file:write("// AUTO GENERATED MACRO DEFINITIONS FOR G3LOG\n\n\n/* ==========================================================================\n*2015 by KjellKod.cc. This is PUBLIC DOMAIN to use at your own risk and comes\n* with no warranties. This code is yours to share, use and modify with no\n\n*strings attached and no restrictions or obligations.\n* \n* For more information see g3log/LICENSE or refer refer to http://unlicense.org\n\n*============================================================================*/\n#pragma once\n\n\n// CMake induced definitions below. See g3log/Options.cmake for details.");
103 | 	  end
104 | 	
105 |     files
106 |      {
107 |        "%{prj.name}/src/**.hpp",
108 |        "%{prj.name}/src/**.cpp"
109 |      }
110 | 	
111 | 	  removefiles
112 | 	  {
113 |   	  "%{prj.name}/src/crashhandler_unix.cpp"
114 |   	}
115 | 
116 |     DeclareMSVCOptions()
117 |     DeclareDebugOptions()
118 | 
119 |   project "External"
120 |     location "External"
121 |     kind "ConsoleApp"
122 |     language "C++"
123 | 
124 |     targetdir ("bin/lib/" .. outputdir)
125 |     objdir ("bin/int/" .. outputdir .. "/%{prj.name}")
126 | 
127 |     PrecompiledHeaderInclude = "common.hpp"
128 |     PrecompiledHeaderSource = "%{prj.name}/src/common.cpp"
129 |  
130 |     files
131 |     {
132 |       "%{prj.name}/src/**.hpp",
133 |       "%{prj.name}/src/**.h",
134 |       "%{prj.name}/src/**.cpp",
135 |       "%{prj.name}/src/**.asm",
136 |       "%{prj.name}/src/**.def"
137 |     }
138 | 
139 |     includedirs
140 |     {
141 |       "%{IncludeDir.g3log}",
142 |       "%{IncludeDir.JITYSC}",
143 |       "%{IncludeDir.json}",
144 |       "%{prj.name}/src"
145 |     }
146 | 
147 |     libdirs
148 |     {
149 |       "bin/lib"
150 |     }
151 | 
152 |     links
153 |     {
154 |       "g3log"
155 |     }
156 | 
157 |     pchheader "%{PrecompiledHeaderInclude}"
158 |     pchsource "%{PrecompiledHeaderSource}"
159 |     targetname "external"
160 | 
161 |     forceincludes
162 |     {
163 |       "%{PrecompiledHeaderInclude}"
164 |     }
165 | 
166 |     DeclareMSVCOptions()
167 |     DeclareDebugOptions()
168 | 
169 |     flags { "NoImportLib", "Maps" }
170 | 
171 |     filter "configurations:Debug"
172 | 	  flags { "LinkTimeOptimization", "MultiProcessorCompile" }
173 | 	  editandcontinue "Off"
174 |       defines { "EXTERNAL_DEBUG" }
175 | 
176 |     filter "configurations:Release"
177 | 	  flags { "LinkTimeOptimization", "NoManifest", "MultiProcessorCompile" }
178 |       defines { "EXTERNAL_RELEASE" }
179 |       optimize "speed"
180 |     filter "configurations:Dist"
181 |       flags { "LinkTimeOptimization", "FatalWarnings", "NoManifest", "MultiProcessorCompile" }
182 |       defines { "EXTERNAL_DIST" }
183 |       optimize "speed"
184 | 


--------------------------------------------------------------------------------
/External/src/logger.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | #include "common.hpp"
  3 | #include "file_manager.hpp"
  4 | #include <g3log/g3log.hpp>
  5 | #include <g3log/loglevels.hpp>
  6 | #include <g3log/logworker.hpp>
  7 | 
  8 | namespace ext
  9 | {
 10 | 	template <typename TP>
 11 | 	std::time_t to_time_t(TP tp)
 12 | 	{
 13 | 		using namespace std::chrono;
 14 | 		auto sctp = time_point_cast<system_clock::duration>(tp - TP::clock::now()
 15 | 			+ system_clock::now());
 16 | 		return system_clock::to_time_t(sctp);
 17 | 	}
 18 | 
 19 | 	class logger;
 20 | 	inline logger* g_log{};
 21 | 
 22 | 	enum class LogColor
 23 | 	{
 24 | 		RESET,
 25 | 		WHITE = 97,
 26 | 		CYAN = 36,
 27 | 		MAGENTA = 35,
 28 | 		BLUE = 34,
 29 | 		GREEN = 32,
 30 | 		YELLOW = 33,
 31 | 		RED = 31,
 32 | 		BLACK = 30
 33 | 	};
 34 | 
 35 | #define AddColorToStream(color) "\x1b[" << int(color) << "m"
 36 | #define ResetStreamColor "\x1b[" << int(LogColor::RESET) << "m"
 37 | #define HEX_TO_UPPER(value) "0x" << std::hex << std::uppercase << (DWORD64)value << std::dec << std::nouppercase
 38 | 
 39 | 	class logger final
 40 | 	{
 41 | 
 42 | 	public:
 43 | 		logger(std::string_view console_title, file file, bool attach_console = true)
 44 | 			: m_attach_console(attach_console), m_did_console_exist(false),
 45 | 			m_console_title(console_title), m_original_console_mode(0),
 46 | 			m_console_handle(nullptr), m_file(file),
 47 | 			m_worker(g3::LogWorker::createLogWorker())
 48 | 		{
 49 | 			initialize();
 50 | 
 51 | 			g_log = this;
 52 | 		}
 53 | 		~logger()
 54 | 		{
 55 | 			g_log = nullptr;
 56 | 		}
 57 | 
 58 | 		void initialize()
 59 | 		{
 60 | 			if (m_attach_console)
 61 | 			{
 62 | 				if (m_did_console_exist = ::AttachConsole(GetCurrentProcessId()); !m_did_console_exist)
 63 | 					AllocConsole();
 64 | 
 65 | 				if (m_console_handle = GetStdHandle(STD_OUTPUT_HANDLE); m_console_handle != nullptr)
 66 | 				{
 67 | 					SetConsoleTitleA(m_console_title.data());
 68 | 					SetConsoleOutputCP(CP_UTF8);
 69 | 
 70 | 					DWORD console_mode;
 71 | 					GetConsoleMode(m_console_handle, &console_mode);
 72 | 					m_original_console_mode = console_mode;
 73 | 
 74 | 					// terminal like behaviour enable full color support
 75 | 					console_mode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING | DISABLE_NEWLINE_AUTO_RETURN;
 76 | 					// prevent clicking in terminal from suspending our main thread
 77 | 					console_mode &= ~(ENABLE_QUICK_EDIT_MODE);
 78 | 
 79 | 					SetConsoleMode(m_console_handle, console_mode);
 80 | 				}
 81 | 			}
 82 | 			create_backup();
 83 | 			open_outstreams();
 84 | 			initialize_g3log();
 85 | 		}
 86 | 		void destroy()
 87 | 		{
 88 | 			destroy_g3log();
 89 | 			close_outstreams();
 90 | 
 91 | 			if (m_did_console_exist)
 92 | 				SetConsoleMode(m_console_handle, m_original_console_mode);
 93 | 
 94 | 			if (!m_did_console_exist && m_attach_console)
 95 | 				FreeConsole();
 96 | 		}
 97 | 
 98 | 	private:
 99 | 		void create_backup()
100 | 		{
101 | 			if (m_file.exists())
102 | 			{
103 | 				auto file_time = std::filesystem::last_write_time(m_file.get_path());
104 | 				auto time_t = to_time_t(file_time);
105 | 				auto local_time = std::localtime(&time_t);
106 | 
107 | 				m_file.move(
108 | 					std::format(
109 | 						"./backup/{:0>2}-{:0>2}-{}-{:0>2}-{:0>2}-{:0>2}_{}",
110 | 						local_time->tm_mon + 1,
111 | 						local_time->tm_mday,
112 | 						local_time->tm_year + 1900,
113 | 						local_time->tm_hour,
114 | 						local_time->tm_min,
115 | 						local_time->tm_sec,
116 | 						m_file.get_path().filename().string().c_str()
117 | 					)
118 | 				);
119 | 			}
120 | 		}
121 | 
122 | 		void initialize_g3log()
123 | 		{
124 | 			m_worker->addSink(std::make_unique<log_sink>(), &log_sink::callback);
125 | 			g3::initializeLogging(m_worker.get());
126 | 		}
127 | 		void destroy_g3log()
128 | 		{
129 | 			m_worker->removeAllSinks();
130 | 			m_worker.reset();
131 | 		}
132 | 
133 | 		void open_outstreams()
134 | 		{
135 | 			if (m_attach_console)
136 | 				m_console_out.open("CONOUT$", std::ios_base::out | std::ios_base::app);
137 | 
138 | 			m_file_out.open(m_file.get_path(), std::ios_base::out | std::ios_base::trunc);
139 | 		}
140 | 		void close_outstreams()
141 | 		{
142 | 			if (m_attach_console)
143 | 				m_console_out.close();
144 | 
145 | 			m_file_out.close();
146 | 		}
147 | 
148 | 	private:
149 | 		struct log_sink
150 | 		{
151 | 			void callback(g3::LogMessageMover log)
152 | 			{
153 | 				if (g_log->m_console_out.is_open())
154 | 					g_log->m_console_out << log.get().toString(log_sink::format_console) << std::flush;
155 | 
156 | 				g_log->m_file_out << log.get().toString(log_sink::format_file) << std::flush;
157 | 			}
158 | 
159 | 			static LogColor get_color(const LEVELS level)
160 | 			{
161 | 				switch (level.value)
162 | 				{
163 | 				case g3::kDebugValue:
164 | 					return LogColor::BLUE;
165 | 				case g3::kInfoValue:
166 | 					return LogColor::GREEN;
167 | 				case g3::kWarningValue:
168 | 					return LogColor::YELLOW;
169 | 				}
170 | 				return g3::internal::wasFatal(level) ? LogColor::RED : LogColor::WHITE;
171 | 			}
172 | 
173 | 			static std::string format_console(const g3::LogMessage& msg)
174 | 			{
175 | 				LogColor color = log_sink::get_color(msg._level);
176 | 				std::stringstream out;
177 | 
178 | 				out
179 | 					<< "[" << msg.timestamp("%H:%M:%S") << "]"
180 | 					<< AddColorToStream(color)
181 | 					<< "[" << std::setw(7) << msg.level() << "/"
182 | 					<< msg.file() << ":" << msg.line() << "]"
183 | 					<< ResetStreamColor
184 | 					<< ": ";
185 | 
186 | 				return out.str();
187 | 			}
188 | 			static std::string format_file(const g3::LogMessage& msg)
189 | 			{
190 | 				LogColor color = log_sink::get_color(msg._level);
191 | 				std::stringstream out;
192 | 
193 | 				out
194 | 					<< "[" << msg.timestamp("%H:%M:%S") << "]"
195 | 					<< "[" << std::setw(7) << msg.level() << "/"
196 | 					<< msg.file() << ":" << msg.line() << "]"
197 | 					<< ": ";
198 | 
199 | 				return out.str();
200 | 			}
201 | 		};
202 | 
203 | 	private:
204 | 		friend struct log_sink;
205 | 
206 | 		bool m_attach_console;
207 | 		bool m_did_console_exist;
208 | 
209 | 		std::string_view m_console_title;
210 | 		DWORD m_original_console_mode;
211 | 		HANDLE m_console_handle;
212 | 
213 | 		std::ofstream m_console_out;
214 | 		std::ofstream m_file_out;
215 | 
216 | 		file m_file;
217 | 
218 | 		std::unique_ptr<g3::LogWorker> m_worker;
219 | 
220 | 	};
221 | }


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | ### C++ ###
  2 | # Prerequisites
  3 | *.d
  4 | 
  5 | # Compiled Object files
  6 | *.slo
  7 | *.lo
  8 | *.o
  9 | *.obj
 10 | 
 11 | # Precompiled Headers
 12 | *.gch
 13 | *.pch
 14 | 
 15 | # Compiled Dynamic libraries
 16 | *.so
 17 | *.dylib
 18 | *.dll
 19 | 
 20 | # Fortran module files
 21 | *.mod
 22 | *.smod
 23 | 
 24 | # Compiled Static libraries
 25 | *.lai
 26 | *.la
 27 | *.a
 28 | *.lib
 29 | 
 30 | # Executables
 31 | *.exe
 32 | *.out
 33 | *.app
 34 | 
 35 | ### CMake ###
 36 | CMakeLists.txt.user
 37 | CMakeCache.txt
 38 | CMakeFiles
 39 | CMakeScripts
 40 | Testing
 41 | Makefile
 42 | cmake_install.cmake
 43 | install_manifest.txt
 44 | compile_commands.json
 45 | CTestTestfile.cmake
 46 | _deps
 47 | 
 48 | ### CMake Patch ###
 49 | # External projects
 50 | *-prefix/
 51 | 
 52 | ### Windows ###
 53 | # Windows thumbnail cache files
 54 | Thumbs.db
 55 | ehthumbs.db
 56 | ehthumbs_vista.db
 57 | 
 58 | # Dump file
 59 | *.stackdump
 60 | 
 61 | # Folder config file
 62 | [Dd]esktop.ini
 63 | 
 64 | # Recycle Bin used on file shares
 65 | $RECYCLE.BIN/
 66 | 
 67 | # Windows Installer files
 68 | *.cab
 69 | *.msi
 70 | *.msix
 71 | *.msm
 72 | *.msp
 73 | 
 74 | # Windows shortcuts
 75 | *.lnk
 76 | 
 77 | ### VisualStudio ###
 78 | ## Ignore Visual Studio temporary files, build results, and
 79 | ## files generated by popular Visual Studio add-ons.
 80 | ##
 81 | ## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
 82 | 
 83 | # User-specific files
 84 | *.rsuser
 85 | *.suo
 86 | *.user
 87 | *.userosscache
 88 | *.sln.docstates
 89 | 
 90 | # User-specific files (MonoDevelop/Xamarin Studio)
 91 | *.userprefs
 92 | 
 93 | # Mono auto generated files
 94 | mono_crash.*
 95 | 
 96 | # Build results
 97 | [Dd]ebug/
 98 | [Dd]ebugPublic/
 99 | [Rr]elease/
100 | [Rr]eleases/
101 | x64/
102 | x86/
103 | [Aa][Rr][Mm]/
104 | [Aa][Rr][Mm]64/
105 | bld/
106 | [Bb]in/
107 | [Oo]bj/
108 | [Ll]og/
109 | 
110 | # Visual Studio 2015/2017 cache/options directory
111 | .vs/
112 | # Uncomment if you have tasks that create the project's static files in wwwroot
113 | #wwwroot/
114 | 
115 | # Visual Studio 2017 auto generated files
116 | Generated\ Files/
117 | 
118 | # MSTest test Results
119 | [Tt]est[Rr]esult*/
120 | [Bb]uild[Ll]og.*
121 | 
122 | # NUNIT
123 | *.VisualState.xml
124 | TestResult.xml
125 | 
126 | # Build Results of an ATL Project
127 | [Dd]ebugPS/
128 | [Rr]eleasePS/
129 | dlldata.c
130 | 
131 | # Benchmark Results
132 | BenchmarkDotNet.Artifacts/
133 | 
134 | # .NET Core
135 | project.lock.json
136 | project.fragment.lock.json
137 | artifacts/
138 | 
139 | # StyleCop
140 | StyleCopReport.xml
141 | 
142 | # Files built by Visual Studio
143 | *_i.c
144 | *_p.c
145 | *_h.h
146 | *.ilk
147 | *.meta
148 | *.iobj
149 | *.pdb
150 | *.ipdb
151 | *.pgc
152 | *.pgd
153 | *.rsp
154 | *.sbr
155 | *.tlb
156 | *.tli
157 | *.tlh
158 | *.tmp
159 | *.tmp_proj
160 | *_wpftmp.csproj
161 | *.log
162 | *.vspscc
163 | *.vssscc
164 | .builds
165 | *.pidb
166 | *.svclog
167 | *.scc
168 | 
169 | # Chutzpah Test files
170 | _Chutzpah*
171 | 
172 | # Visual C++ cache files
173 | ipch/
174 | *.aps
175 | *.ncb
176 | *.opendb
177 | *.opensdf
178 | *.sdf
179 | *.cachefile
180 | *.VC.db
181 | *.VC.VC.opendb
182 | 
183 | # Visual Studio profiler
184 | *.psess
185 | *.vsp
186 | *.vspx
187 | *.sap
188 | 
189 | # Visual Studio Trace Files
190 | *.e2e
191 | 
192 | # TFS 2012 Local Workspace
193 | $tf/
194 | 
195 | # Guidance Automation Toolkit
196 | *.gpState
197 | 
198 | # ReSharper is a .NET coding add-in
199 | _ReSharper*/
200 | *.[Rr]e[Ss]harper
201 | *.DotSettings.user
202 | 
203 | # JustCode is a .NET coding add-in
204 | .JustCode
205 | 
206 | # TeamCity is a build add-in
207 | _TeamCity*
208 | 
209 | # DotCover is a Code Coverage Tool
210 | *.dotCover
211 | 
212 | # AxoCover is a Code Coverage Tool
213 | .axoCover/*
214 | !.axoCover/settings.json
215 | 
216 | # Visual Studio code coverage results
217 | *.coverage
218 | *.coveragexml
219 | 
220 | # NCrunch
221 | _NCrunch_*
222 | .*crunch*.local.xml
223 | nCrunchTemp_*
224 | 
225 | # MightyMoose
226 | *.mm.*
227 | AutoTest.Net/
228 | 
229 | # Web workbench (sass)
230 | .sass-cache/
231 | 
232 | # Installshield output folder
233 | [Ee]xpress/
234 | 
235 | # DocProject is a documentation generator add-in
236 | DocProject/buildhelp/
237 | DocProject/Help/*.HxT
238 | DocProject/Help/*.HxC
239 | DocProject/Help/*.hhc
240 | DocProject/Help/*.hhk
241 | DocProject/Help/*.hhp
242 | DocProject/Help/Html2
243 | DocProject/Help/html
244 | 
245 | # Click-Once directory
246 | publish/
247 | 
248 | # Publish Web Output
249 | *.[Pp]ublish.xml
250 | *.azurePubxml
251 | # Note: Comment the next line if you want to checkin your web deploy settings,
252 | # but database connection strings (with potential passwords) will be unencrypted
253 | *.pubxml
254 | *.publishproj
255 | 
256 | # Microsoft Azure Web App publish settings. Comment the next line if you want to
257 | # checkin your Azure Web App publish settings, but sensitive information contained
258 | # in these scripts will be unencrypted
259 | PublishScripts/
260 | 
261 | # NuGet Packages
262 | *.nupkg
263 | # The packages folder can be ignored because of Package Restore
264 | **/[Pp]ackages/*
265 | # except build/, which is used as an MSBuild target.
266 | !**/[Pp]ackages/build/
267 | # Uncomment if necessary however generally it will be regenerated when needed
268 | #!**/[Pp]ackages/repositories.config
269 | # NuGet v3's project.json files produces more ignorable files
270 | *.nuget.props
271 | *.nuget.targets
272 | 
273 | # Microsoft Azure Build Output
274 | csx/
275 | *.build.csdef
276 | 
277 | # Microsoft Azure Emulator
278 | ecf/
279 | rcf/
280 | 
281 | # Windows Store app package directories and files
282 | AppPackages/
283 | BundleArtifacts/
284 | Package.StoreAssociation.xml
285 | _pkginfo.txt
286 | *.appx
287 | *.appxbundle
288 | *.appxupload
289 | 
290 | # Visual Studio cache files
291 | # files ending in .cache can be ignored
292 | *.[Cc]ache
293 | # but keep track of directories ending in .cache
294 | !?*.[Cc]ache/
295 | 
296 | # Others
297 | ClientBin/
298 | ~$*
299 | *~
300 | *.dbmdl
301 | *.dbproj.schemaview
302 | *.jfm
303 | *.pfx
304 | *.publishsettings
305 | orleans.codegen.cs
306 | 
307 | # Including strong name files can present a security risk
308 | # (https://github.com/github/gitignore/pull/2483#issue-259490424)
309 | #*.snk
310 | 
311 | # Since there are multiple workflows, uncomment next line to ignore bower_components
312 | # (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
313 | #bower_components/
314 | 
315 | # RIA/Silverlight projects
316 | Generated_Code/
317 | 
318 | # Backup & report files from converting an old project file
319 | # to a newer Visual Studio version. Backup files are not needed,
320 | # because we have git ;-)
321 | _UpgradeReport_Files/
322 | Backup*/
323 | UpgradeLog*.XML
324 | UpgradeLog*.htm
325 | ServiceFabricBackup/
326 | *.rptproj.bak
327 | 
328 | # SQL Server files
329 | *.mdf
330 | *.ldf
331 | *.ndf
332 | 
333 | # Business Intelligence projects
334 | *.rdl.data
335 | *.bim.layout
336 | *.bim_*.settings
337 | *.rptproj.rsuser
338 | *- Backup*.rdl
339 | 
340 | # Microsoft Fakes
341 | FakesAssemblies/
342 | 
343 | # GhostDoc plugin setting file
344 | *.GhostDoc.xml
345 | 
346 | # Node.js Tools for Visual Studio
347 | .ntvs_analysis.dat
348 | node_modules/
349 | 
350 | # Visual Studio 6 build log
351 | *.plg
352 | 
353 | # Visual Studio 6 workspace options file
354 | *.opt
355 | 
356 | # Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
357 | *.vbw
358 | 
359 | # Visual Studio LightSwitch build output
360 | **/*.HTMLClient/GeneratedArtifacts
361 | **/*.DesktopClient/GeneratedArtifacts
362 | **/*.DesktopClient/ModelManifest.xml
363 | **/*.Server/GeneratedArtifacts
364 | **/*.Server/ModelManifest.xml
365 | _Pvt_Extensions
366 | 
367 | # Paket dependency manager
368 | .paket/paket.exe
369 | paket-files/
370 | 
371 | # FAKE - F# Make
372 | .fake/
373 | 
374 | # CodeRush personal settings
375 | .cr/personal
376 | 
377 | # Python Tools for Visual Studio (PTVS)
378 | __pycache__/
379 | *.pyc
380 | 
381 | # Cake - Uncomment if you are using it
382 | # tools/**
383 | # !tools/packages.config
384 | 
385 | # Tabs Studio
386 | *.tss
387 | 
388 | # Telerik's JustMock configuration file
389 | *.jmconfig
390 | 
391 | # BizTalk build output
392 | *.btp.cs
393 | *.btm.cs
394 | *.odx.cs
395 | *.xsd.cs
396 | 
397 | # OpenCover UI analysis results
398 | OpenCover/
399 | 
400 | # Azure Stream Analytics local run output
401 | ASALocalRun/
402 | 
403 | # MSBuild Binary and Structured Log
404 | *.binlog
405 | 
406 | # NVidia Nsight GPU debugger configuration file
407 | *.nvuser
408 | 
409 | # MFractors (Xamarin productivity tool) working folder
410 | .mfractor/
411 | 
412 | # Local History for Visual Studio
413 | .localhistory/
414 | 
415 | # BeatPulse healthcheck temp database
416 | healthchecksdb
417 | 
418 | # Backup folder for Package Reference Convert tool in Visual Studio 2017
419 | MigrationBackup/
420 | 
421 | ### Project specific ###
422 | bin/
423 | *.sln
424 | *.vcxproj
425 | *.vcxproj.filters
426 | *.vcxproj.user


--------------------------------------------------------------------------------
/JITYSC/src/ysc.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | #include <vector>
  3 | #include <map>
  4 | 
  5 | #define OSTART(size) constexpr int SIZE = size; if (label_mode) {}  else {
  6 | #define OEND }; cur_ip += SIZE ;
  7 | 
  8 | #pragma pack(push, 1)
  9 | struct uint24_t
 10 | {
 11 | 	int value : 24;
 12 | };
 13 | #pragma pack(pop)
 14 | 
 15 | #define PUSH8(t) *(uint8_t*)opcode_stream = (uint8_t)t; opcode_stream += 1;
 16 | #define PUSH16(t) *(uint16_t*)opcode_stream = (uint16_t)t; opcode_stream += 2;
 17 | #define PUSH32(t) *(uint32_t*)opcode_stream = (uint32_t)t; opcode_stream += 4;
 18 | #define PUSH24(t) (*(uint24_t*)opcode_stream).value = (uint32_t)t; opcode_stream += 3;
 19 | 
 20 | namespace ysc {
 21 | 	class program {
 22 | 		using callback_t = void(*)(program& prog);
 23 | 		enum class Opcode : uint8_t
 24 | 		{
 25 | 			NOP,
 26 | 			IADD,
 27 | 			ISUB,
 28 | 			IMUL,
 29 | 			IDIV,
 30 | 			IMOD,
 31 | 			INOT,
 32 | 			INEG,
 33 | 			IEQ,
 34 | 			INE,
 35 | 			IGT,
 36 | 			IGE,
 37 | 			ILT,
 38 | 			ILE,
 39 | 			FADD,
 40 | 			FSUB,
 41 | 			FMUL,
 42 | 			FDIV,
 43 | 			FMOD,
 44 | 			FNEG,
 45 | 			FEQ,
 46 | 			FNE,
 47 | 			FGT,
 48 | 			FGE,
 49 | 			FLT,
 50 | 			FLE,
 51 | 			VADD,
 52 | 			VSUB,
 53 | 			VMUL,
 54 | 			VDIV,
 55 | 			VNEG,
 56 | 			IAND,
 57 | 			IOR,
 58 | 			IXOR,
 59 | 			I2F,
 60 | 			F2I,
 61 | 			F2V,
 62 | 			PUSH_CONST_U8,
 63 | 			PUSH_CONST_U8_U8,
 64 | 			PUSH_CONST_U8_U8_U8,
 65 | 			PUSH_CONST_U32,
 66 | 			PUSH_CONST_F,
 67 | 			DUP,
 68 | 			DROP,
 69 | 			NATIVE,
 70 | 			ENTER,
 71 | 			LEAVE,
 72 | 			LOAD,
 73 | 			STORE,
 74 | 			STORE_REV,
 75 | 			LOAD_N,
 76 | 			STORE_N,
 77 | 			ARRAY_U8,
 78 | 			ARRAY_U8_LOAD,
 79 | 			ARRAY_U8_STORE,
 80 | 			LOCAL_U8,
 81 | 			LOCAL_U8_LOAD,
 82 | 			LOCAL_U8_STORE,
 83 | 			STATIC_U8,
 84 | 			STATIC_U8_LOAD,
 85 | 			STATIC_U8_STORE,
 86 | 			IADD_U8,
 87 | 			IMUL_U8,
 88 | 			IOFFSET,
 89 | 			IOFFSET_U8,
 90 | 			IOFFSET_U8_LOAD,
 91 | 			IOFFSET_U8_STORE,
 92 | 			PUSH_CONST_S16,
 93 | 			IADD_S16,
 94 | 			IMUL_S16,
 95 | 			IOFFSET_S16,
 96 | 			IOFFSET_S16_LOAD,
 97 | 			IOFFSET_S16_STORE,
 98 | 			ARRAY_U16,
 99 | 			ARRAY_U16_LOAD,
100 | 			ARRAY_U16_STORE,
101 | 			LOCAL_U16,
102 | 			LOCAL_U16_LOAD,
103 | 			LOCAL_U16_STORE,
104 | 			STATIC_U16,
105 | 			STATIC_U16_LOAD,
106 | 			STATIC_U16_STORE,
107 | 			GLOBAL_U16,
108 | 			GLOBAL_U16_LOAD,
109 | 			GLOBAL_U16_STORE,
110 | 			J,
111 | 			JZ,
112 | 			IEQ_JZ,
113 | 			INE_JZ,
114 | 			IGT_JZ,
115 | 			IGE_JZ,
116 | 			ILT_JZ,
117 | 			ILE_JZ,
118 | 			CALL,
119 | 			GLOBAL_U24,
120 | 			GLOBAL_U24_LOAD,
121 | 			GLOBAL_U24_STORE,
122 | 			PUSH_CONST_U24,
123 | 			SWITCH,
124 | 			STRING,
125 | 			STRINGHASH,
126 | 			TEXT_LABEL_ASSIGN_STRING,
127 | 			TEXT_LABEL_ASSIGN_INT,
128 | 			TEXT_LABEL_APPEND_STRING,
129 | 			TEXT_LABEL_APPEND_INT,
130 | 			TEXT_LABEL_COPY,
131 | 			CATCH,
132 | 			THROW,
133 | 			CALLINDIRECT,
134 | 			PUSH_CONST_M1,
135 | 			PUSH_CONST_0,
136 | 			PUSH_CONST_1,
137 | 			PUSH_CONST_2,
138 | 			PUSH_CONST_3,
139 | 			PUSH_CONST_4,
140 | 			PUSH_CONST_5,
141 | 			PUSH_CONST_6,
142 | 			PUSH_CONST_7,
143 | 			PUSH_CONST_FM1,
144 | 			PUSH_CONST_F0,
145 | 			PUSH_CONST_F1,
146 | 			PUSH_CONST_F2,
147 | 			PUSH_CONST_F3,
148 | 			PUSH_CONST_F4,
149 | 			PUSH_CONST_F5,
150 | 			PUSH_CONST_F6,
151 | 			PUSH_CONST_F7
152 | 		};
153 | 
154 | 	public:
155 | 		std::vector<uint64_t> native_table{};
156 | 		std::uint8_t* opcodes;
157 | 		std::uint32_t opcode_size;
158 | 		uint32_t current_params{};
159 | 
160 | 		std::vector<const char*> m_strings;
161 | 	private:
162 | 		std::map<const char*, uint32_t> labels{};
163 | 		std::uint32_t cur_ip = 0;
164 | 		/////std::uint32_t nsize;
165 | 		std::uint8_t* opcode_stream;
166 | 		bool label_mode = false;
167 | 		int m_string_index;
168 | 
169 | 		inline uint16_t get_or_make_native_idx(uint64_t nhash)
170 | 		{
171 | 			native_table.emplace_back(nhash);
172 | 			for (int i = 0; i < native_table.size(); i++) if (native_table[i] == nhash) return i;
173 | 			__assume(0);
174 | 		}
175 | 
176 | 		inline uint32_t get_label_ip(const char* label) {
177 | 			if (labels.count(label) == 0) throw "cannot find label";
178 | 			return labels[label];
179 | 		}
180 | 
181 | 	public:
182 | 		inline program(callback_t cb) :
183 | 			cur_ip(0)
184 | 		{
185 | 			opcodes = new uint8_t[2048];
186 | 			label_mode = true;
187 | 			cb(*this);
188 | 			label_mode = false;
189 | 			cur_ip = 0;
190 | 			opcode_stream = opcodes;
191 | 			cb(*this);
192 | 
193 | 			opcode_size = (opcode_stream - opcodes) + 1;
194 | 		}
195 | 
196 | 		inline ~program()
197 | 		{
198 | 			delete[] opcodes;
199 | 		}
200 | 
201 | 		inline void push(uint32_t val) {
202 | 			OSTART(5)
203 | 				PUSH8(Opcode::PUSH_CONST_U32)
204 | 				PUSH32(val)
205 | 			OEND
206 | 		}
207 | 
208 | 		inline void pushf(float val) {
209 | 			OSTART(5)
210 | 				PUSH8(Opcode::PUSH_CONST_U32)
211 | 				PUSH32(*(uint32_t*)&val)
212 | 			OEND
213 | 		}
214 | 
215 | 		inline void iadd() {
216 | 			OSTART(1)
217 | 				PUSH8(Opcode::IADD)
218 | 			OEND
219 | 		}
220 | 
221 | 		inline void isub() {
222 | 			OSTART(1)
223 | 				PUSH8(Opcode::ISUB)
224 | 			OEND
225 | 		}
226 | 
227 | 		inline void imul() {
228 | 			OSTART(1)
229 | 				PUSH8(Opcode::IMUL)
230 | 			OEND
231 | 		}
232 | 
233 | 		inline void idiv() {
234 | 			OSTART(1)
235 | 				PUSH8(Opcode::IDIV)
236 | 			OEND
237 | 		}
238 | 
239 | 		inline void fadd() {
240 | 			OSTART(1)
241 | 				PUSH8(Opcode::FADD)
242 | 			OEND
243 | 		}
244 | 
245 | 		inline void fsub() {
246 | 			OSTART(1)
247 | 				PUSH8(Opcode::FSUB)
248 | 			OEND
249 | 		}
250 | 
251 | 		inline void fmul() {
252 | 			OSTART(1)
253 | 				PUSH8(Opcode::FMUL)
254 | 			OEND
255 | 		}
256 | 
257 | 		inline void fdiv() {
258 | 			OSTART(1)
259 | 				PUSH8(Opcode::FDIV)
260 | 			OEND
261 | 		}
262 | 
263 | 		inline void vadd() {
264 | 			OSTART(1)
265 | 				PUSH8(Opcode::VADD)
266 | 			OEND
267 | 		}
268 | 
269 | 		inline void vsub() {
270 | 			OSTART(1)
271 | 				PUSH8(Opcode::VSUB)
272 | 			OEND
273 | 		}
274 | 
275 | 		inline void vmul() {
276 | 			OSTART(1)
277 | 				PUSH8(Opcode::VMUL)
278 | 			OEND
279 | 		}
280 | 
281 | 		inline void vdiv() {
282 | 			OSTART(1)
283 | 				PUSH8(Opcode::VDIV)
284 | 			OEND
285 | 		}
286 | 
287 | 		inline void ieq() {
288 | 			OSTART(1)
289 | 				PUSH8(Opcode::IEQ)
290 | 			OEND
291 | 		}
292 | 
293 | 		inline void inot() {
294 | 			OSTART(1)
295 | 				PUSH8(Opcode::INOT)
296 | 			OEND
297 | 		}
298 | 
299 | 		inline void ior() {
300 | 			OSTART(1)
301 | 				PUSH8(Opcode::IOR)
302 | 			OEND
303 | 		}
304 | 
305 | 		inline void iand() {
306 | 			OSTART(1)
307 | 				PUSH8(Opcode::IAND)
308 | 			OEND
309 | 		}
310 | 
311 | 		inline void label(const char* label) {
312 | 			if (label_mode) labels[label] = cur_ip;
313 | 		}
314 | 
315 | 		inline void enter(const char* name, uint8_t params, uint16_t locals) {
316 | 			if (label_mode) labels[name] = cur_ip;
317 | 			OSTART(5)
318 | 				PUSH8(Opcode::ENTER)
319 | 				PUSH8(params)
320 | 				PUSH16(locals)
321 | 				PUSH8(0) // funcNameLen
322 | 
323 | 				current_params = params;
324 | 			OEND
325 | 		}
326 | 
327 | 		inline void leave(uint8_t params, uint8_t returns) {
328 | 			OSTART(3)
329 | 				PUSH8(Opcode::LEAVE)
330 | 				PUSH8(params)
331 | 				PUSH8(returns)
332 | 			OEND
333 | 		}
334 | 
335 | 		inline void drop() {
336 | 			OSTART(1)
337 | 				PUSH8(Opcode::DROP)
338 | 			OEND
339 | 		}
340 | 
341 | 		inline void dup() {
342 | 			OSTART(1)
343 | 				PUSH8(Opcode::DUP)
344 | 			OEND
345 | 		}
346 | 
347 | 		inline void f2v() {
348 | 			OSTART(1)
349 | 				PUSH8(Opcode::F2V)
350 | 			OEND
351 | 		}
352 | 
353 | 		inline void native(uint64_t hash, uint8_t params, uint8_t returns) {
354 | 			OSTART(4)
355 | 				PUSH8(Opcode::NATIVE)
356 | 				PUSH8((params << 2) | (returns & 0x3))
357 | 				std::uint32_t native_idx = get_or_make_native_idx(hash);
358 | 				PUSH8((native_idx >> 8));
359 | 				PUSH8((native_idx & 0x00FF));
360 | 			OEND
361 | 		}
362 | 
363 | 		inline void call(const char* label) {
364 | 			OSTART(4)
365 | 				PUSH8(Opcode::CALL)
366 | 				PUSH24(get_label_ip(label))
367 | 			OEND
368 | 		}
369 | 
370 | 		inline void jmp(const char* label) {
371 | 			OSTART(3)
372 | 				PUSH8(Opcode::J)
373 | 				PUSH16(((uint16_t)get_label_ip(label)) - ((uint16_t)cur_ip) - 3)
374 | 			OEND
375 | 		}
376 | 
377 | 		inline void jz(const char* label) {
378 | 			OSTART(3)
379 | 				PUSH8(Opcode::JZ)
380 | 				PUSH16(((uint16_t)get_label_ip(label)) - ((uint16_t)cur_ip) - 3)
381 | 			OEND
382 | 		}
383 | 
384 | 		inline void je(const char* label) {
385 | 			OSTART(3)
386 | 				PUSH8(Opcode::INE_JZ)
387 | 				PUSH16(((uint16_t)get_label_ip(label)) - ((uint16_t)cur_ip) - 3)
388 | 			OEND
389 | 		}
390 | 
391 | 		inline void jne(const char* label) {
392 | 			OSTART(3)
393 | 				PUSH8(Opcode::IEQ_JZ)
394 | 				PUSH16(((uint16_t)get_label_ip(label)) - ((uint16_t)cur_ip) - 3)
395 | 			OEND
396 | 		}
397 | 
398 | 		inline void load() {
399 | 			OSTART(1)
400 | 				PUSH8(Opcode::LOAD)
401 | 			OEND
402 | 		}
403 | 
404 | 		inline void store() {
405 | 			OSTART(1)
406 | 				PUSH8(Opcode::STORE)
407 | 			OEND
408 | 		}
409 | 
410 | 		inline void global(uint32_t idx) {
411 | 			OSTART(4)
412 | 				PUSH8(Opcode::GLOBAL_U24)
413 | 				PUSH24(idx)
414 | 			OEND
415 | 		}
416 | 
417 | 		inline void global_load(uint32_t idx) {
418 | 			OSTART(4)
419 | 				PUSH8(Opcode::GLOBAL_U24_LOAD)
420 | 				PUSH24(idx)
421 | 			OEND
422 | 		}
423 | 
424 | 		inline void global_store(uint32_t idx) {
425 | 			OSTART(4)
426 | 				PUSH8(Opcode::GLOBAL_U24_STORE)
427 | 				PUSH24(idx)
428 | 			OEND
429 | 		}
430 | 
431 | 		inline void local(uint16_t idx) {
432 | 			OSTART(3)
433 | 				PUSH8(Opcode::STATIC_U16)
434 | 				PUSH16(idx)
435 | 			OEND
436 | 		}
437 | 
438 | 		inline void local_load(uint16_t idx) {
439 | 			OSTART(3)
440 | 				PUSH8(Opcode::STATIC_U16_LOAD)
441 | 				PUSH16(idx)
442 | 			OEND
443 | 		}
444 | 
445 | 		inline void local_store(uint16_t idx) {
446 | 			OSTART(3)
447 | 				PUSH8(Opcode::STATIC_U16_STORE)
448 | 				PUSH16(idx)
449 | 			OEND
450 | 		}
451 | 
452 | 		inline void offset(uint16_t off) {
453 | 			OSTART(3)
454 | 				PUSH8(Opcode::IOFFSET_S16)
455 | 				PUSH16(off)
456 | 			OEND
457 | 		}
458 | 
459 | 		inline void offset_load(uint16_t off) 
460 | 		{
461 | 			OSTART(3)
462 | 				PUSH8(Opcode::IOFFSET_S16_LOAD)
463 | 				PUSH16(off)
464 | 			OEND
465 | 		}
466 | 
467 | 		inline void offset_store(uint16_t off) 
468 | 		{
469 | 			OSTART(3)
470 | 				PUSH8(Opcode::IOFFSET_S16_STORE)
471 | 				PUSH16(off)
472 | 			OEND
473 | 		}
474 | 
475 | 		inline void array(uint16_t size) 
476 | 		{
477 | 			OSTART(3)
478 | 				PUSH8(Opcode::ARRAY_U16)
479 | 				PUSH16(size)
480 | 			OEND
481 | 		}
482 | 
483 | 		inline void array_load(uint16_t size) 
484 | 		{
485 | 			OSTART(3)
486 | 				PUSH8(Opcode::ARRAY_U16_LOAD)
487 | 				PUSH16(size)
488 | 			OEND
489 | 		}
490 | 
491 | 		inline void array_store(uint16_t size) 
492 | 		{
493 | 			OSTART(3)
494 | 				PUSH8(Opcode::ARRAY_U16_STORE)
495 | 				PUSH16(size)
496 | 			OEND
497 | 		}
498 | 
499 | 		inline void frame(uint16_t idx)
500 | 		{
501 | 			OSTART(3)
502 | 				PUSH8(Opcode::LOCAL_U16)
503 | 				PUSH16(2+current_params+idx)
504 | 			OEND
505 | 		}
506 | 
507 | 		inline void frame_load(uint16_t idx)
508 | 		{
509 | 			OSTART(3)
510 | 				PUSH8(Opcode::LOCAL_U16_LOAD)
511 | 				PUSH16(2 + current_params + idx)
512 | 			OEND
513 | 		}
514 | 
515 | 		inline void frame_store(uint16_t idx)
516 | 		{
517 | 			OSTART(3)
518 | 				PUSH8(Opcode::LOCAL_U16_STORE)
519 | 				PUSH16(2 + current_params + idx)
520 | 			OEND
521 | 		}
522 | 	};
523 | };
524 | 
525 | #undef OSTART
526 | #undef OEND
527 | #undef PUSH8
528 | #undef PUSH16
529 | #undef PUSH32
530 | #undef PUSH24


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