%{

#include "config.h"

#include <stdlib.h>

#include <unistd.h> /* readlink */

#include "nls.h"

#include "kbd.h"

#include "contextP.h"

#include "ksyms.h"

#include "paths.h"

#include "parser.h"

%}

%top {

#include "keymap.h"

int stack_push(struct lk_ctx *ctx, lkfile_t *fp, void *scanner);

int stack_pop(struct lk_ctx *ctx, void *scanner);

}

%option reentrant

%option bison-bridge

%option stack

%option never-interactive

%option noyywrap

%option nounput

%option noinput

%option noyy_top_state

%option extra-type="struct lk_ctx *"

%{

int

stack_push(struct lk_ctx *ctx, lkfile_t *fp, void *scanner)

{

	int i = 0;

	while (ctx->stack[i]) i++;

	if (i == MAX_INCLUDE_DEPTH) {

		ERR(ctx, _("includes are nested too deeply"));

		return -1;

	}

	ctx->stack[i] = fp;

	yypush_buffer_state(yy_create_buffer(fp->fd, YY_BUF_SIZE, scanner), scanner);

	return 0;

}

int

stack_pop(struct lk_ctx *ctx, void *scanner)

{

	int i = 0;

	while (ctx->stack[i]) i++;

	if (!i)

		return 0;

	i--;

	/*

	 * The top of stack is input file for library. No need to close it.

	 */

	if (i) {

		lk_fpclose(ctx->stack[i]);

		free(ctx->stack[i]);

	}

	ctx->stack[i] = NULL;

	yypop_buffer_state(scanner);

	return 0;

}

/*

 * Where shall we look for an include file?

 * Current strategy (undocumented, may change):

 *

 * 1. Look for a user-specified LOADKEYS_INCLUDE_PATH

 * 2. Try . and ../include and ../../include

 * 3. Try D and D/../include and D/../../include

 *    where D is the directory from where we are loading the current file.

 * 4. Try KD/include and KD/#/include where KD = DATADIR/KEYMAPDIR.

 *

 * Expected layout:

 * KD has subdirectories amiga, atari, i386, mac, sun, include

 * KD/include contains architecture-independent stuff

 * like strings and iso-8859-x compose tables.

 * KD/i386 has subdirectories qwerty, ... and include;

 * this latter include dir contains stuff with keycode=...

 *

 * (Of course, if the present setup turns out to be reasonable,

 * then later also the other architectures will grow and get

 * subdirectories, and the hard-coded i386 below will go again.)

 *

 * People that dislike a dozen lookups for loadkeys

 * can easily do "loadkeys file_with_includes; dumpkeys > my_keymap"

 * and afterwards use only "loadkeys /fullpath/mykeymap", where no

 * lookups are required.

 */

static const char *const include_dirpath0[] = { "", 0 };

static const char *const include_dirpath1[] = { "", "../include/", "../../include/", 0 };

static const char *const include_dirpath3[] = {

	DATADIR "/" KEYMAPDIR "/include/",

	DATADIR "/" KEYMAPDIR "/i386/include/",

	DATADIR "/" KEYMAPDIR "/mac/include/", 0

};

static const char *const include_suffixes[] = { "", ".inc", 0 };

static int

find_incl_file_near_fn(struct lk_ctx *ctx, char *s, char *fn, lkfile_t *fp)

{

	const char *include_dirpath2[] = { 0, 0, 0, 0 };

	char *t, *te, *t1 = NULL, *t2 = NULL;

	int len, rc = 1;

	if (!fn)

		return 1;

	t = strdup(fn);

	if (t == NULL)

		goto nomem;

	te = strrchr(t, '/');

	if (te) {

		te[1] = 0;

		len = strlen(t);

		include_dirpath2[0] = t;

		include_dirpath2[1] = t1 = malloc(len + 12);

		include_dirpath2[2] = t2 = malloc(len + 15);

		if (t1 == NULL || t2 == NULL)

			goto nomem;

		strcpy(t1, t);

		strcat(t1, "../include/");

		strcpy(t2, t);

		strcat(t2, "../../include/");

		rc = lk_findfile(s, include_dirpath2, include_suffixes, fp);

		free(t1);

		free(t2);

	}

	free(t);

	return rc;

nomem:	ERR(ctx, _("out of memory"));

	if (t1) free(t1);

	if (t2) free(t2);

	if (t)  free(t);

	return -1;

}

static int

find_standard_incl_file(struct lk_ctx *ctx, char *s, lkfile_t *fp)

{

	char *pathname;

	int rc = 1;

	int i = 0;

	while (ctx->stack[i]) i++;

	if (i == 0)

		return -1;

	i--;

	pathname = ctx->stack[i]->pathname;

	if (lk_findfile(s, include_dirpath1, include_suffixes, fp)) {

		if ((rc = find_incl_file_near_fn(ctx, s, pathname, fp)) == -1)

			return rc;

	}

	/* If filename is a symlink, also look near its target. */

	if (rc) {

		char buf[MAXPATHLEN], path[MAXPATHLEN], *ptr;

		unsigned int n;

		n = readlink(pathname, buf, sizeof(buf));

		if (n > 0 && n < sizeof(buf)) {

			buf[n] = 0;

			if (buf[0] == '/') {

				rc = find_incl_file_near_fn(ctx, s, buf, fp);

			} else if (strlen(pathname) + n < sizeof(path)) {

				strcpy(path, pathname);

				path[sizeof(path) - 1] = 0;

				ptr = strrchr(path, '/');

				if (ptr)

					ptr[1] = 0;

				strcat(path, buf);

				rc = find_incl_file_near_fn(ctx, s, path, fp);

			}

		}

	}

	if (rc)

		rc = lk_findfile(s, include_dirpath3, include_suffixes, fp);

	return rc;

}

static int

find_incl_file(struct lk_ctx *ctx, char *s, lkfile_t *fp)

{

	char *ev;

	if (!s || !*s)

		return 1;

	if (*s == '/')		/* no path required */

		return (lk_findfile(s, include_dirpath0, include_suffixes, fp));

	if ((ev = getenv("LOADKEYS_INCLUDE_PATH")) != NULL) {

		/* try user-specified path */

		const char *user_dir[2] = { 0, 0 };

		while (ev) {

			int rc;

			char *t = strchr(ev, ':');

			char sv = 0;

			if (t) {

				sv = *t;

				*t = 0;

			}

			user_dir[0] = ev;

			if (*ev)

				rc = lk_findfile(s, user_dir, include_suffixes, fp);

			else	/* empty string denotes system path */

				rc = find_standard_incl_file(ctx, s, fp);

			if (rc <= 0)

				return rc;

			if (t)

				*t++ = sv;

			ev = t;

		}

		return 1;

	}

	return find_standard_incl_file(ctx, s, fp);

}

static int

open_include(struct lk_ctx *ctx, char *s, yyscan_t scanner)

{

	int rc;

	lkfile_t *fp;

	INFO(ctx, _("switching to %s"), s);

	fp = malloc(sizeof(lkfile_t));

	if (!fp) {

		ERR(ctx, _("out of memory"));

		return -1;

	}

	memset(fp, 0, sizeof(lkfile_t));

	rc = find_incl_file(ctx, s, fp);

	if (rc > 0) {

		ERR(ctx, _("cannot open include file %s"), s);

		free(s);

		return -1;

	} else if (rc == -1) {

		free(s);

		return -1;

	}

	free(s);

	return stack_push(ctx, fp, scanner);

}

%}

%s RVALUE

%x STR

%x INCLSTR

Comment			#|!

Continuation		\\\n

Eol			\n

Blank			[ \t]

Include			include[ \t]*

Decimal			[1-9][0-9]*

Octal			0[0-7]*

Hex			0[xX][0-9a-fA-F]+

Unicode			U\+([0-9a-fA-F]){4}

Literal			[a-zA-Z][a-zA-Z_0-9]*

Octa			([0-7]){1,3}

Charset			charset|Charset|CharSet|CHARSET

Keymaps			keymaps|Keymaps|KeyMaps|KEYMAPS

Keycode			keycode|Keycode|KeyCode|KEYCODE

String			string|String|STRING

Equals			=

Plain			plain|Plain|PLAIN

Shift			shift|Shift|SHIFT

Control			control|Control|CONTROL

Alt			alt|Alt|ALT

AltGr			altgr|Altgr|AltGr|ALTGR

ShiftL			shiftl|ShiftL|SHIFTL

ShiftR			shiftr|ShiftR|SHIFTR

CtrlL			ctrll|CtrlL|CTRLL

CtrlR			ctrlr|CtrlR|CTRLR

CapsShift		capsshift|Capsshift|CapsShift|CAPSSHIFT

AltIsMeta		[aA][lL][tT][-_][iI][sS][-_][mM][eE][tT][aA]

Strings			strings|Strings|STRINGS

Compose			compose|Compose|COMPOSE

As			as|As|AS

Usual			usual|Usual|USUAL

For			for|For|FOR

On			on|On|ON

To                      to|To|TO

%%

{Include}		{

				yy_push_state(INCLSTR, yyscanner);

			}

<INCLSTR>\"[^\"\n]+\"	{

				char *s = strndup(yytext+1, strlen(yytext)-2);

				if (s == NULL) {

					ERR(yyextra, _("out of memory"));

					return(ERROR);

				}

				if (open_include(yyextra, s, yyscanner) == -1)

					return(ERROR);

				while (((struct yyguts_t*)yyscanner)->yy_start_stack_ptr) {

					yy_pop_state(yyscanner);

				}

			}

<INCLSTR>[^"]|\"\"|\"[^"\n]*{Eol}	{

				ERR(yyextra, _("expected filename between quotes"));

				return(ERROR);

			}

<<EOF>>			{

				stack_pop(yyextra, yyscanner);

				if (!YY_CURRENT_BUFFER)

					yyterminate();

			}

{Continuation}		{

				yyset_lineno(yyget_lineno(yyscanner) + 1, yyscanner);

			}

{Eol}			{

				yyset_lineno(yyget_lineno(yyscanner) + 1, yyscanner);

				while (((struct yyguts_t*)yyscanner)->yy_start_stack_ptr) {

					yy_pop_state(yyscanner);

				}

				return(EOL);

			}

{Blank}+		; /* do nothing */

{Comment}.*/{Eol}	; /* do nothing */

{Equals}		{

				yy_push_state(RVALUE, yyscanner);

				lk_array_empty(yyextra->key_line);

				return(EQUALS);

			}

{String}		{

				yy_push_state(RVALUE, yyscanner);

				return(STRING);

			}

{To}			{

				yy_push_state(RVALUE, yyscanner);

				return(TO);

			}

{Unicode}		{

				yylval->num = strtol(yytext + 1, NULL, 16);

				if (yylval->num >= 0xf000) {

					ERR(yyextra, _("unicode keysym out of range: %s"),

						yytext);

					return(ERROR);

				}

				return(UNUMBER);

			}

{Decimal}|{Octal}|{Hex}	{

				yylval->num = strtol(yytext, NULL, 0);

				return(NUMBER);

			}

<RVALUE>{Literal}	{	return((yylval->num = ksymtocode(yyextra, yytext, TO_AUTO)) == -1 ? ERROR : LITERAL);	}

\-			{	return(DASH);		}

\,			{	return(COMMA);		}

\+			{	return(PLUS);		}

{Charset}		{	return(CHARSET);	}

{Keymaps}		{	return(KEYMAPS);	}

{Keycode}		{	return(KEYCODE);	}

{Plain}			{	return(PLAIN);		}

{Shift}			{	return(SHIFT);		}

{Control}		{	return(CONTROL);	}

{Alt}			{	return(ALT);		}

{AltGr}			{	return(ALTGR);		}

{ShiftL}		{	return(SHIFTL);		}

{ShiftR}		{	return(SHIFTR);		}

{CtrlL}			{	return(CTRLL);		}

{CtrlR}			{	return(CTRLR);		}

{CapsShift}		{	return(CAPSSHIFT);	}

{AltIsMeta}		{	return(ALT_IS_META);	}

{Strings}		{	return(STRINGS);	}

{Compose}		{	return(COMPOSE);	}

{As}			{	return(AS);		}

{Usual}			{	return(USUAL);		}

{On}			{	return(ON);		}

{For}			{	return(FOR);		}

'\\{Octa}'              {

				yylval->num = strtol(yytext + 2, NULL, 8);

				return(CCHAR);

			}

'\\.'                   {

				yylval->num = (unsigned char) yytext[2];

				return(CCHAR);

			}

'.'                     {

				yylval->num = (unsigned char) yytext[1];

				return(CCHAR);

			}

\"			{

				yylval->str.data[0] = '\0';

				yylval->str.len = 0;

				yy_push_state(STR, yyscanner);

			}

<STR>\\{Octa}		{

				if (yylval->str.len == MAX_PARSER_STRING) {

					ERR(yyextra, _("string too long"));

					return(ERROR);

				}

				yylval->str.data[yylval->str.len++] = strtol(yytext + 1, NULL, 8);

			}

<STR>\\\"               {

				if (yylval->str.len == MAX_PARSER_STRING) {

					ERR(yyextra, _("string too long"));

					return(ERROR);

				}

				yylval->str.data[yylval->str.len++] = '"';

			}

<STR>\\\\               {

				if (yylval->str.len == MAX_PARSER_STRING) {

					ERR(yyextra, _("string too long"));

					return(ERROR);

				}

				yylval->str.data[yylval->str.len++] = '\\';

			}

<STR>\\n		{

				if (yylval->str.len == MAX_PARSER_STRING) {

					ERR(yyextra, _("string too long"));

					return(ERROR);

				}

				yylval->str.data[yylval->str.len++] = '\n';

			}

<STR>[^\"\\]*		{

				int len = strlen(yytext);

				if (yylval->str.len + len >= MAX_PARSER_STRING) {

					ERR(yyextra, _("string too long"));

					return(ERROR);

				}

				strcpy((char *) yylval->str.data + yylval->str.len, yytext);

				yylval->str.len += len;

			}

<STR>\"			{

				yylval->str.data[yylval->str.len] = '\0';

				while (((struct yyguts_t*)yyscanner)->yy_start_stack_ptr) {

					yy_pop_state(yyscanner);

				}

				return(STRLITERAL);

			}

.			{

				return(ERROR);

			}

%%