%code requires {
/* Required to break a circular dependency introduced with bison 2.6 */
typedef void* yyscan_t;
}
%code top {
#include <errno.h>
#include "lang.h"
#include "lexer.h"

static int yyerror(struct lgfs2_lang_state *state, yyscan_t lexer, const char *errorstr)
{
	fprintf(stderr, "%d:%d: %s\n", state->ls_linenum, state->ls_colnum, errorstr);
	return 1;
}

}
%defines
%debug
%define api.pure
%parse-param { struct lgfs2_lang_state *state }
%parse-param { yyscan_t lexer }
%lex-param { yyscan_t lexer }
%start script
%token TOK_COLON
%token TOK_COMMA
%token TOK_ID
%token TOK_LBRACE
%token TOK_LBRACKET
%token TOK_NUMBER
%token TOK_OFFSET
%token TOK_RBRACE
%token TOK_RBRACKET
%token TOK_SEMI
%token TOK_SET
%token TOK_GET
%token TOK_STATE
%token TOK_STRING
%token TOK_PATH
%%
script:	statements {
		state->ls_ast_root = $1;
		state->ls_interp_curr = $1;
	}
	| statements TOK_SEMI {
		state->ls_ast_root = $1;
		state->ls_interp_curr = $1;
	}
;
statements: statements TOK_SEMI statement {
		state->ls_ast_tail->ast_left = $3;
		state->ls_ast_tail = $3;
		$$ = $1;
	}
	| statement {
		if (state->ls_ast_tail == NULL)
			state->ls_ast_tail = $1;
		$$ = $1;
	}
;
statement: set_stmt { $$ = $1;}
	| get_stmt { $$ = $1; }
;
set_stmt: TOK_SET blockspec structspec {
		$1->ast_right = $2;
		$2->ast_right = $3;
		$$ = $1;
	}
	| TOK_SET blockspec typespec structspec {
		$1->ast_right = $2;
		$2->ast_right = $3;
		$3->ast_right = $4;
		$$ = $1;
	}
;
get_stmt: TOK_GET blockspec {
		$1->ast_right = $2; $$ = $1;
	}
	| TOK_GET blockspec TOK_STATE {
		$1->ast_right = $2;
		$2->ast_right = $3;
		$$ = $1;
	}
;
blockspec: offset { $$ = $1; }
	| address { $$ = $1; }
	| path { $$ = $1; }
	| block_literal { $$ = $1; }
	| subscript { $$ = $1; }
;
offset:	blockspec TOK_OFFSET {
		$2->ast_left = $1;
		$$ = $2;
	}
;
typespec: identifier {
		$1->ast_type = AST_EX_TYPESPEC;
		$$ = $1;
	}
;
block_literal: identifier { $$ = $1; }
;
subscript: block_literal TOK_LBRACKET index TOK_RBRACKET {
		$4->ast_left = $1;
		$1->ast_left = $3;
		$$ = $4;
	}
;
index: number { $$ = $1; }
	| identifier { $$ = $1; }
;
address: number {
		$1->ast_type = AST_EX_ADDRESS;
		$$ = $1;
	 }
;
structspec: TOK_LBRACE fieldspecs TOK_RBRACE { $$ = $2; }
	| TOK_LBRACE TOK_RBRACE { $$ = NULL; }
;
fieldspecs: fieldspecs TOK_COMMA fieldspec {
		$1->ast_left = $3;
		$$ = $1;
	}
	| fieldspec { $$ = $1; }
;
fieldspec: identifier TOK_COLON fieldvalue {
		$2->ast_right = $1;
		$1->ast_right = $3;
		$$ = $2;
	}
;
fieldvalue: number { $$ = $1; }
	| string { $$ = $1; }
;
number: TOK_NUMBER { $$ = $1; }
string: TOK_STRING { $$ = $1; }
identifier: TOK_ID { $$ = $1; }
path: TOK_PATH { $$ = $1; }
%%

/**
 * Allocate and initialize a new parse state structure. The caller must free the
 * memory returned by this function.
 */
struct lgfs2_lang_state *lgfs2_lang_init(void)
{
	struct lgfs2_lang_state *state;
	state = calloc(1, sizeof(struct lgfs2_lang_state));
	if (state == NULL) {
		return NULL;
	}
	state->ls_linenum = 1;
	return state;
}

void lgfs2_lang_free(struct lgfs2_lang_state **state)
{
	ast_destroy(&(*state)->ls_ast_root);
	free(*state);
	*state = NULL;
}

int lgfs2_lang_parsef(struct lgfs2_lang_state *state, FILE *src)
{
	int ret = 0;
	yyscan_t lexer;

	ret = yylex_init_extra(state, &lexer);
	if (ret != 0) {
		fprintf(stderr, "Failed to initialize lexer.\n");
		return ret;
	}

	yyset_in(src, lexer);
	ret = yyparse(state, lexer);
	yylex_destroy(lexer);
	return ret;
}

int lgfs2_lang_parses(struct lgfs2_lang_state *state, const char *cstr)
{
	int ret;
	FILE *src;
	char *str = strdup(cstr);

	if (str == NULL) {
		perror("Failed to duplicate source string");
		return 1;
	}
	src = fmemopen(str, strlen(str), "r");
	if (src == NULL) {
		perror("Failed to open string as source file");
		free(str);
		return 1;
	}
	ret = lgfs2_lang_parsef(state, src);
	fclose(src);
	free(str);
	if (ret != 0 || state->ls_errnum != 0) {
		return 1;
	}
	return 0;
}