902 lines
26 KiB
C++
902 lines
26 KiB
C++
// Copyright 2023 xensik. All rights reserved.
|
|
//
|
|
// Use of this source code is governed by a GNU GPLv3 license
|
|
// that can be found in the LICENSE file.
|
|
|
|
#include "stdinc.hpp"
|
|
#include "utils/zlib.hpp"
|
|
#include "utils/file.hpp"
|
|
#include "utils/string.hpp"
|
|
#include "iw5/iw5_pc.hpp"
|
|
#include "iw5/iw5_ps.hpp"
|
|
#include "iw5/iw5_xb.hpp"
|
|
#include "iw6/iw6_pc.hpp"
|
|
#include "iw6/iw6_ps.hpp"
|
|
#include "iw6/iw6_xb.hpp"
|
|
#include "iw7/iw7.hpp"
|
|
#include "iw8/iw8.hpp"
|
|
#include "iw9/iw9.hpp"
|
|
#include "s1/s1_pc.hpp"
|
|
#include "s1/s1_ps.hpp"
|
|
#include "s1/s1_xb.hpp"
|
|
#include "s2/s2.hpp"
|
|
#include "s4/s4.hpp"
|
|
#include "h1/h1.hpp"
|
|
#include "h2/h2.hpp"
|
|
#include "t6/t6.hpp"
|
|
|
|
namespace fs = std::filesystem;
|
|
|
|
namespace xsk
|
|
{
|
|
|
|
enum class encd { _, source, assembly, binary };
|
|
enum class mode { _, assemble, disassemble, compile, decompile, parse, rename };
|
|
enum class game { _, iw5ps, iw5xb, iw6ps, iw6xb, s1ps, s1xb, iw5, iw6, iw7, iw8, iw9, s1, s2, s4, h1, h2, t6 };
|
|
|
|
std::unordered_map<std::string_view, encd> const exts =
|
|
{
|
|
{ ".gsc", encd::source },
|
|
{ ".cgsc", encd::binary },
|
|
{ ".gscbin", encd::binary },
|
|
{ ".gscasm", encd::assembly },
|
|
};
|
|
|
|
std::unordered_map<std::string_view, mode> const modes =
|
|
{
|
|
{ "asm", mode::assemble },
|
|
{ "disasm", mode::disassemble },
|
|
{ "comp", mode::compile },
|
|
{ "decomp", mode::decompile },
|
|
{ "parse", mode::parse },
|
|
{ "rename", mode::rename },
|
|
};
|
|
|
|
std::unordered_map<std::string_view, game> const games =
|
|
{
|
|
{ "iw5ps", game::iw5ps },
|
|
{ "iw5xb", game::iw5xb },
|
|
{ "iw6ps", game::iw6ps },
|
|
{ "iw6xb", game::iw6xb },
|
|
{ "s1ps", game::s1ps },
|
|
{ "s1xb", game::s1xb },
|
|
{ "iw5", game::iw5 },
|
|
{ "iw6", game::iw6 },
|
|
{ "iw7", game::iw7 },
|
|
{ "iw8", game::iw8 },
|
|
{ "iw9", game::iw9 },
|
|
{ "s1", game::s1 },
|
|
{ "s2", game::s2 },
|
|
{ "s4", game::s4 },
|
|
{ "h1", game::h1 },
|
|
{ "h2", game::h2 },
|
|
{ "t6", game::t6 },
|
|
};
|
|
|
|
std::map<game, std::string_view> const games_rev =
|
|
{
|
|
{ game::iw5ps, "iw5ps", },
|
|
{ game::iw5xb, "iw5xb" },
|
|
{ game::iw6ps, "iw6ps" },
|
|
{ game::iw6xb, "iw6xb" },
|
|
{ game::s1ps, "s1ps" },
|
|
{ game::s1xb, "s1xb" },
|
|
{ game::iw5, "iw5" },
|
|
{ game::iw6, "iw6" },
|
|
{ game::iw7, "iw7" },
|
|
{ game::iw8, "iw8" },
|
|
{ game::iw9, "iw9" },
|
|
{ game::s1, "s1" },
|
|
{ game::s2, "s2" },
|
|
{ game::s4, "s4" },
|
|
{ game::h1, "h1" },
|
|
{ game::h2, "h2" },
|
|
{ game::t6, "t6" },
|
|
};
|
|
|
|
std::map<mode, encd> const encds =
|
|
{
|
|
{ mode::assemble , encd::assembly },
|
|
{ mode::disassemble, encd::binary },
|
|
{ mode::compile, encd::source },
|
|
{ mode::decompile, encd::binary },
|
|
};
|
|
|
|
auto overwrite_prompt(std::string const& file) -> bool
|
|
{
|
|
auto overwrite = true;
|
|
|
|
if (utils::file::exists(file))
|
|
{
|
|
do
|
|
{
|
|
std::cout << "File \"" << file << "\" already exists, overwrite? [Y/n]: ";
|
|
auto result = std::getchar();
|
|
|
|
if (result == '\n' || result == 'Y' || result == 'y')
|
|
{
|
|
break;
|
|
}
|
|
else if (result == 'N' || result == 'n')
|
|
{
|
|
overwrite = false;
|
|
break;
|
|
}
|
|
} while (true);
|
|
}
|
|
|
|
return overwrite;
|
|
}
|
|
|
|
namespace gsc
|
|
{
|
|
|
|
std::map<game, std::unique_ptr<context>> contexts;
|
|
std::map<mode, std::function<void(game game, fs::path file, fs::path rel)>> funcs;
|
|
bool zonetool = false;
|
|
|
|
/*auto choose_resolver_file_name(uint32_t id, game& game) -> std::string
|
|
{
|
|
switch (game)
|
|
{
|
|
// case game::iw5c:
|
|
// return iw5c::resolver::token_name(static_cast<std::uint16_t>(id));
|
|
// case game::iw6c:
|
|
// return iw6c::resolver::token_name(static_cast<std::uint16_t>(id));
|
|
// case game::s1c:
|
|
// return s1c::resolver::token_name(static_cast<std::uint16_t>(id));
|
|
// case game::iw5:
|
|
// return iw5::resolver::token_name(static_cast<std::uint16_t>(id));
|
|
// case game::iw6:
|
|
// return iw6::resolver::token_name(static_cast<std::uint16_t>(id));
|
|
// case game::iw7:
|
|
// return iw7::resolver::token_name(id);
|
|
// case game::iw8:
|
|
// return iw8::resolver::token_name(id);
|
|
// case game::s1:
|
|
// return s1::resolver::token_name(static_cast<std::uint16_t>(id));
|
|
// case game::s2:
|
|
// return s2::resolver::token_name(static_cast<std::uint16_t>(id));
|
|
// case game::s4:
|
|
// return s4::resolver::token_name(id);
|
|
// case game::h1:
|
|
// return h1::resolver::token_name(static_cast<std::uint16_t>(id));
|
|
// case game::h2:
|
|
// return h2::resolver::token_name(static_cast<std::uint16_t>(id));
|
|
default:
|
|
return "";
|
|
}
|
|
}*/
|
|
|
|
auto assemble_file(game game, fs::path file, fs::path rel) -> void
|
|
{
|
|
try
|
|
{
|
|
if (file.extension() != ".gscasm")
|
|
throw std::runtime_error("expected .gscasm file");
|
|
|
|
rel = fs::path{ games_rev.at(game) } / rel / file.filename().replace_extension((zonetool ? ".cgsc" : ".gscbin"));
|
|
|
|
auto data = utils::file::read(file);
|
|
auto outasm = contexts[game]->source().parse_assembly(data);
|
|
auto outbin = contexts[game]->assembler().assemble(*outasm);
|
|
|
|
if (true/*overwrite_prompt(file + (zonetool ? ".cgsc" : ".gscbin"))*/)
|
|
{
|
|
if (zonetool)
|
|
{
|
|
auto path = fs::path{ "compiled" } / rel;
|
|
utils::file::save(path, outbin.first.data, outbin.first.size);
|
|
utils::file::save(path.replace_extension(".cgsc.stack"), outbin.second.data, outbin.second.size);
|
|
fmt::print("compiled {}\n", rel.generic_string());
|
|
}
|
|
else
|
|
{
|
|
asset script;
|
|
script.name = "GSC"s;
|
|
|
|
script.bytecode.resize(outbin.first.size);
|
|
std::memcpy(script.bytecode.data(), outbin.first.data, script.bytecode.size());
|
|
|
|
script.buffer.resize(outbin.second.size);
|
|
std::memcpy(script.buffer.data(), outbin.second.data, script.buffer.size());
|
|
script.buffer = utils::zlib::compress(script.buffer);
|
|
|
|
script.len = static_cast<std::uint32_t>(outbin.second.size);
|
|
script.compressedLen = static_cast<std::uint32_t>(script.buffer.size());
|
|
script.bytecodeLen = static_cast<std::uint32_t>(script.bytecode.size());
|
|
|
|
auto result = script.serialize();
|
|
utils::file::save(fs::path{ "compiled" } / rel, result);
|
|
fmt::print("compiled {}\n", rel.generic_string());
|
|
}
|
|
}
|
|
}
|
|
catch (std::exception const& e)
|
|
{
|
|
std::cerr << fmt::format("{} at {}\n", e.what(), file.generic_string());
|
|
}
|
|
}
|
|
|
|
auto disassemble_file(game game, fs::path file, fs::path rel) -> void
|
|
{
|
|
try
|
|
{
|
|
auto script = std::vector<std::uint8_t>{};
|
|
auto stack = std::vector<std::uint8_t>{};
|
|
|
|
if (zonetool)
|
|
{
|
|
if (file.extension() != ".cgsc")
|
|
throw std::runtime_error("expected .cgsc file");
|
|
|
|
auto fbuf = file;
|
|
rel = fs::path{ games_rev.at(game) } / rel / file.filename().replace_extension(".gsc");
|
|
|
|
script = utils::file::read(file);
|
|
stack = utils::file::read(fbuf.replace_extension(".cgsc.stack"));
|
|
}
|
|
else
|
|
{
|
|
if (file.extension() != ".gscbin")
|
|
throw std::runtime_error("expected .gscbin file");
|
|
|
|
rel = fs::path{ games_rev.at(game) } / rel / file.filename().replace_extension(".gscasm");
|
|
|
|
auto data = utils::file::read(file);
|
|
|
|
asset asset;
|
|
asset.deserialize(data);
|
|
|
|
script = std::move(asset.bytecode);
|
|
stack = utils::zlib::decompress(asset.buffer, asset.len);
|
|
}
|
|
|
|
auto outasm = contexts[game]->disassembler().disassemble(script, stack);
|
|
auto outsrc = contexts[game]->source().dump(*outasm);
|
|
|
|
utils::file::save(fs::path{ "disassembled" } / rel, outsrc);
|
|
fmt::print("disassembled {}\n", rel.generic_string());
|
|
}
|
|
catch (std::exception const& e)
|
|
{
|
|
std::cerr << fmt::format("{} at {}\n", e.what(), file.generic_string());
|
|
}
|
|
}
|
|
|
|
auto compile_file(game game, fs::path file, fs::path rel) -> void
|
|
{
|
|
try
|
|
{
|
|
if (file.extension() != ".gsc")
|
|
throw std::runtime_error("expected .gsc file");
|
|
|
|
rel = fs::path{ games_rev.at(game) } / rel / file.filename().replace_extension((zonetool ? ".cgsc" : ".gscbin"));
|
|
|
|
auto data = utils::file::read(file);
|
|
auto outasm = contexts[game]->compiler().compile(file.string(), data);
|
|
auto outbin = contexts[game]->assembler().assemble(*outasm);
|
|
|
|
if (true/*overwrite_prompt(file + (zonetool ? ".cgsc" : ".gscbin"))*/)
|
|
{
|
|
if (zonetool)
|
|
{
|
|
auto path = fs::path{ "compiled" } / rel;
|
|
utils::file::save(path, outbin.first.data, outbin.first.size);
|
|
utils::file::save(path.replace_extension(".cgsc.stack"), outbin.second.data, outbin.second.size);
|
|
fmt::print("compiled {}\n", rel.generic_string());
|
|
}
|
|
else
|
|
{
|
|
asset script;
|
|
script.name = "GSC"s;
|
|
|
|
script.bytecode.resize(outbin.first.size);
|
|
std::memcpy(script.bytecode.data(), outbin.first.data, script.bytecode.size());
|
|
|
|
script.buffer.resize(outbin.second.size);
|
|
std::memcpy(script.buffer.data(), outbin.second.data, script.buffer.size());
|
|
script.buffer = utils::zlib::compress(script.buffer);
|
|
|
|
script.len = static_cast<std::uint32_t>(outbin.second.size);
|
|
script.compressedLen = static_cast<std::uint32_t>(script.buffer.size());
|
|
script.bytecodeLen = static_cast<std::uint32_t>(script.bytecode.size());
|
|
|
|
auto result = script.serialize();
|
|
utils::file::save(fs::path{ "compiled" } / rel, result);
|
|
fmt::print("compiled {}\n", rel.generic_string());
|
|
}
|
|
}
|
|
}
|
|
catch (std::exception const& e)
|
|
{
|
|
std::cerr << fmt::format("{} at {}\n", e.what(), file.generic_string());
|
|
}
|
|
}
|
|
|
|
auto decompile_file(game game, fs::path file, fs::path rel) -> void
|
|
{
|
|
try
|
|
{
|
|
auto script = std::vector<std::uint8_t>{};
|
|
auto stack = std::vector<std::uint8_t>{};
|
|
|
|
if (zonetool)
|
|
{
|
|
if (file.extension() != ".cgsc")
|
|
throw std::runtime_error("expected .cgsc file");
|
|
|
|
auto fbuf = file;
|
|
rel = fs::path{ games_rev.at(game) } / rel / file.filename().replace_extension(".gsc");
|
|
|
|
script = utils::file::read(file);
|
|
stack = utils::file::read(fbuf.replace_extension(".cgsc.stack"));
|
|
}
|
|
else
|
|
{
|
|
if (file.extension() != ".gscbin")
|
|
throw std::runtime_error("expected .gscbin file");
|
|
|
|
rel = fs::path{ games_rev.at(game) } / rel / file.filename().replace_extension(".gsc");
|
|
|
|
auto data = utils::file::read(file);
|
|
|
|
asset asset;
|
|
asset.deserialize(data);
|
|
|
|
script = std::move(asset.bytecode);
|
|
stack = utils::zlib::decompress(asset.buffer, asset.len);
|
|
}
|
|
|
|
auto outasm = contexts[game]->disassembler().disassemble(script, stack);
|
|
auto outast = contexts[game]->decompiler().decompile(*outasm);
|
|
auto outsrc = contexts[game]->source().dump(*outast);
|
|
|
|
utils::file::save(fs::path{ "decompiled" } / rel, outsrc);
|
|
fmt::print("decompiled {}\n", rel.generic_string());
|
|
}
|
|
catch (std::exception const& e)
|
|
{
|
|
std::cerr << fmt::format("{} at {}\n", e.what(), file.generic_string());
|
|
}
|
|
}
|
|
|
|
auto parse_file(game game, fs::path file, fs::path rel) -> void
|
|
{
|
|
try
|
|
{
|
|
if (file.extension() != ".gsc")
|
|
throw std::runtime_error("expected .gsc file");
|
|
|
|
rel = fs::path{ games_rev.at(game) } / rel / file.filename();
|
|
|
|
auto data = utils::file::read(file);
|
|
|
|
auto prog = contexts[game]->source().parse_program(file.string(), data);
|
|
utils::file::save(fs::path{ "parsed" } / rel, contexts[game]->source().dump(*prog));
|
|
fmt::print("parsed {}\n", rel.generic_string());
|
|
}
|
|
catch (std::exception const& e)
|
|
{
|
|
std::cerr << fmt::format("{} at {}\n", e.what(), file.generic_string());
|
|
}
|
|
}
|
|
|
|
auto rename_file(game game, fs::path file, fs::path rel) -> void
|
|
{
|
|
try
|
|
{
|
|
if (file.extension() != ".cgsc" && file.extension() != ".gsc" && file.extension() != ".csc" && file.extension() != ".gscbin" && file.extension() != ".cscbin")
|
|
return;
|
|
|
|
auto ext = file.extension();
|
|
auto zt = file.extension() == ".cgsc";
|
|
|
|
if (game == game::iw9)
|
|
{
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
auto name = file.filename().replace_extension().string();
|
|
|
|
if (utils::string::is_number(name))
|
|
{
|
|
name = contexts[game]->token_name(std::stoul(name));
|
|
}
|
|
else if (utils::string::is_hex_number(name))
|
|
{
|
|
name = contexts[game]->token_name(std::stoul(name, nullptr, 16));
|
|
}
|
|
|
|
if (!name.starts_with("_id_"))
|
|
{
|
|
rel = fs::path{ games_rev.at(game) } / rel / name;
|
|
rel.replace_extension(ext);
|
|
}
|
|
else
|
|
{
|
|
rel = fs::path{ games_rev.at(game) } / rel / file.filename();
|
|
}
|
|
}
|
|
|
|
auto data = utils::file::read(file);
|
|
utils::file::save(fs::path{ "renamed" } / rel, data);
|
|
fmt::print("renamed {} -> {}\n", file.filename().generic_string(), rel.generic_string());
|
|
|
|
if (zt)
|
|
{
|
|
auto stack = utils::file::read(file.replace_extension(".cgsc.stack"));
|
|
utils::file::save(fs::path{ "renamed" } / rel.replace_extension(".cgsc.stack"), stack);
|
|
fmt::print("renamed {} -> {}\n", file.filename().generic_string(), rel.generic_string());
|
|
}
|
|
}
|
|
catch (std::exception const& e)
|
|
{
|
|
std::cerr << fmt::format("{} at {}\n", e.what(), file.generic_string());
|
|
}
|
|
}
|
|
|
|
std::unordered_map<std::string, std::vector<std::uint8_t>> files;
|
|
|
|
auto read_file_cb(std::string const& name) -> std::pair<buffer, buffer>
|
|
{
|
|
auto data = utils::file::read(fs::path{ name });
|
|
|
|
if(name.ends_with(".gscbin") || (!name.ends_with(".gsh") && !name.ends_with(".gsc")))
|
|
{
|
|
asset s;
|
|
s.deserialize(data);
|
|
auto stk = utils::zlib::decompress(s.buffer, s.len);
|
|
auto res1 = files.insert({ name + "1", std::move(s.bytecode) });
|
|
auto res2 = files.insert({ name + "2", std::move(stk) });
|
|
|
|
if(res1.second && res2.second)
|
|
{
|
|
return { {res1.first->second.data(), res1.first->second.size() }, {res2.first->second.data(), res2.first->second.size() } };
|
|
}
|
|
}
|
|
else
|
|
{
|
|
auto res = files.insert({ name, std::move(data) });
|
|
|
|
if(res.second)
|
|
{
|
|
return { {res.first->second.data(), res.first->second.size() }, {} };
|
|
}
|
|
}
|
|
|
|
throw std::runtime_error("file read error");
|
|
}
|
|
|
|
auto init_iw5() -> void
|
|
{
|
|
if (!contexts.contains(game::iw5))
|
|
{
|
|
contexts[game::iw5] = std::make_unique<iw5_pc::context>();
|
|
contexts[game::iw5]->init(build::prod, read_file_cb);
|
|
}
|
|
}
|
|
|
|
auto init_iw5_ps() -> void
|
|
{
|
|
if (!contexts.contains(game::iw5ps))
|
|
{
|
|
contexts[game::iw5ps] = std::make_unique<iw5_ps::context>();
|
|
contexts[game::iw5ps]->init(build::prod, read_file_cb);
|
|
}
|
|
}
|
|
|
|
auto init_iw5_xb() -> void
|
|
{
|
|
if (!contexts.contains(game::iw5xb))
|
|
{
|
|
contexts[game::iw5xb] = std::make_unique<iw5_xb::context>();
|
|
contexts[game::iw5xb]->init(build::prod, read_file_cb);
|
|
}
|
|
}
|
|
|
|
auto init_iw6() -> void
|
|
{
|
|
if (!contexts.contains(game::iw6))
|
|
{
|
|
contexts[game::iw6] = std::make_unique<iw6_pc::context>();
|
|
contexts[game::iw6]->init(build::prod, read_file_cb);
|
|
}
|
|
}
|
|
|
|
auto init_iw6_ps() -> void
|
|
{
|
|
if (!contexts.contains(game::iw6ps))
|
|
{
|
|
contexts[game::iw6ps] = std::make_unique<iw6_ps::context>();
|
|
contexts[game::iw6ps]->init(build::prod, read_file_cb);
|
|
}
|
|
}
|
|
|
|
auto init_iw6_xb() -> void
|
|
{
|
|
if (!contexts.contains(game::iw6xb))
|
|
{
|
|
contexts[game::iw6xb] = std::make_unique<iw6_xb::context>();
|
|
contexts[game::iw6xb]->init(build::prod, read_file_cb);
|
|
}
|
|
}
|
|
|
|
auto init_iw7() -> void
|
|
{
|
|
if (!contexts.contains(game::iw7))
|
|
{
|
|
contexts[game::iw7] = std::make_unique<iw7::context>();
|
|
contexts[game::iw7]->init(build::prod, read_file_cb);
|
|
}
|
|
}
|
|
|
|
auto init_iw8() -> void
|
|
{
|
|
if (!contexts.contains(game::iw8))
|
|
{
|
|
contexts[game::iw8] = std::make_unique<iw8::context>();
|
|
contexts[game::iw8]->init(build::prod, read_file_cb);
|
|
}
|
|
}
|
|
|
|
auto init_iw9() -> void
|
|
{
|
|
if (!contexts.contains(game::iw9))
|
|
{
|
|
contexts[game::iw9] = std::make_unique<iw9::context>();
|
|
contexts[game::iw9]->init(build::prod, read_file_cb);
|
|
}
|
|
}
|
|
|
|
auto init_s1() -> void
|
|
{
|
|
if (!contexts.contains(game::s1))
|
|
{
|
|
contexts[game::s1] = std::make_unique<s1_pc::context>();
|
|
contexts[game::s1]->init(build::prod, read_file_cb);
|
|
}
|
|
}
|
|
|
|
auto init_s1_ps() -> void
|
|
{
|
|
if (!contexts.contains(game::s1ps))
|
|
{
|
|
contexts[game::s1ps] = std::make_unique<s1_ps::context>();
|
|
contexts[game::s1ps]->init(build::prod, read_file_cb);
|
|
}
|
|
}
|
|
|
|
auto init_s1_xb() -> void
|
|
{
|
|
if (!contexts.contains(game::s1xb))
|
|
{
|
|
contexts[game::s1xb] = std::make_unique<s1_xb::context>();
|
|
contexts[game::s1xb]->init(build::prod, read_file_cb);
|
|
}
|
|
}
|
|
|
|
auto init_s2() -> void
|
|
{
|
|
if (!contexts.contains(game::s2))
|
|
{
|
|
contexts[game::s2] = std::make_unique<s2::context>();
|
|
contexts[game::s2]->init(build::prod, read_file_cb);
|
|
}
|
|
}
|
|
|
|
auto init_s4() -> void
|
|
{
|
|
if (!contexts.contains(game::s4))
|
|
{
|
|
contexts[game::s4] = std::make_unique<s4::context>();
|
|
contexts[game::s4]->init(build::prod, read_file_cb);
|
|
}
|
|
}
|
|
|
|
auto init_h1() -> void
|
|
{
|
|
if (!contexts.contains(game::h1))
|
|
{
|
|
contexts[game::h1] = std::make_unique<h1::context>();
|
|
contexts[game::h1]->init(build::prod, read_file_cb);
|
|
}
|
|
}
|
|
|
|
auto init_h2() -> void
|
|
{
|
|
if (!contexts.contains(game::h2))
|
|
{
|
|
contexts[game::h2] = std::make_unique<h2::context>();
|
|
contexts[game::h2]->init(build::prod, read_file_cb);
|
|
}
|
|
}
|
|
|
|
auto init(game game) -> void
|
|
{
|
|
funcs[mode::assemble] = assemble_file;
|
|
funcs[mode::disassemble] = disassemble_file;
|
|
funcs[mode::compile] = compile_file;
|
|
funcs[mode::decompile] = decompile_file;
|
|
funcs[mode::parse] = parse_file;
|
|
funcs[mode::rename] = rename_file;
|
|
|
|
switch (game)
|
|
{
|
|
case game::iw5: init_iw5(); break;
|
|
case game::iw5ps: init_iw5_ps(); break;
|
|
case game::iw5xb: init_iw5_xb(); break;
|
|
case game::iw6: init_iw6(); break;
|
|
case game::iw6ps: init_iw6_ps(); break;
|
|
case game::iw6xb: init_iw6_xb(); break;
|
|
case game::iw7: init_iw7(); break;
|
|
case game::iw8: init_iw8(); break;
|
|
case game::iw9: init_iw9(); break;
|
|
case game::s1: init_s1(); break;
|
|
case game::s1ps: init_s1_ps(); break;
|
|
case game::s1xb: init_s1_xb(); break;
|
|
case game::s2: init_s2(); break;
|
|
case game::s4: init_s4(); break;
|
|
case game::h1: init_h1(); break;
|
|
case game::h2: init_h2(); break;
|
|
default: break;
|
|
}
|
|
}
|
|
|
|
} // namespace xsk::gsc
|
|
|
|
namespace arc
|
|
{
|
|
|
|
std::map<game, context::ptr> contexts;
|
|
std::map<mode, std::function<void(game game, fs::path const& file, fs::path rel)>> funcs;
|
|
|
|
void assemble_file(game game, fs::path const& file, fs::path rel)
|
|
{
|
|
try
|
|
{
|
|
if (file.extension() != ".gscasm" && file.extension() != ".cscasm")
|
|
throw std::runtime_error("expected .gscasm or .cscasm file");
|
|
|
|
rel = fs::path{ games_rev.at(game) } / rel / file.filename().replace_extension((file.extension() == ".gscasm" ? ".gsc" : ".csc"));
|
|
|
|
auto& assembler = contexts[game]->assembler();
|
|
|
|
auto data = utils::file::read(file);
|
|
assembler.assemble(file.string(), data);
|
|
|
|
utils::file::save(fs::path{ "assembled" } / rel, assembler.output());
|
|
fmt::print("assembled {}\n", rel.generic_string());
|
|
}
|
|
catch (std::exception const& e)
|
|
{
|
|
std::cerr << fmt::format("{} at {}\n", e.what(), file.generic_string());
|
|
}
|
|
}
|
|
|
|
void disassemble_file(game game, fs::path const& file, fs::path rel)
|
|
{
|
|
try
|
|
{
|
|
if (file.extension() != ".gsc" && file.extension() != ".csc")
|
|
throw std::runtime_error("expected .gsc or .csc file");
|
|
|
|
rel = fs::path{ games_rev.at(game) } / rel / file.filename().replace_extension((file.extension() == ".gsc" ? ".gscasm" : ".cscasm"));
|
|
|
|
auto& disassembler = contexts[game]->disassembler();
|
|
|
|
auto data = utils::file::read(file.string());
|
|
disassembler.disassemble(file.string(), data);
|
|
|
|
utils::file::save(fs::path{ "disassembled" } / rel, disassembler.output_raw());
|
|
fmt::print("disassembled {}\n", rel.generic_string());
|
|
}
|
|
catch (std::exception const& e)
|
|
{
|
|
std::cerr << fmt::format("{} at {}\n", e.what(), file.generic_string());
|
|
}
|
|
}
|
|
|
|
void compile_file(game game, fs::path const& file, fs::path rel)
|
|
{
|
|
try
|
|
{
|
|
if (file.extension() != ".gsc" && file.extension() != ".csc")
|
|
throw std::runtime_error("expected .gsc or .csc file");
|
|
|
|
rel = fs::path{ games_rev.at(game) } / rel / file.filename();
|
|
|
|
auto& assembler = contexts[game]->assembler();
|
|
auto& compiler = contexts[game]->compiler();
|
|
|
|
auto data = utils::file::read(file);
|
|
|
|
compiler.compile(file.string(), data);
|
|
|
|
auto assembly = compiler.output();
|
|
|
|
assembler.assemble(file.string(), assembly);
|
|
|
|
utils::file::save(fs::path{ "compiled" } / rel, assembler.output());
|
|
fmt::print("compiled {}\n", rel.generic_string());
|
|
}
|
|
catch (std::exception const& e)
|
|
{
|
|
std::cerr << fmt::format("{} at {}\n", e.what(), file.generic_string());
|
|
}
|
|
}
|
|
|
|
void decompile_file(game game, fs::path const& file, fs::path rel)
|
|
{
|
|
try
|
|
{
|
|
if (file.extension() != ".gsc" && file.extension() != ".csc")
|
|
throw std::runtime_error("expected .gsc or .csc file");
|
|
|
|
rel = fs::path{ games_rev.at(game) } / rel / file.filename();
|
|
|
|
auto& disassembler = contexts[game]->disassembler();
|
|
auto& decompiler = contexts[game]->decompiler();
|
|
|
|
auto data = utils::file::read(file);
|
|
|
|
disassembler.disassemble(file.string(), data);
|
|
|
|
auto output = disassembler.output();
|
|
|
|
decompiler.decompile(file.string(), output);
|
|
|
|
utils::file::save(fs::path{ "decompiled" } / rel, decompiler.output());
|
|
fmt::print("decompiled {}\n", rel.generic_string());
|
|
}
|
|
catch (std::exception const& e)
|
|
{
|
|
std::cerr << fmt::format("{} at {}\n", e.what(), file.generic_string());
|
|
}
|
|
}
|
|
|
|
void parse_file(game, fs::path const&, fs::path)
|
|
{
|
|
std::cerr << fmt::format("not implemented for t6\n");
|
|
}
|
|
|
|
void rename_file(game, fs::path const&, fs::path)
|
|
{
|
|
std::cerr << fmt::format("not implemented for t6\n");
|
|
}
|
|
|
|
auto init_t6() -> void
|
|
{
|
|
if (!contexts.contains(game::t6))
|
|
{
|
|
contexts[game::t6] = std::make_unique<t6::context>();
|
|
contexts[game::t6]->init(build::prod, utils::file::read);
|
|
}
|
|
}
|
|
|
|
auto init(game game) -> void
|
|
{
|
|
funcs[mode::assemble] = assemble_file;
|
|
funcs[mode::disassemble] = disassemble_file;
|
|
funcs[mode::compile] = compile_file;
|
|
funcs[mode::decompile] = decompile_file;
|
|
funcs[mode::parse] = parse_file;
|
|
funcs[mode::rename] = rename_file;
|
|
|
|
switch (game)
|
|
{
|
|
case game::t6: init_t6(); break;
|
|
default: break;
|
|
}
|
|
}
|
|
|
|
} // namespace xsk::arc
|
|
|
|
auto execute(mode mode, game game, fs::path const& path) -> void
|
|
{
|
|
gsc::init(game);
|
|
arc::init(game);
|
|
|
|
if (fs::is_directory(path))
|
|
{
|
|
for (auto const& entry : fs::recursive_directory_iterator(path))
|
|
{
|
|
if (entry.is_regular_file() && entry.path().extension() != ".stack")
|
|
{
|
|
auto rel = fs::relative(entry, path).remove_filename();
|
|
|
|
if (game < game::t6)
|
|
gsc::funcs[mode](game, entry.path().generic_string(), rel);
|
|
else
|
|
arc::funcs[mode](game, fs::path{ entry.path().generic_string(), fs::path::format::generic_format }, rel);
|
|
}
|
|
}
|
|
}
|
|
else if (fs::is_regular_file(path))
|
|
{
|
|
if (game < game::t6)
|
|
gsc::funcs[mode](game, path, fs::path{});
|
|
else
|
|
arc::funcs[mode](game, fs::path(path, fs::path::format::generic_format), fs::path{});
|
|
}
|
|
else
|
|
{
|
|
std::cerr << fmt::format("bad path '{}'\n", path.generic_string());
|
|
}
|
|
}
|
|
|
|
auto parse_flags(u32 argc, char** argv, game& game, mode& mode, fs::path& path) -> bool
|
|
{
|
|
if (argc != 4) return false;
|
|
|
|
auto arg = utils::string::to_lower(argv[1]);
|
|
|
|
if (arg.at(0) == 'z')
|
|
{
|
|
arg.erase(arg.begin());
|
|
gsc::zonetool = true;
|
|
}
|
|
|
|
auto const it = modes.find(arg);
|
|
|
|
if (it != modes.end())
|
|
{
|
|
mode = it->second;
|
|
}
|
|
else
|
|
{
|
|
std::cout << "[ERROR] unknown mode '" << argv[1] << "'.\n\n";
|
|
return false;
|
|
}
|
|
|
|
arg = utils::string::to_lower(argv[2]);
|
|
|
|
auto const itr = games.find(arg);
|
|
|
|
if (itr != games.end())
|
|
{
|
|
game = itr->second;
|
|
}
|
|
else
|
|
{
|
|
std::cout << "[ERROR] unknown game '" << argv[2] << "'.\n\n";
|
|
return false;
|
|
}
|
|
|
|
path = fs::path{ utils::string::fordslash(argv[3]), fs::path::format::generic_format };
|
|
|
|
return true;
|
|
}
|
|
|
|
auto print_usage() -> void
|
|
{
|
|
std::cout << "usage: gsc-tool <mode> <game> <path>\n";
|
|
std::cout << "\t* modes: asm, disasm, comp, decomp, parse\n";
|
|
std::cout << "\t* games: iw5ps, iw5xb, iw6ps, iw6xb, s1ps, s1xb, iw5, iw6, iw7, iw8, iw9, s1, s2, s4, h1, h2, t6\n";
|
|
std::cout << "\t* paths: file or directory (recursive)\n";
|
|
std::cin.get();
|
|
}
|
|
|
|
auto main(u32 argc, char** argv) -> void
|
|
{
|
|
auto path = fs::path{};
|
|
auto mode = mode::_;
|
|
auto game = game::_;
|
|
|
|
if (!parse_flags(argc, argv, game, mode, path))
|
|
{
|
|
return print_usage();
|
|
}
|
|
|
|
execute(mode, game, path);
|
|
}
|
|
|
|
} // namespace xsk
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
xsk::main(argc, argv);
|
|
return 0;
|
|
}
|