contradiction.c

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004, 2006 Symbian Software Ltd.                        *
 *   All rights reserved.                                                  *
 *   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 "contradiction.h"
#include "report.h"
#include "line_despatch.h"
#include "io.h"
#include "if_control.h"
#include <stdlib.h>
#include <assert.h>


STATE_DEF(contradiction)
{
    INCLUDE_PUBLIC(contradiction);
    char *   contradiction_insert_prefix;
    int                 contradiction_insert_reason;
    bool                had_warnings;
    heap_str err_msg_buf[2];
}
STATE_T(contradiction);

IMPLEMENT(contradiction,STATIC_INITABLE)

USE_STATIC_INITIALISER(contradiction) = {
    { NULL },
    "//",
    GRIPE_COMMENTED_CONTRADICTION
};


#define CONTRADICTION_PENDING\
        (GET_STATE(contradiction,err_msg_buf)[ERR_MSG_BUF] != 0)

enum {
    ERR_MSG_BUF,        
    OUT_MSG_BUF         
};


/* Helpers ****************************************************************/

static void
compose_contradiction_insert_format(heap_str *buf, const char *sub_format)
{
    int buflen = 0;
    int startoff = 0;
    format_output(buf,&buflen,&startoff,
                  "%serror : inserted by coan: %s at %s(%d)\n",
                  GET_STATE(contradiction,contradiction_insert_prefix),
                  sub_format,
                  GET_PUBLIC(io,filename),
                  GET_PUBLIC(io,line_num));
}

static void
forget_pending_contradiction(void)
{
    release((void **)&GET_STATE(contradiction,err_msg_buf)[OUT_MSG_BUF]);
    release((void **)&GET_STATE(contradiction,err_msg_buf)[ERR_MSG_BUF]);
    SET_PUBLIC(contradiction,last_contradictory_undef) = NULL;
}

static void
insert_pending_contradiction(void)
{
    assert(GET_STATE(contradiction,err_msg_buf)[ERR_MSG_BUF]);
    report(GET_STATE(contradiction,contradiction_insert_reason),
           &GET_STATE(contradiction,err_msg_buf)[ERR_MSG_BUF],NULL);
    if (GET_STATE(contradiction,contradiction_insert_prefix)) {
        substitute(GET_STATE(contradiction,err_msg_buf)[OUT_MSG_BUF]);
        if (GET_STATE(contradiction,contradiction_insert_reason) ==
                GRIPE_ERRORED_CONTRADICTION) {
            set_exit_flags(EVENT_SUMMARY_ERRORED_LINES,true);
            if (is_unconditional_line()) {
                set_exit_flags(EVENT_SUMMARY_ERROR_OUTPUT,true);
                report(GRIPE_UNCONDITIONAL_ERROR_INPUT,NULL,
                       "An unconditional #error directive was output");
            }
        }
    }
    forget_pending_contradiction();
}

/* API **************************************************************/

void
insert_contradiction(char const *sub_format)
{
    save_contradiction(sub_format);
    insert_pending_contradiction();
}


void
contradiction_policy(contradiction_policy_t p)
{
    switch(p) {
    case CONTRADICTION_DELETE:
        SET_STATE(contradiction,contradiction_insert_prefix) = NULL;
        SET_STATE(contradiction,contradiction_insert_reason) =
            GRIPE_DELETED_CONTRADICTION;
        break;
    case CONTRADICTION_COMMENT:
        SET_STATE(contradiction,contradiction_insert_prefix) = "//";
        SET_STATE(contradiction,contradiction_insert_reason) =
            GRIPE_COMMENTED_CONTRADICTION;
        break;
    case CONTRADICTION_ERROR:
        SET_STATE(contradiction,contradiction_insert_prefix) = "#";
        SET_STATE(contradiction,contradiction_insert_reason) =
            GRIPE_ERRORED_CONTRADICTION;
        break;
    default:
        assert(false);
    }
}

void
flush_contradiction(void)
{
    if (GET_STATE(contradiction,err_msg_buf)[ERR_MSG_BUF]) {
        insert_pending_contradiction();
    }
}

void
forget_contradiction(void)
{
    if (GET_STATE(contradiction,err_msg_buf)[OUT_MSG_BUF]) {
        if (!GET_STATE(contradiction,had_warnings)) {
            set_exit_flags(MSGCLASS_WARNING,false);
        }
        forget_pending_contradiction();
    }
}

void
save_contradiction(char const *sub_format)
{
    size_t linelen = line_len(GET_PUBLIC(io,line_start));
    size_t extension_lines = GET_PUBLIC(io,extension_lines);
    assert(GET_STATE(contradiction,err_msg_buf)[ERR_MSG_BUF] == 0);
    if (extension_lines) {
        /* Ensure no embedded newlines or tabs in the error message buffer*/
        flatten_line(GET_PUBLIC(io,line_start));
    }
    SET_STATE(contradiction,had_warnings) = get_exit_flags(MSGCLASS_WARNING) != 0;
    report(GET_STATE(contradiction,contradiction_insert_reason),
           &GET_STATE(contradiction,err_msg_buf)[ERR_MSG_BUF],
           sub_format,
           linelen,
           GET_PUBLIC(io,line_start));
    if (GET_STATE(contradiction,contradiction_insert_prefix)) {
        heap_str contradiction_insert_format = NULL;
        int buflen = 0;
        int startoff;
        compose_contradiction_insert_format(&contradiction_insert_format,
                                            sub_format);
        assert(GET_STATE(contradiction,err_msg_buf)[OUT_MSG_BUF] == 0);
        format_output(&GET_STATE(contradiction,err_msg_buf)[OUT_MSG_BUF],
                        &buflen,&startoff,
                        contradiction_insert_format,
                        linelen,
                        GET_PUBLIC(io,line_start),
                        GET_PUBLIC(io,filename),
                        GET_PUBLIC(io,line_num));
        free(contradiction_insert_format);
    }
}

/* EOF*/