/*

  Copyright (C) 2006 Silicon Graphics, Inc.  All Rights Reserved.

  This program is free software; you can redistribute it and/or modify it

  under the terms of version 2 of the GNU General Public License as

  published by the Free Software Foundation.

  This program is distributed in the hope that it would be useful, but

  WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

  Further, this software is distributed without any warranty that it is

  free of the rightful claim of any third person regarding infringement

  or the like.  Any license provided herein, whether implied or

  otherwise, applies only to this software file.  Patent licenses, if

  any, provided herein do not apply to combinations of this program with

  other software, or any other product whatsoever.

  You should have received a copy of the GNU General Public License along

  with this program; if not, write the Free Software Foundation, Inc., 51

  Franklin Street - Fifth Floor, Boston MA 02110-1301, USA.

  Contact information:  Silicon Graphics, Inc., 1500 Crittenden Lane,

  Mountain View, CA 94043, or:

  http://www.sgi.com

  For further information regarding this notice, see:

  http://oss.sgi.com/projects/GenInfo/NoticeExplan

$Header: /plroot/cmplrs.src/v7.4.5m/.RCS/PL/dwarfdump/RCS/dwconf.c,v 1.4 2006/04/18 18:05:57 davea Exp $ */

#include "globals.h"

#include <ctype.h>

#include "dwconf.h"

#include "makename.h"

struct token_s {

    unsigned tk_len;

    char *tk_data;

};

enum linetype_e {

    LT_ERROR,

    LT_COMMENT,

    LT_BLANK,

    LT_BEGINABI,

    LT_REG,

    LT_FRAME_INTERFACE,

    LT_CFA_REG,

    LT_INITIAL_REG_VALUE,

    LT_REG_TABLE_SIZE,

    LT_ENDABI

};

struct comtable_s {

    enum linetype_e type;

    char *name;

    size_t namelen;

};

static int errcount = 0;	/* Count errors found in this scan of

				   the configuration file. */

static char name_begin_abi[] = "beginabi:";

static char name_reg[] = "reg:";

static char name_frame_interface[] = "frame_interface:";

static char name_cfa_reg[] = "cfa_reg:";

static char name_initial_reg_value[] = "initial_reg_value:";

static char name_reg_table_size[] = "reg_table_size:";

static char name_endabi[] = "endabi:";

static struct comtable_s comtable[] = {

    {LT_BEGINABI, name_begin_abi},

    {LT_REG, name_reg},

    {LT_FRAME_INTERFACE, name_frame_interface},

    {LT_CFA_REG, name_cfa_reg},

    {LT_INITIAL_REG_VALUE, name_initial_reg_value},

    {LT_REG_TABLE_SIZE, name_reg_table_size},

    {LT_ENDABI, name_endabi},

};

static int size_of_comtable = sizeof(comtable) / sizeof(comtable[0]);

static FILE *find_a_file(char *named_file, char **defaults,

			 string * name_used);

static int find_abi_start(FILE * stream, char *abi_name, long *offset,

			  unsigned long *lineno_out);

static int parse_abi(FILE * stream, char *fname, char *abiname,

		     struct dwconf_s *out, unsigned long lineno);

static char *get_token(char *cp, struct token_s *outtok);

/*  This finds a dwarfdump.conf file and

    then parses it.  It updates

    conf_out as appropriate.

    This finds the first file (looking in a set of places)

    with that name.  It then looks for the right  ABI entry.

    If the first file it finds does not have that ABI entry it

    gives up.

    It would also be reasonable to search every 'dwarfdump.conf'

    it finds for the abi. But we stop at the first dwarfdump.conf

    we find.

*/

int

find_conf_file_and_read_config(char *named_file,

			       char *named_abi, char **defaults,

			       struct dwconf_s *conf_out)

{

    FILE *conf_stream = 0;

    char *name_used = 0;

    long offset = 0;

    int res = FALSE;

    unsigned long lineno = 0;

    errcount = 0;

    conf_stream = find_a_file(named_file, defaults, &name_used);

    if (!conf_stream) {

	++errcount;

	printf("dwarfdump found no file %s!\n",

	       named_file ? named_file : "readable for configuration. "

	       "(add options -v -v to see what file names tried)\n");

	return errcount;

    }

    if (verbose > 1) {

	printf("dwarfdump using configuration file %s\n", name_used);

    }

    res = find_abi_start(conf_stream, named_abi, &offset, &lineno);

    if (errcount > 0) {

	++errcount;

	printf("dwarfdump found no ABI %s in file %s.\n",

	       named_abi, name_used);

	return errcount;

    }

    res = fseek(conf_stream, offset, SEEK_SET);

    if (res != 0) {

	++errcount;

	printf("dwarfdump seek to %ld offset in %s failed!\n",

	       offset, name_used);

	return errcount;

    }

    parse_abi(conf_stream, name_used, named_abi, conf_out, lineno);

    fclose(conf_stream);

    return errcount;

}

/* Given path strings, attempt to make a canonical file name:

   that is, avoid superfluous '/' so that no

    '//' (or worse) is created in the output. The path components

    are to be separated so at least one '/'

    is to appear between the two 'input strings' when

    creating the output.

*/

static char *

canonical_append(char *target, unsigned int target_size,

		 char *first_string, char *second_string)

{

    size_t firstlen = strlen(first_string);

    /* +1 +1: Leave room for added "/" and final NUL, though that is

       overkill, as we drop a NUL byte too. */

    if ((firstlen + strlen(second_string) + 1 + 1) >= target_size) {

	/* Not enough space. */

	return NULL;

    }

    for (; *second_string == '/'; ++second_string) {

    }

    for (; firstlen > 0 && first_string[firstlen - 1] == '/';

	 --firstlen) {

    }

    target[0] = 0;

    if (firstlen > 0) {

	strncpy(target, first_string, firstlen);

	target[firstlen + 1] = 0;

    }

    target[firstlen] = '/';

    firstlen++;

    target[firstlen] = 0;

    strcat(target, second_string);

    return target;

}

#ifdef BUILD_FOR_TEST

#define CANBUF 25

struct canap_s {

    char *res_exp;

    char *first;

    char *second;

} canap[] = {

    {

    "ab/c", "ab", "c"}, {

    "ab/c", "ab/", "c"}, {

    "ab/c", "ab", "/c"}, {

    "ab/c", "ab////", "/////c"}, {

    "ab/", "ab", ""}, {

    "ab/", "ab////", ""}, {

    "ab/", "ab////", ""}, {

    "/a", "", "a"}, {

    0, "/abcdefgbijkl", "pqrstuvwxyzabcd"}, {

    0, 0, 0}

};

static void

test_canonical_append(void)

{

    /* Make buf big, this is test code, so be safe. */

    char lbuf[1000];

    unsigned i;

    unsigned failcount = 0;

    printf("Entry test_canonical_append\n");

    for (i = 0;; ++i) {

	char *res = 0;

	if (canap[i].first == 0 && canap[i].second == 0)

	    break;

	res = canonical_append(lbuf, CANBUF, canap[i].first,

			       canap[i].second);

	if (res == 0) {

	    if (canap[i].res_exp == 0) {

		/* GOOD */

		printf("PASS %u\n", i);

	    } else {

		++failcount;

		printf("FAIL: entry %u wrong, expected %s, got NULL\n",

		       i, canap[i].res_exp);

	    }

	} else {

	    if (canap[i].res_exp == 0) {

		++failcount;

		printf("FAIL: entry %u wrong, got %s expected NULL\n",

		       i, res);

	    } else {

		if (strcmp(res, canap[i].res_exp) == 0) {

		    printf("PASS %u\n", i);

		    /* GOOD */

		} else {

		    ++failcount;

		    printf("FAIL: entry %u wrong, expected %s got %s\n",

			   i, canap[i].res_exp, res);

		}

	    }

	}

    }

    printf("FAIL count %u\n", failcount);

}

#endif /* BUILD_FOR_TEST */

/* Try to find a file as named and open for read.

   We treat each name as a full name, we are not

   combining separate name and path components.

   This is  an arbitrary choice...

    The defaults are listed in dwarfdump.c in the array 

    config_file_defaults[].

*/

static FILE *

find_a_file(char *named_file, char **defaults, string * name_used)

{

    FILE *fin = 0;

    char *lname = named_file;

    const char *type = "rw";

    int i = 0;

#ifdef BUILD_FOR_TEST

    test_canonical_append();

#endif /* BUILD_FOR_TEST */

    if (lname) {

	/* Name given, just assume it is fully correct, try no other. */

	if (verbose > 1) {

	    printf("dwarfdump looking for configuration as %s\n",

		   lname);

	}

	fin = fopen(lname, type);

	if (fin) {

	    *name_used = lname;

	    return fin;

	}

	return 0;

    }

    /* No name given, find a default, if we can. */

    for (i = 0; defaults[i]; ++i) {

	lname = defaults[i];

	if (strncmp(lname, "HOME/", 5) == 0) {

	    /* arbitrary size */

	    char buf[2000];

	    char *homedir = getenv("HOME");

	    if (homedir) {

		char *cp = canonical_append(buf, sizeof(buf),

					    homedir, lname + 5);

		if (!cp) {

		    /* OOps, ignore this one. */

		    continue;

		}

		lname = makename(buf);

	    }

	}

	if (verbose > 1) {

	    printf("dwarfdump looking for configuration as %s\n",

		   lname);

	}

	fin = fopen(lname, type);

	if (fin) {

	    *name_used = lname;

	    return fin;

	}

    }

    return 0;

}

/* Start at a token begin, see how long it is,

   return length. */

unsigned

find_token_len(char *cp)

{

    unsigned len = 0;

    for (; *cp; ++cp) {

	if (isspace(*cp)) {

	    return len;

	}

	if (*cp == '#') {

	    return len;		/* begins comment */

	}

	++len;

    }

    return len;

}

/*

   Skip past all whitespace: the only code that even knows

   what whitespace is.

*/

static char *

skipwhite(char *cp)

{

    for (; *cp; ++cp) {

	if (!isspace(*cp)) {

	    return cp;

	}

    }

    return cp;

}

/* Return TRUE if ok. FALSE if find more tokens.

   Emit error message if error.

*/

static int

ensure_has_no_more_tokens(char *cp, char *fname, unsigned long lineno)

{

    struct token_s tok;

    cp = get_token(cp, &tok);

    if (tok.tk_len > 0) {

	printf("dwarfdump.conf error: "

	       "extra characters after command operands, found "

	       "\"%s\" in %s line %lu\n", tok.tk_data, fname, lineno);

	++errcount;

	return FALSE;

    }

    return TRUE;

}

/*

	There may be many  beginabi: lines in a dwarfdump.conf file,

	find the one we want and return it's file offset.

*/

static int

find_abi_start(FILE * stream,

	       char *abi_name, long *offset, unsigned long *lineno_out)

{

    char buf[100];

    unsigned long lineno = 0;

    for (; !feof(stream);) {

	struct token_s tok;

	char *line = 0;

	long loffset = ftell(stream);

	line = fgets(buf, sizeof(buf), stream);

	++lineno;

	if (!line) {

	    ++errcount;

	    return FALSE;

	}

	line = get_token(buf, &tok);

	if (strcmp(tok.tk_data, name_begin_abi) != 0) {

	    continue;

	}

	get_token(line, &tok);

	if (strcmp(tok.tk_data, abi_name) != 0) {

	    continue;

	}

	*offset = loffset;

	*lineno_out = lineno;

	return TRUE;

    }

    ++errcount;

    return FALSE;

}

static char *tempstr = 0;

static unsigned tempstr_len = 0;

/*

	Use a global buffer (tempstr) to turn a non-delimited

	input char array into a NUL-terminated C string

        (with the help of makename() to get a permanent

        address for the result ing string).

*/

static char *

build_string(unsigned tlen, char *cp)

{

    if (tlen >= tempstr_len) {

	free(tempstr);

	tempstr = malloc(tlen + 100);

    }

    strncpy(tempstr, cp, tlen);

    tempstr[tlen] = 0;

    return makename(tempstr);

}

/*

	The tokenizer for our simple parser.

*/

static char *

get_token(char *cp, struct token_s *outtok)

{

    char *lcp = skipwhite(cp);

    unsigned tlen = find_token_len(lcp);

    outtok->tk_len = tlen;

    if (tlen > 0) {

	outtok->tk_data = build_string(tlen, lcp);

    } else {

	outtok->tk_data = "";

    }

    return lcp + tlen;

}

/*

	We can't get all the field set up statically very easily,

        so we get the command string length set here.

*/

static void

finish_comtable_setup(void)

{

    unsigned i;

    for (i = 0; i < size_of_comtable; ++i) {

	comtable[i].namelen = strlen(comtable[i].name);

    }

}

/*

    Given  a line of the table, determine if it is a command

    or not, and if a command, which one is it.

    Return LT_ERROR if it's not recognized.

*/

static enum linetype_e

which_command(char *cp, struct comtable_s **tableentry)

{

    int i;

    struct token_s tok;

    if (*cp == '#')

	return LT_COMMENT;

    if (!*cp)

	return LT_BLANK;

    get_token(cp, &tok);

    for (i = 0; i < size_of_comtable; ++i) {

	if (tok.tk_len == comtable[i].namelen &&

	    strcmp(comtable[i].name, tok.tk_data) == 0) {

	    *tableentry = &comtable[i];

	    return comtable[i].type;

	}

    }

    return LT_ERROR;

}

/* We are promised it's an abiname: command

   find the name on the line.

*/

static int

parsebeginabi(char *cp, char *fname, char *abiname,

	      unsigned long lineno, struct comtable_s *comtab)

{

    size_t clen = comtab->namelen;

    size_t abinamelen = strlen(abiname);

    struct token_s tok;

    cp = cp + clen + 1;

    cp = skipwhite(cp);

    get_token(cp, &tok);

    if (tok.tk_len != abinamelen ||

	strncmp(cp, abiname, abinamelen) != 0) {

	printf("dwarfdump internal error: "

	       "mismatch %s with %s   %s line %lu\n",

	       cp, tok.tk_data, fname, lineno);

	++errcount;

	return FALSE;

    }