#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include "zlib.h"

#include "file_format.h"

void Sp_FreePlugin(sp_file_t *plugin)

{

	if (plugin == NULL)

	{

		return;

	}

	free(plugin->base);

	delete [] plugin->publics;

	delete [] plugin->pubvars;

	delete [] plugin->natives;

	delete plugin;

}

sp_file_t *Sp_ReadPlugin(const char *file, int *err)

{

	sp_file_t *plugin;

	sp_file_hdr_t hdr;

	uint8_t *base;

	int z_result;

	int error;

	FILE *fp = fopen(file, "rb");

	plugin = NULL;

	if (!fp)

	{

		error = SP_ERROR_NOT_FOUND;

		goto return_error;

	}

	/* Rewind for safety */

	fread(&hdr, sizeof(sp_file_hdr_t), 1, fp);

	if (hdr.magic != SPFILE_MAGIC)

	{

		error = SP_ERROR_FILE_FORMAT;

		goto return_error;

	}

	switch (hdr.compression)

	{

	case SPFILE_COMPRESSION_GZ:

		{

			uint32_t uncompsize = hdr.imagesize - hdr.dataoffs;

			uint32_t compsize = hdr.disksize - hdr.dataoffs;

			uint32_t sectsize = hdr.dataoffs - sizeof(sp_file_hdr_t);

			uLongf destlen = uncompsize;

			char *tempbuf = (char *)malloc(compsize);

			void *uncompdata = malloc(uncompsize);

			void *sectheader = malloc(sectsize);

			fread(sectheader, sectsize, 1, fp);

			fread(tempbuf, compsize, 1, fp);

			z_result = uncompress((Bytef *)uncompdata, &destlen, (Bytef *)tempbuf, compsize);

			free(tempbuf);

			if (z_result != Z_OK)

			{

				free(sectheader);

				free(uncompdata);

				error = SP_ERROR_DECOMPRESSOR;

				goto return_error;

			}

			base = (uint8_t *)malloc(hdr.imagesize);

			memcpy(base, &hdr, sizeof(sp_file_hdr_t));

			memcpy(base + sizeof(sp_file_hdr_t), sectheader, sectsize);

			free(sectheader);

			memcpy(base + hdr.dataoffs, uncompdata, uncompsize);

			free(uncompdata);

			break;

		}

	case SPFILE_COMPRESSION_NONE:

		{

			base = (uint8_t *)malloc(hdr.imagesize);

			rewind(fp);

			fread(base, hdr.imagesize, 1, fp);

			break;

		}

	default:

		{

			error = SP_ERROR_DECOMPRESSOR;

			goto return_error;

		}

	}

	plugin = new sp_file_t;

	memset(plugin, 0, sizeof(sp_file_t));

	plugin->base = base;

	{

		int set_err;

		char *nameptr;

		uint8_t sectnum = 0;

		sp_file_section_t *secptr = (sp_file_section_t *)(base + sizeof(sp_file_hdr_t));

		plugin->base_size = hdr.imagesize;

		set_err = SP_ERROR_NONE;

		/* We have to read the name section first */

		for (sectnum = 0; sectnum < hdr.sections; sectnum++)

		{

			nameptr = (char *)(base + hdr.stringtab + secptr[sectnum].nameoffs);

			if (strcmp(nameptr, ".names") == 0)

			{

				plugin->stringbase = (const char *)(base + secptr[sectnum].dataoffs);

				break;

			}

		}

		sectnum = 0;

		/* Now read the rest of the sections */

		while (sectnum < hdr.sections)

		{

			nameptr = (char *)(base + hdr.stringtab + secptr->nameoffs);

			if (!(plugin->pcode) && !strcmp(nameptr, ".code"))

			{

				sp_file_code_t *cod = (sp_file_code_t *)(base + secptr->dataoffs);

				if (cod->codeversion < SP_CODEVERS_JIT1)

				{

					error = SP_ERROR_CODE_TOO_OLD;

					goto return_error;

				}

				else if (cod->codeversion > SP_CODEVERS_JIT2)

				{

					error = SP_ERROR_CODE_TOO_NEW;

					goto return_error;

				}

				plugin->pcode = base + secptr->dataoffs + cod->code;

				plugin->pcode_size = cod->codesize;

				plugin->flags = cod->flags;

				plugin->pcode_version = cod->codeversion;

			}

			else if (!(plugin->data) && !strcmp(nameptr, ".data"))

			{

				sp_file_data_t *dat = (sp_file_data_t *)(base + secptr->dataoffs);

				plugin->data = base + secptr->dataoffs + dat->data;

				plugin->data_size = dat->datasize;

				plugin->mem_size = dat->memsize;

			}

			else if ((plugin->publics == NULL) && !strcmp(nameptr, ".publics"))

			{

				sp_file_publics_t *publics;

				publics = (sp_file_publics_t *)(base + secptr->dataoffs);

				plugin->num_publics = secptr->size / sizeof(sp_file_publics_t);

				if (plugin->num_publics > 0)

				{

					plugin->publics = new sp_public_t[plugin->num_publics];

					for (uint32_t i = 0; i < plugin->num_publics; i++)

					{

						plugin->publics[i].code_offs = publics[i].address;

						plugin->publics[i].funcid = (i << 1) | 1;

						plugin->publics[i].name = plugin->stringbase + publics[i].name;

					}

				}

			}

			else if ((plugin->pubvars == NULL) && !strcmp(nameptr, ".pubvars"))

			{

				sp_file_pubvars_t *pubvars;

				pubvars = (sp_file_pubvars_t *)(base + secptr->dataoffs);

				plugin->num_pubvars = secptr->size / sizeof(sp_file_pubvars_t);

				if (plugin->num_pubvars > 0)

				{

					plugin->pubvars = new sp_pubvar_t[plugin->num_pubvars];

					for (uint32_t i = 0; i < plugin->num_pubvars; i++)

					{

						plugin->pubvars[i].name = plugin->stringbase + pubvars[i].name;

						plugin->pubvars[i].offs = (cell_t *)(plugin->data + pubvars[i].address);

					}

				}

			}

			else if ((plugin->natives == NULL) && !strcmp(nameptr, ".natives"))

			{

				sp_file_natives_t *natives;

				natives = (sp_file_natives_t *)(base + secptr->dataoffs);

				plugin->num_natives = secptr->size / sizeof(sp_file_natives_t);

				if (plugin->num_natives > 0)

				{

					plugin->natives = new sp_native_t[plugin->num_natives];

					for (uint32_t i = 0; i < plugin->num_natives; i++)

					{

						plugin->natives[i].flags = 0;

						plugin->natives[i].pfn = NULL;

						plugin->natives[i].status = SP_NATIVE_UNBOUND;

						plugin->natives[i].user = NULL;

						plugin->natives[i].name = plugin->stringbase + natives[i].name;

					}

				}

			}

			else if ((plugin->tags == NULL) && !strcmp(nameptr, ".tags"))

			{

				sp_file_tag_s *tags;

				tags = (sp_file_tag_s *)(base + secptr->dataoffs);

				plugin->num_tags = secptr->size / sizeof(sp_file_tag_s);

				if (plugin->num_tags > 0)

				{

					plugin->tags = new sp_tag_t[plugin->num_tags];

					for (uint32_t i = 0; i < plugin->num_tags; i++)

					{

						plugin->tags[i].id = tags[i].tag_id;

						plugin->tags[i].name = plugin->stringbase + tags[i].name;

					}

				}

			}

			else if (!(plugin->debug.files) && !strcmp(nameptr, ".dbg.files"))

			{

				plugin->debug.files = (sp_fdbg_file_t *)(base + secptr->dataoffs);

			}

			else if (!(plugin->debug.lines) && !strcmp(nameptr, ".dbg.lines"))

			{

				plugin->debug.lines = (sp_fdbg_line_t *)(base + secptr->dataoffs);

			}

			else if (!(plugin->debug.symbols) && !strcmp(nameptr, ".dbg.symbols"))

			{

				plugin->debug.symbols = (sp_fdbg_symbol_t *)(base + secptr->dataoffs);

			}

			else if (!(plugin->debug.lines_num) && !strcmp(nameptr, ".dbg.info"))

			{

				sp_fdbg_info_t *inf = (sp_fdbg_info_t *)(base + secptr->dataoffs);

				plugin->debug.files_num = inf->num_files;

				plugin->debug.lines_num = inf->num_lines;

				plugin->debug.syms_num = inf->num_syms;

			}

			else if (plugin->debug.ntv == NULL && !strcmp(nameptr, ".dbg.natives"))

			{

				plugin->debug.ntv = (sp_fdbg_ntvtab_s *)(base + secptr->dataoffs);

			}

			else if (!(plugin->debug.stringbase) && !strcmp(nameptr, ".dbg.strings"))

			{

				plugin->debug.stringbase = (const char *)(base + secptr->dataoffs);

			}

			secptr++;

			sectnum++;

		}

		if (plugin->pcode == NULL || plugin->data == NULL)

		{

			error = SP_ERROR_FILE_FORMAT;

			goto return_error;

		}

		if ((plugin->flags & SP_FLAG_DEBUG) && (!(plugin->debug.files) || !(plugin->debug.lines) || !(plugin->debug.symbols)))

		{

			error = SP_ERROR_FILE_FORMAT;

			goto return_error;

		}

	}

	fclose(fp);

	return plugin;

return_error:

	Sp_FreePlugin(plugin);

	*err = error;

	fclose(fp);

	return NULL;

}

sp_fdbg_symbol_t *Sp_FindFunctionSym(sp_file_t *plugin, ucell_t addr)

{

	uint32_t iter;

	sp_fdbg_symbol_t *sym;

	uint8_t *cursor = (uint8_t *)(plugin->debug.symbols);

	for (iter = 0; iter < plugin->debug.syms_num; iter++)

	{

		sym = (sp_fdbg_symbol_t *)cursor;

		if (sym->ident == SP_SYM_FUNCTION

			&& sym->codestart <= addr

			&& sym->codeend > addr)

		{

			return sym;

		}

		cursor += sizeof(sp_fdbg_symbol_t);

		if (sym->dimcount > 0)

		{

			cursor += sizeof(sp_fdbg_arraydim_t) * sym->dimcount;

		}

	}

	return NULL;

}

sp_tag_t *Sp_FindTag(sp_file_t *plugin, uint32_t tag_id)

{

	for (uint32_t i = 0; i < plugin->num_tags; i++)

	{

		if ((plugin->tags[i].id & 0xFFFF) == tag_id)

		{

			return &plugin->tags[i];

		}

	}

	return NULL;

}