symbol.c

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2007-2011 Mike Kinghan, imk@strudl.org                  *
 *   All rights reserved.                                                  *
 *   Contributed originally by Mike Kinghan, imk@strudl.org                *
 *                                                                         *
 *   Redistribution and use in source and binary forms, with or without    *
 *   modification, are permitted provided that the following conditions    *
 *   are met:                                                              *
 *                                                                         *
 *   Redistributions of source code must retain the above copyright        *
 *   notice, this list of conditions and the following disclaimer.         *
 *                                                                         *
 *   Redistributions in binary form must reproduce the above copyright     *
 *   notice, this list of conditions and the following disclaimer in the   *
 *   documentation and/or other materials provided with the distribution.  *
 *                                                                         *
 *   Neither the name of Symbian Software Ltd. nor the names of its        *
 *   contributors may be used to endorse or promote products derived from  *
 *   this software without specific prior written permission.              *
 *                                                                         *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS   *
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT     *
 *   LIMITED TO, THE IMPLIED WARRANTIES OF  MERCHANTABILITY AND FITNESS    *
 *   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE        *
 *   COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,   *
 *   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,  *
 *   BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS *
 *   OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED    *
 *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,*
 *   OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF *
 *   THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH  *
 *   DAMAGE.                                                               *
 *                                                                         *
 **************************************************************************/

#include "report.h"
#include "chew.h"
#include "evaluator.h"
#include "configured_symbols.h"
#include "io.h"
#include "contradiction.h"
#include "args.h"
#include "swiss_army.h"
#include "line_select.h"
#include "if_control.h"


static void
symbol_init(symbol_h sym, char const *name, size_t namelen)
{
    eval_result_clear(sym);
    sym->sym_name = clone(name,namelen);
}

static void
symbol_copy_init(symbol_h dest, symbol_const_h src)
{
    dest->sym_name = clone(src->sym_name,0);
    if (src->sym_def) {
        dest->sym_def = canonical_string_copy(src->sym_def);
    } else {
        dest->sym_def = src->sym_def;
    }
    if (src->most_resolved) {
        dest->most_resolved = canonical_string_copy(src->most_resolved);
    } else {
        dest->most_resolved = src->most_resolved;
    }
    dest->flags = src->flags;
    dest->value = src->value;
}

static int
symbol_name_compare(symbol_const_h sym, char const *name, size_t namelen)
{
    char const *sym_name;
    int comp;
    assert(sym);
    assert(name);
    sym_name = symbol_name(sym);
    comp = strncmp(sym_name,name,namelen);
    if (comp <= 0) {    /* Symbol name compares lesser.*/
        if (comp == 0) { /* Initial match*/
            if (sym_name[namelen] != '\0') {
                /* Symbol name is longer than `name'*/
                comp = 1;
            }
            /* Otherwise full match*/
        }
    }
    return comp;
}

static void
report_symbol_configuration(bool define, int gripe, symbol_const_h sym,
                            canonical_string_const_h old_def,
                            canonical_string_const_h new_def,
                            char const *tail)
{
    if (!gripe) {
        return;
    }
    if (define) {
        switch(gripe) {
        case GRIPE_INSOURCE_FUNCTION_LIKE_MACRO_DEFINITION:
            report(GRIPE_INSOURCE_FUNCTION_LIKE_MACRO_DEFINITION,NULL,
                   "Sorry. Function-like macro definition is not supported, ignored: \"#define %s%s\"",
                    symbol_name(sym),tail);
            break;
        case GRIPE_GLOBAL_FUNCTION_LIKE_MACRO_DEFINITION:
            bail(GRIPE_GLOBAL_FUNCTION_LIKE_MACRO_DEFINITION,
                   "Sorry. Function-like macro definition is not supported: \"-D%s%s\"",
                    symbol_name(sym),tail);
            break;
        case GRIPE_GARBAGE_ARG:
            bail(GRIPE_GARBAGE_ARG,"Garbage in \"-D%s%s\"",
                symbol_name(sym),tail);
            break;
        case GRIPE_DIFFERING_REDEF:
            report(GRIPE_DIFFERING_REDEF,NULL,
                   "Differently redefining \"%s=%s\", after \"%s=%s\" at line %d",
                   symbol_name(sym),
                   canonical_string_text(new_def),
                   symbol_name(sym),
                   canonical_string_text(old_def),
                   sym->line);
            break;
        case GRIPE_DUPLICATE_ARGS:
            report(GRIPE_DUPLICATE_ARGS,NULL,
                   "Duplicated \"-D%s=%s\" ignored",
                   symbol_name(sym),
                   canonical_string_text(new_def));
            break;
        case GRIPE_TRANSIENT_SYMBOL_ADDED:
            report(GRIPE_TRANSIENT_SYMBOL_ADDED,NULL,
                   "\"-D%s=%s\" has been assumed for the current file",
                   symbol_name(sym),
                   canonical_string_text(new_def));
            break;
        case GRIPE_INVALID_ARGS:
            if (old_def) {
                bail(GRIPE_INVALID_ARGS,
                    "\"-D%s=%s\" contradicts prior \"-D%s=%s\"",
                     symbol_name(sym),
                     canonical_string_text(new_def),
                     symbol_name(sym),
                     canonical_string_text(old_def));
            }
            else {
                bail(GRIPE_INVALID_ARGS,
                    "\"-D%s=%s\" contradicts prior \"-U%s\"",
                     symbol_name(sym),
                     canonical_string_text(new_def),
                     symbol_name(sym));
            }
            break;
        default:
            assert(false);
        }
    }
    else {
        switch(gripe) {
        case GRIPE_GARBAGE_ARG:
            bail(GRIPE_GARBAGE_ARG,"Garbage in \"-U%s%s\"",
                symbol_name(sym),tail);
            break;
        case GRIPE_UNDEFING_DEFINED:
            report(GRIPE_UNDEFING_DEFINED,NULL,
                "undefining %s, after defining %s=%s at line %d",
                symbol_name(sym),
                symbol_name(sym),
                canonical_string_text(old_def),
                sym->line);
            break;
        case GRIPE_INVALID_ARGS:
            bail(GRIPE_INVALID_ARGS,
                "\"-U%s\" contradicts prior \"-D%s=%s\"",
                symbol_name(sym),
                symbol_name(sym),
                canonical_string_text(old_def));
            break;
        case GRIPE_DUPLICATE_ARGS:
            report(GRIPE_DUPLICATE_ARGS,NULL,
                   "Duplicated \"-U%s\" ignored",
                   symbol_name(sym));
            break;
        case GRIPE_TRANSIENT_SYMBOL_ADDED:
            report(GRIPE_TRANSIENT_SYMBOL_ADDED,NULL,
                   "\"-U%s\" has been assumed for the current file",
                   symbol_name(sym));
            break;
        default:
            assert(false);
        }
    }
}

static canonical_string_h
symbol_definition_resolve(symbol_const_h sym, ptr_vector_h history)
{
    canonical_string_h resolved = canonical_string_copy(symbol_definition(sym));
    size_t offset = 0;
    symbol_h sy;
    for ( ;(sy = configured_symbol_find(resolved,&offset)) != NULL; offset = 0) {
        char const *symname = symbol_name(sy);
        char const *text = canonical_string_text(resolved);
        char const *cut_start = text + offset;
        char const *cut_end = cut_start + strlen(symname);
        size_t cut_len;
        canonical_string_const_h val = symbol_resolve(sy,history);
        cut_len = cut_end - cut_start;
        if (!val) {
            /* sym has circular definition */
            canonical_string_dispose(resolved);
            resolved = NULL;
            break;
        }
        canonical_string_replace(resolved,offset,cut_len,val);
    }
    return resolved;
}

/* API*/

symbol_h
symbol_new(char const *name, size_t namelen)
{
    symbol_h sym;
    assert(name);
    assert(namelen);
    sym = zallocate(sizeof(eval_result_t));
    symbol_init(sym,name,namelen);
    return sym;
}

void
symbol_dispose(symbol_h sym)
{
    if (sym) {
        eval_result_clear(sym);
        free(sym);
    }
}

symbol_h
symbol_copy(symbol_const_h src)
{
    symbol_h dest;
    assert(src);
    dest = zallocate(sizeof(eval_result_t));
    symbol_copy_init(dest,src);
    return dest;
}

void
symbol_swap(symbol_h lhs, symbol_h rhs)
{
    assert(lhs);
    assert(rhs);
    PODSWAP(char *,&lhs->sym_name,&rhs->sym_name);
    canonical_string_swap(lhs->sym_def,rhs->sym_def);
    canonical_string_swap(lhs->most_resolved,rhs->most_resolved);
    PODSWAP(int_spec_t,&lhs->value,&lhs->value);
    PODSWAP(int,&lhs->flags,&lhs->flags);
}

void
symbol_assign(symbol_h dest, symbol_const_h src)
{
    if (dest != src) {
        symbol_h tmp = symbol_copy(src);
        symbol_swap(dest,tmp);
        symbol_dispose(tmp);
    }
}

bool
symbol_equal(symbol_const_h lhs,symbol_const_h rhs)
{
    bool eq = lhs == rhs;
    if (!eq) {
        eq = symbol_compare(lhs,rhs,0);
        if (eq) {
            eq = canonical_string_equal(symbol_definition(lhs),
                                        symbol_definition(rhs));
        }
    }
    return eq;
}

line_type_t
symbol_define(symbol_h sym, char const *tail, char const **pend)
{
    canonical_string_h new_def = NULL;
    canonical_string_const_h old_def = NULL;
    line_type_t retval = LT_DIRECTIVE_KEEP;
    bool update = true;
    int gripe = 0;
    assert(sym);
    if (*tail == '(') { /* Macro arguments */
        if (INSOURCE) {
            gripe = GRIPE_INSOURCE_FUNCTION_LIKE_MACRO_DEFINITION;
        }
        else {
            gripe = GRIPE_GLOBAL_FUNCTION_LIKE_MACRO_DEFINITION;
        }
        update = false;
        goto conclusion;
    }
    if (!INSOURCE) {
        if (*tail == '=') {
            ++tail;
        }
        else if (*tail) {
            gripe = GRIPE_GARBAGE_ARG;
            goto conclusion;
        }
    }
    if (*tail) {
        new_def = canonical_string_new(tail,0,&tail);
    }
    else {
        new_def = canonical_string_new(NULL,0,NULL);
    }
    old_def = symbol_definition(sym);
    if (symbol_is_configured(sym)) {
        /* This is a re-configuration of an already configured symbol */
        if (old_def) { /* Symbol is already defined */
            if (!canonical_string_equal(old_def,new_def)) { /* Definitions differ */
                if (!symbol_is_global(sym)) { /* Differing #define constradicts prior #define */
                    gripe = GRIPE_DIFFERING_REDEF;
                }
                else if (INSOURCE) { /* Differing #define contradicts -D option */
                    retval = LT_DIRECTIVE_DROP;
                    update = false;
                    flush_contradiction();
                    insert_contradiction("\"%.*s\" differently redefines -D "
                                         "symbol");
                }
                /* Differing -D contradicts prior -D option */
                else {
                    gripe = GRIPE_INVALID_ARGS;
                }
            }
            /* Definitions the same */
            else if (!symbol_is_global(sym)) {  /* #define duplicating #define */
                update = false;
            }
            else if (INSOURCE) { /* #define duplicating -D option */
                retval = LT_DIRECTIVE_DROP;
                update = false;
                if (sym == GET_PUBLIC(contradiction,last_contradictory_undef)) {
                    forget_contradiction();
                }
            }
            /* -D duplicating -D option */
            else {
                gripe = GRIPE_DUPLICATE_ARGS;
                update = false;
            }
        }
        /* Symbol is already undefined. */
        else if (symbol_is_global(sym)) { /* Defining contradicts -U option */
            update = false;
            if (INSOURCE) { /* #define contradicts -U option */
                retval = LT_DIRECTIVE_DROP;
                insert_contradiction("\"%.*s\" contradicts -U or --implicit");
            }
            /* -D option contradicts -U option */
            else {
                gripe = GRIPE_INVALID_ARGS;
            }
        }
        //* Else #define countervails #undef */
    }
    /* Symbol not yet configured */
    else if (INSOURCE) {
        gripe = GRIPE_TRANSIENT_SYMBOL_ADDED;
    }
conclusion:
    if (pend) {
        *pend = tail;
    }
    if (is_unconditional_line() || !INSOURCE) {
        report_symbol_configuration(true,gripe,sym,old_def,new_def,tail);
        if(update) {
            canonical_string_dispose(sym->sym_def);
            sym->sym_def = new_def;
            canonical_string_dispose(sym->most_resolved);
            sym->most_resolved = NULL;
            sym->line = GET_PUBLIC(io,line_num);
            if (!INSOURCE) {
                SET_GLOBAL_SYM(*sym);
            }
            else {
                SET_INSOURCE_SYM(*sym);
            }
        }
        else {
            canonical_string_dispose(new_def);
        }
    }
    return retval;
}

line_type_t
symbol_undefine(symbol_h sym, char const *tail, char const **pend)
{
    line_type_t retval = LT_DIRECTIVE_KEEP;
    bool update = true;
    int gripe = 0;
    canonical_string_const_h old_def = NULL;
    assert(sym);
    if (!INSOURCE) {
        if (*tail) {
            gripe = GRIPE_GARBAGE_ARG;
            update = false;
            goto conclusion;
        }
    }
    old_def = symbol_definition(sym);
    if (symbol_is_configured(sym)) {
        /* This is a re-configuration of an already configured symbol */
        if (old_def) { /* Symbol is already defined */
            if (!symbol_is_global(sym)) {
                gripe = GRIPE_UNDEFING_DEFINED;
            }
            else if (INSOURCE) { /* #undef contradicting -D option */
                retval = LT_DIRECTIVE_DROP;
                update = false;
                if (GET_PUBLIC(contradiction,last_contradictory_undef) != sym) {
                    flush_contradiction();
                    SET_PUBLIC(contradiction,last_contradictory_undef) = sym;
                    save_contradiction("\"%.*s\" contradicts -D symbol");
                }
            }
                        else { /* -U contradicting prior -D */
                                gripe = GRIPE_INVALID_ARGS;
                        }
        }
        /* Symbol is already undefined. */
        else if (symbol_is_global(sym)) {
            update = false;
            if (INSOURCE) {
                retval = LT_DIRECTIVE_DROP;
            }
            else {
                gripe = GRIPE_DUPLICATE_ARGS;
            }
        }
        else {
            update = false;
        }
    }
    else if (INSOURCE) {
        gripe = GRIPE_TRANSIENT_SYMBOL_ADDED;
    }
conclusion:
    if (pend) {
        *pend = tail;
    }
    if (is_unconditional_line() || !INSOURCE) {
        report_symbol_configuration(false,gripe,sym,old_def,NULL,tail);

        if (update) {
            canonical_string_dispose(sym->sym_def);
            sym->sym_def = NULL;
            canonical_string_dispose(sym->most_resolved);
            sym->most_resolved = NULL;
            eval_result_set_value(sym,&int_spec_false);
            sym->line = GET_PUBLIC(io,line_num);
            if (!INSOURCE) {
                SET_GLOBAL_SYM(*sym);
            }
            else {
                SET_INSOURCE_SYM(*sym);
            }
        }
    }
    return retval;
}

char const *
symbol_name(symbol_const_h sym)
{
    assert(sym);
    return sym->sym_name;
}

canonical_string_const_h
symbol_definition(symbol_const_h sym)
{
    assert(sym);
    return sym->sym_def;
}

int
symbol_compare(symbol_const_h lhs, void const * rhs, size_t len)
{
    assert(lhs);
    assert(rhs);
    if (len) {
        return symbol_name_compare(lhs,rhs,len);
    } else {
        symbol_const_h other = rhs;
        return strcmp(lhs->sym_name,other->sym_name);
    }
}

bool
symbol_is_legal(char const *tok, size_t toklen)
{
    if (!is_symbol_start_char(*tok) || toklen < 1) {
        return false;
    }
    for (--toklen; toklen; --toklen,++tok) {
        if (!is_symbol_inner_char(*tok)) {
            return false;
        }
    }
    return true;
}

bool
symbol_is_configured(symbol_const_h sym)
{
    assert(sym);
    return GLOBAL_SYM(*sym) || INSOURCE_SYM(*sym);
}

bool
symbol_is_global(symbol_const_h sym)
{
    assert(sym);
    return GLOBAL_SYM(*sym);
}

bool
is_symbol_start_char(char cp)
{
    return isalpha(cp) || cp == '_';
}

bool
is_symbol_inner_char(char cp)
{
    return isalnum(cp) || cp == '_';
}

bool
symbol_reported(symbol_const_h sym)
{
    assert(sym);
    return REPORTED(*sym);
}

canonical_string_const_h
symbol_resolve(symbol_h sym, ptr_vector_h history)
{
    canonical_string_h resolved = NULL;
    bool outermost = true;
    if (history) {
        symbol_const_h * begin = (symbol_const_h *)ptr_vector_begin_const(history);
        symbol_const_h * end = (symbol_const_h *)ptr_vector_end_const(history);
        outermost = false;
        for (   ;begin != end; ++begin) {
            if (*begin == sym) {
                report(GRIPE_CIRCULAR_SYM_DEF,NULL,
                    "Symbol \"%s\" has a circular definition",
                    symbol_name(sym));
                canonical_string_dispose(sym->most_resolved);
                sym->most_resolved = NULL;
                return sym->most_resolved;
            }
        }
    }
    else {
        history = ptr_vector_new(NULL,NULL);
        ptr_vector_append(history,sym);
    }
    if (symbol_is_configured(sym)) {
        if (symbol_definition(sym)) {
            resolved = symbol_definition_resolve(sym,history);
        }
        else {
            resolved = canonical_string_new("0",0,NULL);
        }
    }
    else {
        resolved = canonical_string_new(symbol_name(sym),0,NULL);
    }
    canonical_string_dispose(sym->most_resolved);
    if (!resolved) {
        /* Sym has circular definition */
        if (outermost) {
            SET_KEEP(*sym);
            sym->most_resolved = canonical_string_new(symbol_name(sym),0,NULL);
        }
        else {
            sym->most_resolved = resolved;
        }
    }
    else {
        char const *pc = clone(canonical_string_text(resolved),0);
        char const *def_text = pc;
        eval_result_t er;
        er = eval_definition_text(&pc);
        if (*pc == 0 && RESOLVED(er)) {
            eval_result_set_value(sym,&er.value);
            sym->most_resolved = canonical_numeral(&er.value);
        }
        else {
            sym->most_resolved = resolved;
        }
        eval_result_clear(&er);
        free((char *)def_text);
    }
    if (outermost) {
        ptr_vector_drop(history);
    }
    return sym->most_resolved;
}

line_type_t
symbol_evaluate_status(bool define, char const *symstart, const char *tail, const char **pend)
{
    line_type_t retval = LT_DIRECTIVE_KEEP;
    symbol_h sym;
    size_t namelen;
    assert(symstart);
    if (!tail) {
        assert(!INSOURCE);
        tail = chew_symbol(symstart);
        namelen = tail - symstart;
    }
    else {
        assert(INSOURCE);
        namelen = strlen(symstart);
    }
    sym = configured_symbol_match(symstart,namelen);
    if (!sym) {
        sym = symbol_new(symstart,namelen);
    }
    if (!dropping_line()) {
        retval = configured_symbol_add(define,sym,tail,pend);
    }
    if (INSOURCE && ((define && eligible_line(CMD_SYMBOLS,HASH_DEFINE)) ||
                    (!define && eligible_line(CMD_SYMBOLS,HASH_UNDEF)))) {
        report_symbol(sym);
    }
    if (!symbol_is_configured(sym)) {
        symbol_dispose(sym);
    }
    return retval;
}
/* EOF*/