line_despatch.c

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004, 2006 Symbian Software Ltd.                        *
 *   All rights reserved.                                                  *
 *   Copyright (C) 2002, 2003 Tony Finch <dot@dotat.at>.                   *
 *   All rights reserved.                                                  *
 *   Copyright (C) 1985, 1993 The Regents of the University of California. *
 *   All rights reserved.                                                  *
 *                                                                         *
 *   Contributed by Mike Kinghan, imk@strudl.org, derived from the code    *
 *   of Tony Finch                                                         *
 *                                                                         *
 *   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 "line_despatch.h"
#include "report.h"
#include "args.h"
#include "line_edit.h"
#include "io.h"


#define LINE_UNSIMPLIFIED (GET_PUBLIC(line_edit,ops_cut) == false && GET_PUBLIC(line_edit,parens_deleted) == 0)

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


static void
printline_fast(void)
{
    fputs(GET_PUBLIC(io,line_start),GET_PUBLIC(io,output));
}

static void
printline_cut(void)
{
    discard_policy_t discard_policy = GET_PUBLIC(args,discard_policy);
    unsigned extension_lines = GET_PUBLIC(io,extension_lines);
    char *cp = LINE_START;
    char last_written = ' ';
        SET_PUBLIC(line_despatch,lines_changed) += extension_lines + 1;
    for (       ; *cp != '\n'; ++cp) {
        assert(*cp);
        if (!DELETEABLE(*cp)) {
            if (*cp == ' ') {}
            else if (*cp == '\\' && cp[1] == '\n') {
                *cp = cp[1] = ' ';
                                ++cp;
            }
            else if (isspace(*cp)) {
                *cp = ' ';
            }
            else if (!isspace(last_written)) {
                fputc(' ',GET_PUBLIC(io,output));
                last_written = ' ';
            }
            fputc(*cp,GET_PUBLIC(io,output));
        }
        else if (!DELETEABLE(last_written)) {
            last_written = *cp;
        }
    }
    fputc('\n',GET_PUBLIC(io,output));
    if (discard_policy == DISCARD_BLANK) {
        for (   ; extension_lines; --extension_lines) {
            putc('\n', GET_PUBLIC(io,output));
        }
    }
    else if (discard_policy == DISCARD_COMMENT) {
        for (   ; extension_lines; --extension_lines) {
            fputs("//coan <\n", GET_PUBLIC(io,output));
        }
    }
}

static void
printline_restore_all_paren(void)
{
    restore_all_paren();
    printline_fast();
}

static void
printline_slow(void)
{
    if (GET_PUBLIC(line_edit,ops_cut)) {
        printline_cut();
    } else {
        printline_restore_all_paren();
    }
}

static void
printline(void)
{
    if (LINE_UNSIMPLIFIED) {
        printline_fast();
    } else {
        printline_slow();
    }
}

static void
printline_commented_out(void)
{
    if (LINE_UNSIMPLIFIED) {
        unsigned extension_lines = GET_PUBLIC(io,extension_lines);
        ++SET_PUBLIC(line_despatch,lines_changed);
        if (!extension_lines) {
            fputs("//coan < ",GET_PUBLIC(io,output));
            printline_fast();
        }
        else {
            char const *linestart = LINE_START;
            char const *newline;
            SET_PUBLIC(line_despatch,lines_changed) += extension_lines;
            for (   ;(newline = strchr(linestart,'\n')) != NULL; ) {
                size_t written;
                fputs("//coan < ",GET_PUBLIC(io,output));
                written = fwrite(linestart,1,newline - linestart,GET_PUBLIC(io,output));
                assert(written == newline - linestart);
                fputc('\n',GET_PUBLIC(io,output));
                linestart = newline + 1;
            }
        }
    } else {
        fputs("//coan < ",GET_PUBLIC(io,output));
        printline_slow();
    }
}

static void
flushline_dummy(bool keep,const char *insert_text) {}


static void
flushline_live(bool keep, char const *insert_text)
{
    if (insert_text) {
        /* Replacing a contradictory input line with a
         * diagnostic comment or #error*/
        fputs(insert_text,GET_PUBLIC(io,output));
        --SET_PUBLIC(line_despatch,lines_inactive);
        ++SET_PUBLIC(line_despatch,lines_changed);
        return;
    }
    if (keep ^ GET_PUBLIC(args,complement)) {
        printline();
    } else {
        unsigned extension_lines = GET_PUBLIC(io,extension_lines);
        discard_policy_t discard_policy = GET_PUBLIC(args,discard_policy);
        if (discard_policy == DISCARD_BLANK) {
            SET_PUBLIC(line_despatch,lines_changed) += extension_lines + 1;
            putc('\n', GET_PUBLIC(io,output));
            for (       ; extension_lines; --extension_lines) {
                putc('\n', GET_PUBLIC(io,output));
            }
        } else if (discard_policy == DISCARD_DROP) {
            SET_PUBLIC(line_despatch,lines_inactive) += extension_lines + 1;
        } else {
            printline_commented_out();
        }
    }
}


STATE_DEF(line_despatch)
{
    INCLUDE_PUBLIC(line_despatch);
    void         (*flushline)(bool,const char *);
    size_t drop_run;
}
STATE_T(line_despatch);


IMPLEMENT(line_despatch,STATIC_INITABLE);

USE_STATIC_INITIALISER(line_despatch) = { { 0, 0 }, flushline_live, false };
/* API **************************************************************/

void
line_despatch_no_op(void)
{
    SET_STATE(line_despatch,flushline) = flushline_dummy;
}

void
print(void)
{
    if (GET_PUBLIC(args,line_directives)) {
        if (GET_STATE(line_despatch,drop_run)) {
            int line_num = GET_PUBLIC(io,line_num);
            size_t extension_lines = GET_PUBLIC(io,extension_lines);
            if (extension_lines) {
                --line_num;
            }
            printf("#line %d\n",line_num);
            --SET_PUBLIC(line_despatch,lines_inactive);
            ++SET_PUBLIC(line_despatch,lines_changed);
        }
        SET_STATE(line_despatch,drop_run) = 0;
    }
    GET_STATE(line_despatch,flushline)(true,NULL);

}

void
drop(void)
{
    GET_STATE(line_despatch,flushline)(false,NULL);
    if (GET_PUBLIC(args,line_directives)) {
        ++SET_STATE(line_despatch,drop_run);
    }
}

void
substitute(const char *replacement)
{
    GET_STATE(line_despatch,flushline)(false,replacement);
}

/* EOF*/