/* $Id$ */
/* Copyright (c) 2011-2022 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 <System.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <errno.h>
#include "common.h"
#include "token.h"
#include "parser.h"

#ifndef PROGNAME_ASM
# define PROGNAME_ASM "asm"
#endif


/* private */
/* types */
typedef struct _State
{
	Cpp * cpp;
	Token * token;
	unsigned int error_cnt;
	unsigned int warning_cnt;
	AsmCode * code;

	/* directive */
	char * directive;
	char ** args;
	size_t args_cnt;

	/* instruction */
	AsmArchInstructionCall call;

	/* operands */
	int address;
	int negative;
} State;


/* prototypes */
static int _parser_check(State * state, TokenCode code);
static int _parser_defines(State * state, AsmPrefs * ap);
static int _parser_error(State * state, char const * format, ...);
static int _parser_is_code(State * state, TokenCode code);
static int _parser_in_set(State * state, TokenSet set);
static int _parser_recover(State * state, TokenCode code, char const * name);
static int _parser_scan(State * state);
static int _parser_warning(State * state, char const * format, ...);

/* grammar */
static int _program(State * state);
static int _directive(State * state);
static int _directive_arg(State * state);
static int _directive_args(State * state);
static int _directive_name(State * state);
static int _section_args(State * state);
static int _section_name(State * state);
static int _newline(State * state);
static int _space(State * state);
static int _statement(State * state);
static int _function(State * state);
static int _function_name(State * state);
static int _instruction(State * state);
static int _instruction_name(State * state);
static int _operand_list(State * state);
static int _operand(State * state);
static int _prefix(State * state);
static int _value(State * state);
static int _symbol(State * state);
static int _register(State * state);
static int _immediate(State * state);
static int _address(State * state);
static int _sign(State * state);
static int _offset(State * state);


/* functions */
/* parser_recover */
static int _parser_recover(State * state, TokenCode code, char const * name)
{
	while(!_parser_is_code(state, code))
		_parser_scan(state);
	return _parser_error(state, "%s%s", name, " expected");
}


/* parser_scan */
static int _scan_skip_meta(State * state);

static int _parser_scan(State * state)
{
	int ret;
	TokenCode code;
	char const * string;

	if(state->token != NULL)
		token_delete(state->token);
	if((ret = _scan_skip_meta(state)) != 0
			|| state->token == NULL)
		return ret;
	code = token_get_code(state->token);
	string = token_get_string(state->token);
	if(code == AS_CODE_WORD)
	{
		if(string != NULL && string[0] == '$')
			token_set_code(state->token, AS_CODE_IMMEDIATE);
	}
	else if(code == AS_CODE_OPERATOR_MODULO)
	{
		/* FIXME ugly workaround */
		if((ret = _scan_skip_meta(state)) != 0)
			return ret;
		if(_parser_is_code(state, AS_CODE_WORD))
			token_set_code(state->token, AS_CODE_REGISTER);
	}
	return 0;
}

static int _scan_skip_meta(State * state)
{
	int ret = 0;
	TokenCode code;

	while(cpp_scan(state->cpp, &state->token) == 0)
	{
		if(state->token == NULL)
			return ret;
		if((code = token_get_code(state->token)) < AS_CODE_META_FIRST
				|| code > AS_CODE_META_LAST)
			return ret;
		if(code == AS_CODE_META_ERROR)
			ret |= _parser_error(state, "%s", token_get_string(
						state->token));
		else if(code == AS_CODE_META_WARNING)
			_parser_warning(state, "%s", token_get_string(
						state->token));
		token_delete(state->token);
	}
	return 1;
}


/* parser_check */
static int _parser_check(State * state, TokenCode code)
{
	int ret = 0;

	if(!_parser_is_code(state, code))
		/* FIXME convert the code to a string */
		ret = _parser_error(state, "%s%u", "Parse error: expected ",
				code);
	ret |= _parser_scan(state);
	return ret;
}


/* parser_defines */
static int _parser_defines(State * state, AsmPrefs * ap)
{
	int ret = 0;
	char const * p;
	char * q;
	size_t len;
	size_t i;

	if((p = asmcode_get_arch(state->code)) != NULL
			&& (len = strlen(p)) > 0)
	{
		if((q = malloc(len + 5)) == NULL)
			return -error_set_code(1, "%s", strerror(errno));
		snprintf(q, len + 5, "__%s__", p);
		ret |= cpp_define_add(state->cpp, q, NULL);
		free(q);
	}
	if(ret == 0 && ap != NULL)
		for(i = 0; i < ap->defines_cnt; i++)
			ret |= cpp_define_add(state->cpp, ap->defines[i].name,
					ap->defines[i].value);
	return ret;
}


/* parser_is_code */
static int _parser_is_code(State * state, TokenCode code)
{
	if(state->token == NULL)
		return 0;
	return token_get_code(state->token) == code;
}


/* parser_in_set */
static int _parser_in_set(State * state, TokenSet set)
{
	if(state->token == NULL)
		return 0;
	return token_in_set(state->token, set);
}


/* parser_error */
static int _parser_error(State * state, char const * format, ...)
{
	va_list ap;

	fputs(PROGNAME_ASM ": ", stderr);
	if(state->cpp != NULL && state->token != NULL)
		/* FIXME will be wrong when string-based input is supported */
		fprintf(stderr, "%s%s%u: ", cpp_get_filename(state->cpp),
				", line ", token_get_line(state->token));
	va_start(ap, format);
	vfprintf(stderr, format, ap);
	va_end(ap);
	fputc('\n', stderr);
	return ++state->error_cnt;
}


/* parser_warning */
static int _parser_warning(State * state, char const * format, ...)
{
	va_list ap;

	fputs(PROGNAME_ASM ": ", stderr);
	if(state->cpp != NULL && state->token != NULL)
		/* FIXME will be wrong when string-based input is supported */
		fprintf(stderr, "%s%s%u: ", cpp_get_filename(state->cpp),
				", line ", token_get_line(state->token));
	va_start(ap, format);
	vfprintf(stderr, format, ap);
	va_end(ap);
	fputc('\n', stderr);
	return ++state->warning_cnt;
}


/* protected */
/* functions */
/* parser */
int parser(AsmPrefs * ap, AsmCode * code, char const * infile)
{
	CppPrefs prefs;
	State state;

	memset(&prefs, 0, sizeof(prefs));
	prefs.filename = infile;
	prefs.filters = CPP_FILTER_COMMENT;
	memset(&state, 0, sizeof(state));
	state.code = code;
	if((state.cpp = cpp_new(&prefs)) == NULL)
		return -1;
	if(_parser_defines(&state, ap) != 0)
	{
		cpp_delete(state.cpp);
		return -1;
	}
	if(_parser_scan(&state) != 0)
	{
		cpp_delete(state.cpp);
		return _parser_error(&state, "%s", error_get(NULL));
	}
	if(_program(&state) != 0)
		error_set_code(1, "%s%s%u%s%u%s", infile,
				": Compilation failed with ", state.error_cnt,
				" error(s) and ", state.warning_cnt,
				" warning(s)");
	if(state.token != NULL)
		token_delete(state.token);
	return state.error_cnt;
}


/* parser_string */
int parser_string(AsmPrefs * ap, AsmCode * code, char const * string)
{
	CppPrefs prefs;
	State state;
	size_t i;

	memset(&prefs, 0, sizeof(prefs));
#if 0
	prefs.filename = infile;
#endif
	prefs.filters = CPP_FILTER_COMMENT;
	memset(&state, 0, sizeof(state));
	state.code = code;
	if((state.cpp = cpp_new_string(&prefs, string)) == NULL)
		return -1;
	if(ap != NULL)
		for(i = 0; i < ap->defines_cnt; i++)
			if(cpp_define_add(state.cpp, ap->defines[i].name,
						ap->defines[i].value) != 0)
			{
				cpp_delete(state.cpp);
				return -1;
			}
	if(_parser_scan(&state) != 0)
		return _parser_error(&state, "%s", error_get(NULL));
	if(_program(&state) != 0)
		error_set_code(1, "%s%u%s%u%s", "Compilation failed with ",
				state.error_cnt, " error(s) and ",
				state.warning_cnt, " warning(s)");
	if(state.token != NULL)
		token_delete(state.token);
	return state.error_cnt;
}


/* grammar */
/* program */
static int _program(State * state)
	/* { directive | statement } */
{
	int ret = 0;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s()\n", __func__);
#endif
	for(;;)
	{
		if(_parser_in_set(state, TS_DIRECTIVE))
			/* directive */
			ret |= _directive(state);
		else if(_parser_in_set(state, TS_STATEMENT))
			/* statement */
			ret |= _statement(state);
		else
			/* end of input (FIXME really check) */
			break;
	}
	return ret;
}


/* directive */
static int _directive(State * state)
	/* "." directive_name [ space [ directive_args ] ] newline */
{
	int ret;
	size_t i;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s()\n", __func__);
#endif
	/* "." */
	ret = _parser_check(state, AS_CODE_OPERATOR_DOT);
	/* directive_name */
	if(!_parser_in_set(state, TS_DIRECTIVE_NAME))
		return _parser_recover(state, AS_CODE_NEWLINE,
				"Directive name");
	ret |= _directive_name(state);
	/* [ space [ directive_args ] ] */
	if(_parser_in_set(state, TS_SPACE))
	{
		ret |= _space(state);
		if(_parser_in_set(state, TS_DIRECTIVE_ARGS))
		{
			/* XXX hack to allow dots in section names */
			if(string_compare(state->directive, "section") == 0)
				ret |= _section_args(state);
			else
				ret |= _directive_args(state);
		}
	}
	/* execute the directive */
	if(string_compare(state->directive, "section") == 0)
	{
		if(state->args_cnt != 1)
			ret |= _parser_error(state, "%s",
					"Sections expect a name");
		else if(asmcode_section(state->code, state->args[0]) != 0)
			ret |= _parser_error(state, "%s", error_get(NULL));
	}
	else if(asmcode_directive(state->code, state->directive,
				(char const **)state->args,
				state->args_cnt) != 0)
		ret |= _parser_error(state, "%s", error_get(NULL));
	free(state->directive);
	state->directive = NULL;
	for(i = 0; i < state->args_cnt; i++)
		free(state->args[i]);
	free(state->args);
	state->args = NULL;
	state->args_cnt = 0;
	/* newline */
	if(!_parser_in_set(state, TS_NEWLINE))
		return _parser_recover(state, AS_CODE_NEWLINE, "New line");
	ret |= _newline(state);
	return ret;
}


/* directive_arg */
static int _directive_arg(State * state)
	/* WORD | NUMBER | "." */
{
	char const * string;
	char ** p;

	if(state->token == NULL
			|| (string = token_get_string(state->token)) == NULL
			|| strlen(token_get_string(state->token)) == 0)
		return error_set_code(1, "%s",
				"Empty directive arguments are not allowed");
	if((p = realloc(state->args, sizeof(*p) * (state->args_cnt + 1)))
			== NULL)
		return error_set_code(1, "%s", strerror(errno));
	state->args = p;
	p = &state->args[state->args_cnt];
	if((*p = strdup(string)) == NULL)
		return error_set_code(1, "%s", strerror(errno));
	state->args_cnt++;
	return _parser_scan(state);
}


/* directive_args */
static int _directive_args(State * state)
	/* directive_arg { space [ directive_arg ] } */
{
	int ret;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s()\n", __func__);
#endif
	ret = _directive_arg(state);
	while(_parser_in_set(state, TS_SPACE))
	{
		/* space */
		ret |= _space(state);
		/* [ directive_arg ] */
		if(_parser_in_set(state, TS_DIRECTIVE_ARGS))
			ret |= _directive_arg(state);
	}
	return ret;
}


/* directive_name */
static int _directive_name(State * state)
	/* WORD */
{
	int ret = 0;
	char const * string;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s()\n", __func__);
#endif
	if(state->token == NULL
			|| (string = token_get_string(state->token)) == NULL
			|| strlen(token_get_string(state->token)) == 0)
		return error_set_code(1, "%s",
				"Directives with empty names are not allowed");
	if((state->directive = strdup(string)) == NULL)
		return ret | error_set_code(1, "%s", strerror(errno));
	ret |= _parser_scan(state);
#ifdef DEBUG
	fprintf(stderr, "%s\"%s\"\n", "DEBUG: directive ", state->directive);
#endif
	return ret;
}


/* section_args */
static int _section_args(State * state)
{
	int ret;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s()\n", __func__);
#endif
	ret = _section_name(state);
	while(_parser_in_set(state, TS_DIRECTIVE_ARGS))
		/* section_name */
		ret |= _section_name(state);
	return ret;
}


/* section_name */
static int _section_name(State * state)
	/* WORD | NUMBER | "." */
{
	char const * string;
	char * p;
	size_t len;

	if(state->token == NULL
			|| (string = token_get_string(state->token)) == NULL
			|| (len = strlen(token_get_string(state->token))) == 0)
		return error_set_code(1, "%s",
				"Empty section arguments are not allowed");
	if(state->args == NULL)
	{
		if((state->args = malloc(sizeof(string))) == NULL
				|| (state->args[0] = strdup(string)) == NULL)
			return error_set_code(1, "%s", strerror(errno));
		state->args_cnt = 1;
		return _parser_scan(state);
	}
	if((p = realloc(state->args[0], strlen(state->args[0]) + len + 1))
			== NULL)
		return error_set_code(1, "%s", strerror(errno));
	state->args[0] = p;
	strcat(state->args[0], string);
	return _parser_scan(state);
}


/* newline */
static int _newline(State * state)
	/* [ space ] NEWLINE */
{
	int ret = 0;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s()\n", __func__);
#endif
	/* [ space ] */
	if(_parser_in_set(state, TS_SPACE))
		ret |= _space(state);
	/* NEWLINE */
	ret |= _parser_check(state, AS_CODE_NEWLINE);
	return ret;
}


/* space */
static int _space(State * state)
	/* SPACE { SPACE } */
{
	int ret;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s()\n", __func__);
#endif
	ret = _parser_check(state, AS_CODE_WHITESPACE);
	while(_parser_is_code(state, AS_CODE_WHITESPACE))
		ret |= _parser_scan(state);
	return ret;
}


/* statement */
static int _statement(State * state)
	/* ( function | [ space [ instruction ] ] ) newline */
{
	int ret = 0;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s()\n", __func__);
#endif
	if(_parser_in_set(state, TS_FUNCTION))
		/* function */
		ret = _function(state);
	else if(_parser_in_set(state, TS_SPACE))
	{
		/* space [ instruction ] */
		ret = _space(state);
		if(_parser_in_set(state, TS_INSTRUCTION))
			ret |= _instruction(state);
	}
	else if(!_parser_in_set(state, TS_NEWLINE))
		return _parser_recover(state, AS_CODE_NEWLINE, "Statement");
	ret |= _newline(state);
	return ret;
}


/* function */
static int _function(State * state)
	/* function_name ":" */
{
	int ret;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s()\n", __func__);
#endif
	ret = _function_name(state);
	ret |= _parser_check(state, AS_CODE_OPERATOR_COLON);
	return ret;
}


/* function_name */
static int _function_name(State * state)
	/* WORD */
{
	int ret;
	char const * string;
	char * function = NULL;

	if((string = token_get_string(state->token)) == NULL)
		return _parser_error(state, "%s", "Empty function names are"
				" not allowed");
	if((function = strdup(string)) == NULL)
		return error_set_code(1, "%s", strerror(errno));
	ret = _parser_check(state, AS_CODE_WORD);
#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s \"%s\"\n", "function", function);
#endif
	if(asmcode_function(state->code, function) != 0)
		ret |= _parser_error(state, "%s", error_get(NULL));
	free(function);
	return ret;
}


/* instruction */
static int _instruction(State * state)
	/* [ prefix space ] instruction_name [ space [ operand_list ] ] */
{
	int ret = 0;
	char const * string;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s()\n", __func__);
#endif
	/* reset the current instruction */
	memset(&state->call, 0, sizeof(state->call));
	/* [ prefix space ] */
	if(_parser_in_set(state, TS_PREFIX)
			&& (string = token_get_string(state->token)) != NULL
			&& asmcode_get_arch_prefix_by_name(state->code,
				string) != NULL)
	{
		ret |= _prefix(state);
		if(_parser_in_set(state, TS_SPACE))
			ret |= _space(state);
		else
			ret |= _parser_error(state, "%s", "Expected a space");
	}
	/* instruction_name */
	ret |= _instruction_name(state);
	if(_parser_in_set(state, TS_SPACE))
	{
		/* [ space */
		ret |= _space(state);
		/* [ operand_list ] ] */
		if(_parser_in_set(state, TS_OPERAND_LIST))
			ret |= _operand_list(state);
	}
	/* call the current instruction */
	if(state->call.name != NULL)
	{
		if(asmcode_instruction(state->code, &state->call) != 0)
			ret |= _parser_error(state, "%s", error_get(NULL));
	}
	/* FIXME memory leak (register names...) */
	memset(&state->call, 0, sizeof(state->call));
	return ret;
}


/* instruction_name */
static int _instruction_name(State * state)
	/* WORD */
{
	char const * string;
	AsmArchInstruction const * ai;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s()\n", __func__);
#endif
	if((string = token_get_string(state->token)) == NULL)
	{
		_parser_scan(state);
		return _parser_error(state, "%s", "Empty instructions are not"
				" allowed");
	}
	if((ai = asmcode_get_arch_instruction_by_name(state->code, string))
			== NULL)
		return _parser_error(state, "%s: %s", string,
				"Unknown instruction");
	state->call.name = ai->name;
	/* optimized free(state->operator); out */
#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s() %s \"%s\"\n", __func__, "instruction ",
			string);
#endif
	return _parser_scan(state);
}


/* operand_list */
static int _operand_list(State * state)
	/* operand [ space ] { "," [ space ] operand [ space ] } */
{
	int ret;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s()\n", __func__);
#endif
	ret = _operand(state);
	state->call.operands_cnt++;
	if(_parser_in_set(state, TS_SPACE))
		ret |= _space(state);
	while(_parser_is_code(state, AS_CODE_COMMA))
	{
		/* "," */
		ret |= _parser_scan(state);
		/* [ space ] */
		if(_parser_in_set(state, TS_SPACE))
			ret |= _space(state);
		/* operand */
		ret |= _operand(state);
		/* [ space ] */
		if(_parser_in_set(state, TS_SPACE))
			ret |= _space(state);
		state->call.operands_cnt++;
	}
	return ret;
}


/* operand */
static int _operand(State * state)
	/* value | address */
{
#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s()\n", __func__);
#endif
	if(_parser_in_set(state, TS_VALUE))
		return _value(state);
	else if(_parser_in_set(state, TS_ADDRESS))
		return _address(state);
	return _parser_error(state, "%s", "Expected value or address");
}


/* prefix */
static int _prefix(State * state)
	/* WORD */
{
	AsmArchPrefix const * prefix;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s()\n", __func__);
#endif
	/* this is not supposed to fail */
	prefix = asmcode_get_arch_prefix_by_name(state->code,
			token_get_string(state->token));
	state->call.prefix = prefix->name;
	return _parser_scan(state);
}


/* value */
static int _value(State * state)
	/* symbol | register | immediate */
{
#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s()\n", __func__);
#endif
	if(_parser_in_set(state, TS_SYMBOL))
		return _symbol(state);
	else if(_parser_in_set(state, TS_REGISTER))
		return _register(state);
	else if(_parser_in_set(state, TS_IMMEDIATE))
		return _immediate(state);
	return _parser_error(state, "%s", "Expected symbol, register or"
			" immediate value");
}


/* symbol */
static int _symbol(State * state)
	/* WORD */
{
#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s()\n", __func__);
#endif
	/* FIXME really implement */
	return _parser_scan(state);
}


/* register */
static int _register(State * state)
	/* "%" WORD */
{
	AsmArchOperand * p;
	char const * string;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s(%%%s) %d\n", __func__, token_get_string(
				state->token), state->address);
#endif
	p = &state->call.operands[state->call.operands_cnt];
	string = token_get_string(state->token); /* XXX may be null or empty? */
	if(state->address == 2)
	{
		p->definition = AO_DREGISTER2(0, 0, 0, 0);
		p->value.dregister2.name = p->value.dregister.name;
		p->value.dregister2.name2 = strdup(string);
	}
	else if(state->address == 1)
	{
		p->definition = AO_DREGISTER(0, 0, 0, 0);
		p->value.dregister.name = strdup(string);
	}
	else if(state->address == 0)
	{
		p->definition = AO_REGISTER(0, 0, 0);
		p->value._register.name = strdup(string);
	}
	return _parser_scan(state);
}


/* immediate */
static int _immediate(State * state)
	/* [ sign ] "$" NUMBER */
{
	int ret = 0;
	AsmArchOperand * p;
	char const * string;
	uint64_t value = 0;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s()\n", __func__);
#endif
	/* [ sign ] */
	if(_parser_in_set(state, TS_SIGN))
		ret |= _sign(state);
	else
		state->negative = 0;
	/* "$" NUMBER */
	p = &state->call.operands[state->call.operands_cnt];
	if((string = token_get_string(state->token)) != NULL
			|| strlen(string) == 0)
		value = strtoul(string + 1, NULL, 0);
	else
		ret = _parser_error(state, "%s", "Empty values are not"
				" allowed");
	if(state->address > 0)
		p->value.dregister.offset = value;
	else
	{
		p->value.immediate.value = strtoul(string + 1, NULL, 0);
		p->definition = AO_IMMEDIATE(0, 0, 0);
		p->value.immediate.negative = state->negative;
	}
	return ret | _parser_scan(state);
}


/* address */
static int _address(State * state)
	/* "[" [ space ] [ sign [ space ] ] value [ space ] [ offset [ space ] ] "]" */
{
	int ret;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s()\n", __func__);
#endif
	state->address = 1;
	/* "[" */
	ret = _parser_scan(state);
	/* [ space ] */
	if(_parser_in_set(state, TS_SPACE))
		ret |= _space(state);
	/* [ sign [ space ] ] */
	if(_parser_in_set(state, TS_SIGN))
	{
		ret |= _sign(state);
		if(_parser_in_set(state, TS_SPACE))
			ret |= _space(state);
	}
	else
		state->negative = 0;
	/* value */
	if(_parser_in_set(state, TS_VALUE))
		ret |= _value(state);
	else
		ret |= _parser_error(state, "%s", "Expected value");
	/* [ space ] */
	if(_parser_in_set(state, TS_SPACE))
		ret |= _space(state);
	/* [ offset [ space ] ] */
	if(_parser_in_set(state, TS_OFFSET))
	{
		state->address = 2;
		ret |= _offset(state);
		if(_parser_in_set(state, TS_SPACE))
			ret |= _space(state);
	}
	state->address = 0;
	/* "]" */
	return ret | _parser_check(state, AS_CODE_OPERATOR_RBRACKET);
}


/* offset */
static int _offset(State * state)
	/* sign [ space ] value */
{
	int ret;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s()\n", __func__);
#endif
	/* sign */
	ret = _sign(state);
	/* [ space ] */
	if(_parser_in_set(state, TS_SPACE))
		ret |= _space(state);
	/* value */
	if(_parser_in_set(state, TS_VALUE))
		ret |= _value(state);
	else
		ret |= _parser_error(state, "%s", "Expected a value");
	return ret;
}


/* sign */
static int _sign(State * state)
	/* ( "+" | "-" ) */
{
#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s()\n", __func__);
#endif
	state->negative = (token_get_code(state->token)
			== AS_CODE_OPERATOR_MINUS) ? 1 : 0;
	return _parser_scan(state);
}