xref: /src/tests/lib/libcurses/director/testlang_conf.l

%{
/*	$NetBSD: testlang_conf.l,v 1.14 2021/02/07 20:27:40 rillig Exp $ 	*/

/*-
 * Copyright 2009 Brett Lymn <blymn (at) NetBSD.org>
 *
 * All rights reserved.
 *
 * This code has been donated to The NetBSD Foundation by the Author.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. The name of the author may not be used to endorse or promote products
 *    derived from this software withough specific prior written permission
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 */

#include <curses.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/param.h>
#include <err.h>
#include "returns.h"
#include "testlang_parse.h"

#define MAX_INCLUDES 32 /* limit for the number of nested includes */

int yylex(void);

extern size_t line;
extern char *include_path; 	/* from director.c */
extern char *cur_file;		/* from director.c */

static int include_stack[MAX_INCLUDES];
static char *include_files[MAX_INCLUDES];
static int include_ptr = 0;

static char *
dequote(const char *s, size_t *len)
{
	const unsigned char *p;
	char *buf, *q;

	*len = 0;
	p = (const unsigned char *)s;
	while (*p) {
		if (*p == '\\' && *(p+1)) {
			if (isdigit(*(p+1)) && *(p+2) && isdigit(*(p+2)) &&
			    *(p+3) && isdigit(*(p+3)))
				p += 3;
			else
				++p;
		}
		++(*len);
		++p;
	}

	buf = malloc(*len + 1);
	if (buf == NULL)
		return NULL;

	p = (const unsigned char *)s;
	q = buf;
	while (*p) {
		if (*p == '\\' && *(p+1)) {
			++p;
			if (isdigit(*p)) {
				if (*(p+1) && isdigit(*(p+1)) && *(p+2) &&
				    isdigit(*(p+2))) {
					*q++ = ((*p - '0') * 8 + (*(p+1) - '0')) * 8 + (*(p+2) - '0');
					p += 3;
				} else {
					*q++ = *p++;
				}
			} else {
				switch (*p) {
				case 'e':
					/* escape */
					*q++ = '\e';
					p++;
					break;

				case 'n':
					/* newline */
					*q++ = '\n';
					p++;
					break;

				case 'r':
					/* carriage return */
					*q++ = '\r';
					p++;
					break;

				case 't':
					/* tab */
					*q++ = '\t';
					p++;
					break;

				case '\\':
					/* backslash */
					*q++ = '\\';
					p++;
					break;

				default:
					*q++ = *p++;
				}
			}
		} else
			*q++ = *p++;
	}
	*q++ = '\0';

	return buf;
}
%}

HEX		0[xX][0-9a-zA-Z]+
STRING		[0-9a-z!#-&(-^ \t%._\\]+
numeric		[-0-9]+
PCHAR           (\\.|[^ \t\n])
ASSIGN		assign
CALL2		call2
CALL3		call3
CALL4		call4
CALL		call
CHECK		check
DELAY		delay
INPUT		input
NOINPUT		noinput
OK_RET		OK
ERR_RET		ERR
COMPARE		compare
COMPAREND	comparend
FILENAME	[A-Za-z0-9.][A-Za-z0-9./_-]+
VARNAME		[A-Za-z][A-Za-z0-9_-]+
NULL_RET	NULL
NON_NULL	NON_NULL
CCHAR		cchar
WCHAR		wchar
BYTE		BYTE
OR		\|
LPAREN		\(
RPAREN		\)
LBRACK		\[
RBRACK		\]
MULTIPLIER	\*

%x incl
%option noinput nounput

%%

include		BEGIN(incl);

<incl>[ \t]*	/* eat the whitespace */
<incl>[^ \t\n]+ { /* got the include file name */
		char inc_file[MAXPATHLEN];

		if (include_ptr > MAX_INCLUDES) {
			fprintf(stderr,
				"Maximum number of nested includes exceeded "
				"at line %zu of file %s\n", line, cur_file);
				exit(2);
		}

		if (yytext[0] != '/') {
			if (strlcpy(inc_file, include_path, sizeof(inc_file))
			    >= sizeof(inc_file))
				err(2, "CHECK_PATH too long");
			if ((include_path[strlen(include_path) - 1] != '/') &&
			    ((strlcat(inc_file, "/", sizeof(inc_file))
			    >= sizeof(inc_file))))
				err(2, "Could not append / to include file path");
		} else {
			inc_file[0] = '\0';
		}

		if (strlcat(inc_file, yytext, sizeof(inc_file))
		    >= sizeof(inc_file))
			err(2, "Path to include file path overflowed");

		yyin = fopen(inc_file, "r" );

		if (!yyin)
			err(1, "Error opening %s", inc_file);

		yypush_buffer_state(yy_create_buffer(yyin, YY_BUF_SIZE));

		include_stack[include_ptr] = line;
		include_files[include_ptr++] = cur_file;
		cur_file = strdup(inc_file);
		if (cur_file == NULL)
			err(2, "Cannot allocate new include file string");
		line = 0;
		BEGIN(INITIAL);
	}

<<EOF>>	{
		yypop_buffer_state();

		if (!YY_CURRENT_BUFFER)
			yyterminate();

		if (--include_ptr < 0)
			err(2, "Include stack underflow");

		free(cur_file);
		cur_file = include_files[include_ptr];
		line = include_stack[include_ptr];
	}

{ASSIGN}	return ASSIGN;
{CALL2}		return CALL2;
{CALL3}		return CALL3;
{CALL4}		return CALL4;
{CALL}		return CALL;
{CHECK}		return CHECK;
{DELAY}		return DELAY;
{INPUT}		return INPUT;
{NOINPUT}	return NOINPUT;
{COMPARE}	return COMPARE;
{COMPAREND}	return COMPAREND;
{NON_NULL}	return NON_NULL;
{NULL_RET}	return NULL_RET;
{OK_RET}	return OK_RET;
{ERR_RET}	return ERR_RET;
{MULTIPLIER}	return MULTIPLIER;
{CCHAR}		return CCHAR;
{WCHAR}		return WCHAR;
{OR}		return OR;
{LPAREN}	return LPAREN;
{RPAREN}	return RPAREN;
{LBRACK}	return LBRACK;
{RBRACK}	return RBRACK;

{HEX}		{
			/* Hex value, convert to decimal and return numeric */
			unsigned long val;

			if (sscanf(yytext, "%lx", &val) != 1)
				err(1, "Bad hex conversion");

			asprintf(&yylval.string, "%ld", val);
			return numeric;
		}

{numeric}	{
			if ((yylval.string = strdup(yytext)) == NULL)
				err(1, "Cannot allocate numeric string");
			return numeric;
		}

{VARNAME}	{
			if ((yylval.string = strdup(yytext)) == NULL)
				err(1, "Cannot allocate string for varname");
			return VARNAME;
		}

{FILENAME}	{
			size_t len;

			if ((yylval.string = dequote(yytext, &len)) == NULL)
				err(1, "Cannot allocate filename string");
			return FILENAME;
		}

	/* path */
\/{PCHAR}+	{
			size_t len;
			if ((yylval.string = dequote(yytext, &len)) == NULL)
				err(1, "Cannot allocate string");
			return PATH;
		}

\'{STRING}\' 	{
			char *p;
			size_t len;

			if ((yylval.retval = malloc(sizeof(ct_data_t))) == NULL)
				err(1, "Cannot allocate return struct");
			p = yytext;
			p++; /* skip the leading ' */
			if ((yylval.retval->data_value = dequote(p, &len))
			     == NULL)
				err(1, "Cannot allocate string");

			yylval.retval->data_type = data_byte;
			/* trim trailing ' */
			yylval.retval->data_len = len - 1;
			return BYTE;
		}

\`{STRING}\` 	{
			char *p, *str;
			size_t len, chlen;
			size_t i;
			chtype *rv;

			if ((yylval.retval = malloc(sizeof(ct_data_t))) == NULL)
				err(1, "Cannot allocate return struct");
			p = yytext;
			p++; /* skip the leading ` */
			if ((str = dequote(p, &len)) == NULL)
				err(1, "Cannot allocate string");
			len--; /* trim trailing ` */
			if ((len % 2) != 0)
				len--;

			chlen = ((len / 2) + 1) * sizeof(chtype);
			if ((yylval.retval->data_value = malloc(chlen))
			    == NULL)
				err(1, "Cannot allocate chtype array");

			rv = yylval.retval->data_value;
			for (i = 0; i < len; i += 2)
				*rv++ = (str[i] << 8) | str[i+1];
			*rv = __NORMAL | '\0'; /* terminates chtype array */
			yylval.retval->data_type = data_byte;
			yylval.retval->data_len = chlen;
			return BYTE;
		}

\"{STRING}\" 	{
			char *p;
			size_t len;

			p = yytext;
			p++; /* skip the leading " */
			if ((yylval.string = dequote(p, &len)) == NULL)
				err(1, "Cannot allocate string");

			/* remove trailing " */
			yylval.string[len - 1] = '\0';
			return STRING;
		}

\${VARNAME}	{
			char *p;

			p = yytext;
			p++; /* skip $ before var name */
			if ((yylval.string = strdup(p)) == NULL)
				err(1, "Cannot allocate string for varname");
			return VARIABLE;
		}

	/* whitespace, comments */
[ \t\r]		|
#.*		;

^[ \t\r]*#.*\n	|
\\\n		|
^\n		line++;

	/* eol on a line with data. need to process, return eol */
#.*\n		|
\n		{
			line++;
			return EOL;
		}

.		{
			if (isprint((unsigned char)yytext[0]))
				errx(1, "%s:%zu: Invalid character '%c'",
				    cur_file, line + 1, yytext[0]);
			else
				errx(1, "%s:%zu: Invalid character '0x%02x'",
				    cur_file, line + 1, yytext[0]);
		}

%%

int
yywrap(void)
{
	return 1;
}