spectrans/spec2trace/symtab.c

	symtab.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
 * 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) 1997-1999 by Sun Microsystems, Inc.
 * All rights reserved.
 */

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

#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <malloc.h>
#include "parser.h"
#include "trace.h"
#include "util.h"
#include "symtab.h"
#include "errlog.h"

/* Types */
enum kind_t { PRIMITIVE = 0, COMPOSITE, VARARG };

struct entry_t {
    char    *e_name;
    int e_valid;
    int e_line;
    char    *e_file;
    int e_kind;     /* PRIMITIVE, COMPOSITE... */
    char    *e_type;    /* where kind == PRIMITIVE */
    /* base type, ie. char if e_type is char */
    char    *e_basetype;
    int e_levels;   /* levels of indirection */
    char    *e_attribute;   /* kind == COMPOSITE or VARARG. */
    char    *e_assertion;   /* reserved for kind == VARARG. */
    char    *e_comment; /* reserved for per-element comments. */
    int e_pre_uses;
    int e_post_uses;
};

typedef struct entry_head_t {
    int used;
    int n_entries;
    ENTRY   entry[1]; /* Actually entry[n_entries]. */
} EHEAD;

static struct symtab_t {
    ENTRY   *Function;
    EHEAD   *Args;
    EHEAD   *Varargs;
    EHEAD   *Globals;
    ENTRY   *Errval;

    /* Includes */
    table_t *Includes;

    /* Bindings */
    ENTRY   *Exception;

    /* Types */
    table_t *Print_Types;

    /* Error-message information. */
    int Line;
    char    Filename[MAXLINE];

    /* Trace additions */
    char    Prototype[MAXLINE];
    char    Formals[MAXLINE];
    char    Actuals[MAXLINE];
    char    Cast[MAXLINE];
    int Nonreturn;
    int Skip;

    /* Adl additions */
    /* various assertions, one hopes */
} Symtab;

/* File Globals. */
static EHEAD *create_entry_table(int);
static EHEAD *add_entry_table(EHEAD *,
    char *, int, char *, int, char *, char *, int, char *, int, int);
static ENTRY *get_entry_table(EHEAD *, int);
static EHEAD *free_entry_table(EHEAD *);
static void clear_entries(EHEAD *, int, int);
static ENTRY *allocate_entry(ENTRY *, char *, int, char *, int,
    char *, char *, int, char *, int, int);
static ENTRY *set_entry(ENTRY *,
    char *, int, char *, int, char *, char *, int, char *, int, int);
static ENTRY *free_entry(ENTRY *);
static void symtab_clear_varargs(void);
static void symtab_clear_globals(void);
static void symtab_clear_print_types(void);
static void symtab_set_nonreturn(int);
static table_t *symtab_free_print_types(table_t *);

/*
 * symtab_new_function -- clear counts, variables for a new function.
 */
void
symtab_new_function(const int line, const char *file)
{
    errlog(BEGIN, "symtab_new_function() {");
    Symtab.Line = line; /* Set, don't clear. */
    symtab_set_filename(file);

    symtab_clear_function();
    symtab_clear_varargs();
    symtab_clear_globals();
    symtab_clear_errval();
    symtab_clear_exception();
    symtab_clear_print_types();

    symtab_set_nonreturn(NO);
    symtab_set_skip(NO);
    errlog(END, "}");
}


/*
 * symtab_clear_function -- clear function-prototype-derived
 *  values. Called on each prototype line and at beginning
 *  of interface.
 */
void
symtab_clear_function(void)
{

    errlog(BEGIN, "symtab_clear_function() {");
    Symtab.Function = free_entry(Symtab.Function);
    Symtab.Args = free_entry_table(Symtab.Args);
    Symtab.Prototype[0] = NULL;
    Symtab.Formals[0] = NULL;
    Symtab.Actuals[0] = NULL;
    Symtab.Cast[0] = NULL;
    errlog(END, "}");
}


/*
 * symtab_clear_varargs -- called only at end
 */
static void
symtab_clear_varargs(void)
{

    errlog(BEGIN, "symtab_clear_varargs() {");
    Symtab.Varargs = free_entry_table(Symtab.Varargs);
    errlog(END, "}");
}

/*
 * symtab_clear_includes -- clear only at end of file (union++)
 */
void
symtab_clear_includes(void)
{

    errlog(BEGIN, "symtab_clear_includes() {");
    Symtab.Includes = free_string_table(Symtab.Includes);
    errlog(END, "}");
}

static void
symtab_clear_globals(void)
{

    errlog(BEGIN, "symtab_clear_globals() {");
    Symtab.Globals = free_entry_table(Symtab.Globals);
    errlog(END, "}");
}

void
symtab_clear_errval(void)
{

    errlog(BEGIN, "symtab_clear_errval() {");
    Symtab.Errval = free_entry(Symtab.Errval);
    errlog(END, "}");
}

void
symtab_clear_exception(void)
{

    errlog(BEGIN, "symtab_clear_exception() {");
    Symtab.Exception = free_entry(Symtab.Exception);
    errlog(END, "}");
}

static void
symtab_clear_print_types(void)
{

    errlog(BEGIN, "symtab_clear_print_types() {");
    Symtab.Print_Types = symtab_free_print_types(Symtab.Print_Types);
    errlog(END, "}");
}


/* Generated by m4 -- character string values */

void
symtab_set_prototype(char *p)
{

    errlog(BEGIN, "symtab_set_prototype(void) {");
    (void) strncpy(Symtab.Prototype, p, sizeof (Symtab.Prototype));
    Symtab.Prototype[sizeof (Symtab.Prototype)-1] = NULL;
    errlog(END, "}");
}

char *
symtab_get_prototype(void)
{
    errlog(BEGIN, "symtab_get_prototype() {"); errlog(END, "}");
    return (Symtab.Prototype);
}

void
symtab_set_formals(char *p)
{
    errlog(BEGIN, "symtab_set_formals() {");
    errlog(VERBOSE, "p = %s", p);
    (void) strncpy(Symtab.Formals, p, sizeof (Symtab.Formals));
    Symtab.Formals[sizeof (Symtab.Formals)-1] = NULL;
    errlog(END, "}");
}

char *
symtab_get_formals(void)
{
    errlog(BEGIN, "symtab_get_formals() {"); errlog(END, "}");
    return (Symtab.Formals);
}

void
symtab_set_actuals(char *p)
{
    errlog(BEGIN, "symtab_set_actuals() {"); errlog(END, "}");
    errlog(VERBOSE, "p = %s", p);
    (void) strncpy(Symtab.Actuals, p, sizeof (Symtab.Actuals));
    Symtab.Actuals[sizeof (Symtab.Actuals)-1] = NULL;
}

char *
symtab_get_actuals(void)
{
    errlog(BEGIN, "symtab_get_actuals() {"); errlog(END, "}");
    return (Symtab.Actuals);
}

void
symtab_set_cast(char *p)
{
    errlog(BEGIN, "symtab_set_cast() {"); errlog(END, "}");
    (void) strncpy(Symtab.Cast, p, sizeof (Symtab.Cast));
    Symtab.Cast[sizeof (Symtab.Cast)-1] = NULL;
}

char *
symtab_get_cast(void)
{
    errlog(BEGIN, "symtab_get_cast() {"); errlog(END, "}");
    return (Symtab.Cast);
}


void
symtab_set_filename(const char *p)
{
    errlog(BEGIN, "symtab_set_filename() {"); errlog(END, "}");
    (void) strncpy(Symtab.Filename, p, sizeof (Symtab.Filename));
    Symtab.Filename[sizeof (Symtab.Filename)-1] = NULL;
}

char *
symtab_get_filename(void)
{
    errlog(BEGIN, "symtab_get_filename() {"); errlog(END, "}");
    return (Symtab.Filename);
}


/* Generated by m4 -- int values */

static void
symtab_set_nonreturn(int val)
{
    errlog(BEGIN, "symtab_set_nonreturn() {"); errlog(END, "}");
    Symtab.Nonreturn = val;
}

int
symtab_get_nonreturn(void)
{
    errlog(BEGIN, "symtab_get_nonreturn() {"); errlog(END, "}");
    return (Symtab.Nonreturn);
}

void
symtab_set_line(int val)
{
    errlog(BEGIN, "symtab_set_line() {"); errlog(END, "}");
    Symtab.Line = val;
}

int
symtab_get_line(void)
{
    errlog(BEGIN, "symtab_get_line() {"); errlog(END, "}");
    return (Symtab.Line);
}


void
symtab_set_skip(int value)
{
    errlog(BEGIN, "symtab_set_skip() {"); errlog(END, "}");
    Symtab.Skip = value;
}

int
symtab_get_skip(void)
{
    errlog(BEGIN, "symtab_get_skip() {"); errlog(END, "}");
    return (Symtab.Skip);
}

/*
 * Manually written access functions for ENTRY * variables.
 */

void
symtab_set_function(char *name, int line, char *file,
    char *type, char *basetype, int levels)
{

    errlog(BEGIN, "symtab_set_function() {");
    Symtab.Function = allocate_entry(Symtab.Function,
        name, line, file, PRIMITIVE, type, basetype, levels, "", -1, -1);
    errlog(END, "}");
}

ENTRY *
symtab_get_function(void)
{
    errlog(BEGIN, "symtab_get_function() {"); errlog(END, "}");
    if (Symtab.Function == NULL)
        return (NULL);
    else
        return ((Symtab.Function->e_valid)? Symtab.Function: NULL);
}

void
symtab_set_exception(char *value, int line, char *file)
{

    errlog(BEGIN, "symtab_set_exception() {");
    Symtab.Exception = allocate_entry(Symtab.Exception,
        value, line, file, COMPOSITE, "", "", 0, "", -1, -1);
    errlog(END, "}");
}

ENTRY *
symtab_get_exception(void)
{

    errlog(BEGIN, "symtab_get_exception() {"); errlog(END, "}");
    if (Symtab.Exception == NULL)
        return (NULL);
    else
        return ((Symtab.Exception->e_valid)? Symtab.Exception: NULL);
}

void
symtab_set_errval(char *name, int line, char *file, char *type, char *basetype,
    int levels)
{

    errlog(BEGIN, "symtab_set_errval() {");
    Symtab.Errval = allocate_entry(Symtab.Errval,
        name, line, file, PRIMITIVE, type, basetype, levels,
        "", -1, -1);
    errlog(END, "}");
}

ENTRY *
symtab_get_errval(void)
{

    errlog(BEGIN, "symtab_get_errval() {"); errlog(END, "}");
    if (Symtab.Errval == NULL)
        return (NULL);
    else
        return ((Symtab.Errval->e_valid)? Symtab.Errval: NULL);
}

/*
 * Manually written  access function for tables of ENTRYs
 */
void
symtab_add_args(char *name, int line, char *file,
    char *type, char *basetype, int levels)
{

    errlog(BEGIN, "symtab_add_args() {");
    if (Symtab.Args == NULL) {
        Symtab.Args = create_entry_table(10);
    }
    Symtab.Args = add_entry_table(Symtab.Args,
        name, line, file, PRIMITIVE, type, basetype, levels, "", -1, -1);
    errlog(END, "}");
}

static int curr_arg;

ENTRY *
symtab_get_first_arg(void)
{

    errlog(BEGIN, "symtab_get_first_arg() {"); errlog(END, "}");
    curr_arg = 1;
    return (get_entry_table(Symtab.Args, 0));
}

ENTRY *
symtab_get_next_arg(void)
{

    errlog(BEGIN, "symtab_get_next_arg() {"); errlog(END, "}");
    return (get_entry_table(Symtab.Args, curr_arg++));
}

ENTRY *
symtab_get_last_arg(void)
{

    errlog(BEGIN, "symtab_get_last_arg() {"); errlog(END, "}");
    return (get_entry_table(Symtab.Args, Symtab.Args->used));
}

void
symtab_add_varargs(char *name, int line, char *file, char *type, char *print)
{

    errlog(BEGIN, "symtab_add_varargs() {");
    if (Symtab.Varargs == NULL) {
        Symtab.Varargs = create_entry_table(10);
    }
    Symtab.Varargs = add_entry_table(Symtab.Varargs,
        name, line, file, PRIMITIVE, type, print, 0, "", -1, -1);
    errlog(END, "}");
}

static int curr_vararg;

ENTRY *
symtab_get_first_vararg(void)
{

    errlog(BEGIN, "symtab_get_first_vararg() {"); errlog(END, "}");
    curr_vararg = 1;
    return (get_entry_table(Symtab.Varargs, 0));
}

ENTRY *
symtab_get_next_vararg(void)
{

    errlog(BEGIN, "symtab_get_next_vararg() {"); errlog(END, "}");
    return (get_entry_table(Symtab.Varargs, curr_vararg++));
}

void
symtab_add_globals(char *name, int line, char *file, char *type,
    char *basetype, int levels)
{

    errlog(BEGIN, "symtab_add_globals() {");
    if (Symtab.Globals == NULL) {
        Symtab.Globals = create_entry_table(10);
    }
    Symtab.Globals = add_entry_table(Symtab.Globals,
        name, line, file, PRIMITIVE, type, basetype, levels, "", -1, -1);
    errlog(END, "}");
}


static int curr_global;

ENTRY *
symtab_get_first_global(void)
{

    errlog(BEGIN, "symtab_get_first_global() {"); errlog(END, "}");
    curr_global = 1;
    return (get_entry_table(Symtab.Globals, 0));
}

ENTRY *
symtab_get_next_global(void)
{

    errlog(BEGIN, "symtab_get_next_global() {"); errlog(END, "}");
    return (get_entry_table(Symtab.Globals, curr_global++));
}

/*
 * manually written functions for accessing tables of strings
 */

/*
 * symtab_add_print_types -- add only non-void print types (due to
 *  parser errors in collect.c, yuck). Also note trick compare...
 *  TBD : common code in db, symtab needs to be
 *  pulled out, as they're getting out of sync.
 */
void
symtab_add_print_types(char *print_type, char *c_type)
{
    char    buffer[MAXLINE];

    errlog(BEGIN, "symtab_add_print_types() {");
#ifdef notdef
    if (strcmp(print_type, "void") == 0 || *print_type == NULL) {
        errlog(END, "}");
        return;
    }
#endif
    (void) snprintf(buffer, sizeof (buffer), "%s, %s", print_type, c_type);
    if (Symtab.Print_Types == NULL) {
    Symtab.Print_Types = create_string_table(50);
    }
    if (in_string_table(Symtab.Print_Types, print_type) == NO) {
        Symtab.Print_Types = add_string_table(Symtab.Print_Types,
                    &buffer[0]);
    }
    errlog(END, "}");
}

static table_t *
symtab_free_print_types(table_t *t)
{
    errlog(BEGIN, "symtab_free_print_types() {"); errlog(END, "}");
    return (free_string_table(t));
}


static int curr_print_type;

char *
symtab_get_first_print_type(void)
{

    errlog(BEGIN, "symtab_get_first_print_type() {"); errlog(END, "}");
    curr_print_type = 1;
    return (get_string_table(Symtab.Print_Types, 0));
}

char *
symtab_get_next_print_type(void)
{

    errlog(BEGIN, "symtab_get_next_print_type() {"); errlog(END, "}");
    return (get_string_table(Symtab.Print_Types, curr_print_type++));
}

void
symtab_add_includes(char *value)
{

    errlog(BEGIN, "symtab_add_includes() {");
    if (Symtab.Includes == NULL) {
        Symtab.Includes = create_string_table(50);
    }
    if (in_string_table(Symtab.Includes, value) == NO) {
        Symtab.Includes = add_string_table(Symtab.Includes, value);
    }
    errlog(END, "}");
}

static int curr_include;

char *
symtab_get_first_include(void)
{

    errlog(BEGIN, "symtab_get_first_include() {"); errlog(END, "}");
    curr_include = 1;
    return (get_string_table(Symtab.Includes, 0));
}

char *
symtab_get_next_include(void)
{

    errlog(BEGIN, "symtab_get_next_include() {"); errlog(END, "}");
    return (get_string_table(Symtab.Includes, curr_include++));
}


void
symtab_sort_includes(void)
{
    errlog(BEGIN, "symtab_sort_includes() {");
    sort_string_table(Symtab.Includes);
    errlog(END, "}");
}

/*
 * ENTRYs  -- access functions to contents of an entry.
 */

char *
name_of(ENTRY *e)
{
    return (e->e_name);
}

int
validity_of(ENTRY *e)
{

    if (e == NULL)
        return (NO);
    else
        return (e->e_valid);
}

int
line_of(ENTRY *e)
{
    return (e->e_line);
}


char *
file_of(ENTRY *e)
{
    return (e->e_file);
}

/*
 * x_type_of -- return (type with an extension: an embedded %s where
 *  the name goes.
 */
char *
x_type_of(ENTRY *e)
{
    if (e != NULL && (e->e_kind == PRIMITIVE || e->e_kind == VARARG))
        return (e->e_type);
    else
        return (NULL);
}


/*
 * type_of -- return (just the type, with the %s removed. This is the common
 *  case, and its also the slowest... TBD.
 */
char *
type_of(ENTRY *e)
{
    static char buffer[MAXLINE];
    char    *p, *q;

    if (e != NULL && (e->e_kind == PRIMITIVE || e->e_kind == VARARG)) {
        p = e->e_type;
        q = &buffer[0];
        while (*p != NULL) {
            if (*p == '%') {
                p += 2;
            } else {
                *q++ = *p++;
            }
        }
        *q = NULL;
        return (strtrim(&buffer[0]));
    }
    else
        return (NULL);
}

char *
basetype_of(ENTRY *e)
{
    if (e != NULL && (e->e_kind == PRIMITIVE || e->e_kind == VARARG))
        return (e->e_basetype);
    else
        return (NULL);
}

int
levels_of(ENTRY *e)
{
    if (e != NULL && (e->e_kind == PRIMITIVE || e->e_kind == VARARG))
        return (e->e_levels);
    else
        return (NULL);
}

char *
inverse_of(ENTRY *e)
{

    if (e != NULL && e->e_kind == COMPOSITE)
        return (e->e_attribute);
    else
        return (NULL);
}

char *
selector_of(ENTRY *e)
{

    if (e != NULL && e->e_kind == VARARG)
        return (e->e_attribute);
    else
        return (NULL);
}

int
preuses_of(ENTRY *e)
{

    if (e)
        return (e->e_pre_uses);
    else
        return (-1);
}

int
postuses_of(ENTRY *e)
{

    if (e)
        return (e->e_post_uses);
    else
        return (-1);
}


/*
 * allocate_entry -- make a parameter list into a complete
 *  ENTRY struct, allocated dynamically.
 */
    /* ARGSUSED -- lint bug */
static ENTRY *
allocate_entry(ENTRY *e,
    char *name, int line, char *file,
    int kind, char *type, char *basetype, int levels, char *attribute,
    int npre, int npost)
{

    errlog(BEGIN, "allocate_entry() {");
    if (e == NULL) {
        if ((e = (ENTRY *)calloc(1, sizeof (ENTRY))) == NULL) {
            errlog(FATAL, "can't allocate space for an ENTRY");
        }
    }
    errlog(END, "}");
    return (set_entry(e, name, line, file, kind, type, basetype, levels,
            attribute, npre, npost));
}

/*
 * set_entry -- set a passed-in entry, using
 *  passed parameters, to values suitable for a
 *  symtab entry
 */
static ENTRY *
set_entry(ENTRY *e,
    char *name, int line, char *file,
    int kind, char *type, char *basetype, int levels, char *attribute,
    int npre, int npost)
{

    errlog(BEGIN, "set_entry() {");
    if (e == NULL) {
        errlog(FATAL, "programmer error: passed a NULL ENTRY");
    }
    e->e_name = strset(e->e_name, name);
    e->e_valid = YES;
    e->e_line = line,
    e->e_file = strset(e->e_file, file);
    e->e_kind = kind;
    switch (kind) {
    case PRIMITIVE:
        e->e_type = strset(e->e_type, type);
        e->e_basetype = strset(e->e_basetype, basetype);
        e->e_levels = levels;
        break;
    case COMPOSITE:
        e->e_attribute = strset(e->e_attribute, attribute);
        break;
    case VARARG:
        e->e_attribute = strset(e->e_attribute, attribute);
        break;
    default:
        errlog(FATAL, "programmer error: impossible kind of ENTRY");
    }

    e->e_pre_uses = npre;
    e->e_post_uses = npost;
    errlog(END, "}");
    return (e);
}


/*
 * free_entry -- really just mark an entry as invalid
 */
static ENTRY *
free_entry(ENTRY *e)
{
    if (e != NULL)
        e->e_valid = NO;
    return (e);
}


/*
 * ENTRY tables.
 */
#define ENTRY_INCREMENT 10

static EHEAD *
create_entry_table(int n)
{
    EHEAD   *p;

    errlog(BEGIN, "create_entry_table() {");
    if ((p = (EHEAD *)calloc(1,
        sizeof (EHEAD)+(n*sizeof (ENTRY)))) == NULL) {
        errlog(FATAL, "can't allocate space for an ENTRY table");
    }
    p->used = -1;
    p->n_entries = n;
    errlog(END, "}");
    return (p);
}

static EHEAD *
add_entry_table(EHEAD *t, char *name, int line, char *file,
    int kind, char *type, char *basetype, int levels, char *attribute,
    int npre, int npost)
{
    EHEAD   *t2;

    errlog(BEGIN, "add_entry_table() {");
    if (t == NULL) {
        errlog(FATAL, "programmer error: tried to add to NULL EHEAD");
    }
    t->used++;
    if (t->used >= t->n_entries) {
        if ((t2 = (EHEAD *)realloc(t,
            sizeof (EHEAD)+(sizeof (ENTRY)*
                (t->n_entries+ENTRY_INCREMENT)))) == NULL) {
            errlog(FATAL, "out of memory extending an EHEAD");
        }
        t = t2;
        clear_entries(t, t->n_entries, (t->n_entries+ENTRY_INCREMENT));
        t->n_entries += ENTRY_INCREMENT;
    }
    (void) set_entry(&t->entry[t->used],
        name, line, file, kind, type, basetype, levels,
        attribute, npre, npost);
    errlog(END, "}");
    return (t);
}

static ENTRY *
get_entry_table(EHEAD *t, int index)
{
    if (t == NULL)  {
        return (NULL);
    } else if (index > t->used) {
        return (NULL);
    } else {
        return (&(t->entry[index]));
    }
}

static EHEAD *
free_entry_table(EHEAD *t)
{
    if (t != NULL)
        t->used = -1;
    return (t);
}

static void
clear_entries(EHEAD *t, int start, int end)
{
    int i;

    for (i = start; i < end; i++) {
        (void) memset(&t->entry[i], 0, sizeof (ENTRY));
    }
}