io.c

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004, 2006 Symbian Software Ltd.                        *
 *   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 "filesys.h"
#include "io.h"
#include "args.h"
#include "platform.h"
#include "dataset.h"
#include "configured_symbols.h"


static bool
readon(void);

static void
make_tempfile(void);

static void
replace_infile(void);

static void
make_backup_name(const char *filename);

static void
backup_infile(void);

static void
delete_infile(void)
{
    if (remove(GET_PUBLIC(io,filename))) {
        bail(GRIPE_CANT_DELETE_FILE,
             "Cannot remove file \"%s\"",GET_PUBLIC(io,filename));
    }
}


static void
open_output(void);


STATE_DEF(io)
{
    INCLUDE_PUBLIC(io); 
    FILE * input;       
    size_t bufsz;       
    size_t infile;      
    char * in_name_buf;
    char * out_name_buf;
    char * bak_name_buf; 
    size_t saved_read_pos; 
}
STATE_T(io);
IMPLEMENT(io,ZERO_INITABLE);
char * read_filename(void)
{
    int ch;
    size_t pos = 0;
    bool quoted;
    char * in_name_buf = GET_STATE(io,in_name_buf);
    if (in_name_buf == NULL) {
        in_name_buf = SET_STATE(io,in_name_buf) = zallocate(PATH_MAX + 1);
    }
    ch = getchar();
    in_name_buf[0] = '\0';
    /* Skip whitespace on stdin*/
    for (       ; ch != EOF && isspace(ch); ch = getchar()) {};
    if (ch == EOF) {
        return NULL;
    }
    quoted = ch == '\"';
    if (quoted) {
        for (ch = getchar() ; ch != EOF && ch != '\"'; ch = getchar()) {
            if (isspace(ch) && ch != ' ') {
                in_name_buf[pos] = '\0';
                bail(GRIPE_ILLEGAL_FILENAME,
                     "Illegal whitespace in input filename: \"%s...",
                     in_name_buf);
            }
            in_name_buf[pos++] = ch;
            if (pos == PATH_MAX) {
                in_name_buf[pos] = '\0';
                bail(GRIPE_FILENAME_TOO_LONG,
                     "A filename exceeds max %d bytes: \"%s...",
                     PATH_MAX,in_name_buf);
            }
        }
        in_name_buf[pos] = '\0';
        if (ch == EOF) {
            bail(GRIPE_EOF_IN_FILENAME,
                 "A quoted input filename is unterminated: \"%s...",
                 in_name_buf);
        }
    } else {
        for (   ; ch != EOF && !isspace(ch); ch = getchar()) {
            in_name_buf[pos++] = ch;
            if (pos == PATH_MAX) {
                in_name_buf[pos] = '\0';
                bail(GRIPE_FILENAME_TOO_LONG,
                     "An input filename exceeds max %d bytes: \"%s...",
                     PATH_MAX,in_name_buf);
            }
        }
        in_name_buf[pos] = '\0';
    }
    return in_name_buf;
}

static bool
readon(void)
{
    size_t read = 0;
    for (;;) {
        char *bufp;
        if (GET_PUBLIC(io,line_len) + 1 >= GET_STATE(io,bufsz)) {
            /* Need more buffer*/
            SET_PUBLIC(io,line_start)
            = reallocate(GET_PUBLIC(io,line_start),
                         SET_STATE(io,bufsz) += BUFSIZ);
        }
        /* Position to end of current line*/
        bufp = LINE_END;
        /* Read some more at that position*/
        if (NULL == fgets(bufp,(int)(GET_STATE(io,bufsz) -
                                     GET_PUBLIC(io,line_len)),GET_STATE(io,input))) {
            /* EOF (or possibly read error).*/
            if (ferror(GET_STATE(io,input))) {
                bail(GRIPE_CANT_READ_INPUT,"Read error on file %s",
                     GET_PUBLIC(io,filename));
            }
            break;
        }
        /* Update length of line*/
        SET_PUBLIC(io,line_len) += read = strlen(bufp);
        bufp += read;
        if (bufp[-1] == '\n') {
            /* End of line. That's all*/
            break;
        }
    }
    return read != 0;
}

static bool
extend_line(void)
{
    bool eof = !readon();
    if (!eof) {
        ++SET_PUBLIC(io,line_num);
        return true;
    }
    return false;
}

static void
make_tempfile(void)
{
    char *out_name_buf = GET_STATE(io,out_name_buf);
    const char *infile = GET_PUBLIC(io,filename);
    const char *delim = strrchr(infile,PATH_DELIM);
    char const *tempname = NULL;
    size_t dirlen = delim ? delim - infile : 0;
    if (out_name_buf == NULL) {
        out_name_buf = SET_STATE(io,out_name_buf) =
                           zallocate(PATH_MAX);
    }
    if (dirlen) {
        strncpy(out_name_buf,infile,dirlen);
        out_name_buf[dirlen++] = PATH_DELIM;
    }
    strcpy(out_name_buf + dirlen,"coan_out_XXXXXX");
    tempname = fs_tempname(out_name_buf);
    if (!tempname) {
        bail(GRIPE_NO_TEMPFILE,
             "Cannot create temporary file");
    }
}

static void
replace_infile(void)
{
    if (rename(GET_STATE(io,out_name_buf),
               GET_PUBLIC(io,filename))) {
        bail(GRIPE_CANT_RENAME_FILE,
             "Cannot rename file \"%s\" as \"%s\"",
             GET_STATE(io,out_name_buf),
             GET_PUBLIC(io,filename));
    }
}

static void
make_backup_name(const char *filename)
{
    FILE *exists = NULL;
    size_t suffix_len = strlen(GET_PUBLIC(args,backup_suffix));
    size_t namelen = strlen(filename) + suffix_len;
    if (GET_STATE(io,bak_name_buf) == NULL) {
        SET_STATE(io,bak_name_buf) = zallocate(PATH_MAX + 1);
    }
    strncpy(GET_STATE(io,bak_name_buf),
            GET_PUBLIC(io,filename),PATH_MAX)[PATH_MAX] = 0;
    do {
        if (namelen > PATH_MAX) {
            bail(GRIPE_FILENAME_TOO_LONG,
                 "A filename exceeds max %d bytes: \"%s...",
                 PATH_MAX,GET_STATE(io,bak_name_buf));
        }
        strcat(GET_STATE(io,bak_name_buf),
               GET_PUBLIC(args,backup_suffix));
        exists = fopen(GET_STATE(io,bak_name_buf),"r");
        if (!exists) {
            break;
        }
        fclose(exists);
        namelen += suffix_len;
    } while(true);
}

static void
backup_infile(void)
{
    make_backup_name(GET_PUBLIC(io,filename));
    if (rename(GET_PUBLIC(io,filename),
               GET_STATE(io,bak_name_buf))) {
        bail(GRIPE_CANT_RENAME_FILE,
             "Cannot rename file \"%s\" as \"%s\"",
             GET_PUBLIC(io,filename),
             GET_STATE(io,bak_name_buf));
    }
}


static void
open_output(void)
{
    if (!GET_PUBLIC(args,replace)) {
        SET_PUBLIC(io,output) = stdout;
    } else {
        make_tempfile();
        SET_PUBLIC(io,output) =
            open_file(GET_STATE(io,out_name_buf),"w");
    }
}

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

FILE * open_file(const char *file, const char *mode)
{
    FILE * stream = fopen(file, mode);
    if (stream == NULL) {
        bail(GRIPE_CANT_OPEN_INPUT,"Can't open %s for %s",
             file, (mode[0] == 'r' ? "reading": "writing"));
    }
    return stream;
}

void
close_io(int error)
{
    ++SET_PUBLIC(dataset,donefiles);
    if (GET_STATE(io,input) != stdin &&
            GET_STATE(io,input) != NULL) {

        fclose(GET_STATE(io,input));
        SET_STATE(io,input) = NULL;

        if (GET_PUBLIC(io,output) != stdout &&
                GET_PUBLIC(io,output) != NULL) {
            fclose(GET_PUBLIC(io,output));
            SET_PUBLIC(io,output) = NULL;
        }
        if (!error && GET_PUBLIC(args,replace)) {
            if (GET_PUBLIC(args,backup_suffix) != NULL) {
                backup_infile();
            } else {
                delete_infile();
            }
            replace_infile();
        }

    }
    if (error) {
        ++SET_PUBLIC(dataset,errorfiles);
        if (!GET_PUBLIC(args,keepgoing)) {
            exit(exitcode());
        }
    }
    io_toplevel();
}


void
open_io(char const *filename)
{
    SET_PUBLIC(io,filename) = filename;
    if (!strcmp(GET_PUBLIC(io,filename),STDIN_NAME)) {
        SET_STATE(io,input) = stdin;
    } else {
        SET_STATE(io,input) =
            open_file(GET_PUBLIC(io,filename),"r");
        SET_PUBLIC(io,line_num) = 0;
    }
    open_output();
    configured_symbols_rewind();
}

bool get_line(void)
{
    bool got_line;
    char *pristine_line;
    char * last_line_end = LINE_END - 1;
    if (last_line_end < LINE_START) {
        last_line_end = "\n";
    }
    SET_PUBLIC(io,line_len) = 0;
    SET_PUBLIC(io,extension_lines) = 0;
    pristine_line = GET_PUBLIC(io,pristine_line);
    if (pristine_line) {
        free(pristine_line);
        SET_PUBLIC(io,pristine_line) = NULL;
    }
    got_line = extend_line();
    if (!got_line) {
        if (INSOURCE && *last_line_end != '\n') {
            report(GRIPE_MISSING_EOF_NEWLINE,NULL,"Missing newline at EOF");
        }
    }
    else { /* If we've read a line then save a pristine copy */
        SET_PUBLIC(io,pristine_line) = clone(GET_PUBLIC(io,line_start),0);
    }
    return got_line;
}

char *
read_more(char const *readpos)
{
    save_read_pos(readpos);
    if (extend_line()) {
        return saved_read_pos();
    }
    early_eof();
    return NULL;
}

size_t
read_offset(char const *readpos)
{
    char *linestart = LINE_START;
    return readpos - linestart;
}

char *
read_pos(size_t readoff)
{
    return LINE_START + readoff;
}


void
ensure_buf(size_t extra)
{
    size_t spare = GET_STATE(io,bufsz) - GET_PUBLIC(io,line_len);
    int i;
    for ( i = 0; spare <= extra; ++i) {
        SET_STATE(io,bufsz) += BUFSIZ;
        spare = GET_STATE(io,bufsz) - GET_PUBLIC(io,line_len);
    }
    if (i) {
        SET_PUBLIC(io,line_start)
        = reallocate(GET_PUBLIC(io,line_start),
                     GET_STATE(io,bufsz));
    }
}

bool
input_opened(void)
{
    return !!GET_STATE(io,input);
}

void
save_read_pos(char const *cp)
{
    SET_STATE(io,saved_read_pos) = cp - GET_PUBLIC(io,line_start);
}

char *
saved_read_pos(void)
{
    return GET_PUBLIC(io,line_start) + GET_STATE(io,saved_read_pos);
}

void
io_toplevel(void)
{
    SET_PUBLIC(io,line_num) = 0;
    SET_PUBLIC(io,filename) = NULL;
}

/* EOF*/