parser.y

/*
	Copyright(C) 2016, Red Hat, Inc., Jerome Marchand

	This program 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/>.
*/

%{
#include "parser.h"
#include <limits.h>

#include "utils.h"

#define abort(...)				\
{						\
	fprintf(stderr, __VA_ARGS__);		\
	YYABORT;				\
}

#define check_and_free_keyword(identifier, expected)			\
{									\
	if (strcmp(identifier, expected))				\
		abort("Wrong keyword: %s expected, %s received\n",	\
		      expected, identifier);				\
	free(identifier);						\
}


%}

%union {
	int i;
	unsigned int ui;
	long l;
	unsigned long ul;
	void *ptr;
	char *str;
	obj_t *obj;
	obj_list_head_t *list;
}

%token <str> IDENTIFIER STRING SRCFILE
%token <ul> CONSTANT

%token NEWLINE
%token TYPEDEF
%token CONST VOLATILE
%token STRUCT UNION ENUM ELLIPSIS
%token VERSION_KW CU_KW FILE_KW STACK_KW SYMBOL_KW_NL
%token ARROW UNKNOWN_FIELD

%type <str> type_qualifier
%type <obj> typed_type base_type reference_file array_type
%type <obj> type ptr_type variable_var_list func_type elt enum_elt enum_type
%type <obj> union_type struct_type struct_elt
%type <obj> declaration_var declaration_typedef declaration
%type <obj> kabi_dw_file symbol
%type <obj> asm_symbol weak_symbol
%type <list> elt_list arg_list enum_list struct_list
%type <ul> alignment byte_size

%parse-param {obj_t **root}

%%

kabi_dw_file:
	fmt_version header SYMBOL_KW_NL symbol
	{
		$$ = *root = $symbol;
		obj_fill_parent(*root);
	}
	;

fmt_version:
	VERSION_KW CONSTANT '.' CONSTANT NEWLINE
	{
		if (($2 != FILEFMT_VERSION_MAJOR) |
		    ($4 > FILEFMT_VERSION_MINOR))
			abort("Unsupported file version: %lu.%lu\n", $2, $4);
	}
	;

header:
	/* empty */
	| header header_field
	;

header_field:
	cu_field
	| source_file_field
	| stack_field
	| UNKNOWN_FIELD
	;

cu_field:
	CU_KW STRING NEWLINE
	{
	    free($STRING);
	}
	;

source_file_field:
	FILE_KW SRCFILE ':' CONSTANT NEWLINE
	{
	    free($SRCFILE);
	}
	;

stack_field:
	STACK_KW NEWLINE stack_list
	;

stack_list:
	/* empty */
	| stack_list stack_elt NEWLINE
	;

stack_elt:
	ARROW STRING
	{
		free($STRING);
	}
	;

symbol:
	declaration NEWLINE
	{
		$$ = $declaration;
	}
	| alignment declaration NEWLINE
	{
		$$ = $declaration;
		$$->alignment = $alignment;
	}
	| byte_size declaration NEWLINE
	{
		$$ = $declaration;
		$$->byte_size = $byte_size;
	}
	| byte_size alignment declaration NEWLINE
	{
		$$ = $declaration;
		$$->byte_size = $byte_size;
		$$->alignment = $alignment;
	}

alignment:
        IDENTIFIER CONSTANT NEWLINE
	{
		check_and_free_keyword($IDENTIFIER, "Alignment");
		$$ = $CONSTANT;
	}

byte_size:
        IDENTIFIER IDENTIFIER CONSTANT NEWLINE
	{
		check_and_free_keyword($1, "Byte");
		check_and_free_keyword($2, "size");
		$$ = $CONSTANT;
	}

/* Possible types are struct union enum func typedef and var */
declaration:
	struct_type
	| union_type
	| enum_type
	| func_type
	| declaration_typedef
	| declaration_var
	| weak_symbol
	| asm_symbol
	;

declaration_typedef:
	TYPEDEF IDENTIFIER NEWLINE type
	{
	    $$ = obj_typedef_new_add($IDENTIFIER, $type);
	}
	;

declaration_var:
	IDENTIFIER IDENTIFIER type
	{
	    check_and_free_keyword($1, "var");
	    $$ = obj_var_new_add($2, $type);
	}
	;

type:
	base_type
	| reference_file
	| struct_type
	| union_type
	| enum_type
	| func_type
	| ptr_type
	| array_type
	| typed_type
	;

struct_type:
	STRUCT IDENTIFIER '{' NEWLINE '}'
	{
	    $$ = obj_struct_new($IDENTIFIER);
	}
	| STRUCT IDENTIFIER '{' NEWLINE struct_list NEWLINE '}'
	{
	    $$ = obj_struct_new($IDENTIFIER);
	    $$->member_list = $struct_list;
	}
	;

struct_list:
	struct_elt
	{
	    $$ = obj_list_head_new($struct_elt);
	}
	| struct_list NEWLINE struct_elt
	{
	    obj_list_add($1, $struct_elt);
	    $$ = $1;
	}
	;

struct_elt:
	CONSTANT IDENTIFIER type
	{
	    $$ = obj_struct_member_new_add($IDENTIFIER, $type);
	    $$->offset = $CONSTANT;
	}
	/* with alignment */
	| CONSTANT CONSTANT IDENTIFIER type
	{
	    $$ = obj_struct_member_new_add($IDENTIFIER, $type);
	    $$->offset = $1;
            $$->alignment = $2;
	}
	| CONSTANT ':' CONSTANT '-' CONSTANT IDENTIFIER type
	{
	    if ($5 > UCHAR_MAX || $3 > $5)
		abort("Invalid offset: %lx:%lu:%lu\n", $1, $3, $5);
	    $$ = obj_struct_member_new_add($IDENTIFIER, $type);
	    $$->offset = $1;
	    $$->is_bitfield = 1;
	    $$->first_bit = $3;
	    $$->last_bit = $5;
	}
	/* with alignment */
	| CONSTANT ':' CONSTANT '-' CONSTANT CONSTANT IDENTIFIER type
	{
	    if ($5 > UCHAR_MAX || $3 > $5)
		abort("Invalid offset: %lx:%lu:%lu\n", $1, $3, $5);
	    $$ = obj_struct_member_new_add($IDENTIFIER, $type);
	    $$->offset = $1;
	    $$->is_bitfield = 1;
	    $$->first_bit = $3;
	    $$->last_bit = $5;
	    $$->alignment = $6;
	}
	;

union_type:
	UNION IDENTIFIER '{' NEWLINE '}'
	{
	    $$ = obj_union_new($IDENTIFIER);
	}
	| UNION IDENTIFIER '{' NEWLINE elt_list NEWLINE '}'
	{
	    $$ = obj_union_new($IDENTIFIER);
	    $$->member_list = $elt_list;
	    $elt_list->object = $$;
	}
	;

enum_type:
	ENUM IDENTIFIER '{' NEWLINE enum_list NEWLINE '}'
	{
	    $$ = obj_enum_new($IDENTIFIER);
	    $$->member_list = $enum_list;
	    $enum_list->object = $$;
	}
	;

enum_list:
	enum_elt
	{
	    $$ = obj_list_head_new($enum_elt);
	}
	| enum_list NEWLINE enum_elt
	{
	    obj_list_add($1, $enum_elt);
	    $$ = $1;
	}
	;

enum_elt:
	IDENTIFIER '=' CONSTANT
	{
	    $$ = obj_constant_new($IDENTIFIER);
	    $$->constant = $CONSTANT;
	}
	;

func_type:
	IDENTIFIER IDENTIFIER '(' NEWLINE arg_list ')' NEWLINE type
	{
	    check_and_free_keyword($1, "func");
	    $$ = obj_func_new_add($2, $type);
	    $$->member_list = $arg_list;
	    if ($arg_list)
		    $arg_list->object = $$;
	}
	| IDENTIFIER reference_file /* protype define as typedef */
	{
	    check_and_free_keyword($IDENTIFIER, "func");
	    $$ = obj_func_new_add(NULL, $reference_file);
	}
	;

arg_list:
	/* empty */
	{
	    $$ = NULL;
	}
	| elt_list NEWLINE
	{
	    $$ = $elt_list;
	}
	| elt_list NEWLINE variable_var_list NEWLINE
	{
	    obj_list_add($elt_list, $variable_var_list);
	    $$ = $elt_list;
	}
	;

variable_var_list:
	IDENTIFIER ELLIPSIS
	{
	    /* TODO: there may be a better solution */
	    $$ = obj_var_new_add(NULL, obj_basetype_new(strdup("...")));
	}
	;

elt_list:
	elt
	{
	    $$ = obj_list_head_new($elt);
	}
	| elt_list NEWLINE elt
	{
	    obj_list_add($1, $elt);
	    $$ = $1;
	}
	;

elt:
	IDENTIFIER type
	{
	    $$ = obj_var_new_add($IDENTIFIER, $type);
	}
	;

ptr_type:
	'*' type
	{
	    $$ = obj_ptr_new_add($type);
	}
	;

array_type:
        '['CONSTANT ']' type
	{
	    $$ = obj_array_new_add($type);
	    $$->index = $CONSTANT;
	}
	;

typed_type:
	type_qualifier type
	{
	    $$ = obj_qualifier_new_add($type);
	    $$->base_type = $type_qualifier;
	}
	;

type_qualifier:
	CONST
	{
	    debug("Qualifier: const\n");
	    $$ = strdup("const");
	}
	| VOLATILE
	{
	    debug("Qualifier: volatile\n");
	    $$ = strdup("volatile");
	}
	;

base_type:
	STRING
	{
	    debug("Base type: %s\n", $STRING);
	    $$ = obj_basetype_new($STRING);
	}
	;

reference_file:
	'@' STRING
	{
	    $$ = obj_reffile_new();
	    $$->base_type = $STRING;
	    }
	;

asm_symbol:
	IDENTIFIER IDENTIFIER
	{
		check_and_free_keyword($1, "assembly");
		$$ = obj_assembly_new($2);
	}
	;

weak_symbol:
        IDENTIFIER IDENTIFIER ARROW IDENTIFIER
	{
		check_and_free_keyword($1, "weak");
		$$ = obj_weak_new($2);
		$$->link = $4;
	}
	;


%%

extern void usage(void);

obj_t *obj_parse(FILE *file, char *fn) {
	obj_t *root = NULL;

#ifdef DEBUG
	yydebug = 1;
#else
	yydebug = 0;
#endif

	yyin = file;
	yyparse(&root);
	if (!root)
		fail("No object build for file %s\n", fn);

	return root;
}

int yyerror(obj_t **root, char *s)
{
	fprintf(stderr, "error: %s\n", s);
	return 0;
}