/*******************************************************************/

/*  slibtool: a skinny libtool implementation, written in C        */

/*  Copyright (C) 2016  Z. Gilboa                                  */

/*  Released under the Standard MIT License; see COPYING.SLIBTOOL. */

/*******************************************************************/

#include <stdint.h>

#include <unistd.h>

#include <fcntl.h>

#define ARGV_DRIVER

#include <slibtool/slibtool.h>

#include "slibtool_driver_impl.h"

#include "argv/argv.h"

struct slbt_split_vector {

	char **		targv;

	char **		cargv;

};

struct slbt_driver_ctx_alloc {

	struct argv_meta *		meta;

	struct slbt_driver_ctx_impl	ctx;

	uint64_t			guard;

	const char *			units[];

};

static uint32_t slbt_argv_flags(uint32_t flags)

{

	uint32_t ret = 0;

	if (flags & SLBT_DRIVER_VERBOSITY_NONE)

		ret |= ARGV_VERBOSITY_NONE;

	if (flags & SLBT_DRIVER_VERBOSITY_ERRORS)

		ret |= ARGV_VERBOSITY_ERRORS;

	if (flags & SLBT_DRIVER_VERBOSITY_STATUS)

		ret |= ARGV_VERBOSITY_STATUS;

	return ret;

}

static int slbt_driver_usage(

	const char *			program,

	const char *			arg,

	const struct argv_option *	options,

	struct argv_meta *		meta)

{

	char header[512];

	snprintf(header,sizeof(header),

		"Usage: %s [options] <file>...\n" "Options:\n",

		program);

	argv_usage(stdout,header,options,arg);

	argv_free(meta);

	return SLBT_USAGE;

}

static struct slbt_driver_ctx_impl * slbt_driver_ctx_alloc(

	struct argv_meta *		meta,

	const struct slbt_common_ctx *	cctx,

	size_t				nunits)

{

	struct slbt_driver_ctx_alloc *	ictx;

	size_t				size;

	struct argv_entry *		entry;

	const char **			units;

	size =  sizeof(struct slbt_driver_ctx_alloc);

	size += (nunits+1)*sizeof(const char *);

	if (!(ictx = calloc(1,size)))

		return 0;

	if (cctx)

		memcpy(&ictx->ctx.cctx,cctx,sizeof(*cctx));

	for (entry=meta->entries,units=ictx->units; entry->fopt || entry->arg; entry++)

		if (!entry->fopt)

			*units++ = entry->arg;

	ictx->meta = meta;

	ictx->ctx.ctx.units = ictx->units;

	return &ictx->ctx;

}

static int slbt_get_driver_ctx_fail(struct argv_meta * meta)

{

	argv_free(meta);

	return -1;

}

static int slbt_split_argv(

	char **				argv,

	uint32_t			flags,

	struct slbt_split_vector *	sargv)

{

	int				i;

	int				argc;

	const char *			program;

	char *				compiler;

	char **				targv;

	char **				cargv;

	struct argv_meta *		meta;

	struct argv_entry *		entry;

	struct argv_entry *		mode;

	const struct argv_option *	option;

	const struct argv_option *	options = slbt_default_options;

	struct argv_ctx			ctx = {ARGV_VERBOSITY_NONE,

						ARGV_MODE_SCAN,

						0,0,0,0,0,0,0};

	program = argv_program_name(argv[0]);

	/* missing arguments? */

	if (!argv[1] && (flags & SLBT_DRIVER_VERBOSITY_USAGE))

		return slbt_driver_usage(program,0,options,0);

	/* initial argv scan: ... --mode=xxx ... <compiler> ... */

	argv_scan(argv,options,&ctx,0);

	/* invalid slibtool arguments? */

	if (ctx.erridx && !ctx.unitidx) {

		if (flags & SLBT_DRIVER_VERBOSITY_ERRORS)

			argv_get(

				argv,options,

				slbt_argv_flags(flags));

		return -1;

	}

	/* missing compiler? */

	if (!ctx.unitidx) {

		if (flags & SLBT_DRIVER_VERBOSITY_ERRORS)

			fprintf(stderr,

				"%s: error: <compiler> is missing.\n",

				program);

		return -1;

	}

	/* obtain slibtool's own arguments */

	compiler = argv[ctx.unitidx];

	argv[ctx.unitidx] = 0;

	meta = argv_get(argv,options,ARGV_VERBOSITY_NONE);

	argv[ctx.unitidx] = compiler;

	/* missing --mode? */

	for (mode=0, entry=meta->entries; entry->fopt; entry++)

		if (entry->tag == TAG_MODE)

			mode = entry;

	argv_free(meta);

	if (!mode) {

		fprintf(stderr,

			"%s: error: --mode must be specified.\n",

			program);

		return -1;

	}

	/* allocate split vectors */

	for (argc=0, targv=argv; *targv; targv++)

		argc++;

	if ((sargv->targv = calloc(2*(argc+1),sizeof(char *))))

		sargv->cargv = sargv->targv + argc + 1;

	else

		return -1;

	/* split vectors: slibtool's own options */

	for (i=0; i

		sargv->targv[i] = argv[i];

	/* split vectors: legacy mixture */

	options = option_from_tag(

			slbt_default_options,

			TAG_OUTPUT);

	targv = sargv->targv + i;

	cargv = sargv->cargv;

	for (; i

		if (argv[i][0] != '-')

			*cargv++ = argv[i];

		else if (argv[i][1] == 'o')

			*targv++ = argv[i];

		else if ((argv[i][1] == 'W')  && (argv[i][2] == 'c'))

			*cargv++ = argv[i];

		else if (!(strcmp("Xcompiler",&argv[i][1])))

			*cargv++ = argv[++i];

		else {

			for (option=options; option->long_name; option++)

				if (!(strcmp(option->long_name,&argv[i][1])))

					break;

			if (option->long_name)

				*targv++ = argv[i];

			else

				*cargv++ = argv[i];

		}

	}

	return 0;

}

int slbt_get_driver_ctx(

	char **				argv,

	char **				envp,

	uint32_t			flags,

	struct slbt_driver_ctx **	pctx)

{

	struct slbt_split_vector	sargv;

	struct slbt_driver_ctx_impl *	ctx;

	struct slbt_common_ctx		cctx;

	const struct argv_option *	options;

	struct argv_meta *		meta;

	struct argv_entry *		entry;

	size_t				nunits;

	const char *			program;

	options = slbt_default_options;

	if (slbt_split_argv(argv,flags,&sargv))

		return -1;

	if (!(meta = argv_get(sargv.targv,options,slbt_argv_flags(flags))))

		return -1;

	nunits	= 0;

	program = argv_program_name(argv[0]);

	memset(&cctx,0,sizeof(cctx));

	/* get options, count units */

	for (entry=meta->entries; entry->fopt || entry->arg; entry++) {

		if (entry->fopt) {

			switch (entry->tag) {

				case TAG_HELP:

				case TAG_HELP_ALL:

					if (flags & SLBT_DRIVER_VERBOSITY_USAGE)

						return slbt_driver_usage(program,entry->arg,options,meta);

				case TAG_VERSION:

					cctx.drvflags |= SLBT_DRIVER_VERSION;

					break;

				case TAG_MODE:

					if (!strcmp("clean",entry->arg))

						cctx.mode = SLBT_MODE_CLEAN;

					else if (!strcmp("compile",entry->arg))

						cctx.mode = SLBT_MODE_COMPILE;

					else if (!strcmp("execute",entry->arg))

						cctx.mode = SLBT_MODE_EXECUTE;

					else if (!strcmp("finish",entry->arg))

						cctx.mode = SLBT_MODE_FINISH;

					else if (!strcmp("install",entry->arg))

						cctx.mode = SLBT_MODE_INSTALL;

					else if (!strcmp("link",entry->arg))

						cctx.mode = SLBT_MODE_LINK;

					else if (!strcmp("uninstall",entry->arg))

						cctx.mode = SLBT_MODE_UNINSTALL;

					break;

				case TAG_DRY_RUN:

					cctx.drvflags |= SLBT_DRIVER_DRY_RUN;

					break;

				case TAG_TAG:

					if (!strcmp("CC",entry->arg))

						cctx.tag = SLBT_TAG_CC;

					else if (!strcmp("CXX",entry->arg))

						cctx.tag = SLBT_TAG_CXX;

					break;

				case TAG_CONFIG:

					cctx.drvflags |= SLBT_DRIVER_CONFIG;

					break;

				case TAG_DEBUG:

					cctx.drvflags |= SLBT_DRIVER_DEBUG;

					break;

				case TAG_FEATURES:

					cctx.drvflags |= SLBT_DRIVER_FEATURES;

					break;

				case TAG_WARNINGS:

					if (!strcmp("all",entry->arg))

						cctx.tag = SLBT_WARNING_LEVEL_ALL;

					else if (!strcmp("error",entry->arg))

						cctx.tag = SLBT_WARNING_LEVEL_ERROR;

					else if (!strcmp("none",entry->arg))

						cctx.tag = SLBT_WARNING_LEVEL_NONE;

					break;

				case TAG_DEPS:

					cctx.drvflags |= SLBT_DRIVER_DEPS;

					break;

				case TAG_SILENT:

					cctx.drvflags |= SLBT_DRIVER_SILENT;

					break;

				case TAG_VERBOSE:

					cctx.drvflags |= SLBT_DRIVER_VERBOSE;

					break;

				case TAG_OUTPUT:

					cctx.output = entry->arg;

					break;

				case TAG_PREFER_PIC:

					cctx.drvflags |= SLBT_DRIVER_PRO_PIC;

					break;

				case TAG_PREFER_NON_PIC:

					cctx.drvflags |= SLBT_DRIVER_ANTI_PIC;

					break;

				case TAG_SHARED:

					cctx.drvflags |= SLBT_DRIVER_SHARED;

					break;

				case TAG_STATIC:

					cctx.drvflags |= SLBT_DRIVER_STATIC;

					break;

			}

		} else

			nunits++;

	}

	if (!(ctx = slbt_driver_ctx_alloc(meta,&cctx,nunits)))

		return slbt_get_driver_ctx_fail(meta);

	ctx->ctx.program	= program;

	ctx->ctx.cctx		= &ctx->cctx;

	ctx->targv		= sargv.targv;

	ctx->cargv		= sargv.cargv;

	*pctx = &ctx->ctx;

	return SLBT_OK;

}

int slbt_create_driver_ctx(

	const struct slbt_common_ctx *	cctx,

	struct slbt_driver_ctx **	pctx)

{

	struct argv_meta *		meta;

	struct slbt_driver_ctx_impl *	ctx;

	char *				argv[] = {"slibtool_driver",0};

	if (!(meta = argv_get(argv,slbt_default_options,0)))

		return -1;

	if (!(ctx = slbt_driver_ctx_alloc(meta,cctx,0)))

		return slbt_get_driver_ctx_fail(0);

	ctx->ctx.cctx = &ctx->cctx;

	memcpy(&ctx->cctx,cctx,sizeof(*cctx));

	*pctx = &ctx->ctx;

	return SLBT_OK;

}

static void slbt_free_driver_ctx_impl(struct slbt_driver_ctx_alloc * ictx)

{

	if (ictx->ctx.targv)

		free(ictx->ctx.targv);

	argv_free(ictx->meta);

	free(ictx);

}

void slbt_free_driver_ctx(struct slbt_driver_ctx * ctx)

{

	struct slbt_driver_ctx_alloc *	ictx;

	uintptr_t			addr;

	if (ctx) {

		addr = (uintptr_t)ctx - offsetof(struct slbt_driver_ctx_alloc,ctx);

		addr = addr - offsetof(struct slbt_driver_ctx_impl,ctx);

		ictx = (struct slbt_driver_ctx_alloc *)addr;

		slbt_free_driver_ctx_impl(ictx);

	}

}