chew.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.                                                  *
 *   Copyright (C) 2007-2011 Mike Kinghan, imk@strudl.org                  *
 *   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 "chew.h"
#include "args.h"
#include "io.h"
#include "report.h"


STATE_DEF(chew)
{
    INCLUDE_PUBLIC(chew);
    size_t single_quote_length;
    bool                escape; 
}
STATE_T(chew);

IMPLEMENT(chew,ZERO_INITABLE)
#if 0 /* Redundant for now */

static char const *
straighten_continuation(char const *cp)
{
    bool reported = false;
    for (       ; cp[0] == '\\' && eol(cp + 1); ) {
        truncate_line(LINE_OFF(cp));
        cp = read_more(cp);
        if (is_symbol_inner_char(cp[1]) && !reported) {
            report(GRIPE_STRAIGHTENED_LINE,NULL,
                   "Obfuscating line-continuation(s) deleted");
            reported = true;
        }

    }
    return cp;
}
#endif

static bool
is_line_continuation(char const *cp)
{
    return *cp == '\\' && eol(cp + 1);
}


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

char const *
chew_continuation(char const *cp)
{
    size_t nl_len;
    for (       ; cp[0] == '\\' && (nl_len = eol(cp + 1)); cp += nl_len + 1) {
        if (cp[nl_len + 1] == 0) {
            cp = read_more(cp);
        }
    }
    return cp;
}

char const *
chew_symbol(char const *cp)
{
    if (is_symbol_start_char(*cp)) {
        for (   ; is_symbol_inner_char(*cp); cp = chew_continuation(++cp)) {}
    }
    return (cp);
}

char const *
chew_string(char const *cp)
{
    char const * save = cp;
    if (*cp == '\"') {
        for ( ++cp ; *cp && *cp != '\"' && !eol(cp);
                cp = chew_continuation(++cp)) {}
        if (!*cp && GET_PUBLIC(chew,in_source)) {
            report(GRIPE_UNCLOSED_QUOTE,NULL,
                   "Unclosed quotation in context \"%s\"",save);
        }
        ++cp;
    } else for (        ; isgraph(*cp); cp = chew_continuation(++cp)) {
            size_t read_off = read_offset(cp);
            char const * leader = chew_on(cp);
            cp = read_pos(read_off);
            if (leader != cp) {
                break;
            }
        }
    return cp;
}

char const *
chew_unbroken_string(char const *cp)
{
    char const * save = cp;
    if (*cp == '\"') {
        for ( ++cp ; *cp && *cp != '\"' && !eol(cp) && !is_line_continuation(cp); ++cp) {}
        if (!*cp && GET_PUBLIC(chew,in_source)) {
            report(GRIPE_UNCLOSED_QUOTE,NULL,
                   "Unclosed quotation in context \"%s\"",save);
        } else if (*cp == '\"') {
            ++cp;
        }
    } else for (        ; isgraph(*cp) && !is_line_continuation(cp); ++cp) {
            size_t read_off = read_offset(cp);
            char const * leader = chew_on(cp);
            cp = read_pos(read_off);
            if (leader != cp) {
                break;
            }
        }
    return cp;
}

char const *
chew_macro_call(char const *cp)
{
    cp = chew_symbol(cp);
    cp = chew_continuation(cp);
    if (*cp == '(') {
        cp = chew_continuation(++cp);
        while(*cp != ')') {
            char const * saved_cp;
            saved_cp = cp = chew_on(cp);
            cp = chew_string(cp);
            if (cp > saved_cp && cp[-1] == ')') {
                return cp;
            }
            cp = chew_on(cp);
            if (*cp == ',') {
                cp = chew_continuation(++cp);
            } else if (*cp == '(') {
                cp = chew_continuation(++cp);
                cp = chew_on(cp);
                cp = chew_macro_call(cp);
            } else if (!*cp) {
                break;
            }
        }
        if (*cp == ')') {
            ++cp;
        } else {
            for(        ; isspace(cp[-1]); --cp) {}
        }
    }
    return cp;
}

char const *
chew_header_name(char const *cp)
{
    char delim;
    if (*cp == '\"') {
        delim = *cp;
    } else if (*cp == '<') {
        delim = '>';
    } else {
        delim = 0;
    }
    if (delim) {
        for (cp = chew_continuation(++cp);
                *cp != delim &&
                (is_symbol_inner_char(*cp) ||
                 *cp == ' ' ||
                 *cp == '/' ||
#ifdef WINDOWS
                 *cp == '\\' ||
#endif
                 *cp == '.');
                cp = chew_continuation(++cp)) {};
        if (*cp == delim) {
            cp = chew_continuation(++cp);
        }
    }
    return cp;
}

unsigned
eol(char const * cp)
{
    if (cp[0] == '\n') {
        return 1;
    }
    if (cp[0] == '\r' && cp[1] == '\n') {
        return 2;
    }
    return 0;
}


char const *
chew_on(char const *cp)
{
    char const *chew_start = cp;
    unsigned nl_len;
    /*  Need to track single-quotes to detect quotations of the
        character '"', which must not count as opening or closing
        double-quotes. Is necessary only to recognise single-quotes
        enclosing a single character: if the enclosed charccter is
        escaped, e.g. '\"', then escape-tracking copes.
    */
    if (GET_PUBLIC(args,plaintext)) {
        for (; isspace((unsigned char)*cp); ++cp) {
            if (eol(cp)) {
                SET_PUBLIC(chew,line_state) = LS_NEUTER;
            }
        }
        return (cp);
    }
    while (*cp != '\0') {
        if (GET_STATE(chew,single_quote_length)) {
            ++SET_STATE(chew,single_quote_length);
        }
        if (cp[0] == '\\') {
            if (eol(cp + 1)) {
                /* Line continuation "\\n" sequence cannot itself be escaped */
                SET_STATE(chew,escape) = true;
            } else if (GET_STATE(chew,single_quote_length)) {
                /* Toggle escape state if we are in single quotes */
                SET_STATE(chew,escape) = !GET_STATE(chew,escape);
                /* Discount an escape token from the length of a single quotation */
                --SET_STATE(chew,single_quote_length);
            } else if (GET_PUBLIC(chew,in_double_quote)) {
                /* Also Toggle escape state if we are in double quotes */
                SET_STATE(chew,escape) = !GET_STATE(chew,escape);
            } else if (GET_PUBLIC(chew,line_state) != LS_CODE ||
                       GET_PUBLIC(chew,comment_state) == NO_COMMENT) {
                /* This is a plain backslash within directive. Quit */
                break;
            }
            ++cp;
            continue;
        }
        if (cp[0] == '"') {
            if (!GET_STATE(chew,escape)) {
                if (GET_PUBLIC(chew,stop_at_quote) &&
                        GET_PUBLIC(chew,comment_state) == NO_COMMENT) {
                    break;
                }
                /*      Can toggle double-quote state if we are not escaped.
                    This action will be invalid if this double-quote is
                    within single-quotes, but in that case we will
                    detect and rectify the error when we close the
                    single-quote. */
                if ((SET_PUBLIC(chew,in_double_quote) =
                            !GET_PUBLIC(chew,in_double_quote)) == true) {
                    SET_PUBLIC(chew,last_quote_start_line) =
                        GET_PUBLIC(io,line_num);
                }
            }
            ++cp;
        } else if (cp[0] == '\'') {
            if (!GET_STATE(chew,escape)) {
                size_t single_quote_len;
                if (GET_PUBLIC(chew,stop_at_quote) &&
                        GET_PUBLIC(chew,comment_state) == NO_COMMENT) {
                    break;
                }
                /* Can only enter a single-quote state is we are not escaped */
                single_quote_len = GET_STATE(chew,single_quote_length);
                if (single_quote_len == 0 &&
                        !GET_PUBLIC(chew,in_double_quote)) {
                    /* Can enter single-quotation if not already in
                    single- or double-quotatioon */
                    ++SET_STATE(chew,single_quote_length);
                } else if (single_quote_len > 0) { /* Leaving single quotation */
                    if (GET_PUBLIC(chew,in_double_quote)) {
                        /* If we are leaving single-quotation then we
                        cannot have been within double-quotation when
                        we entered single-quotation because we forbid
                        entry to single-quotation within double-quotation.
                        Therefore we have entered double-quotation within
                        single-quotation. If the last '"'-character
                        parsed was escaped we would not have entered double
                        quotation. And since we are     still within
                        single-quotation now, we know that the previous
                        character parsed was an unescaped '"', which
                        we falsely interpreted as the start of
                        double-quotation. So we correct that error
                        now by exiting double-quotation.*/
                        SET_PUBLIC(chew,in_double_quote) = false;
                    }
                    SET_STATE(chew,single_quote_length) = 0;
                }
                ++cp;
            }
            else if (GET_PUBLIC(chew,in_double_quote) || GET_STATE(chew,single_quote_length) > 0 ||
                GET_PUBLIC(chew,comment_state) != NO_COMMENT) {
                /* If we're in double quotation or comments then apostrophe is not start of a
                    character constant */
                ++cp;
            }
            else { /* Apostrophe may be start of a character constant */
                break;
            }
        } else if ((nl_len = eol(cp)) != 0) { /* Newline*/
            if (GET_STATE(chew,escape)) {
                /* Line continuation */
                if (cp[nl_len] == 0) {
                    /* Newline is at actual end of line, so extend line */
                    ++SET_PUBLIC(io,extension_lines);
                    cp = read_more(cp);
                }
                if (GET_STATE(chew,single_quote_length)) {
                    /*  A line continuation doesn't count as a character,
                        so discount both a '\' and preceding '\\' from the length of the single-quote */
                    SET_STATE(chew,single_quote_length) -= 2;
                }
            } else {    /* Plain newline*/
                SET_PUBLIC(chew,line_state) = LS_NEUTER;
                if (GET_PUBLIC(chew,comment_state) == CXX_COMMENT) {
                    /* Newline terminates C++ comment*/
                    SET_PUBLIC(chew,comment_state) = NO_COMMENT;
                    SET_PUBLIC(chew,in_double_quote) = false;
                } else if (GET_PUBLIC(chew,comment_state) == C_COMMENT) {
                    SET_PUBLIC(chew,in_double_quote) = false;
                    ++SET_PUBLIC(io,extension_lines);
                    cp = read_more(cp);
                } else if (GET_PUBLIC(chew,in_double_quote)) {
                    SET_PUBLIC(chew,in_double_quote) = false;
                    if (GET_PUBLIC(chew,must_balance_quotes &&
                                   GET_PUBLIC(chew,in_source))) {
                        /* Dangling quotation is not in comment. Error*/
                        parse_error(GRIPE_NEWLINE_IN_QUOTE,
                                    "Newline within quotation");
                    }
                }
            }
            if (*cp == '\r') {
                /* Detected Windows line-end in Unix environment*/
                ++cp;
            }
            ++cp;
        } else if (cp[0] == ' ' || cp[0] == '\t') { /* Some whitespace*/
            ++cp;
        }
        /* Could be at the start or end of a comment*/
        else if (GET_PUBLIC(chew,comment_state) == NO_COMMENT) {
            /* Not in C or C++ comment*/
            /* Check for start of comment*/
            if (!GET_PUBLIC(chew,in_double_quote) && !GET_STATE(chew,single_quote_length)) {
                /* Don't let comments start within quotation*/
                if (!strncmp(cp, "/\\\n",3)) {
                    SET_PUBLIC(chew,comment_state) = STARTING_COMMENT;
                    SET_PUBLIC(chew,last_comment_start_line) =
                        GET_PUBLIC(io,line_num);
                    cp += 3;
                }
                if (!strncmp(cp, "/\\\r\n",4)) {
                    SET_PUBLIC(chew,comment_state) = STARTING_COMMENT;
                    SET_PUBLIC(chew,last_comment_start_line) =
                        GET_PUBLIC(io,line_num);
                    cp += 4;
                } else if (cp[0] == '/' && cp[1] == '*') {
                    SET_PUBLIC(chew,comment_state) = C_COMMENT;
                    SET_PUBLIC(chew,last_comment_start_line) =
                        GET_PUBLIC(io,line_num);
                    cp += 2;
                } else if (cp[0] == '/' && cp[1] == cp[0]) {
                    SET_PUBLIC(chew,comment_state) = CXX_COMMENT;
                    SET_PUBLIC(chew,last_comment_start_line) =
                        GET_PUBLIC(io,line_num);
                    cp += 2;
                } else if (GET_PUBLIC(chew,line_state) == LS_CODE) {
                    /* Cool if we have got into code. Carry on */
                    //TODO See how much we get here! */
                    ++cp;
                } else {
                    /* Got some non-chewable char within directive. Quit */
                    break;
                }
            } else {    /* We're inside quotation. Truck on*/
                ++cp;
            }
        }
        /* We are in a comment state. Check for end of comment*/
        /* No need to test for end of C++ comment 'cos newline case
                covers it*/
        else if (GET_PUBLIC(chew,comment_state) == C_COMMENT) {
            if (!strncmp(cp, "*\\\n",3)) {
                SET_PUBLIC(chew,comment_state) = FINISHING_COMMENT;
                cp += 3;
            }
            if (!strncmp(cp, "*\\\r\n",4)) {
                SET_PUBLIC(chew,comment_state) = FINISHING_COMMENT;
                cp += 4;
            } else if (cp[0] == '*' && cp[1] == '/') {
                SET_PUBLIC(chew,comment_state) = NO_COMMENT;
                SET_PUBLIC(chew,in_double_quote) = false;
                cp += 2;
            } else {
                ++cp;
            }
        } else if (GET_PUBLIC(chew,comment_state) == STARTING_COMMENT) {
            if (*cp == '*') {
                SET_PUBLIC(chew,comment_state) = C_COMMENT;
                ++cp;
            } else if (*cp == '/') {
                SET_PUBLIC(chew,comment_state) = CXX_COMMENT;
                ++cp;
            } else {
                SET_PUBLIC(chew,comment_state) = NO_COMMENT;
                SET_PUBLIC(chew,line_state) = LS_CODE;
            }
        } else if (GET_PUBLIC(chew,comment_state) == FINISHING_COMMENT) {
            if (*cp == '/') {
                SET_PUBLIC(chew,comment_state) = NO_COMMENT;
                ++cp;
            } else {
                SET_PUBLIC(chew,comment_state) = C_COMMENT;
            }
        } else {
            ++cp;
        }
        SET_STATE(chew,escape) = false;
        if (GET_STATE(chew,single_quote_length) > 3) {
            SET_STATE(chew,single_quote_length) = 0;
        }
    }
    if (GET_STATE(chew,escape)) {
        SET_STATE(chew,escape) = false;
        if (GET_PUBLIC(chew,in_source)) {
            report(GRIPE_STRAY_ESCAPE,NULL,"Stray '\\' ignored");
        }
    }
    if (GET_PUBLIC(chew,in_double_quote) && GET_PUBLIC(chew,in_source)) {
        report(GRIPE_UNCLOSED_QUOTE,NULL,"Unclosed quotation in context \"%s\"",
               chew_start);
    }
    return cp;
}

void
chew_toplevel(void)
{
    SET_PUBLIC(chew,line_state) = LS_NEUTER;
    SET_PUBLIC(chew,comment_state) = NO_COMMENT;
    SET_PUBLIC(chew,in_double_quote) = false;
    SET_STATE(chew,single_quote_length) = 0;
    SET_PUBLIC(chew,stop_at_quote) = false;
    SET_PUBLIC(chew,must_balance_quotes) = true;
    SET_PUBLIC(chew,in_source) = true;
}

/* EOF*/