/* $Id$ */
/* Copyright (c) 2013-2018 Pierre Pronchery <khorben@defora.org> */
/* This file is part of DeforaOS Devel Asm */
/* This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, version 3 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>. */



#include <Python.h>
#include "../../include/Asm.h"


/* libAsm */
/* private */
/* constants */
static char const _libasm_asm_name[] = "libAsm::Asm";


/* prototypes */
/* Asm */
static PyObject * _libasm_asm_new(PyObject * self, PyObject * args);
static void _libasm_asm_delete(PyObject * self);

/* accessors */
static PyObject * _libasm_asm_get_arch(PyObject * self, PyObject * args);
static PyObject * _libasm_asm_get_format(PyObject * self, PyObject * args);
static PyObject * _libasm_asm_set_arch(PyObject * self, PyObject * args);
static PyObject * _libasm_asm_set_format(PyObject * self, PyObject * args);

/* useful */
/* detection */
static PyObject * _libasm_asm_guess_arch(PyObject * self, PyObject * args);
static PyObject * _libasm_asm_guess_format(PyObject * self, PyObject * args);

/* common */
static PyObject * _libasm_asm_close(PyObject * self, PyObject * args);

/* assemble */
static PyObject * _libasm_asm_assemble_string(PyObject * self, PyObject * args);
static PyObject * _libasm_asm_open_assemble(PyObject * self, PyObject * args);

static PyObject * _libasm_asm_instruction(PyObject * self, PyObject * args);

/* deassemble */
static PyObject * _libasm_asm_open_deassemble(PyObject * self, PyObject * args);


/* variables */
static PyMethodDef _libasm_methods[] =
{
	{ "asm_new", _libasm_asm_new, METH_VARARGS,
		"Instantiates an Asm object." },
	{ "asm_get_arch", _libasm_asm_get_arch, METH_VARARGS,
		"Obtain the current architecture in use." },
	{ "asm_get_format", _libasm_asm_get_format, METH_VARARGS,
		"Obtain the current format in use." },
	{ "asm_set_arch", _libasm_asm_set_arch, METH_VARARGS,
		"Set the current architecture in use." },
	{ "asm_set_format", _libasm_asm_set_format, METH_VARARGS,
		"Set the current format in use." },
	{ "asm_guess_arch", _libasm_asm_guess_arch, METH_VARARGS,
		"Guess the current architecture." },
	{ "asm_guess_format", _libasm_asm_guess_format, METH_VARARGS,
		"Guess the current format." },
	{ "asm_close",	_libasm_asm_close, METH_VARARGS,
		"Close the file currently opened." },
	{ "asm_assemble_string", _libasm_asm_assemble_string, METH_VARARGS,
		"Write instructions from a string directly to a file." },
	{ "asm_open_assemble", _libasm_asm_open_assemble, METH_VARARGS,
		"Open a file to write instructions." },
	{ "asm_instruction", _libasm_asm_instruction, METH_VARARGS,
		"Process an assembly instruction." },
	{ "asm_open_deassemble", _libasm_asm_open_deassemble, METH_VARARGS,
		"Open a file to read instructions." },
	{ NULL, NULL, 0, NULL }
};


/* public */
/* prototypes */
PyMODINIT_FUNC init_libasm(void);


/* functions */
PyMODINIT_FUNC init_libasm(void)
{
	Py_InitModule("_libasm", _libasm_methods);
}


/* private */
/* functions */
/* Asm */
/* libasm_asm_new */
static PyObject * _libasm_asm_new(PyObject * self, PyObject * args)
{
	Asm * a;
	char const * arch;
	char const * format;

	if(!PyArg_ParseTuple(args, "ss", &arch, &format))
		return NULL;
	if((a = asm_new(arch, format)) == NULL)
		return NULL;
	return PyCapsule_New(a, _libasm_asm_name, _libasm_asm_delete);
}


/* libasm_asm_delete */
static void _libasm_asm_delete(PyObject * self)
{
	Asm * a;

	if((a = PyCapsule_GetPointer(self, _libasm_asm_name)) == NULL)
		return;
	asm_delete(a);
}


/* accessors */
/* libasm_asm_get_arch */
static PyObject * _libasm_asm_get_arch(PyObject * self, PyObject * args)
{
	Asm * a;
	char const * ret;

	if(!PyArg_ParseTuple(args, "O", &self))
		return NULL;
	if((a = PyCapsule_GetPointer(self, _libasm_asm_name)) == NULL
			|| (ret = asm_get_arch(a)) == NULL)
		return NULL;
	return Py_BuildValue("s", ret);
}


/* libasm_asm_get_format */
static PyObject * _libasm_asm_get_format(PyObject * self, PyObject * args)
{
	Asm * a;
	char const * ret;

	if(!PyArg_ParseTuple(args, "O", &self))
		return NULL;
	if((a = PyCapsule_GetPointer(self, _libasm_asm_name)) == NULL
			|| (ret = asm_get_format(a)) == NULL)
		return NULL;
	return Py_BuildValue("s", ret);
}


/* libasm_asm_set_arch */
static PyObject * _libasm_asm_set_arch(PyObject * self, PyObject * args)
{
	Asm * a;
	char const * arch;
	int ret;

	if(!PyArg_ParseTuple(args, "Os", &self, &arch))
		return NULL;
	if((a = PyCapsule_GetPointer(self, _libasm_asm_name)) == NULL)
		return NULL;
	ret = asm_set_arch(a, arch);
	return Py_BuildValue("i", ret);
}


/* libasm_asm_set_format */
static PyObject * _libasm_asm_set_format(PyObject * self, PyObject * args)
{
	Asm * a;
	char const * format;
	int ret;

	if(!PyArg_ParseTuple(args, "Os", &self, &format))
		return NULL;
	if((a = PyCapsule_GetPointer(self, _libasm_asm_name)) == NULL)
		return NULL;
	ret = asm_set_format(a, format);
	return Py_BuildValue("i", ret);
}


/* useful */
/* detection */
/* libasm_asm_guess_arch */
static PyObject * _libasm_asm_guess_arch(PyObject * self, PyObject * args)
{
	Asm * a;
	int ret;

	if(!PyArg_ParseTuple(args, "O", self))
		return NULL;
	if((a = PyCapsule_GetPointer(self, _libasm_asm_name)) == NULL)
		return NULL;
	ret = asm_guess_arch(a);
	return Py_BuildValue("i", ret);
}


/* libasm_guess_format */
static PyObject * _libasm_asm_guess_format(PyObject * self, PyObject * args)
{
	Asm * a;
	int ret;

	if(!PyArg_ParseTuple(args, "O", &self))
		return NULL;
	if((a = PyCapsule_GetPointer(self, _libasm_asm_name)) == NULL)
		return NULL;
	ret = asm_guess_format(a);
	return Py_BuildValue("i", ret);
}


/* common */
/* libasm_asm_close */
static PyObject * _libasm_asm_close(PyObject * self, PyObject * args)
{
	Asm * a;
	int ret;

	if(!PyArg_ParseTuple(args, "O", &self))
		return NULL;
	if((a = PyCapsule_GetPointer(self, _libasm_asm_name)) == NULL)
		return NULL;
	ret = asm_close(a);
	return Py_BuildValue("i", ret);
}


/* assemble */
/* libasm_asm_assemble_string */
static PyObject * _libasm_asm_assemble_string(PyObject * self, PyObject * args)
{
	Asm * a;
	char const * outfile;
	char const * string;
	int ret;

	if(!PyArg_ParseTuple(args, "Oss", &self, &outfile, &string))
		return NULL;
	if((a = PyCapsule_GetPointer(self, _libasm_asm_name)) == NULL)
		return NULL;
	ret = asm_assemble_string(a, NULL, outfile, string);
	return Py_BuildValue("i", ret);
}


/* libasm_asm_open_assemble */
static PyObject * _libasm_asm_open_assemble(PyObject * self, PyObject * args)
{
	Asm * a;
	char const * outfile;
	int ret;

	if(!PyArg_ParseTuple(args, "Os", &self, &outfile))
		return NULL;
	if((a = PyCapsule_GetPointer(self, _libasm_asm_name)) == NULL)
		return NULL;
	ret = asm_open_assemble(a, outfile);
	return Py_BuildValue("i", ret);
}


/* libasm_asm_instruction */
static PyObject * _libasm_asm_instruction(PyObject * self, PyObject * args)
{
	Asm * a;
	char const * name;
	int ret;

	/* FIXME really parse the arguments */
	if(!PyArg_ParseTuple(args, "Os", &self, &name))
		return NULL;
	if((a = PyCapsule_GetPointer(self, _libasm_asm_name)) == NULL)
		return NULL;
	ret = asm_instruction(a, name, 0);
	return Py_BuildValue("i", ret);
}


/* deassemble */
/* libasm_asm_open_deassemble */
static PyObject * _libasm_asm_open_deassemble(PyObject * self, PyObject * args)
{
	Asm * a;
	char const * filename;
	int raw;
	AsmCode * ret;

	if(!PyArg_ParseTuple(args, "Osi", &self, &filename, &raw))
		return NULL;
	if((a = PyCapsule_GetPointer(self, _libasm_asm_name)) == NULL)
		return NULL;
	ret = asm_open_deassemble(a, filename, raw);
	/* FIXME really return an AsmCode Python object */
	return Py_BuildValue("p", ret);
}