sourcemod/sourcepawn/decompiler/decompiler.cpp

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <assert.h>
#include "decompiler.h"
#include "platform_util.h"

sp_decomp_t *Sp_InitDecomp(const char *file, int *err)
{
	sp_decomp_t *dc;
	sp_file_t *plugin;

	if ((plugin = Sp_ReadPlugin(file, err)) == NULL)
	{
		return NULL;
	}

	dc = new sp_decomp_t;
	memset(dc, 0, sizeof(sp_decomp_t));
	dc->plugin = plugin;
	dc->pcode_map = (cell_t *)malloc(dc->plugin->pcode_size);
	memset(dc->pcode_map, 0, dc->plugin->pcode_size);

#define OPDEF(num,enm,str,prms)	\
	dc->opdef[num].name = str;		\
	dc->opdef[num].params = prms;
#include "opcodes.tbl"
#undef OPDEF

	if (plugin->debug.ntv != NULL)
	{
		assert(plugin->debug.ntv->num_entries == plugin->num_natives);
		dc->natives = new FunctionInfo[plugin->num_natives];
		memset(dc->natives, 0, sizeof(FunctionInfo) * plugin->num_natives);

		/* Unfurl this mess. */
		uint8_t *cursor = (uint8_t *)plugin->debug.ntv;

		cursor += sizeof(sp_fdbg_ntvtab_t);
		for (uint32_t i = 0; i < plugin->num_natives; i++)
		{
			sp_fdbg_native_t *native = (sp_fdbg_native_t *)cursor;

			uint32_t idx = native->index;

			assert(dc->natives[idx].name[0] == '\0');

			Sp_Format(dc->natives[idx].name, 
				sizeof(dc->natives[idx].name),
				"%s",
				plugin->debug.stringbase + native->name);
			dc->natives[idx].tag = Sp_FindTag(plugin, native->tagid);
			dc->natives[idx].num_known_args = native->nargs;
			
			cursor += sizeof(sp_fdbg_native_t);

			for (uint32_t j = 0; j < dc->natives[idx].num_known_args; j++)
			{
				sp_fdbg_ntvarg_t *arg = (sp_fdbg_ntvarg_t *)cursor;
				dc->natives[idx].known_args[j].name = 
					plugin->debug.stringbase + arg->name;
				dc->natives[idx].known_args[j].tag = 
					Sp_FindTag(plugin, arg->tagid);
				dc->natives[idx].known_args[j].dimcount = arg->dimcount;

				cursor += sizeof(sp_fdbg_ntvarg_t);
				if (arg->dimcount != 0)
				{
					dc->natives[idx].known_args[j].dims = (sp_fdbg_arraydim_t *)cursor;
					cursor += sizeof(sp_fdbg_arraydim_t) * arg->dimcount;
				}
			}
		}
	}

	return dc;
}

void Sp_FreeDecomp(sp_decomp_t *decomp)
{
	FunctionInfo *info, *info_temp;

	info = decomp->funcs;
	while (info != NULL)
	{
		info_temp = info->next;
		delete info;
		info = info_temp;
	}

	Sp_FreePlugin(decomp->plugin);
	free(decomp->pcode_map);
	delete [] decomp->natives;
	delete decomp;
}

PrintBuffer::PrintBuffer() : printbuf(NULL), printbuf_alloc(0), printbuf_pos(0)
{
}

PrintBuffer::~PrintBuffer()
{
	free(printbuf);
}

void PrintBuffer::Grow(size_t len)
{
	if (printbuf_pos + len > printbuf_alloc)
	{
		if (printbuf_alloc == 0)
		{
			printbuf_alloc = len * 8;
		}
		else
		{
			printbuf_alloc += len;
			printbuf_alloc *= 2;
		}

		printbuf = (char *)realloc(printbuf, printbuf_alloc);
	}
}

void PrintBuffer::Append(const char *fmt, ...)
{
	size_t len;
	va_list ap;
	char buffer[2048];

	va_start(ap, fmt);
	len = Sp_FormatArgs(buffer, sizeof(buffer), fmt, ap);
	va_end(ap);

	Grow(len + 1);

	strcpy(&printbuf[printbuf_pos], buffer);
	printbuf_pos += len;
}

void PrintBuffer::Set(const char *fmt, ...)
{
	size_t len;
	va_list ap;
	char buffer[2048];

	va_start(ap, fmt);
	len = Sp_FormatArgs(buffer, sizeof(buffer), fmt, ap);
	va_end(ap);

	Reset();
	Grow(len + 1);

	printbuf = (char *)realloc(printbuf, printbuf_alloc);
	strcpy(&printbuf[printbuf_pos], buffer);
	printbuf_pos += len;
}

void PrintBuffer::Prepend(const char *fmt, ...)
{
	size_t len;
	va_list ap;
	char buffer[2048];

	va_start(ap, fmt);
	len = Sp_FormatArgs(buffer, sizeof(buffer), fmt, ap);
	va_end(ap);

	Grow(len + 1);

	/* Move old data forward.  Move one extra byte for the null terminator. */
	memmove(&printbuf[len], printbuf, printbuf_pos + 1);
	printbuf_pos += len;
	/* Move the new data in. */
	memcpy(printbuf, buffer, len);
}

void PrintBuffer::Reset()
{
	printbuf_pos = 0;
}

void PrintBuffer::Dump(FILE *fp)
{
	fprintf(fp, "%s", printbuf);
}