xref: /illumos-gate/usr/src/cmd/abi/spectrans/parser/frontend.c (revision 2a8bcb4e)

/*
 * 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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <dlfcn.h>
#include <dirent.h>
#include <libgen.h>
#include <sys/param.h>
#include <errno.h>

#include "parser.h"
#include "errlog.h"

static char const *ARCH_I386 = "i386";
static char const *ARCH_SPARC = "sparc";
static char const *ARCH_SPARCV9 = "sparcv9";
static char const *ARCH_IA64 = "ia64";
static char const *ARCH_AMD64 = "amd64";
static char const *ARCH_ALL = "all";

static int dofiles(const Translator_info *);
static int read_spec(const Translator_info *, char *);

static int Curlineno;

xlator_keyword_t *keywordlist;

/*
 * frontend entry point
 * returns the number of errors encountered
 */
int
frontend(const Translator_info *T_info)
{
	int retval, i = 0, errors = 0;

	keywordlist = xlator_init(T_info);
	if (keywordlist == NULL) {
		errlog(ERROR, "Error: Unable to get keywordlist\n");
		return (1);
	}

	if (T_info->ti_verbosity >= STATUS) {
		errlog(STATUS, "interesting keywords:\n");
		while (keywordlist[i].key != NULL) {
			errlog(STATUS,  "\t%s\n", keywordlist[i].key);
			++i;
		};
	}

	retval = xlator_startlib(T_info->ti_liblist);
	switch (retval) {
	case XLATOR_SKIP:
		if (T_info->ti_verbosity >= STATUS)
			errlog(STATUS,  "Skipping %s\n", T_info->ti_liblist);
		retval = 0;
		break;

	case XLATOR_NONFATAL:
		++errors;
		retval = 0;
		break;

	case XLATOR_SUCCESS:
		retval = dofiles(T_info);
		errors += retval;
		if ((retval = xlator_endlib()) != XLATOR_SUCCESS)
			++errors;
		retval = 0;
		break;

	default:
		errlog(ERROR | FATAL,
		    "Error: Invalid return code from xlator_startlib()\n");
		exit(1);
	}

	if ((retval = xlator_end()) != XLATOR_SUCCESS)
		++errors;

	return (errors);
}

/*
 * dofiles(const Translator_info *T_info);
 *    iterate through files specified in the command line and process
 *    them one by one
 * requires spec files to have a ".spec" suffix
 * returns the number of errors;
 */
static int
dofiles(const Translator_info *T_info)
{
	int nfiles, flen, findex, retval = 0, errors = 0;

	nfiles = T_info->ti_nfiles;

	for (findex = 0; findex < nfiles; ++findex) {
		flen = strlen(filelist[findex]);
		if ((flen <= 5) ||
			strcmp(&filelist[findex][flen-5], ".spec") != 0) {
			errlog(ERROR,
			    "Error: File specified does not have the "
			    ".spec extension: %s\n", filelist[findex]);
			++errors;
			continue;
		};
		retval = read_spec(T_info, filelist[findex]);
		errors += retval;
	}
	return (errors);
}

/*
 * read_spec -
 *   Given a filename, this function will reads the spec file to
 *   recognize keywords which it passes along with the corresponding
 *   value to the back-end translator to process. The following
 *   back-end interfaces are called:
 *	xlator_startfile
 *	xlator_start_if
 *	xlator_take_kvpair
 *	xlator_end_if
 *	xlator_endfile
 */
static int
read_spec(const Translator_info *T_info, char *spec_filename)
{
	FILE *spec_fp;
	Meta_info meta_info;
	char key[BUFSIZ], *value = NULL, *p = NULL;
	char *buf2 = NULL;
	int retval = 0, errors = 0, ki = 0;	/* keyword indicator */
	int start_if_fail = 0, skip_if = 0;
	int extends_err = 0;

	meta_info.mi_ext_cnt = 0; /* All info is non-extends */
	meta_info.mi_flags = 0;

	retval = xlator_startfile(spec_filename);

	switch (retval) {
	case XLATOR_SKIP:
		if (T_info->ti_verbosity >= WARNING)
			errlog(WARNING, "Warning: Skipping %s\n",
			    spec_filename);
		return (errors);

	case XLATOR_NONFATAL:
		errlog(ERROR, "Error in xlator_startfile\n");
		++errors;
		return (errors);

	case XLATOR_SUCCESS:
		break;

	default:
		errlog(ERROR,
		    "Error: Invalid return code from xlator_startfile()\n");
		++errors;
		return (errors);
	};

	/* file processing */
	spec_fp = fopen(spec_filename, "r");
	if (spec_fp == NULL) {
		errlog(ERROR,  "Error: Unable to open spec file %s: %s\n",
		    spec_filename, strerror(errno));
		++errors;
		return (errors);
	}

	(void) strncpy(meta_info.mi_filename, spec_filename, BUFSIZ);
	meta_info.mi_line_number = 0;
	Curlineno = meta_info.mi_line_number;
	while (meta_info.mi_nlines = readline(&buf2, spec_fp)) {
		meta_info.mi_line_number += meta_info.mi_nlines;
		Curlineno = meta_info.mi_line_number;
		if (!non_empty(buf2)) {
			free(buf2);
			buf2 = NULL;
			continue;
		}
		p = realloc(value, sizeof (char)*(strlen(buf2)+1));
		if (p == NULL) {
			errlog(ERROR | FATAL,
			    "Error: Unable to allocate memory for "
			    "value: %d\n", errno);
		}
		value = p;
		split(buf2, key, value);
		ki = interesting_keyword(keywordlist, key);
		switch (ki) {
		case XLATOR_KW_FUNC:	 /* Function keyword */
		case XLATOR_KW_DATA:	 /* Data keyword */
			meta_info.mi_extended = 0;
			retval = xlator_start_if(meta_info, ki, value);
			switch (retval) {
			case XLATOR_FATAL: /* FATAL ERROR */
				if (T_info->ti_verbosity >= STATUS) {
					errlog(STATUS,
					    "Error in xlator_start_if: ");
				}
				++errors;
				return (errors);
			case XLATOR_NONFATAL: /* NON-FATAL ERROR */
				if (T_info->ti_verbosity >= STATUS)
					errlog(STATUS,
					    "Error in xlator_start_if\n");
				++errors;
				start_if_fail = 1;
				break;
			case XLATOR_SUCCESS: /* OK */
				start_if_fail = 0;
				extends_err = check4extends(spec_filename,
				    value, T_info->ti_archtoken, spec_fp);
				switch (extends_err) {
				case -1:	/* Error */
					errlog(ERROR, "\"%s\", line %d: "
					    "Error occurred while "
					    "checking for extends clause\n",
					    spec_filename, Curlineno);
					++errors;
					/*FALLTHRU*/
				case 0:		/* No Extends */
					break;
				case 1:		/* Extends */
					meta_info.mi_extended = 1;
					extends_err = do_extends(meta_info,
					    T_info, value);
					if (extends_err) {
						errors += extends_err;
					}
					break;
				default:	/* Programmer Error */
					errlog(ERROR | FATAL,
					    "Error: invalid return from "
					    "check4extends %d\n", extends_err);
				}
				break;
			case XLATOR_SKIP: /* SKIP */
				if (T_info->ti_verbosity >= WARNING)
					errlog(WARNING, "Warning: Skipping "
					    "interface %s\n", value);
				skip_if = 1;
				start_if_fail = 0;
				break;
			default:
				/* Invalid Return */
				errlog(ERROR | FATAL,
				    "Error:  Invalid return code "
				    "from xlator_start_if (): %d\n", retval);
			}
			break;
		case XLATOR_KW_END: /* END keyword */
			if (start_if_fail == 0 && skip_if == 0) {
				retval = xlator_end_if(meta_info, value);
				if (retval)
					++errors;
			}
			skip_if = 0;
			break;
		case XLATOR_KW_NOTFOUND:
			if (T_info->ti_verbosity >= TRACING)
				errlog(TRACING, "uninteresting keyword: %s\n",
				    key);
			break;
		default:
			if (skip_if == 0 && start_if_fail == 0) {
				retval = xlator_take_kvpair(meta_info,
				    ki, value);
				if (retval) {
					if (T_info->ti_verbosity >= STATUS)
						errlog(STATUS, "Error in "
						    "xlator_take_kvpair\n");
					++errors;
				}
			}
		}
		free(buf2);
		buf2 = NULL;
	}

	if ((retval = xlator_endfile()) != XLATOR_SUCCESS) {
		if (T_info->ti_verbosity >= STATUS)
			errlog(STATUS, "Error in xlator_endfile\n");
		++errors;
	}
	free(p);
	(void) fclose(spec_fp);
	return (errors);
}

/*
 * interesting_keyword(char **keywordlist, const char *key) {
 *   returns the token associated with key if key is found in keywordlist
 *   returns XLATOR_KW_NOTFOUND if key is NOT found in keywordlist
 *   "Function" and "End" are always interesting, return XLATOR_KW_FUNC
 *   and XLATOR_KW_DATA respectively;
 *   "End" is always interesting, return XLATOR_KW_END;
 *
 */
int
interesting_keyword(xlator_keyword_t *keywordlist, const char *key)
{
	int i = 0;

	if (strcasecmp(key, "data") == 0) {
		return (XLATOR_KW_DATA);
	}
	if (strcasecmp(key, "function") == 0) {
		return (XLATOR_KW_FUNC);
	}

	if (strcasecmp(key, "end") == 0)
		return (XLATOR_KW_END);

	while (keywordlist[i].key != NULL) {
		if (strcasecmp(keywordlist[i].key, key) == 0)
			return (keywordlist[i].token);
		++i;
	}
	return (XLATOR_KW_NOTFOUND);
}

/*
 * line_to_buf(char *dest, const char *src) {
 *    appends src to dest, dynamically increasing the size of dest.
 *    replaces the trailing '\' continuation character with a space.
 *
 * if src is continuation of dest, dest != NULL, and
 * the last character in dest before the newline must be a `\'
 * if src is not continuation of dest, then dest must be NULL
 */
char *
line_to_buf(char *dest, const char *src)
{
	int slen = strlen(src);
	int dlen;

	if (dest == NULL) {
		/* We're being called for the first time */
		dest = malloc(sizeof (char) * (slen + 1));
		if (dest == NULL) {
			errlog(ERROR | FATAL,
			    "Error: Unable to allocate memory for dest\n");
		}
		(void) strcpy(dest, src);
		return (dest);
	}

	dlen = strlen(dest);

	dest = realloc(dest, (size_t)(sizeof (char) * (dlen+slen+1)));
	if (dest == NULL) {
		errlog(ERROR | FATAL,
		    "Error: Unable to allocate memory for dest\n");
	}

	if (dlen > 1) {
		/*
		 * remove continuation character
		 * we replace the '\' from the previous line with a space
		 */
		if (dest[dlen-2] == '\\') {
			dest[dlen-2] = ' ';
		}
	}

	/* join the two strings */
	(void) strcat(dest, src);

	return (dest);
}

/*
 * non_empty(const char *str)
 * assumes str is non null
 * checks if str is a non empty string
 * returns 1 if string contains non whitespace
 * returns 0 if string contains only whitespace
 */
int
non_empty(const char *str)
{
	while (*str != '\0') {
		if (!isspace(*str))
			return (1);
		++str;
	};
	return (0);
}

/*
 * split(const char *line, char *key, char *value);
 * splits the line into keyword (key) and value pair
 */
void
split(const char *line, char *key, char *value)
{
	char *p;

	p = (char *)line;

	/* skip leading whitespace */
	while (isspace(*p)&& *p != '\0')
		++p;

	/* copy keyword from line into key */
	while (!isspace(*p) && *p != '\0')
		*key++ = *p++;

	*key = '\0';

	/* skip whitespace */
	while (isspace(*p) && *p != '\0')
		p++;

	(void) strcpy(value, p);

}

/*
 * check4extends(char *filename, char *value, int arch, FILE *fp)
 * if no arch keyword is found or there is a MATCHING arch keyword
 *     returns 1 if value is of the form "data|function name extends"
 *          -1 for error
 *          0  no other keyword after the function name
 * else
 *     return 0
 *
 * filename is used only for error reporting
 */
int
check4extends(const char *filename, const char *value, int arch, FILE *fp)
{
	char fun[BUFSIZ];
	char extends[BUFSIZ];
	int n;

	if (arch_match(fp, arch)) {
		split(value, fun, extends);
		n = strlen(extends);
		if (extends[n-1] == '\n')
			extends[n-1] = '\0';
		if (strncasecmp("extends", extends, 7) == 0) {
			return (1);
		} else {
			if (*extends != '\0') {
				errlog(ERROR, "\"%s\", line %d: Error: "
				    "Trailing garbage after function name\n",
				    filename, Curlineno);
				return (-1);
			}
		}
	}
	return (0);
}

/*
 * remcomment (char *buf)
 * replace comments with single whitespace
 */
/* XXX: There is currently no way to escape a comment character */
void
remcomment(char const *buf)
{
	char *p;
	p = strchr(buf, '#');
	if (p) {
		*p = ' ';
		*(p+1) = '\0';
	}
}

/*
 * arch_strtoi()
 *
 * input: string
 * return: XLATOR_I386 if string == ARCH_I386
 *         XLATOR_SPARC if string == ARCH_SPARC
 *         XLATOR_SPARCV9 if string == ARCH_SPARCV9
 *         XLATOR_IA64 if string == ARCH_IA64
 *         XLATOR_AMD64 if string == ARCH_AMD64
 *         XLATOR_ALLARCH if string == ARCH_ALL
 *         0 if outside the known set {i386, sparc, sparcv9, ia64, amd64}.
 */
int
arch_strtoi(const char *arch_str)
{
	if (arch_str != NULL) {
		if (strcmp(arch_str, ARCH_I386) == 0)
			return (XLATOR_I386);
		else if (strcmp(arch_str, ARCH_SPARC) == 0)
			return (XLATOR_SPARC);
		else if (strcmp(arch_str, ARCH_SPARCV9) == 0)
			return (XLATOR_SPARCV9);
		else if (strcmp(arch_str, ARCH_IA64) == 0)
			return (XLATOR_IA64);
		else if (strcmp(arch_str, ARCH_AMD64) == 0)
			return (XLATOR_AMD64);
		else if (strcmp(arch_str, ARCH_ALL) == 0)
			return (XLATOR_ALLARCH);
	} else {
		errlog(ERROR, "\"%s\", line %d: Error: "
		    "arch keyword with no value");
	}
	return (0);
}

int
readline(char **buffer, FILE *fp)
{
	int nlines = 0;
	int len;
	char buf[BUFSIZ];

	if (fgets(buf, BUFSIZ, fp)) {
		nlines++;
		/* replace comments with single whitespace */
		remcomment(buf);

		/* get complete line */
		*buffer = line_to_buf(*buffer, buf); /* append buf to buffer */
		len = strlen(buf);
		if (len > 1) {
			/* handle continuation lines */
			while (buf[len-2] == '\\') {
				if (!fgets(buf, BUFSIZ, fp)) {
					*buffer = line_to_buf(*buffer, buf);
					break;
				}
				nlines++;
				len = strlen(buf);
				*buffer = line_to_buf(*buffer, buf);
			}
		} /* end of 'get complete line' */
	}
	return (nlines);
}