src/tic/ticparse.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 1996, by Sun Microsystems, Inc.
 * All rights reserved.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 *	ticparse.c
 *
 *	Terminal Information Compiler
 *
 *	Copyright 1990, 1992 by Mortice Kern Systems Inc.  All rights reserved.
 *
 *	Portions of this code Copyright 1982 by Pavel Curtis.
 */

#ifdef M_RCSID
#ifndef lint
static char rcsID[] = "$Header: /rd/src/tic/rcs/ticparse.c 1.22 1995/06/27 14:56:46 ant Exp $";
#endif
#endif

#include "tic.h"
#include <ctype.h>
#include <sys/stat.h>
#include <errno.h>

extern int get_token ANSI((void));	/* from ticscan.c */

char *string_table;
int next_free;		/* next free character in string_table */
int table_size = 0; 	/* current string_table size */
int term_names;		/* string table offset - current terminal */
int part2 = 0;		/* set to allow old compiled defns to be used */
int complete = 0;	/* 1 if entry done with no forward uses */

struct use_item {
	long	offset;
	struct use_item	*fptr, *bptr;
};

struct use_header {
	struct use_item	*head, *tail;
};

struct use_header	use_list = {NULL, NULL};
int			use_count = 0;

/*
 *  The use_list is a doubly-linked list with NULLs terminating the lists:
 *
 *	   use_item    use_item    use_item
 *	  ---------   ---------   ---------
 *	  |       |   |       |   |       |   offset
 *        |-------|   |-------|   |-------|
 *	  |   ----+-->|   ----+-->|  NULL |   fptr
 *	  |-------|   |-------|   |-------|
 *	  |  NULL |<--+----   |<--+----   |   bptr
 *	  ---------   ---------   ---------
 *	  ^                       ^
 *	  |  ------------------   |
 *	  |  |       |        |   |
 *	  +--+----   |    ----+---+
 *	     |       |        |
 *	     ------------------
 *	       head     tail
 *	          use_list
 *
 */

char bad_start[] = m_textstr(
	3107, "File does not start with terminal names in column one", "E"
);
char not_names[] = m_textstr(3108, "Token after a seek not NAMES", "E");
char use_links[] = m_textstr(3109, "\
\n\
Error in following up use-links.  Either there is\n\
a loop in the links or they reference non-existant\n\
terminals.  The following is a list of the entries\n\
involved:\n\n\
", "E");
char nomem_use_list[] = m_textstr(
	3110, "Not enough memory for use_list element", "E"
);
char long_path[] = m_textstr(3111, "Pathname \"%c/%s\" too long.", "W char term");
char more_than_one[] = m_textstr(
	3112, "More than one entry defined for \"%s\".\n","W term"
);
char fail_open[] = m_textstr(3113, "Failed to open \"%s\".\n", "E filename");
char write_err[] = m_textstr(3114, "Error in writing \"%s\".\n", "E filename");
char synonym[] = m_textstr(3115, "Terminal \"%s\" is a synonym for itself.\n", "W term");
char fail_link[] = m_textstr(3116, "Failed to link \"%s\" to \"%s\".\n", "E file1 file2");
char name_check[] = m_textstr(3117, "\
compile: Line %d: Illegal terminal name - '%s'\n\
Terminal names must start with lowercase or digit.\n\
", "E line_num term");
char nomem[] = m_textstr(3118, "Failed to allocated memory.\n", "E");
char unknown_term[] = m_textstr(202, "Unknown terminal \"%s\".\n", "E term");
char no_terminfo[] = m_textstr(203, "No terminfo database.\n", "E");
char unknown_cap[] = m_textstr(3119, "Unknown capability '%s'.", "E action");
char unknown_token[] = m_textstr(3120, "Unknown token type.", "W");
char wrong_type[] = m_textstr(3121, "Wrong type used for capability \"%s\".", "W type");


/*f
 * debugging routine to dump list
 */
STATIC int
dump_list(str)
char *str;
{
	struct use_item *ptr;
	char line[512];

	fprintf(stderr, "dump_list %s\n", str);
	for (ptr = use_list.head; ptr != NULL; ptr = ptr->fptr)
	{
		fseek(stdin, ptr->offset, 0);
		fgets(line, 1024, stdin);
		fprintf(stderr, "ptr %x off %d bptr %x fptr %x str %s",
		ptr, ptr->offset, ptr->bptr, ptr->fptr, line);
	}
	fprintf(stderr, "\n");
}


/*f
 *	Generate an error message if given name does not begin with a
 *	digit or lower-case letter.
 */
STATIC int
check_name(name)
char	*name;
{
	if (!isdigit(name[0]) && !isalpha(name[0])) {
		fprintf(stderr, m_strmsg(name_check), curr_line, name);
		exit(1);
	}
}

/*f
 *	Test whether this machine will need byte-swapping
 */
STATIC int
must_swap()
{
	union {
		short num;
		char byte[2];
	} test;
	test.num = 1;
	return (test.byte[1]);
}


/*f
 *      Put a record of the given offset onto the use-list.
 */
STATIC int
enqueue(offset)
long	offset;
{
	struct use_item	*item;

	item = (struct use_item *) malloc(sizeof(struct use_item));

	if (item == NULL)
	    syserr_abort(m_strmsg(nomem_use_list));

	item->offset = offset;

	if (use_list.head != NULL)
	{
	    item->bptr = use_list.tail;
	    use_list.tail->fptr = item;
	    item->fptr = NULL;
	    use_list.tail = item;
	}
	else
	{
	    use_list.tail = use_list.head = item;
	    item->fptr = item->bptr = NULL;
	}

	use_count ++;
}


/*f
 *	remove the pointed-to item from the use_list
 */
STATIC int
dequeue(ptr)
struct use_item	*ptr;
{
	if (ptr->fptr == NULL)
	    use_list.tail = ptr->bptr;
	else
	    (ptr->fptr)->bptr = ptr->bptr;

	if (ptr->bptr == NULL)
	    use_list.head = ptr->fptr;
	else
	    (ptr->bptr)->fptr = ptr->fptr;

	use_count --;
}


/*f
 *	Write out the compiled entry to the given file.
 *	Return 0 if OK or -1 if not.
 */
STATIC int
write_object(fp)
FILE *fp;
{
	int i, tlength;
    	__t_term_header header;
	char *tnames, zero = '\0';

	tnames = string_table + term_names;
	tlength = strlen(tnames) + 1;
	if (TERM_NAMES_LENGTH < tlength)
		tlength = TERM_NAMES_LENGTH;
	if (must_swap()) {
		header.magic = swap(TERMINFO_MAGIC);
		header.name_size = swap(tlength);
		header.bool_count = swap(BOOLCOUNT);
		header.num_count = swap(NUMCOUNT);
		header.str_count = swap(STRCOUNT);
		header.str_size = swap(next_free);
	} else {
		header.magic = TERMINFO_MAGIC;
		header.name_size = tlength;
		header.bool_count = BOOLCOUNT;
		header.num_count = NUMCOUNT;
		header.str_count = STRCOUNT;
		header.str_size = next_free;
	}

	if (fwrite(&header, sizeof (header), 1, fp) != 1
	|| fwrite(tnames, sizeof (char), tlength, fp) != tlength
	|| fwrite(boolean, sizeof (char), BOOLCOUNT, fp) != BOOLCOUNT)
		return (-1);

	if ((tlength+BOOLCOUNT) % 2 != 0
	&& fwrite(&zero, sizeof (char), 1, fp) != 1)
		return (-1);

	if (must_swap()) {
		for (i = 0; i < NUMCOUNT; ++i)
			number[i] = swap(number[i]);
		for (i = 0; i < STRCOUNT; ++i)
			string[i] = swap(string[i]);
	}

	if (fwrite(number, sizeof (short), NUMCOUNT, fp) != NUMCOUNT
	|| fwrite(string, sizeof (short), STRCOUNT, fp) != STRCOUNT
	|| fwrite(string_table, sizeof (char), next_free, fp) != next_free)
		return (-1);
	return (0);
}


/*f
 *	Save the compiled version of a description in the filesystem.
 *
 *	make a copy of the name-list
 *	break it up into first-name and all-but-last-name
 *	creat(first-name)
 *	write object information to first-name
 *	close(first-name)
 *      for each name in all-but-last-name
 *	    link to first-name
 *
 */
STATIC void
dump_structure()
{
	FILE *fp;
	struct stat sb;
	char *p, *q, *first, *fn, *long_name, dir[2], tname[TERM_NAMES_LENGTH];

	/* Bag copy of terminal name list.  Parse off the last name,
	 * which should be the terminal's long name.  Parse off the
	 * first name to be used for the terminal filename.
	 */
	(void) strncpy(tname, string_table + term_names, TERM_NAMES_LENGTH);
	DEBUG(7, "Terminal names are \"%s\".\n", tname);
	for (p = tname + strlen(tname); tname < p; --p) {
		if (*p == '|') {
			long_name = ++p;
			break;
		}
	}
	if (tname == p)
		long_name = tname;
	for (p = tname; p < long_name; ++p) {
		if (*p == '|') {
			if (tname < p)
				*p++ = '\0';
			break;
		}
	}
	if (check_only) {
		DEBUG(1, "Checked \"%s\".\n", tname);
		return;
	}
	DEBUG(7, "Terminfo file name is \"%s\".\n", tname);
	DEBUG(7, "Terminal's long name is \"%s\".\n", long_name);

	/* Create terminfo object file. */
	check_name(tname);
	*dir = tolower(*tname);
	dir[1] = '\0';
	first = m_pathcat(dir, tname);
	if (first == NULL)
		err_abort(m_strmsg(long_path), *tname, tname);
	if (0 <= stat(first, &sb) && start_time <= sb.st_mtime)
		warning(m_strmsg(more_than_one), tname);
	if (access(first, W_OK) == -1 && errno != ENOENT) {
		perror(first);
		err_abort(m_strmsg(write_err), first);
	}
	(void) unlink(first);
	if ((fp = fopen(first, "w")) == NULL)
		err_abort(m_strmsg(fail_open), first);
	DEBUG(1, "Created \"%s\".\n", first);
	if (write_object(fp) < 0)
		err_abort(m_strmsg(write_err), first);
	(void) fclose(fp);

	/* Create links for alternate names. */
	while (p < long_name) {
		for (q = p; p < long_name; ++p) {
			if (*p == '|') {
				*p++ = '\0';
				break;
			}
		}
		check_name(q);
		*dir = tolower(*q);
		dir[1] = '\0';
		fn = m_pathcat(dir, q);
		if (fn == NULL) {
			warning(m_strmsg(long_path), *q, q);
			continue;
		}
		if (strcmp(q, tname) == 0) {
			warning(m_strmsg(synonym), tname);
			continue;
		}
		if (0 <= stat(fn, &sb) && start_time <= sb.st_mtime) {
			warning(m_strmsg(more_than_one), q);
			continue;
		}
		if (access(fn, W_OK) == -1 && errno != ENOENT) {
			err_abort(m_strmsg(write_err), fn);
		}
		(void) unlink(fn);
		if (link(first, fn) < 0) {
			if ((fp = fopen(fn, "w")) == NULL)
				err_abort(m_strmsg(fail_open), fn);
			DEBUG(1, "Created \"%s\".\n", fn);
			if (write_object(fp) < 0)
				err_abort(m_strmsg(write_err), fn);
			(void) fclose(fp);
		} else {
			DEBUG(1, "Linked \"%s\".\n", fn);
		}
		free(fn);
	}
	free(first);
}


/*f
 *	copy string into next free part of string_table, doing a realloc()
 *	if necessary.  return offset of beginning of string from start of
 *	string_table.
 */
STATIC int
save_str(string)
char	*string;
{
	int	old_next_free = next_free;

	if (table_size == 0)
	{
	    if ((string_table = malloc(1024)) == NULL)
		syserr_abort(m_strmsg(nomem));
	    table_size = 1024;
	    DEBUG(5, "Made initial string table allocation.  Size is %d\n",
								    table_size);
	}

	while (table_size < next_free + strlen(string))
	{
	    if ((string_table = realloc(string_table, table_size + 1024))
									== NULL)
		syserr_abort(m_strmsg(nomem));
	    table_size += 1024;
	    DEBUG(5, "Extended string table.  Size now %d\n", table_size);
	}

	strcpy(&string_table[next_free], string);
	DEBUG(7, "Saved string '%s' ", string);
	DEBUG(7, "at location %d\n", next_free);
	next_free += strlen(string) + 1;

	return (old_next_free);
}

/*f
 *	Merge the compiled file whose name is in cur_token.valstring
 *	with the current entry.
 *
 *		if it's a forward use-link
 *	    	    if item_ptr == NULL
 *		        queue it up for later handling
 *	            else
 *		        ignore it (we're already going through the queue)
 *	        else it's a backward use-link
 *	            read in the object file for that terminal
 *	            merge contents with current structure
 *
 *	Returned value is 0 if it was a backward link and we
 *	successfully read it in, -1 if a forward link.
 */
STATIC int
handle_use(item_ptr, entry_offset)
struct use_item	*item_ptr;
long entry_offset;
{
        int i, err;
	struct stat sb;
	char *filename, dir[2];

	check_name(curr_token.tk_valstring);
	*dir = tolower(*curr_token.tk_valstring);
	dir[1] = '\0';
	filename = m_pathcat(dir, curr_token.tk_valstring);
	if (filename == NULL) {
		err_abort(
			m_strmsg(long_path),
			*curr_token.tk_valstring, curr_token.tk_valstring
		);
	}
	if (stat(filename, &sb) < 0
	|| (part2 == 0 && sb.st_mtime < start_time)) {
		DEBUG(2, "Forward USE to %s", curr_token.tk_valstring);
		if (item_ptr == NULL) {
			DEBUG(2, " (enqueued)\n", "");
			enqueue(entry_offset);
		} else {
			DEBUG(2, " (skipped)\n", "");
		}
		free(filename);
		return (-1);
	}
	DEBUG(2, "Backward USE to %s\n", curr_token.tk_valstring);
	(void) setupterm(curr_token.tk_valstring, STDOUT_FILENO, &err);
	switch (err) {
	case 1:
		for (i = 0; i < BOOLCOUNT; ++i) {
			if (boolean[i] == 0 && cur_term->Booleans[i])
				boolean[i] = 1;
		}
		for (i = 0; i < NUMCOUNT; ++i) {
			if (number[i] == -1 && cur_term->Numbers[i] != -1)
				number[i] = cur_term->Numbers[i];
		}
		for (i = 0; i < STRCOUNT; ++i) {
			if (string[i] == -1 && cur_term->Strings[i] != NULL)
				string[i] = save_str(cur_term->Strings[i]);
		}
		(void) del_curterm(cur_term);
		free(filename);
		break;
	case 0:
		err_abort(m_strmsg(unknown_term), filename);
		exit(BAD_TERMINAL);
	case -1:
		err_abort(m_strmsg(no_terminfo));
		exit(BAD_TERMINAL);
	}
	return (0);
}


/*f
 *	Compile one entry.  During the first pass, item_ptr is NULL.  In pass
 *	two, item_ptr points to the current entry in the use_list.
 *
 *	found-forward-use = FALSE
 *	re-initialise internal arrays
 *	save names in string_table
 *	get_token()
 *	while (not EOF and not NAMES)
 *	    if found-forward-use
 *		do nothing
 *	    else if 'use'
 *		if handle_use() < 0
 *		    found-forward-use = TRUE
 *          else
 *	        check for existance and type-correctness
 *	        enter cap into structure
 *	        if STRING
 *	            save string in string_table
 *	    get_token()
 *      if ! found-forward-use
 *	    clear CANCELS out of the structure
 *	    dump compiled entry into filesystem
 */
STATIC int
do_entry(item_ptr)
struct use_item	*item_ptr;
{
	void *array;
	long entry_offset;
	int i, index;
	register int token_type;
	int found_forward_use = 0;

	reset();
	next_free = 0;

	complete = 0;
	term_names = save_str(curr_token.tk_name);
	DEBUG(2, "Starting '%s'\n", curr_token.tk_name);
	entry_offset = curr_file_pos;

	for (token_type = get_token();
	token_type != EOF && token_type != NAMES;
	token_type = get_token()) {
		if (found_forward_use) {
			;
		} else if (strcmp(curr_token.tk_name, "use") == 0) {
			if (handle_use(item_ptr, entry_offset) < 0)
				found_forward_use = 1;
		} else {
			if (find(curr_token.tk_name, &array, &index) < 0) {
				warning(
					m_strmsg(unknown_cap),
					curr_token.tk_name
				);
				continue;
			}
			switch (token_type) {
			case CANCEL:
				if (array == boolean)
					boolean[index] = 2;
				else
					((short*) array)[index] = -2;
				continue;
			case BOOLEAN:
				if (array == boolean) {
					boolean[index] = 1;
					continue;
				}
				break;
			case NUMBER:
				if (array == number) {
					number[index] = curr_token.tk_valnumber;
					continue;
				}
				break;
			case STRING:
				if (array == string) {
					string[index] = save_str(
						curr_token.tk_valstring
					);
					continue;
				}
				break;
			default:
				warning(m_strmsg(unknown_token));
				panic_mode(',');
				continue;
			}
			warning(m_strmsg(wrong_type), curr_token.tk_name);
		}
	}
	if (found_forward_use)
		return (token_type);

	/* Changed canceled values into in-active values. */
	for (i = 0; i < BOOLCOUNT; ++i)
		if (boolean[i] == 2)
			boolean[i] = 0;
	for (i = 0; i < NUMCOUNT; ++i)
		if (number[i] == -2)
			number[i] = -1;
	for (i = 0; i < STRCOUNT; ++i)
		if (string[i] == -2)
			string[i] = -1;
	dump_structure();
	complete = 1;
	return (token_type);
}


/*f
 *	Main loop of the compiler.
 *
 *	get_token()
 *	if curr_token != NAMES
 *	    err_abort()
 *	while (not at end of file)
 *	    do an entry
 */
void
compile()
{
	char			line[1024];
	int			token_type;
	struct use_item	*ptr;
	int			old_use_count;

	token_type = get_token();

	if (token_type != NAMES)
		err_abort(m_strmsg(bad_start));

	while (token_type != EOF)
	    token_type = do_entry(NULL);

	DEBUG(2, "Starting handling of forward USE's\n", "");

	for (part2=0; part2<2; part2++) {
	    old_use_count = -1;

	    DEBUG(2, "\n\nPART %d\n\n", part2);

	    while (use_list.head != NULL && old_use_count != use_count)
	    {
		old_use_count = use_count;
		for (ptr = use_list.tail; ptr != NULL; ptr = ptr->bptr)
		{
		    fseek(stdin, ptr->offset, 0);
		    reset_input();
		    if ((token_type = get_token()) != NAMES)
			syserr_abort(m_strmsg(not_names));
		    (void) do_entry(ptr);
		    if (complete)
			dequeue(ptr);
		}

		for (ptr = use_list.head; ptr != NULL; ptr = ptr->fptr)
		{
		    fseek(stdin, ptr->offset, 0);
		    reset_input();
		    if ((token_type = get_token()) != NAMES)
			syserr_abort(m_strmsg(not_names));
		    (void) do_entry(ptr);
		    if (complete)
			dequeue(ptr);
		}

		DEBUG(2,"Finished a pass through enqueued forward USE's\n","");
	    }
	}

	if (use_list.head != NULL) {
		fprintf(stderr, use_links);
		for (ptr = use_list.head; ptr != NULL; ptr = ptr->fptr) {
			fseek(stdin, ptr->offset, 0);
			fgets(line, 1024, stdin);
			fprintf(stderr, "%s", line);
		}
		exit(1);
	}
}