/*
pragma.c
Copyright © 2008 William Astle

This file is part of LWASM.

LWASM is free software: you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the Free Software
Foundation, either version 3 of the License, or (at your option) any later
version.

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 General Public License for
more details.

You should have received a copy of the GNU General Public License along with
this program. If not, see <http://www.gnu.org/licenses/>.


This file contains stuff associated with lwasm specific strangeness
*/
#include <config.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include "lwasm.h"
#include "instab.h"

/*
A pragma is a means of controlling code generation.

The pseudo op "*pragma" which will be treated as a comment by an assembler
that doesn't recognize it and thus will not cause assembly errors. This is
the preferred way of flagging a pragma if it will not cause incorrect
execution of the program.

The pseudo op "pragma" which will cause an error on an assembler that does
not understand it.

In the case of "*pragma", unrecognized pragmas MUST be silently ignored. In
the case of "pragma", unrecognized pragmas should raise an error.

LWASM understands the following pragmas:

index0tonone
noindex0tonone

When set (index0tonone), an expression that evaluates to 0, other than a
bare constant, in a <offset>,r operand will cause the code for ",r" to be
emitted rather than "0,r". If not set (noindex0tonone), the "0,r" output
will be emitted. The default is to perform the optimization.

This particular optimization will save a cycle for a direct operation. For
an indirect operation, however, it will save several cycles and a program byte
which may be very useful.
*/

void pseudo_pragma_real(asmstate_t *as, lwasm_line_t *cl, char **optr, int error)
{
	char pragma[128];
	int c = 0;
	
	while (**optr && isspace(**optr))
		(*optr)++;

pragmaagain:
	c = 0;	
	while (c < 127 && **optr && **optr != ',' && !isspace(**optr))
	{
		pragma[c++] = **optr;
		(*optr)++;
	}
	
	if (c == 0 || (**optr && **optr != ',' && !isspace(**optr)))
	{
		if (error)
		{
			register_error(as, cl, 1, "Unrecognized pragma");
		}
		if (error == 2)
		{
			*optr = NULL;
		}
		return;
	}
	pragma[c] = 0;
	if (!strcasecmp(pragma, "noindex0tonone"))
	{
		as -> pragmas |= PRAGMA_NOINDEX0TONONE;
	}
	else if (!strcasecmp(pragma, "index0tonone"))
	{
		as -> pragmas &= ~PRAGMA_NOINDEX0TONONE;
	}
	else if (!strcasecmp(pragma, "undefextern"))
	{
		as -> pragmas |= PRAGMA_UNDEFEXTERN;
	}
	else if (!strcasecmp(pragma, "noundefextern"))
	{
		as -> pragmas &= ~PRAGMA_UNDEFEXTERN;
	}
	else if (!strcasecmp(pragma, "cescapes"))
	{
		as -> pragmas |= PRAGMA_CESCAPES;
	}
	else if (!strcasecmp(pragma, "nocescapes"))
	{
		as -> pragmas &= ~PRAGMA_CESCAPES;
	}
	else if (!strcasecmp(pragma, "importundefexport"))
	{
		as -> pragmas |= PRAGMA_IMPORTUNDEFEXPORT;
	}
	else if (!strcasecmp(pragma, "noimportundefexport"))
	{
		as -> pragmas &= ~PRAGMA_IMPORTUNDEFEXPORT;
	}
	else
	{
		if (error)
		{
			register_error(as, cl, 1, "Unrecognized pragma");
			if (error == 2)
			{
				*optr = NULL;
			}
		}
	}
	if (*optr && **optr == ',')
	{
		(*optr)++;
		goto pragmaagain;
	}
}

OPFUNC(pseudo_pragma)
{
	pseudo_pragma_real(as, l, p, 1);
}

OPFUNC(pseudo_starpragma)
{
	pseudo_pragma_real(as, l, p, 0);
}