356 lines
11 KiB
C++
356 lines
11 KiB
C++
#include "FunctionInfo.hpp"
|
|
#include "Utility.hpp"
|
|
#include <thread>
|
|
#include <chrono>
|
|
#include <algorithm>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <queue>
|
|
#include <regex>
|
|
#include <string>
|
|
#include <string_view>
|
|
#include <unordered_map>
|
|
#include <map>
|
|
|
|
std::string fl_path;
|
|
bool dbg;
|
|
bool ivld_only;
|
|
bool use_all = true;
|
|
/*
|
|
* 907 cln
|
|
* 25 ivld
|
|
*/
|
|
/*
|
|
* 1742 cln
|
|
* 123 ivld
|
|
*/
|
|
|
|
|
|
#define PL(msg) std::cout << msg << '\n' // print line
|
|
#define PDBG(msg) if(!dbg) PL(msg) // print line if debug flag is set
|
|
|
|
std::smatch match1; // TODO remove later
|
|
|
|
std::regex usage_regex(R"(,"(Usage: [^;]+).?"[, \)])"); // .? is just a workaround, since )" in the raw string would terminate it immediately
|
|
std::regex lua_push_regex(R"(lua_push(.+?)\(())");
|
|
std::regex lua_is_regex(R"(lua_is(.+?)\(L,(\w+?)\))");
|
|
std::regex lua_to_regex(R"(lua_to(.+?)\(L,(\w+?)[,\)])");
|
|
std::regex var_decl_regex(R"(^ (?:int|uint|BOOL) (\w+);)"); // currently only considering these types for declarations
|
|
std::regex var_ass_regex(R"(^ +?(\w+?) = (\w+) ?(.)? ?(\w+?){0,1};)");
|
|
|
|
FunctionInfo fi;
|
|
int lua_index;
|
|
std::string lua_type;
|
|
int out_index;
|
|
std::unordered_map<std::string, FunctionInfo> fmap;
|
|
std::chrono::steady_clock::time_point tstart;
|
|
std::chrono::steady_clock::time_point tend;
|
|
|
|
bool process_varmap_regex(std::map<int, std::vector<std::string>>& varmap, std::string ln, std::regex* regex)
|
|
{
|
|
bool found = false;
|
|
while (std::regex_search(ln, match1, *regex))
|
|
{
|
|
found = true;
|
|
lua_type = match1[1];
|
|
if (lua_type == "lstring") lua_type = "string"; // lstring is a string!
|
|
else if (lua_type == "fstring") lua_type = "string"; // frsting is a string!
|
|
if (regex == &lua_push_regex)
|
|
{ // push parsing uses a global index starting with 1
|
|
lua_index = out_index;
|
|
out_index++;
|
|
}
|
|
else lua_index = prsi(match1[2]).val;
|
|
if (lua_index == -1)
|
|
{ // -1 means there wasn't a literal used for accessing the index, so i can not parse it
|
|
if (regex == &lua_push_regex) fi.out_cnt = -1;
|
|
else fi.in_cnt = -1; // TODO might be possible to parse when evaluating variables
|
|
return found;
|
|
}
|
|
varmap[lua_index].push_back(lua_type); // always push lua type for now
|
|
ln = match1.suffix();
|
|
}
|
|
return found;
|
|
}
|
|
|
|
void pfmap(bool ivld_only)
|
|
{
|
|
for (const auto& [name, fi] : fmap)
|
|
{
|
|
if (!ivld_only || !fi.prs_vld)
|
|
PL(fi.str() + "\n");
|
|
}
|
|
}
|
|
|
|
void pstats()
|
|
{ // print parsing statistics
|
|
int ttl = 0;
|
|
int cln = 0;
|
|
int ivld = 0;
|
|
for (const auto& [name, fi] : fmap)
|
|
{
|
|
ttl++;
|
|
cln += fi.prs_vld && fi.in_cnt != -1 && fi.out_cnt != -1 && !fi.nil_in_varmap(false);
|
|
ivld += !fi.prs_vld;
|
|
}
|
|
auto dur = duration_cast<std::chrono::milliseconds>(tend - tstart);
|
|
PL(std::format("Functions parsed: {}", ttl));
|
|
PL(std::format("Clean: {}", cln));
|
|
PL(std::format("Invalid: {}", ivld));
|
|
PL(std::format("Duration: {} ms", dur.count()));
|
|
}
|
|
|
|
int main()
|
|
{
|
|
/*
|
|
* PARSING RULES
|
|
* lua_is* calls can occur in if-lines
|
|
* lua_to* calls can occur in if-lines
|
|
* lua_push* calls can NOT occur in if-lines
|
|
* lua_push* calls are not called with an index as param, unlike lua_is* / lua_to* - the index is inferred by the order of calls
|
|
* lua_push* calls can occur in branch structures (if/else, switch) - they must only be considered in one of them
|
|
* wow functions return the number of outputs - 0 when they error or there are none; consider any non-0 return as the real number of outputs
|
|
* wow functions may return a dynamic number of outputs - there is no way to parse this into a single result
|
|
* skip scanning for the usg string if it already has been encountered in the function, there can only be 1
|
|
* skip scanning for input params, if unparsable index (not into int) has been found for lua_is* or lua_to* (dynamic inputs)
|
|
* skip scanning for output params, if unparsable index (not into int) has been found for lua_push* (dynamic outputs)
|
|
* skip scanning for output params, if returns with different non-0 values have been found (or it can not be parsed as int)
|
|
*/
|
|
|
|
tstart = std::chrono::high_resolution_clock::now();
|
|
if (use_all)
|
|
{
|
|
dbg = true;
|
|
ivld_only = true;
|
|
fl_path = R"(C:\Users\alphaomega\Documents\Wow.exe.c.txt)";
|
|
}
|
|
else
|
|
{
|
|
dbg = true;
|
|
ivld_only = false;
|
|
fl_path = R"(C:\Users\alphaomega\Documents\Wow.exe.c.test.txt)";
|
|
}
|
|
|
|
|
|
|
|
std::ifstream source_file(fl_path);
|
|
if (!source_file.is_open())
|
|
{
|
|
std::cerr << "Unable to open file " << fl_path << std::endl;
|
|
return 1;
|
|
}
|
|
std::unordered_map<std::string, int> func_vars;
|
|
|
|
std::string skp_push_utl = ""; // skip push parsing until this ln has been reached
|
|
std::string lp_utl = "";
|
|
std::unordered_map<std::string, bool> push_track;
|
|
|
|
bool in_func = false;
|
|
bool enc_usg = false; // encountered usg
|
|
bool prc_def = false;
|
|
uint ret_val; // return value
|
|
bool is_if_ln;
|
|
std::string ind; // indent
|
|
std::string ln;
|
|
|
|
std::vector<char>::iterator eol;
|
|
while (std::getline(source_file, ln))
|
|
{
|
|
if (ln.empty()) continue; // skip empty lines
|
|
if (ln.starts_with("/*")) continue; // skip block comment lines
|
|
if (!in_func)
|
|
{ // searching for next function
|
|
if (ln.starts_with("// ADDRESS - "))
|
|
{ // found addr ln - create new FunctionInfo and reset variables
|
|
fi = {};
|
|
fi.addr = std::stoi(&ln[13], 0, 16); // do not use prsi, these values prb occur only once, so no caching wanted
|
|
out_index = 0;
|
|
enc_usg = false;
|
|
lp_utl = "";
|
|
skp_push_utl = "";
|
|
push_track = {};
|
|
func_vars = {};
|
|
continue;
|
|
}
|
|
if (ln.starts_with("uint lua_wow_"))
|
|
{ // found ln with function signature
|
|
fi.nm = ln.substr(13, ln.find_first_of("(") - 13); // get part of real function name
|
|
in_func = true; // start function parsing from now on
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{ // processing current function
|
|
is_if_ln = false;
|
|
if (ln == "{")
|
|
{ // this is the starting block of the function
|
|
prc_def = true; // enable regex handling for local variable definitions
|
|
continue;
|
|
}
|
|
if (ln == "}")
|
|
{ // end of function found
|
|
in_func = false;
|
|
fi.cln_varmap(true);
|
|
fi.cln_varmap(false);
|
|
fi.chk_vld();
|
|
fmap[fi.nm] = fi;
|
|
continue;
|
|
}
|
|
if (prc_def)
|
|
{ // if local variable definition parsing is enabled
|
|
if (ln == " ")
|
|
{ // reached end variable definition block, no further processing required
|
|
prc_def = false;
|
|
continue;
|
|
}
|
|
if (std::regex_search(ln, match1, var_decl_regex))
|
|
{ // found local variable, track it with init value 0
|
|
func_vars[match1[1]] = 0;
|
|
}
|
|
|
|
}
|
|
int i = 0;
|
|
while (i < ln.length())
|
|
{
|
|
if (ln[i] != ' ')
|
|
{
|
|
ind = ln.substr(0, i);
|
|
break;
|
|
}
|
|
i++;
|
|
}
|
|
switch (ln[i])
|
|
{
|
|
case 'c':
|
|
case 'd':
|
|
if (lnsw(ln, i, "do {"))
|
|
{ // setting loop end, if not already in a loop
|
|
ssie(lp_utl, ln[ln.length() - 1] == '{' ? ind + "}" : "\1"); // check if this is a single ln do-while loop (who would even program such a thing!?
|
|
break;
|
|
}
|
|
if (lnsw(ln, i, "case ") || lnsw(ln, i, "default:"))
|
|
{
|
|
if (push_track[ind]) ssie(skp_push_utl, ind + "}");
|
|
else push_track[ind] = false; // only execute if a previous case didn't already contain a push
|
|
break;
|
|
}
|
|
break;
|
|
case 'f':
|
|
if (lnsw(ln, i, "for ("))
|
|
{
|
|
ssie(lp_utl, ln[ln.length() - 1] == '{' ? ind + "}" : "\1"); // check if this is a single ln for loop
|
|
break;
|
|
}
|
|
break;
|
|
case 'i': // check for if
|
|
if (lnsw(ln, i, "if "))
|
|
{ // enough characters left to be if statement
|
|
is_if_ln = true;
|
|
push_track[ind] = false;
|
|
break;
|
|
}
|
|
break;
|
|
case 'e':
|
|
if (lnsw(ln, i, "else "))
|
|
{ // enough characters left to be if statement
|
|
if (push_track[ind]) ssie(skp_push_utl, ln[ln.length() - 1] == '{' ? ind + "}" : "\1");
|
|
break;
|
|
}
|
|
break;
|
|
case 'g':
|
|
if (!fi.out.empty() && lnsw(ln, i, "goto "))
|
|
{
|
|
ssie(skp_push_utl, std::string(ln.substr(i + 5, ln.length() - i - 6)) + ":");
|
|
break;
|
|
}
|
|
break;
|
|
case 'r': // check for return
|
|
if (fi.out_cnt == -1) break; // this function has a dynamic number of outputs, no need for further processing
|
|
if (lnsw(ln, i, "return "))
|
|
{ // enough characters left to be the simplest return
|
|
ret_val = prsi(std::string(&ln[i + 7], ln.length() - i - 8)).val;
|
|
// check if already encountered return value (except 0) matches; dynamic if not
|
|
if (ret_val != 0)
|
|
{ // TODO probably need to check if i am currently skipping push
|
|
fi.out_cnt = (fi.out_cnt == 0 || fi.out_cnt == ret_val) ? ret_val : -1;
|
|
if (ret_val == fi.out.size())
|
|
{ // found a return statement and return value matches output param count
|
|
ssie(skp_push_utl, "\1skip2end");
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
case 'w':
|
|
if (lnsw(ln, i, "while ("))
|
|
{ // setting loop end, if not already in a loop
|
|
ssie(lp_utl, ln[ln.length() - 1] == '{' ? ind + "}" : "\1"); // check if this is a single ln while loop
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
//pdbg(ln);
|
|
//pdbg(ind + "<-");
|
|
//if (auto match = ctre::match<var_ass_regex>(ln))
|
|
|
|
if (std::regex_search(ln, match1, var_ass_regex))
|
|
{
|
|
|
|
int i = 0;
|
|
//auto test = match.get<1>();
|
|
//pdbg("variable assignment happens for " + match.get<1>().to_string());
|
|
}
|
|
|
|
if (!enc_usg)
|
|
{ // usage string can only occur once anyway
|
|
//if (auto match = ctre::match<usage_regex>(ln))
|
|
if (std::regex_search(ln, match1, usage_regex))
|
|
{ // found usg string
|
|
fi.usg = match1[1];
|
|
size_t found = -1; // so the first find uses 0 through the increment
|
|
while ((found = fi.usg.find("\\\"", found + 1)) != std::string::npos) fi.usg.replace(found, 2, "\"");
|
|
enc_usg = true;
|
|
skp_push_utl = !skp_push_utl.empty() ? skp_push_utl : "\1"; // sometimes lua_pushfstring is used before lua_error; do not consider this an output!
|
|
}
|
|
}
|
|
|
|
if (fi.in_cnt != -1)
|
|
{
|
|
process_varmap_regex(fi.in, ln, &lua_is_regex);
|
|
process_varmap_regex(fi.in, ln, &lua_to_regex);
|
|
}
|
|
if (fi.out_cnt != -1 && skp_push_utl.empty() && process_varmap_regex(fi.out, ln, &lua_push_regex))
|
|
{
|
|
if (!lp_utl.empty())
|
|
{ // found lua_push* inside a loop
|
|
fi.out_cnt = -1;
|
|
}
|
|
else
|
|
{ // normal processing
|
|
|
|
std::string lvl = is_if_ln ? ind : ind.substr(0, ind.length() - 2); // do not subtract 1 block level, if this was a simple if ln
|
|
while (lvl >= " ")
|
|
{ // if a push was found, track it for this and all lower block levels
|
|
push_track[lvl] = true;
|
|
lvl = lvl.substr(0, lvl.length() - 2);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
if (!lp_utl.empty() && ln.starts_with(lp_utl)) lp_utl = "";
|
|
if (lp_utl == "\1") lp_utl = "";
|
|
if (!skp_push_utl.empty() && ln.starts_with(skp_push_utl)) skp_push_utl = ""; // reset skip since ln has been reached now
|
|
if (skp_push_utl == "\1") skp_push_utl = ""; // reset temporary skip which was used for 1 ln
|
|
}
|
|
|
|
}
|
|
|
|
tend = std::chrono::high_resolution_clock::now();
|
|
if (dbg) pfmap(ivld_only);
|
|
std::cout << "GhidraParser is done..." << std::endl;
|
|
pstats();
|
|
std::cin.ignore();
|
|
return 0;
|
|
}
|