/*

 * Copyright (c) 2005, 2008 Sun Microsystems, Inc. All Rights Reserved.

 * Use is subject to license terms.

 *

 *	Copyright (c) 1984 AT&T

 *	  All Rights Reserved  	

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *  http://www.apache.org/licenses/LICENSE-2.0. 

 * 

 * Unless required by applicable law or agreed to in writing, software 

 * distributed under the License is distributed on an "AS IS" BASIS, 

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express 

 * or implied. 

 * See the License for the specific language governing permissions and

 * limitations under the License. 

 */

#include "apr.h"

#include "apr_lib.h"

#include "libsed.h"

#include "sed.h"

#include "apr_strings.h"

#include "regexp.h"

char    *trans[040]  = {

    "\\01",

    "\\02",

    "\\03",

    "\\04",

    "\\05",

    "\\06",

    "\\07",

    "\\10",

    "\\11",

    "\n",

    "\\13",

    "\\14",

    "\\15",

    "\\16",

    "\\17",

    "\\20",

    "\\21",

    "\\22",

    "\\23",

    "\\24",

    "\\25",

    "\\26",

    "\\27",

    "\\30",

    "\\31",

    "\\32",

    "\\33",

    "\\34",

    "\\35",

    "\\36",

    "\\37"

};

char rub[] = {"\\177"};

extern int sed_step(char *p1, char *p2, int circf, step_vars_storage *vars);

static int substitute(sed_eval_t *eval, sed_reptr_t *ipc,

                      step_vars_storage *step_vars);

static apr_status_t execute(sed_eval_t *eval);

static int match(sed_eval_t *eval, char *expbuf, int gf,

                 step_vars_storage *step_vars);

static apr_status_t dosub(sed_eval_t *eval, char *rhsbuf, int n,

                          step_vars_storage *step_vars);

static char *place(sed_eval_t *eval, char *asp, char *al1, char *al2);

static apr_status_t command(sed_eval_t *eval, sed_reptr_t *ipc,

                            step_vars_storage *step_vars);

static apr_status_t wline(sed_eval_t *eval, char *buf, int sz);

static apr_status_t arout(sed_eval_t *eval);

static void eval_errf(sed_eval_t *eval, const char *fmt, ...)

{

    if (eval->errfn && eval->pool) {

        va_list args;

        const char* error;

        va_start(args, fmt);

        error = apr_pvsprintf(eval->pool, fmt, args);

        eval->errfn(eval->data, error);

        va_end(args);

    }

}

#define INIT_BUF_SIZE 1024

/*

 * grow_buffer

 */

static void grow_buffer(apr_pool_t *pool, char **buffer,

                        char **spend, unsigned int *cursize,

                        unsigned int newsize)

{

    char* newbuffer = NULL;

    int spendsize = 0;

    if (*cursize >= newsize)

        return;

    /* Avoid number of times realloc is called. It could cause huge memory

     * requirement if line size is huge e.g 2 MB */

    if (newsize < *cursize * 2) {

        newsize = *cursize * 2;

    }

    /* Align it to 4 KB boundary */

    newsize = (newsize  + ((1 << 12) - 1)) & ~((1 << 12) -1);

    newbuffer = apr_pcalloc(pool, newsize);

    if (*spend && *buffer && (*cursize > 0)) {

        spendsize = *spend - *buffer;

    }

    if ((*cursize > 0) && *buffer) {

        memcpy(newbuffer, *buffer, *cursize);

    }

    *buffer = newbuffer;

    *cursize = newsize;

    if (spend != buffer) {

        *spend = *buffer + spendsize;

    }

}

/*

 * grow_line_buffer

 */

static void grow_line_buffer(sed_eval_t *eval, int newsize)

{

    grow_buffer(eval->pool, &eval->linebuf, &eval->lspend,

                &eval->lsize, newsize);

}

/*

 * grow_hold_buffer

 */

static void grow_hold_buffer(sed_eval_t *eval, int newsize)

{

    grow_buffer(eval->pool, &eval->holdbuf, &eval->hspend,

                &eval->hsize, newsize);

}

/*

 * grow_gen_buffer

 */

static void grow_gen_buffer(sed_eval_t *eval, int newsize,

                            char **gspend)

{

    if (gspend == NULL) {

        gspend = &eval->genbuf;

    }

    grow_buffer(eval->pool, &eval->genbuf, gspend,

                &eval->gsize, newsize);

    eval->lcomend = &eval->genbuf[71];

}

/*

 * appendmem_to_linebuf

 */

static void appendmem_to_linebuf(sed_eval_t *eval, const char* sz, int len)

{

    unsigned int reqsize = (eval->lspend - eval->linebuf) + len;

    if (eval->lsize < reqsize) {

        grow_line_buffer(eval, reqsize);

    }

    memcpy(eval->lspend, sz, len);

    eval->lspend += len;

}

/*

 * append_to_linebuf

 */

static void append_to_linebuf(sed_eval_t *eval, const char* sz)

{

    int len = strlen(sz);

    /* Copy string including null character */

    appendmem_to_linebuf(eval, sz, len + 1);

    --eval->lspend; /* lspend will now point to NULL character */

}

/*

 * copy_to_linebuf

 */

static void copy_to_linebuf(sed_eval_t *eval, const char* sz)

{

    eval->lspend = eval->linebuf;

    append_to_linebuf(eval, sz);

}

/*

 * append_to_holdbuf

 */

static void append_to_holdbuf(sed_eval_t *eval, const char* sz)

{

    int len = strlen(sz);

    unsigned int reqsize = (eval->hspend - eval->holdbuf) + len + 1;

    if (eval->hsize <= reqsize) {

        grow_hold_buffer(eval, reqsize);

    }

    strcpy(eval->hspend, sz);

    /* hspend will now point to NULL character */

    eval->hspend += len;

}

/*

 * copy_to_holdbuf

 */

static void copy_to_holdbuf(sed_eval_t *eval, const char* sz)

{

    eval->hspend = eval->holdbuf;

    append_to_holdbuf(eval, sz);

}

/*

 * append_to_genbuf

 */

static void append_to_genbuf(sed_eval_t *eval, const char* sz, char **gspend)

{

    int len = strlen(sz);

    unsigned int reqsize = (*gspend - eval->genbuf) + len + 1;

    if (eval->gsize < reqsize) {

        grow_gen_buffer(eval, reqsize, gspend);

    }

    strcpy(*gspend, sz);

    /* *gspend will now point to NULL character */

    *gspend += len;

}

/*

 * copy_to_genbuf

 */

static void copy_to_genbuf(sed_eval_t *eval, const char* sz)

{

    int len = strlen(sz);

    unsigned int reqsize = len + 1;

    if (eval->gsize < reqsize) {

        grow_gen_buffer(eval, reqsize, NULL);

    }

}

/*

 * sed_init_eval

 */

apr_status_t sed_init_eval(sed_eval_t *eval, sed_commands_t *commands, sed_err_fn_t *errfn, void *data, sed_write_fn_t *writefn, apr_pool_t* p)

{

    memset(eval, 0, sizeof(*eval));

    eval->pool = p;

    eval->writefn = writefn;

    return sed_reset_eval(eval, commands, errfn, data);

}

/*

 * sed_reset_eval

 */

apr_status_t sed_reset_eval(sed_eval_t *eval, sed_commands_t *commands, sed_err_fn_t *errfn, void *data)

{

    int i;

    eval->errfn = errfn;

    eval->data = data;

    eval->commands = commands;

    eval->lnum = 0;

    eval->fout = NULL;

    if (eval->linebuf == NULL) {

        eval->lsize = INIT_BUF_SIZE;

        eval->linebuf = apr_pcalloc(eval->pool, eval->lsize);

    }

    if (eval->holdbuf == NULL) {

        eval->hsize = INIT_BUF_SIZE;

        eval->holdbuf = apr_pcalloc(eval->pool, eval->hsize);

    }

    if (eval->genbuf == NULL) {

        eval->gsize = INIT_BUF_SIZE;

        eval->genbuf = apr_pcalloc(eval->pool, eval->gsize);

    }

    eval->lspend = eval->linebuf;

    eval->hspend = eval->holdbuf;

    eval->lcomend = &eval->genbuf[71];

    for (i = 0; i < sizeof(eval->abuf) / sizeof(eval->abuf[0]); i++)

        eval->abuf[i] = NULL;

    eval->aptr = eval->abuf;

    eval->pending = NULL;

    eval->inar = apr_pcalloc(eval->pool, commands->nrep * sizeof(unsigned char));

    eval->nrep = commands->nrep;

    eval->dolflag = 0;

    eval->sflag = 0;

    eval->jflag = 0;

    eval->delflag = 0;

    eval->lreadyflag = 0;

    eval->quitflag = 0;

    eval->finalflag = 1; /* assume we're evaluating only one file/stream */

    eval->numpass = 0;

    eval->nullmatch = 0;

    eval->col = 0;

    for (i = 0; i < commands->nfiles; i++) {

        const char* filename = commands->fname[i];

        if (apr_file_open(&eval->fcode[i], filename,

                          APR_WRITE | APR_CREATE, APR_OS_DEFAULT,

                          eval->pool) != APR_SUCCESS) {

            eval_errf(eval, SEDERR_COMES, filename);

            return APR_EGENERAL;

        }

    }

    return APR_SUCCESS;

}

/*

 * sed_destroy_eval

 */

void sed_destroy_eval(sed_eval_t *eval)

{

    int i;

    /* eval->linebuf, eval->holdbuf, eval->genbuf and eval->inar are allocated

     * on pool. It will be freed when pool will be freed */

    for (i = 0; i < eval->commands->nfiles; i++) {

        if (eval->fcode[i] != NULL) {

            apr_file_close(eval->fcode[i]);

            eval->fcode[i] = NULL;

        }

    }

}

/*

 * sed_eval_file

 */

apr_status_t sed_eval_file(sed_eval_t *eval, apr_file_t *fin, void *fout)

{

    for (;;) {

        char buf[1024];

        apr_size_t read_bytes = 0;

        read_bytes = sizeof(buf);

        if (apr_file_read(fin, buf, &read_bytes) != APR_SUCCESS)

            break;

        if (sed_eval_buffer(eval, buf, read_bytes, fout) != APR_SUCCESS)

            return APR_EGENERAL;

        if (eval->quitflag)

            return APR_SUCCESS;

    }

    return sed_finalize_eval(eval, fout);

}

/*

 * sed_eval_buffer

 */

apr_status_t sed_eval_buffer(sed_eval_t *eval, const char *buf, int bufsz, void *fout)

{

    apr_status_t rv;

    if (eval->quitflag)

        return APR_SUCCESS;

    if (!sed_canbe_finalized(eval->commands)) {

        /* Commands were not finalized properly. */

        const char* error = sed_get_finalize_error(eval->commands, eval->pool);

        if (error) {

            eval_errf(eval, error);

            return APR_EGENERAL;

        }

    }

    eval->fout = fout;

    /* Process leftovers */

    if (bufsz && eval->lreadyflag) {

        eval->lreadyflag = 0;

        eval->lspend--;

        *eval->lspend = '\0';

        rv = execute(eval);

        if (rv != APR_SUCCESS)

            return rv;

    }

    while (bufsz) {

        char *n;

        int llen;

        n = memchr(buf, '\n', bufsz);

        if (n == NULL)

            break;

        llen = n - buf;

        if (llen == bufsz - 1) {

            /* This might be the last line; delay its processing */

            eval->lreadyflag = 1;

            break;

        }

        appendmem_to_linebuf(eval, buf, llen + 1);

        --eval->lspend;

        /* replace new line character with NULL */

        *eval->lspend = '\0';

        buf += (llen + 1);

        bufsz -= (llen + 1);

        rv = execute(eval);

        if (rv != APR_SUCCESS)

            return rv;

        if (eval->quitflag)

            break;

    }

    /* Save the leftovers for later */

    if (bufsz) {

        appendmem_to_linebuf(eval, buf, bufsz);

    }

    return APR_SUCCESS;

}

/*

 * sed_finalize_eval

 */

apr_status_t sed_finalize_eval(sed_eval_t *eval, void *fout)

{

    if (eval->quitflag)

        return APR_SUCCESS;

    if (eval->finalflag)

        eval->dolflag = 1;

    eval->fout = fout;

    /* Process leftovers */

    if (eval->lspend > eval->linebuf) {

        apr_status_t rv;

        if (eval->lreadyflag) {

            eval->lreadyflag = 0;

            eval->lspend--;

        } else {

            /* Code can probably reach here when last character in output

             * buffer is not a newline.

             */

            /* Assure space for NULL */

            append_to_linebuf(eval, "");

        }

        *eval->lspend = '\0';

        rv = execute(eval);

        if (rv != APR_SUCCESS)

            return rv;

    }

    eval->quitflag = 1;

    return APR_SUCCESS;

}

/*

 * execute

 */

static apr_status_t execute(sed_eval_t *eval)

{

    sed_reptr_t *ipc = eval->commands->ptrspace;

    step_vars_storage step_vars;

    apr_status_t rv = APR_SUCCESS;

    eval->lnum++;

    eval->sflag = 0;

    if (eval->pending) {

        ipc = eval->pending;

        eval->pending = NULL;

    }

    memset(&step_vars, 0, sizeof(step_vars));

    while (ipc->command) {

        char *p1;

        char *p2;

        int c;

        p1 = ipc->ad1;

        p2 = ipc->ad2;

        if (p1) {

            if (eval->inar[ipc->nrep]) {

                if (*p2 == CEND) {

                    p1 = 0;

                } else if (*p2 == CLNUM) {

                    c = (unsigned char)p2[1];

                    if (eval->lnum > eval->commands->tlno[c]) {

                        eval->inar[ipc->nrep] = 0;

                        if (ipc->negfl)

                            goto yes;

                        ipc = ipc->next;

                        continue;

                    }

                    if (eval->lnum == eval->commands->tlno[c]) {

                        eval->inar[ipc->nrep] = 0;

                    }

                } else if (match(eval, p2, 0, &step_vars)) {

                    eval->inar[ipc->nrep] = 0;

                }

            } else if (*p1 == CEND) {

                if (!eval->dolflag) {

                    if (ipc->negfl)

                        goto yes;

                    ipc = ipc->next;

                    continue;

                }

            } else if (*p1 == CLNUM) {

                c = (unsigned char)p1[1];

                if (eval->lnum != eval->commands->tlno[c]) {

                    if (ipc->negfl)

                        goto yes;

                    ipc = ipc->next;

                    continue;

                }

                if (p2)

                    eval->inar[ipc->nrep] = 1;

            } else if (match(eval, p1, 0, &step_vars)) {

                if (p2)

                    eval->inar[ipc->nrep] = 1;

            } else {

                if (ipc->negfl)

                    goto yes;

                ipc = ipc->next;