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

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include "xlator.h"
#include "util.h"
#include "bucket.h"
#include "errlog.h"

/* Statics: */
#define TRUE    1
#define FALSE   0
#define NLISTS  50
#define NPAR    25

static bucket_t **Buckethead;
static int N_lists;

static int Bc = -1; /* For iterators. */
static bucket_t *Bp;

static void start_new_list(const bucket_t *);
static void grow_lists(void);
static bucket_t *new_bucket(const char *, int);
static void print_iface(const Interface *);
static void new_hashmap(void);
static int add_to_hashmap(const char *, const bucket_t *);
static bucket_t *find_in_hashmap(const char *);
/*
 * initialization interfaces.
 */

/*
 * create_lists -- initialize the bucket list and hash map.
 */
void
create_lists(void)
{

        errlog(BEGIN, "create_lists() {");
        new_hashmap();
        if ((Buckethead = calloc(sizeof (bucket_t *), NLISTS)) == NULL) {
                errlog(FATAL, "out of memory creating initial "
                        "list of versions");

        }
        N_lists = NLISTS;
        errlog(END, "}");
}


/*
 * data-loading interfaces -- adding buckets to lists and
 *      interfaces to buckets.
 */

/*
 * add_parent -- add a parent node. Returns TRUE or FALSE.
 *
 *      if *version == NULL, then
 *              the bucket version (eg, SUNW_1.1) hasn't
 *              been parsed correctly.  Die.
 *      if *after == NULL, then this is the ``initial case'',
 *              where no predecessor (child) exists.  We start a new
 *              tree of buckets.
 *      if *after != NULL, we have the normal case, and
 *              add to an existing tree.
 *      if *after is not a version name found among the buckets,
 *              then something got misparsed or the versions file is
 *              malformed. Function will print problem and
 *              return 0 so caller can report location of error.
 *      If either version or after is NULL, it's a programmer error.
 */
int
add_parent(const char *version, const char *after, int weak)
{
        bucket_t *new, *child;

        /* Sanity-check parameters. */
        assert(version != NULL, "passed a null version to add_parent");
        assert(after != NULL, "passed a null after to add_parent");
        errlog(BEGIN, "add_parent(%s,%s,%d) {", version, after, weak);
        if ((new = find_in_hashmap(version)) == NULL) {
                /* We don't have one have one yet. */
                new = new_bucket(version, weak);
        }
        new->b_weak = weak;
        if (*after == '\0') {
                /*
                 * This is the ``initial case'', where no
                 * child exists.  We start a new tree of buckets.
                 */
                (void) add_to_hashmap(version, new);
                start_new_list(new);
        } else {
                if ((child = find_in_hashmap(after)) == NULL) {
                        /*
                         * The version in the spec doesn't appear in the
                         * versions file.  One or the other is lying.
                         */
                        errlog(WARNING, "set file: can't find version \"%s\","
                            "therefor can't add it's parent, \"%s\"",
                            after, version);
                        errlog(END, "} /* add_parent */");
                        return (FALSE);
                }
                (void) add_to_hashmap(version, new);
                child->b_parent = new;
        }
        errlog(END, "} /* add_parent */");
        return (TRUE);
}

/*
 * add_uncle -- adds an uncle node
 */
int
add_uncle(const char *version, const char *after, int weak)
{
        bucket_t *new, *child;
        struct bucketlist *uncle;

        /* Sanity-check parameters. */
        assert(version != NULL, "passed a null version to add_uncle");
        assert(after != NULL, "passed a null after to add_uncle");
        errlog(BEGIN, "add_uncle(%s,%s,%d) {", version, after, weak);
        if ((new = find_in_hashmap(version)) == NULL) {
                /* We don't have one have one yet. */
                new = new_bucket(version, weak);
        }
        if (*after == '\0') {
                /*
                 * This is the ``initial case'', where no
                 * child exists.  We start a new tree of buckets.
                 */
                (void) add_to_hashmap(version, new);
                start_new_list(new);
        } else {
                if ((child = find_in_hashmap(after)) == NULL) {
                        /*
                         * The version in the spec doesn't appear in the
                         * versions file.  One or the other is lying.
                         */
                        errlog(WARNING, "set file: can't find version \"%s\","
                            "therefor can't add it's uncle, \"%s\"",
                            after, version);
                        errlog(END, "}");
                        return (FALSE);
                }
                (void) add_to_hashmap(version, new);
                uncle = malloc(sizeof (struct bucketlist));
                uncle->bl_next = child->b_uncles;
                uncle->bl_bucket = new;
                child->b_uncles = uncle;
        }
        errlog(END, "}");
        return (TRUE);
}

/*
 * set_weak -- set a version to be a weak version
 */
void
set_weak(const char *version, int weak)
{
        bucket_t *v;
        if ((v = find_in_hashmap(version)) == NULL) {
                /* We don't have one have one yet. */
                errlog(ERROR|FATAL, "Unable to set weak. Version not found");
        }
        v->b_weak = weak;
}

/*
 * add_by_name -- look up bucket and add an interface to it.
 *      Returns 0 for success or an errno.h value for failure.
 *
 *      if *version is not among the buckets, then the
 *              version in the spec doesn't appear in the
 *              set file.  One or the other is lying. Function will
 *              report the problem and return ENOENT
 *              so the front end can report and exit (or
 *              continue if it wants).
 *      if interface ore version is NULL, then
 *              the begin line code should
 *              have caught it long before, to avoid passing
 *              a null pointer around. Die.
 *
 */
#define ADD_EQUALS(str) if (strchr(str, '=') == NULL) (void) strcat(str, " =")

int
add_by_name(const char *version, const Interface *interface)
{
        bucket_t *b;
        char buffer[1024];

        assert(version != NULL, "passed a null version to add_by_name");
        assert(interface != NULL, "passed a null interface to add_by_name");

        errlog(BEGIN, "add_by_name(%s,", version);
        print_iface(interface);
        errlog(TRACING, ");");

        /* Sanity-check the parameters. */
        if ((b = find_in_hashmap(version)) == NULL) {
                /*
                 * The version in the spec doesn't appear in the
                 * versions file. Alas, this isn't an error.  It can
                 * happen whenever doing just sparc, just i386
                 * or the like.
                 */
                errlog(END, "}");
                return (ENOENT);
        }
        /*
         * Add to bucket.
         */
        (void) snprintf(buffer, sizeof (buffer), "%s", interface->IF_name);

        if (interface->IF_filter && interface->IF_auxiliary) {
                errlog(FATAL, "Error: cannot set both FILTER and AUXILIARY "
                    "for an interface: %s", interface->IF_name);
        }

        if (interface->IF_filter) {
                ADD_EQUALS(buffer);
                if (interface->IF_type == FUNCTION) {
                        (void) strcat(buffer, " FUNCTION");
                } else if (interface->IF_type == DATA) {
                        (void) strcat(buffer, " DATA");
                }
                (void) strcat(buffer, " FILTER ");
                (void) strcat(buffer, interface->IF_filter);
        } else if (interface->IF_auxiliary) {
                ADD_EQUALS(buffer);
                (void) strcat(buffer, " AUXILIARY ");
                (void) strcat(buffer, interface->IF_auxiliary);
        } else if (IsFilterLib) {
                /*
                 * For DATA types it is currently assumed that they are
                 * handled via a minimal C file, e.g. 'data.c', in the
                 * library's build.  Hence, we do not append '= DATA' here.
                 */
                if (interface->IF_type == FUNCTION) {
                        ADD_EQUALS(buffer);
                        (void) strcat(buffer, " FUNCTION");
                }
        }

        switch (interface->IF_binding) {
        case DIRECT:
                ADD_EQUALS(buffer);
                (void) strcat(buffer, " DIRECT");
                break;
        case NODIRECT:
                ADD_EQUALS(buffer);
                (void) strcat(buffer, " NODIRECT");
                break;
        }

        if (interface->IF_binding == PROTECTED) {
                /* Assign in case of realloc. */
                b->b_protected_table =
                    add_to_stringtable(b->b_protected_table, buffer);
                b->b_has_protecteds = 1;
                errlog(VERBOSE, "set has_protecteds on bucket 0x%p", b);
        } else {
                /* Assign in case of realloc. */
                b->b_global_table = add_to_stringtable(b->b_global_table,
                        buffer);
        }
        errlog(END, "}");
        return (0);
}


/*
 * Processing interfaces
 */

/*
 * sort_buckets -- sort the interfaces within the buckets into
 *      alphabetical order.
 */
void
sort_buckets(void)
{
        bucket_t *l, *b;

        errlog(BEGIN, "sort_buckets() {");
        for (l = first_list(); l != NULL; l = next_list()) {
                errlog(VERBOSE, "l-bucket: %s", l->b_name);
                for (b = first_from_list(l); b != NULL; b = next_from_list()) {
                        errlog(VERBOSE, "   b-bkt: %s", b->b_name);
                        sort_stringtable(b->b_global_table);
                        sort_stringtable(b->b_protected_table);
                        if (b->b_uncles) {

                                if (b->b_uncles->bl_bucket) {
                sort_stringtable(b->b_uncles->bl_bucket->b_global_table);
                sort_stringtable(b->b_uncles->bl_bucket->b_protected_table);
                                }
                        }
                }
        }
        errlog(END, "}");
}


/*
 * add_local -- set the local flag on the logically first bucket.
 *     This decision may belong in the caller, as it is about
 *     mapfiles, not inherent ordering or bucket contents...
 */
void
add_local(void)
{
        bucket_t *b, *list;
        int     done = 0;

        errlog(BEGIN, "add_local() {");
        /* Iterate across lists of buckets */
        for (list = first_list(); list != NULL; list = next_list()) {
                /* Traverse the list found. */
                for (b = list; b != NULL; b = b->b_parent) {
                        if (b->b_weak != 1) {
                                /* We've found the first non-weak. */
                                b->b_has_locals = done = 1;
                                errlog(VERBOSE,
                                    "set has_locals on bucket 0x%p", b);
                                break;
                        }
                }
                if (b != NULL && b->b_has_locals == 1)
                        break;
        }
        if (done == 0) {
                errlog(WARNING, "has_locals never set");
        }
        errlog(END, "}");
}


/*
 * Output interfaces, mostly iterators
 */


/*
 * parents_of -- return a list of all parents.
 */
char **
parents_of(const bucket_t *start)
{
        static char *a[NPAR] = {NULL};
        const bucket_t *b = start;
        char **p = &a[0];

        assert(start != NULL, "passed a null start to parents_of");
        errlog(BEGIN, "parents_of() {");
        a[0] = '\0';

        /* Go to parent, print it and all its uncle. */
        if (b->b_parent == NULL) {
                errlog(TRACING, "returning empty string");
                errlog(END, "}");
                return (a);
        }
        b = b->b_parent;
        *p++ = b->b_name;
        *p = '\0';

        assert(p < &a[NPAR], "p fell off the end of a in parents_of");
        errlog(END, "}");
        return (a);
}

/*
 * first, next_from_bucket --iterators for bucket contents. Serially
 *      reusable only.
 */
int Ic = -1;

/*
 * debugging interfaces
 */
void
print_bucket(const bucket_t *b)
{

        errlog(TRACING, "bucket_t at 0x%p {", (void *)b);
        errlog(TRACING, "    char   *b_name = \"%s\";", b->b_name);
        errlog(TRACING, "    struct bucket_t *b_parent = 0x%p;",
                (void *)b->b_parent);
        errlog(TRACING, "    struct bucketlist *b_uncles = 0x%p;",
                (void *)b->b_uncles);
        errlog(TRACING, "    struct bucket_t *b_thread = 0x%p;",
                (void *)b->b_thread);
        errlog(TRACING, "    int        b_has_locals = %d;",
                b->b_has_locals);
        errlog(TRACING, "    int        b_has_protecteds = %d;",
                b->b_has_protecteds);
        errlog(TRACING, "    int        b_was_printed = %d;",
                b->b_was_printed);
        errlog(TRACING, "    int        b_weak = %d;",
                b->b_weak);
        errlog(TRACING, "    table_t  *b_global_table = 0x%p;",
                (void *)b->b_global_table);
        errlog(TRACING, "    table_t  *b_protected_table = 0x%p;",
                (void *)b->b_protected_table);
        errlog(TRACING, "}");
}

void
print_all_buckets(void)
{
        bucket_t *l, *b;
        int i = 0, j = 0;
        char **p;

        for (i = 0, l = first_list(); l != NULL; l = next_list(), ++i) {
                errlog(TRACING, "list %d", i);
                for (j = 0, b = first_from_list(l);
                    b != NULL; b = next_from_list(), ++j) {
                        errlog(TRACING, "bucket %d", j);
                        print_bucket(b);
                        errlog(TRACING, "global interfaces = {");
                        print_stringtable(b->b_global_table);
                        errlog(TRACING, "}");
                        errlog(TRACING, "protected interfaces = {");
                        print_stringtable(b->b_protected_table);
                        errlog(TRACING, "}");

                        for (p = parents_of(b); p != NULL && *p != NULL; ++p) {
                                errlog(TRACING, " %s", *p);
                        }
                        errlog(TRACING, ";");

                        if (b->b_uncles) {
                                errlog(TRACING, " uncle bucket %d.1", j);
                                print_bucket(b->b_uncles->bl_bucket);
                                errlog(TRACING, "global interfaces = {");
                                print_stringtable(
                                    b->b_uncles->bl_bucket->b_global_table);
                                errlog(TRACING, "}");
                                errlog(TRACING, "protected interfaces = {");
                                print_stringtable(
                                    b->b_uncles->bl_bucket->b_protected_table);
                                errlog(TRACING, "}");
                        }
                }
        }
}


/*
 * lower-level functions, not visible outside the file.
 */

/*
 * new_bucket -- create a bucket for a given version. Must not fail.
 */
static bucket_t *
new_bucket(const char *name, int weak)
{
        bucket_t *b;

        if ((b = (bucket_t *)calloc(1, sizeof (bucket_t))) == NULL) {
                errlog(FATAL, "out of memory creating a bucket "
                        "to store interfaces in");
        }
        if ((b->b_name = strdup(name)) == NULL) {
                errlog(FATAL, "out of memory storing an interface "
                        "in a version bucket");
        }
        b->b_uncles = NULL;
        b->b_global_table = create_stringtable(TABLE_INITIAL);
        b->b_protected_table = create_stringtable(TABLE_INITIAL);
        b->b_weak = weak;
        return (b);
}


/*
 * start_new_list -- start a list of buckets.
 */
static void
start_new_list(const bucket_t *b)
{
        int i;

        errlog(BEGIN, "start_new_list() {");
        assert(Buckethead != NULL, "Buckethead null in start_new_list");
        for (i = 0; Buckethead[i] != NULL && i < N_lists; ++i)
                continue;
        if (i >= N_lists) {
                grow_lists();
        }
        Buckethead[i] = (bucket_t *)b;
        errlog(END, "}");
}

/*
 * grow_list -- make more lists.  This should never occur...
 */
static void
grow_lists(void)
{
        int i = N_lists;

        errlog(BEGIN, "grow_lists() {");
        errlog(WARNING, "Warning: more than %d version lists "
            "required (< %d is normal). Check sets file "
            "to see why so many lines appear.",
            N_lists, NLISTS);

        N_lists *= 2;
        if ((Buckethead = realloc(Buckethead, sizeof (bucket_t *) * N_lists))
                == NULL) {
                errlog(FATAL, "out of memory growing list of "
                        "version buckets");
        }
        for (; i < N_lists; ++i) {
                Buckethead[i] = NULL;
        }
}

/*
 * delete_lists -- clean up afterwards.
 */
void
delete_lists(void)
{
        N_lists = 0;
        free(Buckethead);
        Buckethead = 0;
}

/*
 * first_list, next_list -- an iterator for lists themselves.  Serially
 *      reusable only.
 */
bucket_t *
first_list(void)
{
        Bc = 0;
        return (Buckethead[Bc]);
}

bucket_t *
next_list(void)
{
        return (Buckethead[++Bc]);
}


/*
 * first, next, last_from_list -- iterators for individual lists. Serially
 *      reusable only.
 */
bucket_t *
first_from_list(const bucket_t *l)
{
        return (Bp = (bucket_t *)l);
}

bucket_t *
next_from_list(void)
{
        return (Bp = Bp->b_parent);
}



/*
 * Iface print utility
 */
static void
print_iface(const Interface * p)
{

        errlog(TRACING, "%s (%s, %s, %s %d)", p->IF_name,
                (p->IF_type == FUNCTION) ? "function" :
                (p->IF_type == DATA) ? "data" : "unknown type",
                (p->IF_version) ? p->IF_version : "unknown version",
                (p->IF_class) ? p->IF_class : "unknown class",
                p->IF_binding);
}



#define HASHMAPSIZE     100
#define ERR     (-1)

static struct {
        hashmap_t *hh_map;
        int hh_map_size;
        int hh_mapC;
        hashmap_t *hh_last;
} Hashhead = {
        NULL, -1, -1, NULL
};

static int checksum(const char *);
static void print_hashmap(const hashmap_t *);

/*
 * new_hashmap -- create the hash.
 */
static void
new_hashmap(void)
{

        errlog(BEGIN, "new_hashmap() {");
        if ((Hashhead.hh_map = calloc(sizeof (hashmap_t), HASHMAPSIZE))
            == NULL) {
                errlog(FATAL, "out of memory creating a hash-map of "
                        "the versions");
        }
        Hashhead.hh_mapC = 0;
        errlog(END, "}");
}

/*
 * add_to_hashmap -- add a bucket to the map.  This is strictly for
 *      use by add_parent()/add_uncle().
 */
static int
add_to_hashmap(const char *version_name, const bucket_t *bucket)
{
        hashmap_t *p;

        assert(Hashhead.hh_map != NULL,
            "Hashead.map was null in add_to_hashmap");
        assert(Hashhead.hh_mapC < HASHMAPSIZE,
            "mapC too big in add_to_hashmap");
        errlog(BEGIN, "add_to_hashmap(%s, %s) {", version_name, bucket);
        if (find_in_hashmap(version_name) != NULL) {
                /* Seen for the second time. TBD... */
                errlog(END, "} /* add_to_hashmap */");
                return (ERR);
        }
        p = &Hashhead.hh_map[Hashhead.hh_mapC++];
        if ((p->h_version_name = strdup(version_name)) == NULL) {
                errlog(FATAL, "out of memory storing a version name");

        }
        p->h_bucket = (bucket_t *)bucket;
        p->h_hash = checksum(version_name);
        Hashhead.hh_last = p;
        print_hashmap(p);
        errlog(END, "} /* add_to_hashmap */");
        return (0);
}


/*
 * find_in_hashmap -- find a bucket by name.  Strictly for use by addByName().
 */
static bucket_t *
find_in_hashmap(const char *version_name)
{
        hashmap_t *current;
        int hash = checksum(version_name);

        assert(Hashhead.hh_map != NULL,
                "Hashhead.hh_map was null in find_in_hashmap");
        errlog(BEGIN, "find_in_hashmap(%s) {", version_name);
        if (Hashhead.hh_last != NULL && Hashhead.hh_last->h_hash == hash &&
            strcmp(Hashhead.hh_last->h_version_name, version_name) == 0) {
                errlog(END, "}");
                return (Hashhead.hh_last->h_bucket);
        }
        for (current = Hashhead.hh_map;
                current->h_version_name != NULL; ++current) {
                if (current->h_hash == hash &&
                        strcmp(current->h_version_name, version_name) == 0) {
                        /* Found it */
                        Hashhead.hh_last = current;
                        errlog(END, "}");
                        return (current->h_bucket);
                }
        }
        /* Doesn't exist, meaning version name is bogus. */
        errlog(END, "}");
        return (NULL);
}

/*
 * checksum -- from sum(1), algorithm 1.
 */
static int
checksum(const char *p)
{
        int sum;

        for (sum = 0; *p != '\0'; ++p) {
                if (sum & 01)
                        sum = (sum >> 1) + 0x8000;
                else
                        sum >>= 1;
                sum += *p;
                sum &= 0xFFFF;
        }
        return (sum);
}

static void
print_hashmap(const hashmap_t *h)
{
        errlog(VERBOSE, "struct hashmap_t at 0x4.4x {", h);
        errlog(VERBOSE, "    int    h_hash = %d;", h->h_hash);
        errlog(VERBOSE, "    char   *h_version_name = \"%s\";",
                h->h_version_name);
        errlog(VERBOSE, "    bucket_t *h_bucket = 0x%p;;",
                (void *) h->h_bucket);
        errlog(VERBOSE, "}");
}